[PATCH i-g-t v3 00/14] Test coverage for GPU debug support

[PATCH i-g-t v3 00/14] Test coverage for GPU debug support

[Christoph Manszewski]

Hi,

In this series the eudebug kernel and validation team would like to
add test coverage for GPU debug support recently proposed as an RFC.
(https://patchwork.freedesktop.org/series/136572/)

This series adds 'xe_eudebug' and 'xe_eudebug_online' tests together
with a library that encapsulates common paths in current and future
EU debugger scenarios. It also extends the 'xe_exec_sip' test and
'gpgpu_shader' library.

The aim of the 'xe_eudebug' test is to validate the eudebug resource
tracking and event delivery mechanism. The 'xe_eudebug_online' test is
dedicated for 'online' scenarios which means scenarios that exercise
hardware exception handling and thread state manipulation.

The xe_eudebug library provides an abstraction over debugger and debuggee
processes, asynchronous event reader, and event log buffers for post-mortem
analysis.

Latest kernel code can be found here:
https://gitlab.freedesktop.org/miku/kernel/-/commits/eudebug-dev

Thank you in advance for any comments and insight.

v2:
 - make sure to include all patches and verify that each individual
 patch compiles (Zbigniew)

v3:
 - fix multiple typos (Dominik Karol),
 - squash subtest and eudebug lib patches (Zbigniew),
 - include uapi sync/fix (Kamil)

Andrzej Hajda (4):
  lib/gpgpu_shader: Add write_on_exception template
  lib/gpgpu_shader: Add set/clear exception register (cr0.1) helpers
  lib/intel_batchbuffer: Add helper to get pointer at specified offset
  lib/gpgpu_shader: Allow enabling illegal opcode exceptions in shader

Christoph Manszewski (5):
  drm-uapi/xe: Sync with oa uapi fix
  lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter
  lib/gpgpu_shader: Extend shader building library
  tests/xe_exec_sip: Extend SIP interaction testing
  tests/xe_live_ktest: Add xe_eudebug live test

Dominik Grzegorzek (4):
  drm-uapi/xe: Sync with eudebug uapi
  lib/xe_eudebug: Introduce eu debug testing framework
  tests/xe_eudebug: Test eudebug resource tracking and manipulation
  tests/xe_eudebug_online: Debug client which runs workloads on EU

Gwan-gyeong Mun (1):
  lib/intel_batchbuffer: Add support for long-running mode execution

 include/drm-uapi/xe_drm.h         |  112 +-
 include/drm-uapi/xe_drm_eudebug.h |  225 +++
 lib/gpgpu_shader.c                |  474 ++++-
 lib/gpgpu_shader.h                |   29 +-
 lib/iga64_generated_codes.c       |  428 ++++-
 lib/intel_batchbuffer.c           |  153 +-
 lib/intel_batchbuffer.h           |   22 +
 lib/meson.build                   |    1 +
 lib/xe/xe_eudebug.c               | 2192 +++++++++++++++++++++++
 lib/xe/xe_eudebug.h               |  206 +++
 lib/xe/xe_ioctl.c                 |   20 +-
 lib/xe/xe_ioctl.h                 |    5 +
 tests/intel/xe_eudebug.c          | 2671 +++++++++++++++++++++++++++++
 tests/intel/xe_eudebug_online.c   | 2203 ++++++++++++++++++++++++
 tests/intel/xe_exec_sip.c         |  332 +++-
 tests/intel/xe_live_ktest.c       |    6 +
 tests/meson.build                 |    2 +
 17 files changed, 9036 insertions(+), 45 deletions(-)
 create mode 100644 include/drm-uapi/xe_drm_eudebug.h
 create mode 100644 lib/xe/xe_eudebug.c
 create mode 100644 lib/xe/xe_eudebug.h
 create mode 100644 tests/intel/xe_eudebug.c
 create mode 100644 tests/intel/xe_eudebug_online.c

-- 
2.34.1

[PATCH i-g-t v3 01/14] drm-uapi/xe: Sync with oa uapi fix

[Christoph Manszewski]

Align with kernel commit f2881dfdaaa9 ("drm/xe/oa/uapi: Make bit masks
unsigned"). Use built header instead of raw uapi header.

Cc: Jonathan Cavitt <jonathan.cavitt@intel.com>
Cc: Lucas De Marchi <lucas.demarchi@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 include/drm-uapi/xe_drm.h | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h
index 29425d7fd..f0a450db9 100644
--- a/include/drm-uapi/xe_drm.h
+++ b/include/drm-uapi/xe_drm.h
@@ -3,8 +3,8 @@
  * Copyright © 2023 Intel Corporation
  */
 
-#ifndef _UAPI_XE_DRM_H_
-#define _UAPI_XE_DRM_H_
+#ifndef _XE_DRM_H_
+#define _XE_DRM_H_
 
 #include "drm.h"
 
@@ -134,7 +134,7 @@ extern "C" {
  * redefine the interface more easily than an ever growing struct of
  * increasing complexity, and for large parts of that interface to be
  * entirely optional. The downside is more pointer chasing; chasing across
- * the __user boundary with pointers encapsulated inside u64.
+ * the boundary with pointers encapsulated inside u64.
  *
  * Example chaining:
  *
@@ -1598,10 +1598,10 @@ enum drm_xe_oa_property_id {
 	 * b. Counter select c. Counter size and d. BC report. Also refer to the
 	 * oa_formats array in drivers/gpu/drm/xe/xe_oa.c.
 	 */
-#define DRM_XE_OA_FORMAT_MASK_FMT_TYPE		(0xff << 0)
-#define DRM_XE_OA_FORMAT_MASK_COUNTER_SEL	(0xff << 8)
-#define DRM_XE_OA_FORMAT_MASK_COUNTER_SIZE	(0xff << 16)
-#define DRM_XE_OA_FORMAT_MASK_BC_REPORT		(0xff << 24)
+#define DRM_XE_OA_FORMAT_MASK_FMT_TYPE		(0xffu << 0)
+#define DRM_XE_OA_FORMAT_MASK_COUNTER_SEL	(0xffu << 8)
+#define DRM_XE_OA_FORMAT_MASK_COUNTER_SIZE	(0xffu << 16)
+#define DRM_XE_OA_FORMAT_MASK_BC_REPORT		(0xffu << 24)
 
 	/**
 	 * @DRM_XE_OA_PROPERTY_OA_PERIOD_EXPONENT: Requests periodic OA unit
@@ -1698,4 +1698,4 @@ struct drm_xe_oa_stream_info {
 }
 #endif
 
-#endif /* _UAPI_XE_DRM_H_ */
+#endif /* _XE_DRM_H_ */
-- 
2.34.1

[PATCH i-g-t v3 02/14] drm-uapi/xe: Sync with eudebug uapi

[Christoph Manszewski]

From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>

Align with kernel commit 09411c6ecbef ("drm/xe/eudebug: Add debug
metadata support for xe_eudebug") from:

https://gitlab.freedesktop.org/miku/kernel.git

which introduces most recent changes to the eudebug uapi.

Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 include/drm-uapi/xe_drm.h         |  96 ++++++++++++-
 include/drm-uapi/xe_drm_eudebug.h | 225 ++++++++++++++++++++++++++++++
 2 files changed, 319 insertions(+), 2 deletions(-)
 create mode 100644 include/drm-uapi/xe_drm_eudebug.h

diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h
index f0a450db9..01ffbb8cb 100644
--- a/include/drm-uapi/xe_drm.h
+++ b/include/drm-uapi/xe_drm.h
@@ -102,7 +102,9 @@ extern "C" {
 #define DRM_XE_EXEC			0x09
 #define DRM_XE_WAIT_USER_FENCE		0x0a
 #define DRM_XE_OBSERVATION		0x0b
-
+#define DRM_XE_EUDEBUG_CONNECT		0x0c
+#define DRM_XE_DEBUG_METADATA_CREATE	0x0d
+#define DRM_XE_DEBUG_METADATA_DESTROY	0x0e
 /* Must be kept compact -- no holes */
 
 #define DRM_IOCTL_XE_DEVICE_QUERY		DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEVICE_QUERY, struct drm_xe_device_query)
@@ -117,6 +119,9 @@ extern "C" {
 #define DRM_IOCTL_XE_EXEC			DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)
 #define DRM_IOCTL_XE_WAIT_USER_FENCE		DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)
 #define DRM_IOCTL_XE_OBSERVATION		DRM_IOW(DRM_COMMAND_BASE + DRM_XE_OBSERVATION, struct drm_xe_observation_param)
+#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)
 
 /**
  * DOC: Xe IOCTL Extensions
@@ -881,6 +886,23 @@ struct drm_xe_vm_destroy {
 	__u64 reserved[2];
 };
 
+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;
+};
+
 /**
  * struct drm_xe_vm_bind_op - run bind operations
  *
@@ -905,7 +927,9 @@ struct drm_xe_vm_destroy {
  *    handle MBZ, and the BO offset MBZ. This flag is intended to
  *    implement VK sparse bindings.
  */
+
 struct drm_xe_vm_bind_op {
+#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0
 	/** @extensions: Pointer to the first extension struct, if any */
 	__u64 extensions;
 
@@ -1108,7 +1132,8 @@ struct drm_xe_exec_queue_create {
 #define DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY		0
 #define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_PRIORITY		0
 #define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_TIMESLICE		1
-
+#define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG		2
+#define     DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE		(1 << 0)
 	/** @extensions: Pointer to the first extension struct, if any */
 	__u64 extensions;
 
@@ -1694,6 +1719,73 @@ struct drm_xe_oa_stream_info {
 	__u64 reserved[3];
 };
 
+/*
+ * Debugger ABI (ioctl and events) Version History:
+ * 0 - No debugger available
+ * 1 - Initial version
+ */
+#define DRM_XE_EUDEBUG_VERSION 1
+
+struct drm_xe_eudebug_connect {
+	/** @extensions: Pointer to the first extension struct, if any */
+	__u64 extensions;
+
+	__u64 pid; /* input: Target process ID */
+	__u32 flags; /* MBZ */
+
+	__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;
+};
+
+#include "xe_drm_eudebug.h"
+
 #if defined(__cplusplus)
 }
 #endif
diff --git a/include/drm-uapi/xe_drm_eudebug.h b/include/drm-uapi/xe_drm_eudebug.h
new file mode 100644
index 000000000..1db737080
--- /dev/null
+++ b/include/drm-uapi/xe_drm_eudebug.h
@@ -0,0 +1,225 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+
+#ifndef _XE_DRM_EUDEBUG_H_
+#define _XE_DRM_EUDEBUG_H_
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ * Do a eudebug event read for a debugger connection.
+ *
+ * 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)
+
+/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */
+struct drm_xe_eudebug_event {
+	__u32 len;
+
+	__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
+
+	__u16 flags;
+#define DRM_XE_EUDEBUG_EVENT_CREATE		(1 << 0)
+#define DRM_XE_EUDEBUG_EVENT_DESTROY		(1 << 1)
+#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE	(1 << 2)
+#define DRM_XE_EUDEBUG_EVENT_NEED_ACK		(1 << 3)
+
+	__u64 seqno;
+	__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;
+	__u32 width;
+	__u64 lrc_handle[];
+};
+
+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;
+	__u32 bitmask_size;
+	__u8 bitmask[];
+};
+
+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
+#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):
+ *
+ *  ┌───────────────────────┐
+ *  │  EVENT_VM_BIND        ├───────┬─┬─┐
+ *  └───────────────────────┘       │ │ │
+ *      ┌───────────────────────┐   │ │ │
+ *      │ EVENT_VM_BIND_OP #1   ├───┘ │ │
+ *      └───────────────────────┘     │ │
+ *                 ...                │ │
+ *      ┌───────────────────────┐     │ │
+ *      │ EVENT_VM_BIND_OP #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
+ * attach sync of type UFENCE into its vm_bind_ioctl().
+ *
+ * When EVENT_UFENCE is sent by the driver, all the OPs of
+ * the original VM_BIND are completed and the [addr,range]
+ * contained in them are present and modifiable through the
+ * vm accessors. Accessing [addr, range] before related ufence
+ * event will lead to undefined results as the actual bind
+ * operations are async and the backing storage might not
+ * be there on a moment of receiving the event.
+ *
+ * Client's UFENCE sync will be held by the driver: client's
+ * drm_xe_wait_ufence will not complete and the value of the ufence
+ * won't appear until ufence is acked by the debugger process calling
+ * DRM_XE_EUDEBUG_IOCTL_ACK_EVENT with the event_ufence.base.seqno.
+ * This will signal the fence, .value will update and the wait will
+ * complete allowing the client to continue.
+ *
+ */
+
+struct drm_xe_eudebug_event_vm_bind {
+	struct drm_xe_eudebug_event base;
+
+	__u64 client_handle;
+	__u64 vm_handle;
+
+	__u32 flags;
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0)
+
+	__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_ufence {
+	struct drm_xe_eudebug_event base;
+	__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
+};
+
+struct drm_xe_eudebug_ack_event {
+	__u32 type;
+	__u32 flags; /* MBZ */
+	__u64 seqno;
+};
+
+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;
+
+	/** @flags: flags */
+	__u64 flags;
+
+	/** @timeout_ns: Timeout value in nanoseconds operations (fsync) */
+	__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;
+};
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif
-- 
2.34.1

[PATCH i-g-t v3 03/14] lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter

[Christoph Manszewski]

Currently there is no way to set drm_xe_vm_bind_op extension field. Add
vm_bind wrapper that allows pass this field as a parameter.

Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Reviewed-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
---
 lib/xe/xe_ioctl.c | 20 ++++++++++++++++----
 lib/xe/xe_ioctl.h |  5 +++++
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/lib/xe/xe_ioctl.c b/lib/xe/xe_ioctl.c
index ae43ffd15..6d8388918 100644
--- a/lib/xe/xe_ioctl.c
+++ b/lib/xe/xe_ioctl.c
@@ -96,15 +96,17 @@ void xe_vm_bind_array(int fd, uint32_t vm, uint32_t exec_queue,
 	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_VM_BIND, &bind), 0);
 }
 
-int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
-		  uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
-		  uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
-		  uint32_t prefetch_region, uint8_t pat_index, uint64_t ext)
+int  ___xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
+		   uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
+		   uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
+		   uint32_t prefetch_region, uint8_t pat_index, uint64_t ext,
+		   uint64_t op_ext)
 {
 	struct drm_xe_vm_bind bind = {
 		.extensions = ext,
 		.vm_id = vm,
 		.num_binds = 1,
+		.bind.extensions = op_ext,
 		.bind.obj = bo,
 		.bind.obj_offset = offset,
 		.bind.range = size,
@@ -125,6 +127,16 @@ int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
 	return 0;
 }
 
+int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
+		  uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
+		  uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
+		  uint32_t prefetch_region, uint8_t pat_index, uint64_t ext)
+{
+	return ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size, op,
+			     flags, sync, num_syncs, prefetch_region,
+			     pat_index, ext, 0);
+}
+
 void  __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
 			  uint64_t offset, uint64_t addr, uint64_t size,
 			  uint32_t op, uint32_t flags, struct drm_xe_sync *sync,
diff --git a/lib/xe/xe_ioctl.h b/lib/xe/xe_ioctl.h
index b27c0053f..18cc2b72b 100644
--- a/lib/xe/xe_ioctl.h
+++ b/lib/xe/xe_ioctl.h
@@ -20,6 +20,11 @@
 uint32_t xe_cs_prefetch_size(int fd);
 uint64_t xe_bb_size(int fd, uint64_t reqsize);
 uint32_t xe_vm_create(int fd, uint32_t flags, uint64_t ext);
+int  ___xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
+		   uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
+		   uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
+		   uint32_t prefetch_region, uint8_t pat_index, uint64_t ext,
+		   uint64_t op_ext);
 int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
 		  uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
 		  uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
-- 
2.34.1

[PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Christoph Manszewski]

From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>

Introduce library which simplifies testing of eu debug capability.
The library provides event log helpers together with asynchronous
abstraction for client proccess and the debugger itself.

xe_eudebug_client creates its own proccess with user's work function,
and gives machanisms to synchronize beginning of execution and event
logging.

xe_eudebug_debugger allows to attach to the given proccess, provides
asynchronous thread for event reading and introduces triggers -
a callback mechanism triggered every time subscribed event was read.

Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
---
 lib/meson.build     |    1 +
 lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
 lib/xe/xe_eudebug.h |  206 ++++
 3 files changed, 2399 insertions(+)
 create mode 100644 lib/xe/xe_eudebug.c
 create mode 100644 lib/xe/xe_eudebug.h

diff --git a/lib/meson.build b/lib/meson.build
index f711e60a7..969ca4101 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -111,6 +111,7 @@ lib_sources = [
 	'igt_msm.c',
 	'igt_dsc.c',
 	'xe/xe_gt.c',
+	'xe/xe_eudebug.c',
 	'xe/xe_ioctl.c',
 	'xe/xe_mmio.c',
 	'xe/xe_query.c',
diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
new file mode 100644
index 000000000..4eac87476
--- /dev/null
+++ b/lib/xe/xe_eudebug.c
@@ -0,0 +1,2192 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+
+#include <fcntl.h>
+#include <poll.h>
+#include <signal.h>
+#include <sys/select.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include "igt.h"
+#include "igt_sysfs.h"
+#include "intel_pat.h"
+#include "xe_eudebug.h"
+#include "xe_ioctl.h"
+
+struct event_trigger {
+	xe_eudebug_trigger_fn fn;
+	int type;
+	struct igt_list_head link;
+};
+
+struct seqno_list_entry {
+	struct igt_list_head link;
+	uint64_t seqno;
+};
+
+struct match_dto {
+	struct drm_xe_eudebug_event *target;
+	struct igt_list_head *seqno_list;
+	uint64_t client_handle;
+	uint32_t filter;
+
+	/* store latest 'EVENT_VM_BIND' seqno */
+	uint64_t *bind_seqno;
+	/* latest vm_bind_op seqno matching bind_seqno */
+	uint64_t *bind_op_seqno;
+};
+
+#define CLIENT_PID  1
+#define CLIENT_RUN  2
+#define CLIENT_FINI 3
+#define CLIENT_STOP 4
+#define CLIENT_STAGE 5
+#define DEBUGGER_STAGE 6
+
+#define DEBUGGER_WORKER_INACTIVE  0
+#define DEBUGGER_WORKER_ACTIVE  1
+#define DEBUGGER_WORKER_QUITTING 2
+
+static const char *type_to_str(unsigned int type)
+{
+	switch (type) {
+	case DRM_XE_EUDEBUG_EVENT_NONE:
+		return "none";
+	case DRM_XE_EUDEBUG_EVENT_READ:
+		return "read";
+	case DRM_XE_EUDEBUG_EVENT_OPEN:
+		return "client";
+	case DRM_XE_EUDEBUG_EVENT_VM:
+		return "vm";
+	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
+		return "exec_queue";
+	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
+		return "attention";
+	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_UFENCE:
+		return "vm_bind_ufence";
+	case DRM_XE_EUDEBUG_EVENT_METADATA:
+		return "metadata";
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
+		return "vm_bind_op_metadata";
+	}
+
+	return "UNKNOWN";
+}
+
+static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
+{
+	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
+
+	return buf;
+}
+
+static const char *flags_to_str(unsigned int flags)
+{
+	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
+			return "create|ack";
+		else
+			return "create";
+	}
+	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
+		return "destroy";
+
+	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
+		return "state-change";
+
+	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
+
+	return "flags unknown";
+}
+
+static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
+{
+	switch (e->type) {
+	case DRM_XE_EUDEBUG_EVENT_OPEN: {
+		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
+
+		sprintf(b, "handle=%llu", ec->client_handle);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM: {
+		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
+
+		sprintf(b, "client_handle=%llu, handle=%llu",
+			evm->client_handle, evm->vm_handle);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
+		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
+
+		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
+			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
+			ee->client_handle, ee->vm_handle,
+			ee->exec_queue_handle, ee->engine_class, ee->width);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
+		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
+
+		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
+			   "lrc_handle=%llu, bitmask_size=%d",
+			ea->client_handle, ea->exec_queue_handle,
+			ea->lrc_handle, ea->bitmask_size);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
+		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
+
+		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
+			evmb->client_handle, 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 = (void *)e;
+
+		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
+			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
+		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
+
+		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_METADATA: {
+		struct drm_xe_eudebug_event_metadata *em = (void *)e;
+
+		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
+			em->client_handle, em->metadata_handle, em->type, em->len);
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
+
+		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
+			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
+		break;
+	}
+	default:
+		strcpy(b, "<...>");
+	}
+
+	return b;
+}
+
+/**
+ * xe_eudebug_event_to_str:
+ * @e: pointer to event
+ * @buf: target to write string representation of @e
+ * @len: size of target buffer @buf
+ *
+ * Creates string representation for given event.
+ *
+ * Returns: the written input buffer pointed by @buf.
+ */
+const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
+{
+	char a[256];
+	char b[256];
+
+	snprintf(buf, len, "(%llu) %15s:%s: %s",
+		 e->seqno,
+		 event_type_to_str(e, a),
+		 flags_to_str(e->flags),
+		 event_members_to_str(e, b));
+
+	return buf;
+}
+
+static void catch_child_failure(void)
+{
+	pid_t pid;
+	int status;
+
+	pid = waitpid(-1, &status, WNOHANG);
+
+	if (pid == 0 || pid == -1)
+		return;
+
+	if (!WIFEXITED(status))
+		return;
+
+	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
+}
+
+static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
+{
+	int ret;
+	int t = 0;
+	struct pollfd fd = {
+		.fd = pipe[0],
+		.events = POLLIN,
+		.revents = 0
+	};
+
+	/* When child fails we may get stuck forever. Check whether
+	 * the child process ended with an error.
+	 */
+	do {
+		const int interval_ms = 1000;
+
+		ret = poll(&fd, 1, interval_ms);
+
+		if (!ret) {
+			catch_child_failure();
+			t += interval_ms;
+		}
+	} while (!ret && t < timeout_ms);
+
+	if (ret > 0)
+		return read(pipe[0], buf, nbytes);
+
+	return 0;
+}
+
+static uint64_t pipe_read(int pipe[2], int timeout_ms)
+{
+	uint64_t in;
+	uint64_t ret;
+
+	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
+	igt_assert(ret == sizeof(in));
+
+	return in;
+}
+
+static void pipe_signal(int pipe[2], uint64_t token)
+{
+	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
+}
+
+static void pipe_close(int pipe[2])
+{
+	if (pipe[0] != -1)
+		close(pipe[0]);
+
+	if (pipe[1] != -1)
+		close(pipe[1]);
+}
+
+static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
+{
+	uint64_t in;
+
+	in = pipe_read(p, timeout_ms);
+
+	igt_assert_eq(in, token);
+
+	return pipe_read(p, timeout_ms);
+}
+
+static uint64_t client_wait_token(struct xe_eudebug_client *c,
+				 const uint64_t token)
+{
+	return __wait_token(c->p_in, token, c->timeout_ms);
+}
+
+static uint64_t wait_from_client(struct xe_eudebug_client *c,
+				 const uint64_t token)
+{
+	return __wait_token(c->p_out, token, c->timeout_ms);
+}
+
+static void token_signal(int p[2], const uint64_t token, const uint64_t value)
+{
+	pipe_signal(p, token);
+	pipe_signal(p, value);
+}
+
+static void client_signal(struct xe_eudebug_client *c,
+			  const uint64_t token,
+			  const uint64_t value)
+{
+	token_signal(c->p_out, token, value);
+}
+
+static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
+{
+	struct drm_xe_eudebug_connect param = {
+		.pid = pid,
+		.flags = flags,
+	};
+	int debugfd;
+
+	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
+
+	if (debugfd < 0)
+		return -errno;
+
+	return debugfd;
+}
+
+static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
+{
+	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
+		      sizeof(l->head));
+
+	igt_assert_eq(write(fd, l->log, l->head), l->head);
+}
+
+static void read_all(int fd, void *buf, size_t nbytes)
+{
+	ssize_t remaining_size = nbytes;
+	ssize_t current_size = 0;
+	ssize_t read_size = 0;
+
+	do {
+		read_size = read(fd, buf + current_size, remaining_size);
+		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
+
+		current_size += read_size;
+		remaining_size -= read_size;
+	} while (remaining_size > 0 && read_size > 0);
+
+	igt_assert_eq(current_size, nbytes);
+}
+
+static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
+{
+	read_all(fd, &l->head, sizeof(l->head));
+	igt_assert_lt(l->head, l->max_size);
+
+	read_all(fd, l->log, l->head);
+}
+
+typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
+
+static struct drm_xe_eudebug_event *
+event_cmp(struct xe_eudebug_event_log *l,
+	  struct drm_xe_eudebug_event *current,
+	  cmp_fn_t match,
+	  void *data)
+{
+	struct drm_xe_eudebug_event *e = current;
+
+	xe_eudebug_for_each_event(e, l) {
+		if (match(e, data))
+			return e;
+	}
+
+	return NULL;
+}
+
+static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
+{
+	struct drm_xe_eudebug_event *b = data;
+
+	if (a->type == b->type &&
+	    a->flags == b->flags)
+		return 1;
+
+	return 0;
+}
+
+static int match_fields(struct drm_xe_eudebug_event *a, void *data)
+{
+	struct drm_xe_eudebug_event *b = data;
+	int ret = 0;
+
+	ret = match_type_and_flags(a, data);
+	if (!ret)
+		return ret;
+
+	ret = 0;
+
+	switch (a->type) {
+	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
+		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
+		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
+
+		if (ae->engine_class == be->engine_class && ae->width == be->width)
+			ret = 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
+		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
+		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
+
+		if (ea->num_binds == eb->num_binds)
+			ret = 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
+		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
+		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
+
+		if (ea->addr == eb->addr && ea->range == eb->range &&
+		    ea->num_extensions == eb->num_extensions)
+			ret = 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
+		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
+
+		if (ea->metadata_handle == eb->metadata_handle &&
+		    ea->metadata_cookie == eb->metadata_cookie)
+			ret = 1;
+		break;
+	}
+
+	default:
+		ret = 1;
+		break;
+	}
+
+	return ret;
+}
+
+static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
+{
+	struct match_dto *md = (void *)data;
+	uint64_t *bind_seqno = md->bind_seqno;
+	uint64_t *bind_op_seqno = md->bind_op_seqno;
+	uint64_t h = md->client_handle;
+
+	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
+		return 0;
+
+	switch (e->type) {
+	case DRM_XE_EUDEBUG_EVENT_OPEN: {
+		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
+
+		if (client->client_handle == h)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM: {
+		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
+
+		if (vm->client_handle == h)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
+		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
+
+		if (ee->client_handle == h)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
+		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
+
+		if (evmb->client_handle == h) {
+			*bind_seqno = evmb->base.seqno;
+			return 1;
+		}
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
+		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
+
+		if (eo->vm_bind_ref_seqno == *bind_seqno) {
+			*bind_op_seqno = eo->base.seqno;
+			return 1;
+		}
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
+		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
+
+		if (ef->vm_bind_ref_seqno == *bind_seqno)
+			return 1;
+
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_METADATA: {
+		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
+
+		if (em->client_handle == h)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
+
+		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
+			return 1;
+		break;
+	}
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
+{
+
+	struct drm_xe_eudebug_event *d = (void *)data;
+	int ret;
+
+	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
+	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
+	ret = match_type_and_flags(e, data);
+	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
+
+	if (!ret)
+		return 0;
+
+	switch (e->type) {
+	case DRM_XE_EUDEBUG_EVENT_OPEN: {
+		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
+		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
+
+		if (client->client_handle == filter->client_handle)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM: {
+		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
+		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
+
+		if (vm->vm_handle == filter->vm_handle)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
+		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
+		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
+
+		if (ee->exec_queue_handle == filter->exec_queue_handle)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
+		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
+		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
+
+		if (evmb->vm_handle == filter->vm_handle &&
+		    evmb->num_binds == filter->num_binds)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
+		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
+		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
+
+		if (avmb->addr == filter->addr &&
+		    avmb->range == filter->range)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_METADATA: {
+		struct drm_xe_eudebug_event_metadata *em = (void *)e;
+		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
+
+		if (em->metadata_handle == filter->metadata_handle)
+			return 1;
+		break;
+	}
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
+		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
+
+		if (avmb->metadata_handle == filter->metadata_handle &&
+		    avmb->metadata_cookie == filter->metadata_cookie)
+			return 1;
+		break;
+	}
+
+	default:
+		break;
+	}
+	return 0;
+}
+
+static int match_full(struct drm_xe_eudebug_event *e, void *data)
+{
+	struct seqno_list_entry *sl;
+
+	struct match_dto *md = (void *)data;
+	int ret = 0;
+
+	ret = match_client_handle(e, md);
+	if (!ret)
+		return 0;
+
+	ret = match_fields(e, md->target);
+	if (!ret)
+		return 0;
+
+	igt_list_for_each_entry(sl, md->seqno_list, link) {
+		if (sl->seqno == e->seqno)
+			return 0;
+	}
+
+	return 1;
+}
+
+static struct drm_xe_eudebug_event *
+event_type_match(struct xe_eudebug_event_log *l,
+		 struct drm_xe_eudebug_event *target,
+		 struct drm_xe_eudebug_event *current)
+{
+	return event_cmp(l, current, match_type_and_flags, target);
+}
+
+static struct drm_xe_eudebug_event *
+client_match(struct xe_eudebug_event_log *l,
+	     uint64_t client_handle,
+	     struct drm_xe_eudebug_event *current,
+	     uint32_t filter,
+	     uint64_t *bind_seqno,
+	     uint64_t *bind_op_seqno)
+{
+	struct match_dto md = {
+		.client_handle = client_handle,
+		.filter = filter,
+		.bind_seqno = bind_seqno,
+		.bind_op_seqno = bind_op_seqno,
+	};
+
+	return event_cmp(l, current, match_client_handle, &md);
+}
+
+static struct drm_xe_eudebug_event *
+opposite_event_match(struct xe_eudebug_event_log *l,
+		    struct drm_xe_eudebug_event *target,
+		    struct drm_xe_eudebug_event *current)
+{
+	return event_cmp(l, current, match_opposite_resource, target);
+}
+
+static struct drm_xe_eudebug_event *
+event_match(struct xe_eudebug_event_log *l,
+	    struct drm_xe_eudebug_event *target,
+	    uint64_t client_handle,
+	    struct igt_list_head *seqno_list,
+	    uint64_t *bind_seqno,
+	    uint64_t *bind_op_seqno)
+{
+	struct match_dto md = {
+		.target = target,
+		.client_handle = client_handle,
+		.seqno_list = seqno_list,
+		.bind_seqno = bind_seqno,
+		.bind_op_seqno = bind_op_seqno,
+	};
+
+	return event_cmp(l, NULL, match_full, &md);
+}
+
+static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
+			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
+			   uint32_t filter)
+{
+	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
+	struct drm_xe_eudebug_event_client *de = (void *)_de;
+	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
+
+	struct igt_list_head matched_seqno_list;
+	struct drm_xe_eudebug_event *hc, *hd;
+	struct seqno_list_entry *entry, *tmp;
+
+	igt_assert(ce);
+	igt_assert(de);
+
+	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
+
+	hc = NULL;
+	hd = NULL;
+	IGT_INIT_LIST_HEAD(&matched_seqno_list);
+
+	do {
+		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
+		if (!hc)
+			break;
+
+		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
+
+		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
+			     c->name,
+			     hc->seqno,
+			     hc->type,
+			     ce->client_handle);
+
+		igt_debug("comparing %s %llu vs %s %llu\n",
+			  c->name, hc->seqno, d->name, hd->seqno);
+
+		/*
+		 * Store the seqno of the event that was matched above,
+		 * inside 'matched_seqno_list', to avoid it getting matched
+		 * by subsequent 'event_match' calls.
+		 */
+		entry = malloc(sizeof(*entry));
+		entry->seqno = hd->seqno;
+		igt_list_add(&entry->link, &matched_seqno_list);
+	} while (hc);
+
+	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
+		free(entry);
+}
+
+/**
+ * xe_eudebug_event_log_find_seqno:
+ * @l: event log pointer
+ * @seqno: seqno of event to be found
+ *
+ * Finds the event with given seqno in the event log.
+ *
+ * Returns: pointer to the event with given seqno within @l or NULL seqno is
+ * not present.
+ */
+struct drm_xe_eudebug_event *
+xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
+{
+	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
+
+	igt_assert_neq(seqno, 0);
+	/*
+	 * Try to catch if seqno is corrupted and prevent too long tests,
+	 * as our post processing of events is not optimized.
+	 */
+	igt_assert_lt(seqno, 10 * 1000 * 1000);
+
+	xe_eudebug_for_each_event(e, l) {
+		if (e->seqno == seqno) {
+			if (found) {
+				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
+				xe_eudebug_event_log_print(l, false);
+				igt_assert(!found);
+			}
+			found = e;
+		}
+	}
+
+	return found;
+}
+
+static void event_log_sort(struct xe_eudebug_event_log *l)
+{
+	struct xe_eudebug_event_log *tmp;
+	struct drm_xe_eudebug_event *e = NULL;
+	uint64_t first_seqno = 0;
+	uint64_t last_seqno = 0;
+	uint64_t events = 0, added = 0;
+	uint64_t i;
+
+	xe_eudebug_for_each_event(e, l) {
+		if (e->seqno > last_seqno)
+			last_seqno = e->seqno;
+
+		if (e->seqno < first_seqno)
+			first_seqno = e->seqno;
+
+		events++;
+	}
+
+	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
+
+	for (i = 1; i <= last_seqno; i++) {
+		e = xe_eudebug_event_log_find_seqno(l, i);
+		if (e) {
+			xe_eudebug_event_log_write(tmp, e);
+			added++;
+		}
+	}
+
+	igt_assert_eq(events, added);
+	igt_assert_eq(tmp->head, l->head);
+
+	memcpy(l->log, tmp->log, tmp->head);
+
+	xe_eudebug_event_log_destroy(tmp);
+}
+
+/**
+ * xe_eudebug_connect:
+ * @fd: Xe file descriptor
+ * @pid: client PID
+ * @flags: connection flags
+ *
+ * Opens the xe eu debugger connection to the process described by @pid
+ *
+ * Returns: 0 if the debugger was successfully attached, -errno otherwise.
+ */
+int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
+{
+	int ret;
+	uint64_t events = 0; /* events filtering not supported yet! */
+
+	ret = __xe_eudebug_connect(fd, pid, flags, events);
+
+	return ret;
+}
+
+/**
+ * xe_eudebug_event_log_create:
+ * @name: event log identifier
+ * @max_size: maximum size of created log
+ *
+ * Function creates an Eu Debugger event log with size equal to @max_size.
+ *
+ * Returns: pointer to just created log
+ */
+#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
+struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
+{
+	struct xe_eudebug_event_log *l;
+
+	l = calloc(1, sizeof(*l));
+	igt_assert(l);
+	l->log = calloc(1, max_size);
+	igt_assert(l->log);
+	l->max_size = max_size;
+	strncpy(l->name, name, sizeof(l->name) - 1);
+	pthread_mutex_init(&l->lock, NULL);
+
+	return l;
+}
+
+/**
+ * xe_eudebug_event_log_destroy:
+ * @l: event log pointer
+ *
+ * Frees given event log @l.
+ */
+void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
+{
+	pthread_mutex_destroy(&l->lock);
+	free(l->log);
+	free(l);
+}
+
+/**
+ * xe_eudebug_event_log_write:
+ * @l: event log pointer
+ * @e: event to be written to event log
+ *
+ * Writes event @e to the event log, thread-safe.
+ */
+void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
+{
+	igt_assert(e->seqno);
+	/*
+	 * Try to catch if seqno is corrupted and prevent too long tests,
+	 * as our post processing of events is not optimized.
+	 */
+	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
+
+	pthread_mutex_lock(&l->lock);
+	igt_assert_lt(l->head + e->len, l->max_size);
+	memcpy(l->log + l->head, e, e->len);
+	l->head += e->len;
+
+#ifdef DEBUG_LOG
+	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
+		 l->name, e->len, l->max_size - l->head);
+#endif
+	pthread_mutex_unlock(&l->lock);
+}
+
+/**
+ * xe_eudebug_event_log_print:
+ * @l: event log pointer
+ * @debug: when true function uses igt_debug instead of igt_info.
+ *
+ * Prints given event log.
+ */
+void
+xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
+{
+	struct drm_xe_eudebug_event *e = NULL;
+	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
+	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
+
+	igt_log(IGT_LOG_DOMAIN, level,
+		"event log '%s' (%u bytes):\n", l->name, l->head);
+
+	xe_eudebug_for_each_event(e, l) {
+		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
+		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
+	}
+}
+
+/**
+ * xe_eudebug_event_log_compare:
+ * @a: event log pointer
+ * @b: event log pointer
+ * @filter: mask that represents events to be skipped during comparison, useful
+ * for events like 'VM_BIND' since they can be asymmetric. Note that
+ * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
+ *
+ * Compares and asserts event logs @a, @b if the event
+ * sequence matches.
+ */
+void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
+				  uint32_t filter)
+{
+	struct drm_xe_eudebug_event *ae = NULL;
+	struct drm_xe_eudebug_event *be = NULL;
+
+	xe_eudebug_for_each_event(ae, a) {
+		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
+		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+			be = event_type_match(b, ae, be);
+
+			compare_client(a, ae, b, be, filter);
+			compare_client(b, be, a, ae, filter);
+		}
+	}
+}
+
+/**
+ * xe_eudebug_event_log_match_opposite:
+ * @l: event log pointer
+ * @filter: mask that represents events to be skipped during comparison, useful
+ * for events like 'VM_BIND' since they can be asymmetric
+ *
+ * Matches and asserts content of all opposite events (create vs destroy).
+ */
+void
+xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
+{
+	struct drm_xe_eudebug_event *ce = NULL;
+	struct drm_xe_eudebug_event *de = NULL;
+
+	xe_eudebug_for_each_event(ce, l) {
+		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
+			int opposite_matching;
+
+			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
+				continue;
+
+			/* No opposite matching for binds */
+			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
+			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
+			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
+				continue;
+
+			de = opposite_event_match(l, ce, ce);
+
+			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
+
+			igt_assert_eq(ce->len, de->len);
+			opposite_matching = memcmp((uint8_t *)de + offset,
+						   (uint8_t *)ce + offset,
+						   de->len - offset) == 0;
+
+			igt_assert_f(opposite_matching,
+				     "%s: create|destroy event not "
+				     "maching (%llu) vs (%llu)\n",
+				     l->name, de->seqno, ce->seqno);
+		}
+	}
+}
+
+static void debugger_run_triggers(struct xe_eudebug_debugger *d,
+				  struct drm_xe_eudebug_event *e)
+{
+	struct event_trigger *t;
+
+	igt_list_for_each_entry(t, &d->triggers, link) {
+		if (e->type == t->type)
+			t->fn(d, e);
+	}
+}
+
+#define MAX_EVENT_SIZE (32 * 1024)
+static int
+xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
+{
+	int ret;
+
+	event->type = DRM_XE_EUDEBUG_EVENT_READ;
+	event->flags = 0;
+	event->len = MAX_EVENT_SIZE;
+
+	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
+	if (ret < 0)
+		return -errno;
+
+	return ret;
+}
+
+static void *debugger_worker_loop(void *data)
+{
+	uint8_t buf[MAX_EVENT_SIZE];
+	struct drm_xe_eudebug_event *e = (void *)buf;
+	struct xe_eudebug_debugger *d = data;
+	struct pollfd p = {
+		.events = POLLIN,
+		.revents = 0,
+	};
+	int timeout_ms = 100, ret;
+
+	igt_assert(d->master_fd >= 0);
+
+	do {
+		p.fd = d->fd;
+		ret = poll(&p, 1, timeout_ms);
+
+		if (ret == -1) {
+			igt_info("poll failed with errno %d\n", errno);
+			break;
+		}
+
+		if (ret == 1 && (p.revents & POLLIN)) {
+			int err = xe_eudebug_read_event(d->fd, e);
+
+			if (!err) {
+				++d->event_count;
+
+				xe_eudebug_event_log_write(d->log, e);
+				debugger_run_triggers(d, e);
+			} else {
+				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;
+	return NULL;
+}
+
+/**
+ * xe_eudebug_debugger_available:
+ * @fd: Xe file descriptor
+ *
+ * Returns: true it debugger connection is available, false otherwise.
+ */
+bool xe_eudebug_debugger_available(int fd)
+{
+	struct drm_xe_eudebug_connect param = { .pid = getpid() };
+	int debugfd;
+
+	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
+	if (debugfd >= 0)
+		close(debugfd);
+
+	return debugfd >= 0;
+}
+
+/**
+ * xe_eudebug_debugger_create:
+ * @master_fd: xe client used to open the debugger connection
+ * @flags: flags stored in a debugger structure, can be used at will
+ * of the caller, i.e. to be used inside triggers.
+ * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
+ * can be shared between client and debugger. Can be NULL.
+ *
+ * Returns: newly created xe_eudebug_debugger structure with its
+ * event log initialized. Note that to open the connection
+ * you need call @xe_eudebug_debugger_attach.
+ */
+struct xe_eudebug_debugger *
+xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
+{
+	struct xe_eudebug_debugger *d;
+
+	d = calloc(1, sizeof(*d));
+	d->flags = flags;
+	igt_assert(d);
+	IGT_INIT_LIST_HEAD(&d->triggers);
+	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
+	d->fd = -1;
+	d->master_fd = master_fd;
+	d->ptr = data;
+
+	return d;
+}
+
+static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
+{
+	struct event_trigger *t, *tmp;
+
+	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
+		free(t);
+}
+
+/**
+ * xe_eudebug_debugger_destroy:
+ * @d: pointer to the debugger
+ *
+ * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
+ * connection was still opened it terminates it.
+ */
+void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
+{
+	if (d->worker_state)
+		xe_eudebug_debugger_stop_worker(d, 1);
+
+	if (d->target_pid)
+		xe_eudebug_debugger_dettach(d);
+
+	xe_eudebug_event_log_destroy(d->log);
+	debugger_destroy_triggers(d);
+	free(d);
+}
+
+/**
+ * xe_eudebug_debugger_attach:
+ * @d: pointer to the debugger
+ * @c: pointer to the client
+ *
+ * Opens the xe eu debugger connection to the process described by @c (c->pid)
+ *
+ * Returns: 0 if the debugger was successfully attached, -errno otherwise.
+ */
+int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
+			       struct xe_eudebug_client *c)
+{
+	int ret;
+
+	igt_assert_eq(d->fd, -1);
+	igt_assert_neq(c->pid, 0);
+	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
+
+	if (ret < 0)
+		return ret;
+
+	d->fd = ret;
+	d->target_pid = c->pid;
+	d->p_client[0] = c->p_in[0];
+	d->p_client[1] = c->p_in[1];
+
+	igt_debug("debugger connected to %lu\n", d->target_pid);
+
+	return 0;
+}
+
+/**
+ * xe_eudebug_debugger_dettach:
+ * @d: pointer to the debugger
+ *
+ * Closes previously opened xe eu debugger connection. Asserts if
+ * the debugger has active session.
+ */
+void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
+{
+	igt_assert(d->target_pid);
+	close(d->fd);
+	d->target_pid = 0;
+	d->fd = -1;
+}
+
+/**
+ * xe_eudebug_debugger_add_trigger:
+ * @d: pointer to the debugger
+ * @type: the type of the event which activates the trigger
+ * @fn: function to be called when event of @type was read by the debugger.
+ *
+ * Adds function @fn to the list of triggers activated when event of @type
+ * has been read by worker.
+ * Note: Triggers are activated by the worker.
+ */
+void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
+				     int type, xe_eudebug_trigger_fn fn)
+{
+	struct event_trigger *t;
+
+	t = calloc(1, sizeof(*t));
+	IGT_INIT_LIST_HEAD(&t->link);
+	t->type = type;
+	t->fn = fn;
+
+	igt_list_add_tail(&t->link, &d->triggers);
+	igt_debug("added trigger %p\n", t);
+}
+
+/**
+ * xe_eudebug_debugger_start_worker:
+ * @d: pointer to the debugger
+ *
+ * Starts the debugger worker. Worker is resposible for reading all
+ * incoming events from the debugger, put then into debugger log and
+ * execute appropriate event triggers. Note that using the debuggers
+ * event log while worker is running is not safe.
+ */
+void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
+{
+	int ret;
+
+	d->worker_state = true;
+	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
+
+	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
+}
+
+/**
+ * xe_eudebug_debugger_stop_worker:
+ * @d: pointer to the debugger
+ *
+ * Stops the debugger worker. Event log is sorted by seqno after closure.
+ */
+void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
+				     int timeout_s)
+{
+	struct timespec t = {};
+	int ret;
+
+	igt_assert(d->worker_state);
+
+	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
+	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
+	t.tv_sec += timeout_s;
+
+	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_assert_f(ret == 0 || ret != ESRCH,
+		     "pthread join failed with error %d!\n", ret);
+
+	event_log_sort(d->log);
+}
+
+/**
+ * xe_eudebug_debugger_signal_stage:
+ * @d: pointer to the debugger
+ * @stage: stage to signal
+ *
+ * Signals to client, waiting in xe_eudebug_client_wait_stage(),
+ * releasing it to proceed.
+ */
+void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
+{
+	token_signal(d->p_client, CLIENT_STAGE, stage);
+}
+
+/**
+ * xe_eudebug_debugger_wait_stage:
+ * @s: pointer to xe_eudebug_debugger structure
+ * @stage: stage to wait on
+ *
+ * Pauses debugger until the client has signalled the corresponding stage with
+ * xe_eudebug_client_signal_stage. This is only for situations where the actual
+ * event flow is not enough to coordinate between client/debugger and extra sync
+ * mechanism is needed.
+ */
+void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
+{
+	u64 stage_in;
+
+	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
+
+	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
+	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
+		  stage_in, stage);
+
+	igt_assert_eq(stage_in, stage);
+}
+
+/**
+ * xe_eudebug_client_create:
+ * @master_fd: xe client used to open the debugger connection
+ * @work: function that opens xe device and executes arbitrary workload
+ * @flags: flags stored in a client structure, can be used at will
+ * of the caller, i.e. to provide the @work function an additional switch.
+ * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
+ * can be shared between client and debugger. Accesible via client->ptr.
+ * Can be NULL.
+ *
+ * Forks and creates the debugger process. @work won't be called until
+ * xe_eudebug_client_start is called.
+ *
+ * Returns: newly created xe_eudebug_debugger structure with its
+ * event log initialized.
+ */
+struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
+						   uint64_t flags, void *data)
+{
+	struct xe_eudebug_client *c;
+
+	c = calloc(1, sizeof(*c));
+	c->flags = flags;
+	igt_assert(c);
+	igt_assert(!pipe(c->p_in));
+	igt_assert(!pipe(c->p_out));
+	c->seqno = 1;
+	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
+	c->done = 0;
+	c->ptr = data;
+	c->master_fd = master_fd;
+	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
+
+	igt_fork(child, 1) {
+		int mypid;
+
+		igt_assert_eq(c->pid, 0);
+
+		close(c->p_out[0]);
+		c->p_out[0] = -1;
+		close(c->p_in[1]);
+		c->p_in[1] = -1;
+
+		mypid = getpid();
+		client_signal(c, CLIENT_PID, mypid);
+
+		c->pid = client_wait_token(c, CLIENT_RUN);
+		igt_assert_eq(c->pid, mypid);
+		if (work)
+			work(c);
+
+		client_signal(c, CLIENT_FINI, c->seqno);
+
+		event_log_write_to_fd(c->log, c->p_out[1]);
+
+		c->pid = client_wait_token(c, CLIENT_STOP);
+		igt_assert_eq(c->pid, mypid);
+	}
+
+	close(c->p_out[1]);
+	c->p_out[1] = -1;
+	close(c->p_in[0]);
+	c->p_in[0] = -1;
+
+	c->pid = wait_from_client(c, CLIENT_PID);
+
+	igt_info("client running with pid %d\n", c->pid);
+
+	return c;
+}
+
+/**
+ * xe_eudebug_client_stop:
+ * @c: pointer to xe_eudebug_client structure
+ *
+ * Waits for the end of client's work and exits the proccess.
+ */
+void xe_eudebug_client_stop(struct xe_eudebug_client *c)
+{
+	if (c->pid) {
+		int waitstatus;
+
+		xe_eudebug_client_wait_done(c);
+
+		token_signal(c->p_in, CLIENT_STOP, c->pid);
+		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
+			      c->pid);
+		c->pid = 0;
+	}
+}
+
+/**
+ * xe_eudebug_client_destroy:
+ * @c: pointer to xe_eudebug_client structure to be freed
+ *
+ * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
+ * client proccess has not terminated yet.
+ */
+void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
+{
+	xe_eudebug_client_stop(c);
+	pipe_close(c->p_in);
+	pipe_close(c->p_out);
+	xe_eudebug_event_log_destroy(c->log);
+	free(c);
+}
+
+/**
+ * xe_eudebug_client_get_seqno:
+ * @c: pointer to xe_eudebug_client structure
+ *
+ * Increments and returns current seqno value of the given client @c
+ *
+ * Returns: incremented seqno
+ */
+uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
+{
+	return c->seqno++;
+}
+
+/**
+ * xe_eudebug_client_start:
+ * @c: pointer to xe_eudebug_client structure
+ *
+ * Starts execution of client's work function within the client's proccess.
+ */
+void xe_eudebug_client_start(struct xe_eudebug_client *c)
+{
+	token_signal(c->p_in, CLIENT_RUN, c->pid);
+}
+
+/**
+ * xe_eudebug_client_wait_done:
+ * @c: pointer to xe_eudebug_client structure
+ *
+ * Waits for the client work end updates the event log.
+ * Doesn't terminate the client's proccess yet.
+ */
+void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
+{
+	if (!c->done) {
+		c->done = 1;
+		c->seqno = wait_from_client(c, CLIENT_FINI);
+		event_log_read_from_fd(c->log, c->p_out[0]);
+	}
+}
+
+/**
+ * xe_eudebug_client_signal_stage:
+ * @c: pointer to the client
+ * @stage: stage to signal
+ *
+ * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
+ * releasing it to proceed.
+ */
+void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
+{
+	token_signal(c->p_out, DEBUGGER_STAGE, stage);
+}
+
+/**
+ * xe_eudebug_client_wait_stage:
+ * @c: pointer to xe_eudebug_client structure
+ * @stage: stage to wait on
+ *
+ * Pauses client until the debugger has signalled the corresponding stage with
+ * xe_eudebug_debugger_signal_stage. This is only for situations where the
+ * actual event flow is not enough to coordinate between client/debugger and extra
+ * sync mechanism is needed.
+ *
+ */
+void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
+{
+	u64 stage_in;
+
+	if (c->done) {
+		igt_warn("client: %d already done before %lu\n", c->pid, stage);
+		return;
+	}
+
+	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
+
+	stage_in = client_wait_token(c, CLIENT_STAGE);
+	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
+
+	igt_assert_eq(stage_in, stage);
+}
+
+
+/**
+ * xe_eudebug_session_create:
+ * @fd: XE file descriptor
+ * @work: function passed to the xe_eudebug_client_create
+ * @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.
+ *
+ * Creates session together with client and debugger structures.
+ */
+struct xe_eudebug_session *xe_eudebug_session_create(int fd,
+						     xe_eudebug_client_work_fn work,
+						     unsigned int flags,
+						     void *test_private)
+{
+	struct xe_eudebug_session *s;
+
+	s = calloc(1, sizeof(*s));
+	igt_assert(s);
+
+	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
+	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
+	s->flags = flags;
+
+	return s;
+}
+
+/**
+ * xe_eudebug_session_run:
+ * @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.
+ */
+void xe_eudebug_session_run(struct xe_eudebug_session *s)
+{
+	struct xe_eudebug_debugger *debugger = s->d;
+	struct xe_eudebug_client *client = s->c;
+
+	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
+
+	xe_eudebug_debugger_start_worker(debugger);
+
+	xe_eudebug_client_start(client);
+	xe_eudebug_client_wait_done(client);
+
+	xe_eudebug_debugger_stop_worker(debugger, 1);
+
+	xe_eudebug_event_log_print(debugger->log, true);
+	xe_eudebug_event_log_print(client->log, true);
+}
+
+/**
+ * xe_eudebug_session_check:
+ * @s: pointer to xe_eudebug_session structure
+ * @match_opposite: indicates whether check should match all
+ * create and destroy events.
+ * @filter: mask that represents events to be skipped during comparison, useful
+ * for events like 'VM_BIND' since they can be asymmetric
+ *
+ * Validate debugger's log against the log created by the client.
+ */
+void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
+{
+	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
+
+	if (match_opposite)
+		xe_eudebug_event_log_match_opposite(s->d->log, filter);
+}
+
+/**
+ * xe_eudebug_session_destroy:
+ * @s: pointer to xe_eudebug_session structure
+ *
+ * Destroy session together with its debugger and client.
+ */
+void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
+{
+	xe_eudebug_debugger_destroy(s->d);
+	xe_eudebug_client_destroy(s->c);
+
+	free(s);
+}
+
+#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
+
+static void base_event(struct xe_eudebug_client *c,
+		       struct drm_xe_eudebug_event *e,
+		       uint32_t type,
+		       uint32_t flags,
+		       uint64_t size)
+{
+	e->type = type;
+	e->flags = flags;
+	e->seqno = xe_eudebug_client_get_seqno(c);
+	e->len = size;
+}
+
+static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
+{
+	struct drm_xe_eudebug_event_client ec;
+
+	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
+
+	ec.client_handle = client_fd;
+
+	xe_eudebug_event_log_write(c->log, (void *)&ec);
+}
+
+static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
+{
+	struct drm_xe_eudebug_event_vm evm;
+
+	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
+
+	evm.client_handle = client_fd;
+	evm.vm_handle = vm_id;
+
+	xe_eudebug_event_log_write(c->log, (void *)&evm);
+}
+
+static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
+			     int client_fd, uint32_t vm_id,
+			     uint32_t exec_queue_handle, uint16_t class,
+			     uint16_t width)
+{
+	struct drm_xe_eudebug_event_exec_queue ee;
+
+	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
+		   flags, sizeof(ee));
+
+	ee.client_handle = client_fd;
+	ee.vm_handle = vm_id;
+	ee.exec_queue_handle = exec_queue_handle;
+	ee.engine_class = class;
+	ee.width = width;
+
+	xe_eudebug_event_log_write(c->log, (void *)&ee);
+}
+
+static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
+			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
+{
+	struct drm_xe_eudebug_event_metadata em;
+
+	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
+		   flags, sizeof(em));
+
+	em.client_handle = client_fd;
+	em.metadata_handle = id;
+	em.type = type;
+	em.len = len;
+
+	xe_eudebug_event_log_write(c->log, (void *)&em);
+}
+
+static int enable_getset(int fd, bool *old, bool *new)
+{
+	static const char * const fname = "enable_eudebug";
+	int ret = 0;
+
+	int sysfs, device_fd;
+	bool val_before;
+	struct stat st;
+
+	igt_assert(new || old);
+
+	igt_assert_eq(fstat(fd, &st), 0);
+	sysfs = igt_sysfs_open(fd);
+	if (sysfs < 0)
+		return -1;
+
+	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
+	close(sysfs);
+	if (device_fd < 0)
+		return -1;
+
+	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
+		ret = -1;
+		goto out;
+	}
+
+	igt_debug("enable_eudebug before: %d\n", val_before);
+
+	if (old)
+		*old = val_before;
+
+	ret = 0;
+	if (new) {
+		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
+			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
+		else
+			ret = -1;
+	}
+
+out:
+	close(device_fd);
+	return ret;
+}
+
+/**
+ * xe_eudebug_enable
+ * @fd: xe client
+ * @enable: state toggle - true to enable, false to disable
+ *
+ * Enables/disables eudebug capability by writing to
+ * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
+ *
+ * Returns: previous toggle value, i.e. true when eudebugging was enabled,
+ * false when eudebugging was disabled.
+ */
+bool xe_eudebug_enable(int fd, bool enable)
+{
+	bool old = false;
+	int ret = enable_getset(fd, &old, &enable);
+
+	if (ret) {
+		igt_skip_on(enable);
+		old = false;
+	}
+
+	return old;
+}
+
+/* Eu debugger wrappers around resource creating xe ioctls. */
+
+/**
+ * xe_eudebug_client_open_driver:
+ * @c: pointer to xe_eudebug_client structure
+ *
+ * Calls drm_open_client(DRIVER_XE) and logs the corresponding
+ * event in client's event log.
+ *
+ * Returns: valid DRM file descriptor
+ */
+int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
+{
+	int fd;
+
+	fd = drm_reopen_driver(c->master_fd);
+	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
+
+	return fd;
+}
+
+/**
+ * xe_eudebug_client_close_driver:
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ *
+ * Calls close driver and logs the corresponding event in
+ * client's event log.
+ */
+void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
+{
+	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
+	close(fd);
+}
+
+/**
+ * xe_eudebug_client_vm_create:
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @flags: vm bind flags
+ * @ext: pointer to the first user extension
+ *
+ * Calls xe_vm_create() and logs corresponding events
+ * (including vm set metadata events) in client's event log.
+ *
+ * Returns: valid vm handle
+ */
+uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
+				     uint32_t flags, uint64_t ext)
+{
+	uint32_t vm;
+
+	vm = xe_vm_create(fd, flags, ext);
+	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
+
+	return vm;
+}
+
+/**
+ * xe_eudebug_client_vm_destroy:
+ * @c: pointer to xe_eudebug_client structure
+ * fd: xe client
+ * vm: vm handle
+ *
+ * Calls xe_vm_destroy() and logs the corresponding event in
+ * client's event log.
+ */
+void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
+{
+	xe_vm_destroy(fd, vm);
+	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
+}
+
+/**
+ * xe_eudebug_client_exec_queue_create:
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @create: exec_queue create drm struct
+ *
+ * Calls xe exec queue create ioctl and logs the corresponding event in
+ * client's event log.
+ *
+ * Returns: valid exec queue handle
+ */
+uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
+					     struct drm_xe_exec_queue_create *create)
+{
+	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
+
+	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
+		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
+				 create->exec_queue_id, class, create->width);
+
+	return create->exec_queue_id;
+}
+
+/**
+ * xe_eudebug_client_exec_queue_destroy:
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @create: exec_queue create drm struct which was used for creation
+ *
+ * Calls xe exec_queue destroy ioctl and logs the corresponding event in
+ * client's event log.
+ */
+void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
+					  struct drm_xe_exec_queue_create *create)
+{
+	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
+	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
+
+	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
+		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
+				 create->exec_queue_id, class, create->width);
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
+}
+
+/**
+ * xe_eudebug_client_vm_bind_event:
+ * @c: pointer to xe_eudebug_client structure
+ * @event_flags: base event flags
+ * @fd: xe client
+ * @vm: vm handle
+ * @bind_flags: bind flags of vm_bind_event
+ * @num_binds: 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, int fd,
+				     uint32_t vm, uint32_t bind_flags,
+				     uint32_t num_binds, u64 *ref_seqno)
+{
+	struct drm_xe_eudebug_event_vm_bind evmb;
+
+	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
+		   event_flags, sizeof(evmb));
+	evmb.client_handle = fd;
+	evmb.vm_handle = vm;
+	evmb.flags = bind_flags;
+	evmb.num_binds = num_binds;
+
+	*ref_seqno = evmb.base.seqno;
+
+	xe_eudebug_event_log_write(c->log, (void *)&evmb);
+}
+
+/**
+ * xe_eudebug_client_vm_bind_op_event:
+ * @c: pointer to xe_eudebug_client structure
+ * @event_flags: base event flags
+ * @bind_ref_seqno: base vm bind reference seqno
+ * @op_ref_seqno: output, the vm_bind_op event seqno
+ * @addr: ppgtt address
+ * @size: size of the binding
+ * @num_extensions: number of vm bind op extensions
+ *
+ * Logs vm bind op event in client's event log.
+ */
+void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
+					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
+					uint64_t addr, uint64_t range,
+					uint64_t num_extensions)
+{
+	struct drm_xe_eudebug_event_vm_bind_op op;
+
+	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
+		   event_flags, sizeof(op));
+	op.vm_bind_ref_seqno = bind_ref_seqno;
+	op.addr = addr;
+	op.range = range;
+	op.num_extensions = num_extensions;
+
+	*op_ref_seqno = op.base.seqno;
+
+	xe_eudebug_event_log_write(c->log, (void *)&op);
+}
+
+/**
+ * xe_eudebug_client_vm_bind_op_metadata_event:
+ * @c: pointer to xe_eudebug_client structure
+ * @event_flags: base event flags
+ * @op_ref_seqno: base vm bind op reference seqno
+ * @metadata_handle: metadata handle
+ * @metadata_cookie: metadata cookie
+ *
+ * Logs vm bind op metadata event in client's event log.
+ */
+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)
+{
+	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
+
+	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
+		   event_flags, sizeof(op));
+	op.vm_bind_op_ref_seqno = op_ref_seqno;
+	op.metadata_handle = metadata_handle;
+	op.metadata_cookie = metadata_cookie;
+
+	xe_eudebug_event_log_write(c->log, (void *)&op);
+}
+
+/**
+ * xe_eudebug_client_vm_bind_ufence_event:
+ * @c: pointer to xe_eudebug_client structure
+ * @event_flags: base event flags
+ * @ref_seqno: base vm bind event seqno
+ *
+ * Logs vm bind ufence event in client's event log.
+ */
+void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
+					    uint64_t ref_seqno)
+{
+	struct drm_xe_eudebug_event_vm_bind_ufence f;
+
+	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+		   event_flags, sizeof(f));
+	f.vm_bind_ref_seqno = ref_seqno;
+
+	xe_eudebug_event_log_write(c->log, (void *)&f);
+}
+
+static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
+{
+	while (num_syncs--)
+		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
+			return true;
+
+	return false;
+}
+
+#define for_each_metadata(__m, __ext)					\
+	for ((__m) = from_user_pointer(__ext);				\
+	     (__m);							\
+	     (__m) = from_user_pointer((__m)->base.next_extension))	\
+		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
+
+static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
+					int fd, uint32_t vm, uint32_t exec_queue,
+					uint32_t bo, uint64_t offset,
+					uint64_t addr, uint64_t size,
+					uint32_t op, uint32_t flags,
+					struct drm_xe_sync *sync,
+					uint32_t num_syncs,
+					uint32_t prefetch_region,
+					uint8_t pat_index, uint64_t op_ext)
+{
+	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
+	const bool ufence = has_user_fence(sync, num_syncs);
+	const uint32_t bind_flags = ufence ?
+		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
+	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
+	uint32_t bind_base_flags = 0;
+	int ret;
+
+	for_each_metadata(metadata, op_ext)
+		num_metadata++;
+
+	switch (op) {
+	case DRM_XE_VM_BIND_OP_MAP:
+		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
+		break;
+	case DRM_XE_VM_BIND_OP_UNMAP:
+		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
+		igt_assert_eq(num_metadata, 0);
+		igt_assert_eq(ufence, false);
+		break;
+	default:
+		/* XXX unmap all? */
+		igt_assert(op);
+		break;
+	}
+
+	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
+			    op, flags, sync, num_syncs, prefetch_region,
+			    pat_index, 0, op_ext);
+
+	if (ret)
+		return ret;
+
+	if (!bind_base_flags)
+		return -EINVAL;
+
+	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
+					fd, vm, bind_flags, 1, &seqno);
+	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
+					   seqno, &op_seqno, addr, size,
+					   num_metadata);
+
+	for_each_metadata(metadata, op_ext)
+		xe_eudebug_client_vm_bind_op_metadata_event(c,
+							    DRM_XE_EUDEBUG_EVENT_CREATE,
+							    op_seqno,
+							    metadata->metadata_id,
+							    metadata->cookie);
+	if (ufence)
+		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
+						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
+						       seqno);
+	return ret;
+}
+
+static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
+				       uint32_t vm, uint32_t bo,
+				       uint64_t offset, uint64_t addr, uint64_t size,
+				       uint32_t op,
+				       uint32_t flags,
+				       struct drm_xe_sync *sync,
+				       uint32_t num_syncs,
+				       uint64_t op_ext)
+{
+	const uint32_t exec_queue_id = 0;
+	const uint32_t prefetch_region = 0;
+
+	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
+						  addr, size, op, flags,
+						  sync, num_syncs, prefetch_region,
+						  DEFAULT_PAT_INDEX, op_ext),
+		      0);
+}
+
+/**
+ * xe_eudebug_client_vm_bind_flags
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @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, int fd, 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)
+{
+	_xe_eudebug_client_vm_bind(c, fd, 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
+ * @fd: xe client
+ * @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, int fd, 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, fd, vm, bo, offset, addr, size,
+					flags,
+					sync, num_syncs, op_ext);
+}
+
+/**
+ * xe_eudebug_client_vm_unbind_flags
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @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, int fd,
+				       uint32_t vm, uint64_t offset,
+				       uint64_t addr, uint64_t size, uint32_t flags,
+				       struct drm_xe_sync *sync, uint32_t num_syncs)
+{
+	_xe_eudebug_client_vm_bind(c, fd, 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
+ * @fd: xe client
+ * @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, int fd, 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, fd, vm, offset, addr, size,
+					  flags, sync, num_syncs);
+}
+
+/**
+ * xe_eudebug_client_metadata_create:
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @type: debug metadata type
+ * @len: size of @data
+ * @data: debug metadata paylad
+ *
+ * Calls xe metadata create ioctl and logs the corresponding event in
+ * client's event log.
+ *
+ * Return: valid debug metadata id.
+ */
+uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
+					   int type, size_t len, void *data)
+{
+	struct drm_xe_debug_metadata_create create = {
+		.type = type,
+		.user_addr = to_user_pointer(data),
+		.len = len
+	};
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
+
+	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
+
+	return create.metadata_id;
+}
+
+/**
+ * xe_eudebug_client_metadata_destroy:
+ * @c: pointer to xe_eudebug_client structure
+ * @fd: xe client
+ * @id: xe debug metadata handle
+ * @type: debug metadata type
+ * @len: size of debug metadata payload
+ *
+ * Calls xe metadata destroy ioctl and logs the corresponding event in
+ * client's event log.
+ */
+void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
+					uint32_t id, int type, size_t len)
+{
+	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
+
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
+
+	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
+}
+
+void xe_eudebug_ack_ufence(int debugfd,
+			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
+{
+	struct drm_xe_eudebug_ack_event ack = { 0, };
+	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
+
+	ack.type = f->base.type;
+	ack.seqno = f->base.seqno;
+
+	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
+	igt_debug("delivering ack for event: %s\n", event_str);
+	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
+}
diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
new file mode 100644
index 000000000..444f5a7b7
--- /dev/null
+++ b/lib/xe/xe_eudebug.h
@@ -0,0 +1,206 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+#include <fcntl.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <xe_drm.h>
+
+#include "igt_list.h"
+
+struct xe_eudebug_event_log {
+	uint8_t *log;
+	unsigned int head;
+	unsigned int max_size;
+	char name[80];
+	pthread_mutex_t lock;
+};
+
+struct xe_eudebug_debugger {
+	int fd;
+	uint64_t flags;
+
+	/* Used to smuggle private data */
+	void *ptr;
+
+	struct xe_eudebug_event_log *log;
+
+	uint64_t event_count;
+
+	uint64_t target_pid;
+
+	struct igt_list_head triggers;
+
+	int master_fd;
+
+	pthread_t worker_thread;
+	int worker_state;
+
+	int p_client[2];
+};
+
+struct xe_eudebug_client {
+	int pid;
+	uint64_t seqno;
+	uint64_t flags;
+
+	/* Used to smuggle private data */
+	void *ptr;
+
+	struct xe_eudebug_event_log *log;
+
+	int done;
+	int p_in[2];
+	int p_out[2];
+
+	/* Used to pickup right device (the one used in debugger) */
+	int master_fd;
+
+	int timeout_ms;
+};
+
+struct xe_eudebug_session {
+	uint64_t flags;
+	struct xe_eudebug_client *c;
+	struct xe_eudebug_debugger *d;
+};
+
+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_event(_e, _log) \
+	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
+		    (void *)(_log)->log; \
+	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
+	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
+
+#define xe_eudebug_assert(d, c)						\
+	do {								\
+		if (!(c)) {						\
+			xe_eudebug_event_log_print((d)->log, true);	\
+			igt_assert(c);					\
+		}							\
+	} while (0)
+
+#define xe_eudebug_assert_f(d, c, f...)					\
+	do {								\
+		if (!(c)) {						\
+			xe_eudebug_event_log_print((d)->log, true);	\
+			igt_assert_f(c, f);				\
+		}							\
+	} while (0)
+
+#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
+
+/*
+ * Default abort timeout to use across xe_eudebug lib and tests if no specific
+ * timeout value is required.
+ */
+#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
+
+#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
+#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
+#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
+
+int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
+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);
+struct xe_eudebug_event_log *
+xe_eudebug_event_log_create(const char *name, unsigned int max_size);
+void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
+void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
+void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
+				  uint32_t filter);
+void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
+void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
+
+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_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, int timeout_s);
+void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
+void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
+void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
+				     xe_eudebug_trigger_fn fn);
+void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
+void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
+
+struct xe_eudebug_client *
+xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
+void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
+void xe_eudebug_client_start(struct xe_eudebug_client *c);
+void xe_eudebug_client_stop(struct xe_eudebug_client *c);
+void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
+void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
+void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
+
+uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
+void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
+
+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 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,
+					     struct drm_xe_exec_queue_create *create);
+void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
+					  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,
+				     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,
+					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,
+			   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,
+				     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,
+			       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,
+				       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,
+				 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,
+						     void *test_private);
+void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
+void xe_eudebug_session_run(struct xe_eudebug_session *s);
+void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
-- 
2.34.1

[PATCH i-g-t v3 05/14] tests/xe_eudebug: Test eudebug resource tracking and manipulation

[Christoph Manszewski]

From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>

For typical debugging under gdb one can specify two main usecases:
accessing and manupulating resources created by the application and
manipulating thread execution (interrupting and setting breakpoints).

This test adds coverage for the former by checking that:
- the debugger reports the expected events for Xe resources created
by the debugged client,
- the debugger is able to read and write the vm of the debugged client.

Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
Signed-off-by: Jonathan Cavitt <jonathan.cavitt@intel.com>
---
 tests/intel/xe_eudebug.c | 2671 ++++++++++++++++++++++++++++++++++++++
 tests/meson.build        |    1 +
 2 files changed, 2672 insertions(+)
 create mode 100644 tests/intel/xe_eudebug.c

diff --git a/tests/intel/xe_eudebug.c b/tests/intel/xe_eudebug.c
new file mode 100644
index 000000000..152643850
--- /dev/null
+++ b/tests/intel/xe_eudebug.c
@@ -0,0 +1,2671 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+
+/**
+ * TEST: Test EU Debugger functionality
+ * Category: Core
+ * Mega feature: EUdebug
+ * Sub-category: EUdebug tests
+ * Functionality: eu debugger framework
+ * Test category: functionality test
+ */
+
+#include <grp.h>
+#include <poll.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <sys/ioctl.h>
+#include <sys/prctl.h>
+
+#include "igt.h"
+#include "intel_pat.h"
+#include "lib/igt_syncobj.h"
+#include "xe/xe_eudebug.h"
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+
+/**
+ * SUBTEST: sysfs-toggle
+ * Description:
+ *	Exercise the debugger enable/disable sysfs toggle logic
+ */
+static void test_sysfs_toggle(int fd)
+{
+	xe_eudebug_enable(fd, false);
+	igt_assert(!xe_eudebug_debugger_available(fd));
+
+	xe_eudebug_enable(fd, true);
+	igt_assert(xe_eudebug_debugger_available(fd));
+	xe_eudebug_enable(fd, true);
+	igt_assert(xe_eudebug_debugger_available(fd));
+
+	xe_eudebug_enable(fd, false);
+	igt_assert(!xe_eudebug_debugger_available(fd));
+	xe_eudebug_enable(fd, false);
+	igt_assert(!xe_eudebug_debugger_available(fd));
+
+	xe_eudebug_enable(fd, true);
+	igt_assert(xe_eudebug_debugger_available(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_METADATA (1 << 5)
+#define VM_BIND_METADATA (1 << 6)
+#define VM_BIND_OP_MAP_USERPTR (1 << 7)
+#define TEST_DISCOVERY (1 << 31)
+
+#define PAGE_SIZE 4096
+static struct drm_xe_vm_bind_op_ext_attach_debug *
+basic_vm_bind_metadata_ext_prepare(int fd, struct xe_eudebug_client *c,
+				   uint8_t **data, uint32_t data_size)
+{
+	struct drm_xe_vm_bind_op_ext_attach_debug *ext;
+	int i;
+
+	*data = calloc(data_size, sizeof(*data));
+	igt_assert(*data);
+
+	for (i = 0; i < data_size; i++)
+		(*data)[i] = 0xff & (i + (i > PAGE_SIZE));
+
+
+	ext = calloc(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM, sizeof(*ext));
+	igt_assert(ext);
+
+	for (i = 0; i < WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM; i++) {
+		ext[i].base.name = XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
+		ext[i].metadata_id = xe_eudebug_client_metadata_create(c, fd, i,
+								       (i + 1) * PAGE_SIZE, *data);
+		ext[i].cookie = i;
+
+		if (i < WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM - 1)
+			ext[i].base.next_extension = to_user_pointer(&ext[i+1]);
+	}
+	return ext;
+}
+
+static void basic_vm_bind_metadata_ext_del(int fd, struct xe_eudebug_client *c,
+					   struct drm_xe_vm_bind_op_ext_attach_debug *ext,
+					   uint8_t *data)
+{
+	for (int i = 0; i < WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM; i++)
+		xe_eudebug_client_metadata_destroy(c, fd, ext[i].metadata_id,
+							   i, (i + 1) * PAGE_SIZE);
+	free(ext);
+	free(data);
+}
+
+static void basic_vm_bind_client(int fd, 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, fd, 0, 0);
+	size_t bo_size = xe_get_default_alignment(fd);
+	bool test_discovery = c->flags & TEST_DISCOVERY;
+	bool test_metadata = c->flags & VM_BIND_METADATA;
+	uint32_t bo = xe_bo_create(fd, 0, bo_size,
+				   system_memory(fd), 0);
+	uint64_t addr = 0x1a0000;
+	uint8_t *data = NULL;
+
+	if (test_metadata)
+		ext = basic_vm_bind_metadata_ext_prepare(fd, c, &data, PAGE_SIZE);
+
+	xe_eudebug_client_vm_bind_flags(c, fd, vm, bo, 0, addr,
+					bo_size, 0, NULL, 0, to_user_pointer(ext));
+
+	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, fd, vm, 0, addr, bo_size);
+
+	if (test_metadata)
+		basic_vm_bind_metadata_ext_del(fd, c, ext, data);
+
+	gem_close(fd, bo);
+	xe_eudebug_client_vm_destroy(c, fd, vm);
+}
+
+static void basic_vm_bind_vm_destroy_client(int fd, struct xe_eudebug_client *c)
+{
+	uint32_t vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+	size_t bo_size = xe_get_default_alignment(fd);
+	bool test_discovery = c->flags & TEST_DISCOVERY;
+	uint32_t bo = xe_bo_create(fd, 0, bo_size,
+				   system_memory(fd), 0);
+	uint64_t addr = 0x1a0000;
+
+	if (test_discovery) {
+		vm = xe_vm_create(fd, 0, 0);
+
+		xe_vm_bind_async(fd, vm, 0, bo, 0, addr, bo_size, NULL, 0);
+
+		xe_vm_destroy(fd, vm);
+
+		xe_eudebug_client_signal_stage(c, STAGE_PRE_DEBUG_RESOURCES_DONE);
+		xe_eudebug_client_wait_stage(c, STAGE_DISCOVERY_DONE);
+	} else {
+		vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+		xe_eudebug_client_vm_bind(c, fd, vm, bo, 0, addr, bo_size);
+		xe_eudebug_client_vm_destroy(c, fd, vm);
+	}
+
+	gem_close(fd, bo);
+}
+
+#define BO_ADDR 0x1a0000
+#define BO_ITEMS 4096
+#define MIN_BO_SIZE (BO_ITEMS * sizeof(uint64_t))
+
+union buf_id {
+	uint32_t fd;
+	void *userptr;
+};
+
+struct bind_list {
+	int fd;
+	uint32_t vm;
+	union buf_id *bo;
+	struct drm_xe_vm_bind_op *bind_ops;
+	unsigned int n;
+};
+
+static void *bo_get_ptr(int fd, struct drm_xe_vm_bind_op *o)
+{
+	void *ptr;
+
+	if (o->op != DRM_XE_VM_BIND_OP_MAP_USERPTR)
+		ptr = xe_bo_map(fd, o->obj, o->range);
+	else
+		ptr = (void *)(uintptr_t)o->userptr;
+
+	igt_assert(ptr);
+
+	return ptr;
+}
+
+static void bo_put_ptr(int fd, struct drm_xe_vm_bind_op *o, void *ptr)
+{
+	if (o->op != DRM_XE_VM_BIND_OP_MAP_USERPTR)
+		munmap(ptr, o->range);
+}
+
+static void bo_prime(int fd, struct drm_xe_vm_bind_op *o)
+{
+	uint64_t *d;
+	uint64_t i;
+
+	d = bo_get_ptr(fd, o);
+
+	for (i = 0; i < o->range / sizeof(*d); i++)
+		d[i] = o->addr + i;
+
+	bo_put_ptr(fd, o, d);
+}
+
+static void bo_check(int fd, struct drm_xe_vm_bind_op *o)
+{
+	uint64_t *d;
+	uint64_t i;
+
+	d = bo_get_ptr(fd, o);
+
+	for (i = 0; i < o->range / sizeof(*d); i++)
+		igt_assert_eq(d[i], o->addr + i + 1);
+
+	bo_put_ptr(fd, o, d);
+}
+
+static union buf_id *vm_create_objects(int fd, uint32_t bo_placement, uint32_t vm, unsigned int size,
+				   unsigned int n)
+{
+	union buf_id *bo;
+	unsigned int i;
+
+	bo = calloc(n, sizeof(*bo));
+	igt_assert(bo);
+
+	for (i = 0; i < n; i++) {
+		if (bo_placement) {
+			bo[i].fd = xe_bo_create(fd, vm, size, bo_placement, 0);
+			igt_assert(bo[i].fd);
+		} else {
+			bo[i].userptr = aligned_alloc(PAGE_SIZE, size);
+			igt_assert(bo[i].userptr);
+		}
+	}
+
+	return bo;
+}
+
+static struct bind_list *create_bind_list(int fd, uint32_t bo_placement,
+					  uint32_t vm, unsigned int n,
+					  unsigned int target_size)
+{
+	unsigned int i = target_size ?: MIN_BO_SIZE;
+	const unsigned int bo_size = max_t(bo_size, xe_get_default_alignment(fd), i);
+	bool is_userptr = !bo_placement;
+	struct bind_list *bl;
+
+	bl = malloc(sizeof(*bl));
+	bl->fd = fd;
+	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));
+	igt_assert(bl->bind_ops);
+
+	for (i = 0; i < n; i++) {
+		struct drm_xe_vm_bind_op *o = &bl->bind_ops[i];
+
+		if (is_userptr) {
+			o->obj = 0;
+			o->userptr = (uintptr_t)bl->bo[i].userptr;
+			o->op = DRM_XE_VM_BIND_OP_MAP_USERPTR;
+		} else {
+			o->obj = bl->bo[i].fd;
+			o->obj_offset = 0;
+			o->op = DRM_XE_VM_BIND_OP_MAP;
+		}
+
+		o->range = bo_size;
+		o->addr = BO_ADDR + 2 * i * bo_size;
+		o->flags = 0;
+		o->pat_index = intel_get_pat_idx_wb(fd);
+		o->prefetch_mem_region_instance = 0;
+		o->reserved[0] = 0;
+		o->reserved[1] = 0;
+	}
+
+	for (i = 0; i < bl->n; i++) {
+		struct drm_xe_vm_bind_op *o = &bl->bind_ops[i];
+
+		igt_debug("bo %d: addr 0x%llx, range 0x%llx\n", i, o->addr, o->range);
+		bo_prime(fd, o);
+	}
+
+	return bl;
+}
+
+static void do_bind_list(struct xe_eudebug_client *c,
+			 struct bind_list *bl, struct drm_xe_sync *sync)
+{
+	int i;
+	uint64_t ref_seqno = 0, op_ref_seqno = 0;
+
+	xe_vm_bind_array(bl->fd, bl->vm, 0, bl->bind_ops, bl->n, sync, sync ? 1 : 0);
+	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
+					bl->fd, 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);
+
+	if (sync)
+		igt_assert(syncobj_wait(bl->fd, &sync->handle, 1, INT64_MAX, 0, NULL));
+}
+
+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(bl->fd, &bl->bind_ops[i]);
+		if (bl->bind_ops[i].op == DRM_XE_VM_BIND_OP_MAP_USERPTR)
+			free(bl->bo[i].userptr);
+		xe_eudebug_client_vm_unbind(c, bl->fd, bl->vm, 0,
+					    bl->bind_ops[i].addr,
+					    bl->bind_ops[i].range);
+	}
+
+	free(bl->bind_ops);
+	free(bl->bo);
+	free(bl);
+}
+
+static void vm_bind_client(int fd, 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(fd);
+	uint32_t bo[2] = {
+		xe_bo_create(fd, 0, bo_size, system_memory(fd), 0),
+		xe_bo_create(fd, 0, bo_size, system_memory(fd), 0),
+	};
+	uint32_t vm = xe_eudebug_client_vm_create(c, fd, 0, 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(fd, vm, 0, bo[0], 0, addr[0], bo_size, NULL, 0);
+
+		xe_vm_unbind_async(fd, vm, 0, 0, addr[0] + size, size, NULL, 0);
+
+		xe_vm_bind_async(fd, vm, 0, bo[1], 0, addr[1], bo_size, NULL, 0);
+
+		xe_vm_bind_async(fd, vm, 0, bo[1], rebind_bo_offset, addr[1], size, NULL, 0);
+
+		bl = create_bind_list(fd, system_memory(fd), vm, 4, 0);
+		xe_vm_bind_array(bl->fd, bl->vm, 0, bl->bind_ops, bl->n, NULL, 0);
+
+		xe_vm_unbind_all_async(fd, vm, 0, bo[0], NULL, 0);
+
+		xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
+						bl->fd, 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, fd, vm, bo[0], 0, addr[0], bo_size);
+		xe_eudebug_client_vm_unbind(c, fd, vm, 0, addr[0] + size, size);
+
+		xe_eudebug_client_vm_bind(c, fd, vm, bo[1], 0, addr[1], bo_size);
+		xe_eudebug_client_vm_bind(c, fd, vm, bo[1], rebind_bo_offset, addr[1], size);
+
+		bl = create_bind_list(fd, system_memory(fd), vm, 4, 0);
+		do_bind_list(c, bl, NULL);
+	}
+
+	xe_vm_unbind_all_async(fd, vm, 0, bo[1], NULL, 0);
+
+	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE, fd, 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(fd, bo[0]);
+	gem_close(fd, bo[1]);
+	xe_eudebug_client_vm_destroy(c, fd, vm);
+}
+
+static void run_basic_client(struct xe_eudebug_client *c)
+{
+	int fd, i;
+
+	fd = xe_eudebug_client_open_driver(c);
+	xe_device_get(fd);
+
+	if (c->flags & CREATE_VMS) {
+		const uint32_t flags[] = {
+			DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE,
+			DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		};
+		uint32_t vms[ARRAY_SIZE(flags)];
+
+		for (i = 0; i < ARRAY_SIZE(flags); i++)
+			vms[i] = xe_eudebug_client_vm_create(c, fd, flags[i], 0);
+
+		for (i--; i >= 0; i--)
+			xe_eudebug_client_vm_destroy(c, fd, vms[i]);
+	}
+
+	if (c->flags & CREATE_EXEC_QUEUES) {
+		struct drm_xe_exec_queue_create *create;
+		struct drm_xe_engine_class_instance *hwe;
+		struct drm_xe_engine_class_instance bind_sync = {
+			.engine_class = DRM_XE_ENGINE_CLASS_VM_BIND,
+			.engine_instance = 0,
+		};
+		struct drm_xe_engine_class_instance bind_async = {
+			.engine_class = DRM_XE_ENGINE_CLASS_VM_BIND,
+			.engine_instance = 0,
+		};
+		uint32_t vm;
+
+		create = calloc((xe_number_engines(fd) + 2), sizeof(*create));
+
+		vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+
+		i = 0;
+		xe_for_each_engine(fd, hwe) {
+			create[i].instances = to_user_pointer(hwe);
+			create[i].vm_id = vm;
+			create[i].width = 1;
+			create[i].num_placements = 1;
+			xe_eudebug_client_exec_queue_create(c, fd, &create[i++]);
+		}
+
+		create[i].instances = to_user_pointer(&bind_sync),
+		create[i].vm_id = vm;
+		create[i].width = 1,
+		create[i].num_placements = 1,
+		xe_eudebug_client_exec_queue_create(c, fd, &create[i++]);
+
+		create[i].instances = to_user_pointer(&bind_async),
+		create[i].vm_id = vm;
+		create[i].width = 1,
+		create[i].num_placements = 1,
+		xe_eudebug_client_exec_queue_create(c, fd, &create[i]);
+
+		for (; i >= 0; i--)
+			xe_eudebug_client_exec_queue_destroy(c, fd, &create[i]);
+
+		xe_eudebug_client_vm_destroy(c, fd,  vm);
+	}
+
+	if (c->flags & VM_BIND || c->flags & VM_BIND_METADATA)
+		basic_vm_bind_client(fd, c);
+
+	if (c->flags & VM_BIND_EXTENDED)
+		vm_bind_client(fd, c);
+
+	if (c->flags & VM_BIND_VM_DESTROY)
+		basic_vm_bind_vm_destroy_client(fd, c);
+
+	xe_device_put(fd);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+static int read_event(int debugfd, struct drm_xe_eudebug_event *event)
+{
+	int ret;
+
+	ret = igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
+	if (ret < 0)
+		return -errno;
+
+	return ret;
+}
+
+static int __read_event(int debugfd, struct drm_xe_eudebug_event *event)
+{
+	int ret;
+
+	ret = ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
+	if (ret < 0)
+		return -errno;
+
+	return ret;
+}
+
+static int poll_event(int fd, int timeout_ms)
+{
+	int ret;
+
+	struct pollfd p = {
+		.fd = fd,
+		.events = POLLIN,
+		.revents = 0,
+	};
+
+	ret = poll(&p, 1, timeout_ms);
+	if (ret == -1)
+		return -errno;
+
+	return ret == 1 && (p.revents & POLLIN);
+}
+
+static int __debug_connect(int fd, int *debugfd, struct drm_xe_eudebug_connect *param)
+{
+	int ret = 0;
+
+	*debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, param);
+
+	if (*debugfd < 0) {
+		ret = -errno;
+		igt_assume(ret != 0);
+	}
+
+	errno = 0;
+	return ret;
+}
+
+/**
+ * SUBTEST: basic-connect
+ * Description:
+ *	Exercise XE_EUDEBUG_CONNECT ioctl with passing
+ *	valid and invalid params.
+ */
+static void test_connect(int fd)
+{
+	struct drm_xe_eudebug_connect param = {};
+	int debugfd, ret;
+	pid_t *pid;
+
+	pid = mmap(NULL, sizeof(pid_t), PROT_WRITE,
+		   MAP_SHARED | MAP_ANON, -1, 0);
+
+	/* get fresh unrelated pid */
+	igt_fork(child, 1)
+		*pid = getpid();
+
+	igt_waitchildren();
+	param.pid = *pid;
+	munmap(pid, sizeof(pid_t));
+
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert(debugfd == -1);
+	igt_assert_eq(ret, param.pid ? -ENOENT : -EINVAL);
+
+	param.pid = 0;
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert(debugfd == -1);
+	igt_assert_eq(ret, -EINVAL);
+
+	param.pid = getpid();
+	param.version = -1;
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert(debugfd == -1);
+	igt_assert_eq(ret, -EINVAL);
+
+	param.version = 0;
+	param.flags = ~0;
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert(debugfd == -1);
+	igt_assert_eq(ret, -EINVAL);
+
+	param.flags = 0;
+	param.extensions = ~0;
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert(debugfd == -1);
+	igt_assert_eq(ret, -EINVAL);
+
+	param.extensions = 0;
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert_neq(debugfd, -1);
+	igt_assert_eq(ret, 0);
+
+	close(debugfd);
+}
+
+static void switch_user(__uid_t uid, __gid_t gid)
+{
+	struct group *gr;
+	__gid_t gr_v;
+
+	/* Users other then root need to belong to video group */
+	gr = getgrnam("video");
+	igt_assert(gr);
+
+	/* Drop all */
+	igt_assert_eq(setgroups(1, &gr->gr_gid), 0);
+	igt_assert_eq(setgid(gid), 0);
+	igt_assert_eq(setuid(uid), 0);
+
+	igt_assert_eq(getgroups(1, &gr_v), 1);
+	igt_assert_eq(gr_v, gr->gr_gid);
+	igt_assert_eq(getgid(), gid);
+	igt_assert_eq(getuid(), uid);
+
+	igt_assert_eq(prctl(PR_SET_DUMPABLE, 1L), 0);
+}
+
+/**
+ * SUBTEST: connect-user
+ * Description:
+ *	Verify unprivileged XE_EUDEBG_CONNECT ioctl.
+ *	Check:
+ *	 - user debugger to user workload connection
+ *	 - user debugger to other user workload connection
+ *	 - user debugger to privileged workload connection
+ */
+static void test_connect_user(int fd)
+{
+	struct drm_xe_eudebug_connect param = {};
+	struct passwd *pwd, *pwd2;
+	const char *user1 = "lp";
+	const char *user2 = "mail";
+	int debugfd, ret, i;
+	int p1[2], p2[2];
+	__uid_t u1, u2;
+	__gid_t g1, g2;
+	int newfd;
+	pid_t pid;
+
+#define NUM_USER_TESTS 4
+#define P_APP 0
+#define P_GDB 1
+	struct conn_user {
+		/* u[0] - process uid, u[1] - gdb uid */
+		__uid_t u[P_GDB + 1];
+		/* g[0] - process gid, g[1] - gdb gid */
+		__gid_t g[P_GDB + 1];
+		/* Expected fd from open */
+		int ret;
+		/* Skip this test case */
+		int skip;
+		const char *desc;
+	} test[NUM_USER_TESTS] = {};
+
+	igt_assert(!pipe(p1));
+	igt_assert(!pipe(p2));
+
+	pwd = getpwnam(user1);
+	igt_require(pwd);
+	u1 = pwd->pw_uid;
+	g1 = pwd->pw_gid;
+
+	/*
+	 * Keep a copy of needed contents as it is a static
+	 * memory area and subsequent calls will overwrite
+	 * what's in.
+	 * However getpwnam() returns NULL if cannot find
+	 * user in passwd.
+	 */
+	setpwent();
+	pwd2 = getpwnam(user2);
+	if (pwd2) {
+		u2 = pwd2->pw_uid;
+		g2 = pwd2->pw_gid;
+	}
+
+	test[0].skip = !pwd;
+	test[0].u[P_GDB] = u1;
+	test[0].g[P_GDB] = g1;
+	test[0].ret = -EACCES;
+	test[0].desc = "User GDB to Root App";
+
+	test[1].skip = !pwd;
+	test[1].u[P_APP] = u1;
+	test[1].g[P_APP] = g1;
+	test[1].u[P_GDB] = u1;
+	test[1].g[P_GDB] = g1;
+	test[1].ret = 0;
+	test[1].desc = "User GDB to User App";
+
+	test[2].skip = !pwd;
+	test[2].u[P_APP] = u1;
+	test[2].g[P_APP] = g1;
+	test[2].ret = 0;
+	test[2].desc = "Root GDB to User App";
+
+	test[3].skip = !pwd2;
+	test[3].u[P_APP] = u1;
+	test[3].g[P_APP] = g1;
+	test[3].u[P_GDB] = u2;
+	test[3].g[P_GDB] = g2;
+	test[3].ret = -EACCES;
+	test[3].desc = "User GDB to Other User App";
+
+	if (!pwd2)
+		igt_warn("User %s not available in the system. Skipping subtests: %s.\n",
+			 user2, test[3].desc);
+
+	for (i = 0; i < NUM_USER_TESTS; i++) {
+		if (test[i].skip) {
+			igt_debug("Subtest %s skipped\n", test[i].desc);
+			continue;
+		}
+		igt_debug("Executing connection: %s\n", test[i].desc);
+		igt_fork(child, 2) {
+			if (!child) {
+				if (test[i].u[P_APP])
+					switch_user(test[i].u[P_APP], test[i].g[P_APP]);
+
+				pid = getpid();
+				/* Signal the PID */
+				igt_assert(write(p1[1], &pid, sizeof(pid)) == sizeof(pid));
+				/* wait with exit */
+				igt_assert(read(p2[0], &pid, sizeof(pid)) == sizeof(pid));
+			} else {
+				if (test[i].u[P_GDB])
+					switch_user(test[i].u[P_GDB], test[i].g[P_GDB]);
+
+				igt_assert(read(p1[0], &pid, sizeof(pid)) == sizeof(pid));
+				param.pid = pid;
+
+				newfd = drm_open_driver(DRIVER_XE);
+				ret = __debug_connect(newfd, &debugfd, &param);
+
+				/* Release the app first */
+				igt_assert(write(p2[1], &pid, sizeof(pid)) == sizeof(pid));
+
+				igt_assert_eq(ret, test[i].ret);
+				if (!ret)
+					close(debugfd);
+			}
+		}
+		igt_waitchildren();
+	}
+	close(p1[0]);
+	close(p1[1]);
+	close(p2[0]);
+	close(p2[1]);
+#undef NUM_USER_TESTS
+#undef P_APP
+#undef P_GDB
+}
+
+/**
+ * SUBTEST: basic-close
+ * Description:
+ *	Test whether eudebug can be reattached after closure.
+ */
+static void test_close(int fd)
+{
+	struct drm_xe_eudebug_connect param = { 0,  };
+	int debug_fd1, debug_fd2;
+	int fd2;
+
+	param.pid = getpid();
+
+	igt_assert_eq(__debug_connect(fd, &debug_fd1, &param), 0);
+	igt_assert(debug_fd1 >= 0);
+	igt_assert_eq(__debug_connect(fd, &debug_fd2, &param), -EBUSY);
+	igt_assert_eq(debug_fd2, -1);
+
+	close(debug_fd1);
+	fd2 = drm_open_driver(DRIVER_XE);
+
+	igt_assert_eq(__debug_connect(fd2, &debug_fd2, &param), 0);
+	igt_assert(debug_fd2 >= 0);
+	close(fd2);
+	close(debug_fd2);
+	close(debug_fd1);
+}
+
+/**
+ * SUBTEST: basic-read-event
+ * Description:
+ *	Synchronously exercise eu debugger event polling and reading.
+ */
+#define MAX_EVENT_SIZE (32 * 1024)
+static void test_read_event(int fd)
+{
+	struct drm_xe_eudebug_event *event;
+	struct xe_eudebug_debugger *d;
+	struct xe_eudebug_client *c;
+
+	event = malloc(MAX_EVENT_SIZE);
+	igt_assert(event);
+	memset(event, 0, sizeof(*event));
+
+	c = xe_eudebug_client_create(fd, run_basic_client, 0, NULL);
+	d = xe_eudebug_debugger_create(fd, 0, NULL);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(d, c), 0);
+	igt_assert_eq(poll_event(d->fd, 500), 0);
+
+	event->len = 1;
+	event->type = DRM_XE_EUDEBUG_EVENT_NONE;
+	igt_assert_eq(read_event(d->fd, event), -EINVAL);
+
+	event->len = MAX_EVENT_SIZE;
+	event->type = DRM_XE_EUDEBUG_EVENT_NONE;
+	igt_assert_eq(read_event(d->fd, event), -EINVAL);
+
+	xe_eudebug_client_start(c);
+
+	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(poll_event(d->fd, 500), 1);
+	event->len = MAX_EVENT_SIZE;
+	event->flags = 0;
+	event->type = DRM_XE_EUDEBUG_EVENT_READ;
+	igt_assert_eq(read_event(d->fd, event), 0);
+
+	fcntl(d->fd, F_SETFL, fcntl(d->fd, F_GETFL) | O_NONBLOCK);
+	igt_assert(fcntl(d->fd, F_GETFL) & O_NONBLOCK);
+
+	igt_assert_eq(poll_event(d->fd, 500), 0);
+	event->len = MAX_EVENT_SIZE;
+	event->flags = 0;
+	event->type = DRM_XE_EUDEBUG_EVENT_READ;
+	igt_assert_eq(__read_event(d->fd, event), -EAGAIN);
+
+	xe_eudebug_client_wait_done(c);
+	xe_eudebug_client_stop(c);
+
+	igt_assert_eq(poll_event(d->fd, 500), 0);
+	igt_assert_eq(__read_event(d->fd, event), -EAGAIN);
+
+	xe_eudebug_debugger_destroy(d);
+	xe_eudebug_client_destroy(c);
+
+	free(event);
+}
+
+/**
+ * SUBTEST: basic-client
+ * Description:
+ *	Attach the debugger to process which opens and closes xe drm client.
+ *
+ * SUBTEST: basic-client-th
+ * Description:
+ *	Create client basic resources (vms) in multiple threads
+ *
+ * SUBTEST: multiple-sessions
+ * Description:
+ *	Simultaneously attach many debuggers to many processes.
+ *	Each process opens and closes xe drm client and creates few resources.
+ *
+ * SUBTEST: basic-%s
+ * Description:
+ *	Attach the debugger to process which creates and destroys a few %arg[1].
+ *
+ * SUBTEST: basic-vm-bind
+ * Description:
+ *	Attach the debugger to a process that performs synchronous vm bind
+ *	and vm unbind.
+ *
+ * SUBTEST: basic-vm-bind-vm-destroy
+ * 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
+ * Description:
+ *	Attach the debugger to a process that performs bind, bind array, rebind,
+ *	partial unbind, unbind and unbind all operations.
+ *
+ * SUBTEST: multigpu-basic-client
+ * Description:
+ *	Attach the debugger to process which opens and closes xe drm client on all Xe devices.
+ *
+ * SUBTEST: multigpu-basic-client-many
+ * Description:
+ *	Simultaneously attach many debuggers to many processes on all Xe devices.
+ *	Each process opens and closes xe drm client and creates few resources.
+ *
+ * arg[1]:
+ *
+ * @vms: vms
+ * @exec-queues: exec queues
+ */
+
+static void test_basic_sessions(int fd, unsigned int flags, int count, bool match_opposite)
+{
+	struct xe_eudebug_session **s;
+	int i;
+
+	s = calloc(count, sizeof(*s));
+
+	igt_assert(s);
+
+	for (i = 0; i < count; i++)
+		s[i] = xe_eudebug_session_create(fd, run_basic_client, flags, NULL);
+
+	for (i = 0; i < count; i++)
+		xe_eudebug_session_run(s[i]);
+
+	for (i = 0; i < count; i++)
+		xe_eudebug_session_check(s[i], match_opposite, 0);
+
+	for (i = 0; i < count; i++)
+		xe_eudebug_session_destroy(s[i]);
+}
+
+/**
+ * SUBTEST: basic-vm-bind-discovery
+ * Description:
+ *	Attach the debugger to a process that performs vm-bind before attaching
+ *	and check if the discovery process reports it.
+ *
+ * SUBTEST: basic-vm-bind-metadata-discovery
+ * Description:
+ *	Attach the debugger to a process that performs vm-bind with metadata attached
+ *	before attaching and check if the discovery process reports it.
+ *
+ * SUBTEST: basic-vm-bind-vm-destroy-discovery
+ * Description:
+ *	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
+ * 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)
+{
+	struct xe_eudebug_debugger *d;
+	struct xe_eudebug_session *s;
+	struct xe_eudebug_client *c;
+
+	s = xe_eudebug_session_create(fd, run_basic_client, flags | TEST_DISCOVERY, NULL);
+
+	c = s->c;
+	d = s->d;
+
+	xe_eudebug_client_start(c);
+	xe_eudebug_debugger_wait_stage(s, STAGE_PRE_DEBUG_RESOURCES_DONE);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(d, c), 0);
+	xe_eudebug_debugger_start_worker(d);
+
+	/* give the worker time to do it's job */
+	sleep(2);
+	xe_eudebug_debugger_signal_stage(d, STAGE_DISCOVERY_DONE);
+
+	xe_eudebug_client_wait_done(c);
+
+	xe_eudebug_debugger_stop_worker(d, 1);
+
+	xe_eudebug_event_log_print(d->log, true);
+	xe_eudebug_event_log_print(c->log, true);
+
+	xe_eudebug_session_check(s, match_opposite, 0);
+	xe_eudebug_session_destroy(s);
+}
+
+#define RESOURCE_COUNT 16
+#define PRIMARY_THREAD			(1 << 0)
+#define DISCOVERY_CLOSE_CLIENT		(1 << 1)
+#define DISCOVERY_DESTROY_RESOURCES	(1 << 2)
+#define DISCOVERY_VM_BIND		(1 << 3)
+static void run_discovery_client(struct xe_eudebug_client *c)
+{
+	struct drm_xe_engine_class_instance *hwe = NULL;
+	int fd[RESOURCE_COUNT], i;
+	bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES | DISCOVERY_CLOSE_CLIENT);
+	uint64_t addr = 0x1a0000;
+
+	srand(getpid());
+
+	for (i = 0; i < RESOURCE_COUNT; i++) {
+		fd[i] = xe_eudebug_client_open_driver(c);
+
+		if (!i) {
+			bool found = false;
+
+			xe_device_get(fd[0]);
+			xe_for_each_engine(fd[0], hwe) {
+				if (hwe->engine_class == DRM_XE_ENGINE_CLASS_COMPUTE ||
+				    hwe->engine_class == DRM_XE_ENGINE_CLASS_RENDER) {
+					found = true;
+					break;
+				}
+			}
+			igt_assert(found);
+		}
+
+		/*
+		 * Give the debugger a break in event stream after every
+		 * other client, that allows to read discovery and dettach in quiet.
+		 */
+		if (random() % 2 == 0 && !skip_sleep)
+			sleep(1);
+
+		for (int j = 0; j < RESOURCE_COUNT; j++) {
+			uint32_t vm = xe_eudebug_client_vm_create(c, fd[i], 0, 0);
+			struct drm_xe_exec_queue_create create = {
+				.width = 1,
+				.num_placements = 1,
+				.vm_id = vm,
+				.instances = to_user_pointer(hwe)
+			};
+			const unsigned int bo_size = max_t(bo_size,
+							   xe_get_default_alignment(fd[i]),
+							   MIN_BO_SIZE);
+			uint32_t bo = xe_bo_create(fd[i], 0, bo_size, system_memory(fd[i]), 0);
+
+			xe_eudebug_client_exec_queue_create(c, fd[i], &create);
+
+			if (c->flags & DISCOVERY_VM_BIND) {
+				xe_eudebug_client_vm_bind(c, fd[i], vm, bo, 0, addr, bo_size);
+				addr += 0x100000;
+			}
+
+			if (c->flags & DISCOVERY_DESTROY_RESOURCES) {
+				xe_eudebug_client_exec_queue_destroy(c, fd[i], &create);
+				xe_eudebug_client_vm_destroy(c, fd[i], create.vm_id);
+				gem_close(fd[i], bo);
+			}
+		}
+
+		if (c->flags & DISCOVERY_CLOSE_CLIENT)
+			xe_eudebug_client_close_driver(c, fd[i]);
+	}
+	xe_device_put(fd[0]);
+}
+
+/**
+ * SUBTEST: discovery-%s
+ * Description: Race discovery against %arg[1] and the debugger dettach.
+ *
+ * arg[1]:
+ *
+ * @race:		resources creation
+ * @race-vmbind:	vm-bind operations
+ * @empty:		resources destruction
+ * @empty-clients:	client closure
+ */
+static void *discovery_race_thread(void *data)
+{
+	struct {
+		uint64_t client_handle;
+		int vm_count;
+		int exec_queue_count;
+		int vm_bind_op_count;
+	} clients[RESOURCE_COUNT];
+	struct xe_eudebug_session *s = data;
+	int expected = RESOURCE_COUNT * (1 + 2 * RESOURCE_COUNT);
+	const int tries = 100;
+	bool done = false;
+	int ret = 0;
+
+	for (int try = 0; try < tries && !done; try++) {
+
+		ret = xe_eudebug_debugger_attach(s->d, s->c);
+
+		if (ret == -EBUSY) {
+			usleep(100000);
+			continue;
+		}
+
+		igt_assert_eq(ret, 0);
+
+		if (random() % 2) {
+			struct drm_xe_eudebug_event *e = NULL;
+			int i = -1;
+
+			xe_eudebug_debugger_start_worker(s->d);
+			sleep(1);
+			xe_eudebug_debugger_stop_worker(s->d, 1);
+			igt_debug("Resources discovered: %lu\n", s->d->event_count);
+
+			xe_eudebug_for_each_event(e, s->d->log) {
+				if (e->type == DRM_XE_EUDEBUG_EVENT_OPEN) {
+					struct drm_xe_eudebug_event_client *eo = (void *)e;
+
+					if (i >= 0) {
+						igt_assert_eq(clients[i].vm_count,
+							      RESOURCE_COUNT);
+
+						igt_assert_eq(clients[i].exec_queue_count,
+							      RESOURCE_COUNT);
+
+						if (s->c->flags & DISCOVERY_VM_BIND)
+							igt_assert_eq(clients[i].vm_bind_op_count,
+								      RESOURCE_COUNT);
+					}
+
+					igt_assert(++i < RESOURCE_COUNT);
+					clients[i].client_handle = eo->client_handle;
+					clients[i].vm_count = 0;
+					clients[i].exec_queue_count = 0;
+					clients[i].vm_bind_op_count = 0;
+				}
+
+				if (e->type == DRM_XE_EUDEBUG_EVENT_VM)
+					clients[i].vm_count++;
+
+				if (e->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE)
+					clients[i].exec_queue_count++;
+
+				if (e->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP)
+					clients[i].vm_bind_op_count++;
+			};
+
+			igt_assert_lte(0, i);
+
+			for (int j = 0; j < i; j++)
+				for (int k = 0; k < i; k++) {
+					if (k == j)
+						continue;
+
+					igt_assert_neq(clients[j].client_handle,
+						       clients[k].client_handle);
+				}
+
+			if (s->d->event_count >= expected)
+				done = true;
+		}
+
+		xe_eudebug_debugger_dettach(s->d);
+		s->d->log->head = 0;
+		s->d->event_count = 0;
+	}
+
+	/* Primary thread must read everything */
+	if (s->flags & PRIMARY_THREAD) {
+		while ((ret = xe_eudebug_debugger_attach(s->d, s->c)) == -EBUSY)
+			usleep(100000);
+
+		igt_assert_eq(ret, 0);
+
+		xe_eudebug_debugger_start_worker(s->d);
+		xe_eudebug_client_wait_done(s->c);
+
+		if (READ_ONCE(s->d->event_count) != expected)
+			sleep(5);
+
+		xe_eudebug_debugger_stop_worker(s->d, 1);
+		xe_eudebug_debugger_dettach(s->d);
+	}
+
+	return NULL;
+}
+
+static void test_race_discovery(int fd, unsigned int flags, int clients)
+{
+	const int debuggers_per_client = 3;
+	int count = clients * debuggers_per_client;
+	struct xe_eudebug_session *sessions, *s;
+	struct xe_eudebug_client *c;
+	pthread_t *threads;
+	int i, j;
+
+	sessions = calloc(count, sizeof(*sessions));
+	threads = calloc(count, sizeof(*threads));
+
+	for (i = 0; i < clients; i++) {
+		c = xe_eudebug_client_create(fd, run_discovery_client, flags, NULL);
+		for (j = 0; j < debuggers_per_client; j++) {
+			s = &sessions[i * debuggers_per_client + j];
+			s->c = c;
+			s->d = xe_eudebug_debugger_create(fd, flags, NULL);
+			s->flags = flags | (!j ? PRIMARY_THREAD : 0);
+		}
+	}
+
+	for (i = 0; i < count; i++) {
+		if (sessions[i].flags & PRIMARY_THREAD)
+			xe_eudebug_client_start(sessions[i].c);
+
+		pthread_create(&threads[i], NULL, discovery_race_thread, &sessions[i]);
+	}
+
+	for (i = 0; i < count; i++)
+		pthread_join(threads[i], NULL);
+
+	for (i = count - 1; i > 0; i--) {
+		if (sessions[i].flags & PRIMARY_THREAD) {
+			igt_assert_eq(sessions[i].c->seqno-1, sessions[i].d->event_count);
+
+			xe_eudebug_event_log_compare(sessions[0].d->log,
+						     sessions[i].d->log,
+						     XE_EUDEBUG_FILTER_EVENT_VM_BIND);
+
+			xe_eudebug_client_destroy(sessions[i].c);
+		}
+		xe_eudebug_debugger_destroy(sessions[i].d);
+	}
+}
+
+static void *attach_dettach_thread(void *data)
+{
+	struct xe_eudebug_session *s = data;
+	const int tries = 100;
+	int ret = 0;
+
+	for (int try = 0; try < tries; try++) {
+
+		ret = xe_eudebug_debugger_attach(s->d, s->c);
+
+		if (ret == -EBUSY) {
+			usleep(100000);
+			continue;
+		}
+
+		igt_assert_eq(ret, 0);
+
+		if (random() % 2 == 0) {
+			xe_eudebug_debugger_start_worker(s->d);
+			xe_eudebug_debugger_stop_worker(s->d, 1);
+		}
+
+		xe_eudebug_debugger_dettach(s->d);
+		s->d->log->head = 0;
+		s->d->event_count = 0;
+	}
+
+	return NULL;
+}
+
+static void test_empty_discovery(int fd, unsigned int flags, int clients)
+{
+	struct xe_eudebug_session **s;
+	pthread_t *threads;
+	int i, expected = flags & DISCOVERY_CLOSE_CLIENT ? 0 : RESOURCE_COUNT;
+
+	igt_assert(flags & (DISCOVERY_DESTROY_RESOURCES | DISCOVERY_CLOSE_CLIENT));
+
+	s = calloc(clients, sizeof(struct xe_eudebug_session *));
+	threads = calloc(clients, sizeof(*threads));
+
+	for (i = 0; i < clients; i++)
+		s[i] = xe_eudebug_session_create(fd, run_discovery_client, flags, NULL);
+
+	for (i = 0; i < clients; i++) {
+		xe_eudebug_client_start(s[i]->c);
+
+		pthread_create(&threads[i], NULL, attach_dettach_thread, s[i]);
+	}
+
+	for (i = 0; i < clients; i++)
+		pthread_join(threads[i], NULL);
+
+	for (i = 0; i < clients; i++) {
+		xe_eudebug_client_wait_done(s[i]->c);
+		igt_assert_eq(xe_eudebug_debugger_attach(s[i]->d, s[i]->c), 0);
+
+		xe_eudebug_debugger_start_worker(s[i]->d);
+		xe_eudebug_debugger_stop_worker(s[i]->d, 5);
+		xe_eudebug_debugger_dettach(s[i]->d);
+
+		igt_assert_eq(s[i]->d->event_count, expected);
+
+		xe_eudebug_session_destroy(s[i]);
+	}
+}
+
+typedef void (*client_run_t)(struct xe_eudebug_client *);
+
+static void test_client_with_trigger(int fd, unsigned int flags, int count,
+				     client_run_t client_fn, int type,
+				     xe_eudebug_trigger_fn trigger_fn,
+				     struct drm_xe_engine_class_instance *hwe,
+				     bool match_opposite, uint32_t event_filter)
+{
+	struct xe_eudebug_session **s;
+	int i;
+
+	s = calloc(count, sizeof(*s));
+
+	igt_assert(s);
+
+	for (i = 0; i < count; i++)
+		s[i] = xe_eudebug_session_create(fd, client_fn, flags, hwe);
+
+	if (trigger_fn)
+		for (i = 0; i < count; i++)
+			xe_eudebug_debugger_add_trigger(s[i]->d, type, trigger_fn);
+
+	for (i = 0; i < count; i++)
+		xe_eudebug_session_run(s[i]);
+
+	for (i = 0; i < count; i++)
+		xe_eudebug_session_check(s[i], match_opposite, event_filter);
+
+	for (i = 0; i < count; i++)
+		xe_eudebug_session_destroy(s[i]);
+}
+
+struct thread_fn_args {
+	struct xe_eudebug_client *client;
+	int fd;
+};
+
+static void *basic_client_th(void *data)
+{
+	struct thread_fn_args *f = data;
+	struct xe_eudebug_client *c = f->client;
+	uint32_t *vms;
+	int fd, i, num_vms;
+
+	fd = f->fd;
+	igt_assert(fd);
+
+	xe_device_get(fd);
+
+	num_vms = 2 + rand() % 16;
+	vms = calloc(num_vms, sizeof(*vms));
+	igt_assert(vms);
+	igt_debug("Create %d client vms\n", num_vms);
+
+	for (i = 0; i < num_vms; i++)
+		vms[i] = xe_eudebug_client_vm_create(c, fd, DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE, 0);
+
+	for (i = 0; i < num_vms; i++)
+		xe_eudebug_client_vm_destroy(c, fd, vms[i]);
+
+	xe_device_put(fd);
+	free(vms);
+
+	return NULL;
+}
+
+static void run_basic_client_th(struct xe_eudebug_client *c)
+{
+	struct thread_fn_args *args;
+	int i, num_threads, fd;
+	pthread_t *threads;
+
+	args = calloc(1, sizeof(*args));
+	igt_assert(args);
+
+	num_threads = 2 + random() % 16;
+	igt_debug("Run on %d threads\n", num_threads);
+	threads = calloc(num_threads, sizeof(*threads));
+	igt_assert(threads);
+
+	fd = xe_eudebug_client_open_driver(c);
+	args->client = c;
+	args->fd = fd;
+
+	for (i = 0; i < num_threads; i++)
+		pthread_create(&threads[i], NULL, basic_client_th, args);
+
+	for (i = 0; i < num_threads; i++)
+		pthread_join(threads[i], NULL);
+
+	xe_eudebug_client_close_driver(c, fd);
+	free(args);
+	free(threads);
+}
+
+static void test_basic_sessions_th(int fd, unsigned int flags, int num_clients, bool match_opposite)
+{
+	test_client_with_trigger(fd, flags, num_clients, run_basic_client_th,
+					 0, NULL, NULL, match_opposite, 0);
+}
+
+static void vm_access_client(struct xe_eudebug_client *c)
+{
+	struct drm_xe_sync sync = {
+		.flags = DRM_XE_SYNC_TYPE_SYNCOBJ | DRM_XE_SYNC_FLAG_SIGNAL, };
+	struct drm_xe_engine_class_instance *hwe = c->ptr;
+	uint32_t bo_placement;
+	struct bind_list *bl;
+	uint32_t vm;
+	int fd, i, j;
+
+	igt_debug("Using %s\n", xe_engine_class_string(hwe->engine_class));
+
+	fd = xe_eudebug_client_open_driver(c);
+	xe_device_get(fd);
+
+	vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+
+	if (c->flags & VM_BIND_OP_MAP_USERPTR)
+		bo_placement = 0;
+	else
+		bo_placement = vram_if_possible(fd, hwe->gt_id);
+
+	for (j = 0; j < 5; j++) {
+		unsigned int target_size = MIN_BO_SIZE * (1 << j);
+
+		bl = create_bind_list(fd, bo_placement, vm, 4, target_size);
+		sync.handle = syncobj_create(bl->fd, 0);
+		do_bind_list(c, bl, &sync);
+		syncobj_destroy(bl->fd, sync.handle);
+
+		for (i = 0; i < bl->n; i++)
+			xe_eudebug_client_wait_stage(c, bl->bind_ops[i].addr);
+
+		free_bind_list(c, bl);
+	}
+	xe_eudebug_client_vm_destroy(c, fd, vm);
+
+	xe_device_put(fd);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+static void debugger_test_vma(struct xe_eudebug_debugger *d,
+			      uint64_t client_handle,
+			      uint64_t vm_handle,
+			      uint64_t va_start,
+			      uint64_t va_length)
+{
+	struct drm_xe_eudebug_vm_open vo = { 0, };
+	uint64_t *v1, *v2;
+	uint64_t items = va_length / sizeof(uint64_t);
+	int fd;
+	int r, i;
+
+	v1 = malloc(va_length);
+	igt_assert(v1);
+	v2 = malloc(va_length);
+	igt_assert(v2);
+
+	vo.client_handle = client_handle;
+	vo.vm_handle = vm_handle;
+
+	fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+	igt_assert_lte(0, fd);
+
+	r = pread(fd, v1, va_length, va_start);
+	igt_assert_eq(r, va_length);
+
+	for (i = 0; i < items; i++)
+		igt_assert_eq(v1[i], va_start + i);
+
+	for (i = 0; i < items; i++)
+		v1[i] = va_start + i + 1;
+
+	r = pwrite(fd, v1, va_length, va_start);
+	igt_assert_eq(r, va_length);
+
+	lseek(fd, va_start, SEEK_SET);
+	r = read(fd, v2, va_length);
+	igt_assert_eq(r, va_length);
+
+	for (i = 0; i < items; i++)
+		igt_assert_eq(v1[i], v2[i]);
+
+	fsync(fd);
+
+	close(fd);
+	free(v1);
+	free(v2);
+}
+
+static void vm_trigger(struct xe_eudebug_debugger *d,
+		       struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		struct drm_xe_eudebug_event_vm_bind *eb;
+
+		igt_debug("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n",
+			  eo->vm_bind_ref_seqno,
+			  eo->addr,
+			  eo->range);
+
+		eb = (struct drm_xe_eudebug_event_vm_bind *)
+			xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno);
+		igt_assert(eb);
+
+		debugger_test_vma(d, eb->client_handle, eb->vm_handle,
+				  eo->addr, eo->range);
+		xe_eudebug_debugger_signal_stage(d, eo->addr);
+	}
+}
+
+/**
+ * SUBTEST: basic-vm-access
+ * Description:
+ *      Exercise XE_EUDEBUG_VM_OPEN with pread and pwrite into the
+ *      vm fd, concerning many different offsets inside the vm,
+ *      and many virtual addresses of the vm_bound object.
+ *
+ * SUBTEST: basic-vm-access-userptr
+ * Description:
+ *      Exercise XE_EUDEBUG_VM_OPEN with pread and pwrite into the
+ *      vm fd, concerning many different offsets inside the vm,
+ *      and many virtual addresses of the vm_bound object, but backed
+ *      by userptr.
+ */
+static void test_vm_access(int fd, unsigned int flags, int num_clients)
+{
+	struct drm_xe_engine_class_instance *hwe;
+
+	xe_for_each_engine(fd, hwe)
+		test_client_with_trigger(fd, flags, num_clients,
+					 vm_access_client,
+					 DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
+					 vm_trigger, hwe,
+					 false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP);
+}
+
+static void debugger_test_vma_parameters(struct xe_eudebug_debugger *d,
+					 uint64_t client_handle,
+					 uint64_t vm_handle,
+					 uint64_t va_start,
+					 uint64_t va_length)
+{
+	struct drm_xe_eudebug_vm_open vo = { 0, };
+	uint64_t *v;
+	uint64_t items = va_length / sizeof(uint64_t);
+	int fd;
+	int r, i;
+
+	v = malloc(va_length);
+	igt_assert(v);
+
+	/* Negative VM open - bad client handle */
+	vo.client_handle = client_handle + 123;
+	vo.vm_handle = vm_handle;
+	fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+	igt_assert(fd < 0);
+
+	/* Negative VM open - bad vm handle */
+	vo.client_handle = client_handle;
+	vo.vm_handle = vm_handle + 123;
+	fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+	igt_assert(fd < 0);
+
+	/* Positive VM open */
+	vo.client_handle = client_handle;
+	vo.vm_handle = vm_handle;
+	fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+	igt_assert_lte(0, fd);
+
+	/* Negative pread - bad fd */
+	r = pread(fd + 123, v, va_length, va_start);
+	igt_assert(r < 0);
+
+	/* Negative pread - bad va_start */
+	r = pread(fd, v, va_length, 0);
+	igt_assert(r < 0);
+
+	/* Negative pread - bad va_start */
+	r = pread(fd, v, va_length, va_start - 1);
+	igt_assert(r < 0);
+
+	/* Positive pread - zero va_length */
+	r = pread(fd, v, 0, va_start);
+	igt_assert_eq(r, 0);
+
+	/* Negative pread - out of range */
+	r = pread(fd, v, va_length + 1, va_start);
+	igt_assert_eq(r, va_length);
+
+	/* Negative pread - bad va_start */
+	r = pread(fd, v, 1, va_start + va_length);
+	igt_assert(r < 0);
+
+	/* Positive pread - whole range */
+	r = pread(fd, v, va_length, va_start);
+	igt_assert_eq(r, va_length);
+
+	/* Positive pread */
+	r = pread(fd, v, 1, va_start + va_length - 1);
+	igt_assert_eq(r, 1);
+
+	for (i = 0; i < items; i++)
+		igt_assert_eq(v[i], va_start + i);
+
+	for (i = 0; i < items; i++)
+		v[i] = va_start + i + 1;
+
+	/* Negative pwrite - bad fd */
+	r = pwrite(fd + 123, v, va_length, va_start);
+	igt_assert(r < 0);
+
+	/* Negative pwrite - bad va_start */
+	r = pwrite(fd, v, va_length, -1);
+	igt_assert(r < 0);
+
+	/* Negative pwrite - zero va_start */
+	r = pwrite(fd, v, va_length, 0);
+	igt_assert(r < 0);
+
+	/* Negative pwrite - bad va_length */
+	r = pwrite(fd, v, va_length + 1, va_start);
+	igt_assert_eq(r, va_length);
+
+	/* Positive pwrite - zero va_length */
+	r = pwrite(fd, v, 0, va_start);
+	igt_assert_eq(r, 0);
+
+	/* Positive pwrite */
+	r = pwrite(fd, v, va_length, va_start);
+	igt_assert_eq(r, va_length);
+	fsync(fd);
+
+	close(fd);
+	free(v);
+}
+
+static void vm_trigger_access_parameters(struct xe_eudebug_debugger *d,
+		       struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		struct drm_xe_eudebug_event_vm_bind *eb;
+
+		igt_debug("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n",
+			  eo->vm_bind_ref_seqno,
+			  eo->addr,
+			  eo->range);
+
+		eb = (struct drm_xe_eudebug_event_vm_bind *)
+			xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno);
+		igt_assert(eb);
+
+		debugger_test_vma_parameters(d, eb->client_handle, eb->vm_handle,
+						   eo->addr, eo->range);
+		xe_eudebug_debugger_signal_stage(d, eo->addr);
+	}
+}
+
+/**
+ * SUBTEST: basic-vm-access-parameters
+ * Description:
+ *      Check negative scenarios of VM_OPEN ioctl and pread/pwrite usage.
+ */
+static void test_vm_access_parameters(int fd, unsigned int flags, int num_clients)
+{
+	struct drm_xe_engine_class_instance *hwe;
+
+	xe_for_each_engine(fd, hwe)
+		test_client_with_trigger(fd, flags, num_clients,
+					 vm_access_client,
+					 DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
+					 vm_trigger_access_parameters, hwe,
+					 false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP);
+}
+
+#define PAGE_SIZE 4096
+#define MDATA_SIZE (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM * PAGE_SIZE)
+static void metadata_access_client(struct xe_eudebug_client *c)
+{
+	const uint64_t addr = 0x1a0000;
+	struct drm_xe_vm_bind_op_ext_attach_debug *ext;
+	uint8_t *data;
+	size_t bo_size;
+	uint32_t bo, vm;
+	int fd, i;
+
+	fd = xe_eudebug_client_open_driver(c);
+	xe_device_get(fd);
+
+	bo_size = xe_get_default_alignment(fd);
+	vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+	bo = xe_bo_create(fd, vm, bo_size, system_memory(fd), 0);
+
+	ext = basic_vm_bind_metadata_ext_prepare(fd, c, &data, MDATA_SIZE);
+
+	xe_eudebug_client_vm_bind_flags(c, fd, vm, bo, 0, addr,
+					bo_size, 0, NULL, 0, to_user_pointer(ext));
+
+	for (i = 0; i < WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM; i++)
+		xe_eudebug_client_wait_stage(c, i);
+
+	xe_eudebug_client_vm_unbind(c, fd, vm, 0, addr, bo_size);
+
+	basic_vm_bind_metadata_ext_del(fd, c, ext, data);
+
+	close(bo);
+	xe_eudebug_client_vm_destroy(c, fd, vm);
+
+	xe_device_put(fd);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+static void debugger_test_metadata(struct xe_eudebug_debugger *d,
+				   uint64_t client_handle,
+				   uint64_t metadata_handle,
+				   uint64_t type,
+				   uint64_t len)
+{
+	struct drm_xe_eudebug_read_metadata rm = {
+		.client_handle = client_handle,
+		.metadata_handle = metadata_handle,
+		.size = len,
+	};
+	uint8_t *data;
+	int i;
+
+	data = malloc(len);
+	igt_assert(data);
+
+	rm.ptr = to_user_pointer(data);
+
+	igt_assert_eq(igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0);
+
+	/* syntetic check, test sets different size per metadata type */
+	igt_assert_eq((type + 1) * PAGE_SIZE, rm.size);
+
+	for (i = 0; i < rm.size; i++)
+		igt_assert_eq(data[i], 0xff & (i + (i > PAGE_SIZE)));
+
+	free(data);
+}
+
+static void metadata_read_trigger(struct xe_eudebug_debugger *d,
+				  struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_metadata *em = (void *)e;
+
+	/* syntetic check, test sets different size per metadata type */
+	igt_assert_eq((em->type + 1) * PAGE_SIZE, em->len);
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		debugger_test_metadata(d, em->client_handle, em->metadata_handle,
+				       em->type, em->len);
+		xe_eudebug_debugger_signal_stage(d, em->type);
+	}
+}
+
+static void metadata_read_on_vm_bind_trigger(struct xe_eudebug_debugger *d,
+					     struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_op_metadata *em = (void *)e;
+	struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e;
+	struct drm_xe_eudebug_event_vm_bind *eb;
+
+	/* For testing purpose client sets metadata_cookie = type */
+
+	/*
+	 * Metadata event has a reference to vm-bind-op event which has a reference
+	 * to vm-bind event which contains proper client-handle.
+	 */
+	eo = (struct drm_xe_eudebug_event_vm_bind_op *)
+		xe_eudebug_event_log_find_seqno(d->log, em->vm_bind_op_ref_seqno);
+	igt_assert(eo);
+	eb = (struct drm_xe_eudebug_event_vm_bind *)
+		xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno);
+	igt_assert(eb);
+
+	debugger_test_metadata(d,
+			       eb->client_handle,
+			       em->metadata_handle,
+			       em->metadata_cookie,
+			       MDATA_SIZE); /* max size */
+
+	xe_eudebug_debugger_signal_stage(d, em->metadata_cookie);
+}
+
+/**
+ * SUBTEST: read-metadata
+ * Description:
+ *      Exercise DRM_XE_EUDEBUG_IOCTL_READ_METADATA and debug metadata create|destroy events.
+ */
+static void test_metadata_read(int fd, unsigned int flags, int num_clients)
+{
+	test_client_with_trigger(fd, flags, num_clients, metadata_access_client,
+				 DRM_XE_EUDEBUG_EVENT_METADATA, metadata_read_trigger,
+				 NULL, true, 0);
+}
+
+/**
+ * SUBTEST: attach-debug-metadata
+ * Description:
+ *      Read debug metadata when vm_bind has it attached.
+ */
+static void test_metadata_attach(int fd, unsigned int flags, int num_clients)
+{
+	test_client_with_trigger(fd, flags, num_clients, metadata_access_client,
+				 DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
+				 metadata_read_on_vm_bind_trigger,
+				 NULL, true, 0);
+}
+
+#define STAGE_CLIENT_WAIT_ON_UFENCE_DONE 1337
+
+#define UFENCE_EVENT_COUNT_EXPECTED 4
+#define UFENCE_EVENT_COUNT_MAX 100
+
+struct ufence_bind {
+	struct drm_xe_sync f;
+	uint64_t addr;
+	uint64_t range;
+	uint64_t value;
+	struct {
+		uint64_t vm_sync;
+	} *fence_data;
+};
+
+static void client_wait_ufences(struct xe_eudebug_client *c,
+				int fd, struct ufence_bind *binds, int count)
+{
+	const int64_t default_fence_timeout_ns = MS_TO_NS(500);
+	int64_t timeout_ns;
+	int err;
+
+	/* Ensure that wait on unacked ufence times out */
+	for (int i = 0; i < count; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		timeout_ns = default_fence_timeout_ns;
+		err = __xe_wait_ufence(fd, &b->fence_data->vm_sync, b->f.timeline_value,
+				       0, &timeout_ns);
+		igt_assert_eq(err, -ETIME);
+		igt_assert_neq(b->fence_data->vm_sync, b->f.timeline_value);
+		igt_debug("wait #%d blocked on ack\n", i);
+	}
+
+	/* Wait on fence timed out, now tell the debugger to ack */
+	xe_eudebug_client_signal_stage(c, STAGE_CLIENT_WAIT_ON_UFENCE_DONE);
+
+	/* Check that ack unblocks ufence */
+	for (int i = 0; i < count; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		timeout_ns = MS_TO_NS(XE_EUDEBUG_DEFAULT_TIMEOUT_MS);
+		err = __xe_wait_ufence(fd, &b->fence_data->vm_sync, b->f.timeline_value,
+				       0, &timeout_ns);
+		igt_assert_eq(err, 0);
+		igt_assert_eq(b->fence_data->vm_sync, b->f.timeline_value);
+		igt_debug("wait #%d completed\n", i);
+	}
+}
+
+static struct ufence_bind *create_binds_with_ufence(int fd, int count)
+{
+	struct ufence_bind *binds;
+
+	binds = calloc(count, sizeof(*binds));
+	igt_assert(binds);
+
+	for (int i = 0; i < count; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		b->range = 0x1000;
+		b->addr = 0x100000 + b->range * i;
+		b->fence_data = aligned_alloc(xe_get_default_alignment(fd),
+					      sizeof(*b->fence_data));
+		igt_assert(b->fence_data);
+		memset(b->fence_data, 0, sizeof(*b->fence_data));
+
+		b->f.type = DRM_XE_SYNC_TYPE_USER_FENCE;
+		b->f.flags = DRM_XE_SYNC_FLAG_SIGNAL;
+		b->f.addr = to_user_pointer(&b->fence_data->vm_sync);
+		b->f.timeline_value = UFENCE_EVENT_COUNT_EXPECTED + i;
+	}
+
+	return binds;
+}
+
+static void basic_ufence_client(struct xe_eudebug_client *c)
+{
+	const unsigned int n = UFENCE_EVENT_COUNT_EXPECTED;
+	int fd = xe_eudebug_client_open_driver(c);
+	uint32_t vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+	size_t bo_size = n * xe_get_default_alignment(fd);
+	uint32_t bo = xe_bo_create(fd, 0, bo_size,
+				   system_memory(fd), 0);
+	struct ufence_bind *binds = create_binds_with_ufence(fd, n);
+
+	for (int i = 0; i < n; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		xe_eudebug_client_vm_bind_flags(c, fd, vm, bo, 0, b->addr, b->range, 0,
+						&b->f, 1, 0);
+	}
+
+	client_wait_ufences(c, fd, binds, n);
+
+	for (int i = 0; i < n; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		xe_eudebug_client_vm_unbind(c, fd, vm, 0, b->addr, b->range);
+	}
+
+	free(binds);
+	gem_close(fd, bo);
+	xe_eudebug_client_vm_destroy(c, fd, vm);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+struct ufence_priv {
+	struct drm_xe_eudebug_event_vm_bind_ufence ufence_events[UFENCE_EVENT_COUNT_MAX];
+	uint64_t ufence_event_seqno[UFENCE_EVENT_COUNT_MAX];
+	uint64_t ufence_event_vm_addr_start[UFENCE_EVENT_COUNT_MAX];
+	uint64_t ufence_event_vm_addr_range[UFENCE_EVENT_COUNT_MAX];
+	unsigned int ufence_event_count;
+	unsigned int vm_bind_op_count;
+	pthread_mutex_t mutex;
+};
+
+static struct ufence_priv *ufence_priv_create(void)
+{
+	struct ufence_priv *priv;
+
+	priv = mmap(0, ALIGN(sizeof(*priv), PAGE_SIZE),
+		    PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	igt_assert(priv);
+	memset(priv, 0, sizeof(*priv));
+	pthread_mutex_init(&priv->mutex, NULL);
+
+	return priv;
+}
+
+static void ufence_priv_destroy(struct ufence_priv *priv)
+{
+	munmap(priv, ALIGN(sizeof(*priv), PAGE_SIZE));
+}
+
+static void ack_fences(struct xe_eudebug_debugger *d)
+{
+	struct ufence_priv *priv = d->ptr;
+
+	for (int i = 0; i < priv->ufence_event_count; i++)
+		xe_eudebug_ack_ufence(d->fd, &priv->ufence_events[i]);
+}
+
+static void basic_ufence_trigger(struct xe_eudebug_debugger *d,
+				 struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e;
+	struct ufence_priv *priv = d->ptr;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
+		struct drm_xe_eudebug_event_vm_bind *eb;
+
+		xe_eudebug_event_to_str(e, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
+		igt_debug("ufence event received: %s\n", event_str);
+
+		xe_eudebug_assert_f(d, priv->ufence_event_count < UFENCE_EVENT_COUNT_EXPECTED,
+				    "surplus ufence event received: %s\n", event_str);
+		xe_eudebug_assert(d, ef->vm_bind_ref_seqno);
+
+		memcpy(&priv->ufence_events[priv->ufence_event_count++], ef, sizeof(*ef));
+
+		eb = (struct drm_xe_eudebug_event_vm_bind *)
+			xe_eudebug_event_log_find_seqno(d->log, ef->vm_bind_ref_seqno);
+		xe_eudebug_assert_f(d, eb, "vm bind event with seqno (%lld) not found\n",
+				    ef->vm_bind_ref_seqno);
+		xe_eudebug_assert_f(d, eb->flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE,
+				    "vm bind event does not have ufence: %s\n", event_str);
+	}
+}
+
+static int wait_for_ufence_events(struct ufence_priv *priv, int timeout_ms)
+{
+	int ret = -ETIMEDOUT;
+
+	igt_for_milliseconds(timeout_ms) {
+		pthread_mutex_lock(&priv->mutex);
+		if (priv->ufence_event_count == UFENCE_EVENT_COUNT_EXPECTED)
+			ret = 0;
+		pthread_mutex_unlock(&priv->mutex);
+
+		if (!ret)
+			break;
+		usleep(1000);
+	}
+
+	return ret;
+}
+
+/**
+ * SUBTEST: basic-vm-bind-ufence
+ * Description:
+ *      Give user fence in application and check if ufence ack works
+ */
+static void test_basic_ufence(int fd, unsigned int flags)
+{
+	struct xe_eudebug_debugger *d;
+	struct xe_eudebug_session *s;
+	struct xe_eudebug_client *c;
+	struct ufence_priv *priv;
+
+	priv = ufence_priv_create();
+	s = xe_eudebug_session_create(fd, basic_ufence_client, flags, priv);
+	c = s->c;
+	d = s->d;
+
+	xe_eudebug_debugger_add_trigger(d,
+					DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					basic_ufence_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(d, c), 0);
+	xe_eudebug_debugger_start_worker(d);
+	xe_eudebug_client_start(c);
+
+	xe_eudebug_debugger_wait_stage(s, STAGE_CLIENT_WAIT_ON_UFENCE_DONE);
+	xe_eudebug_assert_f(d, wait_for_ufence_events(priv, XE_EUDEBUG_DEFAULT_TIMEOUT_MS) == 0,
+			    "missing ufence events\n");
+	ack_fences(d);
+
+	xe_eudebug_client_wait_done(c);
+	xe_eudebug_debugger_stop_worker(d, 1);
+
+	xe_eudebug_event_log_print(d->log, true);
+	xe_eudebug_event_log_print(c->log, true);
+
+	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
+
+	xe_eudebug_session_destroy(s);
+	ufence_priv_destroy(priv);
+}
+
+struct vm_bind_clear_thread_priv {
+	struct drm_xe_engine_class_instance *hwe;
+	struct xe_eudebug_client *c;
+	pthread_t thread;
+	uint64_t region;
+	unsigned long sum;
+};
+
+struct vm_bind_clear_priv {
+	unsigned long unbind_count;
+	unsigned long bind_count;
+	unsigned long sum;
+};
+
+static struct vm_bind_clear_priv *vm_bind_clear_priv_create(void)
+{
+	struct vm_bind_clear_priv *priv;
+
+	priv = mmap(0, ALIGN(sizeof(*priv), PAGE_SIZE),
+		    PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	igt_assert(priv);
+	memset(priv, 0, sizeof(*priv));
+
+	return priv;
+}
+
+static void vm_bind_clear_priv_destroy(struct vm_bind_clear_priv *priv)
+{
+	munmap(priv, ALIGN(sizeof(*priv), PAGE_SIZE));
+}
+
+static void *vm_bind_clear_thread(void *data)
+{
+	const uint32_t CS_GPR0 = 0x600;
+	const size_t batch_size = 16;
+	struct drm_xe_sync uf_sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE, .flags = DRM_XE_SYNC_FLAG_SIGNAL,
+	};
+	struct vm_bind_clear_thread_priv *priv = data;
+	int fd = xe_eudebug_client_open_driver(priv->c);
+	uint32_t gtt_size = 1ull << min_t(uint32_t, xe_va_bits(fd), 48);
+	uint32_t vm = xe_eudebug_client_vm_create(priv->c, fd, 0, 0);
+	size_t bo_size = xe_bb_size(fd, batch_size);
+	unsigned long count = 0;
+	uint64_t *fence_data;
+
+	/* init uf_sync */
+	fence_data = aligned_alloc(xe_get_default_alignment(fd), sizeof(*fence_data));
+	igt_assert(fence_data);
+	uf_sync.timeline_value = 1337;
+	uf_sync.addr = to_user_pointer(fence_data);
+
+	igt_debug("Run on: %s%u\n", xe_engine_class_string(priv->hwe->engine_class),
+		  priv->hwe->engine_instance);
+
+	igt_until_timeout(5) {
+		struct drm_xe_exec_queue_create eq_create = { 0 };
+		uint32_t clean_bo = 0;
+		uint32_t batch_bo = 0;
+		uint64_t clean_offset, batch_offset;
+		uint32_t exec_queue;
+		uint32_t *map, *cs;
+		uint64_t delta;
+
+		/* calculate offsets (vma addresses) */
+		batch_offset = (random() * SZ_2M) & (gtt_size - 1);
+		/* XXX: for some platforms/memory regions batch offset '0' can be problematic */
+		if (batch_offset == 0)
+			batch_offset = SZ_2M;
+
+		do {
+			clean_offset = (random() * SZ_2M) & (gtt_size - 1);
+			if (clean_offset == 0)
+				clean_offset = SZ_2M;
+		} while (clean_offset == batch_offset);
+
+		batch_offset += random() % SZ_2M & -bo_size;
+		clean_offset += random() % SZ_2M & -bo_size;
+
+		delta = (random() % bo_size) & -4;
+
+		/* prepare clean bo */
+		clean_bo = xe_bo_create(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(priv->c, fd, vm, clean_bo, 0, clean_offset, bo_size,
+						0, &uf_sync, 1, 0);
+		xe_wait_ufence(fd, fence_data, uf_sync.timeline_value, 0,
+			       MS_TO_NS(XE_EUDEBUG_DEFAULT_TIMEOUT_MS));
+
+		/* prepare batch bo */
+		batch_bo = xe_bo_create(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(priv->c, fd, vm, batch_bo, 0, batch_offset, bo_size,
+						0, &uf_sync, 1, 0);
+		xe_wait_ufence(fd, fence_data, uf_sync.timeline_value, 0,
+			       MS_TO_NS(XE_EUDEBUG_DEFAULT_TIMEOUT_MS));
+
+		map = xe_bo_map(fd, batch_bo, bo_size);
+
+		cs = map;
+		*cs++ = MI_NOOP | 0xc5a3;
+		*cs++ = MI_LOAD_REGISTER_MEM_CMD | MI_LRI_LRM_CS_MMIO | 2;
+		*cs++ = CS_GPR0;
+		*cs++ = clean_offset + delta;
+		*cs++ = (clean_offset + delta) >> 32;
+		*cs++ = MI_STORE_REGISTER_MEM_CMD | MI_LRI_LRM_CS_MMIO | 2;
+		*cs++ = CS_GPR0;
+		*cs++ = batch_offset;
+		*cs++ = batch_offset >> 32;
+		*cs++ = MI_BATCH_BUFFER_END;
+
+		/* execute batch */
+		eq_create.width = 1;
+		eq_create.num_placements = 1;
+		eq_create.vm_id = vm;
+		eq_create.instances = to_user_pointer(priv->hwe);
+		exec_queue = xe_eudebug_client_exec_queue_create(priv->c, fd, &eq_create);
+		xe_exec_wait(fd, exec_queue, batch_offset);
+
+		igt_assert_eq(*map, 0);
+
+		/* cleanup */
+		xe_eudebug_client_exec_queue_destroy(priv->c, fd, &eq_create);
+		munmap(map, bo_size);
+
+		xe_eudebug_client_vm_unbind(priv->c, fd, vm, 0, batch_offset, bo_size);
+		gem_close(fd, batch_bo);
+
+		xe_eudebug_client_vm_unbind(priv->c, fd, vm, 0, clean_offset, bo_size);
+		gem_close(fd, clean_bo);
+
+		count++;
+	}
+
+	priv->sum = count;
+
+	free(fence_data);
+	xe_eudebug_client_close_driver(priv->c, fd);
+	return NULL;
+}
+
+static void vm_bind_clear_client(struct xe_eudebug_client *c)
+{
+	int fd = xe_eudebug_client_open_driver(c);
+	struct xe_device *xe_dev = xe_device_get(fd);
+	int count = xe_number_engines(fd) * xe_dev->mem_regions->num_mem_regions;
+	uint64_t memreg = all_memory_regions(fd);
+	struct vm_bind_clear_priv *priv = c->ptr;
+	int current = 0;
+	struct drm_xe_engine_class_instance *engine;
+	struct vm_bind_clear_thread_priv *threads;
+	uint64_t region;
+
+	threads = calloc(count, sizeof(*threads));
+	igt_assert(threads);
+	priv->sum = 0;
+
+	xe_for_each_mem_region(fd, memreg, region) {
+		xe_for_each_engine(fd, engine) {
+			threads[current].c = c;
+			threads[current].hwe = engine;
+			threads[current].region = region;
+
+			pthread_create(&threads[current].thread, NULL,
+				       vm_bind_clear_thread, &threads[current]);
+			current++;
+		}
+	}
+
+	for (current = 0; current < count; current++)
+		pthread_join(threads[current].thread, NULL);
+
+	xe_for_each_mem_region(fd, memreg, region) {
+		unsigned long sum = 0;
+
+		for (current = 0; current < count; current++)
+			if (threads[current].region == region)
+				sum += threads[current].sum;
+
+		igt_info("%s sampled %lu objects\n", xe_region_name(region), sum);
+		priv->sum += sum;
+	}
+
+	free(threads);
+	xe_device_put(fd);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+static void vm_bind_clear_test_trigger(struct xe_eudebug_debugger *d,
+				       struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e;
+	struct vm_bind_clear_priv *priv = d->ptr;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		if (random() & 1) {
+			struct drm_xe_eudebug_vm_open vo = { 0, };
+			uint32_t v = 0xc1c1c1c1;
+
+			struct drm_xe_eudebug_event_vm_bind *eb;
+			int fd, delta, r;
+
+			igt_debug("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n",
+				eo->vm_bind_ref_seqno,
+				eo->addr,
+				eo->range);
+
+			eb = (struct drm_xe_eudebug_event_vm_bind *)
+				xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno);
+			igt_assert(eb);
+
+			vo.client_handle = eb->client_handle;
+			vo.vm_handle = eb->vm_handle;
+
+			fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+			igt_assert_lte(0, fd);
+
+			delta = (random() % eo->range) & -4;
+			r = pread(fd, &v, sizeof(v), eo->addr + delta);
+			igt_assert_eq(r, sizeof(v));
+			igt_assert_eq_u32(v, 0);
+
+			close(fd);
+		}
+		priv->bind_count++;
+	}
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
+		priv->unbind_count++;
+}
+
+static void vm_bind_clear_ack_trigger(struct xe_eudebug_debugger *d,
+				      struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e;
+
+	xe_eudebug_ack_ufence(d->fd, ef);
+}
+
+/**
+ * SUBTEST: vm-bind-clear
+ * Description:
+ *      Check that fresh buffers we vm_bind into the ppGTT are always clear.
+ */
+static void test_vm_bind_clear(int fd)
+{
+	struct vm_bind_clear_priv *priv;
+	struct xe_eudebug_session *s;
+
+	priv = vm_bind_clear_priv_create();
+	s = xe_eudebug_session_create(fd, vm_bind_clear_client, 0, priv);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
+					vm_bind_clear_test_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					vm_bind_clear_ack_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+	xe_eudebug_client_start(s->c);
+
+	xe_eudebug_client_wait_done(s->c);
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	igt_assert_eq(priv->bind_count, priv->unbind_count);
+	igt_assert_eq(priv->sum * 2, priv->bind_count);
+
+	xe_eudebug_session_destroy(s);
+	vm_bind_clear_priv_destroy(priv);
+}
+
+#define UFENCE_CLIENT_VM_TEST_VAL_START 0xaaaaaaaa
+#define UFENCE_CLIENT_VM_TEST_VAL_END 0xbbbbbbbb
+
+static void vma_ufence_client(struct xe_eudebug_client *c)
+{
+	const unsigned int n = UFENCE_EVENT_COUNT_EXPECTED;
+	int fd = xe_eudebug_client_open_driver(c);
+	struct ufence_bind *binds = create_binds_with_ufence(fd, n);
+	uint32_t vm = xe_eudebug_client_vm_create(c, fd, 0, 0);
+	size_t bo_size = xe_get_default_alignment(fd);
+	uint64_t items = bo_size / sizeof(uint32_t);
+	uint32_t bo[UFENCE_EVENT_COUNT_EXPECTED];
+	uint32_t *ptr[UFENCE_EVENT_COUNT_EXPECTED];
+
+	for (int i = 0; i < n; i++) {
+		bo[i] = xe_bo_create(fd, 0, bo_size,
+				     system_memory(fd), 0);
+		ptr[i] = xe_bo_map(fd, bo[i], bo_size);
+		igt_assert(ptr[i]);
+		memset(ptr[i], UFENCE_CLIENT_VM_TEST_VAL_START, bo_size);
+	}
+
+	for (int i = 0; i < n; i++)
+		for (int j = 0; j < items; j++)
+			igt_assert_eq(ptr[i][j], UFENCE_CLIENT_VM_TEST_VAL_START);
+
+	for (int i = 0; i < n; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		xe_eudebug_client_vm_bind_flags(c, fd, vm, bo[i], 0, b->addr, b->range, 0,
+						&b->f, 1, 0);
+	}
+
+	/* Wait for acks on ufences */
+	for (int i = 0; i < n; i++) {
+		int err;
+		int64_t timeout_ns;
+		struct ufence_bind *b = &binds[i];
+
+		timeout_ns = MS_TO_NS(XE_EUDEBUG_DEFAULT_TIMEOUT_MS);
+		err = __xe_wait_ufence(fd, &b->fence_data->vm_sync, b->f.timeline_value,
+				       0, &timeout_ns);
+		igt_assert_eq(err, 0);
+		igt_assert_eq(b->fence_data->vm_sync, b->f.timeline_value);
+		igt_debug("wait #%d completed\n", i);
+
+		for (int j = 0; j < items; j++)
+			igt_assert_eq(ptr[i][j], UFENCE_CLIENT_VM_TEST_VAL_END);
+	}
+
+	for (int i = 0; i < n; i++) {
+		struct ufence_bind *b = &binds[i];
+
+		xe_eudebug_client_vm_unbind(c, fd, vm, 0, b->addr, b->range);
+	}
+
+	free(binds);
+
+	for (int i = 0; i < n; i++) {
+		munmap(ptr[i], bo_size);
+		gem_close(fd, bo[i]);
+	}
+
+	xe_eudebug_client_vm_destroy(c, fd, vm);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+static void debugger_test_vma_ufence(struct xe_eudebug_debugger *d,
+				     uint64_t client_handle,
+				     uint64_t vm_handle,
+				     uint64_t va_start,
+				     uint64_t va_length)
+{
+	struct drm_xe_eudebug_vm_open vo = { 0, };
+	uint32_t *v1, *v2;
+	uint32_t items = va_length / sizeof(uint32_t);
+	int fd;
+	int r, i;
+
+	v1 = malloc(va_length);
+	igt_assert(v1);
+	v2 = malloc(va_length);
+	igt_assert(v2);
+
+	vo.client_handle = client_handle;
+	vo.vm_handle = vm_handle;
+
+	fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+	igt_assert_lte(0, fd);
+
+	r = pread(fd, v1, va_length, va_start);
+	igt_assert_eq(r, va_length);
+
+	for (i = 0; i < items; i++)
+		igt_assert_eq(v1[i], UFENCE_CLIENT_VM_TEST_VAL_START);
+
+	memset(v1, UFENCE_CLIENT_VM_TEST_VAL_END, va_length);
+
+	r = pwrite(fd, v1, va_length, va_start);
+	igt_assert_eq(r, va_length);
+
+	lseek(fd, va_start, SEEK_SET);
+	r = read(fd, v2, va_length);
+	igt_assert_eq(r, va_length);
+
+	for (i = 0; i < items; i++)
+		igt_assert_eq_u64(v1[i], v2[i]);
+
+	fsync(fd);
+
+	close(fd);
+	free(v1);
+	free(v2);
+}
+
+static void vma_ufence_op_trigger(struct xe_eudebug_debugger *d,
+				  struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e;
+	struct ufence_priv *priv = d->ptr;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
+		struct drm_xe_eudebug_event_vm_bind *eb;
+		unsigned int op_count = priv->vm_bind_op_count++;
+
+		xe_eudebug_event_to_str(e, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
+		igt_debug("vm bind op event: ref %lld, addr 0x%llx, range 0x%llx, op_count %u\n",
+			  eo->vm_bind_ref_seqno,
+			  eo->addr,
+			  eo->range,
+			  op_count);
+		igt_debug("vm bind op event received: %s\n", event_str);
+		xe_eudebug_assert(d, eo->vm_bind_ref_seqno);
+		eb = (struct drm_xe_eudebug_event_vm_bind *)
+			xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno);
+
+		xe_eudebug_assert_f(d, eb, "vm bind event with seqno (%lld) not found\n",
+				    eo->vm_bind_ref_seqno);
+		xe_eudebug_assert_f(d, eb->flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE,
+				    "vm bind event does not have ufence: %s\n", event_str);
+
+		priv->ufence_event_seqno[op_count] = eo->vm_bind_ref_seqno;
+		priv->ufence_event_vm_addr_start[op_count] = eo->addr;
+		priv->ufence_event_vm_addr_range[op_count] = eo->range;
+	}
+}
+
+static void vma_ufence_trigger(struct xe_eudebug_debugger *d,
+			       struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e;
+	struct ufence_priv *priv = d->ptr;
+	unsigned int ufence_count = priv->ufence_event_count;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
+		struct drm_xe_eudebug_event_vm_bind *eb;
+		uint64_t addr = priv->ufence_event_vm_addr_start[ufence_count];
+		uint64_t range = priv->ufence_event_vm_addr_range[ufence_count];
+
+		xe_eudebug_event_to_str(e, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
+		igt_debug("ufence event received: %s\n", event_str);
+
+		xe_eudebug_assert_f(d, priv->ufence_event_count < UFENCE_EVENT_COUNT_EXPECTED,
+				    "surplus ufence event received: %s\n", event_str);
+		xe_eudebug_assert(d, ef->vm_bind_ref_seqno);
+
+		memcpy(&priv->ufence_events[priv->ufence_event_count++], ef, sizeof(*ef));
+
+		eb = (struct drm_xe_eudebug_event_vm_bind *)
+			xe_eudebug_event_log_find_seqno(d->log, ef->vm_bind_ref_seqno);
+		xe_eudebug_assert_f(d, eb, "vm bind event with seqno (%lld) not found\n",
+				    ef->vm_bind_ref_seqno);
+		xe_eudebug_assert_f(d, eb->flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE,
+				    "vm bind event does not have ufence: %s\n", event_str);
+		igt_debug("vm bind ufence event received with ref %lld, addr 0x%lx, range 0x%lx\n",
+			  ef->vm_bind_ref_seqno,
+			  addr,
+			  range);
+		debugger_test_vma_ufence(d, eb->client_handle, eb->vm_handle,
+					 addr, range);
+
+		xe_eudebug_ack_ufence(d->fd, ef);
+	}
+}
+/**
+ * SUBTEST: vma-ufence
+ * Description:
+ *      Intercept vm bind after receiving ufence event, then access target vm and write to it.
+ *      Then check on client side if the write was successful.
+ */
+static void test_vma_ufence(int fd, unsigned int flags)
+{
+	struct xe_eudebug_session *s;
+	struct ufence_priv *priv;
+
+	priv = ufence_priv_create();
+	s = xe_eudebug_session_create(fd, vma_ufence_client, flags, priv);
+
+	xe_eudebug_debugger_add_trigger(s->d,
+					DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
+					vma_ufence_op_trigger);
+	xe_eudebug_debugger_add_trigger(s->d,
+					DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					vma_ufence_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+	xe_eudebug_client_start(s->c);
+
+	xe_eudebug_client_wait_done(s->c);
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	xe_eudebug_event_log_print(s->d->log, true);
+	xe_eudebug_event_log_print(s->c->log, true);
+
+	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
+
+	xe_eudebug_session_destroy(s);
+	ufence_priv_destroy(priv);
+}
+
+igt_main
+{
+	bool was_enabled;
+	bool *multigpu_was_enabled;
+	int fd, gpu_count;
+
+	igt_fixture {
+		fd = drm_open_driver(DRIVER_XE);
+		was_enabled = xe_eudebug_enable(fd, true);
+	}
+
+	igt_subtest("sysfs-toggle")
+		test_sysfs_toggle(fd);
+
+	igt_subtest("basic-connect")
+		test_connect(fd);
+
+	igt_subtest("connect-user")
+		test_connect_user(fd);
+
+	igt_subtest("basic-close")
+		test_close(fd);
+
+	igt_subtest("basic-read-event")
+		test_read_event(fd);
+
+	igt_subtest("basic-client")
+		test_basic_sessions(fd, 0, 1, true);
+
+	igt_subtest("basic-client-th")
+		test_basic_sessions_th(fd, 0, 1, true);
+
+	igt_subtest("basic-vm-access")
+		test_vm_access(fd, 0, 1);
+
+	igt_subtest("basic-vm-access-userptr")
+		test_vm_access(fd, VM_BIND_OP_MAP_USERPTR, 1);
+
+	igt_subtest("basic-vm-access-parameters")
+		test_vm_access_parameters(fd, 0, 1);
+
+	igt_subtest("multiple-sessions")
+		test_basic_sessions(fd, CREATE_VMS | CREATE_EXEC_QUEUES, 4, true);
+
+	igt_subtest("basic-vms")
+		test_basic_sessions(fd, CREATE_VMS, 1, true);
+
+	igt_subtest("basic-exec-queues")
+		test_basic_sessions(fd, CREATE_EXEC_QUEUES, 1, true);
+
+	igt_subtest("basic-vm-bind")
+		test_basic_sessions(fd, VM_BIND, 1, true);
+
+	igt_subtest("basic-vm-bind-ufence")
+		test_basic_ufence(fd, 0);
+
+	igt_subtest("vma-ufence")
+		test_vma_ufence(fd, 0);
+
+	igt_subtest("vm-bind-clear")
+		test_vm_bind_clear(fd);
+
+	igt_subtest("basic-vm-bind-discovery")
+		test_basic_discovery(fd, VM_BIND, true);
+
+	igt_subtest("basic-vm-bind-metadata-discovery")
+		test_basic_discovery(fd, VM_BIND_METADATA, true);
+
+	igt_subtest("basic-vm-bind-vm-destroy")
+		test_basic_sessions(fd, VM_BIND_VM_DESTROY, 1, false);
+
+	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("read-metadata")
+		test_metadata_read(fd, 0, 1);
+
+	igt_subtest("attach-debug-metadata")
+		test_metadata_attach(fd, 0, 1);
+
+	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-empty")
+		test_empty_discovery(fd, DISCOVERY_CLOSE_CLIENT, 16);
+
+	igt_subtest("discovery-empty-clients")
+		test_empty_discovery(fd, DISCOVERY_DESTROY_RESOURCES, 16);
+
+	igt_fixture {
+		xe_eudebug_enable(fd, was_enabled);
+		drm_close_driver(fd);
+	}
+
+	igt_subtest_group {
+		igt_fixture {
+			gpu_count = drm_prepare_filtered_multigpu(DRIVER_XE);
+			igt_require(gpu_count >= 2);
+
+			multigpu_was_enabled = malloc(gpu_count * sizeof(bool));
+			igt_assert(multigpu_was_enabled);
+			for (int i = 0; i < gpu_count; i++) {
+				fd = drm_open_filtered_card(i);
+				multigpu_was_enabled[i] = xe_eudebug_enable(fd, true);
+				close(fd);
+			}
+		}
+
+		igt_subtest("multigpu-basic-client") {
+			igt_multi_fork(child, gpu_count) {
+				fd = drm_open_filtered_card(child);
+				igt_assert_f(fd > 0, "cannot open gpu-%d, errno=%d\n",
+					     child, errno);
+				igt_assert(is_xe_device(fd));
+
+				test_basic_sessions(fd, 0, 1, true);
+				close(fd);
+			}
+			igt_waitchildren();
+		}
+
+		igt_subtest("multigpu-basic-client-many") {
+			igt_multi_fork(child, gpu_count) {
+				fd = drm_open_filtered_card(child);
+				igt_assert_f(fd > 0, "cannot open gpu-%d, errno=%d\n",
+					     child, errno);
+				igt_assert(is_xe_device(fd));
+
+				test_basic_sessions(fd, 0, 4, true);
+				close(fd);
+			}
+			igt_waitchildren();
+		}
+
+		igt_fixture {
+			for (int i = 0; i < gpu_count; i++) {
+				fd = drm_open_filtered_card(i);
+				xe_eudebug_enable(fd, multigpu_was_enabled[i]);
+				close(fd);
+			}
+			free(multigpu_was_enabled);
+		}
+	}
+}
diff --git a/tests/meson.build b/tests/meson.build
index e649466be..35bf8ed35 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -279,6 +279,7 @@ intel_xe_progs = [
 	'xe_dma_buf_sync',
 	'xe_debugfs',
 	'xe_drm_fdinfo',
+	'xe_eudebug',
 	'xe_evict',
 	'xe_evict_ccs',
 	'xe_exec_atomic',
-- 
2.34.1

[PATCH i-g-t v3 06/14] lib/gpgpu_shader: Extend shader building library

[Christoph Manszewski]

Add shader building functions and iga64 code used by eudebug subtests.

Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
---
 lib/gpgpu_shader.c          | 386 +++++++++++++++++++++++++++++++++++-
 lib/gpgpu_shader.h          |  24 ++-
 lib/iga64_generated_codes.c | 321 +++++++++++++++++++++++++++++-
 3 files changed, 727 insertions(+), 4 deletions(-)

diff --git a/lib/gpgpu_shader.c b/lib/gpgpu_shader.c
index 991455c49..3b16db593 100644
--- a/lib/gpgpu_shader.c
+++ b/lib/gpgpu_shader.c
@@ -7,10 +7,16 @@
 
 #include <i915_drm.h>
 
+#include "igt_map.h"
 #include "ioctl_wrappers.h"
 #include "gpgpu_shader.h"
 #include "gpu_cmds.h"
 
+struct label_entry {
+	uint32_t id;
+	uint32_t offset;
+};
+
 #define IGA64_ARG0 0xc0ded000
 #define IGA64_ARG_MASK 0xffffff00
 
@@ -32,7 +38,7 @@ static void gpgpu_shader_extend(struct gpgpu_shader *shdr)
 	igt_assert(shdr->code);
 }
 
-void
+uint32_t
 __emit_iga64_code(struct gpgpu_shader *shdr, struct iga64_template const *tpls,
 		  int argc, uint32_t *argv)
 {
@@ -60,6 +66,8 @@ __emit_iga64_code(struct gpgpu_shader *shdr, struct iga64_template const *tpls,
 	}
 
 	shdr->size += tpls->size;
+
+	return tpls->size;
 }
 
 static uint32_t fill_sip(struct intel_bb *ibb,
@@ -235,6 +243,7 @@ struct gpgpu_shader *gpgpu_shader_create(int fd)
 	shdr->gen_ver = 100 * info->graphics_ver + info->graphics_rel;
 	shdr->max_size = 16 * 4;
 	shdr->code = malloc(4 * shdr->max_size);
+	shdr->labels = igt_map_create(igt_map_hash_32, igt_map_equal_32);
 	igt_assert(shdr->code);
 	return shdr;
 }
@@ -251,6 +260,70 @@ void gpgpu_shader_destroy(struct gpgpu_shader *shdr)
 	free(shdr);
 }
 
+/**
+ * gpgpu_shader_dump:
+ * @shdr: shader to be printed
+ *
+ * Print shader instructions from @shdr in hex.
+ */
+void gpgpu_shader_dump(struct gpgpu_shader *shdr)
+{
+	for (int i = 0; i < shdr->size / 4; i++)
+		igt_info("0x%08x 0x%08x 0x%08x 0x%08x\n",
+			 shdr->instr[i][0], shdr->instr[i][1],
+			 shdr->instr[i][2], shdr->instr[i][3]);
+}
+
+/**
+ * gpgpu_shader__breakpoint_on:
+ * @shdr: shader to create breakpoint in
+ * @cmd_no: index of the instruction to break on
+ *
+ * Insert a breakpoint on the @cmd_no'th instruction within @shdr.
+ */
+void gpgpu_shader__breakpoint_on(struct gpgpu_shader *shdr, uint32_t cmd_no)
+{
+	shdr->instr[cmd_no][0] |= 1<<30;
+}
+
+/**
+ * gpgpu_shader__breakpoint:
+ * @shdr: shader to create breakpoint in
+ *
+ * Insert a breakpoint on the last instruction in @shdr.
+ */
+void gpgpu_shader__breakpoint(struct gpgpu_shader *shdr)
+{
+	gpgpu_shader__breakpoint_on(shdr, shdr->size / 4 - 1);
+}
+
+/**
+ * gpgpu_shader__wait:
+ * @shdr: shader to be modified
+ *
+ * Append wait instruction to @shader. This instruction raises attention
+ * and stops execution.
+ */
+void gpgpu_shader__wait(struct gpgpu_shader *shdr)
+{
+	emit_iga64_code(shdr, sync_host, "	\n\
+(W)	sync.host	        null		\n\
+	");
+}
+
+/**
+ * gpgpu_shader__nop:
+ * @shdr: shader to be modified
+ *
+ * Append a no-op instruction to @shdr.
+ */
+void gpgpu_shader__nop(struct gpgpu_shader *shdr)
+{
+	emit_iga64_code(shdr, nop, "	\n\
+(W)	nop				\n\
+	");
+}
+
 /**
  * gpgpu_shader__eot:
  * @shdr: shader to be modified
@@ -269,6 +342,247 @@ void gpgpu_shader__eot(struct gpgpu_shader *shdr)
 	");
 }
 
+/**
+ * gpgpu_shader__label:
+ * @shdr: shader to be modified
+ * @label_id: id of the label to be created
+ *
+ * Create a label for the last instruction within @shdr.
+ */
+void gpgpu_shader__label(struct gpgpu_shader *shdr, int label_id)
+{
+	struct label_entry *l = malloc(sizeof(*l));
+
+	l->id = label_id;
+	l->offset = shdr->size;
+	igt_map_insert(shdr->labels, &l->id, l);
+}
+
+#define OPCODE(x) (x & 0x7f)
+#define OPCODE_JUMP_INDEXED 0x20
+static void __patch_indexed_jump(struct gpgpu_shader *shdr, int label_id,
+				 uint32_t jump_iga64_size)
+{
+	struct label_entry *l;
+	uint32_t *start, *end, *label;
+	int32_t relative;
+
+	l = igt_map_search(shdr->labels, &label_id);
+	igt_assert(l);
+
+	igt_assert(jump_iga64_size % 4 == 0);
+
+	label = shdr->code + l->offset;
+	end = shdr->code + shdr->size;
+	start = end - jump_iga64_size;
+
+	for (; start < end; start += 4)
+		if (OPCODE(*start) == OPCODE_JUMP_INDEXED) {
+			relative = (label - start) * 4;
+			*(start + 3) = relative;
+			break;
+		}
+}
+
+/**
+ * gpgpu_shader__jump:
+ * @shdr: shader to be modified
+ * @label_id: label to jump to
+ *
+ * Append jump instruction to @shdr. Jump to instruction with label @label_id.
+ */
+void gpgpu_shader__jump(struct gpgpu_shader *shdr, int label_id)
+{
+	size_t shader_size;
+
+	shader_size = emit_iga64_code(shdr, jump, "	\n\
+L0:							\n\
+(W)	jmpi        L0					\n\
+	");
+
+	__patch_indexed_jump(shdr, label_id, shader_size);
+}
+
+/**
+ * gpgpu_shader__jump_neq:
+ * @shdr: shader to be modified
+ * @label_id: label to jump to
+ * @y_offset: offset within target buffer in rows
+ * @value: expected value
+ *
+ * Append jump instruction to @shdr. Jump to instruction with label @label_id
+ * when @value is not equal to dword stored at @dw_offset within the surface.
+ *
+ * Note: @dw_offset has to be aligned to 4
+ */
+void gpgpu_shader__jump_neq(struct gpgpu_shader *shdr, int label_id,
+			    uint32_t y_offset, uint32_t value)
+{
+	uint32_t size;
+
+	size = emit_iga64_code(shdr, jump_dw_neq, "					\n\
+L0:											\n\
+(W)		mov (16|M0)              r30.0<1>:ud    0x0:ud				\n\
+#if GEN_VER < 2000 // Media Block Write							\n\
+	// Y offset of the block in rows := thread group id Y				\n\
+(W)		mov (1|M0)               r30.1<1>:ud    ARG(0):ud			\n\
+	// block width [0,63] representing 1 to 64 bytes, we want dword			\n\
+(W)		mov (1|M0)               r30.2<1>:ud    0x3:ud				\n\
+	// FFTID := FFTID from R0 header						\n\
+(W)		mov (1|M0)               r30.4<1>:ud    r0.5<0;1,0>:ud  		\n\
+(W)		send.dc1 (16|M0)         r31     r30      null    0x0	0x2190000	\n\
+#else // Typed 2D Block Store								\n\
+	// Store X and Y block start (160:191 and 192:223)				\n\
+(W)            mov (2|M0)               r30.6<1>:ud    ARG(0):ud			\n\
+	// Store X and Y block size (224:231 and 232:239)				\n\
+(W)            mov (1|M0)               r30.7<1>:ud    0x3:ud				\n\
+(W)            send.tgm (16|M0)         r31     r30    null:0    0x0    0x62100003	\n\
+#endif											\n\
+	// clear the flag register							\n\
+(W)		mov (1|M0)               f0.0<1>:ud    0x0:ud				\n\
+(W)		cmp (1|M0)    (ne)f0.0   null<1>:ud     r31.0<0;1,0>:ud   ARG(1):ud	\n\
+(W&f0.0)	jmpi                     L0						\n\
+	", y_offset, value);
+
+	__patch_indexed_jump(shdr, label_id, size);
+}
+
+/**
+ * gpgpu_shader__loop_begin:
+ * @shdr: shader to be modified
+ * @label_id: id of the label to be created
+ *
+ * Begin a counting loop in @shdr. All subsequent instructions will constitute
+ * the loop body up until 'gpgpu_shader__loop_end' gets called. The first
+ * instruction of the loop will be at label @label_id.
+ */
+void gpgpu_shader__loop_begin(struct gpgpu_shader *shdr, int label_id)
+{
+	emit_iga64_code(shdr, clear_r40, "		\n\
+L0:							\n\
+(W)	mov (1|M0)               r40:ud    0x0:ud	\n\
+	");
+
+	gpgpu_shader__label(shdr, label_id);
+}
+
+/**
+ * gpgpu_shader__loop_end:
+ * @shdr: shader to be modified
+ * @label_id: label id passed to 'gpgpu_shader__loop_begin'
+ * @iter: iteration count
+ *
+ * End loop body in @shdr.
+ */
+void gpgpu_shader__loop_end(struct gpgpu_shader *shdr, int label_id, uint32_t iter)
+{
+	uint32_t size;
+
+	size = emit_iga64_code(shdr, inc_r40_jump_neq, "				\n\
+L0:											\n\
+(W)		add (1|M0)              r40:ud          r40.0<0;1,0>:ud 0x1:ud		\n\
+(W)		mov (1|M0)              f0.0<1>:ud      0x0:ud				\n\
+(W)		cmp (1|M0)    (ne)f0.0   null<1>:ud     r40.0<0;1,0>:ud   ARG(0):ud	\n\
+(W&f0.0)	jmpi                     L0						\n\
+	", iter);
+
+	__patch_indexed_jump(shdr, label_id, size);
+}
+
+/**
+ * gpgpu_shader__common_target_write:
+ * @shdr: shader to be modified
+ * @y_offset: write target offset within target buffer in rows
+ * @value: oword to be written
+ *
+ * Write the oword stored in @value to the target buffer at @y_offset.
+ */
+void gpgpu_shader__common_target_write(struct gpgpu_shader *shdr,
+				       uint32_t y_offset, const uint32_t value[4])
+{
+	emit_iga64_code(shdr, common_target_write, "				\n\
+(W)	mov (16|M0)		r31.0<1>:ud	0x0:ud				\n\
+(W)	mov (1|M0)		r31.0<1>:ud	ARG(1):ud			\n\
+(W)	mov (1|M0)		r31.1<1>:ud	ARG(2):ud			\n\
+(W)	mov (1|M0)		r31.2<1>:ud	ARG(3):ud			\n\
+(W)	mov (1|M0)		r31.3<1>:ud	ARG(4):ud			\n\
+(W)	mov (16|M0)		r30.0<1>:ud	0x0:ud				\n\
+#if GEN_VER < 2000 // Media Block Write						\n\
+	// Y offset of the block in rows					\n\
+(W)	mov (1|M0)		r30.1<1>:ud	ARG(0):ud			\n\
+	// block width [0,63] representing 1 to 64 bytes			\n\
+(W)	mov (1|M0)		r30.2<1>:ud	0xf:ud				\n\
+	// FFTID := FFTID from R0 header					\n\
+(W)	mov (1|M0)		r30.4<1>:ud	r0.5<0;1,0>:ud			\n\
+	// written value							\n\
+(W)	send.dc1 (16|M0)	null	r30	src1_null  0x0	0x40A8000	\n\
+#else	// Typed 2D Block Store							\n\
+	// Store X and Y block start (160:191 and 192:223)			\n\
+(W)	mov (2|M0)              r30.6<1>:ud     ARG(0):ud			\n\
+	// Store X and Y block size (224:231 and 232:239)			\n\
+(W)	mov (1|M0)              r30.7<1>:ud     0xf:ud				\n\
+(W)	send.tgm (16|M0)        null    r30     null:0  0x0     0x64000007	\n\
+#endif										\n\
+	", y_offset, value[0], value[1], value[2], value[3]);
+}
+
+/**
+ * gpgpu_shader__common_target_write_u32:
+ * @shdr: shader to be modified
+ * @y_offset: write target offset within target buffer in rows
+ * @value: dword to be written
+ *
+ * Fill oword at @y_offset with dword stored in @value.
+ */
+void gpgpu_shader__common_target_write_u32(struct gpgpu_shader *shdr,
+					   uint32_t y_offset, uint32_t value)
+{
+	const uint32_t owblock[4] = {
+		value, value, value, value
+	};
+	gpgpu_shader__common_target_write(shdr, y_offset, owblock);
+}
+
+/**
+ * gpgpu_shader__write_aip:
+ * @shdr: shader to be modified
+ * @y_offset: write target offset within the surface in rows
+ *
+ * Write address instruction pointer to row tg_id_y + @y_offset.
+ */
+void gpgpu_shader__write_aip(struct gpgpu_shader *shdr, uint32_t y_offset)
+{
+	emit_iga64_code(shdr, media_block_write_aip, "				\n\
+	// Payload								\n\
+(W)	mov (1|M0)               r5.0<1>:ud    cr0.2:ud				\n\
+#if GEN_VER < 2000 // Media Block Write						\n\
+	// X offset of the block in bytes := (thread group id X << ARG(0))	\n\
+(W)	shl (1|M0)               r4.0<1>:ud    r0.1<0;1,0>:ud    0x2:ud		\n\
+	// Y offset of the block in rows := thread group id Y			\n\
+(W)	mov (1|M0)               r4.1<1>:ud    r0.6<0;1,0>:ud			\n\
+(W)	add (1|M0)               r4.1<1>:ud    r4.1<0;1,0>:ud    ARG(0):ud	\n\
+	// block width [0,63] representing 1 to 64 bytes			\n\
+(W)	mov (1|M0)               r4.2<1>:ud    0x3:ud				\n\
+	// FFTID := FFTID from R0 header					\n\
+(W)	mov (1|M0)               r4.4<1>:ud    r0.5<0;1,0>:ud			\n\
+(W)	send.dc1 (16|M0)         null     r4   src1_null 0       0x40A8000	\n\
+#else // Typed 2D Block Store							\n\
+	// Load r2.0-3 with tg id X << ARG(0)					\n\
+(W)	shl (1|M0)               r2.0<1>:ud    r0.1<0;1,0>:ud    0x2:ud		\n\
+	// Load r2.4-7 with tg id Y + ARG(1):ud					\n\
+(W)	mov (1|M0)               r2.1<1>:ud    r0.6<0;1,0>:ud			\n\
+(W)	add (1|M0)               r2.1<1>:ud    r2.1<0;1,0>:ud    ARG(0):ud	\n\
+	// payload setup							\n\
+(W)	mov (16|M0)              r4.0<1>:ud    0x0:ud				\n\
+	// Store X and Y block start (160:191 and 192:223)			\n\
+(W)	mov (2|M0)               r4.5<1>:ud    r2.0<2;2,1>:ud			\n\
+	// Store X and Y block max_size (224:231 and 232:239)			\n\
+(W)	mov (1|M0)               r4.7<1>:ud    0x3:ud				\n\
+(W)	send.tgm (16|M0)         null     r4   null:0    0    0x64000007	\n\
+#endif										\n\
+	", y_offset);
+}
+
 /**
  * gpgpu_shader__write_dword:
  * @shdr: shader to be modified
@@ -313,3 +627,73 @@ void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
 #endif										\n\
 	", 2, y_offset, 3, value, value, value, value);
 }
+
+/**
+ * gpgpu_shader__end_system_routine:
+ * @shdr: shader to be modified
+ * @breakpoint_suppress: breakpoint suppress flag
+ *
+ * Return from system routine. To prevent infinite jumping to the system
+ * routine on a breakpoint, @breakpoint_suppres flag has to be set.
+ */
+void gpgpu_shader__end_system_routine(struct gpgpu_shader *shdr,
+				      bool breakpoint_suppress)
+{
+	/*
+	 * set breakpoint suppress bit to avoid an endless loop
+	 * when sip was invoked by a breakpoint
+	 */
+	if (breakpoint_suppress)
+		emit_iga64_code(shdr, breakpoint_suppress, "			\n\
+(W)	or  (1|M0)               cr0.0<1>:ud   cr0.0<0;1,0>:ud   0x8000:ud	\n\
+		");
+
+	emit_iga64_code(shdr, end_system_routine, "				\n\
+(W)	and (1|M0)               cr0.1<1>:ud   cr0.1<0;1,0>:ud   ARG(0):ud	\n\
+	// return to an application						\n\
+(W)	and (1|M0)               cr0.0<1>:ud   cr0.0<0;1,0>:ud   0x7FFFFFFD:ud	\n\
+	", 0x7fffff | (1 << 26)); /* clear all exceptions, except read only bit */
+}
+
+/**
+ * gpgpu_shader__end_system_routine_step_if_eq:
+ * @shdr: shader to be modified
+ * @y_offset: offset within target buffer in rows
+ * @value: expected value for single stepping execution
+ *
+ * Return from system routine. Don't clear breakpoint exception when @value
+ * is equal to value stored at @dw_offset. This triggers the system routine
+ * after the subsequent instruction, resulting in single stepping execution.
+ */
+void gpgpu_shader__end_system_routine_step_if_eq(struct gpgpu_shader *shdr,
+						 uint32_t y_offset,
+						 uint32_t value)
+{
+	emit_iga64_code(shdr, end_system_routine_step_if_eq, "				\n\
+(W)		or  (1|M0)               cr0.0<1>:ud   cr0.0<0;1,0>:ud   0x8000:ud	\n\
+(W)		and (1|M0)               cr0.1<1>:ud   cr0.1<0;1,0>:ud   ARG(0):ud	\n\
+(W)		mov (16|M0)              r30.0<1>:ud    0x0:ud				\n\
+#if GEN_VER < 2000 // Media Block Write							\n\
+		// Y offset of the block in rows := thread group id Y			\n\
+(W)		mov (1|M0)               r30.1<1>:ud    ARG(1):ud			\n\
+		// block width [0,63] representing 1 to 64 bytes, we want dword		\n\
+(W)		mov (1|M0)               r30.2<1>:ud    0x3:ud				\n\
+		// FFTID := FFTID from R0 header					\n\
+(W)		mov (1|M0)               r30.4<1>:ud    r0.5<0;1,0>:ud			\n\
+(W)		send.dc1 (16|M0)         r31     r30      null    0x0	0x2190000	\n\
+#else	// Typed 2D Block Store								\n\
+		// Store X and Y block start (160:191 and 192:223)			\n\
+(W)		mov (2|M0)               r30.6<1>:ud    ARG(1):ud			\n\
+		// Store X and Y block size (224:231 and 232:239)			\n\
+(W)		mov (1|M0)               r30.7<1>:ud    0x3:ud				\n\
+(W)		send.tgm (16|M0)         r31     r30    null:0    0x0    0x62100003	\n\
+#endif											\n\
+		// clear the flag register						\n\
+(W)		mov (1|M0)               f0.0<1>:ud    0x0:ud				\n\
+(W)		cmp (1|M0)    (ne)f0.0   null<1>:ud     r31.0<0;1,0>:ud   ARG(2):ud	\n\
+(W&f0.0)	and (1|M0)              cr0.1<1>:ud     cr0.1<0;1,0>:ud   ARG(3):ud	\n\
+		// return to an application						\n\
+(W)		and (1|M0)               cr0.0<1>:ud   cr0.0<0;1,0>:ud   0x7FFFFFFD:ud	\n\
+	", 0x807fffff, /* leave breakpoint exception */
+	y_offset, value, 0x7fffff /* clear all exceptions */ );
+}
diff --git a/lib/gpgpu_shader.h b/lib/gpgpu_shader.h
index 255f93b4d..e4ca0be4c 100644
--- a/lib/gpgpu_shader.h
+++ b/lib/gpgpu_shader.h
@@ -21,6 +21,7 @@ struct gpgpu_shader {
 		uint32_t *code;
 		uint32_t (*instr)[4];
 	};
+	struct igt_map *labels;
 };
 
 struct iga64_template {
@@ -31,7 +32,7 @@ struct iga64_template {
 
 #pragma GCC diagnostic ignored "-Wnested-externs"
 
-void
+uint32_t
 __emit_iga64_code(struct gpgpu_shader *shdr, const struct iga64_template *tpls,
 		  int argc, uint32_t *argv);
 
@@ -56,8 +57,27 @@ void gpgpu_shader_exec(struct intel_bb *ibb,
 		       struct gpgpu_shader *sip,
 		       uint64_t ring, bool explicit_engine);
 
+void gpgpu_shader__wait(struct gpgpu_shader *shdr);
+void gpgpu_shader__breakpoint_on(struct gpgpu_shader *shdr, uint32_t cmd_no);
+void gpgpu_shader__breakpoint(struct gpgpu_shader *shdr);
+void gpgpu_shader__nop(struct gpgpu_shader *shdr);
 void gpgpu_shader__eot(struct gpgpu_shader *shdr);
+void gpgpu_shader__common_target_write(struct gpgpu_shader *shdr,
+				       uint32_t y_offset, const uint32_t value[4]);
+void gpgpu_shader__common_target_write_u32(struct gpgpu_shader *shdr,
+				     uint32_t y_offset, uint32_t value);
+void gpgpu_shader__end_system_routine(struct gpgpu_shader *shdr,
+				      bool breakpoint_suppress);
+void gpgpu_shader__end_system_routine_step_if_eq(struct gpgpu_shader *shdr,
+						 uint32_t dw_offset,
+						 uint32_t value);
+void gpgpu_shader__write_aip(struct gpgpu_shader *shdr, uint32_t y_offset);
 void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
 			       uint32_t y_offset);
-
+void gpgpu_shader__label(struct gpgpu_shader *shdr, int label_id);
+void gpgpu_shader__jump(struct gpgpu_shader *shdr, int label_id);
+void gpgpu_shader__jump_neq(struct gpgpu_shader *shdr, int label_id,
+			    uint32_t dw_offset, uint32_t value);
+void gpgpu_shader__loop_begin(struct gpgpu_shader *shdr, int label_id);
+void gpgpu_shader__loop_end(struct gpgpu_shader *shdr, int label_id, uint32_t iter);
 #endif /* GPGPU_SHADER_H */
diff --git a/lib/iga64_generated_codes.c b/lib/iga64_generated_codes.c
index 6a08c4844..fea436dee 100644
--- a/lib/iga64_generated_codes.c
+++ b/lib/iga64_generated_codes.c
@@ -3,7 +3,95 @@
 
 #include "gpgpu_shader.h"
 
-#define MD5_SUM_IGA64_ASMS 2c503cbfbd7b3043e9a52188ae4da7a8
+#define MD5_SUM_IGA64_ASMS 61a15534954fe7c6bd0e983fbfd54c27
+
+struct iga64_template const iga64_code_end_system_routine_step_if_eq[] = {
+	{ .gen_ver = 2000, .size = 44, .code = (const uint32_t []) {
+		0x80000966, 0x80018220, 0x02008000, 0x00008000,
+		0x80000965, 0x80118220, 0x02008010, 0xc0ded000,
+		0x80100961, 0x1e054220, 0x00000000, 0x00000000,
+		0x80040061, 0x1e654220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1e754220, 0x00000000, 0x00000003,
+		0x80132031, 0x1f0c0000, 0xd0061e8c, 0x04000000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80008070, 0x00018220, 0x22001f04, 0xc0ded002,
+		0x84000965, 0x80118220, 0x02008010, 0xc0ded003,
+		0x80000965, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1272, .size = 48, .code = (const uint32_t []) {
+		0x80000966, 0x80018220, 0x02008000, 0x00008000,
+		0x80000965, 0x80118220, 0x02008010, 0xc0ded000,
+		0x80100961, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e154220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1e254220, 0x00000000, 0x00000003,
+		0x80000061, 0x1e450220, 0x00000054, 0x00000000,
+		0x80132031, 0x1f0c0000, 0xc0001e0c, 0x02400000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80008070, 0x00018220, 0x22001f04, 0xc0ded002,
+		0x84000965, 0x80118220, 0x02008010, 0xc0ded003,
+		0x80000965, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 52, .code = (const uint32_t []) {
+		0x80000966, 0x80018220, 0x02008000, 0x00008000,
+		0x80000965, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80040961, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e254220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1e454220, 0x00000000, 0x00000003,
+		0x80000061, 0x1e850220, 0x000000a4, 0x00000000,
+		0x80001901, 0x00010000, 0x00000000, 0x00000000,
+		0x80044031, 0x1f0c0000, 0xc0001e0c, 0x02400000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80002070, 0x00018220, 0x22001f04, 0xc0ded002,
+		0x81000965, 0x80218220, 0x02008020, 0xc0ded003,
+		0x80000965, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 48, .code = (const uint32_t []) {
+		0x80000166, 0x80018220, 0x02008000, 0x00008000,
+		0x80000165, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80040161, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e254220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1e454220, 0x00000000, 0x00000003,
+		0x80000061, 0x1e850220, 0x000000a4, 0x00000000,
+		0x80049031, 0x1f0c0000, 0xc0001e0c, 0x02400000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80002070, 0x00018220, 0x22001f04, 0xc0ded002,
+		0x81000165, 0x80218220, 0x02008020, 0xc0ded003,
+		0x80000165, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_end_system_routine[] = {
+	{ .gen_ver = 1272, .size = 12, .code = (const uint32_t []) {
+		0x80000965, 0x80118220, 0x02008010, 0xc0ded000,
+		0x80000965, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 12, .code = (const uint32_t []) {
+		0x80000965, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80000965, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 12, .code = (const uint32_t []) {
+		0x80000165, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80000165, 0x80018220, 0x02008000, 0x7ffffffd,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_breakpoint_suppress[] = {
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x80000966, 0x80018220, 0x02008000, 0x00008000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x80000166, 0x80018220, 0x02008000, 0x00008000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
 
 struct iga64_template const iga64_code_media_block_write[] = {
 	{ .gen_ver = 2000, .size = 56, .code = (const uint32_t []) {
@@ -86,6 +174,215 @@ struct iga64_template const iga64_code_media_block_write[] = {
 	}}
 };
 
+struct iga64_template const iga64_code_media_block_write_aip[] = {
+	{ .gen_ver = 2000, .size = 44, .code = (const uint32_t []) {
+		0x80000961, 0x05050220, 0x00008020, 0x00000000,
+		0x80000969, 0x02058220, 0x02000014, 0x00000002,
+		0x80000061, 0x02150220, 0x00000064, 0x00000000,
+		0x80001940, 0x02158220, 0x02000214, 0xc0ded000,
+		0x80100061, 0x04054220, 0x00000000, 0x00000000,
+		0x80041a61, 0x04550220, 0x00220205, 0x00000000,
+		0x80000061, 0x04754220, 0x00000000, 0x00000003,
+		0x80132031, 0x00000000, 0xd00e0494, 0x04000000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1272, .size = 40, .code = (const uint32_t []) {
+		0x80000961, 0x05050220, 0x00008020, 0x00000000,
+		0x80000969, 0x04058220, 0x02000014, 0x00000002,
+		0x80000061, 0x04150220, 0x00000064, 0x00000000,
+		0x80001940, 0x04158220, 0x02000414, 0xc0ded000,
+		0x80000061, 0x04254220, 0x00000000, 0x00000003,
+		0x80000061, 0x04450220, 0x00000054, 0x00000000,
+		0x80132031, 0x00000000, 0xc0000414, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 44, .code = (const uint32_t []) {
+		0x80000961, 0x05050220, 0x00008040, 0x00000000,
+		0x80000969, 0x04058220, 0x02000024, 0x00000002,
+		0x80000061, 0x04250220, 0x000000c4, 0x00000000,
+		0x80001940, 0x04258220, 0x02000424, 0xc0ded000,
+		0x80000061, 0x04454220, 0x00000000, 0x00000003,
+		0x80000061, 0x04850220, 0x000000a4, 0x00000000,
+		0x80001901, 0x00010000, 0x00000000, 0x00000000,
+		0x80044031, 0x00000000, 0xc0000414, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 40, .code = (const uint32_t []) {
+		0x80000161, 0x05050220, 0x00008040, 0x00000000,
+		0x80000169, 0x04058220, 0x02000024, 0x00000002,
+		0x80000061, 0x04250220, 0x000000c4, 0x00000000,
+		0x80000140, 0x04258220, 0x02000424, 0xc0ded000,
+		0x80000061, 0x04454220, 0x00000000, 0x00000003,
+		0x80000061, 0x04850220, 0x000000a4, 0x00000000,
+		0x80049031, 0x00000000, 0xc0000414, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_common_target_write[] = {
+	{ .gen_ver = 2000, .size = 48, .code = (const uint32_t []) {
+		0x80100061, 0x1f054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1f054220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1f154220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x1f254220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x1f354220, 0x00000000, 0xc0ded004,
+		0x80100061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80040061, 0x1e654220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e754220, 0x00000000, 0x0000000f,
+		0x80132031, 0x00000000, 0xd00e1e94, 0x04000000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1272, .size = 52, .code = (const uint32_t []) {
+		0x80100061, 0x1f054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1f054220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1f154220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x1f254220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x1f354220, 0x00000000, 0xc0ded004,
+		0x80100061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e154220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e254220, 0x00000000, 0x0000000f,
+		0x80000061, 0x1e450220, 0x00000054, 0x00000000,
+		0x80132031, 0x00000000, 0xc0001e14, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 56, .code = (const uint32_t []) {
+		0x80040061, 0x1f054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1f054220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1f254220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x1f454220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x1f654220, 0x00000000, 0xc0ded004,
+		0x80040061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e254220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e454220, 0x00000000, 0x0000000f,
+		0x80000061, 0x1e850220, 0x000000a4, 0x00000000,
+		0x80001901, 0x00010000, 0x00000000, 0x00000000,
+		0x80044031, 0x00000000, 0xc0001e14, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 52, .code = (const uint32_t []) {
+		0x80040061, 0x1f054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1f054220, 0x00000000, 0xc0ded001,
+		0x80000061, 0x1f254220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x1f454220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x1f654220, 0x00000000, 0xc0ded004,
+		0x80040061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e254220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e454220, 0x00000000, 0x0000000f,
+		0x80000061, 0x1e850220, 0x000000a4, 0x00000000,
+		0x80049031, 0x00000000, 0xc0001e14, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_inc_r40_jump_neq[] = {
+	{ .gen_ver = 1272, .size = 20, .code = (const uint32_t []) {
+		0x80000040, 0x28058220, 0x02002804, 0x00000001,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80001a70, 0x00018220, 0x22002804, 0xc0ded000,
+		0x84000020, 0x00004000, 0x00000000, 0xffffffd0,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 20, .code = (const uint32_t []) {
+		0x80000040, 0x28058220, 0x02002804, 0x00000001,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80001a70, 0x00018220, 0x22002804, 0xc0ded000,
+		0x81000020, 0x00004000, 0x00000000, 0xffffffd0,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 20, .code = (const uint32_t []) {
+		0x80000040, 0x28058220, 0x02002804, 0x00000001,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80000270, 0x00018220, 0x22002804, 0xc0ded000,
+		0x81000020, 0x00004000, 0x00000000, 0xffffffd0,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_clear_r40[] = {
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x80000061, 0x28054220, 0x00000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x80000061, 0x28054220, 0x00000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_jump_dw_neq[] = {
+	{ .gen_ver = 2000, .size = 32, .code = (const uint32_t []) {
+		0x80100061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80040061, 0x1e654220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e754220, 0x00000000, 0x00000003,
+		0x80132031, 0x1f0c0000, 0xd0061e8c, 0x04000000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80008070, 0x00018220, 0x22001f04, 0xc0ded001,
+		0x84000020, 0x00004000, 0x00000000, 0xffffffa0,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1272, .size = 36, .code = (const uint32_t []) {
+		0x80100061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e154220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e254220, 0x00000000, 0x00000003,
+		0x80000061, 0x1e450220, 0x00000054, 0x00000000,
+		0x80132031, 0x1f0c0000, 0xc0001e0c, 0x02400000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80008070, 0x00018220, 0x22001f04, 0xc0ded001,
+		0x84000020, 0x00004000, 0x00000000, 0xffffff90,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 40, .code = (const uint32_t []) {
+		0x80040061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e254220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e454220, 0x00000000, 0x00000003,
+		0x80000061, 0x1e850220, 0x000000a4, 0x00000000,
+		0x80001901, 0x00010000, 0x00000000, 0x00000000,
+		0x80044031, 0x1f0c0000, 0xc0001e0c, 0x02400000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80002070, 0x00018220, 0x22001f04, 0xc0ded001,
+		0x81000020, 0x00004000, 0x00000000, 0xffffff80,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 36, .code = (const uint32_t []) {
+		0x80040061, 0x1e054220, 0x00000000, 0x00000000,
+		0x80000061, 0x1e254220, 0x00000000, 0xc0ded000,
+		0x80000061, 0x1e454220, 0x00000000, 0x00000003,
+		0x80000061, 0x1e850220, 0x000000a4, 0x00000000,
+		0x80049031, 0x1f0c0000, 0xc0001e0c, 0x02400000,
+		0x80000061, 0x30014220, 0x00000000, 0x00000000,
+		0x80002070, 0x00018220, 0x22001f04, 0xc0ded001,
+		0x81000020, 0x00004000, 0x00000000, 0xffffff90,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_jump[] = {
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x80000020, 0x00004000, 0x00000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x80000020, 0x00004000, 0x00000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
 struct iga64_template const iga64_code_eot[] = {
 	{ .gen_ver = 2000, .size = 8, .code = (const uint32_t []) {
 		0x800c0061, 0x70050220, 0x00460005, 0x00000000,
@@ -110,3 +407,25 @@ struct iga64_template const iga64_code_eot[] = {
 		0x80049031, 0x00000004, 0x7020700c, 0x10000000,
 	}}
 };
+
+struct iga64_template const iga64_code_nop[] = {
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x00000060, 0x00000000, 0x00000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x00000060, 0x00000000, 0x00000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_sync_host[] = {
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x80000001, 0x00010000, 0xf0000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x80000001, 0x00010000, 0xf0000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
-- 
2.34.1

[PATCH i-g-t v3 07/14] lib/gpgpu_shader: Add write_on_exception template

[Christoph Manszewski]

From: Andrzej Hajda <andrzej.hajda@intel.com>

Writing specific value to memory location on unexpected value in exception
register allows to report errors from inside shader or siplet.

Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 lib/gpgpu_shader.c          | 56 ++++++++++++++++++++++++++
 lib/gpgpu_shader.h          |  2 +
 lib/iga64_generated_codes.c | 79 ++++++++++++++++++++++++++++++++++++-
 3 files changed, 136 insertions(+), 1 deletion(-)

diff --git a/lib/gpgpu_shader.c b/lib/gpgpu_shader.c
index 3b16db593..a98abc57e 100644
--- a/lib/gpgpu_shader.c
+++ b/lib/gpgpu_shader.c
@@ -628,6 +628,62 @@ void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
 	", 2, y_offset, 3, value, value, value, value);
 }
 
+/**
+ * gpgpu_shader__write_on_exception:
+ * @shdr: shader to be modified
+ * @value: dword to be written
+ * @y_offset: write target offset within the surface in rows
+ * @mask: mask to be applied on exception register
+ * @expected: expected value of exception register with @mask applied
+ *
+ * Check if bits specified by @mask in exception register(cr0.1) are equal
+ * to provided ones: cr0.1 & @mask == @expected,
+ * if yes fill dword in (row, column/dword) == (tg_id_y + @y_offset, tg_id_x).
+ */
+void gpgpu_shader__write_on_exception(struct gpgpu_shader *shdr, uint32_t value,
+				      uint32_t y_offset, uint32_t mask, uint32_t expected)
+{
+	emit_iga64_code(shdr, write_on_exception, "					\n\
+	// Payload									\n\
+(W)	mov (1|M0)               r5.0<1>:ud    ARG(3):ud				\n\
+(W)	mov (1|M0)               r5.1<1>:ud    ARG(4):ud				\n\
+(W)	mov (1|M0)               r5.2<1>:ud    ARG(5):ud				\n\
+(W)	mov (1|M0)               r5.3<1>:ud    ARG(6):ud				\n\
+#if GEN_VER < 2000 // prepare Media Block Write						\n\
+	// X offset of the block in bytes := (thread group id X << ARG(0))		\n\
+(W)	shl (1|M0)               r4.0<1>:ud    r0.1<0;1,0>:ud    ARG(0):ud		\n\
+	// Y offset of the block in rows := thread group id Y				\n\
+(W)	mov (1|M0)               r4.1<1>:ud    r0.6<0;1,0>:ud				\n\
+(W)	add (1|M0)               r4.1<1>:ud    r4.1<0;1,0>:ud   ARG(1):ud		\n\
+	// block width [0,63] representing 1 to 64 bytes				\n\
+(W)	mov (1|M0)               r4.2<1>:ud    ARG(2):ud				\n\
+	// FFTID := FFTID from R0 header						\n\
+(W)	mov (1|M0)               r4.4<1>:ud    r0.5<0;1,0>:ud				\n\
+#else // prepare Typed 2D Block Store							\n\
+	// Load r2.0-3 with tg id X << ARG(0)						\n\
+(W)	shl (1|M0)               r2.0<1>:ud    r0.1<0;1,0>:ud    ARG(0):ud		\n\
+	// Load r2.4-7 with tg id Y + ARG(1):ud						\n\
+(W)	mov (1|M0)               r2.1<1>:ud    r0.6<0;1,0>:ud				\n\
+(W)	add (1|M0)               r2.1<1>:ud    r2.1<0;1,0>:ud    ARG(1):ud		\n\
+	// payload setup								\n\
+(W)	mov (16|M0)              r4.0<1>:ud    0x0:ud					\n\
+	// Store X and Y block start (160:191 and 192:223)				\n\
+(W)	mov (2|M0)               r4.5<1>:ud    r2.0<2;2,1>:ud				\n\
+	// Store X and Y block max_size (224:231 and 232:239)				\n\
+(W)	mov (1|M0)               r4.7<1>:ud    ARG(2):ud				\n\
+#endif											\n\
+	// Check if masked exception is equal to provided value and write conditionally \n\
+(W)      and (1|M0)              r3.0<1>:ud     cr0.1<0;1,0>:ud ARG(7):ud		\n\
+(W)      mov (1|M0)              f0.0<1>:ud     0x0:ud					\n\
+(W)      cmp (1|M0)     (eq)f0.0 null:ud        r3.0<0;1,0>:ud  ARG(8):ud		\n\
+#if GEN_VER < 2000 // Media Block Write							\n\
+(W&f0.0) send.dc1 (16|M0)        null     r4   src1_null 0    0x40A8000			\n\
+#else // Typed 2D Block Store								\n\
+(W&f0.0) send.tgm (16|M0)        null     r4   null:0    0    0x64000007		\n\
+#endif											\n\
+	", 2, y_offset, 3, value, value, value, value, mask, expected);
+}
+
 /**
  * gpgpu_shader__end_system_routine:
  * @shdr: shader to be modified
diff --git a/lib/gpgpu_shader.h b/lib/gpgpu_shader.h
index e4ca0be4c..76ff4989e 100644
--- a/lib/gpgpu_shader.h
+++ b/lib/gpgpu_shader.h
@@ -74,6 +74,8 @@ void gpgpu_shader__end_system_routine_step_if_eq(struct gpgpu_shader *shdr,
 void gpgpu_shader__write_aip(struct gpgpu_shader *shdr, uint32_t y_offset);
 void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
 			       uint32_t y_offset);
+void gpgpu_shader__write_on_exception(struct gpgpu_shader *shdr, uint32_t dw,
+			       uint32_t y_offset, uint32_t mask, uint32_t value);
 void gpgpu_shader__label(struct gpgpu_shader *shdr, int label_id);
 void gpgpu_shader__jump(struct gpgpu_shader *shdr, int label_id);
 void gpgpu_shader__jump_neq(struct gpgpu_shader *shdr, int label_id,
diff --git a/lib/iga64_generated_codes.c b/lib/iga64_generated_codes.c
index fea436dee..71429d442 100644
--- a/lib/iga64_generated_codes.c
+++ b/lib/iga64_generated_codes.c
@@ -3,7 +3,7 @@
 
 #include "gpgpu_shader.h"
 
-#define MD5_SUM_IGA64_ASMS 61a15534954fe7c6bd0e983fbfd54c27
+#define MD5_SUM_IGA64_ASMS 88529cc180578939c0b8c4bb29da7db6
 
 struct iga64_template const iga64_code_end_system_routine_step_if_eq[] = {
 	{ .gen_ver = 2000, .size = 44, .code = (const uint32_t []) {
@@ -93,6 +93,83 @@ struct iga64_template const iga64_code_breakpoint_suppress[] = {
 	}}
 };
 
+struct iga64_template const iga64_code_write_on_exception[] = {
+	{ .gen_ver = 2000, .size = 68, .code = (const uint32_t []) {
+		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x05154220, 0x00000000, 0xc0ded004,
+		0x80000061, 0x05254220, 0x00000000, 0xc0ded005,
+		0x80000061, 0x05354220, 0x00000000, 0xc0ded006,
+		0x80000069, 0x02058220, 0x02000014, 0xc0ded000,
+		0x80000061, 0x02150220, 0x00000064, 0x00000000,
+		0x80001940, 0x02158220, 0x02000214, 0xc0ded001,
+		0x80100061, 0x04054220, 0x00000000, 0x00000000,
+		0x80041a61, 0x04550220, 0x00220205, 0x00000000,
+		0x80000061, 0x04754220, 0x00000000, 0xc0ded002,
+		0x80000965, 0x03058220, 0x02008010, 0xc0ded007,
+		0x80000961, 0x30014220, 0x00000000, 0x00000000,
+		0x80001a70, 0x00018220, 0x12000304, 0xc0ded008,
+		0x84134031, 0x00000000, 0xd00e0494, 0x04000000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1272, .size = 64, .code = (const uint32_t []) {
+		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x05154220, 0x00000000, 0xc0ded004,
+		0x80000061, 0x05254220, 0x00000000, 0xc0ded005,
+		0x80000061, 0x05354220, 0x00000000, 0xc0ded006,
+		0x80000069, 0x04058220, 0x02000014, 0xc0ded000,
+		0x80000061, 0x04150220, 0x00000064, 0x00000000,
+		0x80001940, 0x04158220, 0x02000414, 0xc0ded001,
+		0x80000061, 0x04254220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x04450220, 0x00000054, 0x00000000,
+		0x80000965, 0x03058220, 0x02008010, 0xc0ded007,
+		0x80000961, 0x30014220, 0x00000000, 0x00000000,
+		0x80001a70, 0x00018220, 0x12000304, 0xc0ded008,
+		0x84134031, 0x00000000, 0xc0000414, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 68, .code = (const uint32_t []) {
+		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x05254220, 0x00000000, 0xc0ded004,
+		0x80000061, 0x05454220, 0x00000000, 0xc0ded005,
+		0x80000061, 0x05654220, 0x00000000, 0xc0ded006,
+		0x80000069, 0x04058220, 0x02000024, 0xc0ded000,
+		0x80000061, 0x04250220, 0x000000c4, 0x00000000,
+		0x80001940, 0x04258220, 0x02000424, 0xc0ded001,
+		0x80000061, 0x04454220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x04850220, 0x000000a4, 0x00000000,
+		0x80000965, 0x03058220, 0x02008020, 0xc0ded007,
+		0x80000961, 0x30014220, 0x00000000, 0x00000000,
+		0x80001a70, 0x00018220, 0x12000304, 0xc0ded008,
+		0x80001a01, 0x00010000, 0x00000000, 0x00000000,
+		0x81044031, 0x00000000, 0xc0000414, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 64, .code = (const uint32_t []) {
+		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
+		0x80000061, 0x05254220, 0x00000000, 0xc0ded004,
+		0x80000061, 0x05454220, 0x00000000, 0xc0ded005,
+		0x80000061, 0x05654220, 0x00000000, 0xc0ded006,
+		0x80000069, 0x04058220, 0x02000024, 0xc0ded000,
+		0x80000061, 0x04250220, 0x000000c4, 0x00000000,
+		0x80000140, 0x04258220, 0x02000424, 0xc0ded001,
+		0x80000061, 0x04454220, 0x00000000, 0xc0ded002,
+		0x80000061, 0x04850220, 0x000000a4, 0x00000000,
+		0x80000165, 0x03058220, 0x02008020, 0xc0ded007,
+		0x80000161, 0x30014220, 0x00000000, 0x00000000,
+		0x80000270, 0x00018220, 0x12000304, 0xc0ded008,
+		0x8104a031, 0x00000000, 0xc0000414, 0x02a00000,
+		0x80000001, 0x00010000, 0x20000000, 0x00000000,
+		0x80000001, 0x00010000, 0x30000000, 0x00000000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
 struct iga64_template const iga64_code_media_block_write[] = {
 	{ .gen_ver = 2000, .size = 56, .code = (const uint32_t []) {
 		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
-- 
2.34.1

[PATCH i-g-t v3 08/14] lib/gpgpu_shader: Add set/clear exception register (cr0.1) helpers

[Christoph Manszewski]

From: Andrzej Hajda <andrzej.hajda@intel.com>

To allow enabling and handling exceptions from shader and siplet
proper helpers should be provided.

Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 lib/gpgpu_shader.c          | 28 ++++++++++++++++++++++++++++
 lib/gpgpu_shader.h          |  2 ++
 lib/iga64_generated_codes.c | 32 +++++++++++++++++++++++++++++++-
 3 files changed, 61 insertions(+), 1 deletion(-)

diff --git a/lib/gpgpu_shader.c b/lib/gpgpu_shader.c
index a98abc57e..40161c52b 100644
--- a/lib/gpgpu_shader.c
+++ b/lib/gpgpu_shader.c
@@ -628,6 +628,34 @@ void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
 	", 2, y_offset, 3, value, value, value, value);
 }
 
+/**
+ * gpgpu_shader__clear_exception:
+ * @shdr: shader to be modified
+ * @value: exception bits to be cleared
+ *
+ * Clear provided bits in exception register: cr0.1 &= ~value.
+ */
+void gpgpu_shader__clear_exception(struct gpgpu_shader *shdr, uint32_t value)
+{
+	emit_iga64_code(shdr, clear_exception, "		\n\
+(W)	and (1|M0) cr0.1<1>:ud cr0.1<0;1,0>:ud ARG(0):ud	\n\
+	", ~value);
+}
+
+/**
+ * gpgpu_shader__set_exception:
+ * @shdr: shader to be modified
+ * @value: exception bits to be set
+ *
+ * Set provided bits in exception register: cr0.1 |= value.
+ */
+void gpgpu_shader__set_exception(struct gpgpu_shader *shdr, uint32_t value)
+{
+	emit_iga64_code(shdr, set_exception, "		\n\
+(W)	or (1|M0) cr0.1<1>:ud cr0.1<0;1,0>:ud ARG(0):ud	\n\
+	", value);
+}
+
 /**
  * gpgpu_shader__write_on_exception:
  * @shdr: shader to be modified
diff --git a/lib/gpgpu_shader.h b/lib/gpgpu_shader.h
index 76ff4989e..0bbeae66f 100644
--- a/lib/gpgpu_shader.h
+++ b/lib/gpgpu_shader.h
@@ -66,6 +66,8 @@ void gpgpu_shader__common_target_write(struct gpgpu_shader *shdr,
 				       uint32_t y_offset, const uint32_t value[4]);
 void gpgpu_shader__common_target_write_u32(struct gpgpu_shader *shdr,
 				     uint32_t y_offset, uint32_t value);
+void gpgpu_shader__clear_exception(struct gpgpu_shader *shdr, uint32_t value);
+void gpgpu_shader__set_exception(struct gpgpu_shader *shdr, uint32_t value);
 void gpgpu_shader__end_system_routine(struct gpgpu_shader *shdr,
 				      bool breakpoint_suppress);
 void gpgpu_shader__end_system_routine_step_if_eq(struct gpgpu_shader *shdr,
diff --git a/lib/iga64_generated_codes.c b/lib/iga64_generated_codes.c
index 71429d442..2cba1b315 100644
--- a/lib/iga64_generated_codes.c
+++ b/lib/iga64_generated_codes.c
@@ -3,7 +3,7 @@
 
 #include "gpgpu_shader.h"
 
-#define MD5_SUM_IGA64_ASMS 88529cc180578939c0b8c4bb29da7db6
+#define MD5_SUM_IGA64_ASMS 6cfe013e2a99076bcdf69ecdbf4333cf
 
 struct iga64_template const iga64_code_end_system_routine_step_if_eq[] = {
 	{ .gen_ver = 2000, .size = 44, .code = (const uint32_t []) {
@@ -170,6 +170,36 @@ struct iga64_template const iga64_code_write_on_exception[] = {
 	}}
 };
 
+struct iga64_template const iga64_code_set_exception[] = {
+	{ .gen_ver = 1272, .size = 8, .code = (const uint32_t []) {
+		0x80000966, 0x80118220, 0x02008010, 0xc0ded000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x80000966, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x80000166, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
+struct iga64_template const iga64_code_clear_exception[] = {
+	{ .gen_ver = 1272, .size = 8, .code = (const uint32_t []) {
+		0x80000965, 0x80118220, 0x02008010, 0xc0ded000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 1250, .size = 8, .code = (const uint32_t []) {
+		0x80000965, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80000901, 0x00010000, 0x00000000, 0x00000000,
+	}},
+	{ .gen_ver = 0, .size = 8, .code = (const uint32_t []) {
+		0x80000165, 0x80218220, 0x02008020, 0xc0ded000,
+		0x80000101, 0x00010000, 0x00000000, 0x00000000,
+	}}
+};
+
 struct iga64_template const iga64_code_media_block_write[] = {
 	{ .gen_ver = 2000, .size = 56, .code = (const uint32_t []) {
 		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
-- 
2.34.1

[PATCH i-g-t v3 09/14] lib/intel_batchbuffer: Add helper to get pointer at specified offset

[Christoph Manszewski]

From: Andrzej Hajda <andrzej.hajda@intel.com>

The helper will be used to access data placed in batchbuffer.

Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
Cc: Mika Kuoppala <mika.kuoppala@intel.com>
Cc: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 lib/intel_batchbuffer.h | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/lib/intel_batchbuffer.h b/lib/intel_batchbuffer.h
index cb32206e5..7caf6c518 100644
--- a/lib/intel_batchbuffer.h
+++ b/lib/intel_batchbuffer.h
@@ -353,6 +353,11 @@ static inline uint32_t intel_bb_offset(struct intel_bb *ibb)
 	return (uint32_t) ((uint8_t *) ibb->ptr - (uint8_t *) ibb->batch);
 }
 
+static inline void *intel_bb_ptr_get(struct intel_bb *ibb, uint32_t offset)
+{
+	return ((uint8_t *) ibb->batch + offset);
+}
+
 static inline void intel_bb_ptr_set(struct intel_bb *ibb, uint32_t offset)
 {
 	ibb->ptr = (void *) ((uint8_t *) ibb->batch + offset);
-- 
2.34.1

[PATCH i-g-t v3 10/14] lib/gpgpu_shader: Allow enabling illegal opcode exceptions in shader

[Christoph Manszewski]

From: Andrzej Hajda <andrzej.hajda@intel.com>

Illegal opcode exceptions can be enabled in interface descriptor data
passed to COMPUTE_WALKER instruction.

Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
Cc: Mika Kuoppala <mika.kuoppala@intel.com>
Cc: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 lib/gpgpu_shader.c | 4 ++++
 lib/gpgpu_shader.h | 1 +
 2 files changed, 5 insertions(+)

diff --git a/lib/gpgpu_shader.c b/lib/gpgpu_shader.c
index 40161c52b..e53c61553 100644
--- a/lib/gpgpu_shader.c
+++ b/lib/gpgpu_shader.c
@@ -103,6 +103,7 @@ __xelp_gpgpu_execfunc(struct intel_bb *ibb,
 		      struct gpgpu_shader *sip,
 		      uint64_t ring, bool explicit_engine)
 {
+	struct gen8_interface_descriptor_data *idd;
 	uint32_t interface_descriptor, sip_offset;
 	uint64_t engine;
 
@@ -113,6 +114,8 @@ __xelp_gpgpu_execfunc(struct intel_bb *ibb,
 	interface_descriptor = gen8_fill_interface_descriptor(ibb, target,
 							      shdr->instr,
 							      4 * shdr->size);
+	idd = intel_bb_ptr_get(ibb, interface_descriptor);
+	idd->desc2.illegal_opcode_exception_enable = shdr->illegal_opcode_exception_enable;
 
 	if (sip && sip->size)
 		sip_offset = fill_sip(ibb, sip->instr, 4 * sip->size);
@@ -163,6 +166,7 @@ __xehp_gpgpu_execfunc(struct intel_bb *ibb,
 
 	xehp_fill_interface_descriptor(ibb, target, shdr->instr,
 				       4 * shdr->size, &idd);
+	idd.desc2.illegal_opcode_exception_enable = shdr->illegal_opcode_exception_enable;
 
 	if (sip && sip->size)
 		sip_offset = fill_sip(ibb, sip->instr, 4 * sip->size);
diff --git a/lib/gpgpu_shader.h b/lib/gpgpu_shader.h
index 0bbeae66f..26a117a0b 100644
--- a/lib/gpgpu_shader.h
+++ b/lib/gpgpu_shader.h
@@ -22,6 +22,7 @@ struct gpgpu_shader {
 		uint32_t (*instr)[4];
 	};
 	struct igt_map *labels;
+	bool illegal_opcode_exception_enable;
 };
 
 struct iga64_template {
-- 
2.34.1

[PATCH i-g-t v3 11/14] tests/xe_exec_sip: Extend SIP interaction testing

[Christoph Manszewski]

Extend xe_exec_sip test by adding subtests that check SIP interaction
sanity with regard to resets and hardware debugging capabilities like
breakpoints, and invalid instruction exceptions.

Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
---
 tests/intel/xe_exec_sip.c | 332 +++++++++++++++++++++++++++++++++++---
 1 file changed, 310 insertions(+), 22 deletions(-)

diff --git a/tests/intel/xe_exec_sip.c b/tests/intel/xe_exec_sip.c
index 4b599e7f6..0db0dc4b8 100644
--- a/tests/intel/xe_exec_sip.c
+++ b/tests/intel/xe_exec_sip.c
@@ -21,6 +21,7 @@
 #include "gpgpu_shader.h"
 #include "igt.h"
 #include "igt_sysfs.h"
+#include "xe/xe_eudebug.h"
 #include "xe/xe_ioctl.h"
 #include "xe/xe_query.h"
 
@@ -30,9 +31,29 @@
 #define COLOR_C4 0xc4
 
 #define SHADER_CANARY 0x01010101
+#define SIP_CANARY 0x02020202
 
 #define NSEC_PER_MSEC (1000 * 1000ull)
 
+#define SHADER_BREAKPOINT 0
+#define SHADER_WRITE 1
+#define SHADER_WAIT 2
+#define SHADER_INV_INSTR_DISABLED 3
+#define SHADER_INV_INSTR_THREAD_ENABLED 4
+#define SHADER_INV_INSTR_WALKER_ENABLED 5
+#define SHADER_HANG 6
+#define SIP_WRITE 7
+#define SIP_NULL 8
+#define SIP_WAIT 9
+#define SIP_HEAVY 10
+#define SIP_INV_INSTR 11
+
+#define F_SUBMIT_TWICE	(1 << 0)
+
+/* Control Register cr0.1 bits for exception handling */
+#define ILLEGAL_OPCODE_ENABLE BIT(12)
+#define ILLEGAL_OPCODE_STATUS BIT(28)
+
 static struct intel_buf *
 create_fill_buf(int fd, int width, int height, uint8_t color)
 {
@@ -52,24 +73,109 @@ create_fill_buf(int fd, int width, int height, uint8_t color)
 	return buf;
 }
 
-static struct gpgpu_shader *get_shader(int fd)
+static struct gpgpu_shader *get_shader(int fd, const int shadertype)
 {
 	static struct gpgpu_shader *shader;
+	uint32_t bad;
 
 	shader = gpgpu_shader_create(fd);
+	if (shadertype == SHADER_INV_INSTR_WALKER_ENABLED)
+		shader->illegal_opcode_exception_enable = true;
+
 	gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
+
+	switch (shadertype) {
+	case SHADER_HANG:
+		gpgpu_shader__label(shader, 0);
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__jump(shader, 0);
+		break;
+	case SHADER_WAIT:
+		gpgpu_shader__wait(shader);
+		break;
+	case SHADER_WRITE:
+		break;
+	case SHADER_BREAKPOINT:
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__breakpoint(shader);
+		break;
+	case SHADER_INV_INSTR_THREAD_ENABLED:
+		gpgpu_shader__set_exception(shader, ILLEGAL_OPCODE_ENABLE);
+		/* fall through */
+	case SHADER_INV_INSTR_DISABLED:
+	case SHADER_INV_INSTR_WALKER_ENABLED:
+		bad = (shadertype == SHADER_INV_INSTR_DISABLED) ? ILLEGAL_OPCODE_ENABLE : 0;
+		gpgpu_shader__write_on_exception(shader, 1, 0, ILLEGAL_OPCODE_ENABLE, bad);
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__nop(shader);
+		/* modify second nop, set only opcode bits[6:0] */
+		shader->instr[shader->size/4 - 1][0] = 0x7f;
+		/* SIP should clear exception bit */
+		bad = ILLEGAL_OPCODE_STATUS;
+		gpgpu_shader__write_on_exception(shader, 2, 0, ILLEGAL_OPCODE_STATUS, bad);
+		break;
+	}
+
 	gpgpu_shader__eot(shader);
 	return shader;
 }
 
-static uint32_t gpgpu_shader(int fd, struct intel_bb *ibb, unsigned int threads,
-			     unsigned int width, unsigned int height)
+static struct gpgpu_shader *get_sip(int fd, const int siptype,
+				    const int shadertype, unsigned int y_offset)
+{
+	static struct gpgpu_shader *sip;
+
+	if (siptype == SIP_NULL)
+		return NULL;
+
+	sip = gpgpu_shader_create(fd);
+	gpgpu_shader__write_dword(sip, SIP_CANARY, y_offset);
+
+	switch (siptype) {
+	case SIP_WRITE:
+		break;
+	case SIP_WAIT:
+		gpgpu_shader__wait(sip);
+		break;
+	case SIP_HEAVY:
+		/* Depending on the generation, the production sip
+		 * executes between 145 to 157 instructions.
+		 * It performs at most 45 data port writes and 5 data port reads.
+		 * Make sure our heavy sip is at least twice heavy as production one.
+		 */
+		gpgpu_shader__loop_begin(sip, 0);
+		gpgpu_shader__write_dword(sip, 0xdeadbeef, y_offset);
+		gpgpu_shader__write_dword(sip, SIP_CANARY, y_offset);
+		gpgpu_shader__loop_end(sip, 0, 45);
+
+		gpgpu_shader__loop_begin(sip, 1);
+		gpgpu_shader__jump_neq(sip, 1, y_offset, SIP_CANARY);
+		gpgpu_shader__loop_end(sip, 1, 10);
+
+		gpgpu_shader__wait(sip);
+		break;
+	case SIP_INV_INSTR:
+		gpgpu_shader__write_on_exception(sip, 1, y_offset, ILLEGAL_OPCODE_STATUS, 0);
+		break;
+	}
+
+	gpgpu_shader__end_system_routine(sip, shadertype == SHADER_BREAKPOINT);
+	return sip;
+}
+
+static uint32_t gpgpu_shader(int fd, struct intel_bb *ibb, const int shadertype, const int siptype,
+			     unsigned int threads, unsigned int width, unsigned int height)
 {
 	struct intel_buf *buf = create_fill_buf(fd, width, height, COLOR_C4);
-	struct gpgpu_shader *shader = get_shader(fd);
+	struct gpgpu_shader *sip = get_sip(fd, siptype, shadertype, height / 2);
+	struct gpgpu_shader *shader = get_shader(fd, shadertype);
 
-	gpgpu_shader_exec(ibb, buf, 1, threads, shader, NULL, 0, 0);
+	gpgpu_shader_exec(ibb, buf, 1, threads, shader, sip, 0, 0);
+
+	if (sip)
+		gpgpu_shader_destroy(sip);
 	gpgpu_shader_destroy(shader);
+
 	return buf->handle;
 }
 
@@ -83,11 +189,11 @@ static void check_fill_buf(uint8_t *ptr, const int width, const int x,
 		     color, val, x, y);
 }
 
-static void check_buf(int fd, uint32_t handle, int width, int height,
-		      uint8_t poison_c)
+static int check_buf(int fd, uint32_t handle, int width, int height,
+		      int shadertype, int siptype, uint8_t poison_c)
 {
 	unsigned int sz = ALIGN(width * height, 4096);
-	int thread_count = 0;
+	int thread_count = 0, sip_count = 0;
 	uint32_t *ptr;
 	int i, j;
 
@@ -105,9 +211,87 @@ static void check_buf(int fd, uint32_t handle, int width, int height,
 		i = 0;
 	}
 
+	for (i = 0, j = height / 2; j < height; ++j) {
+		if (ptr[j * width / 4] == SIP_CANARY) {
+			++sip_count;
+			i = 4;
+		}
+
+		for (; i < width; i++)
+			check_fill_buf((uint8_t *)ptr, width, i, j, poison_c);
+
+		i = 0;
+	}
+
 	igt_assert(thread_count);
+	if (shadertype == SHADER_INV_INSTR_DISABLED)
+		igt_assert(!sip_count);
+	else if ((siptype != SIP_NULL && xe_eudebug_debugger_available(fd)) ||
+		 (siptype == SIP_INV_INSTR && shadertype != SHADER_INV_INSTR_DISABLED))
+		igt_assert_f(thread_count == sip_count,
+			     "Thread and SIP count mismatch, %d != %d\n",
+			     thread_count, sip_count);
+	else
+		igt_assert(sip_count == 0);
 
 	munmap(ptr, sz);
+
+	return sip_count;
+}
+
+#define USERCOREDUMP_FORMAT "usercoredumps/%d/%d"
+static char *get_latest_usercoredump(int dir)
+{
+	char tmp[256];
+	int i = 1;
+
+	do {
+		snprintf(tmp, sizeof(tmp), USERCOREDUMP_FORMAT, getpid(), i++);
+	} while (igt_sysfs_has_attr(dir, tmp));
+
+	snprintf(tmp, sizeof(tmp), USERCOREDUMP_FORMAT, getpid(), i-2);
+	return igt_sysfs_get(dir, tmp);
+}
+
+static void check_usercoredump(int fd, int sip, int dispatched)
+{
+	int dir = igt_debugfs_dir(fd);
+	char *usercoredump, *str;
+	unsigned int before, after;
+	char match[256];
+
+	if (sip != SIP_WAIT && sip != SIP_HEAVY)
+		return;
+
+	/* XXX reinstate when offline coredumps are implemented */
+#ifndef XXX_ATTENTIONS_THROUGH_COREDUMPS
+	return;
+#endif
+	usercoredump = get_latest_usercoredump(dir);
+	igt_assert(usercoredump);
+	igt_debug("%s\n", usercoredump);
+
+	snprintf(match, sizeof(match), "PID: %d", getpid());
+	str = strstr(usercoredump, match);
+	igt_assert(str);
+
+	snprintf(match, sizeof(match), "Comm: %s", igt_test_name());
+	str = strstr(str, match);
+	igt_assert(str);
+
+	str = strstr(str, "TD_ATT");
+	igt_assert(str);
+	igt_assert_eq(sscanf(str, "TD_ATT before (%d):", &before), 1);
+	str = strstr(str + 1, "TD_ATT");
+	igt_assert_eq(sscanf(str, "TD_ATT after (%d):", &after), 1);
+
+	igt_info("attentions %d before, %d after\n", before, after);
+
+	igt_assert_eq(before, dispatched);
+	igt_assert_eq(after, dispatched);
+
+	free(usercoredump);
+	close(dir);
 }
 
 static uint64_t
@@ -128,17 +312,58 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)
  * Description: check basic shader with write operation
  * Run type: BAT
  *
+ * SUBTEST: sanity-after-timeout
+ * Description: check basic shader execution after job timeout
+ *
+ * SUBTEST: wait-writesip-nodebug
+ * Description: verify that we don't enter SIP after wait with debugging disabled.
+ *
+ * SUBTEST: invalidinstr-disabled
+ * Description: Verify that we don't enter SIP after running into an invalid
+ *		instruction when exception is not enabled.
+ *
+ * SUBTEST: invalidinstr-thread-enabled
+ * Description: Verify that we enter SIP after running into an invalid instruction
+ *              when exception is enabled from thread.
+ *
+ * SUBTEST: invalidinstr-walker-enabled
+ * Description: Verify that we enter SIP after running into an invalid instruction
+ *              when exception is enabled from COMPUTE_WALKER.
+ *
+ * SUBTEST: breakpoint-writesip-nodebug
+ * Description: verify that we don't enter SIP after hitting breakpoint in shader
+ *		when debugging is disabled.
+ *
+ * SUBTEST: breakpoint-writesip
+ * Description: Test that we enter SIP after hitting breakpoint in shader.
+ *
+ * SUBTEST: breakpoint-writesip-twice
+ * Description: Test twice that we enter SIP after hitting breakpoint in shader.
+ *
+ * SUBTEST: breakpoint-waitsip
+ * Description: Test that we reset after seeing the attention without the debugger.
+ *
+ * SUBTEST: breakpoint-waitsip-heavy
+ * Description:
+ *	Test that we reset after seeing the attention from heavy SIP, that resembles
+ *	the production one, without the debugger.
  */
-static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags)
+static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *eci, uint32_t flags)
 {
 	unsigned int threads = 512;
 	unsigned int height = max_t(threads, HEIGHT, threads * 2);
-	uint32_t exec_queue_id, handle, vm_id;
 	unsigned int width = WIDTH;
+	struct drm_xe_ext_set_property ext = {
+		.base.name = DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+		.property = DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG,
+		.value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE,
+	};
 	struct timespec ts = { };
-	uint64_t timeout;
+	int done = 0;
+	uint32_t exec_queue_id, handle, vm_id;
 	struct intel_bb *ibb;
-	int fd;
+	uint64_t timeout;
+	int dispatched, fd;
 
 	igt_debug("Using %s\n", xe_engine_class_string(eci->engine_class));
 
@@ -152,19 +377,24 @@ static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags)
 	timeout *= NSEC_PER_MSEC;
 	timeout *= igt_run_in_simulation() ? 10 : 1;
 
-	exec_queue_id = xe_exec_queue_create(fd, vm_id, eci, 0);
-	ibb = intel_bb_create_with_context(fd, exec_queue_id, vm_id, NULL, 4096);
+	exec_queue_id = xe_exec_queue_create(fd, vm_id, eci,
+					     xe_eudebug_debugger_available(fd) ?
+					     to_user_pointer(&ext) : 0);
+	do {
+		ibb = intel_bb_create_with_context(fd, exec_queue_id, vm_id, NULL, 4096);
 
-	igt_nsec_elapsed(&ts);
-	handle = gpgpu_shader(fd, ibb, threads, width, height);
+		igt_nsec_elapsed(&ts);
+		handle = gpgpu_shader(fd, ibb, shader, sip, threads, width, height);
 
-	intel_bb_sync(ibb);
-	igt_assert_lt_u64(igt_nsec_elapsed(&ts), timeout);
+		intel_bb_sync(ibb);
+		igt_assert_lt_u64(igt_nsec_elapsed(&ts), timeout);
 
-	check_buf(fd, handle, width, height, COLOR_C4);
+		dispatched = check_buf(fd, handle, width, height, shader, sip, COLOR_C4);
+		check_usercoredump(fd, sip, dispatched);
 
-	gem_close(fd, handle);
-	intel_bb_destroy(ibb);
+		gem_close(fd, handle);
+		intel_bb_destroy(ibb);
+	} while (!done++ && (flags & F_SUBMIT_TWICE));
 
 	xe_exec_queue_destroy(fd, exec_queue_id);
 	xe_vm_destroy(fd, vm_id);
@@ -183,13 +413,71 @@ static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags)
 igt_main
 {
 	struct drm_xe_engine_class_instance *eci;
+	bool was_enabled;
 	int fd;
 
 	igt_fixture
 		fd = drm_open_driver(DRIVER_XE);
 
 	test_render_and_compute("sanity", fd, eci)
-		test_sip(eci, 0);
+		test_sip(SHADER_WRITE, SIP_NULL, eci, 0);
+
+	test_render_and_compute("sanity-after-timeout", fd, eci) {
+		test_sip(SHADER_HANG, SIP_NULL, eci, 0);
+
+		xe_for_each_engine(fd, eci)
+			if (eci->engine_class == DRM_XE_ENGINE_CLASS_RENDER ||
+			    eci->engine_class == DRM_XE_ENGINE_CLASS_COMPUTE)
+				test_sip(SHADER_WRITE, SIP_NULL, eci, 0);
+	}
+
+	/* Debugger disabled (TD_CTL not set) */
+	igt_subtest_group {
+		igt_fixture {
+			was_enabled = xe_eudebug_enable(fd, false);
+			igt_require(!xe_eudebug_debugger_available(fd));
+		}
+
+		test_render_and_compute("wait-writesip-nodebug", fd, eci)
+			test_sip(SHADER_WAIT, SIP_WRITE, eci, 0);
+
+		test_render_and_compute("invalidinstr-disabled", fd, eci)
+			test_sip(SHADER_INV_INSTR_DISABLED, SIP_INV_INSTR, eci, 0);
+
+		test_render_and_compute("invalidinstr-thread-enabled", fd, eci)
+			test_sip(SHADER_INV_INSTR_THREAD_ENABLED, SIP_INV_INSTR, eci, 0);
+
+		test_render_and_compute("invalidinstr-walker-enabled", fd, eci)
+			test_sip(SHADER_INV_INSTR_WALKER_ENABLED, SIP_INV_INSTR, eci, 0);
+
+		test_render_and_compute("breakpoint-writesip-nodebug", fd, eci)
+			test_sip(SHADER_BREAKPOINT, SIP_WRITE, eci, 0);
+
+		igt_fixture
+			xe_eudebug_enable(fd, was_enabled);
+	}
+
+	/* Debugger enabled (TD_CTL set) */
+	igt_subtest_group {
+		igt_fixture {
+			was_enabled = xe_eudebug_enable(fd, true);
+		}
+
+		test_render_and_compute("breakpoint-writesip", fd, eci)
+			test_sip(SHADER_BREAKPOINT, SIP_WRITE, eci, 0);
+
+		test_render_and_compute("breakpoint-writesip-twice", fd, eci)
+			test_sip(SHADER_BREAKPOINT, SIP_WRITE, eci, F_SUBMIT_TWICE);
+
+		test_render_and_compute("breakpoint-waitsip", fd, eci)
+			test_sip(SHADER_BREAKPOINT, SIP_WAIT, eci, 0);
+
+		test_render_and_compute("breakpoint-waitsip-heavy", fd, eci)
+			test_sip(SHADER_BREAKPOINT, SIP_HEAVY, eci, 0);
+
+		igt_fixture
+			xe_eudebug_enable(fd, was_enabled);
+	}
 
 	igt_fixture
 		drm_close_driver(fd);
-- 
2.34.1

[PATCH i-g-t v3 12/14] lib/intel_batchbuffer: Add support for long-running mode execution

[Christoph Manszewski]

From: Gwan-gyeong Mun <gwan-gyeong.mun@intel.com>

To execute in lr (long-running) mode, apart from setting
'DRM_XE_VM_CREATE_FLAG_LR_MODE' flag during vm creation, it is required
to use 'DRM_XE_SYNC_TYPE_USER_FENCE' syncs with vm_bind and xe_exec
ioctls.

Make it possible to execute batch buffers via intel_bb_exec() in lr mode
by setting the 'lr_mode' field with the supplied setter.

Signed-off-by: Gwan-gyeong Mun <gwan-gyeong.mun@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 lib/intel_batchbuffer.c | 153 ++++++++++++++++++++++++++++++++++++++--
 lib/intel_batchbuffer.h |  17 +++++
 2 files changed, 165 insertions(+), 5 deletions(-)

diff --git a/lib/intel_batchbuffer.c b/lib/intel_batchbuffer.c
index 824e92831..43bf5b04b 100644
--- a/lib/intel_batchbuffer.c
+++ b/lib/intel_batchbuffer.c
@@ -992,6 +992,7 @@ __intel_bb_create(int fd, uint32_t ctx, uint32_t vm, const intel_ctx_cfg_t *cfg,
 	igt_assert(ibb->batch);
 	ibb->ptr = ibb->batch;
 	ibb->fence = -1;
+	ibb->user_fence_offset = -1;
 
 	/* Cache context configuration */
 	if (cfg) {
@@ -1455,7 +1456,7 @@ int intel_bb_sync(struct intel_bb *ibb)
 {
 	int ret;
 
-	if (ibb->fence < 0 && !ibb->engine_syncobj)
+	if (ibb->fence < 0 && !ibb->engine_syncobj && ibb->user_fence_offset < 0)
 		return 0;
 
 	if (ibb->fence >= 0) {
@@ -1464,10 +1465,28 @@ int intel_bb_sync(struct intel_bb *ibb)
 			close(ibb->fence);
 			ibb->fence = -1;
 		}
-	} else {
-		igt_assert_neq(ibb->engine_syncobj, 0);
+	} else if(ibb->engine_syncobj) {
 		ret = syncobj_wait_err(ibb->fd, &ibb->engine_syncobj,
 				       1, INT64_MAX, 0);
+	} else {
+		int64_t timeout = -1;
+		uint64_t *sync_data;
+		void *map;
+
+		igt_assert(ibb->user_fence_offset >= 0);
+
+		map = xe_bo_map(ibb->fd, ibb->handle, ibb->size);
+		sync_data = (void*)((uint8_t *)map + ibb->user_fence_offset);
+
+		ret = __xe_wait_ufence(ibb->fd, sync_data, ibb->user_fence_value,
+				       ibb->ctx ?: ibb->engine_id, &timeout);
+
+		gem_munmap(map, ibb->size);
+		ibb->user_fence_offset = -1;
+
+		/* Workload finished forcibly, but finished none the less */
+		if (ret == -EIO)
+			ret = 0;
 	}
 
 	return ret;
@@ -2441,6 +2460,126 @@ __xe_bb_exec(struct intel_bb *ibb, uint64_t flags, bool sync)
 	return 0;
 }
 
+static int
+__xe_lr_bb_exec(struct intel_bb *ibb, uint64_t flags, bool sync)
+{
+	uint32_t engine = flags & (I915_EXEC_BSD_MASK | I915_EXEC_RING_MASK);
+	uint32_t engine_id;
+#define USER_FENCE_VALUE	0xdeadbeefdeadbeefull
+	/*
+	 * LR mode vm_bind requires to use DRM_XE_SYNC_TYPE_USER_FENCE type sync
+	 * LR mode xe_exec requires to use DRM_XE_SYNC_TYPE_USER_FENCE type sync
+	 */
+	struct drm_xe_sync syncs[2] = {
+		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		  .timeline_value = USER_FENCE_VALUE
+		},
+		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		  .timeline_value = USER_FENCE_VALUE
+		},
+	};
+	struct drm_xe_vm_bind_op *bind_ops;
+	struct {
+		uint64_t vm_sync;
+		uint64_t exec_sync;
+	} *sync_data;
+	uint32_t sync_offset;
+	uint64_t ibb_addr, vm_sync_addr, exec_sync_addr;
+	void *map;
+
+	igt_assert_eq(ibb->num_relocs, 0);
+	igt_assert_eq(ibb->xe_bound, false);
+
+	if (ibb->ctx) {
+		engine_id = ibb->ctx;
+	} else if (ibb->last_engine != engine) {
+		struct drm_xe_engine_class_instance inst = { };
+
+		inst.engine_instance =
+			(flags & I915_EXEC_BSD_MASK) >> I915_EXEC_BSD_SHIFT;
+
+		switch (flags & I915_EXEC_RING_MASK) {
+		case I915_EXEC_DEFAULT:
+		case I915_EXEC_BLT:
+			inst.engine_class = DRM_XE_ENGINE_CLASS_COPY;
+			break;
+		case I915_EXEC_BSD:
+			inst.engine_class = DRM_XE_ENGINE_CLASS_VIDEO_DECODE;
+			break;
+		case I915_EXEC_RENDER:
+			if (xe_has_engine_class(ibb->fd, DRM_XE_ENGINE_CLASS_RENDER))
+				inst.engine_class = DRM_XE_ENGINE_CLASS_RENDER;
+			else
+				inst.engine_class = DRM_XE_ENGINE_CLASS_COMPUTE;
+			break;
+		case I915_EXEC_VEBOX:
+			inst.engine_class = DRM_XE_ENGINE_CLASS_VIDEO_ENHANCE;
+			break;
+		default:
+			igt_assert_f(false, "Unknown engine: %x", (uint32_t) flags);
+		}
+		igt_debug("Run on %s\n", xe_engine_class_string(inst.engine_class));
+
+		if (ibb->engine_id)
+			xe_exec_queue_destroy(ibb->fd, ibb->engine_id);
+
+		ibb->engine_id = engine_id =
+			xe_exec_queue_create(ibb->fd, ibb->vm_id, &inst, 0);
+	} else {
+		engine_id = ibb->engine_id;
+	}
+	ibb->last_engine = engine;
+
+	/* User fence add for sync: sync.addr has a quadword align limitation */
+	intel_bb_ptr_align(ibb, 8);
+	sync_offset = intel_bb_offset(ibb);
+	intel_bb_ptr_add(ibb, sizeof(*sync_data));
+
+	map = xe_bo_map(ibb->fd, ibb->handle, ibb->size);
+	memcpy(map, ibb->batch, ibb->size);
+
+	sync_data = (void*)((uint8_t *)map + sync_offset);
+	/* vm_sync userfence userspace address. */
+	vm_sync_addr = to_user_pointer(&sync_data->vm_sync);
+	ibb_addr = ibb->batch_offset;
+	/* exec_sync userfence ppgtt address. */
+	exec_sync_addr = ibb_addr + sync_offset + sizeof(uint64_t);
+	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);
+	}
+
+	/* use default vm_bind_exec_queue */
+	xe_wait_ufence(ibb->fd, &sync_data->vm_sync, USER_FENCE_VALUE, 0, -1);
+	gem_munmap(map, ibb->size);
+
+	ibb->xe_bound = true;
+	ibb->user_fence_value = USER_FENCE_VALUE;
+	ibb->user_fence_offset = sync_offset + sizeof(uint64_t);
+
+	xe_exec_sync(ibb->fd, engine_id, ibb->batch_offset, &syncs[1], 1);
+
+	if (sync)
+		intel_bb_sync(ibb);
+
+	return 0;
+}
+
+
 /*
  * __intel_bb_exec:
  * @ibb: pointer to intel_bb
@@ -2541,8 +2680,12 @@ void intel_bb_exec(struct intel_bb *ibb, uint32_t end_offset,
 
 	if (ibb->driver == INTEL_DRIVER_I915)
 		igt_assert_eq(__intel_bb_exec(ibb, end_offset, flags, sync), 0);
-	else
-		igt_assert_eq(__xe_bb_exec(ibb, flags, sync), 0);
+	else {
+		if (intel_bb_get_lr_mode(ibb))
+			igt_assert_eq(__xe_lr_bb_exec(ibb, flags, sync), 0);
+		else
+			igt_assert_eq(__xe_bb_exec(ibb, flags, sync), 0);
+	}
 }
 
 /**
diff --git a/lib/intel_batchbuffer.h b/lib/intel_batchbuffer.h
index 7caf6c518..051c336de 100644
--- a/lib/intel_batchbuffer.h
+++ b/lib/intel_batchbuffer.h
@@ -303,6 +303,11 @@ struct intel_bb {
 	 * is not thread-safe.
 	 */
 	int32_t refcount;
+
+	/* long running mode */
+	bool lr_mode;
+	int64_t user_fence_offset;
+	uint64_t user_fence_value;
 };
 
 struct intel_bb *
@@ -421,6 +426,18 @@ static inline uint32_t intel_bb_pxp_appid(struct intel_bb *ibb)
 	return ibb->pxp.appid;
 }
 
+static inline void intel_bb_set_lr_mode(struct intel_bb *ibb, bool lr_mode)
+{
+	igt_assert(ibb);
+	ibb->lr_mode = lr_mode;
+}
+
+static inline bool intel_bb_get_lr_mode(struct intel_bb *ibb)
+{
+	igt_assert(ibb);
+	return ibb->lr_mode;
+}
+
 struct drm_i915_gem_exec_object2 *
 intel_bb_add_object(struct intel_bb *ibb, uint32_t handle, uint64_t size,
 		    uint64_t offset, uint64_t alignment, bool write);
-- 
2.34.1

[PATCH i-g-t v3 13/14] tests/xe_eudebug_online: Debug client which runs workloads on EU

[Christoph Manszewski]

From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>

For typical debugging under gdb one can specify two main usecases:
accessing and manupulating resources created by the application and
manipulating thread execution (interrupting and setting breakpoints).

This test adds coverage for the latter by checking that:
- EU workloads that hit a instruction with breakpoint bit set will stop
  halt execution and the debugger will report this via attention events,
- the debugger is able to interrupt workload execution by issuing a
  'interrupt_all' ioctl call,
- the debugger is able to resume selected workloads that are stopped.

Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
Signed-off-by: Mika Kuoppala <mika.kuoppala@intel.com>
Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
Signed-off-by: Kolanupaka Naveena <kolanupaka.naveena@intel.com>
---
 tests/intel/xe_eudebug_online.c | 2203 +++++++++++++++++++++++++++++++
 tests/meson.build               |    1 +
 2 files changed, 2204 insertions(+)
 create mode 100644 tests/intel/xe_eudebug_online.c

diff --git a/tests/intel/xe_eudebug_online.c b/tests/intel/xe_eudebug_online.c
new file mode 100644
index 000000000..1c8ac67f1
--- /dev/null
+++ b/tests/intel/xe_eudebug_online.c
@@ -0,0 +1,2203 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2023 Intel Corporation
+ */
+
+/**
+ * TEST: Tests for eudebug online functionality
+ * Category: Core
+ * Mega feature: EUdebug
+ * Sub-category: EUdebug tests
+ * Functionality: eu kernel debug
+ * Test category: functionality test
+ */
+
+#include "xe/xe_eudebug.h"
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+#include "igt.h"
+#include "intel_pat.h"
+#include "intel_mocs.h"
+#include "gpgpu_shader.h"
+
+#define SHADER_NOP			(0 << 0)
+#define SHADER_BREAKPOINT		(1 << 0)
+#define SHADER_LOOP			(1 << 1)
+#define SHADER_SINGLE_STEP		(1 << 2)
+#define SIP_SINGLE_STEP			(1 << 3)
+#define DISABLE_DEBUG_MODE		(1 << 4)
+#define SHADER_N_NOOP_BREAKPOINT	(1 << 5)
+#define SHADER_CACHING_SRAM		(1 << 6)
+#define SHADER_CACHING_VRAM		(1 << 7)
+#define SHADER_MIN_THREADS		(1 << 8)
+#define DO_NOT_EXPECT_CANARIES		(1 << 9)
+#define TRIGGER_RESUME_SINGLE_WALK	(1 << 25)
+#define TRIGGER_RESUME_PARALLEL_WALK	(1 << 26)
+#define TRIGGER_RECONNECT		(1 << 27)
+#define TRIGGER_RESUME_SET_BP		(1 << 28)
+#define TRIGGER_RESUME_DELAYED		(1 << 29)
+#define TRIGGER_RESUME_DSS		(1 << 30)
+#define TRIGGER_RESUME_ONE		(1 << 31)
+
+#define DEBUGGER_REATTACHED	1
+
+#define SHADER_LOOP_N		3
+#define SINGLE_STEP_COUNT	16
+#define STEERING_SINGLE_STEP	0
+#define STEERING_CONTINUE	0x00c0ffee
+#define STEERING_END_LOOP	0xdeadca11
+
+#define CACHING_INIT_VALUE	0xcafe0000
+#define CACHING_POISON_VALUE	0xcafedead
+#define CACHING_VALUE(n)	(CACHING_INIT_VALUE + n)
+
+#define SHADER_CANARY 0x01010101
+
+#define WALKER_X_DIM		4
+#define WALKER_ALIGNMENT	16
+#define SIMD_SIZE		16
+
+#define STARTUP_TIMEOUT_MS	3000
+#define WORKLOAD_DELAY_US	(5000 * 1000)
+
+#define PAGE_SIZE 4096
+
+struct dim_t {
+	uint32_t x;
+	uint32_t y;
+	uint32_t alignment;
+};
+
+static struct dim_t walker_dimensions(int threads)
+{
+	uint32_t x_dim = min_t(x_dim, threads, WALKER_X_DIM);
+	struct dim_t ret = {
+		.x = x_dim,
+		.y = threads / x_dim,
+		.alignment = WALKER_ALIGNMENT
+	};
+
+	return ret;
+}
+
+static struct dim_t surface_dimensions(int threads)
+{
+	struct dim_t ret = walker_dimensions(threads);
+
+	ret.y = max_t(ret.y, threads/ret.x, 4);
+	ret.x *= SIMD_SIZE;
+	ret.alignment *= SIMD_SIZE;
+
+	return ret;
+}
+
+static uint32_t steering_offset(int threads)
+{
+	struct dim_t w = walker_dimensions(threads);
+
+	return ALIGN(w.x, w.alignment) * w.y * 4;
+}
+
+static struct intel_buf *create_uc_buf(int fd, int width, int height)
+{
+	struct intel_buf *buf;
+
+	buf = intel_buf_create_full(buf_ops_create(fd), 0, width/4, height,
+				    32, 0, I915_TILING_NONE, 0, 0, 0,
+				    vram_if_possible(fd, 0),
+				    DEFAULT_PAT_INDEX, DEFAULT_MOCS_INDEX);
+
+	return buf;
+}
+
+static int get_number_of_threads(uint64_t flags)
+{
+	if (flags & SHADER_MIN_THREADS)
+		return 16;
+
+	if (flags & (TRIGGER_RESUME_ONE | TRIGGER_RESUME_SINGLE_WALK |
+		     TRIGGER_RESUME_PARALLEL_WALK | SHADER_CACHING_SRAM | SHADER_CACHING_VRAM))
+		return 32;
+
+	return 512;
+}
+
+static int caching_get_instruction_count(int fd, uint32_t s_dim__x, int flags)
+{
+	uint64_t memory;
+
+	igt_assert((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM));
+
+	if (flags & SHADER_CACHING_SRAM)
+		memory = system_memory(fd);
+	else
+		memory = vram_memory(fd, 0);
+
+	/* each instruction writes to given y offset */
+	return (2 * xe_min_page_size(fd, memory)) / s_dim__x;
+}
+
+static struct gpgpu_shader *get_shader(int fd, const unsigned int flags)
+{
+	struct dim_t w_dim = walker_dimensions(get_number_of_threads(flags));
+	struct dim_t s_dim = surface_dimensions(get_number_of_threads(flags));
+	static struct gpgpu_shader *shader;
+
+	shader = gpgpu_shader_create(fd);
+
+	gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
+	if (flags & SHADER_BREAKPOINT) {
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__breakpoint(shader);
+	} else if (flags & SHADER_LOOP) {
+		gpgpu_shader__label(shader, 0);
+		gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
+		gpgpu_shader__jump_neq(shader, 0, w_dim.y, STEERING_END_LOOP);
+		gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
+	} else if (flags & SHADER_SINGLE_STEP) {
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__breakpoint(shader);
+		for (int i = 0; i < SINGLE_STEP_COUNT; i++)
+			gpgpu_shader__nop(shader);
+	} else if (flags & SHADER_N_NOOP_BREAKPOINT) {
+		for (int i = 0; i < SHADER_LOOP_N; i++) {
+			gpgpu_shader__nop(shader);
+			gpgpu_shader__breakpoint(shader);
+		}
+	} else if ((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM)) {
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__breakpoint(shader);
+		for (int i = 0; i < caching_get_instruction_count(fd, s_dim.x, flags); i++)
+			gpgpu_shader__common_target_write_u32(shader, s_dim.y + i, CACHING_VALUE(i));
+		gpgpu_shader__nop(shader);
+		gpgpu_shader__breakpoint(shader);
+	}
+
+	gpgpu_shader__eot(shader);
+	return shader;
+}
+
+static struct gpgpu_shader *get_sip(int fd, const unsigned int flags)
+{
+	struct dim_t w_dim = walker_dimensions(get_number_of_threads(flags));
+	static struct gpgpu_shader *sip;
+
+	sip = gpgpu_shader_create(fd);
+	gpgpu_shader__write_aip(sip, 0);
+
+	gpgpu_shader__wait(sip);
+	if (flags & SIP_SINGLE_STEP)
+		gpgpu_shader__end_system_routine_step_if_eq(sip, w_dim.y, 0);
+	else
+		gpgpu_shader__end_system_routine(sip, true);
+	return sip;
+}
+
+static int count_set_bits(void *ptr, size_t size)
+{
+	uint8_t *p = ptr;
+	int count = 0;
+	int i, j;
+
+	for (i = 0; i < size; i++)
+		for (j = 0; j < 8; j++)
+			count += !!(p[i] & (1 << j));
+
+	return count;
+}
+
+static int count_canaries_eq(uint32_t *ptr, struct dim_t w_dim, uint32_t value)
+{
+	int count = 0;
+	int x, y;
+
+	for (x = 0; x < w_dim.x; x++)
+		for (y = 0; y < w_dim.y; y++)
+			if (READ_ONCE(ptr[x + ALIGN(w_dim.x, w_dim.alignment) * y]) == value)
+				count++;
+
+	return count;
+}
+
+static int count_canaries_neq(uint32_t *ptr, struct dim_t w_dim, uint32_t value)
+{
+	return w_dim.x * w_dim.y - count_canaries_eq(ptr, w_dim, value);
+}
+
+static const char *td_ctl_cmd_to_str(uint32_t cmd)
+{
+	switch (cmd) {
+	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL:
+		return "interrupt all";
+	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED:
+		return "stopped";
+	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME:
+		return "resume";
+	default:
+		return "unknown command";
+	}
+}
+
+static int __eu_ctl(int debugfd, uint64_t client,
+		    uint64_t exec_queue, uint64_t lrc,
+		    uint8_t *bitmask, uint32_t *bitmask_size,
+		    uint32_t cmd, uint64_t *seqno)
+{
+	struct drm_xe_eudebug_eu_control control = {
+		.client_handle = lower_32_bits(client),
+		.exec_queue_handle = exec_queue,
+		.lrc_handle = lrc,
+		.cmd = cmd,
+		.bitmask_ptr = to_user_pointer(bitmask),
+	};
+	int ret;
+
+	if (bitmask_size)
+		control.bitmask_size = *bitmask_size;
+
+	ret = igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &control);
+
+	if (ret < 0)
+		return -errno;
+
+	igt_debug("EU CONTROL[%llu]: %s\n", control.seqno, td_ctl_cmd_to_str(cmd));
+
+	if (bitmask_size)
+		*bitmask_size = control.bitmask_size;
+
+	if (seqno)
+		*seqno = control.seqno;
+
+	return 0;
+
+}
+
+static uint64_t eu_ctl(int debugfd, uint64_t client,
+		       uint64_t exec_queue, uint64_t lrc,
+		       uint8_t *bitmask, uint32_t *bitmask_size, uint32_t cmd)
+{
+	uint64_t seqno;
+
+	igt_assert_eq(__eu_ctl(debugfd, client, exec_queue, lrc, bitmask,
+			       bitmask_size, cmd, &seqno), 0);
+
+	return seqno;
+}
+
+static bool intel_gen_needs_resume_wa(int fd)
+{
+	const uint32_t id = intel_get_drm_devid(fd);
+
+	return intel_gen(id) == 12 && intel_graphics_ver(id) < IP_VER(12, 55);
+}
+
+static uint64_t eu_ctl_resume(int fd, int debugfd, uint64_t client,
+			      uint64_t exec_queue, uint64_t lrc,
+			      uint8_t *bitmask, uint32_t bitmask_size)
+{
+	int i;
+
+	/* XXX: WA for hsd: 14011332042 */
+	if (intel_gen_needs_resume_wa(fd)) {
+		uint32_t *att_reg_half = (uint32_t *)bitmask;
+
+		for (i = 0; i < bitmask_size / sizeof(uint32_t); i += 2) {
+			att_reg_half[i] |= att_reg_half[i + 1];
+			att_reg_half[i + 1] |= att_reg_half[i];
+		}
+	}
+
+	return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, &bitmask_size,
+		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME);
+}
+
+static inline uint64_t eu_ctl_stopped(int debugfd, uint64_t client,
+				      uint64_t exec_queue, uint64_t lrc,
+				      uint8_t *bitmask, uint32_t *bitmask_size)
+{
+	return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, bitmask_size,
+		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED);
+}
+
+static inline uint64_t eu_ctl_interrupt_all(int debugfd, uint64_t client,
+					    uint64_t exec_queue, uint64_t lrc)
+{
+	return eu_ctl(debugfd, client, exec_queue, lrc, NULL, 0,
+		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL);
+}
+
+struct online_debug_data {
+	pthread_mutex_t mutex;
+	/* client in */
+	struct drm_xe_engine_class_instance hwe;
+	/* client out */
+	int threads_count;
+	/* debugger internals */
+	uint64_t client_handle;
+	uint64_t exec_queue_handle;
+	uint64_t lrc_handle;
+	uint64_t target_offset;
+	size_t target_size;
+	uint64_t bb_offset;
+	size_t bb_size;
+	int vm_fd;
+	uint32_t first_aip;
+	uint64_t *aips_offset_table;
+	uint32_t steps_done;
+	uint8_t *single_step_bitmask;
+	int stepped_threads_count;
+	struct timespec exception_arrived;
+	int last_eu_control_seqno;
+	struct drm_xe_eudebug_event *exception_event;
+};
+
+static struct online_debug_data *
+online_debug_data_create(struct drm_xe_engine_class_instance *hwe)
+{
+	struct online_debug_data *data;
+
+	data = mmap(0, ALIGN(sizeof(*data), PAGE_SIZE),
+		    PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+	memcpy(&data->hwe, hwe, sizeof(*hwe));
+	pthread_mutex_init(&data->mutex, NULL);
+	data->client_handle = -1ULL;
+	data->exec_queue_handle = -1ULL;
+	data->lrc_handle = -1ULL;
+	data->vm_fd = -1;
+	data->stepped_threads_count = -1;
+
+	return data;
+}
+
+static void online_debug_data_destroy(struct online_debug_data *data)
+{
+	free(data->aips_offset_table);
+	munmap(data, ALIGN(sizeof(*data), PAGE_SIZE));
+}
+
+static void eu_attention_debug_trigger(struct xe_eudebug_debugger *d,
+					struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
+	uint32_t *ptr = (uint32_t *) att->bitmask;
+
+	igt_debug("EVENT[%llu] eu-attenttion; threads=%d "
+		 "client[%llu], exec_queue[%llu], lrc[%llu], bitmask_size[%d]\n",
+		 att->base.seqno, count_set_bits(att->bitmask, att->bitmask_size),
+				att->client_handle, att->exec_queue_handle,
+				att->lrc_handle, att->bitmask_size);
+
+	for (uint32_t i = 0; i < att->bitmask_size/4; i += 2)
+		igt_debug("bitmask[%d] = 0x%08x%08x\n", i/2, ptr[i], ptr[i+1]);
+
+}
+
+static void eu_attention_reset_trigger(struct xe_eudebug_debugger *d,
+					struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
+	uint32_t *ptr = (uint32_t *) att->bitmask;
+	struct online_debug_data *data = d->ptr;
+
+	igt_debug("EVENT[%llu] eu-attention with reset; threads=%d "
+		 "client[%llu], exec_queue[%llu], lrc[%llu], bitmask_size[%d]\n",
+		 att->base.seqno, count_set_bits(att->bitmask, att->bitmask_size),
+				att->client_handle, att->exec_queue_handle,
+				att->lrc_handle, att->bitmask_size);
+
+	for (uint32_t i = 0; i < att->bitmask_size/4; i += 2)
+		igt_debug("bitmask[%d] = 0x%08x%08x\n", i/2, ptr[i], ptr[i+1]);
+
+	xe_force_gt_reset_async(d->master_fd, data->hwe.gt_id);
+}
+
+static void copy_first_bit(uint8_t *dst, uint8_t *src, int size)
+{
+	bool found = false;
+	int i, j;
+
+	for (i = 0; i < size; i++) {
+		if (found) {
+			dst[i] = 0;
+		} else {
+			uint32_t tmp = src[i]; /* in case dst == src */
+
+			for (j = 0; j < 8; j++) {
+				dst[i] = tmp & (1 << j);
+				if (dst[i]) {
+					found = true;
+					break;
+				}
+			}
+		}
+	}
+}
+
+static void copy_nth_bit(uint8_t *dst, uint8_t *src, int size, int n)
+{
+	int count = 0;
+
+	for (int i = 0; i < size; i++) {
+		uint32_t tmp = src[i];
+		for (int j = 7; j >= 0; j--) {
+			if (tmp & (1 << j)) {
+				count++;
+				if (count == n)
+					dst[i] |= (1 << j);
+				else
+					dst[i] &= ~(1 << j);
+			} else
+				dst[i] &= ~(1 << j);
+		}
+	}
+}
+
+/*
+ * Searches for the first instruction. It stands on assumption,
+ * that shader kernel is placed before sip within the bb.
+ */
+static uint32_t find_kernel_in_bb(struct gpgpu_shader *kernel,
+				  struct online_debug_data *data)
+{
+	uint32_t *p = kernel->code;
+	size_t sz = 4 * sizeof(uint32_t);
+	uint32_t buf[4];
+	int i;
+
+	for (i = 0; i < data->bb_size; i += sz) {
+		igt_assert_eq(pread(data->vm_fd, &buf, sz, data->bb_offset + i), sz);
+
+
+		if (memcmp(p, buf, sz) == 0)
+			break;
+	}
+
+	igt_assert(i < data->bb_size);
+
+	return i;
+}
+
+static void set_breakpoint_once(struct xe_eudebug_debugger *d,
+				struct online_debug_data *data)
+{
+	const uint32_t breakpoint_bit = 1 << 30;
+	size_t sz = sizeof(uint32_t);
+	struct gpgpu_shader *kernel;
+	uint32_t aip;
+
+	kernel = get_shader(d->master_fd, d->flags);
+
+	if (data->first_aip) {
+		uint32_t expected = find_kernel_in_bb(kernel, data) + kernel->size * 4 - 0x10;
+
+		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset), sz);
+		igt_assert_eq_u32(aip, expected);
+	} else {
+		uint32_t instr_usdw;
+
+		igt_assert(data->vm_fd != -1);
+		igt_assert(data->target_size != 0);
+		igt_assert(data->bb_size != 0);
+
+		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset), sz);
+		data->first_aip = aip;
+
+		aip = find_kernel_in_bb(kernel, data);
+
+		/* set breakpoint on last instruction */
+		aip += kernel->size * 4 - 0x10;
+		igt_assert_eq(pread(data->vm_fd, &instr_usdw, sz,
+				    data->bb_offset + aip), sz);
+		instr_usdw |= breakpoint_bit;
+		igt_assert_eq(pwrite(data->vm_fd, &instr_usdw, sz,
+				     data->bb_offset + aip), sz);
+
+	}
+
+	gpgpu_shader_destroy(kernel);
+}
+
+static void get_aips_offset_table(struct online_debug_data *data, int threads)
+{
+	size_t sz = sizeof(uint32_t);
+	uint32_t aip;
+	uint32_t first_aip;
+	int table_index = 0;
+
+	if (data->aips_offset_table)
+		return;
+
+	data->aips_offset_table = malloc(threads * sizeof(uint64_t));
+	igt_assert(data->aips_offset_table);
+
+	igt_assert_eq(pread(data->vm_fd, &first_aip, sz, data->target_offset), sz);
+	data->first_aip = first_aip;
+	data->aips_offset_table[table_index++] = 0;
+
+	fsync(data->vm_fd);
+	for (int i = 1; i < data->target_size; i++) {
+		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset + i), sz);
+		if (aip == first_aip)
+			data->aips_offset_table[table_index++] = i;
+	}
+
+	igt_assert_eq(threads, table_index);
+
+	igt_debug("AIPs offset table:\n");
+	for (int i = 0; i < threads; i++) {
+		igt_debug("%lx\n", data->aips_offset_table[i]);
+	}
+}
+
+static int get_stepped_threads_count(struct online_debug_data *data, int threads)
+{
+	int count = 0;
+	size_t sz = sizeof(uint32_t);
+	uint32_t aip;
+
+	fsync(data->vm_fd);
+	for (int i = 0; i < threads; i++) {
+		igt_assert_eq(pread(data->vm_fd, &aip, sz,
+				    data->target_offset + data->aips_offset_table[i]), sz);
+		if (aip != data->first_aip) {
+			igt_assert(aip == data->first_aip + 0x10);
+			count++;
+		}
+	}
+
+	return count;
+}
+
+static void save_first_exception_trigger(struct xe_eudebug_debugger *d,
+					 struct drm_xe_eudebug_event *e)
+{
+	struct online_debug_data *data = d->ptr;
+
+	pthread_mutex_lock(&data->mutex);
+	if (!data->exception_event) {
+		igt_gettime(&data->exception_arrived);
+		data->exception_event = igt_memdup(e, e->len);
+	}
+	pthread_mutex_unlock(&data->mutex);
+}
+
+#define MAX_PREEMPT_TIMEOUT 10ull
+static int is_client_resumed;
+static void eu_attention_resume_trigger(struct xe_eudebug_debugger *d,
+					struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
+	struct online_debug_data *data = d->ptr;
+	uint32_t bitmask_size = att->bitmask_size;
+	uint8_t *bitmask;
+	int i;
+
+	if (data->last_eu_control_seqno > att->base.seqno)
+		return;
+
+	bitmask = calloc(1, att->bitmask_size);
+
+	eu_ctl_stopped(d->fd, att->client_handle, att->exec_queue_handle,
+		       att->lrc_handle, bitmask, &bitmask_size);
+	igt_assert(bitmask_size == att->bitmask_size);
+	igt_assert(memcmp(bitmask, att->bitmask, att->bitmask_size) == 0);
+
+	pthread_mutex_lock(&data->mutex);
+	if (igt_nsec_elapsed(&data->exception_arrived) < (MAX_PREEMPT_TIMEOUT + 1) * NSEC_PER_SEC &&
+	    d->flags & TRIGGER_RESUME_DELAYED) {
+		pthread_mutex_unlock(&data->mutex);
+		free(bitmask);
+		return;
+	} else if (d->flags & TRIGGER_RESUME_ONE) {
+		copy_first_bit(bitmask, bitmask, bitmask_size);
+	} else if (d->flags & TRIGGER_RESUME_DSS) {
+		uint64_t *event = (uint64_t *)att->bitmask;
+		uint64_t *resume = (uint64_t *)bitmask;
+
+		memset(bitmask, 0, bitmask_size);
+		for (i = 0; i < att->bitmask_size / sizeof(uint64_t); i++) {
+			if (!event[i])
+				continue;
+
+			resume[i] = event[i];
+			break;
+		}
+	} else if (d->flags & TRIGGER_RESUME_SET_BP) {
+		set_breakpoint_once(d, data);
+	}
+
+	if (d->flags & SHADER_LOOP) {
+		uint32_t threads = get_number_of_threads(d->flags);
+		uint32_t val = STEERING_END_LOOP;
+
+		igt_assert_eq(pwrite(data->vm_fd, &val, sizeof(uint32_t),
+				     data->target_offset + steering_offset(threads)),
+			      sizeof(uint32_t));
+		fsync(data->vm_fd);
+	}
+	pthread_mutex_unlock(&data->mutex);
+
+	data->last_eu_control_seqno = eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
+						    att->exec_queue_handle, att->lrc_handle,
+						    bitmask, att->bitmask_size);
+
+	is_client_resumed = 1;
+	free(bitmask);
+}
+
+static void eu_attention_resume_single_step_trigger(struct xe_eudebug_debugger *d,
+						    struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
+	struct online_debug_data *data = d->ptr;
+	const int threads = get_number_of_threads(d->flags);
+	uint32_t val;
+	size_t sz = sizeof(uint32_t);
+
+	get_aips_offset_table(data, threads);
+
+	if (d->flags & TRIGGER_RESUME_PARALLEL_WALK) {
+		if (data->stepped_threads_count != -1)
+			if (data->steps_done < SINGLE_STEP_COUNT) {
+				int stepped_threads_count_after_resume =
+						get_stepped_threads_count(data, threads);
+				igt_debug("Stepped threads after: %d\n",
+					  stepped_threads_count_after_resume);
+
+				if (stepped_threads_count_after_resume == threads) {
+					data->first_aip += 0x10;
+					data->steps_done++;
+				}
+
+				igt_debug("Shader steps: %d\n", data->steps_done);
+				igt_assert(data->stepped_threads_count == 0);
+				igt_assert(stepped_threads_count_after_resume == threads);
+			}
+
+		if (data->steps_done < SINGLE_STEP_COUNT) {
+			data->stepped_threads_count = get_stepped_threads_count(data, threads);
+			igt_debug("Stepped threads before: %d\n", data->stepped_threads_count);
+		}
+
+		val = data->steps_done < SINGLE_STEP_COUNT ? STEERING_SINGLE_STEP :
+							     STEERING_CONTINUE;
+	} else if (d->flags & TRIGGER_RESUME_SINGLE_WALK) {
+		if (data->stepped_threads_count != -1)
+			if (data->steps_done < 2) {
+				int stepped_threads_count_after_resume =
+						get_stepped_threads_count(data, threads);
+				igt_debug("Stepped threads after: %d\n",
+					  stepped_threads_count_after_resume);
+
+				if (stepped_threads_count_after_resume == threads) {
+					data->first_aip += 0x10;
+					data->steps_done++;
+					free(data->single_step_bitmask);
+					data->single_step_bitmask = 0;
+				}
+
+				igt_debug("Shader steps: %d\n", data->steps_done);
+				igt_assert(data->stepped_threads_count +
+					   (intel_gen_needs_resume_wa(d->master_fd) ? 2 : 1) ==
+					   stepped_threads_count_after_resume);
+			}
+
+		if (data->steps_done < 2) {
+			data->stepped_threads_count = get_stepped_threads_count(data, threads);
+			igt_debug("Stepped threads before: %d\n", data->stepped_threads_count);
+			if (intel_gen_needs_resume_wa(d->master_fd)) {
+				if (!data->single_step_bitmask) {
+					data->single_step_bitmask = malloc(att->bitmask_size *
+									   sizeof(uint8_t));
+					igt_assert(data->single_step_bitmask);
+					memcpy(data->single_step_bitmask, att->bitmask,
+					       att->bitmask_size);
+				}
+
+				copy_first_bit(att->bitmask, data->single_step_bitmask,
+					       att->bitmask_size);
+			} else
+				copy_nth_bit(att->bitmask, att->bitmask, att->bitmask_size,
+					     data->stepped_threads_count + 1);
+		}
+
+		val = data->steps_done < 2 ? STEERING_SINGLE_STEP : STEERING_CONTINUE;
+	}
+
+	igt_assert_eq(pwrite(data->vm_fd, &val, sz,
+			     data->target_offset + steering_offset(threads)), sz);
+	fsync(data->vm_fd);
+
+	eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
+		      att->exec_queue_handle, att->lrc_handle,
+		      att->bitmask, att->bitmask_size);
+
+	if (data->single_step_bitmask)
+		for (int i = 0; i < att->bitmask_size; i++)
+			data->single_step_bitmask[i] &= ~att->bitmask[i];
+}
+
+static void open_trigger(struct xe_eudebug_debugger *d,
+			 struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_client *client = (void *)e;
+	struct online_debug_data *data = d->ptr;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
+		return;
+
+	pthread_mutex_lock(&data->mutex);
+	data->client_handle = client->client_handle;
+	pthread_mutex_unlock(&data->mutex);
+}
+
+static void exec_queue_trigger(struct xe_eudebug_debugger *d,
+			       struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_exec_queue *eq = (void *)e;
+	struct online_debug_data *data = d->ptr;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
+		return;
+
+	pthread_mutex_lock(&data->mutex);
+	data->exec_queue_handle = eq->exec_queue_handle;
+	data->lrc_handle = eq->lrc_handle[0];
+	pthread_mutex_unlock(&data->mutex);
+}
+
+static void vm_open_trigger(struct xe_eudebug_debugger *d,
+			    struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm *vm = (void *)e;
+	struct online_debug_data *data = d->ptr;
+	struct drm_xe_eudebug_vm_open vo = {
+		.client_handle = vm->client_handle,
+		.vm_handle = vm->vm_handle,
+	};
+	int fd;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
+		igt_assert_lte(0, fd);
+
+		pthread_mutex_lock(&data->mutex);
+		igt_assert(data->vm_fd == -1);
+		data->vm_fd = fd;
+		pthread_mutex_unlock(&data->mutex);
+		return;
+	}
+
+	pthread_mutex_lock(&data->mutex);
+	close(data->vm_fd);
+	data->vm_fd = -1;
+	pthread_mutex_unlock(&data->mutex);
+}
+
+static void read_metadata(struct xe_eudebug_debugger *d,
+			  uint64_t client_handle,
+			  uint64_t metadata_handle,
+			  uint64_t type,
+			  uint64_t len)
+{
+	struct drm_xe_eudebug_read_metadata rm = {
+		.client_handle = client_handle,
+		.metadata_handle = metadata_handle,
+		.size = len,
+	};
+	struct online_debug_data *data = d->ptr;
+	uint64_t *metadata;
+
+	metadata = malloc(len);
+	igt_assert(metadata);
+
+	rm.ptr = to_user_pointer(metadata);
+	igt_assert_eq(igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0);
+
+	pthread_mutex_lock(&data->mutex);
+	switch (type) {
+	case DRM_XE_DEBUG_METADATA_ELF_BINARY:
+		data->bb_offset = metadata[0];
+		data->bb_size = metadata[1];
+		break;
+	case DRM_XE_DEBUG_METADATA_PROGRAM_MODULE:
+		data->target_offset = metadata[0];
+		data->target_size = metadata[1];
+		break;
+	default:
+		break;
+	}
+	pthread_mutex_unlock(&data->mutex);
+
+	free(metadata);
+}
+
+static void create_metadata_trigger(struct xe_eudebug_debugger *d, struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_metadata *em = (void *)e;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
+		read_metadata(d, em->client_handle, em->metadata_handle, em->type, em->len);
+	}
+}
+
+static void overwrite_immediate_value_in_common_target_write(int vm_fd, uint64_t offset,
+							     uint32_t old_val, uint32_t new_val)
+{
+	uint64_t addr = offset;
+	int vals_changed = 0;
+	uint32_t val;
+
+	while (vals_changed < 4) {
+		igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr), sizeof(uint32_t));
+		if (val == old_val) {
+			igt_debug("val_before_write[%d]: %08x\n", vals_changed, val);
+			igt_assert_eq(pwrite(vm_fd, &new_val, sizeof(uint32_t), addr),
+				      sizeof(uint32_t));
+			igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr),
+				      sizeof(uint32_t));
+			igt_debug("val_before_fsync[%d]: %08x\n", vals_changed, val);
+			fsync(vm_fd);
+			igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr),
+				      sizeof(uint32_t));
+			igt_debug("val_after_fsync[%d]: %08x\n", vals_changed, val);
+			igt_assert_eq_u32(val, new_val);
+			vals_changed++;
+		}
+		addr += sizeof(uint32_t);
+	}
+}
+
+static void eu_attention_resume_caching_trigger(struct xe_eudebug_debugger *d,
+						struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
+	struct online_debug_data *data = d->ptr;
+	static int counter = 0;
+	static int kernel_in_bb = 0;
+	struct dim_t s_dim = surface_dimensions(get_number_of_threads(d->flags));
+	int val;
+	uint32_t instr_usdw;
+	struct gpgpu_shader *kernel;
+	const uint32_t breakpoint_bit = 1 << 30;
+	struct gpgpu_shader *shader_preamble;
+	struct gpgpu_shader *shader_write_instr;
+
+	shader_preamble = gpgpu_shader_create(d->master_fd);
+	gpgpu_shader__write_dword(shader_preamble, SHADER_CANARY, 0);
+	gpgpu_shader__nop(shader_preamble);
+	gpgpu_shader__breakpoint(shader_preamble);
+
+	shader_write_instr = gpgpu_shader_create(d->master_fd);
+	gpgpu_shader__common_target_write_u32(shader_write_instr, 0, 0);
+
+	if (!kernel_in_bb) {
+		kernel = get_shader(d->master_fd, d->flags);
+		kernel_in_bb = find_kernel_in_bb(kernel, data);
+		gpgpu_shader_destroy(kernel);
+	}
+
+	/* set breakpoint on next write instruction */
+	if (counter < caching_get_instruction_count(d->master_fd, s_dim.x, d->flags)) {
+		igt_assert_eq(pread(data->vm_fd, &instr_usdw, sizeof(instr_usdw),
+				    data->bb_offset + kernel_in_bb + shader_preamble->size * 4 +
+				    shader_write_instr->size * 4 * counter), sizeof(instr_usdw));
+		instr_usdw |= breakpoint_bit;
+		igt_assert_eq(pwrite(data->vm_fd, &instr_usdw, sizeof(instr_usdw),
+				     data->bb_offset + kernel_in_bb + shader_preamble->size * 4 +
+				     shader_write_instr->size * 4 * counter), sizeof(instr_usdw));
+		fsync(data->vm_fd);
+	}
+
+	/* restore current instruction */
+	if (counter && counter <= caching_get_instruction_count(d->master_fd, s_dim.x, d->flags))
+		overwrite_immediate_value_in_common_target_write(data->vm_fd,
+								 data->bb_offset + kernel_in_bb +
+								 shader_preamble->size * 4 +
+								 shader_write_instr->size * 4 * (counter - 1),
+								 CACHING_POISON_VALUE,
+								 CACHING_VALUE(counter - 1));
+
+	/* poison next instruction */
+	if (counter < caching_get_instruction_count(d->master_fd, s_dim.x, d->flags))
+		overwrite_immediate_value_in_common_target_write(data->vm_fd,
+								 data->bb_offset + kernel_in_bb +
+								 shader_preamble->size * 4 +
+								 shader_write_instr->size * 4 * counter,
+								 CACHING_VALUE(counter),
+								 CACHING_POISON_VALUE);
+
+	gpgpu_shader_destroy(shader_write_instr);
+	gpgpu_shader_destroy(shader_preamble);
+
+	for (int i = 0; i < data->target_size; i += sizeof(uint32_t)) {
+		igt_assert_eq(pread(data->vm_fd, &val, sizeof(val), data->target_offset + i),
+			      sizeof(val));
+		igt_assert_f(val != CACHING_POISON_VALUE, "Poison value found at %04d!\n", i);
+	}
+
+	eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
+		      att->exec_queue_handle, att->lrc_handle,
+		      att->bitmask, att->bitmask_size);
+
+	counter++;
+}
+
+static struct intel_bb *xe_bb_create_on_offset(int fd, uint32_t exec_queue, uint32_t vm,
+					       uint64_t offset, uint32_t size)
+{
+	struct intel_bb *ibb;
+
+	ibb = intel_bb_create_with_context(fd, exec_queue, vm, NULL, size);
+
+	/* update intel bb offset */
+	intel_bb_remove_object(ibb, ibb->handle, ibb->batch_offset, ibb->size);
+	intel_bb_add_object(ibb, ibb->handle, ibb->size, offset, ibb->alignment, false);
+	ibb->batch_offset = offset;
+
+	return ibb;
+}
+
+static size_t get_bb_size(int flags)
+{
+	if ((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM))
+		return 32768;
+
+	return 4096;
+}
+
+static void run_online_client(struct xe_eudebug_client *c)
+{
+	int threads = get_number_of_threads(c->flags);
+	const uint64_t target_offset = 0x1a000000;
+	const uint64_t bb_offset = 0x1b000000;
+	const size_t bb_size = get_bb_size(c->flags);
+	struct online_debug_data *data = c->ptr;
+	struct drm_xe_engine_class_instance hwe = data->hwe;
+	struct drm_xe_ext_set_property ext = {
+		.base.name = DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
+		.property = DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG,
+		.value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE,
+	};
+	struct drm_xe_exec_queue_create create = {
+		.instances = to_user_pointer(&hwe),
+		.width = 1,
+		.num_placements = 1,
+		.extensions = c->flags & DISABLE_DEBUG_MODE ? 0 : to_user_pointer(&ext)
+	};
+	struct dim_t w_dim = walker_dimensions(threads);
+	struct dim_t s_dim = surface_dimensions(threads);
+	struct timespec ts = { };
+	struct gpgpu_shader *sip, *shader;
+	uint32_t metadata_id[2];
+	uint64_t *metadata[2];
+	struct intel_bb *ibb;
+	struct intel_buf *buf;
+	uint32_t *ptr;
+	int fd;
+
+	metadata[0] = calloc(2, sizeof(*metadata));
+	metadata[1] = calloc(2, sizeof(*metadata));
+	igt_assert(metadata[0]);
+	igt_assert(metadata[1]);
+
+	fd = xe_eudebug_client_open_driver(c);
+	xe_device_get(fd);
+
+	/* Additional memory for steering control */
+	if (c->flags & SHADER_LOOP || c->flags & SHADER_SINGLE_STEP)
+		s_dim.y++;
+	/* Additional memory for caching check */
+	if ((c->flags & SHADER_CACHING_SRAM) || (c->flags & SHADER_CACHING_VRAM))
+		s_dim.y += caching_get_instruction_count(fd, s_dim.x, c->flags);
+	buf = create_uc_buf(fd, s_dim.x, s_dim.y);
+
+	buf->addr.offset = target_offset;
+
+	metadata[0][0] = bb_offset;
+	metadata[0][1] = bb_size;
+	metadata[1][0] = target_offset;
+	metadata[1][1] = buf->size;
+	metadata_id[0] = xe_eudebug_client_metadata_create(c, fd, DRM_XE_DEBUG_METADATA_ELF_BINARY,
+							   2 * sizeof(*metadata), metadata[0]);
+	metadata_id[1] = xe_eudebug_client_metadata_create(c, fd,
+							   DRM_XE_DEBUG_METADATA_PROGRAM_MODULE,
+							   2 * sizeof(*metadata), metadata[1]);
+
+	create.vm_id = xe_eudebug_client_vm_create(c, fd, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
+	xe_eudebug_client_exec_queue_create(c, fd, &create);
+
+	ibb = xe_bb_create_on_offset(fd, create.exec_queue_id, create.vm_id,
+				     bb_offset, bb_size);
+	intel_bb_set_lr_mode(ibb, true);
+
+	sip = get_sip(fd, c->flags);
+	shader = get_shader(fd, c->flags);
+
+	igt_nsec_elapsed(&ts);
+	gpgpu_shader_exec(ibb, buf, w_dim.x, w_dim.y, shader, sip, 0, 0);
+
+	gpgpu_shader_destroy(sip);
+	gpgpu_shader_destroy(shader);
+
+	intel_bb_sync(ibb);
+
+	if (c->flags & TRIGGER_RECONNECT)
+		xe_eudebug_client_wait_stage(c, DEBUGGER_REATTACHED);
+	else
+		/* Make sure it wasn't the timeout. */
+		igt_assert(igt_nsec_elapsed(&ts) <
+			   XE_EUDEBUG_DEFAULT_TIMEOUT_MS / MSEC_PER_SEC * NSEC_PER_SEC);
+
+	if (!(c->flags & DO_NOT_EXPECT_CANARIES)) {
+		ptr = xe_bo_mmap_ext(fd, buf->handle, buf->size, PROT_READ);
+		data->threads_count = count_canaries_neq(ptr, w_dim, 0);
+		igt_assert_f(data->threads_count, "No canaries found, nothing executed?\n");
+
+		if ((c->flags & SHADER_BREAKPOINT || c->flags & TRIGGER_RESUME_SET_BP ||
+		     c->flags & SHADER_N_NOOP_BREAKPOINT) && !(c->flags & DISABLE_DEBUG_MODE)) {
+			uint32_t aip = ptr[0];
+
+			igt_assert_f(aip != SHADER_CANARY, "Workload executed but breakpoint not hit!\n");
+			igt_assert_eq(count_canaries_eq(ptr, w_dim, aip), data->threads_count);
+			igt_debug("Breakpoint hit in %d threads, AIP=0x%08x\n", data->threads_count, aip);
+		}
+
+		munmap(ptr, buf->size);
+	}
+
+	intel_bb_destroy(ibb);
+
+	xe_eudebug_client_exec_queue_destroy(c, fd, &create);
+	xe_eudebug_client_vm_destroy(c, fd,  create.vm_id);
+
+	xe_eudebug_client_metadata_destroy(c, fd, metadata_id[0], DRM_XE_DEBUG_METADATA_ELF_BINARY,
+					   2 * sizeof(*metadata));
+	xe_eudebug_client_metadata_destroy(c, fd, metadata_id[1],
+					   DRM_XE_DEBUG_METADATA_PROGRAM_MODULE,
+					   2 * sizeof(*metadata));
+
+	xe_device_put(fd);
+	xe_eudebug_client_close_driver(c, fd);
+}
+
+static bool intel_gen_has_lockstep_eus(int fd)
+{
+	const uint32_t id = intel_get_drm_devid(fd);
+
+	/*
+	 * Lockstep (or in some parlance, fused) EUs are pair of EUs
+	 * that work in sync, supposedly same clock and same control flow.
+	 * Thus for attentions, if the control has breakpoint, both will be
+	 * excepted into SIP. In this level, the hardware has only one attention
+	 * thread bit for units. PVC is the first one without lockstepping.
+	 */
+	return !(intel_graphics_ver(id) == IP_VER(12, 60) || intel_gen(id) >= 20);
+}
+
+static int query_attention_bitmask_size(int fd, int gt)
+{
+	const unsigned int threads = 8;
+	struct drm_xe_query_topology_mask *c_dss = NULL, *g_dss = NULL, *eu_per_dss = NULL;
+	struct drm_xe_query_topology_mask *topology;
+	struct drm_xe_device_query query = {
+		.extensions = 0,
+		.query = DRM_XE_DEVICE_QUERY_GT_TOPOLOGY,
+		.size = 0,
+		.data = 0,
+	};
+	int pos = 0, eus;
+	uint8_t *any_dss;
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEVICE_QUERY, &query), 0);
+	igt_assert_neq(query.size, 0);
+
+	topology = malloc(query.size);
+	igt_assert(topology);
+
+	query.data = to_user_pointer(topology);
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEVICE_QUERY, &query), 0);
+
+	while (query.size >= sizeof(struct drm_xe_query_topology_mask)) {
+		struct drm_xe_query_topology_mask *topo;
+		int sz;
+
+		topo = (struct drm_xe_query_topology_mask *)((unsigned char *)topology + pos);
+		sz = sizeof(struct drm_xe_query_topology_mask) + topo->num_bytes;
+
+		query.size -= sz;
+		pos += sz;
+
+		if (topo->gt_id != gt)
+			continue;
+
+		if (topo->type == DRM_XE_TOPO_DSS_GEOMETRY)
+			g_dss = topo;
+		else if (topo->type == DRM_XE_TOPO_DSS_COMPUTE)
+			c_dss = topo;
+		else if (topo->type == DRM_XE_TOPO_EU_PER_DSS ||
+			 topo->type == DRM_XE_TOPO_SIMD16_EU_PER_DSS)
+			eu_per_dss = topo;
+	}
+
+	igt_assert(g_dss && c_dss && eu_per_dss);
+	igt_assert_eq_u32(c_dss->num_bytes, g_dss->num_bytes);
+
+	any_dss = malloc(c_dss->num_bytes);
+
+	for (int i = 0; i < c_dss->num_bytes; i++)
+		any_dss[i] = c_dss->mask[i] | g_dss->mask[i];
+
+	eus = count_set_bits(any_dss, c_dss->num_bytes);
+	eus *= count_set_bits(eu_per_dss->mask, eu_per_dss->num_bytes);
+
+	if (intel_gen_has_lockstep_eus(fd))
+		eus /= 2;
+
+	free(any_dss);
+	free(topology);
+
+	return eus * threads / 8;
+}
+
+static struct drm_xe_eudebug_event_exec_queue *
+match_attention_with_exec_queue(struct xe_eudebug_event_log *log,
+				struct drm_xe_eudebug_event_eu_attention *ea)
+{
+	struct drm_xe_eudebug_event_exec_queue *ee;
+	struct drm_xe_eudebug_event *event = NULL, *current = NULL, *matching_destroy = NULL;
+	int lrc_idx;
+
+	xe_eudebug_for_each_event(event, log) {
+		if (event->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE &&
+		    event->flags == DRM_XE_EUDEBUG_EVENT_CREATE) {
+			ee = (struct drm_xe_eudebug_event_exec_queue *)event;
+
+			if (ee->exec_queue_handle != ea->exec_queue_handle)
+				continue;
+
+			if (ee->client_handle != ea->client_handle)
+				continue;
+
+			for (lrc_idx = 0; lrc_idx < ee->width; lrc_idx++) {
+				if (ee->lrc_handle[lrc_idx] == ea->lrc_handle)
+					break;
+			}
+
+			if (lrc_idx >= ee->width) {
+				igt_debug("No matching lrc handle within matching exec_queue!");
+				continue;
+			}
+
+			/* event logs are sorted, every found next would not be present. */
+			if (ea->base.seqno < ee->base.seqno)
+				break;
+
+			/* sanity check whether attention did
+			 * not appear yet on already destroyed exec_queue
+			 */
+			current = event;
+			xe_eudebug_for_each_event(current, log) {
+				if (current->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE &&
+				    current->flags == DRM_XE_EUDEBUG_EVENT_DESTROY) {
+					uint8_t offset = sizeof(struct drm_xe_eudebug_event);
+
+					if (memcmp((uint8_t *)current + offset,
+						   (uint8_t *)event + offset,
+						   current->len - offset) == 0) {
+						matching_destroy = current;
+					}
+				}
+			}
+
+			if (!matching_destroy || ea->base.seqno > matching_destroy->seqno)
+				continue;
+
+			return ee;
+		}
+	}
+
+	return NULL;
+}
+
+static void online_session_check(struct xe_eudebug_session *s, int flags)
+{
+	struct drm_xe_eudebug_event_eu_attention *ea = NULL;
+	struct drm_xe_eudebug_event *event = NULL;
+	struct online_debug_data *data = s->c->ptr;
+	bool expect_exception = flags & DISABLE_DEBUG_MODE ? false : true;
+	int sum = 0;
+	int bitmask_size;
+
+	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_UFENCE);
+
+	bitmask_size = query_attention_bitmask_size(s->d->master_fd, data->hwe.gt_id);
+
+	xe_eudebug_for_each_event(event, s->d->log) {
+		if (event->type == DRM_XE_EUDEBUG_EVENT_EU_ATTENTION) {
+			ea = (struct drm_xe_eudebug_event_eu_attention *)event;
+
+			igt_assert(event->flags == DRM_XE_EUDEBUG_EVENT_STATE_CHANGE);
+			igt_assert_eq(ea->bitmask_size, bitmask_size);
+			sum += count_set_bits(ea->bitmask, bitmask_size);
+			igt_assert(match_attention_with_exec_queue(s->d->log, ea));
+		}
+	}
+
+	/*
+	 * We can expect attention to sum up only
+	 * if we have a breakpoint set and we resume all threads always.
+	 */
+	if (flags == SHADER_BREAKPOINT)
+		igt_assert_eq(sum, data->threads_count);
+
+	if (expect_exception)
+		igt_assert(sum > 0);
+	else
+		igt_assert(sum == 0);
+}
+
+static void ufence_ack_trigger(struct xe_eudebug_debugger *d,
+			       struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e;
+
+	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE)
+		xe_eudebug_ack_ufence(d->fd, ef);
+}
+
+/**
+ * SUBTEST: basic-breakpoint
+ * Description:
+ *	Check whether KMD sends attention events
+ *	for workload in debug mode stopped on breakpoint.
+ *
+ * SUBTEST: breakpoint-not-in-debug-mode
+ * Description:
+ *	Check whether KMD resets the GPU when it spots an attention
+ *	coming from workload not in debug mode.
+ *
+ * SUBTEST: stopped-thread
+ * Description:
+ *	Hits breakpoint on runalone workload and
+ *	reads attention for fixed time.
+ *
+ * SUBTEST: resume-%s
+ * Description:
+ *	Resumes stopped on a breakpoint workload
+ *	with granularity of %arg[1].
+ *
+ *
+ * arg[1]:
+ *
+ * @one:	one thread
+ * @dss:	threads running on one subslice
+ */
+static void test_basic_online(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	xe_eudebug_session_run(s);
+	online_session_check(s, s->flags);
+
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+/**
+ * SUBTEST: preempt-breakpoint
+ * Description:
+ *	Verify that eu debugger disables preemption timeout to
+ *	prevent reset of workload stopped on breakpoint.
+ */
+static void test_preemption(int fd, struct drm_xe_engine_class_instance *hwe)
+{
+	int flags = SHADER_BREAKPOINT | TRIGGER_RESUME_DELAYED;
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+	struct xe_eudebug_client *other;
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	other = xe_eudebug_client_create(fd, run_online_client, SHADER_NOP, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+
+	xe_eudebug_client_start(s->c);
+	sleep(1); /* make sure s->c starts first */
+	xe_eudebug_client_start(other);
+
+	xe_eudebug_client_wait_done(s->c);
+	xe_eudebug_client_wait_done(other);
+
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	xe_eudebug_session_destroy(s);
+	xe_eudebug_client_destroy(other);
+
+	igt_assert_f(data->last_eu_control_seqno != 0,
+		     "Workload with breakpoint has ended without resume!\n");
+
+	online_debug_data_destroy(data);
+}
+
+/**
+ * SUBTEST: reset-with-attention
+ * Description:
+ *	Check whether GPU is usable after resetting with attention raised 
+ *	(stopped on breakpoint) by running the same workload again.
+ */
+static void test_reset_with_attention_online(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s1, *s2;
+	struct online_debug_data *data;
+
+	data = online_debug_data_create(hwe);
+	s1 = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s1->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_reset_trigger);
+	xe_eudebug_debugger_add_trigger(s1->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	xe_eudebug_session_run(s1);
+	xe_eudebug_session_destroy(s1);
+
+	s2 = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	xe_eudebug_debugger_add_trigger(s2->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_trigger);
+	xe_eudebug_debugger_add_trigger(s2->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	xe_eudebug_session_run(s2);
+
+	online_session_check(s2, s2->flags);
+
+	xe_eudebug_session_destroy(s2);
+	online_debug_data_destroy(data);
+}
+
+/**
+ * SUBTEST: interrupt-all
+ * Description:
+ *	Schedules EU workload which should last about a few seconds, then
+ *	interrupts all threads, checks whether attention event came, and
+ *	resumes stopped threads back.
+ *
+ * SUBTEST: interrupt-all-set-breakpoint
+ * Description:
+ *	Schedules EU workload which should last about a few seconds, then
+ *	interrupts all threads, once attention event come it sets breakpoint on
+ *	the very next instruction and resumes stopped threads back. It expects
+ *	that every thread hits the breakpoint.
+ */
+static void test_interrupt_all(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+	uint32_t val;
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
+					open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
+					exec_queue_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
+					create_metadata_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+	xe_eudebug_client_start(s->c);
+
+	/* wait for workload to start */
+	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
+		/* collect needed data from triggers */
+		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
+			continue;
+
+		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
+			if (val != 0)
+				break;
+	}
+
+	pthread_mutex_lock(&data->mutex);
+	igt_assert(data->client_handle != -1);
+	igt_assert(data->exec_queue_handle != -1);
+	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
+			     data->exec_queue_handle, data->lrc_handle);
+	pthread_mutex_unlock(&data->mutex);
+
+	xe_eudebug_client_wait_done(s->c);
+
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	xe_eudebug_event_log_print(s->d->log, true);
+	xe_eudebug_event_log_print(s->c->log, true);
+
+	online_session_check(s, s->flags);
+
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+static void reset_debugger_log(struct xe_eudebug_debugger *d)
+{
+	unsigned int max_size;
+	char log_name[80];
+
+	/* Don't pull the rug out from under an active debugger */
+	igt_assert(d->target_pid == 0);
+
+	max_size = d->log->max_size;
+	strncpy(log_name, d->log->name, sizeof(d->log->name) - 1);
+	log_name[79] = '\0';
+	xe_eudebug_event_log_destroy(d->log);
+	d->log = xe_eudebug_event_log_create(log_name, max_size);
+}
+
+/**
+ * SUBTEST: interrupt-other-debuggable
+ * Description:
+ *	Schedules EU workload in runalone mode with never ending loop, while
+ *	it is not under debug, tries to interrupt all threads using the different
+ *	client attached to debugger.
+ *
+ * SUBTEST: interrupt-other
+ * Description:
+ * 	Schedules EU workload with a never ending loop and, while it is not
+ * 	configured for debugging, tries to interrupt all threads using the client
+ * 	attached to debugger.
+ */
+static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct online_debug_data *data;
+	struct online_debug_data *debugee_data;
+	struct xe_eudebug_session *s;
+	struct xe_eudebug_client *debugee;
+	int debugee_flags = SHADER_LOOP | DO_NOT_EXPECT_CANARIES;
+	int val;
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
+					exec_queue_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
+					create_metadata_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+	xe_eudebug_client_start(s->c);
+
+	/* wait for workload to start */
+	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
+		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
+			continue;
+
+		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
+			if (val != 0)
+				break;
+	}
+	igt_assert_f(val != 0, "Workload execution is not yet started\n");
+
+	xe_eudebug_debugger_dettach(s->d);
+	reset_debugger_log(s->d);
+
+	debugee_data = online_debug_data_create(hwe);
+	s->d->ptr = debugee_data;
+	debugee = xe_eudebug_client_create(fd, run_online_client, debugee_flags, debugee_data);
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, debugee), 0);
+	xe_eudebug_client_start(debugee);
+
+	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
+		if (READ_ONCE(debugee_data->vm_fd) == -1 || READ_ONCE(debugee_data->target_size) == 0)
+			continue;
+	}
+
+	pthread_mutex_lock(&debugee_data->mutex);
+	igt_assert(debugee_data->client_handle != -1);
+	igt_assert(debugee_data->exec_queue_handle != -1);
+	/* Interrupting the other client should return invalid state
+	 * as it is running in runalone mode */
+	igt_assert_eq(__eu_ctl(s->d->fd, debugee_data->client_handle,
+		       debugee_data->exec_queue_handle, debugee_data->lrc_handle,
+		       NULL, 0, DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL), -EINVAL);
+	pthread_mutex_unlock(&debugee_data->mutex);
+
+	xe_force_gt_reset_async(s->d->master_fd, debugee_data->hwe.gt_id);
+
+	xe_eudebug_client_wait_done(debugee);
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	xe_eudebug_event_log_print(s->d->log, true);
+	xe_eudebug_event_log_print(debugee->log, true);
+
+	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND |
+				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP |
+				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
+
+	xe_eudebug_client_destroy(debugee);
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+	online_debug_data_destroy(debugee_data);
+}
+
+/**
+ * SUBTEST: tdctl-parameters
+ * Description:
+ *	Schedules EU workload which should last about a few seconds, then
+ *	checks negative scenarios of EU_THREADS ioctl usage, interrupts all threads,
+ *	checks whether attention event came, and resumes stopped threads back.
+ */
+static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+	uint32_t val;
+	uint32_t random_command;
+	uint32_t bitmask_size = query_attention_bitmask_size(fd, hwe->gt_id);
+	uint8_t *attention_bitmask = malloc(bitmask_size * sizeof(uint8_t));
+	igt_assert(attention_bitmask);
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
+					open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
+					exec_queue_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
+					create_metadata_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+	xe_eudebug_client_start(s->c);
+
+	/* wait for workload to start */
+	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
+		/* collect needed data from triggers */
+		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
+			continue;
+
+		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
+			if (val != 0)
+				break;
+	}
+
+	pthread_mutex_lock(&data->mutex);
+	igt_assert(data->client_handle != -1);
+	igt_assert(data->exec_queue_handle != -1);
+	igt_assert(data->lrc_handle != -1);
+
+	/* fail on invalid lrc_handle */
+	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
+			    data->exec_queue_handle, data->lrc_handle + 1,
+			    attention_bitmask, &bitmask_size,
+			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
+
+	/* fail on invalid exec_queue_handle */
+	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
+			    data->exec_queue_handle + 1, data->lrc_handle,
+			    attention_bitmask, &bitmask_size,
+			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
+
+	/* fail on invalid client */
+	igt_assert(__eu_ctl(s->d->fd, data->client_handle + 1,
+			    data->exec_queue_handle, data->lrc_handle,
+			    attention_bitmask, &bitmask_size,
+			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
+
+	/*
+	 * bitmask size must be aligned to sizeof(u32) for all commands
+	 * and be zero for interrupt all
+	 */
+	bitmask_size = sizeof(uint32_t) - 1;
+	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
+			    data->exec_queue_handle, data->lrc_handle,
+			    attention_bitmask, &bitmask_size,
+			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED, NULL) == -EINVAL);
+	bitmask_size = 0;
+
+	/* fail on invalid command */
+	random_command = random() | (DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME + 1);
+	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
+			    data->exec_queue_handle, data->lrc_handle,
+			    attention_bitmask, &bitmask_size, random_command, NULL) == -EINVAL);
+
+	free(attention_bitmask);
+
+	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
+			     data->exec_queue_handle, data->lrc_handle);
+	pthread_mutex_unlock(&data->mutex);
+
+	xe_eudebug_client_wait_done(s->c);
+
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	xe_eudebug_event_log_print(s->d->log, true);
+	xe_eudebug_event_log_print(s->c->log, true);
+
+	online_session_check(s, s->flags);
+
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+static void eu_attention_debugger_detach_trigger(struct xe_eudebug_debugger *d,
+						 struct drm_xe_eudebug_event *event)
+{
+	struct online_debug_data *data = d->ptr;
+	uint64_t c_pid;
+	int ret;
+
+	c_pid = d->target_pid;
+
+	/* Reset VM data so the re-triggered VM open handler works properly */
+	data->vm_fd = -1;
+
+	xe_eudebug_debugger_dettach(d);
+
+	/* Let the KMD scan function notice unhandled EU attention */
+	if (!(d->flags & SHADER_N_NOOP_BREAKPOINT))
+		sleep(1);
+
+	/*
+	 * New session that is created by EU debugger on reconnect restarts
+	 * seqno, causing isses with log sorting. To avoid that, create
+	 * a new event log.
+	 */
+	reset_debugger_log(d);
+
+	ret = xe_eudebug_connect(d->master_fd, c_pid, 0);
+	igt_assert(ret >= 0);
+	d->fd = ret;
+	d->target_pid = c_pid;
+
+	/* Let the discovery worker discover resources */
+	sleep(2);
+
+	if (!(d->flags & SHADER_N_NOOP_BREAKPOINT))
+		xe_eudebug_debugger_signal_stage(d, DEBUGGER_REATTACHED);
+}
+
+/**
+ * SUBTEST: interrupt-reconnect
+ * Description:
+ *	Schedules EU workload which should last about a few seconds,
+ *	interrupts all threads and detaches debugger when attention is
+ *	raised. The test checks if KMD resets the workload when there's
+ *	no debugger attached and does the event playback on discovery.
+ */
+static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct drm_xe_eudebug_event *e = NULL;
+	struct online_debug_data *data;
+	struct xe_eudebug_session *s;
+	uint32_t val;
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
+					open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
+					exec_queue_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debugger_detach_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
+					create_metadata_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
+	xe_eudebug_debugger_start_worker(s->d);
+	xe_eudebug_client_start(s->c);
+
+	/* wait for workload to start */
+	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
+		/* collect needed data from triggers */
+		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
+			continue;
+
+		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
+			if (val != 0)
+				break;
+	}
+
+	pthread_mutex_lock(&data->mutex);
+	igt_assert(data->client_handle != -1);
+	igt_assert(data->exec_queue_handle != -1);
+	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
+			     data->exec_queue_handle, data->lrc_handle);
+	pthread_mutex_unlock(&data->mutex);
+
+	xe_eudebug_client_wait_done(s->c);
+
+	xe_eudebug_debugger_stop_worker(s->d, 1);
+
+	xe_eudebug_event_log_print(s->d->log, true);
+	xe_eudebug_event_log_print(s->c->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_UFENCE);
+
+	/* We expect workload reset, so no attention should be raised */
+	xe_eudebug_for_each_event(e, s->d->log)
+		igt_assert(e->type != DRM_XE_EUDEBUG_EVENT_EU_ATTENTION);
+
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+/**
+ * SUBTEST: single-step
+ * Description:
+ *	Schedules EU workload with 16 nops after breakpoint, then single-steps
+ *	through the shader, advances all threads each step, checking if all
+ *	threads advanced every step.
+ *
+ * SUBTEST: single-step-one
+ * Description:
+ *	Schedules EU workload with 16 nops after breakpoint, then single-steps
+ *	through the shader, advances one thread each step, checking if one
+ *	thread advanced every step. Due to the time constraint, only first two
+ *	shader instructions after breakpoint are validated.
+ */
+static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
+					open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_single_step_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
+					create_metadata_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	xe_eudebug_session_run(s);
+	online_session_check(s, s->flags);
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+static void eu_attention_debugger_ndetach_trigger(struct xe_eudebug_debugger *d,
+						 struct drm_xe_eudebug_event *event)
+{
+	static int debugger_detach_count;
+
+	if (debugger_detach_count < (SHADER_LOOP_N - 1)) {
+		/* Make sure the resume command has issued before detaching the debugger */
+		if (!is_client_resumed)
+			return;
+		eu_attention_debugger_detach_trigger(d, event);
+		debugger_detach_count++;
+	} else {
+		igt_debug("Reached Nth breakpoint hence preventing the debugger detach\n");
+	}
+	is_client_resumed = 0;
+}
+
+/**
+ * SUBTEST: debugger-reopen
+ * Description:
+ *	Check whether the debugger is able to reopen the connection and
+ *	capture the events of already running client.
+ */
+static void test_debugger_reopen(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+
+	data = online_debug_data_create(hwe);
+
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debugger_ndetach_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	xe_eudebug_session_run(s);
+
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+/**
+ * SUBTEST: writes-caching-%s
+ * Description:
+ *	Write incrementing values to 2-page-long target surface, poisoning the data one breakpoint
+ *	before each write instruction and restoring it when the poisoned instruction breakpoint
+ *	is hit. Expect to never see poison values in target surface.
+ *
+ *
+ * arg[1]:
+ *
+ * @sram:	Use page size of SRAM
+ * @vram:	Use page size of VRAM
+ */
+static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
+{
+	struct xe_eudebug_session *s;
+	struct online_debug_data *data;
+
+	if (flags & SHADER_CACHING_VRAM)
+		igt_skip_on_f(!xe_has_vram(fd), "Device does not have VRAM.\n");
+
+	data = online_debug_data_create(hwe);
+	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
+					open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_debug_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+					eu_attention_resume_caching_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
+					create_metadata_trigger);
+	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+					ufence_ack_trigger);
+
+	xe_eudebug_session_run(s);
+	online_session_check(s, s->flags);
+	xe_eudebug_session_destroy(s);
+	online_debug_data_destroy(data);
+}
+
+static int wait_for_exception(struct online_debug_data *data, int timeout)
+{
+	int ret = -ETIMEDOUT;
+
+	igt_for_milliseconds(timeout) {
+		pthread_mutex_lock(&data->mutex);
+		if ((data->exception_arrived.tv_sec |
+		     data->exception_arrived.tv_nsec) != 0)
+			ret = 0;
+		pthread_mutex_unlock(&data->mutex);
+
+		if (!ret)
+			break;
+		usleep(1000);
+	}
+
+	return ret;
+}
+
+#define is_compute_on_gt(__e, __gt) ((__e->engine_class == DRM_XE_ENGINE_CLASS_RENDER || \
+				      __e->engine_class == DRM_XE_ENGINE_CLASS_COMPUTE) && \
+				      __e->gt_id == __gt)
+
+struct xe_engine_list_entry {
+	struct igt_list_head link;
+	struct drm_xe_engine_class_instance *hwe;
+};
+
+#define MAX_TILES	2
+static int find_suitable_engines(struct drm_xe_engine_class_instance *hwes[GEM_MAX_ENGINES],
+				 int fd, bool many_tiles)
+{
+	struct xe_device *xe_dev;
+	struct drm_xe_engine_class_instance *e;
+	struct xe_engine_list_entry *en, *tmp;
+	struct igt_list_head compute_engines[MAX_TILES];
+	int gt_id;
+	int tile_id, i, engine_count = 0, tile_count = 0;
+
+	xe_dev = xe_device_get(fd);
+
+	for (i = 0; i < MAX_TILES; i++)
+		IGT_INIT_LIST_HEAD(&compute_engines[i]);
+
+	xe_for_each_gt(fd, gt_id) {
+		xe_for_each_engine(fd, e) {
+			if (is_compute_on_gt(e, gt_id)) {
+				tile_id = xe_dev->gt_list->gt_list[gt_id].tile_id;
+
+				en = malloc(sizeof(struct xe_engine_list_entry));
+				en->hwe = e;
+
+				igt_list_add_tail(&en->link, &compute_engines[tile_id]);
+			}
+		}
+	}
+
+	for (i = 0; i < MAX_TILES; i++) {
+		if (igt_list_empty(&compute_engines[i]))
+			continue;
+
+		if (many_tiles) {
+			en = igt_list_first_entry(&compute_engines[i], en, link);
+			hwes[engine_count++] = en->hwe;
+			tile_count++;
+		} else {
+			if (igt_list_length(&compute_engines[i]) > 1) {
+				igt_list_for_each_entry(en, &compute_engines[i], link)
+					hwes[engine_count++] = en->hwe;
+				break;
+			}
+		}
+	}
+
+	for (i = 0; i < MAX_TILES; i++) {
+		igt_list_for_each_entry_safe(en, tmp, &compute_engines[i], link) {
+			igt_list_del(&en->link);
+			free(en);
+		}
+	}
+
+	if (many_tiles)
+		igt_require_f(tile_count > 1, "Mulit-tile scenario requires more tiles\n");
+
+	return engine_count;
+}
+
+/**
+ * SUBTEST: breakpoint-many-sessions-single-tile
+ * Description:
+ *	Schedules EU workload with preinstalled breakpoint on every compute engine
+ *	available on the tile. Checks if the contexts hit breakpoint in sequence
+ *	and resumes them.
+ *
+ * SUBTEST: breakpoint-many-sessions-tiles
+ * Description:
+ *	Schedules EU workload with preinstalled breakpoint on selected compute
+ *      engines, with one per tile. Checks if each context hit breakpoint and
+ *      resumes them.
+ */
+static void test_many_sessions_on_tiles(int fd, bool multi_tile)
+{
+	int n = 0, flags = SHADER_BREAKPOINT | SHADER_MIN_THREADS;
+	struct xe_eudebug_session *s[GEM_MAX_ENGINES] = {};
+	struct online_debug_data *data[GEM_MAX_ENGINES] = {};
+	struct drm_xe_engine_class_instance *hwe[GEM_MAX_ENGINES] = {};
+	struct drm_xe_eudebug_event_eu_attention *eus;
+	uint64_t current_t, next_t, diff;
+	int i;
+
+	n = find_suitable_engines(hwe, fd, multi_tile);
+
+	igt_require_f(n > 1, "Test requires at least two parallel compute engines!\n");
+
+	for (i = 0; i < n; i++) {
+		data[i] = online_debug_data_create(hwe[i]);
+		s[i] = xe_eudebug_session_create(fd, run_online_client, flags, data[i]);
+
+		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+						eu_attention_debug_trigger);
+		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
+						save_first_exception_trigger);
+		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
+						ufence_ack_trigger);
+
+		igt_assert_eq(xe_eudebug_debugger_attach(s[i]->d, s[i]->c), 0);
+
+		xe_eudebug_debugger_start_worker(s[i]->d);
+		xe_eudebug_client_start(s[i]->c);
+	}
+
+	for (i = 0; i < n; i++) {
+		/* XXX: Sometimes racy, expects clients to execute in sequence */
+		igt_assert(!wait_for_exception(data[i], STARTUP_TIMEOUT_MS));
+
+		eus = (struct drm_xe_eudebug_event_eu_attention *)data[i]->exception_event;
+
+		/* Delay all but the last workload to check serialization */
+		if (i < n - 1)
+			usleep(WORKLOAD_DELAY_US);
+
+		eu_ctl_resume(s[i]->d->master_fd, s[i]->d->fd,
+			      eus->client_handle, eus->exec_queue_handle,
+			      eus->lrc_handle, eus->bitmask, eus->bitmask_size);
+		free(eus);
+	}
+
+	for (i = 0; i < n - 1; i++) {
+		/* Convert timestamps to microseconds */
+		current_t = data[i]->exception_arrived.tv_nsec * 1000;
+		next_t = data[i + 1]->exception_arrived.tv_nsec * 1000;
+		diff = current_t < next_t ? next_t - current_t : current_t - next_t;
+
+		if (multi_tile)
+			igt_assert_f(diff < WORKLOAD_DELAY_US,
+				     "Expected to execute workloads concurrently. Actual delay: %lu ms\n",
+				     diff);
+		else
+			igt_assert_f(diff >= WORKLOAD_DELAY_US,
+				     "Expected a serialization of workloads. Actual delay: %lu ms\n",
+				     diff);
+	}
+
+	for (i = 0; i < n; i++) {
+		xe_eudebug_client_wait_done(s[i]->c);
+		xe_eudebug_debugger_stop_worker(s[i]->d, 1);
+
+		xe_eudebug_event_log_print(s[i]->d->log, true);
+		online_session_check(s[i], flags);
+
+		xe_eudebug_session_destroy(s[i]);
+		online_debug_data_destroy(data[i]);
+	}
+}
+
+static struct drm_xe_engine_class_instance *pick_compute(int fd, int gt)
+{
+	struct drm_xe_engine_class_instance *hwe;
+	int count = 0;
+
+	xe_for_each_engine(fd, hwe)
+		if (is_compute_on_gt(hwe, gt))
+			count++;
+
+	xe_for_each_engine(fd, hwe)
+		if (is_compute_on_gt(hwe, gt) && rand() % count-- == 0)
+			return hwe;
+
+	return NULL;
+}
+
+#define test_gt_render_or_compute(t, i915, __hwe) \
+	igt_subtest_with_dynamic(t) \
+		for (int gt = 0; (__hwe = pick_compute(i915, gt)); gt++) \
+			igt_dynamic_f("%s%d", xe_engine_class_string(__hwe->engine_class), hwe->engine_instance)
+
+igt_main
+{
+	struct drm_xe_engine_class_instance *hwe;
+	bool was_enabled;
+	int fd;
+
+	igt_fixture {
+		fd = drm_open_driver(DRIVER_XE);
+		intel_allocator_multiprocess_start();
+		igt_srandom();
+		was_enabled = xe_eudebug_enable(fd, true);
+	}
+
+	test_gt_render_or_compute("basic-breakpoint", fd, hwe)
+		test_basic_online(fd, hwe, SHADER_BREAKPOINT);
+
+	test_gt_render_or_compute("preempt-breakpoint", fd, hwe)
+		test_preemption(fd, hwe);
+
+	test_gt_render_or_compute("breakpoint-not-in-debug-mode", fd, hwe)
+		test_basic_online(fd, hwe, SHADER_BREAKPOINT | DISABLE_DEBUG_MODE);
+
+	test_gt_render_or_compute("stopped-thread", fd, hwe)
+		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_DELAYED);
+
+	test_gt_render_or_compute("resume-one", fd, hwe)
+		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_ONE);
+
+	test_gt_render_or_compute("resume-dss", fd, hwe)
+		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_DSS);
+
+	test_gt_render_or_compute("interrupt-all", fd, hwe)
+		test_interrupt_all(fd, hwe, SHADER_LOOP);
+
+	test_gt_render_or_compute("interrupt-other-debuggable", fd, hwe)
+		test_interrupt_other(fd, hwe, SHADER_LOOP);
+
+	test_gt_render_or_compute("interrupt-other", fd, hwe)
+		test_interrupt_other(fd, hwe, SHADER_LOOP | DISABLE_DEBUG_MODE);
+
+	test_gt_render_or_compute("interrupt-all-set-breakpoint", fd, hwe)
+		test_interrupt_all(fd, hwe, SHADER_LOOP | TRIGGER_RESUME_SET_BP);
+
+	test_gt_render_or_compute("tdctl-parameters", fd, hwe)
+		test_tdctl_parameters(fd, hwe, SHADER_LOOP);
+
+	test_gt_render_or_compute("reset-with-attention", fd, hwe)
+		test_reset_with_attention_online(fd, hwe, SHADER_BREAKPOINT);
+
+	test_gt_render_or_compute("interrupt-reconnect", fd, hwe)
+		test_interrupt_reconnect(fd, hwe, SHADER_LOOP | TRIGGER_RECONNECT);
+
+	test_gt_render_or_compute("single-step", fd, hwe)
+		test_single_step(fd, hwe, SHADER_SINGLE_STEP | SIP_SINGLE_STEP |
+				 TRIGGER_RESUME_PARALLEL_WALK);
+
+	test_gt_render_or_compute("single-step-one", fd, hwe)
+		test_single_step(fd, hwe, SHADER_SINGLE_STEP | SIP_SINGLE_STEP |
+				 TRIGGER_RESUME_SINGLE_WALK);
+
+	test_gt_render_or_compute("debugger-reopen", fd, hwe)
+		test_debugger_reopen(fd, hwe, SHADER_N_NOOP_BREAKPOINT);
+
+	test_gt_render_or_compute("writes-caching-sram", fd, hwe)
+		test_caching(fd, hwe, SHADER_CACHING_SRAM);
+
+	test_gt_render_or_compute("writes-caching-vram", fd, hwe)
+		test_caching(fd, hwe, SHADER_CACHING_VRAM);
+
+	igt_subtest("breakpoint-many-sessions-single-tile")
+		test_many_sessions_on_tiles(fd, false);
+
+	igt_subtest("breakpoint-many-sessions-tiles")
+		test_many_sessions_on_tiles(fd, true);
+
+	igt_fixture {
+		xe_eudebug_enable(fd, was_enabled);
+
+		intel_allocator_multiprocess_stop();
+		drm_close_driver(fd);
+	}
+}
diff --git a/tests/meson.build b/tests/meson.build
index 35bf8ed35..f18eec7e7 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -280,6 +280,7 @@ intel_xe_progs = [
 	'xe_debugfs',
 	'xe_drm_fdinfo',
 	'xe_eudebug',
+	'xe_eudebug_online',
 	'xe_evict',
 	'xe_evict_ccs',
 	'xe_exec_atomic',
-- 
2.34.1

[PATCH i-g-t v3 14/14] tests/xe_live_ktest: Add xe_eudebug live test

[Christoph Manszewski]

xe_eudebug introduces a dedicated kunit test to the live test module.
Add it to the list of live tests to be executed.

Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
---
 tests/intel/xe_live_ktest.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/intel/xe_live_ktest.c b/tests/intel/xe_live_ktest.c
index 4376d5df7..50af97ecc 100644
--- a/tests/intel/xe_live_ktest.c
+++ b/tests/intel/xe_live_ktest.c
@@ -30,6 +30,11 @@
  * Description:
  *	Kernel dynamic selftests to check mocs configuration.
  * Functionality: mocs configuration
+ *
+ * SUBTEST: xe_eudebug
+ * Description:
+ *	Kernel dynamic selftests to check eudebug functionality.
+ * Functionality: eudebug kunit
  */
 
 static const char *live_tests[] = {
@@ -37,6 +42,7 @@ static const char *live_tests[] = {
 	"xe_dma_buf",
 	"xe_migrate",
 	"xe_mocs",
+	"xe_eudebug",
 };
 
 igt_main
-- 
2.34.1

✗ GitLab.Pipeline: warning for Test coverage for GPU debug support (rev3)

[Patchwork]

== Series Details ==

Series: Test coverage for GPU debug support (rev3)
URL   : https://patchwork.freedesktop.org/series/136623/
State : warning

== Summary ==

Pipeline status: FAILED.

see https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/pipelines/1245140 for the overview.

build:tests-debian-meson-armhf has failed (https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/jobs/62081847):
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                    ~~~~~
  ../lib/igt_core.h:1257:64: note: in definition of macro ‘igt_debug’
   #define igt_debug(f...) igt_log(IGT_LOG_DOMAIN, IGT_LOG_DEBUG, f)
                                                                  ^
  ../lib/xe/xe_eudebug.c: In function ‘xe_eudebug_client_exec_queue_create’:
  ../lib/xe/xe_eudebug.c:1792:20: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
    uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
                      ^
  ../lib/xe/xe_eudebug.c: In function ‘xe_eudebug_client_exec_queue_destroy’:
  ../lib/xe/xe_eudebug.c:1816:20: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
    uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
                      ^
  cc1: some warnings being treated as errors
  ninja: build stopped: subcommand failed.
  section_end:1723210264:step_script
  section_start:1723210264:cleanup_file_variables
  Cleaning up project directory and file based variables
  section_end:1723210265:cleanup_file_variables
  ERROR: Job failed: exit code 1
  

build:tests-debian-meson-mips has failed (https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/jobs/62081849):
              ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                    ~~~~~
  ../lib/igt_core.h:1257:64: note: in definition of macro ‘igt_debug’
   #define igt_debug(f...) igt_log(IGT_LOG_DOMAIN, IGT_LOG_DEBUG, f)
                                                                  ^
  ../lib/xe/xe_eudebug.c: In function ‘xe_eudebug_client_exec_queue_create’:
  ../lib/xe/xe_eudebug.c:1792:20: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
    uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
                      ^
  ../lib/xe/xe_eudebug.c: In function ‘xe_eudebug_client_exec_queue_destroy’:
  ../lib/xe/xe_eudebug.c:1816:20: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
    uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
                      ^
  cc1: some warnings being treated as errors
  ninja: build stopped: subcommand failed.
  section_end:1723210260:step_script
  section_start:1723210260:cleanup_file_variables
  Cleaning up project directory and file based variables
  section_end:1723210261:cleanup_file_variables
  ERROR: Job failed: exit code 1

== Logs ==

For more details see: https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/pipelines/1245140

✓ CI.xeBAT: success for Test coverage for GPU debug support (rev3)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 861 bytes --]

== Series Details ==

Series: Test coverage for GPU debug support (rev3)
URL   : https://patchwork.freedesktop.org/series/136623/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_7964_BAT -> XEIGTPW_11551_BAT
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (9 -> 9)
------------------------------

  No changes in participating hosts


Changes
-------

  No changes found


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

  * IGT: IGT_7964 -> IGTPW_11551

  IGTPW_11551: 11551
  IGT_7964: 0dabf88262c0349d261248638064b97da35369f8 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-1740-8d0f83b389ec64b9f7f9b2ee241fc352346868f1: 8d0f83b389ec64b9f7f9b2ee241fc352346868f1

== Logs ==

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

[-- Attachment #2: Type: text/html, Size: 1406 bytes --]

✓ Fi.CI.BAT: success for Test coverage for GPU debug support (rev3)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 3755 bytes --]

== Series Details ==

Series: Test coverage for GPU debug support (rev3)
URL   : https://patchwork.freedesktop.org/series/136623/
State : success

== Summary ==

CI Bug Log - changes from IGT_7964 -> IGTPW_11551
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

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

Participating hosts (37 -> 37)
------------------------------

  Additional (3): fi-cfl-8109u fi-bsw-n3050 fi-pnv-d510 
  Missing    (3): fi-glk-j4005 fi-snb-2520m fi-elk-e7500 

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

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

### IGT changes ###

#### Issues hit ####

  * igt@gem_huc_copy@huc-copy:
    - fi-cfl-8109u:       NOTRUN -> [SKIP][1] ([i915#2190])
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/fi-cfl-8109u/igt@gem_huc_copy@huc-copy.html

  * igt@gem_lmem_swapping@basic:
    - fi-pnv-d510:        NOTRUN -> [SKIP][2] +32 other tests skip
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/fi-pnv-d510/igt@gem_lmem_swapping@basic.html

  * igt@gem_lmem_swapping@random-engines:
    - fi-bsw-n3050:       NOTRUN -> [SKIP][3] +19 other tests skip
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/fi-bsw-n3050/igt@gem_lmem_swapping@random-engines.html

  * igt@gem_lmem_swapping@verify-random:
    - fi-cfl-8109u:       NOTRUN -> [SKIP][4] ([i915#4613]) +3 other tests skip
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/fi-cfl-8109u/igt@gem_lmem_swapping@verify-random.html

  * igt@i915_selftest@live@hangcheck:
    - bat-arls-2:         [PASS][5] -> [DMESG-WARN][6] ([i915#11349] / [i915#11378])
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/bat-arls-2/igt@i915_selftest@live@hangcheck.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/bat-arls-2/igt@i915_selftest@live@hangcheck.html

  * igt@kms_pm_backlight@basic-brightness:
    - fi-cfl-8109u:       NOTRUN -> [SKIP][7] +11 other tests skip
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/fi-cfl-8109u/igt@kms_pm_backlight@basic-brightness.html

  
#### Possible fixes ####

  * igt@i915_selftest@live@gt_lrc:
    - bat-adlp-11:        [INCOMPLETE][8] ([i915#9413]) -> [PASS][9]
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/bat-adlp-11/igt@i915_selftest@live@gt_lrc.html
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/bat-adlp-11/igt@i915_selftest@live@gt_lrc.html

  * igt@kms_pm_rpm@basic-pci-d3-state:
    - bat-arls-5:         [DMESG-WARN][10] ([i915#11898]) -> [PASS][11]
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/bat-arls-5/igt@kms_pm_rpm@basic-pci-d3-state.html
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/bat-arls-5/igt@kms_pm_rpm@basic-pci-d3-state.html

  
  [i915#11349]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11349
  [i915#11378]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11378
  [i915#11898]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11898
  [i915#2190]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2190
  [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
  [i915#9413]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9413


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

  * CI: CI-20190529 -> None
  * IGT: IGT_7964 -> IGTPW_11551

  CI-20190529: 20190529
  CI_DRM_15204: 040fda7980e8fccde054bf16158538ff80223e36 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_11551: 11551
  IGT_7964: 0dabf88262c0349d261248638064b97da35369f8 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

== Logs ==

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

[-- Attachment #2: Type: text/html, Size: 4560 bytes --]

Re: [PATCH i-g-t v3 01/14] drm-uapi/xe: Sync with oa uapi fix

[Kamil Konieczny]

Hi Christoph,
On 2024-08-09 at 14:38:00 +0200, Christoph Manszewski wrote:
> Align with kernel commit f2881dfdaaa9 ("drm/xe/oa/uapi: Make bit masks
> unsigned"). Use built header instead of raw uapi header.
> 
> Cc: Jonathan Cavitt <jonathan.cavitt@intel.com>
> Cc: Lucas De Marchi <lucas.demarchi@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>

Reviewed-by: Kamil Konieczny <kamil.konieczny@linux.intel.com>

> ---
>  include/drm-uapi/xe_drm.h | 16 ++++++++--------
>  1 file changed, 8 insertions(+), 8 deletions(-)
> 
> diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h
> index 29425d7fd..f0a450db9 100644
> --- a/include/drm-uapi/xe_drm.h
> +++ b/include/drm-uapi/xe_drm.h
> @@ -3,8 +3,8 @@
>   * Copyright © 2023 Intel Corporation
>   */
>  
> -#ifndef _UAPI_XE_DRM_H_
> -#define _UAPI_XE_DRM_H_
> +#ifndef _XE_DRM_H_
> +#define _XE_DRM_H_
>  
>  #include "drm.h"
>  
> @@ -134,7 +134,7 @@ extern "C" {
>   * redefine the interface more easily than an ever growing struct of
>   * increasing complexity, and for large parts of that interface to be
>   * entirely optional. The downside is more pointer chasing; chasing across
> - * the __user boundary with pointers encapsulated inside u64.
> + * the boundary with pointers encapsulated inside u64.
>   *
>   * Example chaining:
>   *
> @@ -1598,10 +1598,10 @@ enum drm_xe_oa_property_id {
>  	 * b. Counter select c. Counter size and d. BC report. Also refer to the
>  	 * oa_formats array in drivers/gpu/drm/xe/xe_oa.c.
>  	 */
> -#define DRM_XE_OA_FORMAT_MASK_FMT_TYPE		(0xff << 0)
> -#define DRM_XE_OA_FORMAT_MASK_COUNTER_SEL	(0xff << 8)
> -#define DRM_XE_OA_FORMAT_MASK_COUNTER_SIZE	(0xff << 16)
> -#define DRM_XE_OA_FORMAT_MASK_BC_REPORT		(0xff << 24)
> +#define DRM_XE_OA_FORMAT_MASK_FMT_TYPE		(0xffu << 0)
> +#define DRM_XE_OA_FORMAT_MASK_COUNTER_SEL	(0xffu << 8)
> +#define DRM_XE_OA_FORMAT_MASK_COUNTER_SIZE	(0xffu << 16)
> +#define DRM_XE_OA_FORMAT_MASK_BC_REPORT		(0xffu << 24)
>  
>  	/**
>  	 * @DRM_XE_OA_PROPERTY_OA_PERIOD_EXPONENT: Requests periodic OA unit
> @@ -1698,4 +1698,4 @@ struct drm_xe_oa_stream_info {
>  }
>  #endif
>  
> -#endif /* _UAPI_XE_DRM_H_ */
> +#endif /* _XE_DRM_H_ */
> -- 
> 2.34.1
> 

Re: [PATCH i-g-t v3 00/14] Test coverage for GPU debug support

[Kamil Konieczny]

Hi Christoph,
On 2024-08-09 at 14:37:59 +0200, Christoph Manszewski wrote:
> Hi,
> 
> In this series the eudebug kernel and validation team would like to
> add test coverage for GPU debug support recently proposed as an RFC.
> (https://patchwork.freedesktop.org/series/136572/)
> 
> This series adds 'xe_eudebug' and 'xe_eudebug_online' tests together
> with a library that encapsulates common paths in current and future
> EU debugger scenarios. It also extends the 'xe_exec_sip' test and
> 'gpgpu_shader' library.
> 
> The aim of the 'xe_eudebug' test is to validate the eudebug resource
> tracking and event delivery mechanism. The 'xe_eudebug_online' test is
> dedicated for 'online' scenarios which means scenarios that exercise
> hardware exception handling and thread state manipulation.
> 
> The xe_eudebug library provides an abstraction over debugger and debuggee
> processes, asynchronous event reader, and event log buffers for post-mortem
> analysis.
> 
> Latest kernel code can be found here:
> https://gitlab.freedesktop.org/miku/kernel/-/commits/eudebug-dev
> 
> Thank you in advance for any comments and insight.
> 
> v2:
>  - make sure to include all patches and verify that each individual
>  patch compiles (Zbigniew)
> 
> v3:
>  - fix multiple typos (Dominik Karol),
>  - squash subtest and eudebug lib patches (Zbigniew),
>  - include uapi sync/fix (Kamil)
> 

Please look into GitLab compilation report with error for
armhf and mips:

build:tests-debian-meson-armhf has failed (https://gitlab.freedesktop.org/gfx-ci/igt-ci-tags/-/jobs/62081847):

../lib/igt_core.h:1257:64: note: in definition of macro ‘igt_debug’
#define igt_debug(f...) igt_log(IGT_LOG_DOMAIN, IGT_LOG_DEBUG, f)

../lib/xe/xe_eudebug.c: In function ‘xe_eudebug_client_exec_queue_create’:
../lib/xe/xe_eudebug.c:1792:20: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;

../lib/xe/xe_eudebug.c: In function ‘xe_eudebug_client_exec_queue_destroy’:
../lib/xe/xe_eudebug.c:1816:20: error: cast to pointer from integer of different size [-Werror=int-to-pointer-cast]
uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;

cc1: some warnings being treated as errors
ninja: build stopped: subcommand failed.

Regards,
Kamil

> Andrzej Hajda (4):
>   lib/gpgpu_shader: Add write_on_exception template
>   lib/gpgpu_shader: Add set/clear exception register (cr0.1) helpers
>   lib/intel_batchbuffer: Add helper to get pointer at specified offset
>   lib/gpgpu_shader: Allow enabling illegal opcode exceptions in shader
> 
> Christoph Manszewski (5):
>   drm-uapi/xe: Sync with oa uapi fix
>   lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter
>   lib/gpgpu_shader: Extend shader building library
>   tests/xe_exec_sip: Extend SIP interaction testing
>   tests/xe_live_ktest: Add xe_eudebug live test
> 
> Dominik Grzegorzek (4):
>   drm-uapi/xe: Sync with eudebug uapi
>   lib/xe_eudebug: Introduce eu debug testing framework
>   tests/xe_eudebug: Test eudebug resource tracking and manipulation
>   tests/xe_eudebug_online: Debug client which runs workloads on EU
> 
> Gwan-gyeong Mun (1):
>   lib/intel_batchbuffer: Add support for long-running mode execution
> 
>  include/drm-uapi/xe_drm.h         |  112 +-
>  include/drm-uapi/xe_drm_eudebug.h |  225 +++
>  lib/gpgpu_shader.c                |  474 ++++-
>  lib/gpgpu_shader.h                |   29 +-
>  lib/iga64_generated_codes.c       |  428 ++++-
>  lib/intel_batchbuffer.c           |  153 +-
>  lib/intel_batchbuffer.h           |   22 +
>  lib/meson.build                   |    1 +
>  lib/xe/xe_eudebug.c               | 2192 +++++++++++++++++++++++
>  lib/xe/xe_eudebug.h               |  206 +++
>  lib/xe/xe_ioctl.c                 |   20 +-
>  lib/xe/xe_ioctl.h                 |    5 +
>  tests/intel/xe_eudebug.c          | 2671 +++++++++++++++++++++++++++++
>  tests/intel/xe_eudebug_online.c   | 2203 ++++++++++++++++++++++++
>  tests/intel/xe_exec_sip.c         |  332 +++-
>  tests/intel/xe_live_ktest.c       |    6 +
>  tests/meson.build                 |    2 +
>  17 files changed, 9036 insertions(+), 45 deletions(-)
>  create mode 100644 include/drm-uapi/xe_drm_eudebug.h
>  create mode 100644 lib/xe/xe_eudebug.c
>  create mode 100644 lib/xe/xe_eudebug.h
>  create mode 100644 tests/intel/xe_eudebug.c
>  create mode 100644 tests/intel/xe_eudebug_online.c
> 
> -- 
> 2.34.1
> 

Re: [PATCH i-g-t v3 13/14] tests/xe_eudebug_online: Debug client which runs workloads on EU

[Kamil Konieczny]

Hi Christoph,
On 2024-08-09 at 14:38:12 +0200, Christoph Manszewski wrote:
> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> 
> For typical debugging under gdb one can specify two main usecases:
> accessing and manupulating resources created by the application and
> manipulating thread execution (interrupting and setting breakpoints).
> 
> This test adds coverage for the latter by checking that:
> - EU workloads that hit a instruction with breakpoint bit set will stop
>   halt execution and the debugger will report this via attention events,
> - the debugger is able to interrupt workload execution by issuing a
>   'interrupt_all' ioctl call,
> - the debugger is able to resume selected workloads that are stopped.
> 
> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Mika Kuoppala <mika.kuoppala@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> Signed-off-by: Kolanupaka Naveena <kolanupaka.naveena@intel.com>
> ---
>  tests/intel/xe_eudebug_online.c | 2203 +++++++++++++++++++++++++++++++
>  tests/meson.build               |    1 +
>  2 files changed, 2204 insertions(+)
>  create mode 100644 tests/intel/xe_eudebug_online.c
[...cut...]

Please use checkpatch.pl from linux kernel, watch out for
whitespace errors, unbalanced braces '{/}' in if...else
and few other problems.

A few useful options for checkpatch.pl are in CONTRIBUTE.md

Regards,
Kamil

✗ CI.xeFULL: failure for Test coverage for GPU debug support (rev3)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 78046 bytes --]

== Series Details ==

Series: Test coverage for GPU debug support (rev3)
URL   : https://patchwork.freedesktop.org/series/136623/
State : failure

== Summary ==

CI Bug Log - changes from XEIGT_7964_full -> XEIGTPW_11551_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with XEIGTPW_11551_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in XEIGTPW_11551_full, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  

Participating hosts (4 -> 4)
------------------------------

  No changes in participating hosts

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

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

### IGT changes ###

#### Possible regressions ####

  * igt@xe_eudebug@basic-connect (NEW):
    - shard-lnl:          NOTRUN -> [SKIP][1] +55 other tests skip
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@xe_eudebug@basic-connect.html

  * igt@xe_eudebug@basic-vm-bind-metadata-discovery (NEW):
    - {shard-bmg}:        NOTRUN -> [SKIP][2] +53 other tests skip
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-2/igt@xe_eudebug@basic-vm-bind-metadata-discovery.html

  * igt@xe_eudebug_online@resume-dss (NEW):
    - shard-dg2-set2:     NOTRUN -> [SKIP][3] +7 other tests skip
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@xe_eudebug_online@resume-dss.html

  * igt@xe_oa@oa-regs-whitelisted:
    - shard-lnl:          [PASS][4] -> [FAIL][5]
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-7/igt@xe_oa@oa-regs-whitelisted.html
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@xe_oa@oa-regs-whitelisted.html

  * igt@xe_oa@oa-regs-whitelisted@ccs-0:
    - shard-lnl:          NOTRUN -> [FAIL][6]
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@xe_oa@oa-regs-whitelisted@ccs-0.html

  
#### Suppressed ####

  The following results come from untrusted machines, tests, or statuses.
  They do not affect the overall result.

  * igt@kms_cursor_edge_walk@256x256-left-edge@pipe-a-dp-2:
    - {shard-bmg}:        [PASS][7] -> [INCOMPLETE][8] +3 other tests incomplete
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-7/igt@kms_cursor_edge_walk@256x256-left-edge@pipe-a-dp-2.html
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-5/igt@kms_cursor_edge_walk@256x256-left-edge@pipe-a-dp-2.html

  * igt@kms_pm_lpsp@kms-lpsp:
    - {shard-bmg}:        NOTRUN -> [SKIP][9] +1 other test skip
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-2/igt@kms_pm_lpsp@kms-lpsp.html

  * igt@xe_ccs@suspend-resume:
    - {shard-bmg}:        [PASS][10] -> [DMESG-WARN][11] +3 other tests dmesg-warn
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-2/igt@xe_ccs@suspend-resume.html
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-4/igt@xe_ccs@suspend-resume.html

  * igt@xe_oa@oa-regs-whitelisted:
    - {shard-bmg}:        [PASS][12] -> [FAIL][13]
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-5/igt@xe_oa@oa-regs-whitelisted.html
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-3/igt@xe_oa@oa-regs-whitelisted.html

  * igt@xe_oa@oa-regs-whitelisted@rcs-0:
    - {shard-bmg}:        NOTRUN -> [FAIL][14]
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-3/igt@xe_oa@oa-regs-whitelisted@rcs-0.html

  
New tests
---------

  New tests have been introduced between XEIGT_7964_full and XEIGTPW_11551_full:

### New IGT tests (74) ###

  * igt@xe_eudebug@attach-debug-metadata:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-client:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-client-th:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-close:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-connect:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-exec-queues:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-read-event:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-access:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-access-parameters:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-access-userptr:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-discovery:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-extended:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-extended-discovery:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-metadata-discovery:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-ufence:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-vm-destroy:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vm-bind-vm-destroy-discovery:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@basic-vms:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@connect-user:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@discovery-empty:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@discovery-empty-clients:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@discovery-race:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@discovery-race-vmbind:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@multigpu-basic-client:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@multigpu-basic-client-many:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@multiple-sessions:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@read-metadata:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@sysfs-toggle:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@vm-bind-clear:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug@vma-ufence:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@basic-breakpoint:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@breakpoint-many-sessions-single-tile:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@breakpoint-many-sessions-tiles:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@breakpoint-not-in-debug-mode:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@debugger-reopen:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@interrupt-all:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@interrupt-all-set-breakpoint:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@interrupt-other:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@interrupt-other-debuggable:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@interrupt-reconnect:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@preempt-breakpoint:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@reset-with-attention:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@resume-dss:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@resume-one:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@single-step:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@single-step-one:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@stopped-thread:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@tdctl-parameters:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@writes-caching-sram:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_eudebug_online@writes-caching-vram:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_exec_sip@breakpoint-waitsip:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_exec_sip@breakpoint-waitsip-heavy:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_exec_sip@breakpoint-writesip:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_exec_sip@breakpoint-writesip-nodebug:
    - Statuses : 3 pass(s)
    - Exec time: [0.01] s

  * igt@xe_exec_sip@breakpoint-writesip-nodebug@drm_xe_engine_class_compute0:
    - Statuses : 3 pass(s)
    - Exec time: [0.00, 0.01] s

  * igt@xe_exec_sip@breakpoint-writesip-nodebug@drm_xe_engine_class_render0:
    - Statuses : 3 pass(s)
    - Exec time: [0.00, 0.01] s

  * igt@xe_exec_sip@breakpoint-writesip-twice:
    - Statuses : 3 skip(s)
    - Exec time: [0.0] s

  * igt@xe_exec_sip@invalidinstr-disabled:
    - Statuses : 3 pass(s)
    - Exec time: [0.01] s

  * igt@xe_exec_sip@invalidinstr-disabled@drm_xe_engine_class_compute0:
    - Statuses : 3 pass(s)
    - Exec time: [0.00] s

  * igt@xe_exec_sip@invalidinstr-disabled@drm_xe_engine_class_render0:
    - Statuses : 3 pass(s)
    - Exec time: [0.00] s

  * igt@xe_exec_sip@invalidinstr-thread-enabled:
    - Statuses : 3 pass(s)
    - Exec time: [11.56, 11.72] s

  * igt@xe_exec_sip@invalidinstr-thread-enabled@drm_xe_engine_class_compute0:
    - Statuses : 3 pass(s)
    - Exec time: [5.68, 5.88] s

  * igt@xe_exec_sip@invalidinstr-thread-enabled@drm_xe_engine_class_render0:
    - Statuses : 3 pass(s)
    - Exec time: [5.67, 6.00] s

  * igt@xe_exec_sip@invalidinstr-walker-enabled:
    - Statuses : 3 pass(s)
    - Exec time: [11.63, 11.86] s

  * igt@xe_exec_sip@invalidinstr-walker-enabled@drm_xe_engine_class_compute0:
    - Statuses : 3 pass(s)
    - Exec time: [5.81, 5.89] s

  * igt@xe_exec_sip@invalidinstr-walker-enabled@drm_xe_engine_class_render0:
    - Statuses : 3 pass(s)
    - Exec time: [5.74, 6.04] s

  * igt@xe_exec_sip@sanity-after-timeout:
    - Statuses : 3 pass(s)
    - Exec time: [11.62, 11.77] s

  * igt@xe_exec_sip@sanity-after-timeout@drm_xe_engine_class_compute0:
    - Statuses : 3 pass(s)
    - Exec time: [5.89, 5.90] s

  * igt@xe_exec_sip@sanity-after-timeout@drm_xe_engine_class_render0:
    - Statuses : 3 pass(s)
    - Exec time: [5.73, 5.87] s

  * igt@xe_exec_sip@wait-writesip-nodebug:
    - Statuses : 3 pass(s)
    - Exec time: [11.61, 11.74] s

  * igt@xe_exec_sip@wait-writesip-nodebug@drm_xe_engine_class_compute0:
    - Statuses : 3 pass(s)
    - Exec time: [5.88] s

  * igt@xe_exec_sip@wait-writesip-nodebug@drm_xe_engine_class_render0:
    - Statuses : 3 pass(s)
    - Exec time: [5.73, 5.86] s

  * igt@xe_live_ktest@xe_eudebug:
    - Statuses : 3 skip(s)
    - Exec time: [0.00] s

  

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

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

### IGT changes ###

#### Issues hit ####

  * igt@kms_addfb_basic@addfb25-y-tiled-small-legacy:
    - shard-dg2-set2:     NOTRUN -> [SKIP][15] ([Intel XE#1201] / [Intel XE#623])
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@kms_addfb_basic@addfb25-y-tiled-small-legacy.html

  * igt@kms_async_flips@async-flip-with-page-flip-events@pipe-a-edp-1-linear:
    - shard-lnl:          [PASS][16] -> [FAIL][17] ([Intel XE#911]) +3 other tests fail
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@kms_async_flips@async-flip-with-page-flip-events@pipe-a-edp-1-linear.html
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@kms_async_flips@async-flip-with-page-flip-events@pipe-a-edp-1-linear.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels:
    - shard-lnl:          [PASS][18] -> [FAIL][19] ([Intel XE#1426]) +1 other test fail
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels@pipe-a-edp-1:
    - shard-lnl:          NOTRUN -> [FAIL][20] ([Intel XE#1426]) +1 other test fail
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels@pipe-a-edp-1.html

  * igt@kms_big_fb@4-tiled-32bpp-rotate-90:
    - shard-lnl:          NOTRUN -> [SKIP][21] ([Intel XE#1407]) +3 other tests skip
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@kms_big_fb@4-tiled-32bpp-rotate-90.html

  * igt@kms_big_fb@linear-8bpp-rotate-90:
    - shard-dg2-set2:     NOTRUN -> [SKIP][22] ([Intel XE#1201] / [Intel XE#316])
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_big_fb@linear-8bpp-rotate-90.html

  * igt@kms_big_fb@y-tiled-8bpp-rotate-180:
    - shard-dg2-set2:     NOTRUN -> [SKIP][23] ([Intel XE#1124] / [Intel XE#1201]) +2 other tests skip
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_big_fb@y-tiled-8bpp-rotate-180.html

  * igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-hflip-async-flip:
    - shard-lnl:          NOTRUN -> [SKIP][24] ([Intel XE#1124]) +4 other tests skip
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-0-hflip-async-flip.html

  * igt@kms_bw@connected-linear-tiling-2-displays-2560x1440p:
    - shard-dg2-set2:     NOTRUN -> [SKIP][25] ([Intel XE#1201] / [Intel XE#367]) +1 other test skip
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_bw@connected-linear-tiling-2-displays-2560x1440p.html

  * igt@kms_bw@connected-linear-tiling-3-displays-1920x1080p:
    - shard-dg2-set2:     NOTRUN -> [SKIP][26] ([Intel XE#1201] / [Intel XE#2191])
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_bw@connected-linear-tiling-3-displays-1920x1080p.html

  * igt@kms_bw@connected-linear-tiling-3-displays-3840x2160p:
    - shard-lnl:          NOTRUN -> [SKIP][27] ([Intel XE#2191])
   [27]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-6/igt@kms_bw@connected-linear-tiling-3-displays-3840x2160p.html

  * igt@kms_bw@linear-tiling-2-displays-1920x1080p:
    - shard-lnl:          NOTRUN -> [SKIP][28] ([Intel XE#367])
   [28]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@kms_bw@linear-tiling-2-displays-1920x1080p.html

  * igt@kms_ccs@bad-aux-stride-4-tiled-mtl-mc-ccs@pipe-a-hdmi-a-6:
    - shard-dg2-set2:     NOTRUN -> [SKIP][29] ([Intel XE#1201] / [Intel XE#787]) +20 other tests skip
   [29]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_ccs@bad-aux-stride-4-tiled-mtl-mc-ccs@pipe-a-hdmi-a-6.html

  * igt@kms_ccs@bad-rotation-90-y-tiled-ccs:
    - shard-dg2-set2:     NOTRUN -> [SKIP][30] ([Intel XE#455] / [Intel XE#787]) +1 other test skip
   [30]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_ccs@bad-rotation-90-y-tiled-ccs.html

  * igt@kms_ccs@bad-rotation-90-y-tiled-ccs@pipe-b-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][31] ([Intel XE#787]) +6 other tests skip
   [31]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_ccs@bad-rotation-90-y-tiled-ccs@pipe-b-dp-4.html

  * igt@kms_ccs@crc-primary-rotation-180-4-tiled-dg2-rc-ccs-cc:
    - shard-lnl:          NOTRUN -> [SKIP][32] ([Intel XE#1399]) +3 other tests skip
   [32]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@kms_ccs@crc-primary-rotation-180-4-tiled-dg2-rc-ccs-cc.html

  * igt@kms_ccs@missing-ccs-buffer-4-tiled-mtl-rc-ccs@pipe-d-dp-4:
    - shard-dg2-set2:     NOTRUN -> [SKIP][33] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#787]) +5 other tests skip
   [33]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_ccs@missing-ccs-buffer-4-tiled-mtl-rc-ccs@pipe-d-dp-4.html

  * igt@kms_chamelium_audio@dp-audio:
    - shard-dg2-set2:     NOTRUN -> [SKIP][34] ([Intel XE#1201] / [Intel XE#373]) +2 other tests skip
   [34]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_chamelium_audio@dp-audio.html

  * igt@kms_chamelium_color@ctm-green-to-red:
    - shard-dg2-set2:     NOTRUN -> [SKIP][35] ([Intel XE#1201] / [Intel XE#306])
   [35]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-435/igt@kms_chamelium_color@ctm-green-to-red.html

  * igt@kms_chamelium_hpd@hdmi-hpd:
    - shard-lnl:          NOTRUN -> [SKIP][36] ([Intel XE#373]) +1 other test skip
   [36]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-5/igt@kms_chamelium_hpd@hdmi-hpd.html

  * igt@kms_cursor_crc@cursor-offscreen-max-size:
    - shard-lnl:          NOTRUN -> [SKIP][37] ([Intel XE#1424])
   [37]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@kms_cursor_crc@cursor-offscreen-max-size.html

  * igt@kms_cursor_crc@cursor-random-512x512:
    - shard-dg2-set2:     NOTRUN -> [SKIP][38] ([Intel XE#1201] / [Intel XE#308])
   [38]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_cursor_crc@cursor-random-512x512.html

  * igt@kms_cursor_legacy@2x-cursor-vs-flip-atomic:
    - shard-lnl:          NOTRUN -> [SKIP][39] ([Intel XE#309])
   [39]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@kms_cursor_legacy@2x-cursor-vs-flip-atomic.html

  * igt@kms_fbcon_fbt@psr-suspend:
    - shard-lnl:          [PASS][40] -> [FAIL][41] ([Intel XE#2028])
   [40]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@kms_fbcon_fbt@psr-suspend.html
   [41]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@kms_fbcon_fbt@psr-suspend.html

  * igt@kms_feature_discovery@display-3x:
    - shard-lnl:          NOTRUN -> [SKIP][42] ([Intel XE#703])
   [42]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_feature_discovery@display-3x.html

  * igt@kms_flip@2x-blocking-absolute-wf_vblank:
    - shard-dg2-set2:     [PASS][43] -> [INCOMPLETE][44] ([Intel XE#1195]) +1 other test incomplete
   [43]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_flip@2x-blocking-absolute-wf_vblank.html
   [44]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-435/igt@kms_flip@2x-blocking-absolute-wf_vblank.html
    - shard-lnl:          NOTRUN -> [SKIP][45] ([Intel XE#1421]) +1 other test skip
   [45]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_flip@2x-blocking-absolute-wf_vblank.html

  * igt@kms_flip@flip-vs-absolute-wf_vblank:
    - shard-lnl:          [PASS][46] -> [FAIL][47] ([Intel XE#886]) +1 other test fail
   [46]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-3/igt@kms_flip@flip-vs-absolute-wf_vblank.html
   [47]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@kms_flip@flip-vs-absolute-wf_vblank.html

  * igt@kms_flip@flip-vs-suspend@a-hdmi-a6:
    - shard-dg2-set2:     [PASS][48] -> [DMESG-WARN][49] ([Intel XE#1551]) +2 other tests dmesg-warn
   [48]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_flip@flip-vs-suspend@a-hdmi-a6.html
   [49]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_flip@flip-vs-suspend@a-hdmi-a6.html

  * igt@kms_flip@flip-vs-suspend@d-dp4:
    - shard-dg2-set2:     NOTRUN -> [INCOMPLETE][50] ([Intel XE#2049])
   [50]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_flip@flip-vs-suspend@d-dp4.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytilegen12rcccs-downscaling@pipe-a-default-mode:
    - shard-lnl:          NOTRUN -> [SKIP][51] ([Intel XE#1401]) +1 other test skip
   [51]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytilegen12rcccs-downscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling:
    - shard-lnl:          NOTRUN -> [SKIP][52] ([Intel XE#1401] / [Intel XE#1745]) +1 other test skip
   [52]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-5/igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling.html

  * igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-shrfb-draw-render:
    - shard-dg2-set2:     NOTRUN -> [SKIP][53] ([Intel XE#651]) +2 other tests skip
   [53]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_frontbuffer_tracking@drrs-2p-scndscrn-pri-shrfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-spr-indfb-draw-render:
    - shard-dg2-set2:     NOTRUN -> [SKIP][54] ([Intel XE#1201] / [Intel XE#651]) +2 other tests skip
   [54]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_frontbuffer_tracking@fbcdrrs-2p-primscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-slowdraw:
    - shard-lnl:          NOTRUN -> [SKIP][55] ([Intel XE#651]) +2 other tests skip
   [55]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_frontbuffer_tracking@fbcdrrs-slowdraw.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y:
    - shard-dg2-set2:     NOTRUN -> [SKIP][56] ([Intel XE#1201] / [Intel XE#658])
   [56]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_frontbuffer_tracking@fbcdrrs-tiling-y.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-draw-render:
    - shard-lnl:          NOTRUN -> [SKIP][57] ([Intel XE#656]) +10 other tests skip
   [57]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-cur-indfb-draw-blt:
    - shard-dg2-set2:     NOTRUN -> [SKIP][58] ([Intel XE#1201] / [Intel XE#653]) +2 other tests skip
   [58]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-cur-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@pipe-fbc-rte:
    - shard-dg2-set2:     NOTRUN -> [SKIP][59] ([Intel XE#1201] / [Intel XE#455]) +1 other test skip
   [59]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_frontbuffer_tracking@pipe-fbc-rte.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-msflip-blt:
    - shard-dg2-set2:     NOTRUN -> [SKIP][60] ([Intel XE#653]) +1 other test skip
   [60]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-msflip-blt.html

  * igt@kms_hdr@invalid-hdr:
    - shard-dg2-set2:     [PASS][61] -> [SKIP][62] ([Intel XE#1201] / [Intel XE#455])
   [61]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_hdr@invalid-hdr.html
   [62]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_hdr@invalid-hdr.html

  * igt@kms_plane@plane-position-covered:
    - shard-lnl:          [PASS][63] -> [DMESG-FAIL][64] ([Intel XE#324]) +2 other tests dmesg-fail
   [63]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-3/igt@kms_plane@plane-position-covered.html
   [64]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-2/igt@kms_plane@plane-position-covered.html

  * igt@kms_plane@plane-position-hole:
    - shard-lnl:          [PASS][65] -> [DMESG-WARN][66] ([Intel XE#324]) +1 other test dmesg-warn
   [65]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-6/igt@kms_plane@plane-position-hole.html
   [66]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@kms_plane@plane-position-hole.html

  * igt@kms_plane_scaling@intel-max-src-size:
    - shard-dg2-set2:     NOTRUN -> [FAIL][67] ([Intel XE#361]) +1 other test fail
   [67]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_plane_scaling@intel-max-src-size.html

  * igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5:
    - shard-lnl:          NOTRUN -> [SKIP][68] ([Intel XE#2318]) +3 other tests skip
   [68]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-5.html

  * igt@kms_pm_dc@dc5-psr:
    - shard-lnl:          [PASS][69] -> [FAIL][70] ([Intel XE#718])
   [69]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@kms_pm_dc@dc5-psr.html
   [70]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@kms_pm_dc@dc5-psr.html

  * igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-fully-sf:
    - shard-dg2-set2:     NOTRUN -> [SKIP][71] ([Intel XE#1201] / [Intel XE#1489])
   [71]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-435/igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-fully-sf.html

  * igt@kms_psr@fbc-psr2-sprite-plane-onoff:
    - shard-dg2-set2:     NOTRUN -> [SKIP][72] ([Intel XE#929])
   [72]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_psr@fbc-psr2-sprite-plane-onoff.html

  * igt@kms_psr@pr-sprite-blt:
    - shard-lnl:          NOTRUN -> [SKIP][73] ([Intel XE#1406])
   [73]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-2/igt@kms_psr@pr-sprite-blt.html

  * igt@kms_psr@psr2-cursor-plane-onoff:
    - shard-dg2-set2:     NOTRUN -> [SKIP][74] ([Intel XE#1201] / [Intel XE#929]) +3 other tests skip
   [74]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_psr@psr2-cursor-plane-onoff.html

  * igt@kms_rotation_crc@primary-yf-tiled-reflect-x-90:
    - shard-dg2-set2:     NOTRUN -> [SKIP][75] ([Intel XE#1201] / [Intel XE#327])
   [75]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-90.html

  * igt@kms_setmode@invalid-clone-exclusive-crtc:
    - shard-lnl:          NOTRUN -> [SKIP][76] ([Intel XE#1435])
   [76]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_setmode@invalid-clone-exclusive-crtc.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-lnl:          NOTRUN -> [SKIP][77] ([Intel XE#362])
   [77]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@kms_vrr@flip-basic-fastset:
    - shard-lnl:          NOTRUN -> [FAIL][78] ([Intel XE#2443]) +1 other test fail
   [78]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_vrr@flip-basic-fastset.html

  * igt@sriov_basic@enable-vfs-autoprobe-off:
    - shard-lnl:          NOTRUN -> [SKIP][79] ([Intel XE#1091])
   [79]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@sriov_basic@enable-vfs-autoprobe-off.html

  * igt@xe_copy_basic@mem-set-linear-0x369:
    - shard-dg2-set2:     NOTRUN -> [SKIP][80] ([Intel XE#1126])
   [80]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@xe_copy_basic@mem-set-linear-0x369.html

  * igt@xe_eudebug@basic-close (NEW):
    - shard-dg2-set2:     NOTRUN -> [SKIP][81] ([Intel XE#1201]) +45 other tests skip
   [81]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@xe_eudebug@basic-close.html

  * igt@xe_evict@evict-beng-mixed-many-threads-small:
    - shard-dg2-set2:     [PASS][82] -> [TIMEOUT][83] ([Intel XE#1473] / [Intel XE#402])
   [82]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@xe_evict@evict-beng-mixed-many-threads-small.html
   [83]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@xe_evict@evict-beng-mixed-many-threads-small.html

  * igt@xe_evict@evict-threads-large:
    - shard-dg2-set2:     NOTRUN -> [TIMEOUT][84] ([Intel XE#1473] / [Intel XE#392])
   [84]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@xe_evict@evict-threads-large.html

  * igt@xe_evict@evict-threads-small:
    - shard-lnl:          NOTRUN -> [SKIP][85] ([Intel XE#688]) +1 other test skip
   [85]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@xe_evict@evict-threads-small.html

  * igt@xe_exec_basic@multigpu-once-null-rebind:
    - shard-lnl:          NOTRUN -> [SKIP][86] ([Intel XE#1392]) +1 other test skip
   [86]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@xe_exec_basic@multigpu-once-null-rebind.html

  * igt@xe_exec_fault_mode@twice-basic-prefetch:
    - shard-dg2-set2:     NOTRUN -> [SKIP][87] ([Intel XE#1201] / [Intel XE#288]) +6 other tests skip
   [87]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@xe_exec_fault_mode@twice-basic-prefetch.html

  * igt@xe_exec_mix_modes@exec-spinner-interrupted-dma-fence:
    - shard-dg2-set2:     NOTRUN -> [SKIP][88] ([Intel XE#1201] / [Intel XE#2360])
   [88]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@xe_exec_mix_modes@exec-spinner-interrupted-dma-fence.html

  * igt@xe_exec_threads@threads-mixed-shared-vm-userptr-invalidate:
    - shard-lnl:          [PASS][89] -> [INCOMPLETE][90] ([Intel XE#1169])
   [89]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@xe_exec_threads@threads-mixed-shared-vm-userptr-invalidate.html
   [90]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@xe_exec_threads@threads-mixed-shared-vm-userptr-invalidate.html

  * igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit:
    - shard-dg2-set2:     NOTRUN -> [SKIP][91] ([Intel XE#1201] / [Intel XE#2229])
   [91]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit.html
    - shard-lnl:          NOTRUN -> [SKIP][92] ([Intel XE#2229])
   [92]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-5/igt@xe_live_ktest@xe_migrate@xe_validate_ccs_kunit.html

  * igt@xe_module_load@reload-no-display:
    - shard-dg2-set2:     [PASS][93] -> [DMESG-WARN][94] ([Intel XE#2019])
   [93]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_module_load@reload-no-display.html
   [94]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@xe_module_load@reload-no-display.html

  * igt@xe_oa@missing-sample-flags:
    - shard-dg2-set2:     NOTRUN -> [SKIP][95] ([Intel XE#1201] / [Intel XE#2207]) +1 other test skip
   [95]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@xe_oa@missing-sample-flags.html

  * igt@xe_pat@pat-index-xehpc:
    - shard-lnl:          NOTRUN -> [SKIP][96] ([Intel XE#1420])
   [96]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@xe_pat@pat-index-xehpc.html

  * igt@xe_pm@d3hot-mmap-vram:
    - shard-lnl:          NOTRUN -> [SKIP][97] ([Intel XE#1948])
   [97]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@xe_pm@d3hot-mmap-vram.html

  * igt@xe_pm@s2idle-mocs:
    - shard-lnl:          NOTRUN -> [FAIL][98] ([Intel XE#2028])
   [98]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-1/igt@xe_pm@s2idle-mocs.html

  * igt@xe_pm@s3-multiple-execs:
    - shard-dg2-set2:     [PASS][99] -> [DMESG-WARN][100] ([Intel XE#1551] / [Intel XE#569])
   [99]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@xe_pm@s3-multiple-execs.html
   [100]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-435/igt@xe_pm@s3-multiple-execs.html

  * igt@xe_pm@s4-vm-bind-prefetch:
    - shard-lnl:          [PASS][101] -> [ABORT][102] ([Intel XE#1794])
   [101]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@xe_pm@s4-vm-bind-prefetch.html
   [102]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-2/igt@xe_pm@s4-vm-bind-prefetch.html

  * igt@xe_query@multigpu-query-engines:
    - shard-lnl:          NOTRUN -> [SKIP][103] ([Intel XE#944])
   [103]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-8/igt@xe_query@multigpu-query-engines.html

  * igt@xe_query@multigpu-query-oa-units:
    - shard-dg2-set2:     NOTRUN -> [SKIP][104] ([Intel XE#1201] / [Intel XE#944])
   [104]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@xe_query@multigpu-query-oa-units.html

  
#### Possible fixes ####

  * igt@kms_async_flips@alternate-sync-async-flip@pipe-d-dp-2:
    - {shard-bmg}:        [DMESG-WARN][105] ([Intel XE#1033]) -> [PASS][106]
   [105]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-7/igt@kms_async_flips@alternate-sync-async-flip@pipe-d-dp-2.html
   [106]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-7/igt@kms_async_flips@alternate-sync-async-flip@pipe-d-dp-2.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing:
    - {shard-bmg}:        [FAIL][107] ([Intel XE#1426]) -> [PASS][108] +1 other test pass
   [107]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-7/igt@kms_atomic_transition@plane-all-modeset-transition-fencing.html
   [108]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-8/igt@kms_atomic_transition@plane-all-modeset-transition-fencing.html

  * igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-edp-1:
    - shard-lnl:          [FAIL][109] ([Intel XE#1426]) -> [PASS][110] +1 other test pass
   [109]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-4/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-edp-1.html
   [110]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-edp-1.html

  * igt@kms_big_fb@4-tiled-64bpp-rotate-180:
    - shard-lnl:          [FAIL][111] ([Intel XE#1659]) -> [PASS][112] +1 other test pass
   [111]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-4/igt@kms_big_fb@4-tiled-64bpp-rotate-180.html
   [112]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_big_fb@4-tiled-64bpp-rotate-180.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-xe2-ccs@pipe-a-hdmi-a-3:
    - {shard-bmg}:        [FAIL][113] ([Intel XE#2436]) -> [PASS][114] +1 other test pass
   [113]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-6/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-xe2-ccs@pipe-a-hdmi-a-3.html
   [114]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-4/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-xe2-ccs@pipe-a-hdmi-a-3.html

  * igt@kms_cursor_legacy@torture-move@pipe-a:
    - shard-dg2-set2:     [DMESG-WARN][115] ([Intel XE#877]) -> [PASS][116] +1 other test pass
   [115]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_cursor_legacy@torture-move@pipe-a.html
   [116]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_cursor_legacy@torture-move@pipe-a.html

  * igt@kms_flip@2x-flip-vs-panning:
    - {shard-bmg}:        [DMESG-WARN][117] ([Intel XE#877]) -> [PASS][118]
   [117]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-8/igt@kms_flip@2x-flip-vs-panning.html
   [118]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-6/igt@kms_flip@2x-flip-vs-panning.html

  * igt@kms_flip@flip-vs-suspend@c-dp4:
    - shard-dg2-set2:     [INCOMPLETE][119] ([Intel XE#1195] / [Intel XE#2049]) -> [PASS][120]
   [119]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_flip@flip-vs-suspend@c-dp4.html
   [120]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_flip@flip-vs-suspend@c-dp4.html

  * igt@kms_plane@plane-panning-bottom-right-suspend:
    - shard-lnl:          [FAIL][121] ([Intel XE#2028]) -> [PASS][122] +2 other tests pass
   [121]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-1/igt@kms_plane@plane-panning-bottom-right-suspend.html
   [122]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@kms_plane@plane-panning-bottom-right-suspend.html

  * igt@kms_plane_scaling@2x-scaler-multi-pipe:
    - {shard-bmg}:        [DMESG-WARN][123] -> [PASS][124] +4 other tests pass
   [123]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-7/igt@kms_plane_scaling@2x-scaler-multi-pipe.html
   [124]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-1/igt@kms_plane_scaling@2x-scaler-multi-pipe.html

  * igt@kms_pm_backlight@fade:
    - shard-lnl:          [SKIP][125] ([Intel XE#870]) -> [PASS][126]
   [125]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-3/igt@kms_pm_backlight@fade.html
   [126]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_pm_backlight@fade.html

  * igt@kms_pm_rpm@universal-planes-dpms:
    - shard-lnl:          [INCOMPLETE][127] ([Intel XE#1620]) -> [PASS][128]
   [127]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-1/igt@kms_pm_rpm@universal-planes-dpms.html
   [128]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-6/igt@kms_pm_rpm@universal-planes-dpms.html

  * igt@kms_pm_rpm@universal-planes-dpms@plane-32:
    - shard-lnl:          [DMESG-FAIL][129] ([Intel XE#1620]) -> [PASS][130]
   [129]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-1/igt@kms_pm_rpm@universal-planes-dpms@plane-32.html
   [130]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-6/igt@kms_pm_rpm@universal-planes-dpms@plane-32.html

  * igt@kms_rotation_crc@primary-4-tiled-reflect-x-180:
    - {shard-bmg}:        [FAIL][131] -> [PASS][132]
   [131]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-6/igt@kms_rotation_crc@primary-4-tiled-reflect-x-180.html
   [132]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-5/igt@kms_rotation_crc@primary-4-tiled-reflect-x-180.html

  * igt@kms_universal_plane@cursor-fb-leak@pipe-d-dp-2:
    - {shard-bmg}:        [FAIL][133] ([Intel XE#899]) -> [PASS][134]
   [133]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-2/igt@kms_universal_plane@cursor-fb-leak@pipe-d-dp-2.html
   [134]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-2/igt@kms_universal_plane@cursor-fb-leak@pipe-d-dp-2.html

  * igt@kms_vblank@ts-continuation-dpms-suspend:
    - shard-lnl:          [INCOMPLETE][135] -> [PASS][136] +1 other test pass
   [135]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-7/igt@kms_vblank@ts-continuation-dpms-suspend.html
   [136]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_vblank@ts-continuation-dpms-suspend.html

  * igt@kms_vrr@flip-basic:
    - shard-lnl:          [FAIL][137] ([Intel XE#2443]) -> [PASS][138] +2 other tests pass
   [137]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-8/igt@kms_vrr@flip-basic.html
   [138]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-4/igt@kms_vrr@flip-basic.html

  * igt@kms_vrr@flip-dpms:
    - shard-lnl:          [FAIL][139] -> [PASS][140]
   [139]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-5/igt@kms_vrr@flip-dpms.html
   [140]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-7/igt@kms_vrr@flip-dpms.html

  * igt@xe_evict@evict-beng-threads-large:
    - shard-dg2-set2:     [TIMEOUT][141] ([Intel XE#1473]) -> [PASS][142]
   [141]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_evict@evict-beng-threads-large.html
   [142]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@xe_evict@evict-beng-threads-large.html

  * igt@xe_evict@evict-cm-threads-large:
    - shard-dg2-set2:     [TIMEOUT][143] ([Intel XE#1473] / [Intel XE#392]) -> [PASS][144]
   [143]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-436/igt@xe_evict@evict-cm-threads-large.html
   [144]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@xe_evict@evict-cm-threads-large.html

  * igt@xe_evict@evict-small-cm:
    - {shard-bmg}:        [INCOMPLETE][145] -> [PASS][146]
   [145]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-bmg-5/igt@xe_evict@evict-small-cm.html
   [146]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-bmg-2/igt@xe_evict@evict-small-cm.html

  * igt@xe_live_ktest@xe_dma_buf:
    - shard-dg2-set2:     [SKIP][147] ([Intel XE#1192]) -> [PASS][148]
   [147]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_live_ktest@xe_dma_buf.html
   [148]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@xe_live_ktest@xe_dma_buf.html

  * igt@xe_live_ktest@xe_migrate:
    - shard-dg2-set2:     [SKIP][149] ([Intel XE#1192] / [Intel XE#1201]) -> [PASS][150]
   [149]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@xe_live_ktest@xe_migrate.html
   [150]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@xe_live_ktest@xe_migrate.html

  * igt@xe_module_load@many-reload:
    - shard-dg2-set2:     [FAIL][151] ([Intel XE#2136]) -> [PASS][152]
   [151]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@xe_module_load@many-reload.html
   [152]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-435/igt@xe_module_load@many-reload.html

  * igt@xe_pm@s4-multiple-execs:
    - shard-lnl:          [ABORT][153] ([Intel XE#1358] / [Intel XE#1794]) -> [PASS][154]
   [153]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-2/igt@xe_pm@s4-multiple-execs.html
   [154]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@xe_pm@s4-multiple-execs.html

  
#### Warnings ####

  * igt@kms_big_fb@4-tiled-8bpp-rotate-270:
    - shard-dg2-set2:     [SKIP][155] ([Intel XE#316]) -> [SKIP][156] ([Intel XE#1201] / [Intel XE#316]) +2 other tests skip
   [155]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_big_fb@4-tiled-8bpp-rotate-270.html
   [156]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_big_fb@4-tiled-8bpp-rotate-270.html

  * igt@kms_big_fb@linear-16bpp-rotate-90:
    - shard-dg2-set2:     [SKIP][157] ([Intel XE#1201] / [Intel XE#316]) -> [SKIP][158] ([Intel XE#316]) +3 other tests skip
   [157]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-434/igt@kms_big_fb@linear-16bpp-rotate-90.html
   [158]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_big_fb@linear-16bpp-rotate-90.html

  * igt@kms_big_fb@y-tiled-64bpp-rotate-180:
    - shard-dg2-set2:     [SKIP][159] ([Intel XE#1124] / [Intel XE#1201]) -> [SKIP][160] ([Intel XE#1124]) +8 other tests skip
   [159]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_big_fb@y-tiled-64bpp-rotate-180.html
   [160]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_big_fb@y-tiled-64bpp-rotate-180.html

  * igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0:
    - shard-dg2-set2:     [SKIP][161] ([Intel XE#1124]) -> [SKIP][162] ([Intel XE#1124] / [Intel XE#1201]) +7 other tests skip
   [161]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0.html
   [162]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_big_fb@y-tiled-max-hw-stride-64bpp-rotate-0.html

  * igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow:
    - shard-dg2-set2:     [SKIP][163] ([Intel XE#607]) -> [SKIP][164] ([Intel XE#1201] / [Intel XE#607]) +1 other test skip
   [163]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow.html
   [164]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_big_fb@yf-tiled-addfb-size-offset-overflow.html

  * igt@kms_big_fb@yf-tiled-addfb-size-overflow:
    - shard-dg2-set2:     [SKIP][165] ([Intel XE#1201] / [Intel XE#610]) -> [SKIP][166] ([Intel XE#610])
   [165]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_big_fb@yf-tiled-addfb-size-overflow.html
   [166]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_big_fb@yf-tiled-addfb-size-overflow.html

  * igt@kms_bw@connected-linear-tiling-3-displays-3840x2160p:
    - shard-dg2-set2:     [SKIP][167] ([Intel XE#1201] / [Intel XE#2191]) -> [SKIP][168] ([Intel XE#2191])
   [167]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_bw@connected-linear-tiling-3-displays-3840x2160p.html
   [168]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_bw@connected-linear-tiling-3-displays-3840x2160p.html

  * igt@kms_bw@linear-tiling-2-displays-1920x1080p:
    - shard-dg2-set2:     [SKIP][169] ([Intel XE#1201] / [Intel XE#367]) -> [SKIP][170] ([Intel XE#367]) +1 other test skip
   [169]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-436/igt@kms_bw@linear-tiling-2-displays-1920x1080p.html
   [170]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_bw@linear-tiling-2-displays-1920x1080p.html

  * igt@kms_bw@linear-tiling-2-displays-3840x2160p:
    - shard-dg2-set2:     [SKIP][171] ([Intel XE#367]) -> [SKIP][172] ([Intel XE#1201] / [Intel XE#367]) +2 other tests skip
   [171]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_bw@linear-tiling-2-displays-3840x2160p.html
   [172]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_bw@linear-tiling-2-displays-3840x2160p.html

  * igt@kms_ccs@bad-rotation-90-y-tiled-gen12-rc-ccs:
    - shard-dg2-set2:     [SKIP][173] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#787]) -> [SKIP][174] ([Intel XE#455] / [Intel XE#787]) +9 other tests skip
   [173]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-rc-ccs.html
   [174]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-rc-ccs.html

  * igt@kms_ccs@crc-primary-basic-4-tiled-xe2-ccs:
    - shard-dg2-set2:     [SKIP][175] ([Intel XE#1252]) -> [SKIP][176] ([Intel XE#1201] / [Intel XE#1252]) +1 other test skip
   [175]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_ccs@crc-primary-basic-4-tiled-xe2-ccs.html
   [176]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@kms_ccs@crc-primary-basic-4-tiled-xe2-ccs.html

  * igt@kms_ccs@crc-primary-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4:
    - shard-dg2-set2:     [SKIP][177] ([Intel XE#787]) -> [SKIP][178] ([Intel XE#1201] / [Intel XE#787]) +48 other tests skip
   [177]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_ccs@crc-primary-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4.html
   [178]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_ccs@crc-primary-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4.html

  * igt@kms_ccs@crc-primary-rotation-180-4-tiled-xe2-ccs:
    - shard-dg2-set2:     [SKIP][179] ([Intel XE#1201] / [Intel XE#1252]) -> [SKIP][180] ([Intel XE#1252])
   [179]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_ccs@crc-primary-rotation-180-4-tiled-xe2-ccs.html
   [180]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_ccs@crc-primary-rotation-180-4-tiled-xe2-ccs.html

  * igt@kms_ccs@missing-ccs-buffer-4-tiled-mtl-mc-ccs@pipe-d-dp-4:
    - shard-dg2-set2:     [SKIP][181] ([Intel XE#455] / [Intel XE#787]) -> [SKIP][182] ([Intel XE#1201] / [Intel XE#455] / [Intel XE#787]) +13 other tests skip
   [181]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_ccs@missing-ccs-buffer-4-tiled-mtl-mc-ccs@pipe-d-dp-4.html
   [182]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@kms_ccs@missing-ccs-buffer-4-tiled-mtl-mc-ccs@pipe-d-dp-4.html

  * igt@kms_ccs@missing-ccs-buffer-y-tiled-gen12-rc-ccs@pipe-d-hdmi-a-6:
    - shard-dg2-set2:     [SKIP][183] ([Intel XE#1201] / [Intel XE#787]) -> [SKIP][184] ([Intel XE#787]) +34 other tests skip
   [183]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-434/igt@kms_ccs@missing-ccs-buffer-y-tiled-gen12-rc-ccs@pipe-d-hdmi-a-6.html
   [184]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_ccs@missing-ccs-buffer-y-tiled-gen12-rc-ccs@pipe-d-hdmi-a-6.html

  * igt@kms_cdclk@mode-transition@pipe-d-dp-4:
    - shard-dg2-set2:     [SKIP][185] ([Intel XE#314]) -> [SKIP][186] ([Intel XE#1201] / [Intel XE#314]) +3 other tests skip
   [185]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_cdclk@mode-transition@pipe-d-dp-4.html
   [186]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_cdclk@mode-transition@pipe-d-dp-4.html

  * igt@kms_cdclk@plane-scaling@pipe-b-dp-4:
    - shard-dg2-set2:     [SKIP][187] ([Intel XE#1152] / [Intel XE#1201]) -> [SKIP][188] ([Intel XE#1152]) +3 other tests skip
   [187]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-436/igt@kms_cdclk@plane-scaling@pipe-b-dp-4.html
   [188]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_cdclk@plane-scaling@pipe-b-dp-4.html

  * igt@kms_chamelium_color@ctm-0-75:
    - shard-dg2-set2:     [SKIP][189] ([Intel XE#306]) -> [SKIP][190] ([Intel XE#1201] / [Intel XE#306]) +1 other test skip
   [189]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_chamelium_color@ctm-0-75.html
   [190]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_chamelium_color@ctm-0-75.html

  * igt@kms_chamelium_color@gamma:
    - shard-dg2-set2:     [SKIP][191] ([Intel XE#1201] / [Intel XE#306]) -> [SKIP][192] ([Intel XE#306]) +1 other test skip
   [191]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_chamelium_color@gamma.html
   [192]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_chamelium_color@gamma.html

  * igt@kms_chamelium_edid@dp-edid-change-during-suspend:
    - shard-dg2-set2:     [SKIP][193] ([Intel XE#373]) -> [SKIP][194] ([Intel XE#1201] / [Intel XE#373]) +8 other tests skip
   [193]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_chamelium_edid@dp-edid-change-during-suspend.html
   [194]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_chamelium_edid@dp-edid-change-during-suspend.html

  * igt@kms_chamelium_edid@vga-edid-read:
    - shard-dg2-set2:     [SKIP][195] ([Intel XE#1201] / [Intel XE#373]) -> [SKIP][196] ([Intel XE#373]) +6 other tests skip
   [195]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-436/igt@kms_chamelium_edid@vga-edid-read.html
   [196]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_chamelium_edid@vga-edid-read.html

  * igt@kms_content_protection@dp-mst-type-1:
    - shard-dg2-set2:     [SKIP][197] ([Intel XE#307]) -> [SKIP][198] ([Intel XE#1201] / [Intel XE#307])
   [197]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_content_protection@dp-mst-type-1.html
   [198]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@kms_content_protection@dp-mst-type-1.html

  * igt@kms_content_protection@lic-type-0:
    - shard-dg2-set2:     [FAIL][199] ([Intel XE#1178] / [Intel XE#1204]) -> [INCOMPLETE][200] ([Intel XE#1195])
   [199]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_content_protection@lic-type-0.html
   [200]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_content_protection@lic-type-0.html

  * igt@kms_content_protection@lic-type-0@pipe-a-dp-4:
    - shard-dg2-set2:     [FAIL][201] ([Intel XE#1204]) -> [INCOMPLETE][202] ([Intel XE#1195])
   [201]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_content_protection@lic-type-0@pipe-a-dp-4.html
   [202]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_content_protection@lic-type-0@pipe-a-dp-4.html

  * igt@kms_cursor_crc@cursor-offscreen-512x170:
    - shard-dg2-set2:     [SKIP][203] ([Intel XE#1201] / [Intel XE#308]) -> [SKIP][204] ([Intel XE#308])
   [203]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-433/igt@kms_cursor_crc@cursor-offscreen-512x170.html
   [204]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_cursor_crc@cursor-offscreen-512x170.html

  * igt@kms_cursor_crc@cursor-rapid-movement-512x170:
    - shard-dg2-set2:     [SKIP][205] ([Intel XE#308]) -> [SKIP][206] ([Intel XE#1201] / [Intel XE#308]) +1 other test skip
   [205]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_cursor_crc@cursor-rapid-movement-512x170.html
   [206]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_cursor_crc@cursor-rapid-movement-512x170.html

  * igt@kms_cursor_crc@cursor-sliding-max-size:
    - shard-dg2-set2:     [SKIP][207] ([Intel XE#455]) -> [SKIP][208] ([Intel XE#1201] / [Intel XE#455]) +9 other tests skip
   [207]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_cursor_crc@cursor-sliding-max-size.html
   [208]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_cursor_crc@cursor-sliding-max-size.html

  * igt@kms_display_modes@mst-extended-mode-negative:
    - shard-dg2-set2:     [SKIP][209] ([Intel XE#1201] / [Intel XE#307]) -> [SKIP][210] ([Intel XE#307])
   [209]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_display_modes@mst-extended-mode-negative.html
   [210]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_display_modes@mst-extended-mode-negative.html

  * igt@kms_feature_discovery@dp-mst:
    - shard-dg2-set2:     [SKIP][211] ([Intel XE#1137]) -> [SKIP][212] ([Intel XE#1137] / [Intel XE#1201])
   [211]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_feature_discovery@dp-mst.html
   [212]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_feature_discovery@dp-mst.html

  * igt@kms_flip@flip-vs-suspend:
    - shard-dg2-set2:     [INCOMPLETE][213] ([Intel XE#1195] / [Intel XE#2049]) -> [INCOMPLETE][214] ([Intel XE#1551] / [Intel XE#2049])
   [213]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_flip@flip-vs-suspend.html
   [214]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_flip@flip-vs-suspend.html

  * igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff:
    - shard-dg2-set2:     [SKIP][215] ([Intel XE#651]) -> [SKIP][216] ([Intel XE#1201] / [Intel XE#651]) +19 other tests skip
   [215]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff.html
   [216]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@kms_frontbuffer_tracking@drrs-2p-primscrn-cur-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-pri-indfb-draw-blt:
    - shard-dg2-set2:     [SKIP][217] ([Intel XE#1201] / [Intel XE#651]) -> [SKIP][218] ([Intel XE#651]) +14 other tests skip
   [217]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-433/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-pri-indfb-draw-blt.html
   [218]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcdrrs-1p-primscrn-pri-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-slowdraw:
    - shard-dg2-set2:     [SKIP][219] ([Intel XE#1201] / [Intel XE#653]) -> [SKIP][220] ([Intel XE#653]) +17 other tests skip
   [219]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_frontbuffer_tracking@fbcpsr-slowdraw.html
   [220]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_frontbuffer_tracking@fbcpsr-slowdraw.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-plflip-blt:
    - shard-dg2-set2:     [SKIP][221] ([Intel XE#653]) -> [SKIP][222] ([Intel XE#1201] / [Intel XE#653]) +22 other tests skip
   [221]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-plflip-blt.html
   [222]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_frontbuffer_tracking@psr-2p-primscrn-shrfb-plflip-blt.html

  * igt@kms_pm_backlight@bad-brightness:
    - shard-dg2-set2:     [SKIP][223] ([Intel XE#870]) -> [SKIP][224] ([Intel XE#1201] / [Intel XE#870])
   [223]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_pm_backlight@bad-brightness.html
   [224]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-433/igt@kms_pm_backlight@bad-brightness.html

  * igt@kms_pm_backlight@fade-with-dpms:
    - shard-dg2-set2:     [SKIP][225] ([Intel XE#1201] / [Intel XE#870]) -> [SKIP][226] ([Intel XE#870])
   [225]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@kms_pm_backlight@fade-with-dpms.html
   [226]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_pm_backlight@fade-with-dpms.html

  * igt@kms_psr2_sf@fbc-overlay-primary-update-sf-dmg-area:
    - shard-dg2-set2:     [SKIP][227] ([Intel XE#1201] / [Intel XE#1489]) -> [SKIP][228] ([Intel XE#1489]) +1 other test skip
   [227]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_psr2_sf@fbc-overlay-primary-update-sf-dmg-area.html
   [228]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_psr2_sf@fbc-overlay-primary-update-sf-dmg-area.html

  * igt@kms_psr2_sf@primary-plane-update-sf-dmg-area-big-fb:
    - shard-dg2-set2:     [SKIP][229] ([Intel XE#1489]) -> [SKIP][230] ([Intel XE#1201] / [Intel XE#1489]) +2 other tests skip
   [229]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_psr2_sf@primary-plane-update-sf-dmg-area-big-fb.html
   [230]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@kms_psr2_sf@primary-plane-update-sf-dmg-area-big-fb.html

  * igt@kms_psr2_su@frontbuffer-xrgb8888:
    - shard-dg2-set2:     [SKIP][231] ([Intel XE#1122] / [Intel XE#1201]) -> [SKIP][232] ([Intel XE#1122])
   [231]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-433/igt@kms_psr2_su@frontbuffer-xrgb8888.html
   [232]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_psr2_su@frontbuffer-xrgb8888.html

  * igt@kms_psr2_su@page_flip-p010:
    - shard-dg2-set2:     [SKIP][233] ([Intel XE#1122]) -> [SKIP][234] ([Intel XE#1122] / [Intel XE#1201])
   [233]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_psr2_su@page_flip-p010.html
   [234]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_psr2_su@page_flip-p010.html

  * igt@kms_psr@fbc-pr-cursor-blt:
    - shard-dg2-set2:     [SKIP][235] ([Intel XE#1201] / [Intel XE#929]) -> [SKIP][236] ([Intel XE#929]) +8 other tests skip
   [235]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_psr@fbc-pr-cursor-blt.html
   [236]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_psr@fbc-pr-cursor-blt.html

  * igt@kms_psr@fbc-pr-dpms:
    - shard-dg2-set2:     [SKIP][237] ([Intel XE#929]) -> [SKIP][238] ([Intel XE#1201] / [Intel XE#929]) +7 other tests skip
   [237]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_psr@fbc-pr-dpms.html
   [238]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_psr@fbc-pr-dpms.html

  * igt@kms_psr_stress_test@invalidate-primary-flip-overlay:
    - shard-dg2-set2:     [SKIP][239] ([Intel XE#1149]) -> [SKIP][240] ([Intel XE#1149] / [Intel XE#1201])
   [239]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_psr_stress_test@invalidate-primary-flip-overlay.html
   [240]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_psr_stress_test@invalidate-primary-flip-overlay.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-90:
    - shard-dg2-set2:     [SKIP][241] ([Intel XE#1201] / [Intel XE#327]) -> [SKIP][242] ([Intel XE#327]) +1 other test skip
   [241]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-434/igt@kms_rotation_crc@primary-y-tiled-reflect-x-90.html
   [242]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_rotation_crc@primary-y-tiled-reflect-x-90.html

  * igt@kms_rotation_crc@sprite-rotation-90-pos-100-0:
    - shard-dg2-set2:     [SKIP][243] ([Intel XE#327]) -> [SKIP][244] ([Intel XE#1201] / [Intel XE#327])
   [243]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_rotation_crc@sprite-rotation-90-pos-100-0.html
   [244]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@kms_rotation_crc@sprite-rotation-90-pos-100-0.html

  * igt@kms_tiled_display@basic-test-pattern:
    - shard-dg2-set2:     [FAIL][245] ([Intel XE#1729]) -> [SKIP][246] ([Intel XE#1201] / [Intel XE#362])
   [245]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-436/igt@kms_tiled_display@basic-test-pattern.html
   [246]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_tiled_display@basic-test-pattern.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-dg2-set2:     [SKIP][247] ([Intel XE#1201] / [Intel XE#1500]) -> [SKIP][248] ([Intel XE#1201] / [Intel XE#362])
   [247]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html
   [248]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@kms_vblank@ts-continuation-suspend:
    - shard-dg2-set2:     [DMESG-WARN][249] ([Intel XE#2019]) -> [DMESG-WARN][250] ([Intel XE#2019] / [Intel XE#2226]) +1 other test dmesg-warn
   [249]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-436/igt@kms_vblank@ts-continuation-suspend.html
   [250]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_vblank@ts-continuation-suspend.html

  * igt@kms_vrr@flipline:
    - shard-dg2-set2:     [SKIP][251] ([Intel XE#1201] / [Intel XE#455]) -> [SKIP][252] ([Intel XE#455]) +13 other tests skip
   [251]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_vrr@flipline.html
   [252]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_vrr@flipline.html

  * igt@kms_vrr@lobf:
    - shard-dg2-set2:     [SKIP][253] -> [SKIP][254] ([Intel XE#1201])
   [253]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_vrr@lobf.html
   [254]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@kms_vrr@lobf.html

  * igt@kms_writeback@writeback-fb-id-xrgb2101010:
    - shard-dg2-set2:     [SKIP][255] ([Intel XE#1201] / [Intel XE#756]) -> [SKIP][256] ([Intel XE#756]) +1 other test skip
   [255]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@kms_writeback@writeback-fb-id-xrgb2101010.html
   [256]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@kms_writeback@writeback-fb-id-xrgb2101010.html

  * igt@kms_writeback@writeback-invalid-parameters:
    - shard-dg2-set2:     [SKIP][257] ([Intel XE#756]) -> [SKIP][258] ([Intel XE#1201] / [Intel XE#756])
   [257]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@kms_writeback@writeback-invalid-parameters.html
   [258]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@kms_writeback@writeback-invalid-parameters.html

  * igt@xe_copy_basic@mem-copy-linear-0xfffe:
    - shard-dg2-set2:     [SKIP][259] ([Intel XE#1123]) -> [SKIP][260] ([Intel XE#1123] / [Intel XE#1201])
   [259]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_copy_basic@mem-copy-linear-0xfffe.html
   [260]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@xe_copy_basic@mem-copy-linear-0xfffe.html

  * igt@xe_exec_fault_mode@once-rebind-imm:
    - shard-dg2-set2:     [SKIP][261] ([Intel XE#288]) -> [SKIP][262] ([Intel XE#1201] / [Intel XE#288]) +12 other tests skip
   [261]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_exec_fault_mode@once-rebind-imm.html
   [262]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@xe_exec_fault_mode@once-rebind-imm.html

  * igt@xe_exec_fault_mode@twice-userptr-prefetch:
    - shard-dg2-set2:     [SKIP][263] ([Intel XE#1201] / [Intel XE#288]) -> [SKIP][264] ([Intel XE#288]) +15 other tests skip
   [263]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@xe_exec_fault_mode@twice-userptr-prefetch.html
   [264]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@xe_exec_fault_mode@twice-userptr-prefetch.html

  * igt@xe_exec_mix_modes@exec-simple-batch-store-lr:
    - shard-dg2-set2:     [SKIP][265] ([Intel XE#2360]) -> [SKIP][266] ([Intel XE#1201] / [Intel XE#2360])
   [265]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_exec_mix_modes@exec-simple-batch-store-lr.html
   [266]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-435/igt@xe_exec_mix_modes@exec-simple-batch-store-lr.html

  * igt@xe_mmap@small-bar:
    - shard-dg2-set2:     [SKIP][267] ([Intel XE#512]) -> [SKIP][268] ([Intel XE#1201] / [Intel XE#512])
   [267]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_mmap@small-bar.html
   [268]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-434/igt@xe_mmap@small-bar.html

  * igt@xe_oa@non-zero-reason:
    - shard-dg2-set2:     [SKIP][269] ([Intel XE#1201] / [Intel XE#2207]) -> [SKIP][270] ([Intel XE#2207]) +3 other tests skip
   [269]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-435/igt@xe_oa@non-zero-reason.html
   [270]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@xe_oa@non-zero-reason.html

  * igt@xe_oa@polling-small-buf:
    - shard-dg2-set2:     [SKIP][271] ([Intel XE#2207]) -> [SKIP][272] ([Intel XE#1201] / [Intel XE#2207]) +2 other tests skip
   [271]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_oa@polling-small-buf.html
   [272]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-436/igt@xe_oa@polling-small-buf.html

  * igt@xe_pm@d3cold-basic-exec:
    - shard-dg2-set2:     [SKIP][273] ([Intel XE#2284] / [Intel XE#366]) -> [SKIP][274] ([Intel XE#1201] / [Intel XE#2284] / [Intel XE#366]) +2 other tests skip
   [273]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_pm@d3cold-basic-exec.html
   [274]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-466/igt@xe_pm@d3cold-basic-exec.html

  * igt@xe_pm@d3cold-multiple-execs:
    - shard-dg2-set2:     [SKIP][275] ([Intel XE#1201] / [Intel XE#2284] / [Intel XE#366]) -> [SKIP][276] ([Intel XE#2284] / [Intel XE#366])
   [275]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-463/igt@xe_pm@d3cold-multiple-execs.html
   [276]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@xe_pm@d3cold-multiple-execs.html

  * igt@xe_query@multigpu-query-uc-fw-version-guc:
    - shard-dg2-set2:     [SKIP][277] ([Intel XE#944]) -> [SKIP][278] ([Intel XE#1201] / [Intel XE#944]) +2 other tests skip
   [277]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-432/igt@xe_query@multigpu-query-uc-fw-version-guc.html
   [278]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-463/igt@xe_query@multigpu-query-uc-fw-version-guc.html

  * igt@xe_query@multigpu-query-uc-fw-version-huc:
    - shard-dg2-set2:     [SKIP][279] ([Intel XE#1201] / [Intel XE#944]) -> [SKIP][280] ([Intel XE#944]) +1 other test skip
   [279]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-dg2-466/igt@xe_query@multigpu-query-uc-fw-version-huc.html
   [280]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-dg2-432/igt@xe_query@multigpu-query-uc-fw-version-huc.html

  * igt@xe_wedged@wedged-at-any-timeout:
    - shard-lnl:          [DMESG-FAIL][281] ([Intel XE#1760]) -> [DMESG-WARN][282] ([Intel XE#1760])
   [281]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7964/shard-lnl-3/igt@xe_wedged@wedged-at-any-timeout.html
   [282]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_11551/shard-lnl-3/igt@xe_wedged@wedged-at-any-timeout.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [Intel XE#1033]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1033
  [Intel XE#1091]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1091
  [Intel XE#1122]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1122
  [Intel XE#1123]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1123
  [Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
  [Intel XE#1126]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1126
  [Intel XE#1137]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1137
  [Intel XE#1149]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1149
  [Intel XE#1152]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1152
  [Intel XE#1169]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1169
  [Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
  [Intel XE#1192]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1192
  [Intel XE#1195]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1195
  [Intel XE#1201]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1201
  [Intel XE#1204]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1204
  [Intel XE#1252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1252
  [Intel XE#1358]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1358
  [Intel XE#1392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1392
  [Intel XE#1399]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1399
  [Intel XE#1401]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1401
  [Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406
  [Intel XE#1407]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1407
  [Intel XE#1420]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1420
  [Intel XE#1421]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1421
  [Intel XE#1424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1424
  [Intel XE#1426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1426
  [Intel XE#1435]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1435
  [Intel XE#1473]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1473
  [Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
  [Intel XE#1500]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1500
  [Intel XE#1551]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1551
  [Intel XE#1620]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1620
  [Intel XE#1659]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1659
  [Intel XE#1695]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1695
  [Intel XE#1729]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1729
  [Intel XE#1745]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1745
  [Intel XE#1760]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1760
  [Intel XE#1794]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1794
  [Intel XE#1861]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1861
  [Intel XE#1948]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1948
  [Intel XE#2019]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2019
  [Intel XE#2028]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2028
  [Intel XE#2049]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2049
  [Intel XE#2136]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2136
  [Intel XE#2191]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2191
  [Intel XE#2207]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2207
  [Intel XE#2226]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2226
  [Intel XE#2229]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2229
  [Intel XE#2233]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2233
  [Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
  [Intel XE#2244]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2244
  [Intel XE#2251]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2251
  [Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
  [Intel XE#2284]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2284
  [Intel XE#2293]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2293
  [Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
  [Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
  [Intel XE#2314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2314
  [Intel XE#2318]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2318
  [Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
  [Intel XE#2321]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2321
  [Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
  [Intel XE#2325]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2325
  [Intel XE#2327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2327
  [Intel XE#2329]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2329
  [Intel XE#2333]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2333
  [Intel XE#2360]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2360
  [Intel XE#2362]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2362
  [Intel XE#2380]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2380
  [Intel XE#2429]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2429
  [Intel XE#2436]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2436
  [Intel XE#2443]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2443
  [Intel XE#2472]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2472
  [Intel XE#288]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/288
  [Intel XE#306]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/306
  [Intel XE#307]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/307
  [Intel XE#308]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/308
  [Intel XE#309]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/309
  [Intel XE#314]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/314
  [Intel XE#316]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/316
  [Intel XE#324]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/324
  [Intel XE#327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/327
  [Intel XE#361]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/361
  [Intel XE#362]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/362
  [Intel XE#366]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/366
  [Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
  [Intel XE#373]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/373
  [Intel XE#392]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/392
  [Intel XE#402]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/402
  [Intel XE#455]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/455
  [Intel XE#512]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/512
  [Intel XE#569]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/569
  [Intel XE#607]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/607
  [Intel XE#610]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/610
  [Intel XE#623]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/623
  [Intel XE#651]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/651
  [Intel XE#653]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/653
  [Intel XE#656]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/656
  [Intel XE#658]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/658
  [Intel XE#688]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/688
  [Intel XE#703]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/703
  [Intel XE#718]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/718
  [Intel XE#756]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/756
  [Intel XE#787]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/787
  [Intel XE#870]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/870
  [Intel XE#877]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/877
  [Intel XE#886]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/886
  [Intel XE#899]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/899
  [Intel XE#911]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/911
  [Intel XE#929]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/929
  [Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944


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

  * IGT: IGT_7964 -> IGTPW_11551

  IGTPW_11551: 11551
  IGT_7964: 0dabf88262c0349d261248638064b97da35369f8 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-1740-8d0f83b389ec64b9f7f9b2ee241fc352346868f1: 8d0f83b389ec64b9f7f9b2ee241fc352346868f1

== Logs ==

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

[-- Attachment #2: Type: text/html, Size: 99420 bytes --]

✗ Fi.CI.IGT: failure for Test coverage for GPU debug support (rev3)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 95630 bytes --]

== Series Details ==

Series: Test coverage for GPU debug support (rev3)
URL   : https://patchwork.freedesktop.org/series/136623/
State : failure

== Summary ==

CI Bug Log - changes from IGT_7964_full -> IGTPW_11551_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_11551_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_11551_full, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

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

Participating hosts (9 -> 9)
------------------------------

  No changes in participating hosts

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

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

### IGT changes ###

#### Possible regressions ####

  * igt@gem_ppgtt@blt-vs-render-ctxn:
    - shard-glk:          [PASS][1] -> [INCOMPLETE][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-glk7/igt@gem_ppgtt@blt-vs-render-ctxn.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk5/igt@gem_ppgtt@blt-vs-render-ctxn.html

  * igt@i915_pm_rps@thresholds:
    - shard-dg2:          NOTRUN -> [SKIP][3]
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@i915_pm_rps@thresholds.html

  * igt@i915_pm_rps@thresholds-park:
    - shard-dg1:          NOTRUN -> [SKIP][4]
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-14/igt@i915_pm_rps@thresholds-park.html

  * igt@kms_color@ctm-0-75:
    - shard-snb:          NOTRUN -> [INCOMPLETE][5]
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb2/igt@kms_color@ctm-0-75.html

  * igt@kms_flip@2x-blocking-absolute-wf_vblank@ab-vga1-hdmi-a1:
    - shard-snb:          [PASS][6] -> [ABORT][7]
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb4/igt@kms_flip@2x-blocking-absolute-wf_vblank@ab-vga1-hdmi-a1.html
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb6/igt@kms_flip@2x-blocking-absolute-wf_vblank@ab-vga1-hdmi-a1.html

  * igt@prime_self_import@export-vs-gem_close-race:
    - shard-rkl:          [PASS][8] -> [FAIL][9]
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-2/igt@prime_self_import@export-vs-gem_close-race.html
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-2/igt@prime_self_import@export-vs-gem_close-race.html
    - shard-glk:          [PASS][10] -> [FAIL][11]
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-glk9/igt@prime_self_import@export-vs-gem_close-race.html
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk7/igt@prime_self_import@export-vs-gem_close-race.html

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

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

### IGT changes ###

#### Issues hit ####

  * igt@debugfs_test@basic-hwmon:
    - shard-rkl:          NOTRUN -> [SKIP][12] ([i915#9318])
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-1/igt@debugfs_test@basic-hwmon.html

  * igt@device_reset@cold-reset-bound:
    - shard-mtlp:         NOTRUN -> [SKIP][13] ([i915#11078]) +1 other test skip
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@device_reset@cold-reset-bound.html
    - shard-dg2:          NOTRUN -> [SKIP][14] ([i915#11078])
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@device_reset@cold-reset-bound.html
    - shard-rkl:          NOTRUN -> [SKIP][15] ([i915#11078])
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@device_reset@cold-reset-bound.html

  * igt@device_reset@unbind-cold-reset-rebind:
    - shard-dg1:          NOTRUN -> [SKIP][16] ([i915#11078])
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-14/igt@device_reset@unbind-cold-reset-rebind.html

  * igt@drm_fdinfo@busy-hang@bcs0:
    - shard-dg1:          NOTRUN -> [SKIP][17] ([i915#8414]) +7 other tests skip
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@drm_fdinfo@busy-hang@bcs0.html

  * igt@drm_fdinfo@most-busy-idle-check-all@vecs1:
    - shard-dg2:          NOTRUN -> [SKIP][18] ([i915#8414]) +14 other tests skip
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@drm_fdinfo@most-busy-idle-check-all@vecs1.html

  * igt@drm_fdinfo@virtual-idle:
    - shard-rkl:          NOTRUN -> [FAIL][19] ([i915#11900] / [i915#7742])
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-2/igt@drm_fdinfo@virtual-idle.html

  * igt@gem_bad_reloc@negative-reloc-bltcopy:
    - shard-mtlp:         NOTRUN -> [SKIP][20] ([i915#3281]) +9 other tests skip
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-6/igt@gem_bad_reloc@negative-reloc-bltcopy.html

  * igt@gem_basic@multigpu-create-close:
    - shard-dg2:          NOTRUN -> [SKIP][21] ([i915#7697])
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@gem_basic@multigpu-create-close.html

  * igt@gem_ctx_persistence@heartbeat-close:
    - shard-dg2:          NOTRUN -> [SKIP][22] ([i915#8555])
   [22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@gem_ctx_persistence@heartbeat-close.html

  * igt@gem_ctx_persistence@heartbeat-stop:
    - shard-mtlp:         NOTRUN -> [SKIP][23] ([i915#8555]) +1 other test skip
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-8/igt@gem_ctx_persistence@heartbeat-stop.html

  * igt@gem_ctx_sseu@engines:
    - shard-mtlp:         NOTRUN -> [SKIP][24] ([i915#280])
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-8/igt@gem_ctx_sseu@engines.html

  * igt@gem_ctx_sseu@invalid-sseu:
    - shard-rkl:          NOTRUN -> [SKIP][25] ([i915#280])
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@gem_ctx_sseu@invalid-sseu.html
    - shard-dg1:          NOTRUN -> [SKIP][26] ([i915#280]) +1 other test skip
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@gem_ctx_sseu@invalid-sseu.html

  * igt@gem_eio@hibernate:
    - shard-rkl:          NOTRUN -> [ABORT][27] ([i915#7975] / [i915#8213])
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@gem_eio@hibernate.html

  * igt@gem_eio@kms:
    - shard-dg2:          [PASS][28] -> [FAIL][29] ([i915#5784])
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-6/igt@gem_eio@kms.html
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@gem_eio@kms.html

  * igt@gem_eio@reset-stress:
    - shard-snb:          NOTRUN -> [FAIL][30] ([i915#8898])
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb5/igt@gem_eio@reset-stress.html

  * igt@gem_eio@unwedge-stress:
    - shard-dg1:          NOTRUN -> [FAIL][31] ([i915#5784])
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@gem_eio@unwedge-stress.html

  * igt@gem_exec_balancer@invalid-bonds:
    - shard-dg2:          NOTRUN -> [SKIP][32] ([i915#4036])
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@gem_exec_balancer@invalid-bonds.html

  * igt@gem_exec_balancer@parallel-bb-first:
    - shard-rkl:          NOTRUN -> [SKIP][33] ([i915#4525]) +1 other test skip
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@gem_exec_balancer@parallel-bb-first.html

  * igt@gem_exec_big@single:
    - shard-tglu:         [PASS][34] -> [ABORT][35] ([i915#11713])
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-tglu-8/igt@gem_exec_big@single.html
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-6/igt@gem_exec_big@single.html

  * igt@gem_exec_fair@basic-deadline:
    - shard-glk:          NOTRUN -> [FAIL][36] ([i915#2846])
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk1/igt@gem_exec_fair@basic-deadline.html

  * igt@gem_exec_fair@basic-none-share@rcs0:
    - shard-tglu:         NOTRUN -> [FAIL][37] ([i915#2842])
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-7/igt@gem_exec_fair@basic-none-share@rcs0.html

  * igt@gem_exec_fair@basic-pace:
    - shard-mtlp:         NOTRUN -> [SKIP][38] ([i915#4473] / [i915#4771])
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-4/igt@gem_exec_fair@basic-pace.html

  * igt@gem_exec_fair@basic-pace-solo:
    - shard-dg2:          NOTRUN -> [SKIP][39] ([i915#3539]) +2 other tests skip
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@gem_exec_fair@basic-pace-solo.html

  * igt@gem_exec_fair@basic-pace@vecs0:
    - shard-rkl:          [PASS][40] -> [FAIL][41] ([i915#2842]) +2 other tests fail
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-3/igt@gem_exec_fair@basic-pace@vecs0.html
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@gem_exec_fair@basic-pace@vecs0.html

  * igt@gem_exec_fair@basic-throttle@rcs0:
    - shard-glk:          NOTRUN -> [FAIL][42] ([i915#2842]) +2 other tests fail
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk8/igt@gem_exec_fair@basic-throttle@rcs0.html

  * igt@gem_exec_fence@submit67:
    - shard-mtlp:         NOTRUN -> [SKIP][43] ([i915#4812])
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@gem_exec_fence@submit67.html

  * igt@gem_exec_flush@basic-batch-kernel-default-wb:
    - shard-dg1:          NOTRUN -> [SKIP][44] ([i915#3539] / [i915#4852]) +2 other tests skip
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@gem_exec_flush@basic-batch-kernel-default-wb.html

  * igt@gem_exec_flush@basic-uc-pro-default:
    - shard-dg2:          NOTRUN -> [SKIP][45] ([i915#3539] / [i915#4852]) +3 other tests skip
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@gem_exec_flush@basic-uc-pro-default.html

  * igt@gem_exec_flush@basic-uc-prw-default:
    - shard-dg1:          NOTRUN -> [SKIP][46] ([i915#3539])
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@gem_exec_flush@basic-uc-prw-default.html

  * igt@gem_exec_reloc@basic-cpu-read:
    - shard-dg2:          NOTRUN -> [SKIP][47] ([i915#3281]) +11 other tests skip
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@gem_exec_reloc@basic-cpu-read.html

  * igt@gem_exec_reloc@basic-gtt-read-noreloc:
    - shard-rkl:          NOTRUN -> [SKIP][48] ([i915#3281]) +7 other tests skip
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@gem_exec_reloc@basic-gtt-read-noreloc.html

  * igt@gem_exec_reloc@basic-wc-read:
    - shard-dg1:          NOTRUN -> [SKIP][49] ([i915#3281]) +10 other tests skip
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@gem_exec_reloc@basic-wc-read.html

  * igt@gem_exec_schedule@preempt-queue-contexts:
    - shard-dg1:          NOTRUN -> [SKIP][50] ([i915#4812]) +1 other test skip
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-18/igt@gem_exec_schedule@preempt-queue-contexts.html

  * igt@gem_exec_schedule@reorder-wide:
    - shard-dg2:          NOTRUN -> [SKIP][51] ([i915#4537] / [i915#4812]) +1 other test skip
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@gem_exec_schedule@reorder-wide.html

  * igt@gem_fence_thrash@bo-write-verify-none:
    - shard-mtlp:         NOTRUN -> [SKIP][52] ([i915#4860]) +3 other tests skip
   [52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-7/igt@gem_fence_thrash@bo-write-verify-none.html

  * igt@gem_fenced_exec_thrash@no-spare-fences-busy-interruptible:
    - shard-dg2:          NOTRUN -> [SKIP][53] ([i915#4860]) +1 other test skip
   [53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@gem_fenced_exec_thrash@no-spare-fences-busy-interruptible.html

  * igt@gem_lmem_swapping@heavy-verify-multi:
    - shard-mtlp:         NOTRUN -> [SKIP][54] ([i915#4613]) +3 other tests skip
   [54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@gem_lmem_swapping@heavy-verify-multi.html

  * igt@gem_lmem_swapping@heavy-verify-multi-ccs:
    - shard-tglu:         NOTRUN -> [SKIP][55] ([i915#4613]) +1 other test skip
   [55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-7/igt@gem_lmem_swapping@heavy-verify-multi-ccs.html
    - shard-glk:          NOTRUN -> [SKIP][56] ([i915#4613]) +2 other tests skip
   [56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk8/igt@gem_lmem_swapping@heavy-verify-multi-ccs.html

  * igt@gem_lmem_swapping@parallel-random-verify:
    - shard-rkl:          NOTRUN -> [SKIP][57] ([i915#4613]) +5 other tests skip
   [57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@gem_lmem_swapping@parallel-random-verify.html

  * igt@gem_media_vme:
    - shard-mtlp:         NOTRUN -> [SKIP][58] ([i915#284])
   [58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@gem_media_vme.html

  * igt@gem_mmap@short-mmap:
    - shard-mtlp:         NOTRUN -> [SKIP][59] ([i915#4083]) +2 other tests skip
   [59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-7/igt@gem_mmap@short-mmap.html

  * igt@gem_mmap_gtt@bad-object:
    - shard-dg2:          NOTRUN -> [SKIP][60] ([i915#4077]) +5 other tests skip
   [60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@gem_mmap_gtt@bad-object.html

  * igt@gem_mmap_gtt@coherency:
    - shard-dg1:          NOTRUN -> [SKIP][61] ([i915#4077]) +11 other tests skip
   [61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@gem_mmap_gtt@coherency.html

  * igt@gem_mmap_wc@close:
    - shard-dg2:          NOTRUN -> [SKIP][62] ([i915#4083]) +4 other tests skip
   [62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@gem_mmap_wc@close.html

  * igt@gem_mmap_wc@write-read:
    - shard-dg1:          NOTRUN -> [SKIP][63] ([i915#4083]) +7 other tests skip
   [63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@gem_mmap_wc@write-read.html

  * igt@gem_pread@self:
    - shard-dg2:          NOTRUN -> [SKIP][64] ([i915#3282]) +4 other tests skip
   [64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-6/igt@gem_pread@self.html

  * igt@gem_pwrite@basic-exhaustion:
    - shard-rkl:          NOTRUN -> [SKIP][65] ([i915#3282]) +7 other tests skip
   [65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@gem_pwrite@basic-exhaustion.html
    - shard-glk:          NOTRUN -> [WARN][66] ([i915#2658])
   [66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk9/igt@gem_pwrite@basic-exhaustion.html

  * igt@gem_pxp@create-valid-protected-context:
    - shard-mtlp:         NOTRUN -> [SKIP][67] ([i915#4270]) +2 other tests skip
   [67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-4/igt@gem_pxp@create-valid-protected-context.html

  * igt@gem_pxp@fail-invalid-protected-context:
    - shard-dg1:          NOTRUN -> [SKIP][68] ([i915#4270]) +1 other test skip
   [68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@gem_pxp@fail-invalid-protected-context.html

  * igt@gem_pxp@protected-raw-src-copy-not-readible:
    - shard-dg2:          NOTRUN -> [SKIP][69] ([i915#4270]) +2 other tests skip
   [69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@gem_pxp@protected-raw-src-copy-not-readible.html
    - shard-rkl:          NOTRUN -> [SKIP][70] ([i915#4270]) +1 other test skip
   [70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@gem_pxp@protected-raw-src-copy-not-readible.html
    - shard-tglu:         NOTRUN -> [SKIP][71] ([i915#4270])
   [71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-6/igt@gem_pxp@protected-raw-src-copy-not-readible.html

  * igt@gem_readwrite@beyond-eob:
    - shard-dg1:          NOTRUN -> [SKIP][72] ([i915#3282]) +3 other tests skip
   [72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@gem_readwrite@beyond-eob.html

  * igt@gem_readwrite@new-obj:
    - shard-mtlp:         NOTRUN -> [SKIP][73] ([i915#3282]) +4 other tests skip
   [73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@gem_readwrite@new-obj.html

  * igt@gem_render_copy@y-tiled-mc-ccs-to-vebox-yf-tiled:
    - shard-mtlp:         NOTRUN -> [SKIP][74] ([i915#8428]) +4 other tests skip
   [74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@gem_render_copy@y-tiled-mc-ccs-to-vebox-yf-tiled.html

  * igt@gem_render_copy@y-tiled-to-vebox-linear:
    - shard-dg2:          NOTRUN -> [SKIP][75] ([i915#5190] / [i915#8428]) +6 other tests skip
   [75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@gem_render_copy@y-tiled-to-vebox-linear.html

  * igt@gem_softpin@evict-snoop:
    - shard-dg1:          NOTRUN -> [SKIP][76] ([i915#4885]) +1 other test skip
   [76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@gem_softpin@evict-snoop.html
    - shard-mtlp:         NOTRUN -> [SKIP][77] ([i915#4885])
   [77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@gem_softpin@evict-snoop.html

  * igt@gem_tiled_pread_basic:
    - shard-mtlp:         NOTRUN -> [SKIP][78] ([i915#4079]) +1 other test skip
   [78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@gem_tiled_pread_basic.html

  * igt@gem_tiling_max_stride:
    - shard-mtlp:         NOTRUN -> [SKIP][79] ([i915#4077]) +7 other tests skip
   [79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@gem_tiling_max_stride.html

  * igt@gem_unfence_active_buffers:
    - shard-dg2:          NOTRUN -> [SKIP][80] ([i915#4879])
   [80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-3/igt@gem_unfence_active_buffers.html

  * igt@gem_userptr_blits@map-fixed-invalidate:
    - shard-dg2:          NOTRUN -> [SKIP][81] ([i915#3297] / [i915#4880])
   [81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@gem_userptr_blits@map-fixed-invalidate.html

  * igt@gem_userptr_blits@map-fixed-invalidate-busy:
    - shard-mtlp:         NOTRUN -> [SKIP][82] ([i915#3297])
   [82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@gem_userptr_blits@map-fixed-invalidate-busy.html

  * igt@gem_userptr_blits@unsync-overlap:
    - shard-dg1:          NOTRUN -> [SKIP][83] ([i915#3297]) +1 other test skip
   [83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@gem_userptr_blits@unsync-overlap.html

  * igt@gem_userptr_blits@unsync-unmap:
    - shard-dg2:          NOTRUN -> [SKIP][84] ([i915#3297]) +2 other tests skip
   [84]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@gem_userptr_blits@unsync-unmap.html
    - shard-rkl:          NOTRUN -> [SKIP][85] ([i915#3297]) +1 other test skip
   [85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-1/igt@gem_userptr_blits@unsync-unmap.html
    - shard-tglu:         NOTRUN -> [SKIP][86] ([i915#3297])
   [86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@gem_userptr_blits@unsync-unmap.html

  * igt@gen9_exec_parse@allowed-single:
    - shard-mtlp:         NOTRUN -> [SKIP][87] ([i915#2856]) +3 other tests skip
   [87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@gen9_exec_parse@allowed-single.html

  * igt@gen9_exec_parse@bb-start-out:
    - shard-dg1:          NOTRUN -> [SKIP][88] ([i915#2527]) +1 other test skip
   [88]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@gen9_exec_parse@bb-start-out.html

  * igt@gen9_exec_parse@secure-batches:
    - shard-rkl:          NOTRUN -> [SKIP][89] ([i915#2527]) +2 other tests skip
   [89]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@gen9_exec_parse@secure-batches.html

  * igt@gen9_exec_parse@unaligned-access:
    - shard-dg2:          NOTRUN -> [SKIP][90] ([i915#2856]) +4 other tests skip
   [90]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@gen9_exec_parse@unaligned-access.html

  * igt@i915_fb_tiling:
    - shard-mtlp:         NOTRUN -> [SKIP][91] ([i915#4881])
   [91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@i915_fb_tiling.html

  * igt@i915_module_load@reload-with-fault-injection:
    - shard-dg1:          [PASS][92] -> [ABORT][93] ([i915#9820])
   [92]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg1-16/igt@i915_module_load@reload-with-fault-injection.html
   [93]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@i915_module_load@reload-with-fault-injection.html

  * igt@i915_pm_rc6_residency@rc6-idle@gt0-vcs0:
    - shard-dg1:          [PASS][94] -> [FAIL][95] ([i915#3591]) +1 other test fail
   [94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg1-15/igt@i915_pm_rc6_residency@rc6-idle@gt0-vcs0.html
   [95]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@i915_pm_rc6_residency@rc6-idle@gt0-vcs0.html

  * igt@i915_pm_sseu@full-enable:
    - shard-dg1:          NOTRUN -> [SKIP][96] ([i915#4387])
   [96]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@i915_pm_sseu@full-enable.html

  * igt@i915_suspend@basic-s3-without-i915:
    - shard-snb:          [PASS][97] -> [ABORT][98] ([i915#11703])
   [97]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb2/igt@i915_suspend@basic-s3-without-i915.html
   [98]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb2/igt@i915_suspend@basic-s3-without-i915.html

  * igt@intel_hwmon@hwmon-read:
    - shard-rkl:          NOTRUN -> [SKIP][99] ([i915#7707])
   [99]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@intel_hwmon@hwmon-read.html

  * igt@intel_hwmon@hwmon-write:
    - shard-mtlp:         NOTRUN -> [SKIP][100] ([i915#7707])
   [100]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@intel_hwmon@hwmon-write.html

  * igt@kms_addfb_basic@addfb25-x-tiled-mismatch-legacy:
    - shard-mtlp:         NOTRUN -> [SKIP][101] ([i915#4212]) +2 other tests skip
   [101]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@kms_addfb_basic@addfb25-x-tiled-mismatch-legacy.html

  * igt@kms_addfb_basic@addfb25-y-tiled-small-legacy:
    - shard-dg2:          NOTRUN -> [SKIP][102] ([i915#5190]) +3 other tests skip
   [102]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_addfb_basic@addfb25-y-tiled-small-legacy.html

  * igt@kms_addfb_basic@clobberred-modifier:
    - shard-dg2:          NOTRUN -> [SKIP][103] ([i915#4212]) +2 other tests skip
   [103]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_addfb_basic@clobberred-modifier.html

  * igt@kms_async_flips@async-flip-with-page-flip-events@pipe-b-hdmi-a-4-y-rc-ccs:
    - shard-dg1:          NOTRUN -> [SKIP][104] ([i915#8709]) +7 other tests skip
   [104]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_async_flips@async-flip-with-page-flip-events@pipe-b-hdmi-a-4-y-rc-ccs.html

  * igt@kms_async_flips@async-flip-with-page-flip-events@pipe-d-hdmi-a-2-4-mc-ccs:
    - shard-dg2:          NOTRUN -> [SKIP][105] ([i915#8709]) +11 other tests skip
   [105]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-3/igt@kms_async_flips@async-flip-with-page-flip-events@pipe-d-hdmi-a-2-4-mc-ccs.html

  * igt@kms_async_flips@invalid-async-flip:
    - shard-mtlp:         NOTRUN -> [SKIP][106] ([i915#6228])
   [106]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_async_flips@invalid-async-flip.html

  * igt@kms_atomic@plane-primary-overlay-mutable-zpos:
    - shard-rkl:          NOTRUN -> [SKIP][107] ([i915#9531])
   [107]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-2/igt@kms_atomic@plane-primary-overlay-mutable-zpos.html

  * igt@kms_atomic_transition@modeset-transition@2x-outputs:
    - shard-glk:          [PASS][108] -> [FAIL][109] ([i915#11859])
   [108]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-glk6/igt@kms_atomic_transition@modeset-transition@2x-outputs.html
   [109]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk8/igt@kms_atomic_transition@modeset-transition@2x-outputs.html

  * igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-1:
    - shard-snb:          [PASS][110] -> [FAIL][111] ([i915#5956])
   [110]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb7/igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-1.html
   [111]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb7/igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-1.html

  * igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-2:
    - shard-rkl:          [PASS][112] -> [FAIL][113] ([i915#11808])
   [112]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-5/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-2.html
   [113]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-1/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-2.html

  * igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-4:
    - shard-dg1:          [PASS][114] -> [FAIL][115] ([i915#5956])
   [114]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg1-17/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-4.html
   [115]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-4.html

  * igt@kms_big_fb@4-tiled-8bpp-rotate-0:
    - shard-rkl:          NOTRUN -> [SKIP][116] ([i915#5286]) +6 other tests skip
   [116]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_big_fb@4-tiled-8bpp-rotate-0.html

  * igt@kms_big_fb@4-tiled-addfb-size-offset-overflow:
    - shard-dg1:          NOTRUN -> [SKIP][117] ([i915#5286])
   [117]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_big_fb@4-tiled-addfb-size-offset-overflow.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-async-flip:
    - shard-dg1:          NOTRUN -> [SKIP][118] ([i915#4538] / [i915#5286]) +2 other tests skip
   [118]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-18/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-async-flip.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180:
    - shard-tglu:         NOTRUN -> [SKIP][119] ([i915#5286]) +1 other test skip
   [119]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-9/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-180.html

  * igt@kms_big_fb@x-tiled-32bpp-rotate-270:
    - shard-rkl:          NOTRUN -> [SKIP][120] ([i915#3638]) +4 other tests skip
   [120]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-1/igt@kms_big_fb@x-tiled-32bpp-rotate-270.html

  * igt@kms_big_fb@y-tiled-64bpp-rotate-90:
    - shard-dg1:          NOTRUN -> [SKIP][121] ([i915#3638]) +6 other tests skip
   [121]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_big_fb@y-tiled-64bpp-rotate-90.html

  * igt@kms_big_fb@yf-tiled-64bpp-rotate-0:
    - shard-dg2:          NOTRUN -> [SKIP][122] ([i915#4538] / [i915#5190]) +8 other tests skip
   [122]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_big_fb@yf-tiled-64bpp-rotate-0.html

  * igt@kms_big_fb@yf-tiled-max-hw-stride-64bpp-rotate-180:
    - shard-dg1:          NOTRUN -> [SKIP][123] ([i915#4538]) +5 other tests skip
   [123]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_big_fb@yf-tiled-max-hw-stride-64bpp-rotate-180.html

  * igt@kms_big_joiner@basic:
    - shard-dg1:          NOTRUN -> [SKIP][124] ([i915#10656])
   [124]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_big_joiner@basic.html
    - shard-mtlp:         NOTRUN -> [SKIP][125] ([i915#10656])
   [125]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@kms_big_joiner@basic.html

  * igt@kms_big_joiner@basic-force-joiner:
    - shard-dg2:          NOTRUN -> [SKIP][126] ([i915#10656])
   [126]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_big_joiner@basic-force-joiner.html

  * igt@kms_ccs@bad-aux-stride-yf-tiled-ccs@pipe-c-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][127] ([i915#6095]) +27 other tests skip
   [127]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-8/igt@kms_ccs@bad-aux-stride-yf-tiled-ccs@pipe-c-edp-1.html

  * igt@kms_ccs@bad-rotation-90-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][128] ([i915#6095]) +61 other tests skip
   [128]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_ccs@bad-rotation-90-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-2.html

  * igt@kms_ccs@bad-rotation-90-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4:
    - shard-dg2:          NOTRUN -> [SKIP][129] ([i915#10307] / [i915#6095]) +166 other tests skip
   [129]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_ccs@bad-rotation-90-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-4.html

  * igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs-cc@pipe-b-hdmi-a-1:
    - shard-tglu:         NOTRUN -> [SKIP][130] ([i915#6095]) +23 other tests skip
   [130]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-6/igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs-cc@pipe-b-hdmi-a-1.html

  * igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-hdmi-a-3:
    - shard-dg1:          NOTRUN -> [SKIP][131] ([i915#6095]) +95 other tests skip
   [131]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_ccs@random-ccs-data-4-tiled-dg2-rc-ccs@pipe-a-hdmi-a-3.html

  * igt@kms_ccs@random-ccs-data-yf-tiled-ccs@pipe-d-hdmi-a-1:
    - shard-dg2:          NOTRUN -> [SKIP][132] ([i915#10307] / [i915#10434] / [i915#6095]) +4 other tests skip
   [132]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_ccs@random-ccs-data-yf-tiled-ccs@pipe-d-hdmi-a-1.html

  * igt@kms_cdclk@mode-transition@pipe-a-dp-4:
    - shard-dg2:          NOTRUN -> [SKIP][133] ([i915#11616] / [i915#7213]) +3 other tests skip
   [133]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_cdclk@mode-transition@pipe-a-dp-4.html

  * igt@kms_cdclk@mode-transition@pipe-b-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][134] ([i915#7213] / [i915#9010]) +3 other tests skip
   [134]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_cdclk@mode-transition@pipe-b-edp-1.html

  * igt@kms_cdclk@plane-scaling:
    - shard-dg1:          NOTRUN -> [SKIP][135] ([i915#3742])
   [135]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_cdclk@plane-scaling.html

  * igt@kms_cdclk@plane-scaling@pipe-c-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][136] ([i915#4087]) +3 other tests skip
   [136]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_cdclk@plane-scaling@pipe-c-edp-1.html

  * igt@kms_cdclk@plane-scaling@pipe-d-dp-4:
    - shard-dg2:          NOTRUN -> [SKIP][137] ([i915#4087]) +3 other tests skip
   [137]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_cdclk@plane-scaling@pipe-d-dp-4.html

  * igt@kms_chamelium_edid@dp-mode-timings:
    - shard-mtlp:         NOTRUN -> [SKIP][138] ([i915#7828]) +6 other tests skip
   [138]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@kms_chamelium_edid@dp-mode-timings.html

  * igt@kms_chamelium_edid@hdmi-edid-change-during-suspend:
    - shard-rkl:          NOTRUN -> [SKIP][139] ([i915#7828]) +8 other tests skip
   [139]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-1/igt@kms_chamelium_edid@hdmi-edid-change-during-suspend.html
    - shard-dg1:          NOTRUN -> [SKIP][140] ([i915#7828]) +6 other tests skip
   [140]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_chamelium_edid@hdmi-edid-change-during-suspend.html

  * igt@kms_chamelium_frames@dp-crc-fast:
    - shard-dg2:          NOTRUN -> [SKIP][141] ([i915#7828]) +7 other tests skip
   [141]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_chamelium_frames@dp-crc-fast.html

  * igt@kms_chamelium_hpd@vga-hpd-without-ddc:
    - shard-tglu:         NOTRUN -> [SKIP][142] ([i915#7828]) +3 other tests skip
   [142]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@kms_chamelium_hpd@vga-hpd-without-ddc.html

  * igt@kms_content_protection@atomic:
    - shard-dg1:          NOTRUN -> [SKIP][143] ([i915#7116] / [i915#9424]) +1 other test skip
   [143]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_content_protection@atomic.html

  * igt@kms_content_protection@atomic-dpms:
    - shard-rkl:          NOTRUN -> [SKIP][144] ([i915#7118] / [i915#9424])
   [144]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_content_protection@atomic-dpms.html

  * igt@kms_content_protection@dp-mst-lic-type-1:
    - shard-dg2:          NOTRUN -> [SKIP][145] ([i915#3299]) +1 other test skip
   [145]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-6/igt@kms_content_protection@dp-mst-lic-type-1.html

  * igt@kms_content_protection@legacy:
    - shard-mtlp:         NOTRUN -> [SKIP][146] ([i915#6944] / [i915#9424])
   [146]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@kms_content_protection@legacy.html

  * igt@kms_content_protection@lic-type-1:
    - shard-dg2:          NOTRUN -> [SKIP][147] ([i915#9424])
   [147]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_content_protection@lic-type-1.html
    - shard-tglu:         NOTRUN -> [SKIP][148] ([i915#6944] / [i915#9424])
   [148]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@kms_content_protection@lic-type-1.html

  * igt@kms_content_protection@mei-interface:
    - shard-rkl:          NOTRUN -> [SKIP][149] ([i915#9424]) +2 other tests skip
   [149]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_content_protection@mei-interface.html

  * igt@kms_content_protection@srm:
    - shard-mtlp:         NOTRUN -> [SKIP][150] ([i915#6944])
   [150]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-6/igt@kms_content_protection@srm.html

  * igt@kms_cursor_crc@cursor-offscreen-32x10:
    - shard-mtlp:         NOTRUN -> [SKIP][151] ([i915#3555] / [i915#8814]) +5 other tests skip
   [151]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@kms_cursor_crc@cursor-offscreen-32x10.html

  * igt@kms_cursor_crc@cursor-offscreen-512x512:
    - shard-tglu:         NOTRUN -> [SKIP][152] ([i915#11453])
   [152]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-9/igt@kms_cursor_crc@cursor-offscreen-512x512.html

  * igt@kms_cursor_crc@cursor-onscreen-32x10:
    - shard-dg2:          NOTRUN -> [SKIP][153] ([i915#3555]) +1 other test skip
   [153]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_cursor_crc@cursor-onscreen-32x10.html

  * igt@kms_cursor_crc@cursor-onscreen-512x170:
    - shard-dg1:          NOTRUN -> [SKIP][154] ([i915#11453]) +2 other tests skip
   [154]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_cursor_crc@cursor-onscreen-512x170.html

  * igt@kms_cursor_crc@cursor-onscreen-512x512:
    - shard-mtlp:         NOTRUN -> [SKIP][155] ([i915#3359]) +1 other test skip
   [155]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@kms_cursor_crc@cursor-onscreen-512x512.html

  * igt@kms_cursor_crc@cursor-random-512x512:
    - shard-dg2:          NOTRUN -> [SKIP][156] ([i915#11453]) +1 other test skip
   [156]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_cursor_crc@cursor-random-512x512.html

  * igt@kms_cursor_crc@cursor-rapid-movement-32x10:
    - shard-rkl:          NOTRUN -> [SKIP][157] ([i915#3555]) +5 other tests skip
   [157]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_cursor_crc@cursor-rapid-movement-32x10.html
    - shard-tglu:         NOTRUN -> [SKIP][158] ([i915#3555]) +3 other tests skip
   [158]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-7/igt@kms_cursor_crc@cursor-rapid-movement-32x10.html

  * igt@kms_cursor_crc@cursor-rapid-movement-64x21:
    - shard-mtlp:         NOTRUN -> [SKIP][159] ([i915#8814]) +1 other test skip
   [159]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@kms_cursor_crc@cursor-rapid-movement-64x21.html

  * igt@kms_cursor_crc@cursor-sliding-512x512:
    - shard-rkl:          NOTRUN -> [SKIP][160] ([i915#11453]) +2 other tests skip
   [160]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-2/igt@kms_cursor_crc@cursor-sliding-512x512.html

  * igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions:
    - shard-mtlp:         NOTRUN -> [SKIP][161] +23 other tests skip
   [161]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions.html

  * igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions-varying-size:
    - shard-mtlp:         NOTRUN -> [SKIP][162] ([i915#9809]) +3 other tests skip
   [162]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions-varying-size.html

  * igt@kms_cursor_legacy@modeset-atomic-cursor-hotspot:
    - shard-dg1:          NOTRUN -> [SKIP][163] ([i915#9067])
   [163]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_cursor_legacy@modeset-atomic-cursor-hotspot.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions:
    - shard-tglu:         NOTRUN -> [SKIP][164] ([i915#4103])
   [164]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions.html
    - shard-dg2:          NOTRUN -> [SKIP][165] ([i915#4103] / [i915#4213])
   [165]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions.html
    - shard-rkl:          NOTRUN -> [SKIP][166] ([i915#4103])
   [166]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size:
    - shard-dg1:          NOTRUN -> [SKIP][167] ([i915#4103] / [i915#4213])
   [167]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions-varying-size.html

  * igt@kms_dirtyfb@psr-dirtyfb-ioctl:
    - shard-rkl:          NOTRUN -> [SKIP][168] ([i915#9723])
   [168]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@kms_dirtyfb@psr-dirtyfb-ioctl.html
    - shard-dg1:          NOTRUN -> [SKIP][169] ([i915#9723])
   [169]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_dirtyfb@psr-dirtyfb-ioctl.html

  * igt@kms_draw_crc@draw-method-mmap-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][170] ([i915#8812])
   [170]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_draw_crc@draw-method-mmap-gtt.html

  * igt@kms_dsc@dsc-basic:
    - shard-dg2:          NOTRUN -> [SKIP][171] ([i915#3555] / [i915#3840])
   [171]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_dsc@dsc-basic.html

  * igt@kms_dsc@dsc-fractional-bpp-with-bpc:
    - shard-rkl:          NOTRUN -> [SKIP][172] ([i915#3840])
   [172]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_dsc@dsc-fractional-bpp-with-bpc.html
    - shard-tglu:         NOTRUN -> [SKIP][173] ([i915#3840])
   [173]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-6/igt@kms_dsc@dsc-fractional-bpp-with-bpc.html

  * igt@kms_dsc@dsc-with-bpc:
    - shard-dg1:          NOTRUN -> [SKIP][174] ([i915#3555] / [i915#3840])
   [174]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_dsc@dsc-with-bpc.html

  * igt@kms_dsc@dsc-with-output-formats-with-bpc:
    - shard-dg2:          NOTRUN -> [SKIP][175] ([i915#3840] / [i915#9053])
   [175]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@kms_dsc@dsc-with-output-formats-with-bpc.html

  * igt@kms_fbcon_fbt@psr:
    - shard-dg2:          NOTRUN -> [SKIP][176] ([i915#3469]) +1 other test skip
   [176]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_fbcon_fbt@psr.html

  * igt@kms_feature_discovery@chamelium:
    - shard-dg2:          NOTRUN -> [SKIP][177] ([i915#4854])
   [177]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_feature_discovery@chamelium.html

  * igt@kms_feature_discovery@display-2x:
    - shard-dg2:          NOTRUN -> [SKIP][178] ([i915#1839])
   [178]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_feature_discovery@display-2x.html

  * igt@kms_feature_discovery@psr2:
    - shard-rkl:          NOTRUN -> [SKIP][179] ([i915#658])
   [179]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_feature_discovery@psr2.html

  * igt@kms_fence_pin_leak:
    - shard-dg1:          NOTRUN -> [SKIP][180] ([i915#4881])
   [180]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_fence_pin_leak.html

  * igt@kms_flip@2x-flip-vs-blocking-wf-vblank@ab-vga1-hdmi-a1:
    - shard-snb:          [PASS][181] -> [FAIL][182] ([i915#2122]) +1 other test fail
   [181]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb5/igt@kms_flip@2x-flip-vs-blocking-wf-vblank@ab-vga1-hdmi-a1.html
   [182]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb7/igt@kms_flip@2x-flip-vs-blocking-wf-vblank@ab-vga1-hdmi-a1.html

  * igt@kms_flip@2x-flip-vs-dpms:
    - shard-rkl:          NOTRUN -> [SKIP][183] +27 other tests skip
   [183]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@kms_flip@2x-flip-vs-dpms.html

  * igt@kms_flip@2x-flip-vs-fences-interruptible:
    - shard-tglu:         NOTRUN -> [SKIP][184] ([i915#3637]) +1 other test skip
   [184]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@kms_flip@2x-flip-vs-fences-interruptible.html
    - shard-dg2:          NOTRUN -> [SKIP][185] ([i915#8381])
   [185]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@kms_flip@2x-flip-vs-fences-interruptible.html

  * igt@kms_flip@2x-flip-vs-suspend:
    - shard-mtlp:         NOTRUN -> [SKIP][186] ([i915#3637]) +4 other tests skip
   [186]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_flip@2x-flip-vs-suspend.html

  * igt@kms_flip@2x-modeset-vs-vblank-race:
    - shard-dg2:          NOTRUN -> [SKIP][187] +23 other tests skip
   [187]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_flip@2x-modeset-vs-vblank-race.html

  * igt@kms_flip@2x-wf_vblank-ts-check-interruptible:
    - shard-dg1:          NOTRUN -> [SKIP][188] ([i915#9934]) +8 other tests skip
   [188]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_flip@2x-wf_vblank-ts-check-interruptible.html

  * igt@kms_flip@flip-vs-fences:
    - shard-mtlp:         NOTRUN -> [SKIP][189] ([i915#8381])
   [189]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_flip@flip-vs-fences.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-upscaling@pipe-a-valid-mode:
    - shard-rkl:          NOTRUN -> [SKIP][190] ([i915#2672]) +5 other tests skip
   [190]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling@pipe-a-valid-mode:
    - shard-dg1:          NOTRUN -> [SKIP][191] ([i915#2587] / [i915#2672]) +4 other tests skip
   [191]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-32bpp-yftileccs-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-upscaling@pipe-a-default-mode:
    - shard-mtlp:         NOTRUN -> [SKIP][192] ([i915#2672]) +3 other tests skip
   [192]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytileccs-upscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling@pipe-a-valid-mode:
    - shard-dg2:          NOTRUN -> [SKIP][193] ([i915#2672]) +3 other tests skip
   [193]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-valid-mode:
    - shard-tglu:         NOTRUN -> [SKIP][194] ([i915#2587] / [i915#2672])
   [194]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-9/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_scaled_crc@flip-64bpp-linear-to-32bpp-linear-downscaling@pipe-a-default-mode:
    - shard-mtlp:         NOTRUN -> [SKIP][195] ([i915#3555] / [i915#8810])
   [195]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_flip_scaled_crc@flip-64bpp-linear-to-32bpp-linear-downscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling@pipe-a-default-mode:
    - shard-mtlp:         NOTRUN -> [SKIP][196] ([i915#2672] / [i915#3555]) +1 other test skip
   [196]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-16bpp-ytile-downscaling@pipe-a-default-mode.html

  * igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-mmap-gtt:
    - shard-mtlp:         NOTRUN -> [SKIP][197] ([i915#8708]) +7 other tests skip
   [197]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-6/igt@kms_frontbuffer_tracking@fbc-1p-offscren-pri-indfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-render:
    - shard-dg1:          NOTRUN -> [SKIP][198] +36 other tests skip
   [198]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-gtt:
    - shard-dg1:          NOTRUN -> [SKIP][199] ([i915#8708]) +16 other tests skip
   [199]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-18/igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-tiling-y:
    - shard-mtlp:         NOTRUN -> [SKIP][200] ([i915#10055]) +1 other test skip
   [200]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@kms_frontbuffer_tracking@fbc-tiling-y.html
    - shard-dg2:          NOTRUN -> [SKIP][201] ([i915#10055])
   [201]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_frontbuffer_tracking@fbc-tiling-y.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-mmap-cpu:
    - shard-dg2:          NOTRUN -> [SKIP][202] ([i915#3458]) +12 other tests skip
   [202]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-mmap-cpu.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-draw-mmap-gtt:
    - shard-rkl:          NOTRUN -> [SKIP][203] ([i915#1825]) +38 other tests skip
   [203]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-cur-indfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-shrfb-draw-render:
    - shard-dg2:          NOTRUN -> [SKIP][204] ([i915#5354]) +35 other tests skip
   [204]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-pri-shrfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-draw-blt:
    - shard-snb:          NOTRUN -> [SKIP][205] +44 other tests skip
   [205]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb6/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-fullscreen:
    - shard-tglu:         NOTRUN -> [SKIP][206] +34 other tests skip
   [206]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-7/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-fullscreen.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-shrfb-fliptrack-mmap-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][207] ([i915#8708]) +22 other tests skip
   [207]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_frontbuffer_tracking@fbcpsr-2p-shrfb-fliptrack-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-blt:
    - shard-dg1:          NOTRUN -> [SKIP][208] ([i915#3458]) +20 other tests skip
   [208]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_frontbuffer_tracking@fbcpsr-rgb101010-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-tiling-4:
    - shard-rkl:          NOTRUN -> [SKIP][209] ([i915#5439])
   [209]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_frontbuffer_tracking@fbcpsr-tiling-4.html
    - shard-dg1:          NOTRUN -> [SKIP][210] ([i915#5439])
   [210]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_frontbuffer_tracking@fbcpsr-tiling-4.html

  * igt@kms_frontbuffer_tracking@pipe-fbc-rte:
    - shard-dg2:          NOTRUN -> [SKIP][211] ([i915#9766])
   [211]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_frontbuffer_tracking@pipe-fbc-rte.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-indfb-plflip-blt:
    - shard-rkl:          NOTRUN -> [SKIP][212] ([i915#3023]) +23 other tests skip
   [212]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@kms_frontbuffer_tracking@psr-1p-primscrn-indfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-pgflip-blt:
    - shard-mtlp:         NOTRUN -> [SKIP][213] ([i915#1825]) +29 other tests skip
   [213]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_frontbuffer_tracking@psr-2p-primscrn-indfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-rgb565-draw-mmap-cpu:
    - shard-dg2:          NOTRUN -> [SKIP][214] ([i915#10433] / [i915#3458]) +2 other tests skip
   [214]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_frontbuffer_tracking@psr-rgb565-draw-mmap-cpu.html

  * igt@kms_hdmi_inject@inject-audio:
    - shard-dg1:          NOTRUN -> [SKIP][215] ([i915#433])
   [215]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_hdmi_inject@inject-audio.html

  * igt@kms_hdr@static-toggle:
    - shard-dg1:          NOTRUN -> [SKIP][216] ([i915#3555] / [i915#8228])
   [216]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_hdr@static-toggle.html

  * igt@kms_hdr@static-toggle-suspend:
    - shard-dg2:          NOTRUN -> [SKIP][217] ([i915#3555] / [i915#8228]) +1 other test skip
   [217]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_hdr@static-toggle-suspend.html

  * igt@kms_multipipe_modeset@basic-max-pipe-crc-check:
    - shard-mtlp:         NOTRUN -> [SKIP][218] ([i915#4816])
   [218]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html

  * igt@kms_panel_fitting@atomic-fastset:
    - shard-dg2:          NOTRUN -> [SKIP][219] ([i915#6301]) +1 other test skip
   [219]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_panel_fitting@atomic-fastset.html

  * igt@kms_panel_fitting@legacy:
    - shard-tglu:         NOTRUN -> [SKIP][220] ([i915#6301])
   [220]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_panel_fitting@legacy.html
    - shard-rkl:          NOTRUN -> [SKIP][221] ([i915#6301])
   [221]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_panel_fitting@legacy.html

  * igt@kms_plane_multiple@tiling-yf:
    - shard-mtlp:         NOTRUN -> [SKIP][222] ([i915#3555] / [i915#8806])
   [222]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_plane_multiple@tiling-yf.html

  * igt@kms_plane_scaling@intel-max-src-size:
    - shard-dg2:          NOTRUN -> [SKIP][223] ([i915#6953] / [i915#9423])
   [223]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_plane_scaling@intel-max-src-size.html

  * igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-3:
    - shard-dg1:          NOTRUN -> [FAIL][224] ([i915#8292])
   [224]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-3.html

  * igt@kms_plane_scaling@plane-downscale-factor-0-25-with-rotation@pipe-d-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][225] ([i915#5176]) +3 other tests skip
   [225]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@kms_plane_scaling@plane-downscale-factor-0-25-with-rotation@pipe-d-edp-1.html

  * igt@kms_plane_scaling@plane-scaler-unity-scaling-with-rotation@pipe-d-hdmi-a-4:
    - shard-dg1:          NOTRUN -> [SKIP][226] ([i915#9423]) +7 other tests skip
   [226]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_plane_scaling@plane-scaler-unity-scaling-with-rotation@pipe-d-hdmi-a-4.html

  * igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][227] ([i915#9423]) +7 other tests skip
   [227]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation@pipe-b-hdmi-a-2.html

  * igt@kms_plane_scaling@plane-upscale-factor-0-25-with-rotation@pipe-d-hdmi-a-1:
    - shard-tglu:         NOTRUN -> [SKIP][228] ([i915#9423]) +3 other tests skip
   [228]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-6/igt@kms_plane_scaling@plane-upscale-factor-0-25-with-rotation@pipe-d-hdmi-a-1.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-a-hdmi-a-3:
    - shard-dg2:          NOTRUN -> [SKIP][229] ([i915#5235] / [i915#9423]) +2 other tests skip
   [229]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-a-hdmi-a-3.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-b-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][230] ([i915#5235]) +9 other tests skip
   [230]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-4/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-b-edp-1.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][231] ([i915#5235]) +1 other test skip
   [231]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-b-hdmi-a-2.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25@pipe-c-hdmi-a-1:
    - shard-tglu:         NOTRUN -> [SKIP][232] ([i915#9728]) +3 other tests skip
   [232]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_plane_scaling@planes-downscale-factor-0-25@pipe-c-hdmi-a-1.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25@pipe-d-hdmi-a-2:
    - shard-dg2:          NOTRUN -> [SKIP][233] ([i915#9423]) +20 other tests skip
   [233]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-3/igt@kms_plane_scaling@planes-downscale-factor-0-25@pipe-d-hdmi-a-2.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-75@pipe-d-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][234] ([i915#3555] / [i915#5235]) +1 other test skip
   [234]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-6/igt@kms_plane_scaling@planes-downscale-factor-0-75@pipe-d-edp-1.html

  * igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-25@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][235] ([i915#9728]) +5 other tests skip
   [235]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-25@pipe-b-hdmi-a-2.html

  * igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-25@pipe-a-hdmi-a-1:
    - shard-glk:          NOTRUN -> [SKIP][236] +190 other tests skip
   [236]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk5/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-25@pipe-a-hdmi-a-1.html

  * igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-25@pipe-d-hdmi-a-4:
    - shard-dg1:          NOTRUN -> [SKIP][237] ([i915#9728]) +11 other tests skip
   [237]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_plane_scaling@planes-upscale-factor-0-25-downscale-factor-0-25@pipe-d-hdmi-a-4.html

  * igt@kms_pm_backlight@basic-brightness:
    - shard-rkl:          NOTRUN -> [SKIP][238] ([i915#5354]) +1 other test skip
   [238]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_pm_backlight@basic-brightness.html
    - shard-dg1:          NOTRUN -> [SKIP][239] ([i915#5354])
   [239]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-14/igt@kms_pm_backlight@basic-brightness.html

  * igt@kms_pm_dc@dc5-psr:
    - shard-rkl:          NOTRUN -> [SKIP][240] ([i915#9685])
   [240]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_pm_dc@dc5-psr.html
    - shard-dg1:          NOTRUN -> [SKIP][241] ([i915#9685])
   [241]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_pm_dc@dc5-psr.html

  * igt@kms_pm_dc@dc6-dpms:
    - shard-dg2:          NOTRUN -> [SKIP][242] ([i915#5978])
   [242]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_pm_dc@dc6-dpms.html

  * igt@kms_pm_dc@dc9-dpms:
    - shard-tglu:         [PASS][243] -> [SKIP][244] ([i915#4281])
   [243]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-tglu-6/igt@kms_pm_dc@dc9-dpms.html
   [244]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-7/igt@kms_pm_dc@dc9-dpms.html

  * igt@kms_pm_rpm@dpms-lpsp:
    - shard-dg1:          NOTRUN -> [SKIP][245] ([i915#9519]) +1 other test skip
   [245]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_pm_rpm@dpms-lpsp.html

  * igt@kms_pm_rpm@dpms-mode-unset-non-lpsp:
    - shard-tglu:         NOTRUN -> [SKIP][246] ([i915#9519])
   [246]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_pm_rpm@dpms-mode-unset-non-lpsp.html

  * igt@kms_pm_rpm@dpms-non-lpsp:
    - shard-dg2:          NOTRUN -> [SKIP][247] ([i915#9519])
   [247]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_pm_rpm@dpms-non-lpsp.html

  * igt@kms_pm_rpm@modeset-non-lpsp-stress-no-wait:
    - shard-rkl:          [PASS][248] -> [SKIP][249] ([i915#9519]) +2 other tests skip
   [248]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-5/igt@kms_pm_rpm@modeset-non-lpsp-stress-no-wait.html
   [249]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-2/igt@kms_pm_rpm@modeset-non-lpsp-stress-no-wait.html

  * igt@kms_prime@basic-crc-vgem:
    - shard-dg2:          NOTRUN -> [SKIP][250] ([i915#6524] / [i915#6805]) +1 other test skip
   [250]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@kms_prime@basic-crc-vgem.html

  * igt@kms_prime@basic-modeset-hybrid:
    - shard-mtlp:         NOTRUN -> [SKIP][251] ([i915#6524]) +1 other test skip
   [251]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-4/igt@kms_prime@basic-modeset-hybrid.html

  * igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-sf:
    - shard-dg2:          NOTRUN -> [SKIP][252] ([i915#11520]) +5 other tests skip
   [252]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-6/igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-sf.html
    - shard-rkl:          NOTRUN -> [SKIP][253] ([i915#11520]) +6 other tests skip
   [253]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-sf.html

  * igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-sf@psr2-pipe-a-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][254] ([i915#9808]) +1 other test skip
   [254]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@kms_psr2_sf@fbc-cursor-plane-move-continuous-exceed-sf@psr2-pipe-a-edp-1.html

  * igt@kms_psr2_sf@fbc-overlay-plane-update-sf-dmg-area:
    - shard-dg1:          NOTRUN -> [SKIP][255] ([i915#11520]) +4 other tests skip
   [255]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_psr2_sf@fbc-overlay-plane-update-sf-dmg-area.html

  * igt@kms_psr2_sf@fbc-plane-move-sf-dmg-area:
    - shard-tglu:         NOTRUN -> [SKIP][256] ([i915#11520]) +1 other test skip
   [256]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_psr2_sf@fbc-plane-move-sf-dmg-area.html

  * igt@kms_psr2_su@page_flip-xrgb8888:
    - shard-rkl:          NOTRUN -> [SKIP][257] ([i915#9683])
   [257]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_psr2_su@page_flip-xrgb8888.html
    - shard-dg1:          NOTRUN -> [SKIP][258] ([i915#9683]) +1 other test skip
   [258]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@kms_psr2_su@page_flip-xrgb8888.html

  * igt@kms_psr@fbc-pr-primary-mmap-cpu:
    - shard-mtlp:         NOTRUN -> [SKIP][259] ([i915#9688]) +10 other tests skip
   [259]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_psr@fbc-pr-primary-mmap-cpu.html

  * igt@kms_psr@fbc-pr-primary-mmap-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][260] ([i915#1072] / [i915#9732]) +20 other tests skip
   [260]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-2/igt@kms_psr@fbc-pr-primary-mmap-gtt.html

  * igt@kms_psr@psr-cursor-mmap-gtt:
    - shard-tglu:         NOTRUN -> [SKIP][261] ([i915#9732]) +8 other tests skip
   [261]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_psr@psr-cursor-mmap-gtt.html

  * igt@kms_psr@psr-primary-mmap-cpu:
    - shard-dg2:          NOTRUN -> [SKIP][262] ([i915#1072] / [i915#9673] / [i915#9732]) +2 other tests skip
   [262]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_psr@psr-primary-mmap-cpu.html

  * igt@kms_psr@psr-sprite-mmap-cpu:
    - shard-dg1:          NOTRUN -> [SKIP][263] ([i915#1072] / [i915#9732]) +19 other tests skip
   [263]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_psr@psr-sprite-mmap-cpu.html

  * igt@kms_psr@psr2-sprite-mmap-cpu:
    - shard-rkl:          NOTRUN -> [SKIP][264] ([i915#1072] / [i915#9732]) +21 other tests skip
   [264]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@kms_psr@psr2-sprite-mmap-cpu.html

  * igt@kms_psr_stress_test@flip-primary-invalidate-overlay:
    - shard-dg2:          NOTRUN -> [SKIP][265] ([i915#9685])
   [265]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_psr_stress_test@flip-primary-invalidate-overlay.html

  * igt@kms_rotation_crc@bad-tiling:
    - shard-mtlp:         NOTRUN -> [SKIP][266] ([i915#4235]) +1 other test skip
   [266]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@kms_rotation_crc@bad-tiling.html

  * igt@kms_rotation_crc@primary-rotation-270:
    - shard-dg2:          NOTRUN -> [SKIP][267] ([i915#11131] / [i915#4235])
   [267]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_rotation_crc@primary-rotation-270.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-180:
    - shard-mtlp:         NOTRUN -> [SKIP][268] ([i915#5289])
   [268]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-2/igt@kms_rotation_crc@primary-y-tiled-reflect-x-180.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-90:
    - shard-dg2:          NOTRUN -> [SKIP][269] ([i915#11131] / [i915#5190])
   [269]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_rotation_crc@primary-y-tiled-reflect-x-90.html

  * igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270:
    - shard-rkl:          NOTRUN -> [SKIP][270] ([i915#5289])
   [270]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-1/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270.html
    - shard-tglu:         NOTRUN -> [SKIP][271] ([i915#5289])
   [271]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270.html

  * igt@kms_scaling_modes@scaling-mode-center:
    - shard-dg1:          NOTRUN -> [SKIP][272] ([i915#3555]) +2 other tests skip
   [272]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-18/igt@kms_scaling_modes@scaling-mode-center.html

  * igt@kms_setmode@basic-clone-single-crtc:
    - shard-mtlp:         NOTRUN -> [SKIP][273] ([i915#3555] / [i915#8809])
   [273]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-3/igt@kms_setmode@basic-clone-single-crtc.html

  * igt@kms_sysfs_edid_timing:
    - shard-dg2:          [PASS][274] -> [FAIL][275] ([IGT#2])
   [274]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-11/igt@kms_sysfs_edid_timing.html
   [275]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_sysfs_edid_timing.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-rkl:          NOTRUN -> [SKIP][276] ([i915#8623])
   [276]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html
    - shard-dg1:          NOTRUN -> [SKIP][277] ([i915#8623])
   [277]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@kms_universal_plane@cursor-fb-leak@pipe-c-hdmi-a-1:
    - shard-tglu:         [PASS][278] -> [FAIL][279] ([i915#9196]) +1 other test fail
   [278]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-tglu-6/igt@kms_universal_plane@cursor-fb-leak@pipe-c-hdmi-a-1.html
   [279]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_universal_plane@cursor-fb-leak@pipe-c-hdmi-a-1.html

  * igt@kms_vrr@flip-basic:
    - shard-mtlp:         NOTRUN -> [SKIP][280] ([i915#3555] / [i915#8808])
   [280]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@kms_vrr@flip-basic.html

  * igt@kms_vrr@seamless-rr-switch-virtual:
    - shard-dg1:          NOTRUN -> [SKIP][281] ([i915#9906])
   [281]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@kms_vrr@seamless-rr-switch-virtual.html

  * igt@kms_vrr@seamless-rr-switch-vrr:
    - shard-mtlp:         NOTRUN -> [SKIP][282] ([i915#8808] / [i915#9906])
   [282]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-7/igt@kms_vrr@seamless-rr-switch-vrr.html

  * igt@kms_writeback@writeback-check-output:
    - shard-dg1:          NOTRUN -> [SKIP][283] ([i915#2437])
   [283]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@kms_writeback@writeback-check-output.html

  * igt@kms_writeback@writeback-fb-id-xrgb2101010:
    - shard-rkl:          NOTRUN -> [SKIP][284] ([i915#2437] / [i915#9412])
   [284]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@kms_writeback@writeback-fb-id-xrgb2101010.html
    - shard-tglu:         NOTRUN -> [SKIP][285] ([i915#2437] / [i915#9412])
   [285]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_writeback@writeback-fb-id-xrgb2101010.html
    - shard-glk:          NOTRUN -> [SKIP][286] ([i915#2437])
   [286]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk9/igt@kms_writeback@writeback-fb-id-xrgb2101010.html

  * igt@kms_writeback@writeback-invalid-parameters:
    - shard-mtlp:         NOTRUN -> [SKIP][287] ([i915#2437]) +1 other test skip
   [287]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@kms_writeback@writeback-invalid-parameters.html

  * igt@perf@global-sseu-config:
    - shard-mtlp:         NOTRUN -> [SKIP][288] ([i915#7387])
   [288]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-8/igt@perf@global-sseu-config.html

  * igt@perf@mi-rpc:
    - shard-dg1:          NOTRUN -> [SKIP][289] ([i915#2434])
   [289]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@perf@mi-rpc.html

  * igt@perf@non-zero-reason@0-rcs0:
    - shard-dg2:          NOTRUN -> [FAIL][290] ([i915#9100])
   [290]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@perf@non-zero-reason@0-rcs0.html

  * igt@perf_pmu@busy-double-start@vecs1:
    - shard-dg2:          NOTRUN -> [FAIL][291] ([i915#4349]) +3 other tests fail
   [291]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@perf_pmu@busy-double-start@vecs1.html

  * igt@perf_pmu@frequency@gt0:
    - shard-dg2:          NOTRUN -> [FAIL][292] ([i915#6806])
   [292]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@perf_pmu@frequency@gt0.html

  * igt@perf_pmu@rc6-all-gts:
    - shard-dg1:          NOTRUN -> [SKIP][293] ([i915#8516]) +1 other test skip
   [293]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-16/igt@perf_pmu@rc6-all-gts.html
    - shard-rkl:          NOTRUN -> [SKIP][294] ([i915#8516])
   [294]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@perf_pmu@rc6-all-gts.html

  * igt@prime_vgem@basic-fence-flip:
    - shard-dg2:          NOTRUN -> [SKIP][295] ([i915#3708])
   [295]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@prime_vgem@basic-fence-flip.html

  * igt@prime_vgem@basic-fence-mmap:
    - shard-dg2:          NOTRUN -> [SKIP][296] ([i915#3708] / [i915#4077])
   [296]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@prime_vgem@basic-fence-mmap.html

  * igt@prime_vgem@basic-fence-read:
    - shard-rkl:          NOTRUN -> [SKIP][297] ([i915#3291] / [i915#3708])
   [297]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@prime_vgem@basic-fence-read.html

  * igt@prime_vgem@basic-write:
    - shard-mtlp:         NOTRUN -> [SKIP][298] ([i915#10216] / [i915#3708])
   [298]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-1/igt@prime_vgem@basic-write.html

  * igt@prime_vgem@fence-flip-hang:
    - shard-dg1:          NOTRUN -> [SKIP][299] ([i915#3708]) +1 other test skip
   [299]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-17/igt@prime_vgem@fence-flip-hang.html

  * igt@sriov_basic@bind-unbind-vf:
    - shard-dg1:          NOTRUN -> [SKIP][300] ([i915#9917]) +1 other test skip
   [300]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@sriov_basic@bind-unbind-vf.html

  * igt@sriov_basic@enable-vfs-autoprobe-on:
    - shard-rkl:          NOTRUN -> [SKIP][301] ([i915#9917])
   [301]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-5/igt@sriov_basic@enable-vfs-autoprobe-on.html

  * igt@syncobj_wait@invalid-wait-zero-handles:
    - shard-rkl:          NOTRUN -> [FAIL][302] ([i915#9781])
   [302]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@syncobj_wait@invalid-wait-zero-handles.html
    - shard-dg1:          NOTRUN -> [FAIL][303] ([i915#9781])
   [303]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-13/igt@syncobj_wait@invalid-wait-zero-handles.html
    - shard-glk:          NOTRUN -> [FAIL][304] ([i915#9781])
   [304]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-glk8/igt@syncobj_wait@invalid-wait-zero-handles.html

  
#### Possible fixes ####

  * igt@gem_exec_fair@basic-none@bcs0:
    - shard-rkl:          [FAIL][305] ([i915#2842]) -> [PASS][306]
   [305]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-5/igt@gem_exec_fair@basic-none@bcs0.html
   [306]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-4/igt@gem_exec_fair@basic-none@bcs0.html

  * igt@gem_exec_fair@basic-pace-share@rcs0:
    - shard-tglu:         [FAIL][307] ([i915#2842]) -> [PASS][308]
   [307]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-tglu-10/igt@gem_exec_fair@basic-pace-share@rcs0.html
   [308]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-8/igt@gem_exec_fair@basic-pace-share@rcs0.html

  * igt@i915_module_load@reload-with-fault-injection:
    - shard-snb:          [ABORT][309] ([i915#9820]) -> [PASS][310]
   [309]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb6/igt@i915_module_load@reload-with-fault-injection.html
   [310]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb7/igt@i915_module_load@reload-with-fault-injection.html
    - shard-mtlp:         [ABORT][311] ([i915#10131] / [i915#10887] / [i915#9820]) -> [PASS][312]
   [311]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-mtlp-6/igt@i915_module_load@reload-with-fault-injection.html
   [312]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-7/igt@i915_module_load@reload-with-fault-injection.html
    - shard-dg2:          [ABORT][313] ([i915#9820]) -> [PASS][314]
   [313]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-3/igt@i915_module_load@reload-with-fault-injection.html
   [314]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@i915_module_load@reload-with-fault-injection.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing@pipe-a-hdmi-a-1:
    - shard-snb:          [FAIL][315] ([i915#5956]) -> [PASS][316]
   [315]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb4/igt@kms_atomic_transition@plane-all-modeset-transition-fencing@pipe-a-hdmi-a-1.html
   [316]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb5/igt@kms_atomic_transition@plane-all-modeset-transition-fencing@pipe-a-hdmi-a-1.html

  * igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-4:
    - shard-dg1:          [FAIL][317] ([i915#5956]) -> [PASS][318]
   [317]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg1-14/igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-4.html
   [318]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-15/igt@kms_atomic_transition@plane-all-modeset-transition@pipe-a-hdmi-a-4.html

  * igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-1:
    - shard-dg2:          [FAIL][319] ([i915#5956]) -> [PASS][320]
   [319]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-2/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-1.html
   [320]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-1.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render:
    - shard-snb:          [SKIP][321] -> [PASS][322] +3 other tests pass
   [321]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb4/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render.html
   [322]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb7/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-rgb565-draw-pwrite:
    - shard-dg2:          [FAIL][323] ([i915#6880]) -> [PASS][324]
   [323]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-10/igt@kms_frontbuffer_tracking@fbc-rgb565-draw-pwrite.html
   [324]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_frontbuffer_tracking@fbc-rgb565-draw-pwrite.html

  * igt@kms_plane@pixel-format@pipe-b-plane-3:
    - shard-mtlp:         [ABORT][325] ([i915#10354]) -> [PASS][326]
   [325]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-mtlp-4/igt@kms_plane@pixel-format@pipe-b-plane-3.html
   [326]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-8/igt@kms_plane@pixel-format@pipe-b-plane-3.html

  * igt@kms_pm_rpm@modeset-lpsp-stress-no-wait:
    - shard-dg2:          [SKIP][327] ([i915#9519]) -> [PASS][328]
   [327]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-5/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html
   [328]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-10/igt@kms_pm_rpm@modeset-lpsp-stress-no-wait.html

  * igt@kms_rotation_crc@primary-4-tiled-reflect-x-180:
    - shard-dg2:          [INCOMPLETE][329] -> [PASS][330]
   [329]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-10/igt@kms_rotation_crc@primary-4-tiled-reflect-x-180.html
   [330]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_rotation_crc@primary-4-tiled-reflect-x-180.html

  * igt@kms_universal_plane@cursor-fb-leak@pipe-a-hdmi-a-1:
    - shard-tglu:         [FAIL][331] ([i915#9196]) -> [PASS][332]
   [331]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-tglu-6/igt@kms_universal_plane@cursor-fb-leak@pipe-a-hdmi-a-1.html
   [332]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-tglu-5/igt@kms_universal_plane@cursor-fb-leak@pipe-a-hdmi-a-1.html

  * igt@perf_pmu@busy-double-start@vcs0:
    - shard-dg1:          [FAIL][333] ([i915#4349]) -> [PASS][334] +1 other test pass
   [333]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg1-17/igt@perf_pmu@busy-double-start@vcs0.html
   [334]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg1-18/igt@perf_pmu@busy-double-start@vcs0.html

  * igt@perf_pmu@busy-double-start@vecs0:
    - shard-mtlp:         [FAIL][335] ([i915#4349]) -> [PASS][336] +1 other test pass
   [335]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-mtlp-1/igt@perf_pmu@busy-double-start@vecs0.html
   [336]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-mtlp-5/igt@perf_pmu@busy-double-start@vecs0.html

  
#### Warnings ####

  * igt@gem_lmem_swapping@smem-oom@lmem0:
    - shard-dg2:          [DMESG-WARN][337] ([i915#4936] / [i915#5493]) -> [TIMEOUT][338] ([i915#5493])
   [337]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-8/igt@gem_lmem_swapping@smem-oom@lmem0.html
   [338]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@gem_lmem_swapping@smem-oom@lmem0.html

  * igt@kms_content_protection@srm:
    - shard-snb:          [SKIP][339] -> [INCOMPLETE][340] ([i915#8816])
   [339]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-snb6/igt@kms_content_protection@srm.html
   [340]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-snb2/igt@kms_content_protection@srm.html

  * igt@kms_cursor_crc@cursor-offscreen-512x512:
    - shard-dg2:          [SKIP][341] ([i915#11453] / [i915#3359]) -> [SKIP][342] ([i915#11453])
   [341]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-11/igt@kms_cursor_crc@cursor-offscreen-512x512.html
   [342]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-5/igt@kms_cursor_crc@cursor-offscreen-512x512.html

  * igt@kms_cursor_crc@cursor-onscreen-512x170:
    - shard-dg2:          [SKIP][343] ([i915#11453]) -> [SKIP][344] ([i915#11453] / [i915#3359]) +1 other test skip
   [343]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-4/igt@kms_cursor_crc@cursor-onscreen-512x170.html
   [344]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_cursor_crc@cursor-onscreen-512x170.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-indfb-draw-blt:
    - shard-dg2:          [SKIP][345] ([i915#10433] / [i915#3458]) -> [SKIP][346] ([i915#3458])
   [345]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-4/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-indfb-draw-blt.html
   [346]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-3/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-indfb-draw-mmap-cpu:
    - shard-dg2:          [SKIP][347] ([i915#3458]) -> [SKIP][348] ([i915#10433] / [i915#3458])
   [347]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-8/igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-indfb-draw-mmap-cpu.html
   [348]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-4/igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-indfb-draw-mmap-cpu.html

  * igt@kms_multipipe_modeset@basic-max-pipe-crc-check:
    - shard-rkl:          [SKIP][349] ([i915#4070] / [i915#4816]) -> [SKIP][350] ([i915#4816])
   [349]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-5/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html
   [350]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-3/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html

  * igt@kms_pm_dc@dc9-dpms:
    - shard-rkl:          [SKIP][351] ([i915#4281]) -> [SKIP][352] ([i915#3361])
   [351]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-rkl-5/igt@kms_pm_dc@dc9-dpms.html
   [352]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-rkl-6/igt@kms_pm_dc@dc9-dpms.html

  * igt@kms_psr@fbc-psr-cursor-plane-move:
    - shard-dg2:          [SKIP][353] ([i915#1072] / [i915#9673] / [i915#9732]) -> [SKIP][354] ([i915#1072] / [i915#9732]) +14 other tests skip
   [353]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-11/igt@kms_psr@fbc-psr-cursor-plane-move.html
   [354]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-7/igt@kms_psr@fbc-psr-cursor-plane-move.html

  * igt@kms_psr@fbc-psr-primary-mmap-gtt:
    - shard-dg2:          [SKIP][355] ([i915#1072] / [i915#9732]) -> [SKIP][356] ([i915#1072] / [i915#9673] / [i915#9732]) +17 other tests skip
   [355]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_7964/shard-dg2-10/igt@kms_psr@fbc-psr-primary-mmap-gtt.html
   [356]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_11551/shard-dg2-11/igt@kms_psr@fbc-psr-primary-mmap-gtt.html

  
  [IGT#2]: https://gitlab.freedesktop.org/drm/igt-gpu-tools/issues/2
  [i915#10055]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10055
  [i915#10131]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10131
  [i915#10216]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10216
  [i915#10307]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10307
  [i915#10354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10354
  [i915#10433]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10433
  [i915#10434]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10434
  [i915#10656]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10656
  [i915#1072]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1072
  [i915#10887]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10887
  [i915#11078]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11078
  [i915#11131]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11131
  [i915#11453]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11453
  [i915#11520]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11520
  [i915#11616]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11616
  [i915#11703]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11703
  [i915#11713]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11713
  [i915#11808]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11808
  [i915#11859]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11859
  [i915#11900]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11900
  [i915#1825]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1825
  [i915#1839]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1839
  [i915#2122]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2122
  [i915#2434]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2434
  [i915#2437]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2437
  [i915#2527]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2527
  [i915#2587]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2587
  [i915#2658]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2658
  [i915#2672]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2672
  [i915#280]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/280
  [i915#284]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/284
  [i915#2842]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2842
  [i915#2846]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2846
  [i915#2856]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2856
  [i915#3023]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3023
  [i915#3281]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3281
  [i915#3282]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3282
  [i915#3291]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3291
  [i915#3297]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3297
  [i915#3299]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3299
  [i915#3359]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3359
  [i915#3361]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3361
  [i915#3458]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3458
  [i915#3469]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3469
  [i915#3539]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3539
  [i915#3555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3555
  [i915#3591]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3591
  [i915#3637]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3637
  [i915#3638]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3638
  [i915#3708]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3708
  [i915#3742]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3742
  [i915#3840]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3840
  [i915#4036]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4036
  [i915#4070]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4070
  [i915#4077]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4077
  [i915#4079]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4079
  [i915#4083]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4083
  [i915#4087]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4087
  [i915#4103]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4103
  [i915#4212]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4212
  [i915#4213]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4213
  [i915#4235]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4235
  [i915#4270]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4270
  [i915#4281]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4281
  [i915#433]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/433
  [i915#4349]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4349
  [i915#4387]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4387
  [i915#4473]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4473
  [i915#4525]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4525
  [i915#4537]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4537
  [i915#4538]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4538
  [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
  [i915#4771]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4771
  [i915#4812]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4812
  [i915#4816]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4816
  [i915#4852]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4852
  [i915#4854]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4854
  [i915#4860]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4860
  [i915#4879]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4879
  [i915#4880]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4880
  [i915#4881]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4881
  [i915#4885]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4885
  [i915#4936]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4936
  [i915#5176]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5176
  [i915#5190]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5190
  [i915#5235]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5235
  [i915#5286]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5286
  [i915#5289]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5289
  [i915#5354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5354
  [i915#5439]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5439
  [i915#5493]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5493
  [i915#5784]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5784
  [i915#5956]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5956
  [i915#5978]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5978
  [i915#6095]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6095
  [i915#6228]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6228
  [i915#6301]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6301
  [i915#6524]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6524
  [i915#658]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/658
  [i915#6805]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6805
  [i915#6806]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6806
  [i915#6880]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6880
  [i915#6944]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6944
  [i915#6953]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6953
  [i915#7116]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7116
  [i915#7118]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7118
  [i915#7213]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7213
  [i915#7387]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7387
  [i915#7697]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7697
  [i915#7707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7707
  [i915#7742]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7742
  [i915#7828]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7828
  [i915#7975]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7975
  [i915#8213]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8213
  [i915#8228]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8228
  [i915#8292]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8292
  [i915#8381]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8381
  [i915#8414]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8414
  [i915#8428]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8428
  [i915#8516]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8516
  [i915#8555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8555
  [i915#8623]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8623
  [i915#8708]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8708
  [i915#8709]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8709
  [i915#8806]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8806
  [i915#8808]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8808
  [i915#8809]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8809
  [i915#8810]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8810
  [i915#8812]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8812
  [i915#8814]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8814
  [i915#8816]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8816
  [i915#8898]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8898
  [i915#9010]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9010
  [i915#9053]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9053
  [i915#9067]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9067
  [i915#9100]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9100
  [i915#9196]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9196
  [i915#9318]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9318
  [i915#9412]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9412
  [i915#9423]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9423
  [i915#9424]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9424
  [i915#9519]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9519
  [i915#9531]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9531
  [i915#9673]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9673
  [i915#9683]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9683
  [i915#9685]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9685
  [i915#9688]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9688
  [i915#9723]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9723
  [i915#9728]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9728
  [i915#9732]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9732
  [i915#9766]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9766
  [i915#9781]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9781
  [i915#9808]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9808
  [i915#9809]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9809
  [i915#9820]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9820
  [i915#9906]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9906
  [i915#9917]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9917
  [i915#9934]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9934


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

  * CI: CI-20190529 -> None
  * IGT: IGT_7964 -> IGTPW_11551

  CI-20190529: 20190529
  CI_DRM_15204: 040fda7980e8fccde054bf16158538ff80223e36 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_11551: 11551
  IGT_7964: 0dabf88262c0349d261248638064b97da35369f8 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git

== Logs ==

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

[-- Attachment #2: Type: text/html, Size: 118774 bytes --]

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Grzegorzek, Dominik]

On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> 
> Introduce library which simplifies testing of eu debug capability.
> The library provides event log helpers together with asynchronous
> abstraction for client proccess and the debugger itself.
> 
> xe_eudebug_client creates its own proccess with user's work function,
> and gives machanisms to synchronize beginning of execution and event
> logging.
> 
> xe_eudebug_debugger allows to attach to the given proccess, provides
> asynchronous thread for event reading and introduces triggers -
> a callback mechanism triggered every time subscribed event was read.
> 
> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> ---
>  lib/meson.build     |    1 +
>  lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
>  lib/xe/xe_eudebug.h |  206 ++++
>  3 files changed, 2399 insertions(+)
>  create mode 100644 lib/xe/xe_eudebug.c
>  create mode 100644 lib/xe/xe_eudebug.h
> 
> diff --git a/lib/meson.build b/lib/meson.build
> index f711e60a7..969ca4101 100644
> --- a/lib/meson.build
> +++ b/lib/meson.build
> @@ -111,6 +111,7 @@ lib_sources = [
>  	'igt_msm.c',
>  	'igt_dsc.c',
>  	'xe/xe_gt.c',
> +	'xe/xe_eudebug.c',
>  	'xe/xe_ioctl.c',
>  	'xe/xe_mmio.c',
>  	'xe/xe_query.c',
> diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
> new file mode 100644
> index 000000000..4eac87476
> --- /dev/null
> +++ b/lib/xe/xe_eudebug.c
> @@ -0,0 +1,2192 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2023 Intel Corporation
> + */
> +
> +#include <fcntl.h>
> +#include <poll.h>
> +#include <signal.h>
> +#include <sys/select.h>
> +#include <sys/stat.h>
> +#include <sys/types.h>
> +#include <sys/wait.h>
> +
> +#include "igt.h"
> +#include "igt_sysfs.h"
> +#include "intel_pat.h"
> +#include "xe_eudebug.h"
> +#include "xe_ioctl.h"
> +
> +struct event_trigger {
> +	xe_eudebug_trigger_fn fn;
> +	int type;
> +	struct igt_list_head link;
> +};
> +
> +struct seqno_list_entry {
> +	struct igt_list_head link;
> +	uint64_t seqno;
> +};
> +
> +struct match_dto {
> +	struct drm_xe_eudebug_event *target;
> +	struct igt_list_head *seqno_list;
> +	uint64_t client_handle;
> +	uint32_t filter;
> +
> +	/* store latest 'EVENT_VM_BIND' seqno */
> +	uint64_t *bind_seqno;
> +	/* latest vm_bind_op seqno matching bind_seqno */
> +	uint64_t *bind_op_seqno;
> +};
> +
> +#define CLIENT_PID  1
> +#define CLIENT_RUN  2
> +#define CLIENT_FINI 3
> +#define CLIENT_STOP 4
> +#define CLIENT_STAGE 5
> +#define DEBUGGER_STAGE 6
> +
> +#define DEBUGGER_WORKER_INACTIVE  0
> +#define DEBUGGER_WORKER_ACTIVE  1
> +#define DEBUGGER_WORKER_QUITTING 2
> +
> +static const char *type_to_str(unsigned int type)
> +{
> +	switch (type) {
> +	case DRM_XE_EUDEBUG_EVENT_NONE:
> +		return "none";
> +	case DRM_XE_EUDEBUG_EVENT_READ:
> +		return "read";
> +	case DRM_XE_EUDEBUG_EVENT_OPEN:
> +		return "client";
> +	case DRM_XE_EUDEBUG_EVENT_VM:
> +		return "vm";
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
> +		return "exec_queue";
> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
> +		return "attention";
> +	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_UFENCE:
> +		return "vm_bind_ufence";
> +	case DRM_XE_EUDEBUG_EVENT_METADATA:
> +		return "metadata";
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
> +		return "vm_bind_op_metadata";
> +	}
> +
> +	return "UNKNOWN";
> +}
> +
> +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
> +{
> +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
> +
> +	return buf;
> +}
> +
> +static const char *flags_to_str(unsigned int flags)
> +{
> +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
> +			return "create|ack";
> +		else
> +			return "create";
> +	}
> +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> +		return "destroy";
> +
> +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
> +		return "state-change";
> +
> +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
> +
> +	return "flags unknown";
> +}
> +
> +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
> +{
> +	switch (e->type) {
> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
> +
> +		sprintf(b, "handle=%llu", ec->client_handle);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM: {
> +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
> +
> +		sprintf(b, "client_handle=%llu, handle=%llu",
> +			evm->client_handle, evm->vm_handle);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
> +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
> +			ee->client_handle, ee->vm_handle,
> +			ee->exec_queue_handle, ee->engine_class, ee->width);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
> +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
> +			   "lrc_handle=%llu, bitmask_size=%d",
> +			ea->client_handle, ea->exec_queue_handle,
> +			ea->lrc_handle, ea->bitmask_size);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
> +			evmb->client_handle, 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 = (void *)e;
> +
> +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
> +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
> +
> +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
> +			em->client_handle, em->metadata_handle, em->type, em->len);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
> +
> +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
> +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
> +		break;
> +	}
> +	default:
> +		strcpy(b, "<...>");
> +	}
> +
> +	return b;
> +}
> +
> +/**
> + * xe_eudebug_event_to_str:
> + * @e: pointer to event
> + * @buf: target to write string representation of @e
> + * @len: size of target buffer @buf
> + *
> + * Creates string representation for given event.
> + *
> + * Returns: the written input buffer pointed by @buf.
> + */
> +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
> +{
> +	char a[256];
> +	char b[256];
> +
> +	snprintf(buf, len, "(%llu) %15s:%s: %s",
> +		 e->seqno,
> +		 event_type_to_str(e, a),
> +		 flags_to_str(e->flags),
> +		 event_members_to_str(e, b));
> +
> +	return buf;
> +}
> +
> +static void catch_child_failure(void)
> +{
> +	pid_t pid;
> +	int status;
> +
> +	pid = waitpid(-1, &status, WNOHANG);
> +
> +	if (pid == 0 || pid == -1)
> +		return;
> +
> +	if (!WIFEXITED(status))
> +		return;
> +
> +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
> +}
> +
> +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
> +{
> +	int ret;
> +	int t = 0;
> +	struct pollfd fd = {
> +		.fd = pipe[0],
> +		.events = POLLIN,
> +		.revents = 0
> +	};
> +
> +	/* When child fails we may get stuck forever. Check whether
> +	 * the child process ended with an error.
> +	 */
> +	do {
> +		const int interval_ms = 1000;
> +
> +		ret = poll(&fd, 1, interval_ms);
> +
> +		if (!ret) {
> +			catch_child_failure();
> +			t += interval_ms;
> +		}
> +	} while (!ret && t < timeout_ms);
> +
> +	if (ret > 0)
> +		return read(pipe[0], buf, nbytes);
> +
> +	return 0;
> +}
> +
> +static uint64_t pipe_read(int pipe[2], int timeout_ms)
> +{
> +	uint64_t in;
> +	uint64_t ret;
> +
> +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
> +	igt_assert(ret == sizeof(in));
> +
> +	return in;
> +}
> +
> +static void pipe_signal(int pipe[2], uint64_t token)
> +{
> +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
> +}
> +
> +static void pipe_close(int pipe[2])
> +{
> +	if (pipe[0] != -1)
> +		close(pipe[0]);
> +
> +	if (pipe[1] != -1)
> +		close(pipe[1]);
> +}
> +
> +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
> +{
> +	uint64_t in;
> +
> +	in = pipe_read(p, timeout_ms);
> +
> +	igt_assert_eq(in, token);
> +
> +	return pipe_read(p, timeout_ms);
> +}
> +
> +static uint64_t client_wait_token(struct xe_eudebug_client *c,
> +				 const uint64_t token)
> +{
> +	return __wait_token(c->p_in, token, c->timeout_ms);
> +}
> +
> +static uint64_t wait_from_client(struct xe_eudebug_client *c,
> +				 const uint64_t token)
> +{
> +	return __wait_token(c->p_out, token, c->timeout_ms);
> +}
> +
> +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
> +{
> +	pipe_signal(p, token);
> +	pipe_signal(p, value);
> +}
> +
> +static void client_signal(struct xe_eudebug_client *c,
> +			  const uint64_t token,
> +			  const uint64_t value)
> +{
> +	token_signal(c->p_out, token, value);
> +}
> +
> +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
> +{
> +	struct drm_xe_eudebug_connect param = {
> +		.pid = pid,
> +		.flags = flags,
> +	};
> +	int debugfd;
> +
> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> +
> +	if (debugfd < 0)
> +		return -errno;
> +
> +	return debugfd;
> +}
> +
> +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
> +{
> +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
> +		      sizeof(l->head));
> +
> +	igt_assert_eq(write(fd, l->log, l->head), l->head);
> +}
> +
> +static void read_all(int fd, void *buf, size_t nbytes)
> +{
> +	ssize_t remaining_size = nbytes;
> +	ssize_t current_size = 0;
> +	ssize_t read_size = 0;
> +
> +	do {
> +		read_size = read(fd, buf + current_size, remaining_size);
> +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
> +
> +		current_size += read_size;
> +		remaining_size -= read_size;
> +	} while (remaining_size > 0 && read_size > 0);
> +
> +	igt_assert_eq(current_size, nbytes);
> +}
> +
> +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
> +{
> +	read_all(fd, &l->head, sizeof(l->head));
> +	igt_assert_lt(l->head, l->max_size);
> +
> +	read_all(fd, l->log, l->head);
> +}
> +
> +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
> +
> +static struct drm_xe_eudebug_event *
> +event_cmp(struct xe_eudebug_event_log *l,
> +	  struct drm_xe_eudebug_event *current,
> +	  cmp_fn_t match,
> +	  void *data)
> +{
> +	struct drm_xe_eudebug_event *e = current;
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		if (match(e, data))
> +			return e;
> +	}
> +
> +	return NULL;
> +}
> +
> +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
> +{
> +	struct drm_xe_eudebug_event *b = data;
> +
> +	if (a->type == b->type &&
> +	    a->flags == b->flags)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
> +{
> +	struct drm_xe_eudebug_event *b = data;
> +	int ret = 0;
> +
> +	ret = match_type_and_flags(a, data);
> +	if (!ret)
> +		return ret;
> +
> +	ret = 0;
> +
> +	switch (a->type) {
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
> +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
> +
> +		if (ae->engine_class == be->engine_class && ae->width == be->width)
> +			ret = 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
> +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
> +
> +		if (ea->num_binds == eb->num_binds)
> +			ret = 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
> +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
> +
> +		if (ea->addr == eb->addr && ea->range == eb->range &&
> +		    ea->num_extensions == eb->num_extensions)
> +			ret = 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
> +
> +		if (ea->metadata_handle == eb->metadata_handle &&
> +		    ea->metadata_cookie == eb->metadata_cookie)
> +			ret = 1;
> +		break;
> +	}
> +
> +	default:
> +		ret = 1;
> +		break;
> +	}
> +
> +	return ret;
> +}
> +
> +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
> +{
> +	struct match_dto *md = (void *)data;
> +	uint64_t *bind_seqno = md->bind_seqno;
> +	uint64_t *bind_op_seqno = md->bind_op_seqno;
> +	uint64_t h = md->client_handle;
> +
> +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
> +		return 0;
> +
> +	switch (e->type) {
> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> +
> +		if (client->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM: {
> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> +
> +		if (vm->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
> +
> +		if (ee->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
> +
> +		if (evmb->client_handle == h) {
> +			*bind_seqno = evmb->base.seqno;
> +			return 1;
> +		}
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
> +
> +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
> +			*bind_op_seqno = eo->base.seqno;
> +			return 1;
> +		}
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
> +
> +		if (ef->vm_bind_ref_seqno == *bind_seqno)
> +			return 1;
> +
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
> +
> +		if (em->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
> +
> +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
> +			return 1;
> +		break;
> +	}
> +	default:
> +		break;
> +	}
> +
> +	return 0;
> +}
> +
> +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
> +{
> +
> +	struct drm_xe_eudebug_event *d = (void *)data;
> +	int ret;
> +
> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
> +	ret = match_type_and_flags(e, data);
> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> +
> +	if (!ret)
> +		return 0;
> +
> +	switch (e->type) {
> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
> +
> +		if (client->client_handle == filter->client_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM: {
> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
> +
> +		if (vm->vm_handle == filter->vm_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
> +
> +		if (ee->exec_queue_handle == filter->exec_queue_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
> +
> +		if (evmb->vm_handle == filter->vm_handle &&
> +		    evmb->num_binds == filter->num_binds)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
> +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
> +
> +		if (avmb->addr == filter->addr &&
> +		    avmb->range == filter->range)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
> +
> +		if (em->metadata_handle == filter->metadata_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
> +
> +		if (avmb->metadata_handle == filter->metadata_handle &&
> +		    avmb->metadata_cookie == filter->metadata_cookie)
> +			return 1;
> +		break;
> +	}
> +
> +	default:
> +		break;
> +	}
> +	return 0;
> +}
> +
> +static int match_full(struct drm_xe_eudebug_event *e, void *data)
> +{
> +	struct seqno_list_entry *sl;
> +
> +	struct match_dto *md = (void *)data;
> +	int ret = 0;
> +
> +	ret = match_client_handle(e, md);
> +	if (!ret)
> +		return 0;
> +
> +	ret = match_fields(e, md->target);
> +	if (!ret)
> +		return 0;
> +
> +	igt_list_for_each_entry(sl, md->seqno_list, link) {
> +		if (sl->seqno == e->seqno)
> +			return 0;
> +	}
> +
> +	return 1;
> +}
> +
> +static struct drm_xe_eudebug_event *
> +event_type_match(struct xe_eudebug_event_log *l,
> +		 struct drm_xe_eudebug_event *target,
> +		 struct drm_xe_eudebug_event *current)
> +{
> +	return event_cmp(l, current, match_type_and_flags, target);
> +}
> +
> +static struct drm_xe_eudebug_event *
> +client_match(struct xe_eudebug_event_log *l,
> +	     uint64_t client_handle,
> +	     struct drm_xe_eudebug_event *current,
> +	     uint32_t filter,
> +	     uint64_t *bind_seqno,
> +	     uint64_t *bind_op_seqno)
> +{
> +	struct match_dto md = {
> +		.client_handle = client_handle,
> +		.filter = filter,
> +		.bind_seqno = bind_seqno,
> +		.bind_op_seqno = bind_op_seqno,
> +	};
> +
> +	return event_cmp(l, current, match_client_handle, &md);
> +}
> +
> +static struct drm_xe_eudebug_event *
> +opposite_event_match(struct xe_eudebug_event_log *l,
> +		    struct drm_xe_eudebug_event *target,
> +		    struct drm_xe_eudebug_event *current)
> +{
> +	return event_cmp(l, current, match_opposite_resource, target);
> +}
> +
> +static struct drm_xe_eudebug_event *
> +event_match(struct xe_eudebug_event_log *l,
> +	    struct drm_xe_eudebug_event *target,
> +	    uint64_t client_handle,
> +	    struct igt_list_head *seqno_list,
> +	    uint64_t *bind_seqno,
> +	    uint64_t *bind_op_seqno)
> +{
> +	struct match_dto md = {
> +		.target = target,
> +		.client_handle = client_handle,
> +		.seqno_list = seqno_list,
> +		.bind_seqno = bind_seqno,
> +		.bind_op_seqno = bind_op_seqno,
> +	};
> +
> +	return event_cmp(l, NULL, match_full, &md);
> +}
> +
> +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
> +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
> +			   uint32_t filter)
> +{
> +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
> +	struct drm_xe_eudebug_event_client *de = (void *)_de;
> +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
> +
> +	struct igt_list_head matched_seqno_list;
> +	struct drm_xe_eudebug_event *hc, *hd;
> +	struct seqno_list_entry *entry, *tmp;
> +
> +	igt_assert(ce);
> +	igt_assert(de);
> +
> +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
> +
> +	hc = NULL;
> +	hd = NULL;
> +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
> +
> +	do {
> +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
> +		if (!hc)
> +			break;
> +
> +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
> +
> +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
> +			     c->name,
> +			     hc->seqno,
> +			     hc->type,
> +			     ce->client_handle);
> +
> +		igt_debug("comparing %s %llu vs %s %llu\n",
> +			  c->name, hc->seqno, d->name, hd->seqno);
> +
> +		/*
> +		 * Store the seqno of the event that was matched above,
> +		 * inside 'matched_seqno_list', to avoid it getting matched
> +		 * by subsequent 'event_match' calls.
> +		 */
> +		entry = malloc(sizeof(*entry));
> +		entry->seqno = hd->seqno;
> +		igt_list_add(&entry->link, &matched_seqno_list);
> +	} while (hc);
> +
> +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
> +		free(entry);
> +}
> +
> +/**
> + * xe_eudebug_event_log_find_seqno:
> + * @l: event log pointer
> + * @seqno: seqno of event to be found
> + *
> + * Finds the event with given seqno in the event log.
> + *
> + * Returns: pointer to the event with given seqno within @l or NULL seqno is
> + * not present.
> + */
> +struct drm_xe_eudebug_event *
> +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
> +{
> +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
> +
> +	igt_assert_neq(seqno, 0);
> +	/*
> +	 * Try to catch if seqno is corrupted and prevent too long tests,
> +	 * as our post processing of events is not optimized.
> +	 */
> +	igt_assert_lt(seqno, 10 * 1000 * 1000);
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		if (e->seqno == seqno) {
> +			if (found) {
> +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
> +				xe_eudebug_event_log_print(l, false);
> +				igt_assert(!found);
> +			}
> +			found = e;
> +		}
> +	}
> +
> +	return found;
> +}
> +
> +static void event_log_sort(struct xe_eudebug_event_log *l)
> +{
> +	struct xe_eudebug_event_log *tmp;
> +	struct drm_xe_eudebug_event *e = NULL;
> +	uint64_t first_seqno = 0;
> +	uint64_t last_seqno = 0;
> +	uint64_t events = 0, added = 0;
> +	uint64_t i;
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		if (e->seqno > last_seqno)
> +			last_seqno = e->seqno;
> +
> +		if (e->seqno < first_seqno)
> +			first_seqno = e->seqno;
> +
> +		events++;
> +	}
> +
> +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
> +
> +	for (i = 1; i <= last_seqno; i++) {
> +		e = xe_eudebug_event_log_find_seqno(l, i);
> +		if (e) {
> +			xe_eudebug_event_log_write(tmp, e);
> +			added++;
> +		}
> +	}
> +
> +	igt_assert_eq(events, added);
> +	igt_assert_eq(tmp->head, l->head);
> +
> +	memcpy(l->log, tmp->log, tmp->head);
> +
> +	xe_eudebug_event_log_destroy(tmp);
> +}
> +
> +/**
> + * xe_eudebug_connect:
> + * @fd: Xe file descriptor
> + * @pid: client PID
> + * @flags: connection flags
> + *
> + * Opens the xe eu debugger connection to the process described by @pid
> + *
> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> + */
> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
> +{
> +	int ret;
> +	uint64_t events = 0; /* events filtering not supported yet! */
> +
> +	ret = __xe_eudebug_connect(fd, pid, flags, events);
> +
> +	return ret;
> +}
> +
> +/**
> + * xe_eudebug_event_log_create:
> + * @name: event log identifier
> + * @max_size: maximum size of created log
> + *
> + * Function creates an Eu Debugger event log with size equal to @max_size.
> + *
> + * Returns: pointer to just created log
> + */
> +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
> +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
> +{
> +	struct xe_eudebug_event_log *l;
> +
> +	l = calloc(1, sizeof(*l));
> +	igt_assert(l);
> +	l->log = calloc(1, max_size);
> +	igt_assert(l->log);
> +	l->max_size = max_size;
> +	strncpy(l->name, name, sizeof(l->name) - 1);
> +	pthread_mutex_init(&l->lock, NULL);
> +
> +	return l;
> +}
> +
> +/**
> + * xe_eudebug_event_log_destroy:
> + * @l: event log pointer
> + *
> + * Frees given event log @l.
> + */
> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
> +{
> +	pthread_mutex_destroy(&l->lock);
> +	free(l->log);
> +	free(l);
> +}
> +
> +/**
> + * xe_eudebug_event_log_write:
> + * @l: event log pointer
> + * @e: event to be written to event log
> + *
> + * Writes event @e to the event log, thread-safe.
> + */
> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
> +{
> +	igt_assert(e->seqno);
> +	/*
> +	 * Try to catch if seqno is corrupted and prevent too long tests,
> +	 * as our post processing of events is not optimized.
> +	 */
> +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
> +
> +	pthread_mutex_lock(&l->lock);
> +	igt_assert_lt(l->head + e->len, l->max_size);
> +	memcpy(l->log + l->head, e, e->len);
> +	l->head += e->len;
> +
> +#ifdef DEBUG_LOG
> +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
> +		 l->name, e->len, l->max_size - l->head);
> +#endif
> +	pthread_mutex_unlock(&l->lock);
I'm not fan of #ifdef debug logs. As the event log has been proven in action,
can we just strip it out? 
<cut>

Regards,
Dominik

Re: [PATCH i-g-t v3 13/14] tests/xe_eudebug_online: Debug client which runs workloads on EU

[Grzegorzek, Dominik]

On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> 
> For typical debugging under gdb one can specify two main usecases:
> accessing and manupulating resources created by the application and
> manipulating thread execution (interrupting and setting breakpoints).
> 
> This test adds coverage for the latter by checking that:
> - EU workloads that hit a instruction with breakpoint bit set will stop
>   halt execution and the debugger will report this via attention events,
> - the debugger is able to interrupt workload execution by issuing a
>   'interrupt_all' ioctl call,
> - the debugger is able to resume selected workloads that are stopped.
> 
> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Mika Kuoppala <mika.kuoppala@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> Signed-off-by: Kolanupaka Naveena <kolanupaka.naveena@intel.com>
> ---
>  tests/intel/xe_eudebug_online.c | 2203 +++++++++++++++++++++++++++++++
>  tests/meson.build               |    1 +
>  2 files changed, 2204 insertions(+)
>  create mode 100644 tests/intel/xe_eudebug_online.c
> 
> diff --git a/tests/intel/xe_eudebug_online.c b/tests/intel/xe_eudebug_online.c
> new file mode 100644
> index 000000000..1c8ac67f1
> --- /dev/null
> +++ b/tests/intel/xe_eudebug_online.c
> @@ -0,0 +1,2203 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2023 Intel Corporation
> + */
> +
> +/**
> + * TEST: Tests for eudebug online functionality
> + * Category: Core
> + * Mega feature: EUdebug
> + * Sub-category: EUdebug tests
> + * Functionality: eu kernel debug
> + * Test category: functionality test
> + */
> +
> +#include "xe/xe_eudebug.h"
> +#include "xe/xe_ioctl.h"
> +#include "xe/xe_query.h"
> +#include "igt.h"
> +#include "intel_pat.h"
> +#include "intel_mocs.h"
> +#include "gpgpu_shader.h"
> +
> +#define SHADER_NOP			(0 << 0)
> +#define SHADER_BREAKPOINT		(1 << 0)
> +#define SHADER_LOOP			(1 << 1)
> +#define SHADER_SINGLE_STEP		(1 << 2)
> +#define SIP_SINGLE_STEP			(1 << 3)
> +#define DISABLE_DEBUG_MODE		(1 << 4)
> +#define SHADER_N_NOOP_BREAKPOINT	(1 << 5)
> +#define SHADER_CACHING_SRAM		(1 << 6)
> +#define SHADER_CACHING_VRAM		(1 << 7)
> +#define SHADER_MIN_THREADS		(1 << 8)
> +#define DO_NOT_EXPECT_CANARIES		(1 << 9)
> +#define TRIGGER_RESUME_SINGLE_WALK	(1 << 25)
> +#define TRIGGER_RESUME_PARALLEL_WALK	(1 << 26)
> +#define TRIGGER_RECONNECT		(1 << 27)
> +#define TRIGGER_RESUME_SET_BP		(1 << 28)
> +#define TRIGGER_RESUME_DELAYED		(1 << 29)
> +#define TRIGGER_RESUME_DSS		(1 << 30)
> +#define TRIGGER_RESUME_ONE		(1 << 31)
> +
> +#define DEBUGGER_REATTACHED	1
> +
> +#define SHADER_LOOP_N		3
> +#define SINGLE_STEP_COUNT	16
> +#define STEERING_SINGLE_STEP	0
> +#define STEERING_CONTINUE	0x00c0ffee
> +#define STEERING_END_LOOP	0xdeadca11
> +
> +#define CACHING_INIT_VALUE	0xcafe0000
> +#define CACHING_POISON_VALUE	0xcafedead
> +#define CACHING_VALUE(n)	(CACHING_INIT_VALUE + n)
> +
> +#define SHADER_CANARY 0x01010101
> +
> +#define WALKER_X_DIM		4
> +#define WALKER_ALIGNMENT	16
> +#define SIMD_SIZE		16
> +
> +#define STARTUP_TIMEOUT_MS	3000
> +#define WORKLOAD_DELAY_US	(5000 * 1000)
> +
> +#define PAGE_SIZE 4096
> +
> +struct dim_t {
> +	uint32_t x;
> +	uint32_t y;
> +	uint32_t alignment;
> +};
> +
> +static struct dim_t walker_dimensions(int threads)
> +{
> +	uint32_t x_dim = min_t(x_dim, threads, WALKER_X_DIM);
> +	struct dim_t ret = {
> +		.x = x_dim,
> +		.y = threads / x_dim,
> +		.alignment = WALKER_ALIGNMENT
> +	};
> +
> +	return ret;
> +}
> +
> +static struct dim_t surface_dimensions(int threads)
> +{
> +	struct dim_t ret = walker_dimensions(threads);
> +
> +	ret.y = max_t(ret.y, threads/ret.x, 4);
> +	ret.x *= SIMD_SIZE;
> +	ret.alignment *= SIMD_SIZE;
> +
> +	return ret;
> +}
> +
> +static uint32_t steering_offset(int threads)
> +{
> +	struct dim_t w = walker_dimensions(threads);
> +
> +	return ALIGN(w.x, w.alignment) * w.y * 4;
> +}
> +
> +static struct intel_buf *create_uc_buf(int fd, int width, int height)
> +{
> +	struct intel_buf *buf;
> +
> +	buf = intel_buf_create_full(buf_ops_create(fd), 0, width/4, height,
> +				    32, 0, I915_TILING_NONE, 0, 0, 0,
> +				    vram_if_possible(fd, 0),
> +				    DEFAULT_PAT_INDEX, DEFAULT_MOCS_INDEX);
> +
> +	return buf;
> +}
> +
> +static int get_number_of_threads(uint64_t flags)
> +{
> +	if (flags & SHADER_MIN_THREADS)
> +		return 16;
> +
> +	if (flags & (TRIGGER_RESUME_ONE | TRIGGER_RESUME_SINGLE_WALK |
> +		     TRIGGER_RESUME_PARALLEL_WALK | SHADER_CACHING_SRAM | SHADER_CACHING_VRAM))
> +		return 32;
> +
> +	return 512;
> +}
> +
> +static int caching_get_instruction_count(int fd, uint32_t s_dim__x, int flags)
> +{
> +	uint64_t memory;
> +
> +	igt_assert((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM));
> +
> +	if (flags & SHADER_CACHING_SRAM)
> +		memory = system_memory(fd);
> +	else
> +		memory = vram_memory(fd, 0);
> +
> +	/* each instruction writes to given y offset */
> +	return (2 * xe_min_page_size(fd, memory)) / s_dim__x;
> +}
> +
> +static struct gpgpu_shader *get_shader(int fd, const unsigned int flags)
> +{
> +	struct dim_t w_dim = walker_dimensions(get_number_of_threads(flags));
> +	struct dim_t s_dim = surface_dimensions(get_number_of_threads(flags));
> +	static struct gpgpu_shader *shader;
> +
> +	shader = gpgpu_shader_create(fd);
> +
> +	gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
> +	if (flags & SHADER_BREAKPOINT) {
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__breakpoint(shader);
> +	} else if (flags & SHADER_LOOP) {
> +		gpgpu_shader__label(shader, 0);
> +		gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
> +		gpgpu_shader__jump_neq(shader, 0, w_dim.y, STEERING_END_LOOP);
> +		gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
> +	} else if (flags & SHADER_SINGLE_STEP) {
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__breakpoint(shader);
> +		for (int i = 0; i < SINGLE_STEP_COUNT; i++)
> +			gpgpu_shader__nop(shader);
> +	} else if (flags & SHADER_N_NOOP_BREAKPOINT) {
> +		for (int i = 0; i < SHADER_LOOP_N; i++) {
> +			gpgpu_shader__nop(shader);
> +			gpgpu_shader__breakpoint(shader);
> +		}
> +	} else if ((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM)) {
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__breakpoint(shader);
> +		for (int i = 0; i < caching_get_instruction_count(fd, s_dim.x, flags); i++)
> +			gpgpu_shader__common_target_write_u32(shader, s_dim.y + i, CACHING_VALUE(i));
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__breakpoint(shader);
> +	}
> +
> +	gpgpu_shader__eot(shader);
> +	return shader;
> +}
> +
> +static struct gpgpu_shader *get_sip(int fd, const unsigned int flags)
> +{
> +	struct dim_t w_dim = walker_dimensions(get_number_of_threads(flags));
> +	static struct gpgpu_shader *sip;
> +
> +	sip = gpgpu_shader_create(fd);
> +	gpgpu_shader__write_aip(sip, 0);
> +
> +	gpgpu_shader__wait(sip);
> +	if (flags & SIP_SINGLE_STEP)
> +		gpgpu_shader__end_system_routine_step_if_eq(sip, w_dim.y, 0);
> +	else
> +		gpgpu_shader__end_system_routine(sip, true);
> +	return sip;
> +}
> +
> +static int count_set_bits(void *ptr, size_t size)
> +{
> +	uint8_t *p = ptr;
> +	int count = 0;
> +	int i, j;
> +
> +	for (i = 0; i < size; i++)
> +		for (j = 0; j < 8; j++)
> +			count += !!(p[i] & (1 << j));
> +
> +	return count;
> +}
> +
> +static int count_canaries_eq(uint32_t *ptr, struct dim_t w_dim, uint32_t value)
> +{
> +	int count = 0;
> +	int x, y;
> +
> +	for (x = 0; x < w_dim.x; x++)
> +		for (y = 0; y < w_dim.y; y++)
> +			if (READ_ONCE(ptr[x + ALIGN(w_dim.x, w_dim.alignment) * y]) == value)
> +				count++;
> +
> +	return count;
> +}
> +
> +static int count_canaries_neq(uint32_t *ptr, struct dim_t w_dim, uint32_t value)
> +{
> +	return w_dim.x * w_dim.y - count_canaries_eq(ptr, w_dim, value);
> +}
> +
> +static const char *td_ctl_cmd_to_str(uint32_t cmd)
> +{
> +	switch (cmd) {
> +	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL:
> +		return "interrupt all";
> +	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED:
> +		return "stopped";
> +	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME:
> +		return "resume";
> +	default:
> +		return "unknown command";
> +	}
> +}
> +
> +static int __eu_ctl(int debugfd, uint64_t client,
> +		    uint64_t exec_queue, uint64_t lrc,
> +		    uint8_t *bitmask, uint32_t *bitmask_size,
> +		    uint32_t cmd, uint64_t *seqno)
> +{
> +	struct drm_xe_eudebug_eu_control control = {
> +		.client_handle = lower_32_bits(client),
> +		.exec_queue_handle = exec_queue,
> +		.lrc_handle = lrc,
> +		.cmd = cmd,
> +		.bitmask_ptr = to_user_pointer(bitmask),
> +	};
> +	int ret;
> +
> +	if (bitmask_size)
> +		control.bitmask_size = *bitmask_size;
> +
> +	ret = igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &control);
> +
> +	if (ret < 0)
> +		return -errno;
> +
> +	igt_debug("EU CONTROL[%llu]: %s\n", control.seqno, td_ctl_cmd_to_str(cmd));
> +
> +	if (bitmask_size)
> +		*bitmask_size = control.bitmask_size;
> +
> +	if (seqno)
> +		*seqno = control.seqno;
> +
> +	return 0;
> +
> +}
> +
> +static uint64_t eu_ctl(int debugfd, uint64_t client,
> +		       uint64_t exec_queue, uint64_t lrc,
> +		       uint8_t *bitmask, uint32_t *bitmask_size, uint32_t cmd)
> +{
> +	uint64_t seqno;
> +
> +	igt_assert_eq(__eu_ctl(debugfd, client, exec_queue, lrc, bitmask,
> +			       bitmask_size, cmd, &seqno), 0);
> +
> +	return seqno;
> +}
> +
> +static bool intel_gen_needs_resume_wa(int fd)
> +{
> +	const uint32_t id = intel_get_drm_devid(fd);
> +
> +	return intel_gen(id) == 12 && intel_graphics_ver(id) < IP_VER(12, 55);
> +}
> +
> +static uint64_t eu_ctl_resume(int fd, int debugfd, uint64_t client,
> +			      uint64_t exec_queue, uint64_t lrc,
> +			      uint8_t *bitmask, uint32_t bitmask_size)
> +{
> +	int i;
> +
> +	/* XXX: WA for hsd: 14011332042 */
Remove XXX.
Maybe plain: /* Wa_14011332042 */ ?
> +	if (intel_gen_needs_resume_wa(fd)) {
> +		uint32_t *att_reg_half = (uint32_t *)bitmask;
> +
> +		for (i = 0; i < bitmask_size / sizeof(uint32_t); i += 2) {
> +			att_reg_half[i] |= att_reg_half[i + 1];
> +			att_reg_half[i + 1] |= att_reg_half[i];
> +		}
> +	}
> +
> +	return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, &bitmask_size,
> +		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME);
> +}
> +
> +static inline uint64_t eu_ctl_stopped(int debugfd, uint64_t client,
> +				      uint64_t exec_queue, uint64_t lrc,
> +				      uint8_t *bitmask, uint32_t *bitmask_size)
> +{
> +	return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, bitmask_size,
> +		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED);
> +}
> +
> +static inline uint64_t eu_ctl_interrupt_all(int debugfd, uint64_t client,
> +					    uint64_t exec_queue, uint64_t lrc)
> +{
> +	return eu_ctl(debugfd, client, exec_queue, lrc, NULL, 0,
> +		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL);
> +}
> +
> +struct online_debug_data {
> +	pthread_mutex_t mutex;
> +	/* client in */
> +	struct drm_xe_engine_class_instance hwe;
> +	/* client out */
> +	int threads_count;
> +	/* debugger internals */
> +	uint64_t client_handle;
> +	uint64_t exec_queue_handle;
> +	uint64_t lrc_handle;
> +	uint64_t target_offset;
> +	size_t target_size;
> +	uint64_t bb_offset;
> +	size_t bb_size;
> +	int vm_fd;
> +	uint32_t first_aip;
> +	uint64_t *aips_offset_table;
> +	uint32_t steps_done;
> +	uint8_t *single_step_bitmask;
> +	int stepped_threads_count;
> +	struct timespec exception_arrived;
> +	int last_eu_control_seqno;
> +	struct drm_xe_eudebug_event *exception_event;
> +};
> +
> +static struct online_debug_data *
> +online_debug_data_create(struct drm_xe_engine_class_instance *hwe)
> +{
> +	struct online_debug_data *data;
> +
> +	data = mmap(0, ALIGN(sizeof(*data), PAGE_SIZE),
> +		    PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
> +	memcpy(&data->hwe, hwe, sizeof(*hwe));
> +	pthread_mutex_init(&data->mutex, NULL);
> +	data->client_handle = -1ULL;
> +	data->exec_queue_handle = -1ULL;
> +	data->lrc_handle = -1ULL;
> +	data->vm_fd = -1;
> +	data->stepped_threads_count = -1;
> +
> +	return data;
> +}
> +
> +static void online_debug_data_destroy(struct online_debug_data *data)
> +{
> +	free(data->aips_offset_table);
> +	munmap(data, ALIGN(sizeof(*data), PAGE_SIZE));
> +}
> +
> +static void eu_attention_debug_trigger(struct xe_eudebug_debugger *d,
> +					struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
> +	uint32_t *ptr = (uint32_t *) att->bitmask;
> +
> +	igt_debug("EVENT[%llu] eu-attenttion; threads=%d "
> +		 "client[%llu], exec_queue[%llu], lrc[%llu], bitmask_size[%d]\n",
> +		 att->base.seqno, count_set_bits(att->bitmask, att->bitmask_size),
> +				att->client_handle, att->exec_queue_handle,
> +				att->lrc_handle, att->bitmask_size);
strange alignment
> +
> +	for (uint32_t i = 0; i < att->bitmask_size/4; i += 2)
> +		igt_debug("bitmask[%d] = 0x%08x%08x\n", i/2, ptr[i], ptr[i+1]);
> +
> +}
> +
> +static void eu_attention_reset_trigger(struct xe_eudebug_debugger *d,
> +					struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
> +	uint32_t *ptr = (uint32_t *) att->bitmask;
> +	struct online_debug_data *data = d->ptr;
> +
> +	igt_debug("EVENT[%llu] eu-attention with reset; threads=%d "
> +		 "client[%llu], exec_queue[%llu], lrc[%llu], bitmask_size[%d]\n",
> +		 att->base.seqno, count_set_bits(att->bitmask, att->bitmask_size),
> +				att->client_handle, att->exec_queue_handle,
> +				att->lrc_handle, att->bitmask_size);
here as well
> +
> +	for (uint32_t i = 0; i < att->bitmask_size/4; i += 2)
> +		igt_debug("bitmask[%d] = 0x%08x%08x\n", i/2, ptr[i], ptr[i+1]);
> +
> +	xe_force_gt_reset_async(d->master_fd, data->hwe.gt_id);
> +}
> +
> +static void copy_first_bit(uint8_t *dst, uint8_t *src, int size)
> +{
> +	bool found = false;
> +	int i, j;
> +
> +	for (i = 0; i < size; i++) {
> +		if (found) {
> +			dst[i] = 0;
> +		} else {
> +			uint32_t tmp = src[i]; /* in case dst == src */
> +
> +			for (j = 0; j < 8; j++) {
> +				dst[i] = tmp & (1 << j);
> +				if (dst[i]) {
> +					found = true;
> +					break;
> +				}
> +			}
> +		}
> +	}
> +}
> +
> +static void copy_nth_bit(uint8_t *dst, uint8_t *src, int size, int n)
> +{
> +	int count = 0;
> +
> +	for (int i = 0; i < size; i++) {
> +		uint32_t tmp = src[i];
> +		for (int j = 7; j >= 0; j--) {
> +			if (tmp & (1 << j)) {
> +				count++;
> +				if (count == n)
> +					dst[i] |= (1 << j);
> +				else
> +					dst[i] &= ~(1 << j);
> +			} else
> +				dst[i] &= ~(1 << j);
> +		}
> +	}
> +}
> +
> +/*
> + * Searches for the first instruction. It stands on assumption,
> + * that shader kernel is placed before sip within the bb.
> + */
> +static uint32_t find_kernel_in_bb(struct gpgpu_shader *kernel,
> +				  struct online_debug_data *data)
> +{
> +	uint32_t *p = kernel->code;
> +	size_t sz = 4 * sizeof(uint32_t);
> +	uint32_t buf[4];
> +	int i;
> +
> +	for (i = 0; i < data->bb_size; i += sz) {
> +		igt_assert_eq(pread(data->vm_fd, &buf, sz, data->bb_offset + i), sz);
> +
> +
> +		if (memcmp(p, buf, sz) == 0)
> +			break;
> +	}
> +
> +	igt_assert(i < data->bb_size);
> +
> +	return i;
> +}
> +
> +static void set_breakpoint_once(struct xe_eudebug_debugger *d,
> +				struct online_debug_data *data)
> +{
> +	const uint32_t breakpoint_bit = 1 << 30;
> +	size_t sz = sizeof(uint32_t);
> +	struct gpgpu_shader *kernel;
> +	uint32_t aip;
> +
> +	kernel = get_shader(d->master_fd, d->flags);
> +
> +	if (data->first_aip) {
> +		uint32_t expected = find_kernel_in_bb(kernel, data) + kernel->size * 4 - 0x10;
> +
> +		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset), sz);
> +		igt_assert_eq_u32(aip, expected);
> +	} else {
> +		uint32_t instr_usdw;
> +
> +		igt_assert(data->vm_fd != -1);
> +		igt_assert(data->target_size != 0);
> +		igt_assert(data->bb_size != 0);
> +
> +		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset), sz);
> +		data->first_aip = aip;
> +
> +		aip = find_kernel_in_bb(kernel, data);
> +
> +		/* set breakpoint on last instruction */
> +		aip += kernel->size * 4 - 0x10;
> +		igt_assert_eq(pread(data->vm_fd, &instr_usdw, sz,
> +				    data->bb_offset + aip), sz);
> +		instr_usdw |= breakpoint_bit;
> +		igt_assert_eq(pwrite(data->vm_fd, &instr_usdw, sz,
> +				     data->bb_offset + aip), sz);
> +
> +	}
> +
> +	gpgpu_shader_destroy(kernel);
> +}
> +
> +static void get_aips_offset_table(struct online_debug_data *data, int threads)
> +{
> +	size_t sz = sizeof(uint32_t);
> +	uint32_t aip;
> +	uint32_t first_aip;
> +	int table_index = 0;
> +
> +	if (data->aips_offset_table)
> +		return;
> +
> +	data->aips_offset_table = malloc(threads * sizeof(uint64_t));
> +	igt_assert(data->aips_offset_table);
> +
> +	igt_assert_eq(pread(data->vm_fd, &first_aip, sz, data->target_offset), sz);
> +	data->first_aip = first_aip;
> +	data->aips_offset_table[table_index++] = 0;
> +
> +	fsync(data->vm_fd);
> +	for (int i = 1; i < data->target_size; i++) {
for (int i = sz; i < data->target_size; i+=sz), no need to compare byte by byte when instruction
pointer has 4 bytes.
> +		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset + i), sz);
> +		if (aip == first_aip)
> +			data->aips_offset_table[table_index++] = i;
> +	}
> +
> +	igt_assert_eq(threads, table_index);
> +
> +	igt_debug("AIPs offset table:\n");
> +	for (int i = 0; i < threads; i++) {
> +		igt_debug("%lx\n", data->aips_offset_table[i]);
> +	}
redundant bracets.
> +}
> +
> +static int get_stepped_threads_count(struct online_debug_data *data, int threads)
> +{
> +	int count = 0;
> +	size_t sz = sizeof(uint32_t);
> +	uint32_t aip;
> +
> +	fsync(data->vm_fd);
> +	for (int i = 0; i < threads; i++) {
> +		igt_assert_eq(pread(data->vm_fd, &aip, sz,
> +				    data->target_offset + data->aips_offset_table[i]), sz);
> +		if (aip != data->first_aip) {
> +			igt_assert(aip == data->first_aip + 0x10);
> +			count++;
> +		}
> +	}
> +
> +	return count;
> +}
> +
> +static void save_first_exception_trigger(struct xe_eudebug_debugger *d,
> +					 struct drm_xe_eudebug_event *e)
> +{
> +	struct online_debug_data *data = d->ptr;
> +
> +	pthread_mutex_lock(&data->mutex);
> +	if (!data->exception_event) {
> +		igt_gettime(&data->exception_arrived);
> +		data->exception_event = igt_memdup(e, e->len);
> +	}
> +	pthread_mutex_unlock(&data->mutex);
> +}
> +
> +#define MAX_PREEMPT_TIMEOUT 10ull
> +static int is_client_resumed;

Why this is static global variable? Could be part of the data struct. 
What's more, it slighlty indicates that when it was set to =1 client 
is running. Which may not be true. (more than one dispatch or more than one breakpoint)
I would consider changing the name, but I do not have strong opinion about that.

> +static void eu_attention_resume_trigger(struct xe_eudebug_debugger *d,
> +					struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
> +	struct online_debug_data *data = d->ptr;
> +	uint32_t bitmask_size = att->bitmask_size;
> +	uint8_t *bitmask;
> +	int i;
> +
> +	if (data->last_eu_control_seqno > att->base.seqno)
> +		return;
> +
> +	bitmask = calloc(1, att->bitmask_size);
> +
> +	eu_ctl_stopped(d->fd, att->client_handle, att->exec_queue_handle,
> +		       att->lrc_handle, bitmask, &bitmask_size);
> +	igt_assert(bitmask_size == att->bitmask_size);
> +	igt_assert(memcmp(bitmask, att->bitmask, att->bitmask_size) == 0);
> +
> +	pthread_mutex_lock(&data->mutex);
> +	if (igt_nsec_elapsed(&data->exception_arrived) < (MAX_PREEMPT_TIMEOUT + 1) * NSEC_PER_SEC &&
> +	    d->flags & TRIGGER_RESUME_DELAYED) {
> +		pthread_mutex_unlock(&data->mutex);
> +		free(bitmask);
> +		return;
> +	} else if (d->flags & TRIGGER_RESUME_ONE) {
> +		copy_first_bit(bitmask, bitmask, bitmask_size);
> +	} else if (d->flags & TRIGGER_RESUME_DSS) {
> +		uint64_t *event = (uint64_t *)att->bitmask;
> +		uint64_t *resume = (uint64_t *)bitmask;
> +
> +		memset(bitmask, 0, bitmask_size);
> +		for (i = 0; i < att->bitmask_size / sizeof(uint64_t); i++) {
> +			if (!event[i])
> +				continue;
> +
> +			resume[i] = event[i];
> +			break;
> +		}
> +	} else if (d->flags & TRIGGER_RESUME_SET_BP) {
> +		set_breakpoint_once(d, data);
> +	}
> +
> +	if (d->flags & SHADER_LOOP) {
> +		uint32_t threads = get_number_of_threads(d->flags);
> +		uint32_t val = STEERING_END_LOOP;
> +
> +		igt_assert_eq(pwrite(data->vm_fd, &val, sizeof(uint32_t),
> +				     data->target_offset + steering_offset(threads)),
> +			      sizeof(uint32_t));
> +		fsync(data->vm_fd);
> +	}
> +	pthread_mutex_unlock(&data->mutex);
> +
> +	data->last_eu_control_seqno = eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
> +						    att->exec_queue_handle, att->lrc_handle,
> +						    bitmask, att->bitmask_size);
> +
> +	is_client_resumed = 1;
> +	free(bitmask);
> +}
> +
> +static void eu_attention_resume_single_step_trigger(struct xe_eudebug_debugger *d,
> +						    struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
> +	struct online_debug_data *data = d->ptr;
> +	const int threads = get_number_of_threads(d->flags);
> +	uint32_t val;
> +	size_t sz = sizeof(uint32_t);
> +
> +	get_aips_offset_table(data, threads);
> +
> +	if (d->flags & TRIGGER_RESUME_PARALLEL_WALK) {
> +		if (data->stepped_threads_count != -1)
> +			if (data->steps_done < SINGLE_STEP_COUNT) {
> +				int stepped_threads_count_after_resume =
> +						get_stepped_threads_count(data, threads);
> +				igt_debug("Stepped threads after: %d\n",
> +					  stepped_threads_count_after_resume);
> +
> +				if (stepped_threads_count_after_resume == threads) {
> +					data->first_aip += 0x10;
> +					data->steps_done++;
> +				}
> +
> +				igt_debug("Shader steps: %d\n", data->steps_done);
> +				igt_assert(data->stepped_threads_count == 0);
> +				igt_assert(stepped_threads_count_after_resume == threads);
> +			}
> +
> +		if (data->steps_done < SINGLE_STEP_COUNT) {
> +			data->stepped_threads_count = get_stepped_threads_count(data, threads);
> +			igt_debug("Stepped threads before: %d\n", data->stepped_threads_count);
> +		}
> +
> +		val = data->steps_done < SINGLE_STEP_COUNT ? STEERING_SINGLE_STEP :
> +							     STEERING_CONTINUE;
> +	} else if (d->flags & TRIGGER_RESUME_SINGLE_WALK) {
> +		if (data->stepped_threads_count != -1)
> +			if (data->steps_done < 2) {
> +				int stepped_threads_count_after_resume =
> +						get_stepped_threads_count(data, threads);
> +				igt_debug("Stepped threads after: %d\n",
> +					  stepped_threads_count_after_resume);
> +
> +				if (stepped_threads_count_after_resume == threads) {
> +					data->first_aip += 0x10;
> +					data->steps_done++;
> +					free(data->single_step_bitmask);
> +					data->single_step_bitmask = 0;
> +				}
> +
> +				igt_debug("Shader steps: %d\n", data->steps_done);
> +				igt_assert(data->stepped_threads_count +
> +					   (intel_gen_needs_resume_wa(d->master_fd) ? 2 : 1) ==
> +					   stepped_threads_count_after_resume);
> +			}
> +
> +		if (data->steps_done < 2) {
> +			data->stepped_threads_count = get_stepped_threads_count(data, threads);
> +			igt_debug("Stepped threads before: %d\n", data->stepped_threads_count);
> +			if (intel_gen_needs_resume_wa(d->master_fd)) {
> +				if (!data->single_step_bitmask) {
> +					data->single_step_bitmask = malloc(att->bitmask_size *
> +									   sizeof(uint8_t));
> +					igt_assert(data->single_step_bitmask);
> +					memcpy(data->single_step_bitmask, att->bitmask,
> +					       att->bitmask_size);
> +				}
> +
> +				copy_first_bit(att->bitmask, data->single_step_bitmask,
> +					       att->bitmask_size);
> +			} else
> +				copy_nth_bit(att->bitmask, att->bitmask, att->bitmask_size,
> +					     data->stepped_threads_count + 1);
> +		}
> +
> +		val = data->steps_done < 2 ? STEERING_SINGLE_STEP : STEERING_CONTINUE;
> +	}
> +
> +	igt_assert_eq(pwrite(data->vm_fd, &val, sz,
> +			     data->target_offset + steering_offset(threads)), sz);
> +	fsync(data->vm_fd);
> +
> +	eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
> +		      att->exec_queue_handle, att->lrc_handle,
> +		      att->bitmask, att->bitmask_size);
> +
> +	if (data->single_step_bitmask)
> +		for (int i = 0; i < att->bitmask_size; i++)
> +			data->single_step_bitmask[i] &= ~att->bitmask[i];
> +}
> +
> +static void open_trigger(struct xe_eudebug_debugger *d,
> +			 struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_client *client = (void *)e;
> +	struct online_debug_data *data = d->ptr;
> +
> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> +		return;
> +
> +	pthread_mutex_lock(&data->mutex);
> +	data->client_handle = client->client_handle;
> +	pthread_mutex_unlock(&data->mutex);
> +}
> +
> +static void exec_queue_trigger(struct xe_eudebug_debugger *d,
> +			       struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_exec_queue *eq = (void *)e;
> +	struct online_debug_data *data = d->ptr;
> +
> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> +		return;
> +
> +	pthread_mutex_lock(&data->mutex);
> +	data->exec_queue_handle = eq->exec_queue_handle;
> +	data->lrc_handle = eq->lrc_handle[0];
> +	pthread_mutex_unlock(&data->mutex);
> +}
> +
> +static void vm_open_trigger(struct xe_eudebug_debugger *d,
> +			    struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_vm *vm = (void *)e;
> +	struct online_debug_data *data = d->ptr;
> +	struct drm_xe_eudebug_vm_open vo = {
> +		.client_handle = vm->client_handle,
> +		.vm_handle = vm->vm_handle,
> +	};
> +	int fd;
> +
> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> +		fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
> +		igt_assert_lte(0, fd);
> +
> +		pthread_mutex_lock(&data->mutex);
> +		igt_assert(data->vm_fd == -1);
> +		data->vm_fd = fd;
> +		pthread_mutex_unlock(&data->mutex);
> +		return;
> +	}
> +
> +	pthread_mutex_lock(&data->mutex);
> +	close(data->vm_fd);
> +	data->vm_fd = -1;
> +	pthread_mutex_unlock(&data->mutex);
> +}
> +
> +static void read_metadata(struct xe_eudebug_debugger *d,
> +			  uint64_t client_handle,
> +			  uint64_t metadata_handle,
> +			  uint64_t type,
> +			  uint64_t len)
> +{
> +	struct drm_xe_eudebug_read_metadata rm = {
> +		.client_handle = client_handle,
> +		.metadata_handle = metadata_handle,
> +		.size = len,
> +	};
> +	struct online_debug_data *data = d->ptr;
> +	uint64_t *metadata;
> +
> +	metadata = malloc(len);
> +	igt_assert(metadata);
> +
> +	rm.ptr = to_user_pointer(metadata);
> +	igt_assert_eq(igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0);
> +
> +	pthread_mutex_lock(&data->mutex);
> +	switch (type) {
> +	case DRM_XE_DEBUG_METADATA_ELF_BINARY:
> +		data->bb_offset = metadata[0];
> +		data->bb_size = metadata[1];
> +		break;
> +	case DRM_XE_DEBUG_METADATA_PROGRAM_MODULE:
> +		data->target_offset = metadata[0];
> +		data->target_size = metadata[1];
> +		break;
> +	default:
> +		break;
> +	}
> +	pthread_mutex_unlock(&data->mutex);
> +
> +	free(metadata);
> +}
> +
> +static void create_metadata_trigger(struct xe_eudebug_debugger *d, struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_metadata *em = (void *)e;
> +
> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> +		read_metadata(d, em->client_handle, em->metadata_handle, em->type, em->len);
> +	}
> +}
> +
> +static void overwrite_immediate_value_in_common_target_write(int vm_fd, uint64_t offset,
> +							     uint32_t old_val, uint32_t new_val)
> +{
> +	uint64_t addr = offset;
> +	int vals_changed = 0;
> +	uint32_t val;
> +
> +	while (vals_changed < 4) {
> +		igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr), sizeof(uint32_t));
> +		if (val == old_val) {
> +			igt_debug("val_before_write[%d]: %08x\n", vals_changed, val);
> +			igt_assert_eq(pwrite(vm_fd, &new_val, sizeof(uint32_t), addr),
> +				      sizeof(uint32_t));
> +			igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr),
> +				      sizeof(uint32_t));
> +			igt_debug("val_before_fsync[%d]: %08x\n", vals_changed, val);
> +			fsync(vm_fd);
> +			igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr),
> +				      sizeof(uint32_t));
> +			igt_debug("val_after_fsync[%d]: %08x\n", vals_changed, val);
> +			igt_assert_eq_u32(val, new_val);
> +			vals_changed++;
> +		}
> +		addr += sizeof(uint32_t);
> +	}
> +}
> +
> +static void eu_attention_resume_caching_trigger(struct xe_eudebug_debugger *d,
> +						struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
> +	struct online_debug_data *data = d->ptr;
> +	static int counter = 0;
> +	static int kernel_in_bb = 0;
> +	struct dim_t s_dim = surface_dimensions(get_number_of_threads(d->flags));
> +	int val;
> +	uint32_t instr_usdw;
> +	struct gpgpu_shader *kernel;
> +	const uint32_t breakpoint_bit = 1 << 30;
> +	struct gpgpu_shader *shader_preamble;
> +	struct gpgpu_shader *shader_write_instr;
> +
> +	shader_preamble = gpgpu_shader_create(d->master_fd);
> +	gpgpu_shader__write_dword(shader_preamble, SHADER_CANARY, 0);
> +	gpgpu_shader__nop(shader_preamble);
> +	gpgpu_shader__breakpoint(shader_preamble);
> +
> +	shader_write_instr = gpgpu_shader_create(d->master_fd);
> +	gpgpu_shader__common_target_write_u32(shader_write_instr, 0, 0);
> +
> +	if (!kernel_in_bb) {
> +		kernel = get_shader(d->master_fd, d->flags);
> +		kernel_in_bb = find_kernel_in_bb(kernel, data);
> +		gpgpu_shader_destroy(kernel);
> +	}
> +
> +	/* set breakpoint on next write instruction */
> +	if (counter < caching_get_instruction_count(d->master_fd, s_dim.x, d->flags)) {
> +		igt_assert_eq(pread(data->vm_fd, &instr_usdw, sizeof(instr_usdw),
> +				    data->bb_offset + kernel_in_bb + shader_preamble->size * 4 +
> +				    shader_write_instr->size * 4 * counter), sizeof(instr_usdw));
> +		instr_usdw |= breakpoint_bit;
> +		igt_assert_eq(pwrite(data->vm_fd, &instr_usdw, sizeof(instr_usdw),
> +				     data->bb_offset + kernel_in_bb + shader_preamble->size * 4 +
> +				     shader_write_instr->size * 4 * counter), sizeof(instr_usdw));
> +		fsync(data->vm_fd);
> +	}
> +
> +	/* restore current instruction */
> +	if (counter && counter <= caching_get_instruction_count(d->master_fd, s_dim.x, d->flags))
> +		overwrite_immediate_value_in_common_target_write(data->vm_fd,
> +								 data->bb_offset + kernel_in_bb +
> +								 shader_preamble->size * 4 +
> +								 shader_write_instr->size * 4 * (counter - 1),
> +								 CACHING_POISON_VALUE,
> +								 CACHING_VALUE(counter - 1));
> +
> +	/* poison next instruction */
> +	if (counter < caching_get_instruction_count(d->master_fd, s_dim.x, d->flags))
> +		overwrite_immediate_value_in_common_target_write(data->vm_fd,
> +								 data->bb_offset + kernel_in_bb +
> +								 shader_preamble->size * 4 +
> +								 shader_write_instr->size * 4 * counter,
> +								 CACHING_VALUE(counter),
> +								 CACHING_POISON_VALUE);
> +
> +	gpgpu_shader_destroy(shader_write_instr);
> +	gpgpu_shader_destroy(shader_preamble);
> +
> +	for (int i = 0; i < data->target_size; i += sizeof(uint32_t)) {
> +		igt_assert_eq(pread(data->vm_fd, &val, sizeof(val), data->target_offset + i),
> +			      sizeof(val));
> +		igt_assert_f(val != CACHING_POISON_VALUE, "Poison value found at %04d!\n", i);
> +	}
> +
> +	eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
> +		      att->exec_queue_handle, att->lrc_handle,
> +		      att->bitmask, att->bitmask_size);
> +
> +	counter++;
> +}
> +
> +static struct intel_bb *xe_bb_create_on_offset(int fd, uint32_t exec_queue, uint32_t vm,
> +					       uint64_t offset, uint32_t size)
> +{
> +	struct intel_bb *ibb;
> +
> +	ibb = intel_bb_create_with_context(fd, exec_queue, vm, NULL, size);
> +
> +	/* update intel bb offset */
> +	intel_bb_remove_object(ibb, ibb->handle, ibb->batch_offset, ibb->size);
> +	intel_bb_add_object(ibb, ibb->handle, ibb->size, offset, ibb->alignment, false);
> +	ibb->batch_offset = offset;
> +
> +	return ibb;
> +}
> +
> +static size_t get_bb_size(int flags)
> +{
> +	if ((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM))
> +		return 32768;
> +
> +	return 4096;
> +}
> +
> +static void run_online_client(struct xe_eudebug_client *c)
> +{
> +	int threads = get_number_of_threads(c->flags);
> +	const uint64_t target_offset = 0x1a000000;
> +	const uint64_t bb_offset = 0x1b000000;
> +	const size_t bb_size = get_bb_size(c->flags);
> +	struct online_debug_data *data = c->ptr;
> +	struct drm_xe_engine_class_instance hwe = data->hwe;
> +	struct drm_xe_ext_set_property ext = {
> +		.base.name = DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
> +		.property = DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG,
> +		.value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE,
> +	};
> +	struct drm_xe_exec_queue_create create = {
> +		.instances = to_user_pointer(&hwe),
> +		.width = 1,
> +		.num_placements = 1,
> +		.extensions = c->flags & DISABLE_DEBUG_MODE ? 0 : to_user_pointer(&ext)
> +	};
> +	struct dim_t w_dim = walker_dimensions(threads);
> +	struct dim_t s_dim = surface_dimensions(threads);
> +	struct timespec ts = { };
> +	struct gpgpu_shader *sip, *shader;
> +	uint32_t metadata_id[2];
> +	uint64_t *metadata[2];
> +	struct intel_bb *ibb;
> +	struct intel_buf *buf;
> +	uint32_t *ptr;
> +	int fd;
> +
> +	metadata[0] = calloc(2, sizeof(*metadata));
> +	metadata[1] = calloc(2, sizeof(*metadata));
> +	igt_assert(metadata[0]);
> +	igt_assert(metadata[1]);
> +
> +	fd = xe_eudebug_client_open_driver(c);
> +	xe_device_get(fd);
> +
> +	/* Additional memory for steering control */
> +	if (c->flags & SHADER_LOOP || c->flags & SHADER_SINGLE_STEP)
> +		s_dim.y++;
> +	/* Additional memory for caching check */
> +	if ((c->flags & SHADER_CACHING_SRAM) || (c->flags & SHADER_CACHING_VRAM))
> +		s_dim.y += caching_get_instruction_count(fd, s_dim.x, c->flags);
> +	buf = create_uc_buf(fd, s_dim.x, s_dim.y);
> +
> +	buf->addr.offset = target_offset;
> +
> +	metadata[0][0] = bb_offset;
> +	metadata[0][1] = bb_size;
> +	metadata[1][0] = target_offset;
> +	metadata[1][1] = buf->size;
> +	metadata_id[0] = xe_eudebug_client_metadata_create(c, fd, DRM_XE_DEBUG_METADATA_ELF_BINARY,
> +							   2 * sizeof(*metadata), metadata[0]);
> +	metadata_id[1] = xe_eudebug_client_metadata_create(c, fd,
> +							   DRM_XE_DEBUG_METADATA_PROGRAM_MODULE,
> +							   2 * sizeof(*metadata), metadata[1]);
> +
> +	create.vm_id = xe_eudebug_client_vm_create(c, fd, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
> +	xe_eudebug_client_exec_queue_create(c, fd, &create);
> +
> +	ibb = xe_bb_create_on_offset(fd, create.exec_queue_id, create.vm_id,
> +				     bb_offset, bb_size);
> +	intel_bb_set_lr_mode(ibb, true);
> +
> +	sip = get_sip(fd, c->flags);
> +	shader = get_shader(fd, c->flags);
> +
> +	igt_nsec_elapsed(&ts);
> +	gpgpu_shader_exec(ibb, buf, w_dim.x, w_dim.y, shader, sip, 0, 0);
> +
> +	gpgpu_shader_destroy(sip);
> +	gpgpu_shader_destroy(shader);
> +
> +	intel_bb_sync(ibb);
> +
> +	if (c->flags & TRIGGER_RECONNECT)
> +		xe_eudebug_client_wait_stage(c, DEBUGGER_REATTACHED);
> +	else
> +		/* Make sure it wasn't the timeout. */
> +		igt_assert(igt_nsec_elapsed(&ts) <
> +			   XE_EUDEBUG_DEFAULT_TIMEOUT_MS / MSEC_PER_SEC * NSEC_PER_SEC);
> +
> +	if (!(c->flags & DO_NOT_EXPECT_CANARIES)) {
> +		ptr = xe_bo_mmap_ext(fd, buf->handle, buf->size, PROT_READ);
> +		data->threads_count = count_canaries_neq(ptr, w_dim, 0);
> +		igt_assert_f(data->threads_count, "No canaries found, nothing executed?\n");
> +
> +		if ((c->flags & SHADER_BREAKPOINT || c->flags & TRIGGER_RESUME_SET_BP ||
> +		     c->flags & SHADER_N_NOOP_BREAKPOINT) && !(c->flags & DISABLE_DEBUG_MODE)) {
> +			uint32_t aip = ptr[0];
> +
> +			igt_assert_f(aip != SHADER_CANARY, "Workload executed but breakpoint not hit!\n");
> +			igt_assert_eq(count_canaries_eq(ptr, w_dim, aip), data->threads_count);
> +			igt_debug("Breakpoint hit in %d threads, AIP=0x%08x\n", data->threads_count, aip);
> +		}
> +
> +		munmap(ptr, buf->size);
> +	}
> +
> +	intel_bb_destroy(ibb);
> +
> +	xe_eudebug_client_exec_queue_destroy(c, fd, &create);
> +	xe_eudebug_client_vm_destroy(c, fd,  create.vm_id);
> +
> +	xe_eudebug_client_metadata_destroy(c, fd, metadata_id[0], DRM_XE_DEBUG_METADATA_ELF_BINARY,
> +					   2 * sizeof(*metadata));
> +	xe_eudebug_client_metadata_destroy(c, fd, metadata_id[1],
> +					   DRM_XE_DEBUG_METADATA_PROGRAM_MODULE,
> +					   2 * sizeof(*metadata));
> +
> +	xe_device_put(fd);
> +	xe_eudebug_client_close_driver(c, fd);
> +}
> +
> +static bool intel_gen_has_lockstep_eus(int fd)
> +{
> +	const uint32_t id = intel_get_drm_devid(fd);
> +
> +	/*
> +	 * Lockstep (or in some parlance, fused) EUs are pair of EUs
> +	 * that work in sync, supposedly same clock and same control flow.
> +	 * Thus for attentions, if the control has breakpoint, both will be
> +	 * excepted into SIP. In this level, the hardware has only one attention
> +	 * thread bit for units. PVC is the first one without lockstepping.
> +	 */
> +	return !(intel_graphics_ver(id) == IP_VER(12, 60) || intel_gen(id) >= 20);
> +}
> +
> +static int query_attention_bitmask_size(int fd, int gt)
> +{
> +	const unsigned int threads = 8;
> +	struct drm_xe_query_topology_mask *c_dss = NULL, *g_dss = NULL, *eu_per_dss = NULL;
> +	struct drm_xe_query_topology_mask *topology;
> +	struct drm_xe_device_query query = {
> +		.extensions = 0,
> +		.query = DRM_XE_DEVICE_QUERY_GT_TOPOLOGY,
> +		.size = 0,
> +		.data = 0,
> +	};
> +	int pos = 0, eus;
> +	uint8_t *any_dss;
> +
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEVICE_QUERY, &query), 0);
> +	igt_assert_neq(query.size, 0);
> +
> +	topology = malloc(query.size);
> +	igt_assert(topology);
> +
> +	query.data = to_user_pointer(topology);
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEVICE_QUERY, &query), 0);
> +
> +	while (query.size >= sizeof(struct drm_xe_query_topology_mask)) {
> +		struct drm_xe_query_topology_mask *topo;
> +		int sz;
> +
> +		topo = (struct drm_xe_query_topology_mask *)((unsigned char *)topology + pos);
> +		sz = sizeof(struct drm_xe_query_topology_mask) + topo->num_bytes;
> +
> +		query.size -= sz;
> +		pos += sz;
> +
> +		if (topo->gt_id != gt)
> +			continue;
> +
> +		if (topo->type == DRM_XE_TOPO_DSS_GEOMETRY)
> +			g_dss = topo;
> +		else if (topo->type == DRM_XE_TOPO_DSS_COMPUTE)
> +			c_dss = topo;
> +		else if (topo->type == DRM_XE_TOPO_EU_PER_DSS ||
> +			 topo->type == DRM_XE_TOPO_SIMD16_EU_PER_DSS)
> +			eu_per_dss = topo;
> +	}
> +
> +	igt_assert(g_dss && c_dss && eu_per_dss);
> +	igt_assert_eq_u32(c_dss->num_bytes, g_dss->num_bytes);
> +
> +	any_dss = malloc(c_dss->num_bytes);
> +
> +	for (int i = 0; i < c_dss->num_bytes; i++)
> +		any_dss[i] = c_dss->mask[i] | g_dss->mask[i];
> +
> +	eus = count_set_bits(any_dss, c_dss->num_bytes);
> +	eus *= count_set_bits(eu_per_dss->mask, eu_per_dss->num_bytes);
> +
> +	if (intel_gen_has_lockstep_eus(fd))
> +		eus /= 2;
> +
> +	free(any_dss);
> +	free(topology);
> +
> +	return eus * threads / 8;
> +}
> +
> +static struct drm_xe_eudebug_event_exec_queue *
> +match_attention_with_exec_queue(struct xe_eudebug_event_log *log,
> +				struct drm_xe_eudebug_event_eu_attention *ea)
> +{
> +	struct drm_xe_eudebug_event_exec_queue *ee;
> +	struct drm_xe_eudebug_event *event = NULL, *current = NULL, *matching_destroy = NULL;
> +	int lrc_idx;
> +
> +	xe_eudebug_for_each_event(event, log) {
> +		if (event->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE &&
> +		    event->flags == DRM_XE_EUDEBUG_EVENT_CREATE) {
> +			ee = (struct drm_xe_eudebug_event_exec_queue *)event;
> +
> +			if (ee->exec_queue_handle != ea->exec_queue_handle)
> +				continue;
> +
> +			if (ee->client_handle != ea->client_handle)
> +				continue;
> +
> +			for (lrc_idx = 0; lrc_idx < ee->width; lrc_idx++) {
> +				if (ee->lrc_handle[lrc_idx] == ea->lrc_handle)
> +					break;
> +			}
> +
> +			if (lrc_idx >= ee->width) {
> +				igt_debug("No matching lrc handle within matching exec_queue!");
> +				continue;
> +			}
> +
> +			/* event logs are sorted, every found next would not be present. */
> +			if (ea->base.seqno < ee->base.seqno)
> +				break;
> +
> +			/* sanity check whether attention did
> +			 * not appear yet on already destroyed exec_queue
> +			 */
> +			current = event;
> +			xe_eudebug_for_each_event(current, log) {
> +				if (current->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE &&
> +				    current->flags == DRM_XE_EUDEBUG_EVENT_DESTROY) {
> +					uint8_t offset = sizeof(struct drm_xe_eudebug_event);
> +
> +					if (memcmp((uint8_t *)current + offset,
> +						   (uint8_t *)event + offset,
> +						   current->len - offset) == 0) {
> +						matching_destroy = current;
> +					}
> +				}
> +			}
> +
> +			if (!matching_destroy || ea->base.seqno > matching_destroy->seqno)
> +				continue;
> +
> +			return ee;
> +		}
> +	}
> +
> +	return NULL;
> +}
> +
> +static void online_session_check(struct xe_eudebug_session *s, int flags)
> +{
> +	struct drm_xe_eudebug_event_eu_attention *ea = NULL;
> +	struct drm_xe_eudebug_event *event = NULL;
> +	struct online_debug_data *data = s->c->ptr;
> +	bool expect_exception = flags & DISABLE_DEBUG_MODE ? false : true;
> +	int sum = 0;
> +	int bitmask_size;
> +
> +	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_UFENCE);
> +
> +	bitmask_size = query_attention_bitmask_size(s->d->master_fd, data->hwe.gt_id);
> +
> +	xe_eudebug_for_each_event(event, s->d->log) {
> +		if (event->type == DRM_XE_EUDEBUG_EVENT_EU_ATTENTION) {
> +			ea = (struct drm_xe_eudebug_event_eu_attention *)event;
> +
> +			igt_assert(event->flags == DRM_XE_EUDEBUG_EVENT_STATE_CHANGE);
> +			igt_assert_eq(ea->bitmask_size, bitmask_size);
> +			sum += count_set_bits(ea->bitmask, bitmask_size);
> +			igt_assert(match_attention_with_exec_queue(s->d->log, ea));
> +		}
> +	}
> +
> +	/*
> +	 * We can expect attention to sum up only
> +	 * if we have a breakpoint set and we resume all threads always.
> +	 */
> +	if (flags == SHADER_BREAKPOINT)
> +		igt_assert_eq(sum, data->threads_count);
> +
> +	if (expect_exception)
> +		igt_assert(sum > 0);
> +	else
> +		igt_assert(sum == 0);
> +}
> +
> +static void ufence_ack_trigger(struct xe_eudebug_debugger *d,
> +			       struct drm_xe_eudebug_event *e)
> +{
> +	struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e;
> +
> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE)
> +		xe_eudebug_ack_ufence(d->fd, ef);
> +}
> +
> +/**
> + * SUBTEST: basic-breakpoint
> + * Description:
> + *	Check whether KMD sends attention events
> + *	for workload in debug mode stopped on breakpoint.
> + *
> + * SUBTEST: breakpoint-not-in-debug-mode
> + * Description:
> + *	Check whether KMD resets the GPU when it spots an attention
> + *	coming from workload not in debug mode.
> + *
> + * SUBTEST: stopped-thread
> + * Description:
> + *	Hits breakpoint on runalone workload and
> + *	reads attention for fixed time.
> + *
> + * SUBTEST: resume-%s
> + * Description:
> + *	Resumes stopped on a breakpoint workload
> + *	with granularity of %arg[1].
> + *
> + *
> + * arg[1]:
> + *
> + * @one:	one thread
> + * @dss:	threads running on one subslice
> + */
> +static void test_basic_online(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	xe_eudebug_session_run(s);
> +	online_session_check(s, s->flags);
> +
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +/**
> + * SUBTEST: preempt-breakpoint
> + * Description:
> + *	Verify that eu debugger disables preemption timeout to
> + *	prevent reset of workload stopped on breakpoint.
> + */
> +static void test_preemption(int fd, struct drm_xe_engine_class_instance *hwe)
> +{
> +	int flags = SHADER_BREAKPOINT | TRIGGER_RESUME_DELAYED;
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +	struct xe_eudebug_client *other;
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +	other = xe_eudebug_client_create(fd, run_online_client, SHADER_NOP, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
> +	xe_eudebug_debugger_start_worker(s->d);
> +
> +	xe_eudebug_client_start(s->c);
> +	sleep(1); /* make sure s->c starts first */
> +	xe_eudebug_client_start(other);
> +
> +	xe_eudebug_client_wait_done(s->c);
> +	xe_eudebug_client_wait_done(other);
> +
> +	xe_eudebug_debugger_stop_worker(s->d, 1);
> +
> +	xe_eudebug_session_destroy(s);
> +	xe_eudebug_client_destroy(other);
> +
> +	igt_assert_f(data->last_eu_control_seqno != 0,
> +		     "Workload with breakpoint has ended without resume!\n");
> +
> +	online_debug_data_destroy(data);
> +}
> +
> +/**
> + * SUBTEST: reset-with-attention
> + * Description:
> + *	Check whether GPU is usable after resetting with attention raised 
> + *	(stopped on breakpoint) by running the same workload again.
> + */
> +static void test_reset_with_attention_online(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s1, *s2;
> +	struct online_debug_data *data;
> +
> +	data = online_debug_data_create(hwe);
> +	s1 = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s1->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_reset_trigger);
> +	xe_eudebug_debugger_add_trigger(s1->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	xe_eudebug_session_run(s1);
> +	xe_eudebug_session_destroy(s1);
> +
> +	s2 = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +	xe_eudebug_debugger_add_trigger(s2->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_trigger);
> +	xe_eudebug_debugger_add_trigger(s2->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	xe_eudebug_session_run(s2);
> +
> +	online_session_check(s2, s2->flags);
> +
> +	xe_eudebug_session_destroy(s2);
> +	online_debug_data_destroy(data);
> +}
> +
> +/**
> + * SUBTEST: interrupt-all
> + * Description:
> + *	Schedules EU workload which should last about a few seconds, then
> + *	interrupts all threads, checks whether attention event came, and
> + *	resumes stopped threads back.
> + *
> + * SUBTEST: interrupt-all-set-breakpoint
> + * Description:
> + *	Schedules EU workload which should last about a few seconds, then
> + *	interrupts all threads, once attention event come it sets breakpoint on
> + *	the very next instruction and resumes stopped threads back. It expects
> + *	that every thread hits the breakpoint.
> + */
> +static void test_interrupt_all(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +	uint32_t val;
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
> +					open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> +					exec_queue_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
> +					create_metadata_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
> +	xe_eudebug_debugger_start_worker(s->d);
> +	xe_eudebug_client_start(s->c);
> +
> +	/* wait for workload to start */
> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
> +		/* collect needed data from triggers */
> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
> +			continue;
> +
> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
> +			if (val != 0)
> +				break;
> +	}
> +
> +	pthread_mutex_lock(&data->mutex);
> +	igt_assert(data->client_handle != -1);
> +	igt_assert(data->exec_queue_handle != -1);
> +	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
> +			     data->exec_queue_handle, data->lrc_handle);
> +	pthread_mutex_unlock(&data->mutex);
> +
> +	xe_eudebug_client_wait_done(s->c);
> +
> +	xe_eudebug_debugger_stop_worker(s->d, 1);
> +
> +	xe_eudebug_event_log_print(s->d->log, true);
> +	xe_eudebug_event_log_print(s->c->log, true);
> +
> +	online_session_check(s, s->flags);
> +
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +static void reset_debugger_log(struct xe_eudebug_debugger *d)
> +{
> +	unsigned int max_size;
> +	char log_name[80];
> +
> +	/* Don't pull the rug out from under an active debugger */
> +	igt_assert(d->target_pid == 0);
> +
> +	max_size = d->log->max_size;
> +	strncpy(log_name, d->log->name, sizeof(d->log->name) - 1);
> +	log_name[79] = '\0';
> +	xe_eudebug_event_log_destroy(d->log);
> +	d->log = xe_eudebug_event_log_create(log_name, max_size);
> +}
> +
> +/**
> + * SUBTEST: interrupt-other-debuggable
> + * Description:
> + *	Schedules EU workload in runalone mode with never ending loop, while
> + *	it is not under debug, tries to interrupt all threads using the different
> + *	client attached to debugger.
> + *
> + * SUBTEST: interrupt-other
> + * Description:
> + * 	Schedules EU workload with a never ending loop and, while it is not
> + * 	configured for debugging, tries to interrupt all threads using the client
> + * 	attached to debugger.
> + */
> +static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct online_debug_data *data;
> +	struct online_debug_data *debugee_data;
> +	struct xe_eudebug_session *s;
> +	struct xe_eudebug_client *debugee;
> +	int debugee_flags = SHADER_LOOP | DO_NOT_EXPECT_CANARIES;
> +	int val;
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> +					exec_queue_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
> +					create_metadata_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
> +	xe_eudebug_debugger_start_worker(s->d);
> +	xe_eudebug_client_start(s->c);
> +
> +	/* wait for workload to start */
> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
> +			continue;
> +
> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
> +			if (val != 0)
> +				break;
> +	}
> +	igt_assert_f(val != 0, "Workload execution is not yet started\n");
> +
> +	xe_eudebug_debugger_dettach(s->d);
> +	reset_debugger_log(s->d);
> +
> +	debugee_data = online_debug_data_create(hwe);
> +	s->d->ptr = debugee_data;
> +	debugee = xe_eudebug_client_create(fd, run_online_client, debugee_flags, debugee_data);
> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, debugee), 0);
> +	xe_eudebug_client_start(debugee);
> +
> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
> +		if (READ_ONCE(debugee_data->vm_fd) == -1 || READ_ONCE(debugee_data->target_size) == 0)
> +			continue;
> +	}
> +
> +	pthread_mutex_lock(&debugee_data->mutex);
> +	igt_assert(debugee_data->client_handle != -1);
> +	igt_assert(debugee_data->exec_queue_handle != -1);
> +	/* Interrupting the other client should return invalid state
> +	 * as it is running in runalone mode */
> +	igt_assert_eq(__eu_ctl(s->d->fd, debugee_data->client_handle,
> +		       debugee_data->exec_queue_handle, debugee_data->lrc_handle,
> +		       NULL, 0, DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL), -EINVAL);
> +	pthread_mutex_unlock(&debugee_data->mutex);
> +
> +	xe_force_gt_reset_async(s->d->master_fd, debugee_data->hwe.gt_id);
> +
> +	xe_eudebug_client_wait_done(debugee);
> +	xe_eudebug_debugger_stop_worker(s->d, 1);
> +
> +	xe_eudebug_event_log_print(s->d->log, true);
> +	xe_eudebug_event_log_print(debugee->log, true);
> +
> +	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND |
> +				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP |
> +				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
> +
> +	xe_eudebug_client_destroy(debugee);
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +	online_debug_data_destroy(debugee_data);
> +}
> +
> +/**
> + * SUBTEST: tdctl-parameters
> + * Description:
> + *	Schedules EU workload which should last about a few seconds, then
> + *	checks negative scenarios of EU_THREADS ioctl usage, interrupts all threads,
> + *	checks whether attention event came, and resumes stopped threads back.
> + */
> +static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +	uint32_t val;
> +	uint32_t random_command;
> +	uint32_t bitmask_size = query_attention_bitmask_size(fd, hwe->gt_id);
> +	uint8_t *attention_bitmask = malloc(bitmask_size * sizeof(uint8_t));
> +	igt_assert(attention_bitmask);
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
> +					open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> +					exec_queue_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
> +					create_metadata_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
> +	xe_eudebug_debugger_start_worker(s->d);
> +	xe_eudebug_client_start(s->c);
> +
> +	/* wait for workload to start */
> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
> +		/* collect needed data from triggers */
> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
> +			continue;
> +
> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
> +			if (val != 0)
> +				break;
> +	}
> +
> +	pthread_mutex_lock(&data->mutex);
> +	igt_assert(data->client_handle != -1);
> +	igt_assert(data->exec_queue_handle != -1);
> +	igt_assert(data->lrc_handle != -1);
> +
> +	/* fail on invalid lrc_handle */
> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
> +			    data->exec_queue_handle, data->lrc_handle + 1,
> +			    attention_bitmask, &bitmask_size,
> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
> +
> +	/* fail on invalid exec_queue_handle */
> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
> +			    data->exec_queue_handle + 1, data->lrc_handle,
> +			    attention_bitmask, &bitmask_size,
> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
> +
> +	/* fail on invalid client */
> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle + 1,
> +			    data->exec_queue_handle, data->lrc_handle,
> +			    attention_bitmask, &bitmask_size,
> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
> +
> +	/*
> +	 * bitmask size must be aligned to sizeof(u32) for all commands
> +	 * and be zero for interrupt all
> +	 */
> +	bitmask_size = sizeof(uint32_t) - 1;
> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
> +			    data->exec_queue_handle, data->lrc_handle,
> +			    attention_bitmask, &bitmask_size,
> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED, NULL) == -EINVAL);
> +	bitmask_size = 0;
> +
> +	/* fail on invalid command */
> +	random_command = random() | (DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME + 1);
> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
> +			    data->exec_queue_handle, data->lrc_handle,
> +			    attention_bitmask, &bitmask_size, random_command, NULL) == -EINVAL);
> +
> +	free(attention_bitmask);
> +
> +	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
> +			     data->exec_queue_handle, data->lrc_handle);
> +	pthread_mutex_unlock(&data->mutex);
> +
> +	xe_eudebug_client_wait_done(s->c);
> +
> +	xe_eudebug_debugger_stop_worker(s->d, 1);
> +
> +	xe_eudebug_event_log_print(s->d->log, true);
> +	xe_eudebug_event_log_print(s->c->log, true);
> +
> +	online_session_check(s, s->flags);
> +
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +static void eu_attention_debugger_detach_trigger(struct xe_eudebug_debugger *d,
> +						 struct drm_xe_eudebug_event *event)
> +{
> +	struct online_debug_data *data = d->ptr;
> +	uint64_t c_pid;
> +	int ret;
> +
> +	c_pid = d->target_pid;
> +
> +	/* Reset VM data so the re-triggered VM open handler works properly */
> +	data->vm_fd = -1;
> +
> +	xe_eudebug_debugger_dettach(d);
> +
> +	/* Let the KMD scan function notice unhandled EU attention */
> +	if (!(d->flags & SHADER_N_NOOP_BREAKPOINT))
> +		sleep(1);
> +
> +	/*
> +	 * New session that is created by EU debugger on reconnect restarts
> +	 * seqno, causing isses with log sorting. To avoid that, create
> +	 * a new event log.
> +	 */
> +	reset_debugger_log(d);
> +
> +	ret = xe_eudebug_connect(d->master_fd, c_pid, 0);
> +	igt_assert(ret >= 0);
> +	d->fd = ret;
> +	d->target_pid = c_pid;
> +
> +	/* Let the discovery worker discover resources */
> +	sleep(2);
> +
> +	if (!(d->flags & SHADER_N_NOOP_BREAKPOINT))
> +		xe_eudebug_debugger_signal_stage(d, DEBUGGER_REATTACHED);
> +}
> +
> +/**
> + * SUBTEST: interrupt-reconnect
> + * Description:
> + *	Schedules EU workload which should last about a few seconds,
> + *	interrupts all threads and detaches debugger when attention is
> + *	raised. The test checks if KMD resets the workload when there's
> + *	no debugger attached and does the event playback on discovery.
> + */
> +static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct drm_xe_eudebug_event *e = NULL;
> +	struct online_debug_data *data;
> +	struct xe_eudebug_session *s;
> +	uint32_t val;
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
> +					open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> +					exec_queue_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debugger_detach_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
> +					create_metadata_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
> +	xe_eudebug_debugger_start_worker(s->d);
> +	xe_eudebug_client_start(s->c);
> +
> +	/* wait for workload to start */
> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
> +		/* collect needed data from triggers */
> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
> +			continue;
> +
> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
> +			if (val != 0)
> +				break;
> +	}
> +
> +	pthread_mutex_lock(&data->mutex);
> +	igt_assert(data->client_handle != -1);
> +	igt_assert(data->exec_queue_handle != -1);
> +	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
> +			     data->exec_queue_handle, data->lrc_handle);
> +	pthread_mutex_unlock(&data->mutex);
> +
> +	xe_eudebug_client_wait_done(s->c);
> +
> +	xe_eudebug_debugger_stop_worker(s->d, 1);
> +
> +	xe_eudebug_event_log_print(s->d->log, true);
> +	xe_eudebug_event_log_print(s->c->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_UFENCE);
> +
> +	/* We expect workload reset, so no attention should be raised */
> +	xe_eudebug_for_each_event(e, s->d->log)
> +		igt_assert(e->type != DRM_XE_EUDEBUG_EVENT_EU_ATTENTION);
> +
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +/**
> + * SUBTEST: single-step
> + * Description:
> + *	Schedules EU workload with 16 nops after breakpoint, then single-steps
> + *	through the shader, advances all threads each step, checking if all
> + *	threads advanced every step.
> + *
> + * SUBTEST: single-step-one
> + * Description:
> + *	Schedules EU workload with 16 nops after breakpoint, then single-steps
> + *	through the shader, advances one thread each step, checking if one
> + *	thread advanced every step. Due to the time constraint, only first two
> + *	shader instructions after breakpoint are validated.
> + */
> +static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
> +					open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_single_step_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
> +					create_metadata_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	xe_eudebug_session_run(s);
> +	online_session_check(s, s->flags);
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +static void eu_attention_debugger_ndetach_trigger(struct xe_eudebug_debugger *d,
> +						 struct drm_xe_eudebug_event *event)
> +{
> +	static int debugger_detach_count;
> +
> +	if (debugger_detach_count < (SHADER_LOOP_N - 1)) {
> +		/* Make sure the resume command has issued before detaching the debugger */
> +		if (!is_client_resumed)
> +			return;
Not sure what we are trying to achieve here. I think triggers are executed in the same order as
added, so this should be ensured. But anyway, I think we could just resue data-
>last_eu_control_seqno. If its greater than seqno of this event we are free to reattach.

Regards,
Dominik

> +		eu_attention_debugger_detach_trigger(d, event);
> +		debugger_detach_count++;
> +	} else {
> +		igt_debug("Reached Nth breakpoint hence preventing the debugger detach\n");
> +	}
> +	is_client_resumed = 0;
> +}
> +
> +/**
> + * SUBTEST: debugger-reopen
> + * Description:
> + *	Check whether the debugger is able to reopen the connection and
> + *	capture the events of already running client.
> + */
> +static void test_debugger_reopen(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +
> +	data = online_debug_data_create(hwe);
> +
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debugger_ndetach_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	xe_eudebug_session_run(s);
> +
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +/**
> + * SUBTEST: writes-caching-%s
> + * Description:
> + *	Write incrementing values to 2-page-long target surface, poisoning the data one breakpoint
> + *	before each write instruction and restoring it when the poisoned instruction breakpoint
> + *	is hit. Expect to never see poison values in target surface.
> + *
> + *
> + * arg[1]:
> + *
> + * @sram:	Use page size of SRAM
> + * @vram:	Use page size of VRAM
> + */
> +static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
> +{
> +	struct xe_eudebug_session *s;
> +	struct online_debug_data *data;
> +
> +	if (flags & SHADER_CACHING_VRAM)
> +		igt_skip_on_f(!xe_has_vram(fd), "Device does not have VRAM.\n");
> +
> +	data = online_debug_data_create(hwe);
> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
> +
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
> +					open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_debug_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +					eu_attention_resume_caching_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
> +					create_metadata_trigger);
> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +					ufence_ack_trigger);
> +
> +	xe_eudebug_session_run(s);
> +	online_session_check(s, s->flags);
> +	xe_eudebug_session_destroy(s);
> +	online_debug_data_destroy(data);
> +}
> +
> +static int wait_for_exception(struct online_debug_data *data, int timeout)
> +{
> +	int ret = -ETIMEDOUT;
> +
> +	igt_for_milliseconds(timeout) {
> +		pthread_mutex_lock(&data->mutex);
> +		if ((data->exception_arrived.tv_sec |
> +		     data->exception_arrived.tv_nsec) != 0)
> +			ret = 0;
> +		pthread_mutex_unlock(&data->mutex);
> +
> +		if (!ret)
> +			break;
> +		usleep(1000);
> +	}
> +
> +	return ret;
> +}
> +
> +#define is_compute_on_gt(__e, __gt) ((__e->engine_class == DRM_XE_ENGINE_CLASS_RENDER || \
> +				      __e->engine_class == DRM_XE_ENGINE_CLASS_COMPUTE) && \
> +				      __e->gt_id == __gt)
> +
> +struct xe_engine_list_entry {
> +	struct igt_list_head link;
> +	struct drm_xe_engine_class_instance *hwe;
> +};
> +
> +#define MAX_TILES	2
> +static int find_suitable_engines(struct drm_xe_engine_class_instance *hwes[GEM_MAX_ENGINES],
> +				 int fd, bool many_tiles)
> +{
> +	struct xe_device *xe_dev;
> +	struct drm_xe_engine_class_instance *e;
> +	struct xe_engine_list_entry *en, *tmp;
> +	struct igt_list_head compute_engines[MAX_TILES];
> +	int gt_id;
> +	int tile_id, i, engine_count = 0, tile_count = 0;
> +
> +	xe_dev = xe_device_get(fd);
> +
> +	for (i = 0; i < MAX_TILES; i++)
> +		IGT_INIT_LIST_HEAD(&compute_engines[i]);
> +
> +	xe_for_each_gt(fd, gt_id) {
> +		xe_for_each_engine(fd, e) {
> +			if (is_compute_on_gt(e, gt_id)) {
> +				tile_id = xe_dev->gt_list->gt_list[gt_id].tile_id;
> +
> +				en = malloc(sizeof(struct xe_engine_list_entry));
> +				en->hwe = e;
> +
> +				igt_list_add_tail(&en->link, &compute_engines[tile_id]);
> +			}
> +		}
> +	}
> +
> +	for (i = 0; i < MAX_TILES; i++) {
> +		if (igt_list_empty(&compute_engines[i]))
> +			continue;
> +
> +		if (many_tiles) {
> +			en = igt_list_first_entry(&compute_engines[i], en, link);
> +			hwes[engine_count++] = en->hwe;
> +			tile_count++;
> +		} else {
> +			if (igt_list_length(&compute_engines[i]) > 1) {
> +				igt_list_for_each_entry(en, &compute_engines[i], link)
> +					hwes[engine_count++] = en->hwe;
> +				break;
> +			}
> +		}
> +	}
> +
> +	for (i = 0; i < MAX_TILES; i++) {
> +		igt_list_for_each_entry_safe(en, tmp, &compute_engines[i], link) {
> +			igt_list_del(&en->link);
> +			free(en);
> +		}
> +	}
> +
> +	if (many_tiles)
> +		igt_require_f(tile_count > 1, "Mulit-tile scenario requires more tiles\n");
> +
> +	return engine_count;
> +}
> +
> +/**
> + * SUBTEST: breakpoint-many-sessions-single-tile
> + * Description:
> + *	Schedules EU workload with preinstalled breakpoint on every compute engine
> + *	available on the tile. Checks if the contexts hit breakpoint in sequence
> + *	and resumes them.
> + *
> + * SUBTEST: breakpoint-many-sessions-tiles
> + * Description:
> + *	Schedules EU workload with preinstalled breakpoint on selected compute
> + *      engines, with one per tile. Checks if each context hit breakpoint and
> + *      resumes them.
> + */
> +static void test_many_sessions_on_tiles(int fd, bool multi_tile)
> +{
> +	int n = 0, flags = SHADER_BREAKPOINT | SHADER_MIN_THREADS;
> +	struct xe_eudebug_session *s[GEM_MAX_ENGINES] = {};
> +	struct online_debug_data *data[GEM_MAX_ENGINES] = {};
> +	struct drm_xe_engine_class_instance *hwe[GEM_MAX_ENGINES] = {};
> +	struct drm_xe_eudebug_event_eu_attention *eus;
> +	uint64_t current_t, next_t, diff;
> +	int i;
> +
> +	n = find_suitable_engines(hwe, fd, multi_tile);
> +
> +	igt_require_f(n > 1, "Test requires at least two parallel compute engines!\n");
> +
> +	for (i = 0; i < n; i++) {
> +		data[i] = online_debug_data_create(hwe[i]);
> +		s[i] = xe_eudebug_session_create(fd, run_online_client, flags, data[i]);
> +
> +		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +						eu_attention_debug_trigger);
> +		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
> +						save_first_exception_trigger);
> +		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +						ufence_ack_trigger);
> +
> +		igt_assert_eq(xe_eudebug_debugger_attach(s[i]->d, s[i]->c), 0);
> +
> +		xe_eudebug_debugger_start_worker(s[i]->d);
> +		xe_eudebug_client_start(s[i]->c);
> +	}
> +
> +	for (i = 0; i < n; i++) {
> +		/* XXX: Sometimes racy, expects clients to execute in sequence */
> +		igt_assert(!wait_for_exception(data[i], STARTUP_TIMEOUT_MS));
> +
> +		eus = (struct drm_xe_eudebug_event_eu_attention *)data[i]->exception_event;
> +
> +		/* Delay all but the last workload to check serialization */
> +		if (i < n - 1)
> +			usleep(WORKLOAD_DELAY_US);
> +
> +		eu_ctl_resume(s[i]->d->master_fd, s[i]->d->fd,
> +			      eus->client_handle, eus->exec_queue_handle,
> +			      eus->lrc_handle, eus->bitmask, eus->bitmask_size);
> +		free(eus);
> +	}
> +
> +	for (i = 0; i < n - 1; i++) {
> +		/* Convert timestamps to microseconds */
> +		current_t = data[i]->exception_arrived.tv_nsec * 1000;
> +		next_t = data[i + 1]->exception_arrived.tv_nsec * 1000;
> +		diff = current_t < next_t ? next_t - current_t : current_t - next_t;
> +
> +		if (multi_tile)
> +			igt_assert_f(diff < WORKLOAD_DELAY_US,
> +				     "Expected to execute workloads concurrently. Actual delay: %lu ms\n",
> +				     diff);
> +		else
> +			igt_assert_f(diff >= WORKLOAD_DELAY_US,
> +				     "Expected a serialization of workloads. Actual delay: %lu ms\n",
> +				     diff);
> +	}
> +
> +	for (i = 0; i < n; i++) {
> +		xe_eudebug_client_wait_done(s[i]->c);
> +		xe_eudebug_debugger_stop_worker(s[i]->d, 1);
> +
> +		xe_eudebug_event_log_print(s[i]->d->log, true);
> +		online_session_check(s[i], flags);
> +
> +		xe_eudebug_session_destroy(s[i]);
> +		online_debug_data_destroy(data[i]);
> +	}
> +}
> +
> +static struct drm_xe_engine_class_instance *pick_compute(int fd, int gt)
> +{
> +	struct drm_xe_engine_class_instance *hwe;
> +	int count = 0;
> +
> +	xe_for_each_engine(fd, hwe)
> +		if (is_compute_on_gt(hwe, gt))
> +			count++;
> +
> +	xe_for_each_engine(fd, hwe)
> +		if (is_compute_on_gt(hwe, gt) && rand() % count-- == 0)
> +			return hwe;
> +
> +	return NULL;
> +}
> +
> +#define test_gt_render_or_compute(t, i915, __hwe) \
> +	igt_subtest_with_dynamic(t) \
> +		for (int gt = 0; (__hwe = pick_compute(i915, gt)); gt++) \
> +			igt_dynamic_f("%s%d", xe_engine_class_string(__hwe->engine_class), hwe->engine_instance)
> +
> +igt_main
> +{
> +	struct drm_xe_engine_class_instance *hwe;
> +	bool was_enabled;
> +	int fd;
> +
> +	igt_fixture {
> +		fd = drm_open_driver(DRIVER_XE);
> +		intel_allocator_multiprocess_start();
> +		igt_srandom();
> +		was_enabled = xe_eudebug_enable(fd, true);
> +	}
> +
> +	test_gt_render_or_compute("basic-breakpoint", fd, hwe)
> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT);
> +
> +	test_gt_render_or_compute("preempt-breakpoint", fd, hwe)
> +		test_preemption(fd, hwe);
> +
> +	test_gt_render_or_compute("breakpoint-not-in-debug-mode", fd, hwe)
> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | DISABLE_DEBUG_MODE);
> +
> +	test_gt_render_or_compute("stopped-thread", fd, hwe)
> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_DELAYED);
> +
> +	test_gt_render_or_compute("resume-one", fd, hwe)
> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_ONE);
> +
> +	test_gt_render_or_compute("resume-dss", fd, hwe)
> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_DSS);
> +
> +	test_gt_render_or_compute("interrupt-all", fd, hwe)
> +		test_interrupt_all(fd, hwe, SHADER_LOOP);
> +
> +	test_gt_render_or_compute("interrupt-other-debuggable", fd, hwe)
> +		test_interrupt_other(fd, hwe, SHADER_LOOP);
> +
> +	test_gt_render_or_compute("interrupt-other", fd, hwe)
> +		test_interrupt_other(fd, hwe, SHADER_LOOP | DISABLE_DEBUG_MODE);
> +
> +	test_gt_render_or_compute("interrupt-all-set-breakpoint", fd, hwe)
> +		test_interrupt_all(fd, hwe, SHADER_LOOP | TRIGGER_RESUME_SET_BP);
> +
> +	test_gt_render_or_compute("tdctl-parameters", fd, hwe)
> +		test_tdctl_parameters(fd, hwe, SHADER_LOOP);
> +
> +	test_gt_render_or_compute("reset-with-attention", fd, hwe)
> +		test_reset_with_attention_online(fd, hwe, SHADER_BREAKPOINT);
> +
> +	test_gt_render_or_compute("interrupt-reconnect", fd, hwe)
> +		test_interrupt_reconnect(fd, hwe, SHADER_LOOP | TRIGGER_RECONNECT);
> +
> +	test_gt_render_or_compute("single-step", fd, hwe)
> +		test_single_step(fd, hwe, SHADER_SINGLE_STEP | SIP_SINGLE_STEP |
> +				 TRIGGER_RESUME_PARALLEL_WALK);
> +
> +	test_gt_render_or_compute("single-step-one", fd, hwe)
> +		test_single_step(fd, hwe, SHADER_SINGLE_STEP | SIP_SINGLE_STEP |
> +				 TRIGGER_RESUME_SINGLE_WALK);
> +
> +	test_gt_render_or_compute("debugger-reopen", fd, hwe)
> +		test_debugger_reopen(fd, hwe, SHADER_N_NOOP_BREAKPOINT);
> +
> +	test_gt_render_or_compute("writes-caching-sram", fd, hwe)
> +		test_caching(fd, hwe, SHADER_CACHING_SRAM);
> +
> +	test_gt_render_or_compute("writes-caching-vram", fd, hwe)
> +		test_caching(fd, hwe, SHADER_CACHING_VRAM);
> +
> +	igt_subtest("breakpoint-many-sessions-single-tile")
> +		test_many_sessions_on_tiles(fd, false);
> +
> +	igt_subtest("breakpoint-many-sessions-tiles")
> +		test_many_sessions_on_tiles(fd, true);
> +
> +	igt_fixture {
> +		xe_eudebug_enable(fd, was_enabled);
> +
> +		intel_allocator_multiprocess_stop();
> +		drm_close_driver(fd);
> +	}
> +}
> diff --git a/tests/meson.build b/tests/meson.build
> index 35bf8ed35..f18eec7e7 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -280,6 +280,7 @@ intel_xe_progs = [
>  	'xe_debugfs',
>  	'xe_drm_fdinfo',
>  	'xe_eudebug',
> +	'xe_eudebug_online',
>  	'xe_evict',
>  	'xe_evict_ccs',
>  	'xe_exec_atomic',

Re: [PATCH i-g-t v3 07/14] lib/gpgpu_shader: Add write_on_exception template

[Grzegorzek, Dominik]

On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
> From: Andrzej Hajda <andrzej.hajda@intel.com>
> 
> Writing specific value to memory location on unexpected value in exception
> register allows to report errors from inside shader or siplet.
> 
> Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> ---
>  lib/gpgpu_shader.c          | 56 ++++++++++++++++++++++++++
>  lib/gpgpu_shader.h          |  2 +
>  lib/iga64_generated_codes.c | 79 ++++++++++++++++++++++++++++++++++++-
>  3 files changed, 136 insertions(+), 1 deletion(-)
> 
> diff --git a/lib/gpgpu_shader.c b/lib/gpgpu_shader.c
> index 3b16db593..a98abc57e 100644
> --- a/lib/gpgpu_shader.c
> +++ b/lib/gpgpu_shader.c
> @@ -628,6 +628,62 @@ void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
>  	", 2, y_offset, 3, value, value, value, value);
>  }
>  
> +/**
> + * gpgpu_shader__write_on_exception:
> + * @shdr: shader to be modified
> + * @value: dword to be written
> + * @y_offset: write target offset within the surface in rows
> + * @mask: mask to be applied on exception register
> + * @expected: expected value of exception register with @mask applied
> + *
> + * Check if bits specified by @mask in exception register(cr0.1) are equal
> + * to provided ones: cr0.1 & @mask == @expected,
> + * if yes fill dword in (row, column/dword) == (tg_id_y + @y_offset, tg_id_x).
> + */
> +void gpgpu_shader__write_on_exception(struct gpgpu_shader *shdr, uint32_t value,
> +				      uint32_t y_offset, uint32_t mask, uint32_t expected)
> +{
> +	emit_iga64_code(shdr, write_on_exception, "					\n\
> +	// Payload									\n\
> +(W)	mov (1|M0)               r5.0<1>:ud    ARG(3):ud				\n\
> +(W)	mov (1|M0)               r5.1<1>:ud    ARG(4):ud				\n\
> +(W)	mov (1|M0)               r5.2<1>:ud    ARG(5):ud				\n\
> +(W)	mov (1|M0)               r5.3<1>:ud    ARG(6):ud				\n\
> +#if GEN_VER < 2000 // prepare Media Block Write						\n\
> +	// X offset of the block in bytes := (thread group id X << ARG(0))		\n\
> +(W)	shl (1|M0)               r4.0<1>:ud    r0.1<0;1,0>:ud    ARG(0):ud		\n\
> +	// Y offset of the block in rows := thread group id Y				\n\
> +(W)	mov (1|M0)               r4.1<1>:ud    r0.6<0;1,0>:ud				\n\
> +(W)	add (1|M0)               r4.1<1>:ud    r4.1<0;1,0>:ud   ARG(1):ud		\n\
> +	// block width [0,63] representing 1 to 64 bytes				\n\
> +(W)	mov (1|M0)               r4.2<1>:ud    ARG(2):ud				\n\
> +	// FFTID := FFTID from R0 header						\n\
> +(W)	mov (1|M0)               r4.4<1>:ud    r0.5<0;1,0>:ud				\n\
> +#else // prepare Typed 2D Block Store							\n\
> +	// Load r2.0-3 with tg id X << ARG(0)						\n\
> +(W)	shl (1|M0)               r2.0<1>:ud    r0.1<0;1,0>:ud    ARG(0):ud		\n\
> +	// Load r2.4-7 with tg id Y + ARG(1):ud						\n\
> +(W)	mov (1|M0)               r2.1<1>:ud    r0.6<0;1,0>:ud				\n\
> +(W)	add (1|M0)               r2.1<1>:ud    r2.1<0;1,0>:ud    ARG(1):ud		\n\
> +	// payload setup								\n\
> +(W)	mov (16|M0)              r4.0<1>:ud    0x0:ud					\n\

Move r4.0 clearing part before to common code before the if statement like in [1].
For < 2000 we depend on clear r4.0 register. If it was used before, by any different shader, we may
have broken code. 

[1] https://patchwork.freedesktop.org/patch/608230/?series=137284&rev=2

With that, it is:

Reviewed-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> +	// Store X and Y block start (160:191 and 192:223)				\n\
> +(W)	mov (2|M0)               r4.5<1>:ud    r2.0<2;2,1>:ud				\n\
> +	// Store X and Y block max_size (224:231 and 232:239)				\n\
> +(W)	mov (1|M0)               r4.7<1>:ud    ARG(2):ud				\n\
> +#endif											\n\
> +	// Check if masked exception is equal to provided value and write conditionally \n\
> +(W)      and (1|M0)              r3.0<1>:ud     cr0.1<0;1,0>:ud ARG(7):ud		\n\
> +(W)      mov (1|M0)              f0.0<1>:ud     0x0:ud					\n\
> +(W)      cmp (1|M0)     (eq)f0.0 null:ud        r3.0<0;1,0>:ud  ARG(8):ud		\n\
> +#if GEN_VER < 2000 // Media Block Write							\n\
> +(W&f0.0) send.dc1 (16|M0)        null     r4   src1_null 0    0x40A8000			\n\
> +#else // Typed 2D Block Store								\n\
> +(W&f0.0) send.tgm (16|M0)        null     r4   null:0    0    0x64000007		\n\
> +#endif											\n\
> +	", 2, y_offset, 3, value, value, value, value, mask, expected);
> +}
> +
>  /**
>   * gpgpu_shader__end_system_routine:
>   * @shdr: shader to be modified
> diff --git a/lib/gpgpu_shader.h b/lib/gpgpu_shader.h
> index e4ca0be4c..76ff4989e 100644
> --- a/lib/gpgpu_shader.h
> +++ b/lib/gpgpu_shader.h
> @@ -74,6 +74,8 @@ void gpgpu_shader__end_system_routine_step_if_eq(struct gpgpu_shader *shdr,
>  void gpgpu_shader__write_aip(struct gpgpu_shader *shdr, uint32_t y_offset);
>  void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value,
>  			       uint32_t y_offset);
> +void gpgpu_shader__write_on_exception(struct gpgpu_shader *shdr, uint32_t dw,
> +			       uint32_t y_offset, uint32_t mask, uint32_t value);
>  void gpgpu_shader__label(struct gpgpu_shader *shdr, int label_id);
>  void gpgpu_shader__jump(struct gpgpu_shader *shdr, int label_id);
>  void gpgpu_shader__jump_neq(struct gpgpu_shader *shdr, int label_id,
> diff --git a/lib/iga64_generated_codes.c b/lib/iga64_generated_codes.c
> index fea436dee..71429d442 100644
> --- a/lib/iga64_generated_codes.c
> +++ b/lib/iga64_generated_codes.c
> @@ -3,7 +3,7 @@
>  
>  #include "gpgpu_shader.h"
>  
> -#define MD5_SUM_IGA64_ASMS 61a15534954fe7c6bd0e983fbfd54c27
> +#define MD5_SUM_IGA64_ASMS 88529cc180578939c0b8c4bb29da7db6
>  
>  struct iga64_template const iga64_code_end_system_routine_step_if_eq[] = {
>  	{ .gen_ver = 2000, .size = 44, .code = (const uint32_t []) {
> @@ -93,6 +93,83 @@ struct iga64_template const iga64_code_breakpoint_suppress[] = {
>  	}}
>  };
>  
> +struct iga64_template const iga64_code_write_on_exception[] = {
> +	{ .gen_ver = 2000, .size = 68, .code = (const uint32_t []) {
> +		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
> +		0x80000061, 0x05154220, 0x00000000, 0xc0ded004,
> +		0x80000061, 0x05254220, 0x00000000, 0xc0ded005,
> +		0x80000061, 0x05354220, 0x00000000, 0xc0ded006,
> +		0x80000069, 0x02058220, 0x02000014, 0xc0ded000,
> +		0x80000061, 0x02150220, 0x00000064, 0x00000000,
> +		0x80001940, 0x02158220, 0x02000214, 0xc0ded001,
> +		0x80100061, 0x04054220, 0x00000000, 0x00000000,
> +		0x80041a61, 0x04550220, 0x00220205, 0x00000000,
> +		0x80000061, 0x04754220, 0x00000000, 0xc0ded002,
> +		0x80000965, 0x03058220, 0x02008010, 0xc0ded007,
> +		0x80000961, 0x30014220, 0x00000000, 0x00000000,
> +		0x80001a70, 0x00018220, 0x12000304, 0xc0ded008,
> +		0x84134031, 0x00000000, 0xd00e0494, 0x04000000,
> +		0x80000001, 0x00010000, 0x20000000, 0x00000000,
> +		0x80000001, 0x00010000, 0x30000000, 0x00000000,
> +		0x80000901, 0x00010000, 0x00000000, 0x00000000,
> +	}},
> +	{ .gen_ver = 1272, .size = 64, .code = (const uint32_t []) {
> +		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
> +		0x80000061, 0x05154220, 0x00000000, 0xc0ded004,
> +		0x80000061, 0x05254220, 0x00000000, 0xc0ded005,
> +		0x80000061, 0x05354220, 0x00000000, 0xc0ded006,
> +		0x80000069, 0x04058220, 0x02000014, 0xc0ded000,
> +		0x80000061, 0x04150220, 0x00000064, 0x00000000,
> +		0x80001940, 0x04158220, 0x02000414, 0xc0ded001,
> +		0x80000061, 0x04254220, 0x00000000, 0xc0ded002,
> +		0x80000061, 0x04450220, 0x00000054, 0x00000000,
> +		0x80000965, 0x03058220, 0x02008010, 0xc0ded007,
> +		0x80000961, 0x30014220, 0x00000000, 0x00000000,
> +		0x80001a70, 0x00018220, 0x12000304, 0xc0ded008,
> +		0x84134031, 0x00000000, 0xc0000414, 0x02a00000,
> +		0x80000001, 0x00010000, 0x20000000, 0x00000000,
> +		0x80000001, 0x00010000, 0x30000000, 0x00000000,
> +		0x80000901, 0x00010000, 0x00000000, 0x00000000,
> +	}},
> +	{ .gen_ver = 1250, .size = 68, .code = (const uint32_t []) {
> +		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
> +		0x80000061, 0x05254220, 0x00000000, 0xc0ded004,
> +		0x80000061, 0x05454220, 0x00000000, 0xc0ded005,
> +		0x80000061, 0x05654220, 0x00000000, 0xc0ded006,
> +		0x80000069, 0x04058220, 0x02000024, 0xc0ded000,
> +		0x80000061, 0x04250220, 0x000000c4, 0x00000000,
> +		0x80001940, 0x04258220, 0x02000424, 0xc0ded001,
> +		0x80000061, 0x04454220, 0x00000000, 0xc0ded002,
> +		0x80000061, 0x04850220, 0x000000a4, 0x00000000,
> +		0x80000965, 0x03058220, 0x02008020, 0xc0ded007,
> +		0x80000961, 0x30014220, 0x00000000, 0x00000000,
> +		0x80001a70, 0x00018220, 0x12000304, 0xc0ded008,
> +		0x80001a01, 0x00010000, 0x00000000, 0x00000000,
> +		0x81044031, 0x00000000, 0xc0000414, 0x02a00000,
> +		0x80000001, 0x00010000, 0x20000000, 0x00000000,
> +		0x80000001, 0x00010000, 0x30000000, 0x00000000,
> +		0x80000901, 0x00010000, 0x00000000, 0x00000000,
> +	}},
> +	{ .gen_ver = 0, .size = 64, .code = (const uint32_t []) {
> +		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,
> +		0x80000061, 0x05254220, 0x00000000, 0xc0ded004,
> +		0x80000061, 0x05454220, 0x00000000, 0xc0ded005,
> +		0x80000061, 0x05654220, 0x00000000, 0xc0ded006,
> +		0x80000069, 0x04058220, 0x02000024, 0xc0ded000,
> +		0x80000061, 0x04250220, 0x000000c4, 0x00000000,
> +		0x80000140, 0x04258220, 0x02000424, 0xc0ded001,
> +		0x80000061, 0x04454220, 0x00000000, 0xc0ded002,
> +		0x80000061, 0x04850220, 0x000000a4, 0x00000000,
> +		0x80000165, 0x03058220, 0x02008020, 0xc0ded007,
> +		0x80000161, 0x30014220, 0x00000000, 0x00000000,
> +		0x80000270, 0x00018220, 0x12000304, 0xc0ded008,
> +		0x8104a031, 0x00000000, 0xc0000414, 0x02a00000,
> +		0x80000001, 0x00010000, 0x20000000, 0x00000000,
> +		0x80000001, 0x00010000, 0x30000000, 0x00000000,
> +		0x80000101, 0x00010000, 0x00000000, 0x00000000,
> +	}}
> +};
> +
>  struct iga64_template const iga64_code_media_block_write[] = {
>  	{ .gen_ver = 2000, .size = 56, .code = (const uint32_t []) {
>  		0x80000061, 0x05054220, 0x00000000, 0xc0ded003,

Re: [PATCH i-g-t v3 09/14] lib/intel_batchbuffer: Add helper to get pointer at specified offset

[Grzegorzek, Dominik]

On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
> From: Andrzej Hajda <andrzej.hajda@intel.com>
> 
> The helper will be used to access data placed in batchbuffer.
> 
> Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
> Cc: Mika Kuoppala <mika.kuoppala@intel.com>
> Cc: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Acked-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> ---
>  lib/intel_batchbuffer.h | 5 +++++
>  1 file changed, 5 insertions(+)
> 
> diff --git a/lib/intel_batchbuffer.h b/lib/intel_batchbuffer.h
> index cb32206e5..7caf6c518 100644
> --- a/lib/intel_batchbuffer.h
> +++ b/lib/intel_batchbuffer.h
> @@ -353,6 +353,11 @@ static inline uint32_t intel_bb_offset(struct intel_bb *ibb)
>  	return (uint32_t) ((uint8_t *) ibb->ptr - (uint8_t *) ibb->batch);
>  }
>  
> +static inline void *intel_bb_ptr_get(struct intel_bb *ibb, uint32_t offset)
> +{
> +	return ((uint8_t *) ibb->batch + offset);
> +}
> +
>  static inline void intel_bb_ptr_set(struct intel_bb *ibb, uint32_t offset)
>  {
>  	ibb->ptr = (void *) ((uint8_t *) ibb->batch + offset);

Re: [PATCH i-g-t v3 10/14] lib/gpgpu_shader: Allow enabling illegal opcode exceptions in shader

[Grzegorzek, Dominik]

On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
> From: Andrzej Hajda <andrzej.hajda@intel.com>
> 
> Illegal opcode exceptions can be enabled in interface descriptor data
> passed to COMPUTE_WALKER instruction.
> 
> Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
> Cc: Mika Kuoppala <mika.kuoppala@intel.com>
> Cc: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>

Looks good to me:

Reviewed-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> ---
>  lib/gpgpu_shader.c | 4 ++++
>  lib/gpgpu_shader.h | 1 +
>  2 files changed, 5 insertions(+)
> 
> diff --git a/lib/gpgpu_shader.c b/lib/gpgpu_shader.c
> index 40161c52b..e53c61553 100644
> --- a/lib/gpgpu_shader.c
> +++ b/lib/gpgpu_shader.c
> @@ -103,6 +103,7 @@ __xelp_gpgpu_execfunc(struct intel_bb *ibb,
>  		      struct gpgpu_shader *sip,
>  		      uint64_t ring, bool explicit_engine)
>  {
> +	struct gen8_interface_descriptor_data *idd;
>  	uint32_t interface_descriptor, sip_offset;
>  	uint64_t engine;
>  
> @@ -113,6 +114,8 @@ __xelp_gpgpu_execfunc(struct intel_bb *ibb,
>  	interface_descriptor = gen8_fill_interface_descriptor(ibb, target,
>  							      shdr->instr,
>  							      4 * shdr->size);
> +	idd = intel_bb_ptr_get(ibb, interface_descriptor);
> +	idd->desc2.illegal_opcode_exception_enable = shdr->illegal_opcode_exception_enable;
>  
>  	if (sip && sip->size)
>  		sip_offset = fill_sip(ibb, sip->instr, 4 * sip->size);
> @@ -163,6 +166,7 @@ __xehp_gpgpu_execfunc(struct intel_bb *ibb,
>  
>  	xehp_fill_interface_descriptor(ibb, target, shdr->instr,
>  				       4 * shdr->size, &idd);
> +	idd.desc2.illegal_opcode_exception_enable = shdr->illegal_opcode_exception_enable;
>  
>  	if (sip && sip->size)
>  		sip_offset = fill_sip(ibb, sip->instr, 4 * sip->size);
> diff --git a/lib/gpgpu_shader.h b/lib/gpgpu_shader.h
> index 0bbeae66f..26a117a0b 100644
> --- a/lib/gpgpu_shader.h
> +++ b/lib/gpgpu_shader.h
> @@ -22,6 +22,7 @@ struct gpgpu_shader {
>  		uint32_t (*instr)[4];
>  	};
>  	struct igt_map *labels;
> +	bool illegal_opcode_exception_enable;
>  };
>  
>  struct iga64_template {

Re: [PATCH i-g-t v3 13/14] tests/xe_eudebug_online: Debug client which runs workloads on EU

[Manszewski, Christoph]

Hi Kamil,

On 9.08.2024 16:38, Kamil Konieczny wrote:
> Hi Christoph,
> On 2024-08-09 at 14:38:12 +0200, Christoph Manszewski wrote:
>> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>
>> For typical debugging under gdb one can specify two main usecases:
>> accessing and manupulating resources created by the application and
>> manipulating thread execution (interrupting and setting breakpoints).
>>
>> This test adds coverage for the latter by checking that:
>> - EU workloads that hit a instruction with breakpoint bit set will stop
>>    halt execution and the debugger will report this via attention events,
>> - the debugger is able to interrupt workload execution by issuing a
>>    'interrupt_all' ioctl call,
>> - the debugger is able to resume selected workloads that are stopped.
>>
>> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>> Signed-off-by: Mika Kuoppala <mika.kuoppala@intel.com>
>> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
>> Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
>> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
>> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
>> Signed-off-by: Kolanupaka Naveena <kolanupaka.naveena@intel.com>
>> ---
>>   tests/intel/xe_eudebug_online.c | 2203 +++++++++++++++++++++++++++++++
>>   tests/meson.build               |    1 +
>>   2 files changed, 2204 insertions(+)
>>   create mode 100644 tests/intel/xe_eudebug_online.c
> [...cut...]
> 
> Please use checkpatch.pl from linux kernel, watch out for
> whitespace errors, unbalanced braces '{/}' in if...else
> and few other problems.
> 
> A few useful options for checkpatch.pl are in CONTRIBUTE.md

Thanks, I will address these issues in the next revision.

Christoph

> 
> Regards,
> Kamil
> 

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Manszewski, Christoph]

Hi Dominik,

On 19.08.2024 10:30, Grzegorzek, Dominik wrote:
> On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
>> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>
>> Introduce library which simplifies testing of eu debug capability.
>> The library provides event log helpers together with asynchronous
>> abstraction for client proccess and the debugger itself.
>>
>> xe_eudebug_client creates its own proccess with user's work function,
>> and gives machanisms to synchronize beginning of execution and event
>> logging.
>>
>> xe_eudebug_debugger allows to attach to the given proccess, provides
>> asynchronous thread for event reading and introduces triggers -
>> a callback mechanism triggered every time subscribed event was read.
>>
>> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>> Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
>> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
>> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
>> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
>> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
>> ---
>>   lib/meson.build     |    1 +
>>   lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
>>   lib/xe/xe_eudebug.h |  206 ++++
>>   3 files changed, 2399 insertions(+)
>>   create mode 100644 lib/xe/xe_eudebug.c
>>   create mode 100644 lib/xe/xe_eudebug.h
>>
>> diff --git a/lib/meson.build b/lib/meson.build
>> index f711e60a7..969ca4101 100644
>> --- a/lib/meson.build
>> +++ b/lib/meson.build
>> @@ -111,6 +111,7 @@ lib_sources = [
>>   	'igt_msm.c',
>>   	'igt_dsc.c',
>>   	'xe/xe_gt.c',
>> +	'xe/xe_eudebug.c',
>>   	'xe/xe_ioctl.c',
>>   	'xe/xe_mmio.c',
>>   	'xe/xe_query.c',
>> diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
>> new file mode 100644
>> index 000000000..4eac87476
>> --- /dev/null
>> +++ b/lib/xe/xe_eudebug.c
>> @@ -0,0 +1,2192 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2023 Intel Corporation
>> + */
>> +
>> +#include <fcntl.h>
>> +#include <poll.h>
>> +#include <signal.h>
>> +#include <sys/select.h>
>> +#include <sys/stat.h>
>> +#include <sys/types.h>
>> +#include <sys/wait.h>
>> +
>> +#include "igt.h"
>> +#include "igt_sysfs.h"
>> +#include "intel_pat.h"
>> +#include "xe_eudebug.h"
>> +#include "xe_ioctl.h"
>> +
>> +struct event_trigger {
>> +	xe_eudebug_trigger_fn fn;
>> +	int type;
>> +	struct igt_list_head link;
>> +};
>> +
>> +struct seqno_list_entry {
>> +	struct igt_list_head link;
>> +	uint64_t seqno;
>> +};
>> +
>> +struct match_dto {
>> +	struct drm_xe_eudebug_event *target;
>> +	struct igt_list_head *seqno_list;
>> +	uint64_t client_handle;
>> +	uint32_t filter;
>> +
>> +	/* store latest 'EVENT_VM_BIND' seqno */
>> +	uint64_t *bind_seqno;
>> +	/* latest vm_bind_op seqno matching bind_seqno */
>> +	uint64_t *bind_op_seqno;
>> +};
>> +
>> +#define CLIENT_PID  1
>> +#define CLIENT_RUN  2
>> +#define CLIENT_FINI 3
>> +#define CLIENT_STOP 4
>> +#define CLIENT_STAGE 5
>> +#define DEBUGGER_STAGE 6
>> +
>> +#define DEBUGGER_WORKER_INACTIVE  0
>> +#define DEBUGGER_WORKER_ACTIVE  1
>> +#define DEBUGGER_WORKER_QUITTING 2
>> +
>> +static const char *type_to_str(unsigned int type)
>> +{
>> +	switch (type) {
>> +	case DRM_XE_EUDEBUG_EVENT_NONE:
>> +		return "none";
>> +	case DRM_XE_EUDEBUG_EVENT_READ:
>> +		return "read";
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN:
>> +		return "client";
>> +	case DRM_XE_EUDEBUG_EVENT_VM:
>> +		return "vm";
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
>> +		return "exec_queue";
>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
>> +		return "attention";
>> +	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_UFENCE:
>> +		return "vm_bind_ufence";
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA:
>> +		return "metadata";
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
>> +		return "vm_bind_op_metadata";
>> +	}
>> +
>> +	return "UNKNOWN";
>> +}
>> +
>> +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
>> +{
>> +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
>> +
>> +	return buf;
>> +}
>> +
>> +static const char *flags_to_str(unsigned int flags)
>> +{
>> +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
>> +			return "create|ack";
>> +		else
>> +			return "create";
>> +	}
>> +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
>> +		return "destroy";
>> +
>> +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
>> +		return "state-change";
>> +
>> +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
>> +
>> +	return "flags unknown";
>> +}
>> +
>> +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
>> +{
>> +	switch (e->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>> +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
>> +
>> +		sprintf(b, "handle=%llu", ec->client_handle);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>> +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, handle=%llu",
>> +			evm->client_handle, evm->vm_handle);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
>> +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
>> +			ee->client_handle, ee->vm_handle,
>> +			ee->exec_queue_handle, ee->engine_class, ee->width);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
>> +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
>> +			   "lrc_handle=%llu, bitmask_size=%d",
>> +			ea->client_handle, ea->exec_queue_handle,
>> +			ea->lrc_handle, ea->bitmask_size);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
>> +			evmb->client_handle, 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 = (void *)e;
>> +
>> +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
>> +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>> +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
>> +
>> +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
>> +			em->client_handle, em->metadata_handle, em->type, em->len);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
>> +
>> +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
>> +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
>> +		break;
>> +	}
>> +	default:
>> +		strcpy(b, "<...>");
>> +	}
>> +
>> +	return b;
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_to_str:
>> + * @e: pointer to event
>> + * @buf: target to write string representation of @e
>> + * @len: size of target buffer @buf
>> + *
>> + * Creates string representation for given event.
>> + *
>> + * Returns: the written input buffer pointed by @buf.
>> + */
>> +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
>> +{
>> +	char a[256];
>> +	char b[256];
>> +
>> +	snprintf(buf, len, "(%llu) %15s:%s: %s",
>> +		 e->seqno,
>> +		 event_type_to_str(e, a),
>> +		 flags_to_str(e->flags),
>> +		 event_members_to_str(e, b));
>> +
>> +	return buf;
>> +}
>> +
>> +static void catch_child_failure(void)
>> +{
>> +	pid_t pid;
>> +	int status;
>> +
>> +	pid = waitpid(-1, &status, WNOHANG);
>> +
>> +	if (pid == 0 || pid == -1)
>> +		return;
>> +
>> +	if (!WIFEXITED(status))
>> +		return;
>> +
>> +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
>> +}
>> +
>> +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
>> +{
>> +	int ret;
>> +	int t = 0;
>> +	struct pollfd fd = {
>> +		.fd = pipe[0],
>> +		.events = POLLIN,
>> +		.revents = 0
>> +	};
>> +
>> +	/* When child fails we may get stuck forever. Check whether
>> +	 * the child process ended with an error.
>> +	 */
>> +	do {
>> +		const int interval_ms = 1000;
>> +
>> +		ret = poll(&fd, 1, interval_ms);
>> +
>> +		if (!ret) {
>> +			catch_child_failure();
>> +			t += interval_ms;
>> +		}
>> +	} while (!ret && t < timeout_ms);
>> +
>> +	if (ret > 0)
>> +		return read(pipe[0], buf, nbytes);
>> +
>> +	return 0;
>> +}
>> +
>> +static uint64_t pipe_read(int pipe[2], int timeout_ms)
>> +{
>> +	uint64_t in;
>> +	uint64_t ret;
>> +
>> +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
>> +	igt_assert(ret == sizeof(in));
>> +
>> +	return in;
>> +}
>> +
>> +static void pipe_signal(int pipe[2], uint64_t token)
>> +{
>> +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
>> +}
>> +
>> +static void pipe_close(int pipe[2])
>> +{
>> +	if (pipe[0] != -1)
>> +		close(pipe[0]);
>> +
>> +	if (pipe[1] != -1)
>> +		close(pipe[1]);
>> +}
>> +
>> +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
>> +{
>> +	uint64_t in;
>> +
>> +	in = pipe_read(p, timeout_ms);
>> +
>> +	igt_assert_eq(in, token);
>> +
>> +	return pipe_read(p, timeout_ms);
>> +}
>> +
>> +static uint64_t client_wait_token(struct xe_eudebug_client *c,
>> +				 const uint64_t token)
>> +{
>> +	return __wait_token(c->p_in, token, c->timeout_ms);
>> +}
>> +
>> +static uint64_t wait_from_client(struct xe_eudebug_client *c,
>> +				 const uint64_t token)
>> +{
>> +	return __wait_token(c->p_out, token, c->timeout_ms);
>> +}
>> +
>> +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
>> +{
>> +	pipe_signal(p, token);
>> +	pipe_signal(p, value);
>> +}
>> +
>> +static void client_signal(struct xe_eudebug_client *c,
>> +			  const uint64_t token,
>> +			  const uint64_t value)
>> +{
>> +	token_signal(c->p_out, token, value);
>> +}
>> +
>> +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
>> +{
>> +	struct drm_xe_eudebug_connect param = {
>> +		.pid = pid,
>> +		.flags = flags,
>> +	};
>> +	int debugfd;
>> +
>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>> +
>> +	if (debugfd < 0)
>> +		return -errno;
>> +
>> +	return debugfd;
>> +}
>> +
>> +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
>> +{
>> +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
>> +		      sizeof(l->head));
>> +
>> +	igt_assert_eq(write(fd, l->log, l->head), l->head);
>> +}
>> +
>> +static void read_all(int fd, void *buf, size_t nbytes)
>> +{
>> +	ssize_t remaining_size = nbytes;
>> +	ssize_t current_size = 0;
>> +	ssize_t read_size = 0;
>> +
>> +	do {
>> +		read_size = read(fd, buf + current_size, remaining_size);
>> +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
>> +
>> +		current_size += read_size;
>> +		remaining_size -= read_size;
>> +	} while (remaining_size > 0 && read_size > 0);
>> +
>> +	igt_assert_eq(current_size, nbytes);
>> +}
>> +
>> +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
>> +{
>> +	read_all(fd, &l->head, sizeof(l->head));
>> +	igt_assert_lt(l->head, l->max_size);
>> +
>> +	read_all(fd, l->log, l->head);
>> +}
>> +
>> +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
>> +
>> +static struct drm_xe_eudebug_event *
>> +event_cmp(struct xe_eudebug_event_log *l,
>> +	  struct drm_xe_eudebug_event *current,
>> +	  cmp_fn_t match,
>> +	  void *data)
>> +{
>> +	struct drm_xe_eudebug_event *e = current;
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		if (match(e, data))
>> +			return e;
>> +	}
>> +
>> +	return NULL;
>> +}
>> +
>> +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
>> +{
>> +	struct drm_xe_eudebug_event *b = data;
>> +
>> +	if (a->type == b->type &&
>> +	    a->flags == b->flags)
>> +		return 1;
>> +
>> +	return 0;
>> +}
>> +
>> +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
>> +{
>> +	struct drm_xe_eudebug_event *b = data;
>> +	int ret = 0;
>> +
>> +	ret = match_type_and_flags(a, data);
>> +	if (!ret)
>> +		return ret;
>> +
>> +	ret = 0;
>> +
>> +	switch (a->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
>> +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
>> +
>> +		if (ae->engine_class == be->engine_class && ae->width == be->width)
>> +			ret = 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
>> +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
>> +
>> +		if (ea->num_binds == eb->num_binds)
>> +			ret = 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>> +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
>> +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
>> +
>> +		if (ea->addr == eb->addr && ea->range == eb->range &&
>> +		    ea->num_extensions == eb->num_extensions)
>> +			ret = 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
>> +
>> +		if (ea->metadata_handle == eb->metadata_handle &&
>> +		    ea->metadata_cookie == eb->metadata_cookie)
>> +			ret = 1;
>> +		break;
>> +	}
>> +
>> +	default:
>> +		ret = 1;
>> +		break;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
>> +{
>> +	struct match_dto *md = (void *)data;
>> +	uint64_t *bind_seqno = md->bind_seqno;
>> +	uint64_t *bind_op_seqno = md->bind_op_seqno;
>> +	uint64_t h = md->client_handle;
>> +
>> +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
>> +		return 0;
>> +
>> +	switch (e->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>> +
>> +		if (client->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>> +
>> +		if (vm->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
>> +
>> +		if (ee->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
>> +
>> +		if (evmb->client_handle == h) {
>> +			*bind_seqno = evmb->base.seqno;
>> +			return 1;
>> +		}
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>> +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
>> +
>> +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
>> +			*bind_op_seqno = eo->base.seqno;
>> +			return 1;
>> +		}
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>> +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
>> +
>> +		if (ef->vm_bind_ref_seqno == *bind_seqno)
>> +			return 1;
>> +
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>> +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
>> +
>> +		if (em->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
>> +
>> +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
>> +			return 1;
>> +		break;
>> +	}
>> +	default:
>> +		break;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
>> +{
>> +
>> +	struct drm_xe_eudebug_event *d = (void *)data;
>> +	int ret;
>> +
>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>> +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
>> +	ret = match_type_and_flags(e, data);
>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>> +
>> +	if (!ret)
>> +		return 0;
>> +
>> +	switch (e->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>> +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
>> +
>> +		if (client->client_handle == filter->client_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>> +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
>> +
>> +		if (vm->vm_handle == filter->vm_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>> +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
>> +
>> +		if (ee->exec_queue_handle == filter->exec_queue_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>> +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
>> +
>> +		if (evmb->vm_handle == filter->vm_handle &&
>> +		    evmb->num_binds == filter->num_binds)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>> +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
>> +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
>> +
>> +		if (avmb->addr == filter->addr &&
>> +		    avmb->range == filter->range)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>> +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
>> +
>> +		if (em->metadata_handle == filter->metadata_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
>> +
>> +		if (avmb->metadata_handle == filter->metadata_handle &&
>> +		    avmb->metadata_cookie == filter->metadata_cookie)
>> +			return 1;
>> +		break;
>> +	}
>> +
>> +	default:
>> +		break;
>> +	}
>> +	return 0;
>> +}
>> +
>> +static int match_full(struct drm_xe_eudebug_event *e, void *data)
>> +{
>> +	struct seqno_list_entry *sl;
>> +
>> +	struct match_dto *md = (void *)data;
>> +	int ret = 0;
>> +
>> +	ret = match_client_handle(e, md);
>> +	if (!ret)
>> +		return 0;
>> +
>> +	ret = match_fields(e, md->target);
>> +	if (!ret)
>> +		return 0;
>> +
>> +	igt_list_for_each_entry(sl, md->seqno_list, link) {
>> +		if (sl->seqno == e->seqno)
>> +			return 0;
>> +	}
>> +
>> +	return 1;
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +event_type_match(struct xe_eudebug_event_log *l,
>> +		 struct drm_xe_eudebug_event *target,
>> +		 struct drm_xe_eudebug_event *current)
>> +{
>> +	return event_cmp(l, current, match_type_and_flags, target);
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +client_match(struct xe_eudebug_event_log *l,
>> +	     uint64_t client_handle,
>> +	     struct drm_xe_eudebug_event *current,
>> +	     uint32_t filter,
>> +	     uint64_t *bind_seqno,
>> +	     uint64_t *bind_op_seqno)
>> +{
>> +	struct match_dto md = {
>> +		.client_handle = client_handle,
>> +		.filter = filter,
>> +		.bind_seqno = bind_seqno,
>> +		.bind_op_seqno = bind_op_seqno,
>> +	};
>> +
>> +	return event_cmp(l, current, match_client_handle, &md);
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +opposite_event_match(struct xe_eudebug_event_log *l,
>> +		    struct drm_xe_eudebug_event *target,
>> +		    struct drm_xe_eudebug_event *current)
>> +{
>> +	return event_cmp(l, current, match_opposite_resource, target);
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +event_match(struct xe_eudebug_event_log *l,
>> +	    struct drm_xe_eudebug_event *target,
>> +	    uint64_t client_handle,
>> +	    struct igt_list_head *seqno_list,
>> +	    uint64_t *bind_seqno,
>> +	    uint64_t *bind_op_seqno)
>> +{
>> +	struct match_dto md = {
>> +		.target = target,
>> +		.client_handle = client_handle,
>> +		.seqno_list = seqno_list,
>> +		.bind_seqno = bind_seqno,
>> +		.bind_op_seqno = bind_op_seqno,
>> +	};
>> +
>> +	return event_cmp(l, NULL, match_full, &md);
>> +}
>> +
>> +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
>> +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
>> +			   uint32_t filter)
>> +{
>> +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
>> +	struct drm_xe_eudebug_event_client *de = (void *)_de;
>> +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
>> +
>> +	struct igt_list_head matched_seqno_list;
>> +	struct drm_xe_eudebug_event *hc, *hd;
>> +	struct seqno_list_entry *entry, *tmp;
>> +
>> +	igt_assert(ce);
>> +	igt_assert(de);
>> +
>> +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
>> +
>> +	hc = NULL;
>> +	hd = NULL;
>> +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
>> +
>> +	do {
>> +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
>> +		if (!hc)
>> +			break;
>> +
>> +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
>> +
>> +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
>> +			     c->name,
>> +			     hc->seqno,
>> +			     hc->type,
>> +			     ce->client_handle);
>> +
>> +		igt_debug("comparing %s %llu vs %s %llu\n",
>> +			  c->name, hc->seqno, d->name, hd->seqno);
>> +
>> +		/*
>> +		 * Store the seqno of the event that was matched above,
>> +		 * inside 'matched_seqno_list', to avoid it getting matched
>> +		 * by subsequent 'event_match' calls.
>> +		 */
>> +		entry = malloc(sizeof(*entry));
>> +		entry->seqno = hd->seqno;
>> +		igt_list_add(&entry->link, &matched_seqno_list);
>> +	} while (hc);
>> +
>> +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
>> +		free(entry);
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_find_seqno:
>> + * @l: event log pointer
>> + * @seqno: seqno of event to be found
>> + *
>> + * Finds the event with given seqno in the event log.
>> + *
>> + * Returns: pointer to the event with given seqno within @l or NULL seqno is
>> + * not present.
>> + */
>> +struct drm_xe_eudebug_event *
>> +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
>> +{
>> +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
>> +
>> +	igt_assert_neq(seqno, 0);
>> +	/*
>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>> +	 * as our post processing of events is not optimized.
>> +	 */
>> +	igt_assert_lt(seqno, 10 * 1000 * 1000);
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		if (e->seqno == seqno) {
>> +			if (found) {
>> +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
>> +				xe_eudebug_event_log_print(l, false);
>> +				igt_assert(!found);
>> +			}
>> +			found = e;
>> +		}
>> +	}
>> +
>> +	return found;
>> +}
>> +
>> +static void event_log_sort(struct xe_eudebug_event_log *l)
>> +{
>> +	struct xe_eudebug_event_log *tmp;
>> +	struct drm_xe_eudebug_event *e = NULL;
>> +	uint64_t first_seqno = 0;
>> +	uint64_t last_seqno = 0;
>> +	uint64_t events = 0, added = 0;
>> +	uint64_t i;
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		if (e->seqno > last_seqno)
>> +			last_seqno = e->seqno;
>> +
>> +		if (e->seqno < first_seqno)
>> +			first_seqno = e->seqno;
>> +
>> +		events++;
>> +	}
>> +
>> +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
>> +
>> +	for (i = 1; i <= last_seqno; i++) {
>> +		e = xe_eudebug_event_log_find_seqno(l, i);
>> +		if (e) {
>> +			xe_eudebug_event_log_write(tmp, e);
>> +			added++;
>> +		}
>> +	}
>> +
>> +	igt_assert_eq(events, added);
>> +	igt_assert_eq(tmp->head, l->head);
>> +
>> +	memcpy(l->log, tmp->log, tmp->head);
>> +
>> +	xe_eudebug_event_log_destroy(tmp);
>> +}
>> +
>> +/**
>> + * xe_eudebug_connect:
>> + * @fd: Xe file descriptor
>> + * @pid: client PID
>> + * @flags: connection flags
>> + *
>> + * Opens the xe eu debugger connection to the process described by @pid
>> + *
>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>> + */
>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
>> +{
>> +	int ret;
>> +	uint64_t events = 0; /* events filtering not supported yet! */
>> +
>> +	ret = __xe_eudebug_connect(fd, pid, flags, events);
>> +
>> +	return ret;
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_create:
>> + * @name: event log identifier
>> + * @max_size: maximum size of created log
>> + *
>> + * Function creates an Eu Debugger event log with size equal to @max_size.
>> + *
>> + * Returns: pointer to just created log
>> + */
>> +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
>> +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
>> +{
>> +	struct xe_eudebug_event_log *l;
>> +
>> +	l = calloc(1, sizeof(*l));
>> +	igt_assert(l);
>> +	l->log = calloc(1, max_size);
>> +	igt_assert(l->log);
>> +	l->max_size = max_size;
>> +	strncpy(l->name, name, sizeof(l->name) - 1);
>> +	pthread_mutex_init(&l->lock, NULL);
>> +
>> +	return l;
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_destroy:
>> + * @l: event log pointer
>> + *
>> + * Frees given event log @l.
>> + */
>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
>> +{
>> +	pthread_mutex_destroy(&l->lock);
>> +	free(l->log);
>> +	free(l);
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_write:
>> + * @l: event log pointer
>> + * @e: event to be written to event log
>> + *
>> + * Writes event @e to the event log, thread-safe.
>> + */
>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
>> +{
>> +	igt_assert(e->seqno);
>> +	/*
>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>> +	 * as our post processing of events is not optimized.
>> +	 */
>> +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
>> +
>> +	pthread_mutex_lock(&l->lock);
>> +	igt_assert_lt(l->head + e->len, l->max_size);
>> +	memcpy(l->log + l->head, e, e->len);
>> +	l->head += e->len;
>> +
>> +#ifdef DEBUG_LOG
>> +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
>> +		 l->name, e->len, l->max_size - l->head);
>> +#endif
>> +	pthread_mutex_unlock(&l->lock);
> I'm not fan of #ifdef debug logs. As the event log has been proven in action,
> can we just strip it out?

Sure, will do.

Thanks,
Christoph

> <cut>
> 
> Regards,
> Dominik
> 

Re: [PATCH i-g-t v3 13/14] tests/xe_eudebug_online: Debug client which runs workloads on EU

[Manszewski, Christoph]

Hi Dominik,

On 19.08.2024 11:58, Grzegorzek, Dominik wrote:
> On Fri, 2024-08-09 at 14:38 +0200, Christoph Manszewski wrote:
>> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>
>> For typical debugging under gdb one can specify two main usecases:
>> accessing and manupulating resources created by the application and
>> manipulating thread execution (interrupting and setting breakpoints).
>>
>> This test adds coverage for the latter by checking that:
>> - EU workloads that hit a instruction with breakpoint bit set will stop
>>    halt execution and the debugger will report this via attention events,
>> - the debugger is able to interrupt workload execution by issuing a
>>    'interrupt_all' ioctl call,
>> - the debugger is able to resume selected workloads that are stopped.
>>
>> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>> Signed-off-by: Mika Kuoppala <mika.kuoppala@intel.com>
>> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
>> Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
>> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
>> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
>> Signed-off-by: Kolanupaka Naveena <kolanupaka.naveena@intel.com>
>> ---
>>   tests/intel/xe_eudebug_online.c | 2203 +++++++++++++++++++++++++++++++
>>   tests/meson.build               |    1 +
>>   2 files changed, 2204 insertions(+)
>>   create mode 100644 tests/intel/xe_eudebug_online.c
>>
>> diff --git a/tests/intel/xe_eudebug_online.c b/tests/intel/xe_eudebug_online.c
>> new file mode 100644
>> index 000000000..1c8ac67f1
>> --- /dev/null
>> +++ b/tests/intel/xe_eudebug_online.c
>> @@ -0,0 +1,2203 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2023 Intel Corporation
>> + */
>> +
>> +/**
>> + * TEST: Tests for eudebug online functionality
>> + * Category: Core
>> + * Mega feature: EUdebug
>> + * Sub-category: EUdebug tests
>> + * Functionality: eu kernel debug
>> + * Test category: functionality test
>> + */
>> +
>> +#include "xe/xe_eudebug.h"
>> +#include "xe/xe_ioctl.h"
>> +#include "xe/xe_query.h"
>> +#include "igt.h"
>> +#include "intel_pat.h"
>> +#include "intel_mocs.h"
>> +#include "gpgpu_shader.h"
>> +
>> +#define SHADER_NOP			(0 << 0)
>> +#define SHADER_BREAKPOINT		(1 << 0)
>> +#define SHADER_LOOP			(1 << 1)
>> +#define SHADER_SINGLE_STEP		(1 << 2)
>> +#define SIP_SINGLE_STEP			(1 << 3)
>> +#define DISABLE_DEBUG_MODE		(1 << 4)
>> +#define SHADER_N_NOOP_BREAKPOINT	(1 << 5)
>> +#define SHADER_CACHING_SRAM		(1 << 6)
>> +#define SHADER_CACHING_VRAM		(1 << 7)
>> +#define SHADER_MIN_THREADS		(1 << 8)
>> +#define DO_NOT_EXPECT_CANARIES		(1 << 9)
>> +#define TRIGGER_RESUME_SINGLE_WALK	(1 << 25)
>> +#define TRIGGER_RESUME_PARALLEL_WALK	(1 << 26)
>> +#define TRIGGER_RECONNECT		(1 << 27)
>> +#define TRIGGER_RESUME_SET_BP		(1 << 28)
>> +#define TRIGGER_RESUME_DELAYED		(1 << 29)
>> +#define TRIGGER_RESUME_DSS		(1 << 30)
>> +#define TRIGGER_RESUME_ONE		(1 << 31)
>> +
>> +#define DEBUGGER_REATTACHED	1
>> +
>> +#define SHADER_LOOP_N		3
>> +#define SINGLE_STEP_COUNT	16
>> +#define STEERING_SINGLE_STEP	0
>> +#define STEERING_CONTINUE	0x00c0ffee
>> +#define STEERING_END_LOOP	0xdeadca11
>> +
>> +#define CACHING_INIT_VALUE	0xcafe0000
>> +#define CACHING_POISON_VALUE	0xcafedead
>> +#define CACHING_VALUE(n)	(CACHING_INIT_VALUE + n)
>> +
>> +#define SHADER_CANARY 0x01010101
>> +
>> +#define WALKER_X_DIM		4
>> +#define WALKER_ALIGNMENT	16
>> +#define SIMD_SIZE		16
>> +
>> +#define STARTUP_TIMEOUT_MS	3000
>> +#define WORKLOAD_DELAY_US	(5000 * 1000)
>> +
>> +#define PAGE_SIZE 4096
>> +
>> +struct dim_t {
>> +	uint32_t x;
>> +	uint32_t y;
>> +	uint32_t alignment;
>> +};
>> +
>> +static struct dim_t walker_dimensions(int threads)
>> +{
>> +	uint32_t x_dim = min_t(x_dim, threads, WALKER_X_DIM);
>> +	struct dim_t ret = {
>> +		.x = x_dim,
>> +		.y = threads / x_dim,
>> +		.alignment = WALKER_ALIGNMENT
>> +	};
>> +
>> +	return ret;
>> +}
>> +
>> +static struct dim_t surface_dimensions(int threads)
>> +{
>> +	struct dim_t ret = walker_dimensions(threads);
>> +
>> +	ret.y = max_t(ret.y, threads/ret.x, 4);
>> +	ret.x *= SIMD_SIZE;
>> +	ret.alignment *= SIMD_SIZE;
>> +
>> +	return ret;
>> +}
>> +
>> +static uint32_t steering_offset(int threads)
>> +{
>> +	struct dim_t w = walker_dimensions(threads);
>> +
>> +	return ALIGN(w.x, w.alignment) * w.y * 4;
>> +}
>> +
>> +static struct intel_buf *create_uc_buf(int fd, int width, int height)
>> +{
>> +	struct intel_buf *buf;
>> +
>> +	buf = intel_buf_create_full(buf_ops_create(fd), 0, width/4, height,
>> +				    32, 0, I915_TILING_NONE, 0, 0, 0,
>> +				    vram_if_possible(fd, 0),
>> +				    DEFAULT_PAT_INDEX, DEFAULT_MOCS_INDEX);
>> +
>> +	return buf;
>> +}
>> +
>> +static int get_number_of_threads(uint64_t flags)
>> +{
>> +	if (flags & SHADER_MIN_THREADS)
>> +		return 16;
>> +
>> +	if (flags & (TRIGGER_RESUME_ONE | TRIGGER_RESUME_SINGLE_WALK |
>> +		     TRIGGER_RESUME_PARALLEL_WALK | SHADER_CACHING_SRAM | SHADER_CACHING_VRAM))
>> +		return 32;
>> +
>> +	return 512;
>> +}
>> +
>> +static int caching_get_instruction_count(int fd, uint32_t s_dim__x, int flags)
>> +{
>> +	uint64_t memory;
>> +
>> +	igt_assert((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM));
>> +
>> +	if (flags & SHADER_CACHING_SRAM)
>> +		memory = system_memory(fd);
>> +	else
>> +		memory = vram_memory(fd, 0);
>> +
>> +	/* each instruction writes to given y offset */
>> +	return (2 * xe_min_page_size(fd, memory)) / s_dim__x;
>> +}
>> +
>> +static struct gpgpu_shader *get_shader(int fd, const unsigned int flags)
>> +{
>> +	struct dim_t w_dim = walker_dimensions(get_number_of_threads(flags));
>> +	struct dim_t s_dim = surface_dimensions(get_number_of_threads(flags));
>> +	static struct gpgpu_shader *shader;
>> +
>> +	shader = gpgpu_shader_create(fd);
>> +
>> +	gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
>> +	if (flags & SHADER_BREAKPOINT) {
>> +		gpgpu_shader__nop(shader);
>> +		gpgpu_shader__breakpoint(shader);
>> +	} else if (flags & SHADER_LOOP) {
>> +		gpgpu_shader__label(shader, 0);
>> +		gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
>> +		gpgpu_shader__jump_neq(shader, 0, w_dim.y, STEERING_END_LOOP);
>> +		gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
>> +	} else if (flags & SHADER_SINGLE_STEP) {
>> +		gpgpu_shader__nop(shader);
>> +		gpgpu_shader__breakpoint(shader);
>> +		for (int i = 0; i < SINGLE_STEP_COUNT; i++)
>> +			gpgpu_shader__nop(shader);
>> +	} else if (flags & SHADER_N_NOOP_BREAKPOINT) {
>> +		for (int i = 0; i < SHADER_LOOP_N; i++) {
>> +			gpgpu_shader__nop(shader);
>> +			gpgpu_shader__breakpoint(shader);
>> +		}
>> +	} else if ((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM)) {
>> +		gpgpu_shader__nop(shader);
>> +		gpgpu_shader__breakpoint(shader);
>> +		for (int i = 0; i < caching_get_instruction_count(fd, s_dim.x, flags); i++)
>> +			gpgpu_shader__common_target_write_u32(shader, s_dim.y + i, CACHING_VALUE(i));
>> +		gpgpu_shader__nop(shader);
>> +		gpgpu_shader__breakpoint(shader);
>> +	}
>> +
>> +	gpgpu_shader__eot(shader);
>> +	return shader;
>> +}
>> +
>> +static struct gpgpu_shader *get_sip(int fd, const unsigned int flags)
>> +{
>> +	struct dim_t w_dim = walker_dimensions(get_number_of_threads(flags));
>> +	static struct gpgpu_shader *sip;
>> +
>> +	sip = gpgpu_shader_create(fd);
>> +	gpgpu_shader__write_aip(sip, 0);
>> +
>> +	gpgpu_shader__wait(sip);
>> +	if (flags & SIP_SINGLE_STEP)
>> +		gpgpu_shader__end_system_routine_step_if_eq(sip, w_dim.y, 0);
>> +	else
>> +		gpgpu_shader__end_system_routine(sip, true);
>> +	return sip;
>> +}
>> +
>> +static int count_set_bits(void *ptr, size_t size)
>> +{
>> +	uint8_t *p = ptr;
>> +	int count = 0;
>> +	int i, j;
>> +
>> +	for (i = 0; i < size; i++)
>> +		for (j = 0; j < 8; j++)
>> +			count += !!(p[i] & (1 << j));
>> +
>> +	return count;
>> +}
>> +
>> +static int count_canaries_eq(uint32_t *ptr, struct dim_t w_dim, uint32_t value)
>> +{
>> +	int count = 0;
>> +	int x, y;
>> +
>> +	for (x = 0; x < w_dim.x; x++)
>> +		for (y = 0; y < w_dim.y; y++)
>> +			if (READ_ONCE(ptr[x + ALIGN(w_dim.x, w_dim.alignment) * y]) == value)
>> +				count++;
>> +
>> +	return count;
>> +}
>> +
>> +static int count_canaries_neq(uint32_t *ptr, struct dim_t w_dim, uint32_t value)
>> +{
>> +	return w_dim.x * w_dim.y - count_canaries_eq(ptr, w_dim, value);
>> +}
>> +
>> +static const char *td_ctl_cmd_to_str(uint32_t cmd)
>> +{
>> +	switch (cmd) {
>> +	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL:
>> +		return "interrupt all";
>> +	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED:
>> +		return "stopped";
>> +	case DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME:
>> +		return "resume";
>> +	default:
>> +		return "unknown command";
>> +	}
>> +}
>> +
>> +static int __eu_ctl(int debugfd, uint64_t client,
>> +		    uint64_t exec_queue, uint64_t lrc,
>> +		    uint8_t *bitmask, uint32_t *bitmask_size,
>> +		    uint32_t cmd, uint64_t *seqno)
>> +{
>> +	struct drm_xe_eudebug_eu_control control = {
>> +		.client_handle = lower_32_bits(client),
>> +		.exec_queue_handle = exec_queue,
>> +		.lrc_handle = lrc,
>> +		.cmd = cmd,
>> +		.bitmask_ptr = to_user_pointer(bitmask),
>> +	};
>> +	int ret;
>> +
>> +	if (bitmask_size)
>> +		control.bitmask_size = *bitmask_size;
>> +
>> +	ret = igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &control);
>> +
>> +	if (ret < 0)
>> +		return -errno;
>> +
>> +	igt_debug("EU CONTROL[%llu]: %s\n", control.seqno, td_ctl_cmd_to_str(cmd));
>> +
>> +	if (bitmask_size)
>> +		*bitmask_size = control.bitmask_size;
>> +
>> +	if (seqno)
>> +		*seqno = control.seqno;
>> +
>> +	return 0;
>> +
>> +}
>> +
>> +static uint64_t eu_ctl(int debugfd, uint64_t client,
>> +		       uint64_t exec_queue, uint64_t lrc,
>> +		       uint8_t *bitmask, uint32_t *bitmask_size, uint32_t cmd)
>> +{
>> +	uint64_t seqno;
>> +
>> +	igt_assert_eq(__eu_ctl(debugfd, client, exec_queue, lrc, bitmask,
>> +			       bitmask_size, cmd, &seqno), 0);
>> +
>> +	return seqno;
>> +}
>> +
>> +static bool intel_gen_needs_resume_wa(int fd)
>> +{
>> +	const uint32_t id = intel_get_drm_devid(fd);
>> +
>> +	return intel_gen(id) == 12 && intel_graphics_ver(id) < IP_VER(12, 55);
>> +}
>> +
>> +static uint64_t eu_ctl_resume(int fd, int debugfd, uint64_t client,
>> +			      uint64_t exec_queue, uint64_t lrc,
>> +			      uint8_t *bitmask, uint32_t bitmask_size)
>> +{
>> +	int i;
>> +
>> +	/* XXX: WA for hsd: 14011332042 */
> Remove XXX.
> Maybe plain: /* Wa_14011332042 */ ?
>> +	if (intel_gen_needs_resume_wa(fd)) {
>> +		uint32_t *att_reg_half = (uint32_t *)bitmask;
>> +
>> +		for (i = 0; i < bitmask_size / sizeof(uint32_t); i += 2) {
>> +			att_reg_half[i] |= att_reg_half[i + 1];
>> +			att_reg_half[i + 1] |= att_reg_half[i];
>> +		}
>> +	}
>> +
>> +	return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, &bitmask_size,
>> +		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME);
>> +}
>> +
>> +static inline uint64_t eu_ctl_stopped(int debugfd, uint64_t client,
>> +				      uint64_t exec_queue, uint64_t lrc,
>> +				      uint8_t *bitmask, uint32_t *bitmask_size)
>> +{
>> +	return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, bitmask_size,
>> +		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED);
>> +}
>> +
>> +static inline uint64_t eu_ctl_interrupt_all(int debugfd, uint64_t client,
>> +					    uint64_t exec_queue, uint64_t lrc)
>> +{
>> +	return eu_ctl(debugfd, client, exec_queue, lrc, NULL, 0,
>> +		      DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL);
>> +}
>> +
>> +struct online_debug_data {
>> +	pthread_mutex_t mutex;
>> +	/* client in */
>> +	struct drm_xe_engine_class_instance hwe;
>> +	/* client out */
>> +	int threads_count;
>> +	/* debugger internals */
>> +	uint64_t client_handle;
>> +	uint64_t exec_queue_handle;
>> +	uint64_t lrc_handle;
>> +	uint64_t target_offset;
>> +	size_t target_size;
>> +	uint64_t bb_offset;
>> +	size_t bb_size;
>> +	int vm_fd;
>> +	uint32_t first_aip;
>> +	uint64_t *aips_offset_table;
>> +	uint32_t steps_done;
>> +	uint8_t *single_step_bitmask;
>> +	int stepped_threads_count;
>> +	struct timespec exception_arrived;
>> +	int last_eu_control_seqno;
>> +	struct drm_xe_eudebug_event *exception_event;
>> +};
>> +
>> +static struct online_debug_data *
>> +online_debug_data_create(struct drm_xe_engine_class_instance *hwe)
>> +{
>> +	struct online_debug_data *data;
>> +
>> +	data = mmap(0, ALIGN(sizeof(*data), PAGE_SIZE),
>> +		    PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
>> +	memcpy(&data->hwe, hwe, sizeof(*hwe));
>> +	pthread_mutex_init(&data->mutex, NULL);
>> +	data->client_handle = -1ULL;
>> +	data->exec_queue_handle = -1ULL;
>> +	data->lrc_handle = -1ULL;
>> +	data->vm_fd = -1;
>> +	data->stepped_threads_count = -1;
>> +
>> +	return data;
>> +}
>> +
>> +static void online_debug_data_destroy(struct online_debug_data *data)
>> +{
>> +	free(data->aips_offset_table);
>> +	munmap(data, ALIGN(sizeof(*data), PAGE_SIZE));
>> +}
>> +
>> +static void eu_attention_debug_trigger(struct xe_eudebug_debugger *d,
>> +					struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
>> +	uint32_t *ptr = (uint32_t *) att->bitmask;
>> +
>> +	igt_debug("EVENT[%llu] eu-attenttion; threads=%d "
>> +		 "client[%llu], exec_queue[%llu], lrc[%llu], bitmask_size[%d]\n",
>> +		 att->base.seqno, count_set_bits(att->bitmask, att->bitmask_size),
>> +				att->client_handle, att->exec_queue_handle,
>> +				att->lrc_handle, att->bitmask_size);
> strange alignment
>> +
>> +	for (uint32_t i = 0; i < att->bitmask_size/4; i += 2)
>> +		igt_debug("bitmask[%d] = 0x%08x%08x\n", i/2, ptr[i], ptr[i+1]);
>> +
>> +}
>> +
>> +static void eu_attention_reset_trigger(struct xe_eudebug_debugger *d,
>> +					struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
>> +	uint32_t *ptr = (uint32_t *) att->bitmask;
>> +	struct online_debug_data *data = d->ptr;
>> +
>> +	igt_debug("EVENT[%llu] eu-attention with reset; threads=%d "
>> +		 "client[%llu], exec_queue[%llu], lrc[%llu], bitmask_size[%d]\n",
>> +		 att->base.seqno, count_set_bits(att->bitmask, att->bitmask_size),
>> +				att->client_handle, att->exec_queue_handle,
>> +				att->lrc_handle, att->bitmask_size);
> here as well
>> +
>> +	for (uint32_t i = 0; i < att->bitmask_size/4; i += 2)
>> +		igt_debug("bitmask[%d] = 0x%08x%08x\n", i/2, ptr[i], ptr[i+1]);
>> +
>> +	xe_force_gt_reset_async(d->master_fd, data->hwe.gt_id);
>> +}
>> +
>> +static void copy_first_bit(uint8_t *dst, uint8_t *src, int size)
>> +{
>> +	bool found = false;
>> +	int i, j;
>> +
>> +	for (i = 0; i < size; i++) {
>> +		if (found) {
>> +			dst[i] = 0;
>> +		} else {
>> +			uint32_t tmp = src[i]; /* in case dst == src */
>> +
>> +			for (j = 0; j < 8; j++) {
>> +				dst[i] = tmp & (1 << j);
>> +				if (dst[i]) {
>> +					found = true;
>> +					break;
>> +				}
>> +			}
>> +		}
>> +	}
>> +}
>> +
>> +static void copy_nth_bit(uint8_t *dst, uint8_t *src, int size, int n)
>> +{
>> +	int count = 0;
>> +
>> +	for (int i = 0; i < size; i++) {
>> +		uint32_t tmp = src[i];
>> +		for (int j = 7; j >= 0; j--) {
>> +			if (tmp & (1 << j)) {
>> +				count++;
>> +				if (count == n)
>> +					dst[i] |= (1 << j);
>> +				else
>> +					dst[i] &= ~(1 << j);
>> +			} else
>> +				dst[i] &= ~(1 << j);
>> +		}
>> +	}
>> +}
>> +
>> +/*
>> + * Searches for the first instruction. It stands on assumption,
>> + * that shader kernel is placed before sip within the bb.
>> + */
>> +static uint32_t find_kernel_in_bb(struct gpgpu_shader *kernel,
>> +				  struct online_debug_data *data)
>> +{
>> +	uint32_t *p = kernel->code;
>> +	size_t sz = 4 * sizeof(uint32_t);
>> +	uint32_t buf[4];
>> +	int i;
>> +
>> +	for (i = 0; i < data->bb_size; i += sz) {
>> +		igt_assert_eq(pread(data->vm_fd, &buf, sz, data->bb_offset + i), sz);
>> +
>> +
>> +		if (memcmp(p, buf, sz) == 0)
>> +			break;
>> +	}
>> +
>> +	igt_assert(i < data->bb_size);
>> +
>> +	return i;
>> +}
>> +
>> +static void set_breakpoint_once(struct xe_eudebug_debugger *d,
>> +				struct online_debug_data *data)
>> +{
>> +	const uint32_t breakpoint_bit = 1 << 30;
>> +	size_t sz = sizeof(uint32_t);
>> +	struct gpgpu_shader *kernel;
>> +	uint32_t aip;
>> +
>> +	kernel = get_shader(d->master_fd, d->flags);
>> +
>> +	if (data->first_aip) {
>> +		uint32_t expected = find_kernel_in_bb(kernel, data) + kernel->size * 4 - 0x10;
>> +
>> +		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset), sz);
>> +		igt_assert_eq_u32(aip, expected);
>> +	} else {
>> +		uint32_t instr_usdw;
>> +
>> +		igt_assert(data->vm_fd != -1);
>> +		igt_assert(data->target_size != 0);
>> +		igt_assert(data->bb_size != 0);
>> +
>> +		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset), sz);
>> +		data->first_aip = aip;
>> +
>> +		aip = find_kernel_in_bb(kernel, data);
>> +
>> +		/* set breakpoint on last instruction */
>> +		aip += kernel->size * 4 - 0x10;
>> +		igt_assert_eq(pread(data->vm_fd, &instr_usdw, sz,
>> +				    data->bb_offset + aip), sz);
>> +		instr_usdw |= breakpoint_bit;
>> +		igt_assert_eq(pwrite(data->vm_fd, &instr_usdw, sz,
>> +				     data->bb_offset + aip), sz);
>> +
>> +	}
>> +
>> +	gpgpu_shader_destroy(kernel);
>> +}
>> +
>> +static void get_aips_offset_table(struct online_debug_data *data, int threads)
>> +{
>> +	size_t sz = sizeof(uint32_t);
>> +	uint32_t aip;
>> +	uint32_t first_aip;
>> +	int table_index = 0;
>> +
>> +	if (data->aips_offset_table)
>> +		return;
>> +
>> +	data->aips_offset_table = malloc(threads * sizeof(uint64_t));
>> +	igt_assert(data->aips_offset_table);
>> +
>> +	igt_assert_eq(pread(data->vm_fd, &first_aip, sz, data->target_offset), sz);
>> +	data->first_aip = first_aip;
>> +	data->aips_offset_table[table_index++] = 0;
>> +
>> +	fsync(data->vm_fd);
>> +	for (int i = 1; i < data->target_size; i++) {
> for (int i = sz; i < data->target_size; i+=sz), no need to compare byte by byte when instruction
> pointer has 4 bytes.
>> +		igt_assert_eq(pread(data->vm_fd, &aip, sz, data->target_offset + i), sz);
>> +		if (aip == first_aip)
>> +			data->aips_offset_table[table_index++] = i;
>> +	}
>> +
>> +	igt_assert_eq(threads, table_index);
>> +
>> +	igt_debug("AIPs offset table:\n");
>> +	for (int i = 0; i < threads; i++) {
>> +		igt_debug("%lx\n", data->aips_offset_table[i]);
>> +	}
> redundant bracets.
>> +}
>> +
>> +static int get_stepped_threads_count(struct online_debug_data *data, int threads)
>> +{
>> +	int count = 0;
>> +	size_t sz = sizeof(uint32_t);
>> +	uint32_t aip;
>> +
>> +	fsync(data->vm_fd);
>> +	for (int i = 0; i < threads; i++) {
>> +		igt_assert_eq(pread(data->vm_fd, &aip, sz,
>> +				    data->target_offset + data->aips_offset_table[i]), sz);
>> +		if (aip != data->first_aip) {
>> +			igt_assert(aip == data->first_aip + 0x10);
>> +			count++;
>> +		}
>> +	}
>> +
>> +	return count;
>> +}
>> +
>> +static void save_first_exception_trigger(struct xe_eudebug_debugger *d,
>> +					 struct drm_xe_eudebug_event *e)
>> +{
>> +	struct online_debug_data *data = d->ptr;
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	if (!data->exception_event) {
>> +		igt_gettime(&data->exception_arrived);
>> +		data->exception_event = igt_memdup(e, e->len);
>> +	}
>> +	pthread_mutex_unlock(&data->mutex);
>> +}
>> +
>> +#define MAX_PREEMPT_TIMEOUT 10ull
>> +static int is_client_resumed;
> 
> Why this is static global variable? Could be part of the data struct.
> What's more, it slighlty indicates that when it was set to =1 client
> is running. Which may not be true. (more than one dispatch or more than one breakpoint)
> I would consider changing the name, but I do not have strong opinion about that.
> 
>> +static void eu_attention_resume_trigger(struct xe_eudebug_debugger *d,
>> +					struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
>> +	struct online_debug_data *data = d->ptr;
>> +	uint32_t bitmask_size = att->bitmask_size;
>> +	uint8_t *bitmask;
>> +	int i;
>> +
>> +	if (data->last_eu_control_seqno > att->base.seqno)
>> +		return;
>> +
>> +	bitmask = calloc(1, att->bitmask_size);
>> +
>> +	eu_ctl_stopped(d->fd, att->client_handle, att->exec_queue_handle,
>> +		       att->lrc_handle, bitmask, &bitmask_size);
>> +	igt_assert(bitmask_size == att->bitmask_size);
>> +	igt_assert(memcmp(bitmask, att->bitmask, att->bitmask_size) == 0);
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	if (igt_nsec_elapsed(&data->exception_arrived) < (MAX_PREEMPT_TIMEOUT + 1) * NSEC_PER_SEC &&
>> +	    d->flags & TRIGGER_RESUME_DELAYED) {
>> +		pthread_mutex_unlock(&data->mutex);
>> +		free(bitmask);
>> +		return;
>> +	} else if (d->flags & TRIGGER_RESUME_ONE) {
>> +		copy_first_bit(bitmask, bitmask, bitmask_size);
>> +	} else if (d->flags & TRIGGER_RESUME_DSS) {
>> +		uint64_t *event = (uint64_t *)att->bitmask;
>> +		uint64_t *resume = (uint64_t *)bitmask;
>> +
>> +		memset(bitmask, 0, bitmask_size);
>> +		for (i = 0; i < att->bitmask_size / sizeof(uint64_t); i++) {
>> +			if (!event[i])
>> +				continue;
>> +
>> +			resume[i] = event[i];
>> +			break;
>> +		}
>> +	} else if (d->flags & TRIGGER_RESUME_SET_BP) {
>> +		set_breakpoint_once(d, data);
>> +	}
>> +
>> +	if (d->flags & SHADER_LOOP) {
>> +		uint32_t threads = get_number_of_threads(d->flags);
>> +		uint32_t val = STEERING_END_LOOP;
>> +
>> +		igt_assert_eq(pwrite(data->vm_fd, &val, sizeof(uint32_t),
>> +				     data->target_offset + steering_offset(threads)),
>> +			      sizeof(uint32_t));
>> +		fsync(data->vm_fd);
>> +	}
>> +	pthread_mutex_unlock(&data->mutex);
>> +
>> +	data->last_eu_control_seqno = eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
>> +						    att->exec_queue_handle, att->lrc_handle,
>> +						    bitmask, att->bitmask_size);
>> +
>> +	is_client_resumed = 1;
>> +	free(bitmask);
>> +}
>> +
>> +static void eu_attention_resume_single_step_trigger(struct xe_eudebug_debugger *d,
>> +						    struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
>> +	struct online_debug_data *data = d->ptr;
>> +	const int threads = get_number_of_threads(d->flags);
>> +	uint32_t val;
>> +	size_t sz = sizeof(uint32_t);
>> +
>> +	get_aips_offset_table(data, threads);
>> +
>> +	if (d->flags & TRIGGER_RESUME_PARALLEL_WALK) {
>> +		if (data->stepped_threads_count != -1)
>> +			if (data->steps_done < SINGLE_STEP_COUNT) {
>> +				int stepped_threads_count_after_resume =
>> +						get_stepped_threads_count(data, threads);
>> +				igt_debug("Stepped threads after: %d\n",
>> +					  stepped_threads_count_after_resume);
>> +
>> +				if (stepped_threads_count_after_resume == threads) {
>> +					data->first_aip += 0x10;
>> +					data->steps_done++;
>> +				}
>> +
>> +				igt_debug("Shader steps: %d\n", data->steps_done);
>> +				igt_assert(data->stepped_threads_count == 0);
>> +				igt_assert(stepped_threads_count_after_resume == threads);
>> +			}
>> +
>> +		if (data->steps_done < SINGLE_STEP_COUNT) {
>> +			data->stepped_threads_count = get_stepped_threads_count(data, threads);
>> +			igt_debug("Stepped threads before: %d\n", data->stepped_threads_count);
>> +		}
>> +
>> +		val = data->steps_done < SINGLE_STEP_COUNT ? STEERING_SINGLE_STEP :
>> +							     STEERING_CONTINUE;
>> +	} else if (d->flags & TRIGGER_RESUME_SINGLE_WALK) {
>> +		if (data->stepped_threads_count != -1)
>> +			if (data->steps_done < 2) {
>> +				int stepped_threads_count_after_resume =
>> +						get_stepped_threads_count(data, threads);
>> +				igt_debug("Stepped threads after: %d\n",
>> +					  stepped_threads_count_after_resume);
>> +
>> +				if (stepped_threads_count_after_resume == threads) {
>> +					data->first_aip += 0x10;
>> +					data->steps_done++;
>> +					free(data->single_step_bitmask);
>> +					data->single_step_bitmask = 0;
>> +				}
>> +
>> +				igt_debug("Shader steps: %d\n", data->steps_done);
>> +				igt_assert(data->stepped_threads_count +
>> +					   (intel_gen_needs_resume_wa(d->master_fd) ? 2 : 1) ==
>> +					   stepped_threads_count_after_resume);
>> +			}
>> +
>> +		if (data->steps_done < 2) {
>> +			data->stepped_threads_count = get_stepped_threads_count(data, threads);
>> +			igt_debug("Stepped threads before: %d\n", data->stepped_threads_count);
>> +			if (intel_gen_needs_resume_wa(d->master_fd)) {
>> +				if (!data->single_step_bitmask) {
>> +					data->single_step_bitmask = malloc(att->bitmask_size *
>> +									   sizeof(uint8_t));
>> +					igt_assert(data->single_step_bitmask);
>> +					memcpy(data->single_step_bitmask, att->bitmask,
>> +					       att->bitmask_size);
>> +				}
>> +
>> +				copy_first_bit(att->bitmask, data->single_step_bitmask,
>> +					       att->bitmask_size);
>> +			} else
>> +				copy_nth_bit(att->bitmask, att->bitmask, att->bitmask_size,
>> +					     data->stepped_threads_count + 1);
>> +		}
>> +
>> +		val = data->steps_done < 2 ? STEERING_SINGLE_STEP : STEERING_CONTINUE;
>> +	}
>> +
>> +	igt_assert_eq(pwrite(data->vm_fd, &val, sz,
>> +			     data->target_offset + steering_offset(threads)), sz);
>> +	fsync(data->vm_fd);
>> +
>> +	eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
>> +		      att->exec_queue_handle, att->lrc_handle,
>> +		      att->bitmask, att->bitmask_size);
>> +
>> +	if (data->single_step_bitmask)
>> +		for (int i = 0; i < att->bitmask_size; i++)
>> +			data->single_step_bitmask[i] &= ~att->bitmask[i];
>> +}
>> +
>> +static void open_trigger(struct xe_eudebug_debugger *d,
>> +			 struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_client *client = (void *)e;
>> +	struct online_debug_data *data = d->ptr;
>> +
>> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
>> +		return;
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	data->client_handle = client->client_handle;
>> +	pthread_mutex_unlock(&data->mutex);
>> +}
>> +
>> +static void exec_queue_trigger(struct xe_eudebug_debugger *d,
>> +			       struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_exec_queue *eq = (void *)e;
>> +	struct online_debug_data *data = d->ptr;
>> +
>> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
>> +		return;
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	data->exec_queue_handle = eq->exec_queue_handle;
>> +	data->lrc_handle = eq->lrc_handle[0];
>> +	pthread_mutex_unlock(&data->mutex);
>> +}
>> +
>> +static void vm_open_trigger(struct xe_eudebug_debugger *d,
>> +			    struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_vm *vm = (void *)e;
>> +	struct online_debug_data *data = d->ptr;
>> +	struct drm_xe_eudebug_vm_open vo = {
>> +		.client_handle = vm->client_handle,
>> +		.vm_handle = vm->vm_handle,
>> +	};
>> +	int fd;
>> +
>> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +		fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo);
>> +		igt_assert_lte(0, fd);
>> +
>> +		pthread_mutex_lock(&data->mutex);
>> +		igt_assert(data->vm_fd == -1);
>> +		data->vm_fd = fd;
>> +		pthread_mutex_unlock(&data->mutex);
>> +		return;
>> +	}
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	close(data->vm_fd);
>> +	data->vm_fd = -1;
>> +	pthread_mutex_unlock(&data->mutex);
>> +}
>> +
>> +static void read_metadata(struct xe_eudebug_debugger *d,
>> +			  uint64_t client_handle,
>> +			  uint64_t metadata_handle,
>> +			  uint64_t type,
>> +			  uint64_t len)
>> +{
>> +	struct drm_xe_eudebug_read_metadata rm = {
>> +		.client_handle = client_handle,
>> +		.metadata_handle = metadata_handle,
>> +		.size = len,
>> +	};
>> +	struct online_debug_data *data = d->ptr;
>> +	uint64_t *metadata;
>> +
>> +	metadata = malloc(len);
>> +	igt_assert(metadata);
>> +
>> +	rm.ptr = to_user_pointer(metadata);
>> +	igt_assert_eq(igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0);
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	switch (type) {
>> +	case DRM_XE_DEBUG_METADATA_ELF_BINARY:
>> +		data->bb_offset = metadata[0];
>> +		data->bb_size = metadata[1];
>> +		break;
>> +	case DRM_XE_DEBUG_METADATA_PROGRAM_MODULE:
>> +		data->target_offset = metadata[0];
>> +		data->target_size = metadata[1];
>> +		break;
>> +	default:
>> +		break;
>> +	}
>> +	pthread_mutex_unlock(&data->mutex);
>> +
>> +	free(metadata);
>> +}
>> +
>> +static void create_metadata_trigger(struct xe_eudebug_debugger *d, struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_metadata *em = (void *)e;
>> +
>> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +		read_metadata(d, em->client_handle, em->metadata_handle, em->type, em->len);
>> +	}
>> +}
>> +
>> +static void overwrite_immediate_value_in_common_target_write(int vm_fd, uint64_t offset,
>> +							     uint32_t old_val, uint32_t new_val)
>> +{
>> +	uint64_t addr = offset;
>> +	int vals_changed = 0;
>> +	uint32_t val;
>> +
>> +	while (vals_changed < 4) {
>> +		igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr), sizeof(uint32_t));
>> +		if (val == old_val) {
>> +			igt_debug("val_before_write[%d]: %08x\n", vals_changed, val);
>> +			igt_assert_eq(pwrite(vm_fd, &new_val, sizeof(uint32_t), addr),
>> +				      sizeof(uint32_t));
>> +			igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr),
>> +				      sizeof(uint32_t));
>> +			igt_debug("val_before_fsync[%d]: %08x\n", vals_changed, val);
>> +			fsync(vm_fd);
>> +			igt_assert_eq(pread(vm_fd, &val, sizeof(uint32_t), addr),
>> +				      sizeof(uint32_t));
>> +			igt_debug("val_after_fsync[%d]: %08x\n", vals_changed, val);
>> +			igt_assert_eq_u32(val, new_val);
>> +			vals_changed++;
>> +		}
>> +		addr += sizeof(uint32_t);
>> +	}
>> +}
>> +
>> +static void eu_attention_resume_caching_trigger(struct xe_eudebug_debugger *d,
>> +						struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_eu_attention *att = (void *) e;
>> +	struct online_debug_data *data = d->ptr;
>> +	static int counter = 0;
>> +	static int kernel_in_bb = 0;
>> +	struct dim_t s_dim = surface_dimensions(get_number_of_threads(d->flags));
>> +	int val;
>> +	uint32_t instr_usdw;
>> +	struct gpgpu_shader *kernel;
>> +	const uint32_t breakpoint_bit = 1 << 30;
>> +	struct gpgpu_shader *shader_preamble;
>> +	struct gpgpu_shader *shader_write_instr;
>> +
>> +	shader_preamble = gpgpu_shader_create(d->master_fd);
>> +	gpgpu_shader__write_dword(shader_preamble, SHADER_CANARY, 0);
>> +	gpgpu_shader__nop(shader_preamble);
>> +	gpgpu_shader__breakpoint(shader_preamble);
>> +
>> +	shader_write_instr = gpgpu_shader_create(d->master_fd);
>> +	gpgpu_shader__common_target_write_u32(shader_write_instr, 0, 0);
>> +
>> +	if (!kernel_in_bb) {
>> +		kernel = get_shader(d->master_fd, d->flags);
>> +		kernel_in_bb = find_kernel_in_bb(kernel, data);
>> +		gpgpu_shader_destroy(kernel);
>> +	}
>> +
>> +	/* set breakpoint on next write instruction */
>> +	if (counter < caching_get_instruction_count(d->master_fd, s_dim.x, d->flags)) {
>> +		igt_assert_eq(pread(data->vm_fd, &instr_usdw, sizeof(instr_usdw),
>> +				    data->bb_offset + kernel_in_bb + shader_preamble->size * 4 +
>> +				    shader_write_instr->size * 4 * counter), sizeof(instr_usdw));
>> +		instr_usdw |= breakpoint_bit;
>> +		igt_assert_eq(pwrite(data->vm_fd, &instr_usdw, sizeof(instr_usdw),
>> +				     data->bb_offset + kernel_in_bb + shader_preamble->size * 4 +
>> +				     shader_write_instr->size * 4 * counter), sizeof(instr_usdw));
>> +		fsync(data->vm_fd);
>> +	}
>> +
>> +	/* restore current instruction */
>> +	if (counter && counter <= caching_get_instruction_count(d->master_fd, s_dim.x, d->flags))
>> +		overwrite_immediate_value_in_common_target_write(data->vm_fd,
>> +								 data->bb_offset + kernel_in_bb +
>> +								 shader_preamble->size * 4 +
>> +								 shader_write_instr->size * 4 * (counter - 1),
>> +								 CACHING_POISON_VALUE,
>> +								 CACHING_VALUE(counter - 1));
>> +
>> +	/* poison next instruction */
>> +	if (counter < caching_get_instruction_count(d->master_fd, s_dim.x, d->flags))
>> +		overwrite_immediate_value_in_common_target_write(data->vm_fd,
>> +								 data->bb_offset + kernel_in_bb +
>> +								 shader_preamble->size * 4 +
>> +								 shader_write_instr->size * 4 * counter,
>> +								 CACHING_VALUE(counter),
>> +								 CACHING_POISON_VALUE);
>> +
>> +	gpgpu_shader_destroy(shader_write_instr);
>> +	gpgpu_shader_destroy(shader_preamble);
>> +
>> +	for (int i = 0; i < data->target_size; i += sizeof(uint32_t)) {
>> +		igt_assert_eq(pread(data->vm_fd, &val, sizeof(val), data->target_offset + i),
>> +			      sizeof(val));
>> +		igt_assert_f(val != CACHING_POISON_VALUE, "Poison value found at %04d!\n", i);
>> +	}
>> +
>> +	eu_ctl_resume(d->master_fd, d->fd, att->client_handle,
>> +		      att->exec_queue_handle, att->lrc_handle,
>> +		      att->bitmask, att->bitmask_size);
>> +
>> +	counter++;
>> +}
>> +
>> +static struct intel_bb *xe_bb_create_on_offset(int fd, uint32_t exec_queue, uint32_t vm,
>> +					       uint64_t offset, uint32_t size)
>> +{
>> +	struct intel_bb *ibb;
>> +
>> +	ibb = intel_bb_create_with_context(fd, exec_queue, vm, NULL, size);
>> +
>> +	/* update intel bb offset */
>> +	intel_bb_remove_object(ibb, ibb->handle, ibb->batch_offset, ibb->size);
>> +	intel_bb_add_object(ibb, ibb->handle, ibb->size, offset, ibb->alignment, false);
>> +	ibb->batch_offset = offset;
>> +
>> +	return ibb;
>> +}
>> +
>> +static size_t get_bb_size(int flags)
>> +{
>> +	if ((flags & SHADER_CACHING_SRAM) || (flags & SHADER_CACHING_VRAM))
>> +		return 32768;
>> +
>> +	return 4096;
>> +}
>> +
>> +static void run_online_client(struct xe_eudebug_client *c)
>> +{
>> +	int threads = get_number_of_threads(c->flags);
>> +	const uint64_t target_offset = 0x1a000000;
>> +	const uint64_t bb_offset = 0x1b000000;
>> +	const size_t bb_size = get_bb_size(c->flags);
>> +	struct online_debug_data *data = c->ptr;
>> +	struct drm_xe_engine_class_instance hwe = data->hwe;
>> +	struct drm_xe_ext_set_property ext = {
>> +		.base.name = DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
>> +		.property = DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG,
>> +		.value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE,
>> +	};
>> +	struct drm_xe_exec_queue_create create = {
>> +		.instances = to_user_pointer(&hwe),
>> +		.width = 1,
>> +		.num_placements = 1,
>> +		.extensions = c->flags & DISABLE_DEBUG_MODE ? 0 : to_user_pointer(&ext)
>> +	};
>> +	struct dim_t w_dim = walker_dimensions(threads);
>> +	struct dim_t s_dim = surface_dimensions(threads);
>> +	struct timespec ts = { };
>> +	struct gpgpu_shader *sip, *shader;
>> +	uint32_t metadata_id[2];
>> +	uint64_t *metadata[2];
>> +	struct intel_bb *ibb;
>> +	struct intel_buf *buf;
>> +	uint32_t *ptr;
>> +	int fd;
>> +
>> +	metadata[0] = calloc(2, sizeof(*metadata));
>> +	metadata[1] = calloc(2, sizeof(*metadata));
>> +	igt_assert(metadata[0]);
>> +	igt_assert(metadata[1]);
>> +
>> +	fd = xe_eudebug_client_open_driver(c);
>> +	xe_device_get(fd);
>> +
>> +	/* Additional memory for steering control */
>> +	if (c->flags & SHADER_LOOP || c->flags & SHADER_SINGLE_STEP)
>> +		s_dim.y++;
>> +	/* Additional memory for caching check */
>> +	if ((c->flags & SHADER_CACHING_SRAM) || (c->flags & SHADER_CACHING_VRAM))
>> +		s_dim.y += caching_get_instruction_count(fd, s_dim.x, c->flags);
>> +	buf = create_uc_buf(fd, s_dim.x, s_dim.y);
>> +
>> +	buf->addr.offset = target_offset;
>> +
>> +	metadata[0][0] = bb_offset;
>> +	metadata[0][1] = bb_size;
>> +	metadata[1][0] = target_offset;
>> +	metadata[1][1] = buf->size;
>> +	metadata_id[0] = xe_eudebug_client_metadata_create(c, fd, DRM_XE_DEBUG_METADATA_ELF_BINARY,
>> +							   2 * sizeof(*metadata), metadata[0]);
>> +	metadata_id[1] = xe_eudebug_client_metadata_create(c, fd,
>> +							   DRM_XE_DEBUG_METADATA_PROGRAM_MODULE,
>> +							   2 * sizeof(*metadata), metadata[1]);
>> +
>> +	create.vm_id = xe_eudebug_client_vm_create(c, fd, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
>> +	xe_eudebug_client_exec_queue_create(c, fd, &create);
>> +
>> +	ibb = xe_bb_create_on_offset(fd, create.exec_queue_id, create.vm_id,
>> +				     bb_offset, bb_size);
>> +	intel_bb_set_lr_mode(ibb, true);
>> +
>> +	sip = get_sip(fd, c->flags);
>> +	shader = get_shader(fd, c->flags);
>> +
>> +	igt_nsec_elapsed(&ts);
>> +	gpgpu_shader_exec(ibb, buf, w_dim.x, w_dim.y, shader, sip, 0, 0);
>> +
>> +	gpgpu_shader_destroy(sip);
>> +	gpgpu_shader_destroy(shader);
>> +
>> +	intel_bb_sync(ibb);
>> +
>> +	if (c->flags & TRIGGER_RECONNECT)
>> +		xe_eudebug_client_wait_stage(c, DEBUGGER_REATTACHED);
>> +	else
>> +		/* Make sure it wasn't the timeout. */
>> +		igt_assert(igt_nsec_elapsed(&ts) <
>> +			   XE_EUDEBUG_DEFAULT_TIMEOUT_MS / MSEC_PER_SEC * NSEC_PER_SEC);
>> +
>> +	if (!(c->flags & DO_NOT_EXPECT_CANARIES)) {
>> +		ptr = xe_bo_mmap_ext(fd, buf->handle, buf->size, PROT_READ);
>> +		data->threads_count = count_canaries_neq(ptr, w_dim, 0);
>> +		igt_assert_f(data->threads_count, "No canaries found, nothing executed?\n");
>> +
>> +		if ((c->flags & SHADER_BREAKPOINT || c->flags & TRIGGER_RESUME_SET_BP ||
>> +		     c->flags & SHADER_N_NOOP_BREAKPOINT) && !(c->flags & DISABLE_DEBUG_MODE)) {
>> +			uint32_t aip = ptr[0];
>> +
>> +			igt_assert_f(aip != SHADER_CANARY, "Workload executed but breakpoint not hit!\n");
>> +			igt_assert_eq(count_canaries_eq(ptr, w_dim, aip), data->threads_count);
>> +			igt_debug("Breakpoint hit in %d threads, AIP=0x%08x\n", data->threads_count, aip);
>> +		}
>> +
>> +		munmap(ptr, buf->size);
>> +	}
>> +
>> +	intel_bb_destroy(ibb);
>> +
>> +	xe_eudebug_client_exec_queue_destroy(c, fd, &create);
>> +	xe_eudebug_client_vm_destroy(c, fd,  create.vm_id);
>> +
>> +	xe_eudebug_client_metadata_destroy(c, fd, metadata_id[0], DRM_XE_DEBUG_METADATA_ELF_BINARY,
>> +					   2 * sizeof(*metadata));
>> +	xe_eudebug_client_metadata_destroy(c, fd, metadata_id[1],
>> +					   DRM_XE_DEBUG_METADATA_PROGRAM_MODULE,
>> +					   2 * sizeof(*metadata));
>> +
>> +	xe_device_put(fd);
>> +	xe_eudebug_client_close_driver(c, fd);
>> +}
>> +
>> +static bool intel_gen_has_lockstep_eus(int fd)
>> +{
>> +	const uint32_t id = intel_get_drm_devid(fd);
>> +
>> +	/*
>> +	 * Lockstep (or in some parlance, fused) EUs are pair of EUs
>> +	 * that work in sync, supposedly same clock and same control flow.
>> +	 * Thus for attentions, if the control has breakpoint, both will be
>> +	 * excepted into SIP. In this level, the hardware has only one attention
>> +	 * thread bit for units. PVC is the first one without lockstepping.
>> +	 */
>> +	return !(intel_graphics_ver(id) == IP_VER(12, 60) || intel_gen(id) >= 20);
>> +}
>> +
>> +static int query_attention_bitmask_size(int fd, int gt)
>> +{
>> +	const unsigned int threads = 8;
>> +	struct drm_xe_query_topology_mask *c_dss = NULL, *g_dss = NULL, *eu_per_dss = NULL;
>> +	struct drm_xe_query_topology_mask *topology;
>> +	struct drm_xe_device_query query = {
>> +		.extensions = 0,
>> +		.query = DRM_XE_DEVICE_QUERY_GT_TOPOLOGY,
>> +		.size = 0,
>> +		.data = 0,
>> +	};
>> +	int pos = 0, eus;
>> +	uint8_t *any_dss;
>> +
>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEVICE_QUERY, &query), 0);
>> +	igt_assert_neq(query.size, 0);
>> +
>> +	topology = malloc(query.size);
>> +	igt_assert(topology);
>> +
>> +	query.data = to_user_pointer(topology);
>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEVICE_QUERY, &query), 0);
>> +
>> +	while (query.size >= sizeof(struct drm_xe_query_topology_mask)) {
>> +		struct drm_xe_query_topology_mask *topo;
>> +		int sz;
>> +
>> +		topo = (struct drm_xe_query_topology_mask *)((unsigned char *)topology + pos);
>> +		sz = sizeof(struct drm_xe_query_topology_mask) + topo->num_bytes;
>> +
>> +		query.size -= sz;
>> +		pos += sz;
>> +
>> +		if (topo->gt_id != gt)
>> +			continue;
>> +
>> +		if (topo->type == DRM_XE_TOPO_DSS_GEOMETRY)
>> +			g_dss = topo;
>> +		else if (topo->type == DRM_XE_TOPO_DSS_COMPUTE)
>> +			c_dss = topo;
>> +		else if (topo->type == DRM_XE_TOPO_EU_PER_DSS ||
>> +			 topo->type == DRM_XE_TOPO_SIMD16_EU_PER_DSS)
>> +			eu_per_dss = topo;
>> +	}
>> +
>> +	igt_assert(g_dss && c_dss && eu_per_dss);
>> +	igt_assert_eq_u32(c_dss->num_bytes, g_dss->num_bytes);
>> +
>> +	any_dss = malloc(c_dss->num_bytes);
>> +
>> +	for (int i = 0; i < c_dss->num_bytes; i++)
>> +		any_dss[i] = c_dss->mask[i] | g_dss->mask[i];
>> +
>> +	eus = count_set_bits(any_dss, c_dss->num_bytes);
>> +	eus *= count_set_bits(eu_per_dss->mask, eu_per_dss->num_bytes);
>> +
>> +	if (intel_gen_has_lockstep_eus(fd))
>> +		eus /= 2;
>> +
>> +	free(any_dss);
>> +	free(topology);
>> +
>> +	return eus * threads / 8;
>> +}
>> +
>> +static struct drm_xe_eudebug_event_exec_queue *
>> +match_attention_with_exec_queue(struct xe_eudebug_event_log *log,
>> +				struct drm_xe_eudebug_event_eu_attention *ea)
>> +{
>> +	struct drm_xe_eudebug_event_exec_queue *ee;
>> +	struct drm_xe_eudebug_event *event = NULL, *current = NULL, *matching_destroy = NULL;
>> +	int lrc_idx;
>> +
>> +	xe_eudebug_for_each_event(event, log) {
>> +		if (event->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE &&
>> +		    event->flags == DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +			ee = (struct drm_xe_eudebug_event_exec_queue *)event;
>> +
>> +			if (ee->exec_queue_handle != ea->exec_queue_handle)
>> +				continue;
>> +
>> +			if (ee->client_handle != ea->client_handle)
>> +				continue;
>> +
>> +			for (lrc_idx = 0; lrc_idx < ee->width; lrc_idx++) {
>> +				if (ee->lrc_handle[lrc_idx] == ea->lrc_handle)
>> +					break;
>> +			}
>> +
>> +			if (lrc_idx >= ee->width) {
>> +				igt_debug("No matching lrc handle within matching exec_queue!");
>> +				continue;
>> +			}
>> +
>> +			/* event logs are sorted, every found next would not be present. */
>> +			if (ea->base.seqno < ee->base.seqno)
>> +				break;
>> +
>> +			/* sanity check whether attention did
>> +			 * not appear yet on already destroyed exec_queue
>> +			 */
>> +			current = event;
>> +			xe_eudebug_for_each_event(current, log) {
>> +				if (current->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE &&
>> +				    current->flags == DRM_XE_EUDEBUG_EVENT_DESTROY) {
>> +					uint8_t offset = sizeof(struct drm_xe_eudebug_event);
>> +
>> +					if (memcmp((uint8_t *)current + offset,
>> +						   (uint8_t *)event + offset,
>> +						   current->len - offset) == 0) {
>> +						matching_destroy = current;
>> +					}
>> +				}
>> +			}
>> +
>> +			if (!matching_destroy || ea->base.seqno > matching_destroy->seqno)
>> +				continue;
>> +
>> +			return ee;
>> +		}
>> +	}
>> +
>> +	return NULL;
>> +}
>> +
>> +static void online_session_check(struct xe_eudebug_session *s, int flags)
>> +{
>> +	struct drm_xe_eudebug_event_eu_attention *ea = NULL;
>> +	struct drm_xe_eudebug_event *event = NULL;
>> +	struct online_debug_data *data = s->c->ptr;
>> +	bool expect_exception = flags & DISABLE_DEBUG_MODE ? false : true;
>> +	int sum = 0;
>> +	int bitmask_size;
>> +
>> +	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_UFENCE);
>> +
>> +	bitmask_size = query_attention_bitmask_size(s->d->master_fd, data->hwe.gt_id);
>> +
>> +	xe_eudebug_for_each_event(event, s->d->log) {
>> +		if (event->type == DRM_XE_EUDEBUG_EVENT_EU_ATTENTION) {
>> +			ea = (struct drm_xe_eudebug_event_eu_attention *)event;
>> +
>> +			igt_assert(event->flags == DRM_XE_EUDEBUG_EVENT_STATE_CHANGE);
>> +			igt_assert_eq(ea->bitmask_size, bitmask_size);
>> +			sum += count_set_bits(ea->bitmask, bitmask_size);
>> +			igt_assert(match_attention_with_exec_queue(s->d->log, ea));
>> +		}
>> +	}
>> +
>> +	/*
>> +	 * We can expect attention to sum up only
>> +	 * if we have a breakpoint set and we resume all threads always.
>> +	 */
>> +	if (flags == SHADER_BREAKPOINT)
>> +		igt_assert_eq(sum, data->threads_count);
>> +
>> +	if (expect_exception)
>> +		igt_assert(sum > 0);
>> +	else
>> +		igt_assert(sum == 0);
>> +}
>> +
>> +static void ufence_ack_trigger(struct xe_eudebug_debugger *d,
>> +			       struct drm_xe_eudebug_event *e)
>> +{
>> +	struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e;
>> +
>> +	if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE)
>> +		xe_eudebug_ack_ufence(d->fd, ef);
>> +}
>> +
>> +/**
>> + * SUBTEST: basic-breakpoint
>> + * Description:
>> + *	Check whether KMD sends attention events
>> + *	for workload in debug mode stopped on breakpoint.
>> + *
>> + * SUBTEST: breakpoint-not-in-debug-mode
>> + * Description:
>> + *	Check whether KMD resets the GPU when it spots an attention
>> + *	coming from workload not in debug mode.
>> + *
>> + * SUBTEST: stopped-thread
>> + * Description:
>> + *	Hits breakpoint on runalone workload and
>> + *	reads attention for fixed time.
>> + *
>> + * SUBTEST: resume-%s
>> + * Description:
>> + *	Resumes stopped on a breakpoint workload
>> + *	with granularity of %arg[1].
>> + *
>> + *
>> + * arg[1]:
>> + *
>> + * @one:	one thread
>> + * @dss:	threads running on one subslice
>> + */
>> +static void test_basic_online(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	xe_eudebug_session_run(s);
>> +	online_session_check(s, s->flags);
>> +
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +/**
>> + * SUBTEST: preempt-breakpoint
>> + * Description:
>> + *	Verify that eu debugger disables preemption timeout to
>> + *	prevent reset of workload stopped on breakpoint.
>> + */
>> +static void test_preemption(int fd, struct drm_xe_engine_class_instance *hwe)
>> +{
>> +	int flags = SHADER_BREAKPOINT | TRIGGER_RESUME_DELAYED;
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +	struct xe_eudebug_client *other;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +	other = xe_eudebug_client_create(fd, run_online_client, SHADER_NOP, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
>> +	xe_eudebug_debugger_start_worker(s->d);
>> +
>> +	xe_eudebug_client_start(s->c);
>> +	sleep(1); /* make sure s->c starts first */
>> +	xe_eudebug_client_start(other);
>> +
>> +	xe_eudebug_client_wait_done(s->c);
>> +	xe_eudebug_client_wait_done(other);
>> +
>> +	xe_eudebug_debugger_stop_worker(s->d, 1);
>> +
>> +	xe_eudebug_session_destroy(s);
>> +	xe_eudebug_client_destroy(other);
>> +
>> +	igt_assert_f(data->last_eu_control_seqno != 0,
>> +		     "Workload with breakpoint has ended without resume!\n");
>> +
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +/**
>> + * SUBTEST: reset-with-attention
>> + * Description:
>> + *	Check whether GPU is usable after resetting with attention raised
>> + *	(stopped on breakpoint) by running the same workload again.
>> + */
>> +static void test_reset_with_attention_online(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s1, *s2;
>> +	struct online_debug_data *data;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s1 = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s1->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_reset_trigger);
>> +	xe_eudebug_debugger_add_trigger(s1->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	xe_eudebug_session_run(s1);
>> +	xe_eudebug_session_destroy(s1);
>> +
>> +	s2 = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +	xe_eudebug_debugger_add_trigger(s2->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_trigger);
>> +	xe_eudebug_debugger_add_trigger(s2->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	xe_eudebug_session_run(s2);
>> +
>> +	online_session_check(s2, s2->flags);
>> +
>> +	xe_eudebug_session_destroy(s2);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +/**
>> + * SUBTEST: interrupt-all
>> + * Description:
>> + *	Schedules EU workload which should last about a few seconds, then
>> + *	interrupts all threads, checks whether attention event came, and
>> + *	resumes stopped threads back.
>> + *
>> + * SUBTEST: interrupt-all-set-breakpoint
>> + * Description:
>> + *	Schedules EU workload which should last about a few seconds, then
>> + *	interrupts all threads, once attention event come it sets breakpoint on
>> + *	the very next instruction and resumes stopped threads back. It expects
>> + *	that every thread hits the breakpoint.
>> + */
>> +static void test_interrupt_all(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +	uint32_t val;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
>> +					open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>> +					exec_queue_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
>> +					create_metadata_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
>> +	xe_eudebug_debugger_start_worker(s->d);
>> +	xe_eudebug_client_start(s->c);
>> +
>> +	/* wait for workload to start */
>> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
>> +		/* collect needed data from triggers */
>> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
>> +			continue;
>> +
>> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
>> +			if (val != 0)
>> +				break;
>> +	}
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	igt_assert(data->client_handle != -1);
>> +	igt_assert(data->exec_queue_handle != -1);
>> +	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
>> +			     data->exec_queue_handle, data->lrc_handle);
>> +	pthread_mutex_unlock(&data->mutex);
>> +
>> +	xe_eudebug_client_wait_done(s->c);
>> +
>> +	xe_eudebug_debugger_stop_worker(s->d, 1);
>> +
>> +	xe_eudebug_event_log_print(s->d->log, true);
>> +	xe_eudebug_event_log_print(s->c->log, true);
>> +
>> +	online_session_check(s, s->flags);
>> +
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +static void reset_debugger_log(struct xe_eudebug_debugger *d)
>> +{
>> +	unsigned int max_size;
>> +	char log_name[80];
>> +
>> +	/* Don't pull the rug out from under an active debugger */
>> +	igt_assert(d->target_pid == 0);
>> +
>> +	max_size = d->log->max_size;
>> +	strncpy(log_name, d->log->name, sizeof(d->log->name) - 1);
>> +	log_name[79] = '\0';
>> +	xe_eudebug_event_log_destroy(d->log);
>> +	d->log = xe_eudebug_event_log_create(log_name, max_size);
>> +}
>> +
>> +/**
>> + * SUBTEST: interrupt-other-debuggable
>> + * Description:
>> + *	Schedules EU workload in runalone mode with never ending loop, while
>> + *	it is not under debug, tries to interrupt all threads using the different
>> + *	client attached to debugger.
>> + *
>> + * SUBTEST: interrupt-other
>> + * Description:
>> + * 	Schedules EU workload with a never ending loop and, while it is not
>> + * 	configured for debugging, tries to interrupt all threads using the client
>> + * 	attached to debugger.
>> + */
>> +static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct online_debug_data *data;
>> +	struct online_debug_data *debugee_data;
>> +	struct xe_eudebug_session *s;
>> +	struct xe_eudebug_client *debugee;
>> +	int debugee_flags = SHADER_LOOP | DO_NOT_EXPECT_CANARIES;
>> +	int val;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>> +					exec_queue_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
>> +					create_metadata_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
>> +	xe_eudebug_debugger_start_worker(s->d);
>> +	xe_eudebug_client_start(s->c);
>> +
>> +	/* wait for workload to start */
>> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
>> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
>> +			continue;
>> +
>> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
>> +			if (val != 0)
>> +				break;
>> +	}
>> +	igt_assert_f(val != 0, "Workload execution is not yet started\n");
>> +
>> +	xe_eudebug_debugger_dettach(s->d);
>> +	reset_debugger_log(s->d);
>> +
>> +	debugee_data = online_debug_data_create(hwe);
>> +	s->d->ptr = debugee_data;
>> +	debugee = xe_eudebug_client_create(fd, run_online_client, debugee_flags, debugee_data);
>> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, debugee), 0);
>> +	xe_eudebug_client_start(debugee);
>> +
>> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
>> +		if (READ_ONCE(debugee_data->vm_fd) == -1 || READ_ONCE(debugee_data->target_size) == 0)
>> +			continue;
>> +	}
>> +
>> +	pthread_mutex_lock(&debugee_data->mutex);
>> +	igt_assert(debugee_data->client_handle != -1);
>> +	igt_assert(debugee_data->exec_queue_handle != -1);
>> +	/* Interrupting the other client should return invalid state
>> +	 * as it is running in runalone mode */
>> +	igt_assert_eq(__eu_ctl(s->d->fd, debugee_data->client_handle,
>> +		       debugee_data->exec_queue_handle, debugee_data->lrc_handle,
>> +		       NULL, 0, DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL), -EINVAL);
>> +	pthread_mutex_unlock(&debugee_data->mutex);
>> +
>> +	xe_force_gt_reset_async(s->d->master_fd, debugee_data->hwe.gt_id);
>> +
>> +	xe_eudebug_client_wait_done(debugee);
>> +	xe_eudebug_debugger_stop_worker(s->d, 1);
>> +
>> +	xe_eudebug_event_log_print(s->d->log, true);
>> +	xe_eudebug_event_log_print(debugee->log, true);
>> +
>> +	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND |
>> +				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP |
>> +				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
>> +
>> +	xe_eudebug_client_destroy(debugee);
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +	online_debug_data_destroy(debugee_data);
>> +}
>> +
>> +/**
>> + * SUBTEST: tdctl-parameters
>> + * Description:
>> + *	Schedules EU workload which should last about a few seconds, then
>> + *	checks negative scenarios of EU_THREADS ioctl usage, interrupts all threads,
>> + *	checks whether attention event came, and resumes stopped threads back.
>> + */
>> +static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +	uint32_t val;
>> +	uint32_t random_command;
>> +	uint32_t bitmask_size = query_attention_bitmask_size(fd, hwe->gt_id);
>> +	uint8_t *attention_bitmask = malloc(bitmask_size * sizeof(uint8_t));
>> +	igt_assert(attention_bitmask);
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
>> +					open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>> +					exec_queue_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
>> +					create_metadata_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
>> +	xe_eudebug_debugger_start_worker(s->d);
>> +	xe_eudebug_client_start(s->c);
>> +
>> +	/* wait for workload to start */
>> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
>> +		/* collect needed data from triggers */
>> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
>> +			continue;
>> +
>> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
>> +			if (val != 0)
>> +				break;
>> +	}
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	igt_assert(data->client_handle != -1);
>> +	igt_assert(data->exec_queue_handle != -1);
>> +	igt_assert(data->lrc_handle != -1);
>> +
>> +	/* fail on invalid lrc_handle */
>> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
>> +			    data->exec_queue_handle, data->lrc_handle + 1,
>> +			    attention_bitmask, &bitmask_size,
>> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
>> +
>> +	/* fail on invalid exec_queue_handle */
>> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
>> +			    data->exec_queue_handle + 1, data->lrc_handle,
>> +			    attention_bitmask, &bitmask_size,
>> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
>> +
>> +	/* fail on invalid client */
>> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle + 1,
>> +			    data->exec_queue_handle, data->lrc_handle,
>> +			    attention_bitmask, &bitmask_size,
>> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL);
>> +
>> +	/*
>> +	 * bitmask size must be aligned to sizeof(u32) for all commands
>> +	 * and be zero for interrupt all
>> +	 */
>> +	bitmask_size = sizeof(uint32_t) - 1;
>> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
>> +			    data->exec_queue_handle, data->lrc_handle,
>> +			    attention_bitmask, &bitmask_size,
>> +			    DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED, NULL) == -EINVAL);
>> +	bitmask_size = 0;
>> +
>> +	/* fail on invalid command */
>> +	random_command = random() | (DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME + 1);
>> +	igt_assert(__eu_ctl(s->d->fd, data->client_handle,
>> +			    data->exec_queue_handle, data->lrc_handle,
>> +			    attention_bitmask, &bitmask_size, random_command, NULL) == -EINVAL);
>> +
>> +	free(attention_bitmask);
>> +
>> +	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
>> +			     data->exec_queue_handle, data->lrc_handle);
>> +	pthread_mutex_unlock(&data->mutex);
>> +
>> +	xe_eudebug_client_wait_done(s->c);
>> +
>> +	xe_eudebug_debugger_stop_worker(s->d, 1);
>> +
>> +	xe_eudebug_event_log_print(s->d->log, true);
>> +	xe_eudebug_event_log_print(s->c->log, true);
>> +
>> +	online_session_check(s, s->flags);
>> +
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +static void eu_attention_debugger_detach_trigger(struct xe_eudebug_debugger *d,
>> +						 struct drm_xe_eudebug_event *event)
>> +{
>> +	struct online_debug_data *data = d->ptr;
>> +	uint64_t c_pid;
>> +	int ret;
>> +
>> +	c_pid = d->target_pid;
>> +
>> +	/* Reset VM data so the re-triggered VM open handler works properly */
>> +	data->vm_fd = -1;
>> +
>> +	xe_eudebug_debugger_dettach(d);
>> +
>> +	/* Let the KMD scan function notice unhandled EU attention */
>> +	if (!(d->flags & SHADER_N_NOOP_BREAKPOINT))
>> +		sleep(1);
>> +
>> +	/*
>> +	 * New session that is created by EU debugger on reconnect restarts
>> +	 * seqno, causing isses with log sorting. To avoid that, create
>> +	 * a new event log.
>> +	 */
>> +	reset_debugger_log(d);
>> +
>> +	ret = xe_eudebug_connect(d->master_fd, c_pid, 0);
>> +	igt_assert(ret >= 0);
>> +	d->fd = ret;
>> +	d->target_pid = c_pid;
>> +
>> +	/* Let the discovery worker discover resources */
>> +	sleep(2);
>> +
>> +	if (!(d->flags & SHADER_N_NOOP_BREAKPOINT))
>> +		xe_eudebug_debugger_signal_stage(d, DEBUGGER_REATTACHED);
>> +}
>> +
>> +/**
>> + * SUBTEST: interrupt-reconnect
>> + * Description:
>> + *	Schedules EU workload which should last about a few seconds,
>> + *	interrupts all threads and detaches debugger when attention is
>> + *	raised. The test checks if KMD resets the workload when there's
>> + *	no debugger attached and does the event playback on discovery.
>> + */
>> +static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct drm_xe_eudebug_event *e = NULL;
>> +	struct online_debug_data *data;
>> +	struct xe_eudebug_session *s;
>> +	uint32_t val;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
>> +					open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>> +					exec_queue_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debugger_detach_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
>> +					create_metadata_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	igt_assert_eq(xe_eudebug_debugger_attach(s->d, s->c), 0);
>> +	xe_eudebug_debugger_start_worker(s->d);
>> +	xe_eudebug_client_start(s->c);
>> +
>> +	/* wait for workload to start */
>> +	igt_for_milliseconds(STARTUP_TIMEOUT_MS) {
>> +		/* collect needed data from triggers */
>> +		if (READ_ONCE(data->vm_fd) == -1 || READ_ONCE(data->target_size) == 0)
>> +			continue;
>> +
>> +		if (pread(data->vm_fd, &val, sizeof(val), data->target_offset) == sizeof(val))
>> +			if (val != 0)
>> +				break;
>> +	}
>> +
>> +	pthread_mutex_lock(&data->mutex);
>> +	igt_assert(data->client_handle != -1);
>> +	igt_assert(data->exec_queue_handle != -1);
>> +	eu_ctl_interrupt_all(s->d->fd, data->client_handle,
>> +			     data->exec_queue_handle, data->lrc_handle);
>> +	pthread_mutex_unlock(&data->mutex);
>> +
>> +	xe_eudebug_client_wait_done(s->c);
>> +
>> +	xe_eudebug_debugger_stop_worker(s->d, 1);
>> +
>> +	xe_eudebug_event_log_print(s->d->log, true);
>> +	xe_eudebug_event_log_print(s->c->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_UFENCE);
>> +
>> +	/* We expect workload reset, so no attention should be raised */
>> +	xe_eudebug_for_each_event(e, s->d->log)
>> +		igt_assert(e->type != DRM_XE_EUDEBUG_EVENT_EU_ATTENTION);
>> +
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +/**
>> + * SUBTEST: single-step
>> + * Description:
>> + *	Schedules EU workload with 16 nops after breakpoint, then single-steps
>> + *	through the shader, advances all threads each step, checking if all
>> + *	threads advanced every step.
>> + *
>> + * SUBTEST: single-step-one
>> + * Description:
>> + *	Schedules EU workload with 16 nops after breakpoint, then single-steps
>> + *	through the shader, advances one thread each step, checking if one
>> + *	thread advanced every step. Due to the time constraint, only first two
>> + *	shader instructions after breakpoint are validated.
>> + */
>> +static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
>> +					open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_single_step_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
>> +					create_metadata_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	xe_eudebug_session_run(s);
>> +	online_session_check(s, s->flags);
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +static void eu_attention_debugger_ndetach_trigger(struct xe_eudebug_debugger *d,
>> +						 struct drm_xe_eudebug_event *event)
>> +{
>> +	static int debugger_detach_count;
>> +
>> +	if (debugger_detach_count < (SHADER_LOOP_N - 1)) {
>> +		/* Make sure the resume command has issued before detaching the debugger */
>> +		if (!is_client_resumed)
>> +			return;
> Not sure what we are trying to achieve here. I think triggers are executed in the same order as
> added, so this should be ensured. But anyway, I think we could just resue data-
>> last_eu_control_seqno. If its greater than seqno of this event we are free to reattach.

Makes sense, thanks - will change it in the next version.

Christoph

> 
> Regards,
> Dominik
> 
>> +		eu_attention_debugger_detach_trigger(d, event);
>> +		debugger_detach_count++;
>> +	} else {
>> +		igt_debug("Reached Nth breakpoint hence preventing the debugger detach\n");
>> +	}
>> +	is_client_resumed = 0;
>> +}
>> +
>> +/**
>> + * SUBTEST: debugger-reopen
>> + * Description:
>> + *	Check whether the debugger is able to reopen the connection and
>> + *	capture the events of already running client.
>> + */
>> +static void test_debugger_reopen(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +
>> +	data = online_debug_data_create(hwe);
>> +
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debugger_ndetach_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	xe_eudebug_session_run(s);
>> +
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +/**
>> + * SUBTEST: writes-caching-%s
>> + * Description:
>> + *	Write incrementing values to 2-page-long target surface, poisoning the data one breakpoint
>> + *	before each write instruction and restoring it when the poisoned instruction breakpoint
>> + *	is hit. Expect to never see poison values in target surface.
>> + *
>> + *
>> + * arg[1]:
>> + *
>> + * @sram:	Use page size of SRAM
>> + * @vram:	Use page size of VRAM
>> + */
>> +static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int flags)
>> +{
>> +	struct xe_eudebug_session *s;
>> +	struct online_debug_data *data;
>> +
>> +	if (flags & SHADER_CACHING_VRAM)
>> +		igt_skip_on_f(!xe_has_vram(fd), "Device does not have VRAM.\n");
>> +
>> +	data = online_debug_data_create(hwe);
>> +	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
>> +
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_OPEN,
>> +					open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_debug_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +					eu_attention_resume_caching_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_METADATA,
>> +					create_metadata_trigger);
>> +	xe_eudebug_debugger_add_trigger(s->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +					ufence_ack_trigger);
>> +
>> +	xe_eudebug_session_run(s);
>> +	online_session_check(s, s->flags);
>> +	xe_eudebug_session_destroy(s);
>> +	online_debug_data_destroy(data);
>> +}
>> +
>> +static int wait_for_exception(struct online_debug_data *data, int timeout)
>> +{
>> +	int ret = -ETIMEDOUT;
>> +
>> +	igt_for_milliseconds(timeout) {
>> +		pthread_mutex_lock(&data->mutex);
>> +		if ((data->exception_arrived.tv_sec |
>> +		     data->exception_arrived.tv_nsec) != 0)
>> +			ret = 0;
>> +		pthread_mutex_unlock(&data->mutex);
>> +
>> +		if (!ret)
>> +			break;
>> +		usleep(1000);
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +#define is_compute_on_gt(__e, __gt) ((__e->engine_class == DRM_XE_ENGINE_CLASS_RENDER || \
>> +				      __e->engine_class == DRM_XE_ENGINE_CLASS_COMPUTE) && \
>> +				      __e->gt_id == __gt)
>> +
>> +struct xe_engine_list_entry {
>> +	struct igt_list_head link;
>> +	struct drm_xe_engine_class_instance *hwe;
>> +};
>> +
>> +#define MAX_TILES	2
>> +static int find_suitable_engines(struct drm_xe_engine_class_instance *hwes[GEM_MAX_ENGINES],
>> +				 int fd, bool many_tiles)
>> +{
>> +	struct xe_device *xe_dev;
>> +	struct drm_xe_engine_class_instance *e;
>> +	struct xe_engine_list_entry *en, *tmp;
>> +	struct igt_list_head compute_engines[MAX_TILES];
>> +	int gt_id;
>> +	int tile_id, i, engine_count = 0, tile_count = 0;
>> +
>> +	xe_dev = xe_device_get(fd);
>> +
>> +	for (i = 0; i < MAX_TILES; i++)
>> +		IGT_INIT_LIST_HEAD(&compute_engines[i]);
>> +
>> +	xe_for_each_gt(fd, gt_id) {
>> +		xe_for_each_engine(fd, e) {
>> +			if (is_compute_on_gt(e, gt_id)) {
>> +				tile_id = xe_dev->gt_list->gt_list[gt_id].tile_id;
>> +
>> +				en = malloc(sizeof(struct xe_engine_list_entry));
>> +				en->hwe = e;
>> +
>> +				igt_list_add_tail(&en->link, &compute_engines[tile_id]);
>> +			}
>> +		}
>> +	}
>> +
>> +	for (i = 0; i < MAX_TILES; i++) {
>> +		if (igt_list_empty(&compute_engines[i]))
>> +			continue;
>> +
>> +		if (many_tiles) {
>> +			en = igt_list_first_entry(&compute_engines[i], en, link);
>> +			hwes[engine_count++] = en->hwe;
>> +			tile_count++;
>> +		} else {
>> +			if (igt_list_length(&compute_engines[i]) > 1) {
>> +				igt_list_for_each_entry(en, &compute_engines[i], link)
>> +					hwes[engine_count++] = en->hwe;
>> +				break;
>> +			}
>> +		}
>> +	}
>> +
>> +	for (i = 0; i < MAX_TILES; i++) {
>> +		igt_list_for_each_entry_safe(en, tmp, &compute_engines[i], link) {
>> +			igt_list_del(&en->link);
>> +			free(en);
>> +		}
>> +	}
>> +
>> +	if (many_tiles)
>> +		igt_require_f(tile_count > 1, "Mulit-tile scenario requires more tiles\n");
>> +
>> +	return engine_count;
>> +}
>> +
>> +/**
>> + * SUBTEST: breakpoint-many-sessions-single-tile
>> + * Description:
>> + *	Schedules EU workload with preinstalled breakpoint on every compute engine
>> + *	available on the tile. Checks if the contexts hit breakpoint in sequence
>> + *	and resumes them.
>> + *
>> + * SUBTEST: breakpoint-many-sessions-tiles
>> + * Description:
>> + *	Schedules EU workload with preinstalled breakpoint on selected compute
>> + *      engines, with one per tile. Checks if each context hit breakpoint and
>> + *      resumes them.
>> + */
>> +static void test_many_sessions_on_tiles(int fd, bool multi_tile)
>> +{
>> +	int n = 0, flags = SHADER_BREAKPOINT | SHADER_MIN_THREADS;
>> +	struct xe_eudebug_session *s[GEM_MAX_ENGINES] = {};
>> +	struct online_debug_data *data[GEM_MAX_ENGINES] = {};
>> +	struct drm_xe_engine_class_instance *hwe[GEM_MAX_ENGINES] = {};
>> +	struct drm_xe_eudebug_event_eu_attention *eus;
>> +	uint64_t current_t, next_t, diff;
>> +	int i;
>> +
>> +	n = find_suitable_engines(hwe, fd, multi_tile);
>> +
>> +	igt_require_f(n > 1, "Test requires at least two parallel compute engines!\n");
>> +
>> +	for (i = 0; i < n; i++) {
>> +		data[i] = online_debug_data_create(hwe[i]);
>> +		s[i] = xe_eudebug_session_create(fd, run_online_client, flags, data[i]);
>> +
>> +		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +						eu_attention_debug_trigger);
>> +		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
>> +						save_first_exception_trigger);
>> +		xe_eudebug_debugger_add_trigger(s[i]->d, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +						ufence_ack_trigger);
>> +
>> +		igt_assert_eq(xe_eudebug_debugger_attach(s[i]->d, s[i]->c), 0);
>> +
>> +		xe_eudebug_debugger_start_worker(s[i]->d);
>> +		xe_eudebug_client_start(s[i]->c);
>> +	}
>> +
>> +	for (i = 0; i < n; i++) {
>> +		/* XXX: Sometimes racy, expects clients to execute in sequence */
>> +		igt_assert(!wait_for_exception(data[i], STARTUP_TIMEOUT_MS));
>> +
>> +		eus = (struct drm_xe_eudebug_event_eu_attention *)data[i]->exception_event;
>> +
>> +		/* Delay all but the last workload to check serialization */
>> +		if (i < n - 1)
>> +			usleep(WORKLOAD_DELAY_US);
>> +
>> +		eu_ctl_resume(s[i]->d->master_fd, s[i]->d->fd,
>> +			      eus->client_handle, eus->exec_queue_handle,
>> +			      eus->lrc_handle, eus->bitmask, eus->bitmask_size);
>> +		free(eus);
>> +	}
>> +
>> +	for (i = 0; i < n - 1; i++) {
>> +		/* Convert timestamps to microseconds */
>> +		current_t = data[i]->exception_arrived.tv_nsec * 1000;
>> +		next_t = data[i + 1]->exception_arrived.tv_nsec * 1000;
>> +		diff = current_t < next_t ? next_t - current_t : current_t - next_t;
>> +
>> +		if (multi_tile)
>> +			igt_assert_f(diff < WORKLOAD_DELAY_US,
>> +				     "Expected to execute workloads concurrently. Actual delay: %lu ms\n",
>> +				     diff);
>> +		else
>> +			igt_assert_f(diff >= WORKLOAD_DELAY_US,
>> +				     "Expected a serialization of workloads. Actual delay: %lu ms\n",
>> +				     diff);
>> +	}
>> +
>> +	for (i = 0; i < n; i++) {
>> +		xe_eudebug_client_wait_done(s[i]->c);
>> +		xe_eudebug_debugger_stop_worker(s[i]->d, 1);
>> +
>> +		xe_eudebug_event_log_print(s[i]->d->log, true);
>> +		online_session_check(s[i], flags);
>> +
>> +		xe_eudebug_session_destroy(s[i]);
>> +		online_debug_data_destroy(data[i]);
>> +	}
>> +}
>> +
>> +static struct drm_xe_engine_class_instance *pick_compute(int fd, int gt)
>> +{
>> +	struct drm_xe_engine_class_instance *hwe;
>> +	int count = 0;
>> +
>> +	xe_for_each_engine(fd, hwe)
>> +		if (is_compute_on_gt(hwe, gt))
>> +			count++;
>> +
>> +	xe_for_each_engine(fd, hwe)
>> +		if (is_compute_on_gt(hwe, gt) && rand() % count-- == 0)
>> +			return hwe;
>> +
>> +	return NULL;
>> +}
>> +
>> +#define test_gt_render_or_compute(t, i915, __hwe) \
>> +	igt_subtest_with_dynamic(t) \
>> +		for (int gt = 0; (__hwe = pick_compute(i915, gt)); gt++) \
>> +			igt_dynamic_f("%s%d", xe_engine_class_string(__hwe->engine_class), hwe->engine_instance)
>> +
>> +igt_main
>> +{
>> +	struct drm_xe_engine_class_instance *hwe;
>> +	bool was_enabled;
>> +	int fd;
>> +
>> +	igt_fixture {
>> +		fd = drm_open_driver(DRIVER_XE);
>> +		intel_allocator_multiprocess_start();
>> +		igt_srandom();
>> +		was_enabled = xe_eudebug_enable(fd, true);
>> +	}
>> +
>> +	test_gt_render_or_compute("basic-breakpoint", fd, hwe)
>> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT);
>> +
>> +	test_gt_render_or_compute("preempt-breakpoint", fd, hwe)
>> +		test_preemption(fd, hwe);
>> +
>> +	test_gt_render_or_compute("breakpoint-not-in-debug-mode", fd, hwe)
>> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | DISABLE_DEBUG_MODE);
>> +
>> +	test_gt_render_or_compute("stopped-thread", fd, hwe)
>> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_DELAYED);
>> +
>> +	test_gt_render_or_compute("resume-one", fd, hwe)
>> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_ONE);
>> +
>> +	test_gt_render_or_compute("resume-dss", fd, hwe)
>> +		test_basic_online(fd, hwe, SHADER_BREAKPOINT | TRIGGER_RESUME_DSS);
>> +
>> +	test_gt_render_or_compute("interrupt-all", fd, hwe)
>> +		test_interrupt_all(fd, hwe, SHADER_LOOP);
>> +
>> +	test_gt_render_or_compute("interrupt-other-debuggable", fd, hwe)
>> +		test_interrupt_other(fd, hwe, SHADER_LOOP);
>> +
>> +	test_gt_render_or_compute("interrupt-other", fd, hwe)
>> +		test_interrupt_other(fd, hwe, SHADER_LOOP | DISABLE_DEBUG_MODE);
>> +
>> +	test_gt_render_or_compute("interrupt-all-set-breakpoint", fd, hwe)
>> +		test_interrupt_all(fd, hwe, SHADER_LOOP | TRIGGER_RESUME_SET_BP);
>> +
>> +	test_gt_render_or_compute("tdctl-parameters", fd, hwe)
>> +		test_tdctl_parameters(fd, hwe, SHADER_LOOP);
>> +
>> +	test_gt_render_or_compute("reset-with-attention", fd, hwe)
>> +		test_reset_with_attention_online(fd, hwe, SHADER_BREAKPOINT);
>> +
>> +	test_gt_render_or_compute("interrupt-reconnect", fd, hwe)
>> +		test_interrupt_reconnect(fd, hwe, SHADER_LOOP | TRIGGER_RECONNECT);
>> +
>> +	test_gt_render_or_compute("single-step", fd, hwe)
>> +		test_single_step(fd, hwe, SHADER_SINGLE_STEP | SIP_SINGLE_STEP |
>> +				 TRIGGER_RESUME_PARALLEL_WALK);
>> +
>> +	test_gt_render_or_compute("single-step-one", fd, hwe)
>> +		test_single_step(fd, hwe, SHADER_SINGLE_STEP | SIP_SINGLE_STEP |
>> +				 TRIGGER_RESUME_SINGLE_WALK);
>> +
>> +	test_gt_render_or_compute("debugger-reopen", fd, hwe)
>> +		test_debugger_reopen(fd, hwe, SHADER_N_NOOP_BREAKPOINT);
>> +
>> +	test_gt_render_or_compute("writes-caching-sram", fd, hwe)
>> +		test_caching(fd, hwe, SHADER_CACHING_SRAM);
>> +
>> +	test_gt_render_or_compute("writes-caching-vram", fd, hwe)
>> +		test_caching(fd, hwe, SHADER_CACHING_VRAM);
>> +
>> +	igt_subtest("breakpoint-many-sessions-single-tile")
>> +		test_many_sessions_on_tiles(fd, false);
>> +
>> +	igt_subtest("breakpoint-many-sessions-tiles")
>> +		test_many_sessions_on_tiles(fd, true);
>> +
>> +	igt_fixture {
>> +		xe_eudebug_enable(fd, was_enabled);
>> +
>> +		intel_allocator_multiprocess_stop();
>> +		drm_close_driver(fd);
>> +	}
>> +}
>> diff --git a/tests/meson.build b/tests/meson.build
>> index 35bf8ed35..f18eec7e7 100644
>> --- a/tests/meson.build
>> +++ b/tests/meson.build
>> @@ -280,6 +280,7 @@ intel_xe_progs = [
>>   	'xe_debugfs',
>>   	'xe_drm_fdinfo',
>>   	'xe_eudebug',
>> +	'xe_eudebug_online',
>>   	'xe_evict',
>>   	'xe_evict_ccs',
>>   	'xe_exec_atomic',
> 

Re: [PATCH i-g-t v3 02/14] drm-uapi/xe: Sync with eudebug uapi

[Zbigniew Kempczyński]

On Fri, Aug 09, 2024 at 02:38:01PM +0200, Christoph Manszewski wrote:
> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> 
> Align with kernel commit 09411c6ecbef ("drm/xe/eudebug: Add debug
> metadata support for xe_eudebug") from:
> 
> https://gitlab.freedesktop.org/miku/kernel.git
> 
> which introduces most recent changes to the eudebug uapi.
> 
> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> ---
>  include/drm-uapi/xe_drm.h         |  96 ++++++++++++-
>  include/drm-uapi/xe_drm_eudebug.h | 225 ++++++++++++++++++++++++++++++
>  2 files changed, 319 insertions(+), 2 deletions(-)
>  create mode 100644 include/drm-uapi/xe_drm_eudebug.h
> 
> diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h
> index f0a450db9..01ffbb8cb 100644
> --- a/include/drm-uapi/xe_drm.h
> +++ b/include/drm-uapi/xe_drm.h
> @@ -102,7 +102,9 @@ extern "C" {
>  #define DRM_XE_EXEC			0x09
>  #define DRM_XE_WAIT_USER_FENCE		0x0a
>  #define DRM_XE_OBSERVATION		0x0b
> -
> +#define DRM_XE_EUDEBUG_CONNECT		0x0c
> +#define DRM_XE_DEBUG_METADATA_CREATE	0x0d
> +#define DRM_XE_DEBUG_METADATA_DESTROY	0x0e
>  /* Must be kept compact -- no holes */
>  
>  #define DRM_IOCTL_XE_DEVICE_QUERY		DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEVICE_QUERY, struct drm_xe_device_query)
> @@ -117,6 +119,9 @@ extern "C" {
>  #define DRM_IOCTL_XE_EXEC			DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)
>  #define DRM_IOCTL_XE_WAIT_USER_FENCE		DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)
>  #define DRM_IOCTL_XE_OBSERVATION		DRM_IOW(DRM_COMMAND_BASE + DRM_XE_OBSERVATION, struct drm_xe_observation_param)
> +#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)
>  
>  /**
>   * DOC: Xe IOCTL Extensions
> @@ -881,6 +886,23 @@ struct drm_xe_vm_destroy {
>  	__u64 reserved[2];
>  };
>  
> +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;
> +};
> +
>  /**
>   * struct drm_xe_vm_bind_op - run bind operations
>   *
> @@ -905,7 +927,9 @@ struct drm_xe_vm_destroy {
>   *    handle MBZ, and the BO offset MBZ. This flag is intended to
>   *    implement VK sparse bindings.
>   */
> +
>  struct drm_xe_vm_bind_op {
> +#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0
>  	/** @extensions: Pointer to the first extension struct, if any */
>  	__u64 extensions;
>  
> @@ -1108,7 +1132,8 @@ struct drm_xe_exec_queue_create {
>  #define DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY		0
>  #define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_PRIORITY		0
>  #define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_TIMESLICE		1
> -
> +#define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG		2
> +#define     DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE		(1 << 0)
>  	/** @extensions: Pointer to the first extension struct, if any */
>  	__u64 extensions;
>  
> @@ -1694,6 +1719,73 @@ struct drm_xe_oa_stream_info {
>  	__u64 reserved[3];
>  };
>  
> +/*
> + * Debugger ABI (ioctl and events) Version History:
> + * 0 - No debugger available
> + * 1 - Initial version
> + */
> +#define DRM_XE_EUDEBUG_VERSION 1
> +
> +struct drm_xe_eudebug_connect {
> +	/** @extensions: Pointer to the first extension struct, if any */
> +	__u64 extensions;
> +
> +	__u64 pid; /* input: Target process ID */
> +	__u32 flags; /* MBZ */
> +
> +	__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;
> +};
> +
> +#include "xe_drm_eudebug.h"
> +

I think we're going toward merging eudebug igt series behind
configuration flag where kernel uapi is not yet established and
merged so above is imo unacceptable.

I think you should:

1. keep xe_drm.h intact, synced with upstream
2. provide xe_drm_eudebug.h which should contain all structure
   definitions
3. eudebug tests should include xe_drm.h and xe_drm_eudebug.h
   because this is not official interface and according to kernel
   series may change. Thus any changes inside xe_drm.h will be
   noise.

--
Zbigniew

>  #if defined(__cplusplus)
>  }
>  #endif
> diff --git a/include/drm-uapi/xe_drm_eudebug.h b/include/drm-uapi/xe_drm_eudebug.h
> new file mode 100644
> index 000000000..1db737080
> --- /dev/null
> +++ b/include/drm-uapi/xe_drm_eudebug.h
> @@ -0,0 +1,225 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2023 Intel Corporation
> + */
> +
> +#ifndef _XE_DRM_EUDEBUG_H_
> +#define _XE_DRM_EUDEBUG_H_
> +
> +#if defined(__cplusplus)
> +extern "C" {
> +#endif
> +
> +/**
> + * Do a eudebug event read for a debugger connection.
> + *
> + * 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)
> +
> +/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */
> +struct drm_xe_eudebug_event {
> +	__u32 len;
> +
> +	__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
> +
> +	__u16 flags;
> +#define DRM_XE_EUDEBUG_EVENT_CREATE		(1 << 0)
> +#define DRM_XE_EUDEBUG_EVENT_DESTROY		(1 << 1)
> +#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE	(1 << 2)
> +#define DRM_XE_EUDEBUG_EVENT_NEED_ACK		(1 << 3)
> +
> +	__u64 seqno;
> +	__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;
> +	__u32 width;
> +	__u64 lrc_handle[];
> +};
> +
> +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;
> +	__u32 bitmask_size;
> +	__u8 bitmask[];
> +};
> +
> +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
> +#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):
> + *
> + *  ┌───────────────────────┐
> + *  │  EVENT_VM_BIND        ├───────┬─┬─┐
> + *  └───────────────────────┘       │ │ │
> + *      ┌───────────────────────┐   │ │ │
> + *      │ EVENT_VM_BIND_OP #1   ├───┘ │ │
> + *      └───────────────────────┘     │ │
> + *                 ...                │ │
> + *      ┌───────────────────────┐     │ │
> + *      │ EVENT_VM_BIND_OP #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
> + * attach sync of type UFENCE into its vm_bind_ioctl().
> + *
> + * When EVENT_UFENCE is sent by the driver, all the OPs of
> + * the original VM_BIND are completed and the [addr,range]
> + * contained in them are present and modifiable through the
> + * vm accessors. Accessing [addr, range] before related ufence
> + * event will lead to undefined results as the actual bind
> + * operations are async and the backing storage might not
> + * be there on a moment of receiving the event.
> + *
> + * Client's UFENCE sync will be held by the driver: client's
> + * drm_xe_wait_ufence will not complete and the value of the ufence
> + * won't appear until ufence is acked by the debugger process calling
> + * DRM_XE_EUDEBUG_IOCTL_ACK_EVENT with the event_ufence.base.seqno.
> + * This will signal the fence, .value will update and the wait will
> + * complete allowing the client to continue.
> + *
> + */
> +
> +struct drm_xe_eudebug_event_vm_bind {
> +	struct drm_xe_eudebug_event base;
> +
> +	__u64 client_handle;
> +	__u64 vm_handle;
> +
> +	__u32 flags;
> +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0)
> +
> +	__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_ufence {
> +	struct drm_xe_eudebug_event base;
> +	__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
> +};
> +
> +struct drm_xe_eudebug_ack_event {
> +	__u32 type;
> +	__u32 flags; /* MBZ */
> +	__u64 seqno;
> +};
> +
> +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;
> +
> +	/** @flags: flags */
> +	__u64 flags;
> +
> +	/** @timeout_ns: Timeout value in nanoseconds operations (fsync) */
> +	__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;
> +};
> +
> +#if defined(__cplusplus)
> +}
> +#endif
> +
> +#endif
> -- 
> 2.34.1
> 

Re: [PATCH i-g-t v3 03/14] lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter

[Zbigniew Kempczyński]

On Fri, Aug 09, 2024 at 02:38:02PM +0200, Christoph Manszewski wrote:
> Currently there is no way to set drm_xe_vm_bind_op extension field. Add
> vm_bind wrapper that allows pass this field as a parameter.
> 
> Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> Reviewed-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
> ---
>  lib/xe/xe_ioctl.c | 20 ++++++++++++++++----
>  lib/xe/xe_ioctl.h |  5 +++++
>  2 files changed, 21 insertions(+), 4 deletions(-)
> 
> diff --git a/lib/xe/xe_ioctl.c b/lib/xe/xe_ioctl.c
> index ae43ffd15..6d8388918 100644
> --- a/lib/xe/xe_ioctl.c
> +++ b/lib/xe/xe_ioctl.c
> @@ -96,15 +96,17 @@ void xe_vm_bind_array(int fd, uint32_t vm, uint32_t exec_queue,
>  	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_VM_BIND, &bind), 0);
>  }
>  
> -int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
> -		  uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
> -		  uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
> -		  uint32_t prefetch_region, uint8_t pat_index, uint64_t ext)
> +int  ___xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
> +		   uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
> +		   uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
> +		   uint32_t prefetch_region, uint8_t pat_index, uint64_t ext,
> +		   uint64_t op_ext)
>  {
>  	struct drm_xe_vm_bind bind = {
>  		.extensions = ext,
>  		.vm_id = vm,
>  		.num_binds = 1,
> +		.bind.extensions = op_ext,
>  		.bind.obj = bo,
>  		.bind.obj_offset = offset,
>  		.bind.range = size,
> @@ -125,6 +127,16 @@ int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
>  	return 0;
>  }
>  
> +int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
> +		  uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
> +		  uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
> +		  uint32_t prefetch_region, uint8_t pat_index, uint64_t ext)
> +{
> +	return ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size, op,
> +			     flags, sync, num_syncs, prefetch_region,
> +			     pat_index, ext, 0);
> +}
> +
>  void  __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
>  			  uint64_t offset, uint64_t addr, uint64_t size,
>  			  uint32_t op, uint32_t flags, struct drm_xe_sync *sync,
> diff --git a/lib/xe/xe_ioctl.h b/lib/xe/xe_ioctl.h
> index b27c0053f..18cc2b72b 100644
> --- a/lib/xe/xe_ioctl.h
> +++ b/lib/xe/xe_ioctl.h
> @@ -20,6 +20,11 @@
>  uint32_t xe_cs_prefetch_size(int fd);
>  uint64_t xe_bb_size(int fd, uint64_t reqsize);
>  uint32_t xe_vm_create(int fd, uint32_t flags, uint64_t ext);
> +int  ___xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
> +		   uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
> +		   uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
> +		   uint32_t prefetch_region, uint8_t pat_index, uint64_t ext,
> +		   uint64_t op_ext);
>  int  __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,
>  		  uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
>  		  uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
> -- 
> 2.34.1
> 

Ok, this is harmless and doesn't depend on eudebug uapi headers.

Reviewed-by: Zbigniew Kempczyński <zbigniew.kempczynski@intel.com>

--
Zbigniew

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Zbigniew Kempczyński]

On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> 
> Introduce library which simplifies testing of eu debug capability.
> The library provides event log helpers together with asynchronous
> abstraction for client proccess and the debugger itself.
> 
> xe_eudebug_client creates its own proccess with user's work function,
> and gives machanisms to synchronize beginning of execution and event
> logging.
> 
> xe_eudebug_debugger allows to attach to the given proccess, provides
> asynchronous thread for event reading and introduces triggers -
> a callback mechanism triggered every time subscribed event was read.
> 
> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> ---
>  lib/meson.build     |    1 +
>  lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
>  lib/xe/xe_eudebug.h |  206 ++++
>  3 files changed, 2399 insertions(+)
>  create mode 100644 lib/xe/xe_eudebug.c
>  create mode 100644 lib/xe/xe_eudebug.h
> 
> diff --git a/lib/meson.build b/lib/meson.build
> index f711e60a7..969ca4101 100644
> --- a/lib/meson.build
> +++ b/lib/meson.build
> @@ -111,6 +111,7 @@ lib_sources = [
>  	'igt_msm.c',
>  	'igt_dsc.c',
>  	'xe/xe_gt.c',
> +	'xe/xe_eudebug.c',
>  	'xe/xe_ioctl.c',
>  	'xe/xe_mmio.c',
>  	'xe/xe_query.c',

As eudebug is quite big feature I think it should be separated and
hidden behind a feature flag (check meson_options.txt), lets say
'xe_eudebug' which would be disabled by default. This way you can
develop it upstream even if kernel side is not officially merged.
I'm pragramatic and I see no reason to block not accepted feature
especially this would imo speed up developement. A final step when
kernel change would be accepted and merged would be to sync with
uapi and remove local definitions.

I look forward maintainers comments is my attitude acceptable.

--
Zbigniew


> diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
> new file mode 100644
> index 000000000..4eac87476
> --- /dev/null
> +++ b/lib/xe/xe_eudebug.c
> @@ -0,0 +1,2192 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2023 Intel Corporation
> + */
> +
> +#include <fcntl.h>
> +#include <poll.h>
> +#include <signal.h>
> +#include <sys/select.h>
> +#include <sys/stat.h>
> +#include <sys/types.h>
> +#include <sys/wait.h>
> +
> +#include "igt.h"
> +#include "igt_sysfs.h"
> +#include "intel_pat.h"
> +#include "xe_eudebug.h"
> +#include "xe_ioctl.h"
> +
> +struct event_trigger {
> +	xe_eudebug_trigger_fn fn;
> +	int type;
> +	struct igt_list_head link;
> +};
> +
> +struct seqno_list_entry {
> +	struct igt_list_head link;
> +	uint64_t seqno;
> +};
> +
> +struct match_dto {
> +	struct drm_xe_eudebug_event *target;
> +	struct igt_list_head *seqno_list;
> +	uint64_t client_handle;
> +	uint32_t filter;
> +
> +	/* store latest 'EVENT_VM_BIND' seqno */
> +	uint64_t *bind_seqno;
> +	/* latest vm_bind_op seqno matching bind_seqno */
> +	uint64_t *bind_op_seqno;
> +};
> +
> +#define CLIENT_PID  1
> +#define CLIENT_RUN  2
> +#define CLIENT_FINI 3
> +#define CLIENT_STOP 4
> +#define CLIENT_STAGE 5
> +#define DEBUGGER_STAGE 6
> +
> +#define DEBUGGER_WORKER_INACTIVE  0
> +#define DEBUGGER_WORKER_ACTIVE  1
> +#define DEBUGGER_WORKER_QUITTING 2
> +
> +static const char *type_to_str(unsigned int type)
> +{
> +	switch (type) {
> +	case DRM_XE_EUDEBUG_EVENT_NONE:
> +		return "none";
> +	case DRM_XE_EUDEBUG_EVENT_READ:
> +		return "read";
> +	case DRM_XE_EUDEBUG_EVENT_OPEN:
> +		return "client";
> +	case DRM_XE_EUDEBUG_EVENT_VM:
> +		return "vm";
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
> +		return "exec_queue";
> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
> +		return "attention";
> +	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_UFENCE:
> +		return "vm_bind_ufence";
> +	case DRM_XE_EUDEBUG_EVENT_METADATA:
> +		return "metadata";
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
> +		return "vm_bind_op_metadata";
> +	}
> +
> +	return "UNKNOWN";
> +}
> +
> +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
> +{
> +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
> +
> +	return buf;
> +}
> +
> +static const char *flags_to_str(unsigned int flags)
> +{
> +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
> +			return "create|ack";
> +		else
> +			return "create";
> +	}
> +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> +		return "destroy";
> +
> +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
> +		return "state-change";
> +
> +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
> +
> +	return "flags unknown";
> +}
> +
> +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
> +{
> +	switch (e->type) {
> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
> +
> +		sprintf(b, "handle=%llu", ec->client_handle);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM: {
> +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
> +
> +		sprintf(b, "client_handle=%llu, handle=%llu",
> +			evm->client_handle, evm->vm_handle);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
> +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
> +			ee->client_handle, ee->vm_handle,
> +			ee->exec_queue_handle, ee->engine_class, ee->width);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
> +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
> +			   "lrc_handle=%llu, bitmask_size=%d",
> +			ea->client_handle, ea->exec_queue_handle,
> +			ea->lrc_handle, ea->bitmask_size);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
> +			evmb->client_handle, 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 = (void *)e;
> +
> +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
> +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
> +
> +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> +
> +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
> +			em->client_handle, em->metadata_handle, em->type, em->len);
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
> +
> +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
> +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
> +		break;
> +	}
> +	default:
> +		strcpy(b, "<...>");
> +	}
> +
> +	return b;
> +}
> +
> +/**
> + * xe_eudebug_event_to_str:
> + * @e: pointer to event
> + * @buf: target to write string representation of @e
> + * @len: size of target buffer @buf
> + *
> + * Creates string representation for given event.
> + *
> + * Returns: the written input buffer pointed by @buf.
> + */
> +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
> +{
> +	char a[256];
> +	char b[256];
> +
> +	snprintf(buf, len, "(%llu) %15s:%s: %s",
> +		 e->seqno,
> +		 event_type_to_str(e, a),
> +		 flags_to_str(e->flags),
> +		 event_members_to_str(e, b));
> +
> +	return buf;
> +}
> +
> +static void catch_child_failure(void)
> +{
> +	pid_t pid;
> +	int status;
> +
> +	pid = waitpid(-1, &status, WNOHANG);
> +
> +	if (pid == 0 || pid == -1)
> +		return;
> +
> +	if (!WIFEXITED(status))
> +		return;
> +
> +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
> +}
> +
> +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
> +{
> +	int ret;
> +	int t = 0;
> +	struct pollfd fd = {
> +		.fd = pipe[0],
> +		.events = POLLIN,
> +		.revents = 0
> +	};
> +
> +	/* When child fails we may get stuck forever. Check whether
> +	 * the child process ended with an error.
> +	 */
> +	do {
> +		const int interval_ms = 1000;
> +
> +		ret = poll(&fd, 1, interval_ms);
> +
> +		if (!ret) {
> +			catch_child_failure();
> +			t += interval_ms;
> +		}
> +	} while (!ret && t < timeout_ms);
> +
> +	if (ret > 0)
> +		return read(pipe[0], buf, nbytes);
> +
> +	return 0;
> +}
> +
> +static uint64_t pipe_read(int pipe[2], int timeout_ms)
> +{
> +	uint64_t in;
> +	uint64_t ret;
> +
> +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
> +	igt_assert(ret == sizeof(in));
> +
> +	return in;
> +}
> +
> +static void pipe_signal(int pipe[2], uint64_t token)
> +{
> +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
> +}
> +
> +static void pipe_close(int pipe[2])
> +{
> +	if (pipe[0] != -1)
> +		close(pipe[0]);
> +
> +	if (pipe[1] != -1)
> +		close(pipe[1]);
> +}
> +
> +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
> +{
> +	uint64_t in;
> +
> +	in = pipe_read(p, timeout_ms);
> +
> +	igt_assert_eq(in, token);
> +
> +	return pipe_read(p, timeout_ms);
> +}
> +
> +static uint64_t client_wait_token(struct xe_eudebug_client *c,
> +				 const uint64_t token)
> +{
> +	return __wait_token(c->p_in, token, c->timeout_ms);
> +}
> +
> +static uint64_t wait_from_client(struct xe_eudebug_client *c,
> +				 const uint64_t token)
> +{
> +	return __wait_token(c->p_out, token, c->timeout_ms);
> +}
> +
> +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
> +{
> +	pipe_signal(p, token);
> +	pipe_signal(p, value);
> +}
> +
> +static void client_signal(struct xe_eudebug_client *c,
> +			  const uint64_t token,
> +			  const uint64_t value)
> +{
> +	token_signal(c->p_out, token, value);
> +}
> +
> +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
> +{
> +	struct drm_xe_eudebug_connect param = {
> +		.pid = pid,
> +		.flags = flags,
> +	};
> +	int debugfd;
> +
> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> +
> +	if (debugfd < 0)
> +		return -errno;
> +
> +	return debugfd;
> +}
> +
> +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
> +{
> +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
> +		      sizeof(l->head));
> +
> +	igt_assert_eq(write(fd, l->log, l->head), l->head);
> +}
> +
> +static void read_all(int fd, void *buf, size_t nbytes)
> +{
> +	ssize_t remaining_size = nbytes;
> +	ssize_t current_size = 0;
> +	ssize_t read_size = 0;
> +
> +	do {
> +		read_size = read(fd, buf + current_size, remaining_size);
> +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
> +
> +		current_size += read_size;
> +		remaining_size -= read_size;
> +	} while (remaining_size > 0 && read_size > 0);
> +
> +	igt_assert_eq(current_size, nbytes);
> +}
> +
> +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
> +{
> +	read_all(fd, &l->head, sizeof(l->head));
> +	igt_assert_lt(l->head, l->max_size);
> +
> +	read_all(fd, l->log, l->head);
> +}
> +
> +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
> +
> +static struct drm_xe_eudebug_event *
> +event_cmp(struct xe_eudebug_event_log *l,
> +	  struct drm_xe_eudebug_event *current,
> +	  cmp_fn_t match,
> +	  void *data)
> +{
> +	struct drm_xe_eudebug_event *e = current;
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		if (match(e, data))
> +			return e;
> +	}
> +
> +	return NULL;
> +}
> +
> +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
> +{
> +	struct drm_xe_eudebug_event *b = data;
> +
> +	if (a->type == b->type &&
> +	    a->flags == b->flags)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
> +{
> +	struct drm_xe_eudebug_event *b = data;
> +	int ret = 0;
> +
> +	ret = match_type_and_flags(a, data);
> +	if (!ret)
> +		return ret;
> +
> +	ret = 0;
> +
> +	switch (a->type) {
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
> +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
> +
> +		if (ae->engine_class == be->engine_class && ae->width == be->width)
> +			ret = 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
> +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
> +
> +		if (ea->num_binds == eb->num_binds)
> +			ret = 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
> +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
> +
> +		if (ea->addr == eb->addr && ea->range == eb->range &&
> +		    ea->num_extensions == eb->num_extensions)
> +			ret = 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
> +
> +		if (ea->metadata_handle == eb->metadata_handle &&
> +		    ea->metadata_cookie == eb->metadata_cookie)
> +			ret = 1;
> +		break;
> +	}
> +
> +	default:
> +		ret = 1;
> +		break;
> +	}
> +
> +	return ret;
> +}
> +
> +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
> +{
> +	struct match_dto *md = (void *)data;
> +	uint64_t *bind_seqno = md->bind_seqno;
> +	uint64_t *bind_op_seqno = md->bind_op_seqno;
> +	uint64_t h = md->client_handle;
> +
> +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
> +		return 0;
> +
> +	switch (e->type) {
> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> +
> +		if (client->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM: {
> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> +
> +		if (vm->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
> +
> +		if (ee->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
> +
> +		if (evmb->client_handle == h) {
> +			*bind_seqno = evmb->base.seqno;
> +			return 1;
> +		}
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
> +
> +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
> +			*bind_op_seqno = eo->base.seqno;
> +			return 1;
> +		}
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
> +
> +		if (ef->vm_bind_ref_seqno == *bind_seqno)
> +			return 1;
> +
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
> +
> +		if (em->client_handle == h)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
> +
> +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
> +			return 1;
> +		break;
> +	}
> +	default:
> +		break;
> +	}
> +
> +	return 0;
> +}
> +
> +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
> +{
> +
> +	struct drm_xe_eudebug_event *d = (void *)data;
> +	int ret;
> +
> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
> +	ret = match_type_and_flags(e, data);
> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> +
> +	if (!ret)
> +		return 0;
> +
> +	switch (e->type) {
> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
> +
> +		if (client->client_handle == filter->client_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM: {
> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
> +
> +		if (vm->vm_handle == filter->vm_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
> +
> +		if (ee->exec_queue_handle == filter->exec_queue_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
> +
> +		if (evmb->vm_handle == filter->vm_handle &&
> +		    evmb->num_binds == filter->num_binds)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
> +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
> +
> +		if (avmb->addr == filter->addr &&
> +		    avmb->range == filter->range)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
> +
> +		if (em->metadata_handle == filter->metadata_handle)
> +			return 1;
> +		break;
> +	}
> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
> +
> +		if (avmb->metadata_handle == filter->metadata_handle &&
> +		    avmb->metadata_cookie == filter->metadata_cookie)
> +			return 1;
> +		break;
> +	}
> +
> +	default:
> +		break;
> +	}
> +	return 0;
> +}
> +
> +static int match_full(struct drm_xe_eudebug_event *e, void *data)
> +{
> +	struct seqno_list_entry *sl;
> +
> +	struct match_dto *md = (void *)data;
> +	int ret = 0;
> +
> +	ret = match_client_handle(e, md);
> +	if (!ret)
> +		return 0;
> +
> +	ret = match_fields(e, md->target);
> +	if (!ret)
> +		return 0;
> +
> +	igt_list_for_each_entry(sl, md->seqno_list, link) {
> +		if (sl->seqno == e->seqno)
> +			return 0;
> +	}
> +
> +	return 1;
> +}
> +
> +static struct drm_xe_eudebug_event *
> +event_type_match(struct xe_eudebug_event_log *l,
> +		 struct drm_xe_eudebug_event *target,
> +		 struct drm_xe_eudebug_event *current)
> +{
> +	return event_cmp(l, current, match_type_and_flags, target);
> +}
> +
> +static struct drm_xe_eudebug_event *
> +client_match(struct xe_eudebug_event_log *l,
> +	     uint64_t client_handle,
> +	     struct drm_xe_eudebug_event *current,
> +	     uint32_t filter,
> +	     uint64_t *bind_seqno,
> +	     uint64_t *bind_op_seqno)
> +{
> +	struct match_dto md = {
> +		.client_handle = client_handle,
> +		.filter = filter,
> +		.bind_seqno = bind_seqno,
> +		.bind_op_seqno = bind_op_seqno,
> +	};
> +
> +	return event_cmp(l, current, match_client_handle, &md);
> +}
> +
> +static struct drm_xe_eudebug_event *
> +opposite_event_match(struct xe_eudebug_event_log *l,
> +		    struct drm_xe_eudebug_event *target,
> +		    struct drm_xe_eudebug_event *current)
> +{
> +	return event_cmp(l, current, match_opposite_resource, target);
> +}
> +
> +static struct drm_xe_eudebug_event *
> +event_match(struct xe_eudebug_event_log *l,
> +	    struct drm_xe_eudebug_event *target,
> +	    uint64_t client_handle,
> +	    struct igt_list_head *seqno_list,
> +	    uint64_t *bind_seqno,
> +	    uint64_t *bind_op_seqno)
> +{
> +	struct match_dto md = {
> +		.target = target,
> +		.client_handle = client_handle,
> +		.seqno_list = seqno_list,
> +		.bind_seqno = bind_seqno,
> +		.bind_op_seqno = bind_op_seqno,
> +	};
> +
> +	return event_cmp(l, NULL, match_full, &md);
> +}
> +
> +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
> +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
> +			   uint32_t filter)
> +{
> +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
> +	struct drm_xe_eudebug_event_client *de = (void *)_de;
> +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
> +
> +	struct igt_list_head matched_seqno_list;
> +	struct drm_xe_eudebug_event *hc, *hd;
> +	struct seqno_list_entry *entry, *tmp;
> +
> +	igt_assert(ce);
> +	igt_assert(de);
> +
> +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
> +
> +	hc = NULL;
> +	hd = NULL;
> +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
> +
> +	do {
> +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
> +		if (!hc)
> +			break;
> +
> +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
> +
> +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
> +			     c->name,
> +			     hc->seqno,
> +			     hc->type,
> +			     ce->client_handle);
> +
> +		igt_debug("comparing %s %llu vs %s %llu\n",
> +			  c->name, hc->seqno, d->name, hd->seqno);
> +
> +		/*
> +		 * Store the seqno of the event that was matched above,
> +		 * inside 'matched_seqno_list', to avoid it getting matched
> +		 * by subsequent 'event_match' calls.
> +		 */
> +		entry = malloc(sizeof(*entry));
> +		entry->seqno = hd->seqno;
> +		igt_list_add(&entry->link, &matched_seqno_list);
> +	} while (hc);
> +
> +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
> +		free(entry);
> +}
> +
> +/**
> + * xe_eudebug_event_log_find_seqno:
> + * @l: event log pointer
> + * @seqno: seqno of event to be found
> + *
> + * Finds the event with given seqno in the event log.
> + *
> + * Returns: pointer to the event with given seqno within @l or NULL seqno is
> + * not present.
> + */
> +struct drm_xe_eudebug_event *
> +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
> +{
> +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
> +
> +	igt_assert_neq(seqno, 0);
> +	/*
> +	 * Try to catch if seqno is corrupted and prevent too long tests,
> +	 * as our post processing of events is not optimized.
> +	 */
> +	igt_assert_lt(seqno, 10 * 1000 * 1000);
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		if (e->seqno == seqno) {
> +			if (found) {
> +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
> +				xe_eudebug_event_log_print(l, false);
> +				igt_assert(!found);
> +			}
> +			found = e;
> +		}
> +	}
> +
> +	return found;
> +}
> +
> +static void event_log_sort(struct xe_eudebug_event_log *l)
> +{
> +	struct xe_eudebug_event_log *tmp;
> +	struct drm_xe_eudebug_event *e = NULL;
> +	uint64_t first_seqno = 0;
> +	uint64_t last_seqno = 0;
> +	uint64_t events = 0, added = 0;
> +	uint64_t i;
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		if (e->seqno > last_seqno)
> +			last_seqno = e->seqno;
> +
> +		if (e->seqno < first_seqno)
> +			first_seqno = e->seqno;
> +
> +		events++;
> +	}
> +
> +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
> +
> +	for (i = 1; i <= last_seqno; i++) {
> +		e = xe_eudebug_event_log_find_seqno(l, i);
> +		if (e) {
> +			xe_eudebug_event_log_write(tmp, e);
> +			added++;
> +		}
> +	}
> +
> +	igt_assert_eq(events, added);
> +	igt_assert_eq(tmp->head, l->head);
> +
> +	memcpy(l->log, tmp->log, tmp->head);
> +
> +	xe_eudebug_event_log_destroy(tmp);
> +}
> +
> +/**
> + * xe_eudebug_connect:
> + * @fd: Xe file descriptor
> + * @pid: client PID
> + * @flags: connection flags
> + *
> + * Opens the xe eu debugger connection to the process described by @pid
> + *
> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> + */
> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
> +{
> +	int ret;
> +	uint64_t events = 0; /* events filtering not supported yet! */
> +
> +	ret = __xe_eudebug_connect(fd, pid, flags, events);
> +
> +	return ret;
> +}
> +
> +/**
> + * xe_eudebug_event_log_create:
> + * @name: event log identifier
> + * @max_size: maximum size of created log
> + *
> + * Function creates an Eu Debugger event log with size equal to @max_size.
> + *
> + * Returns: pointer to just created log
> + */
> +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
> +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
> +{
> +	struct xe_eudebug_event_log *l;
> +
> +	l = calloc(1, sizeof(*l));
> +	igt_assert(l);
> +	l->log = calloc(1, max_size);
> +	igt_assert(l->log);
> +	l->max_size = max_size;
> +	strncpy(l->name, name, sizeof(l->name) - 1);
> +	pthread_mutex_init(&l->lock, NULL);
> +
> +	return l;
> +}
> +
> +/**
> + * xe_eudebug_event_log_destroy:
> + * @l: event log pointer
> + *
> + * Frees given event log @l.
> + */
> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
> +{
> +	pthread_mutex_destroy(&l->lock);
> +	free(l->log);
> +	free(l);
> +}
> +
> +/**
> + * xe_eudebug_event_log_write:
> + * @l: event log pointer
> + * @e: event to be written to event log
> + *
> + * Writes event @e to the event log, thread-safe.
> + */
> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
> +{
> +	igt_assert(e->seqno);
> +	/*
> +	 * Try to catch if seqno is corrupted and prevent too long tests,
> +	 * as our post processing of events is not optimized.
> +	 */
> +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
> +
> +	pthread_mutex_lock(&l->lock);
> +	igt_assert_lt(l->head + e->len, l->max_size);
> +	memcpy(l->log + l->head, e, e->len);
> +	l->head += e->len;
> +
> +#ifdef DEBUG_LOG
> +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
> +		 l->name, e->len, l->max_size - l->head);
> +#endif
> +	pthread_mutex_unlock(&l->lock);
> +}
> +
> +/**
> + * xe_eudebug_event_log_print:
> + * @l: event log pointer
> + * @debug: when true function uses igt_debug instead of igt_info.
> + *
> + * Prints given event log.
> + */
> +void
> +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
> +{
> +	struct drm_xe_eudebug_event *e = NULL;
> +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
> +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> +
> +	igt_log(IGT_LOG_DOMAIN, level,
> +		"event log '%s' (%u bytes):\n", l->name, l->head);
> +
> +	xe_eudebug_for_each_event(e, l) {
> +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
> +	}
> +}
> +
> +/**
> + * xe_eudebug_event_log_compare:
> + * @a: event log pointer
> + * @b: event log pointer
> + * @filter: mask that represents events to be skipped during comparison, useful
> + * for events like 'VM_BIND' since they can be asymmetric. Note that
> + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
> + *
> + * Compares and asserts event logs @a, @b if the event
> + * sequence matches.
> + */
> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
> +				  uint32_t filter)
> +{
> +	struct drm_xe_eudebug_event *ae = NULL;
> +	struct drm_xe_eudebug_event *be = NULL;
> +
> +	xe_eudebug_for_each_event(ae, a) {
> +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
> +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> +			be = event_type_match(b, ae, be);
> +
> +			compare_client(a, ae, b, be, filter);
> +			compare_client(b, be, a, ae, filter);
> +		}
> +	}
> +}
> +
> +/**
> + * xe_eudebug_event_log_match_opposite:
> + * @l: event log pointer
> + * @filter: mask that represents events to be skipped during comparison, useful
> + * for events like 'VM_BIND' since they can be asymmetric
> + *
> + * Matches and asserts content of all opposite events (create vs destroy).
> + */
> +void
> +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
> +{
> +	struct drm_xe_eudebug_event *ce = NULL;
> +	struct drm_xe_eudebug_event *de = NULL;
> +
> +	xe_eudebug_for_each_event(ce, l) {
> +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
> +			int opposite_matching;
> +
> +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
> +				continue;
> +
> +			/* No opposite matching for binds */
> +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
> +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
> +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
> +				continue;
> +
> +			de = opposite_event_match(l, ce, ce);
> +
> +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
> +
> +			igt_assert_eq(ce->len, de->len);
> +			opposite_matching = memcmp((uint8_t *)de + offset,
> +						   (uint8_t *)ce + offset,
> +						   de->len - offset) == 0;
> +
> +			igt_assert_f(opposite_matching,
> +				     "%s: create|destroy event not "
> +				     "maching (%llu) vs (%llu)\n",
> +				     l->name, de->seqno, ce->seqno);
> +		}
> +	}
> +}
> +
> +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
> +				  struct drm_xe_eudebug_event *e)
> +{
> +	struct event_trigger *t;
> +
> +	igt_list_for_each_entry(t, &d->triggers, link) {
> +		if (e->type == t->type)
> +			t->fn(d, e);
> +	}
> +}
> +
> +#define MAX_EVENT_SIZE (32 * 1024)
> +static int
> +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
> +{
> +	int ret;
> +
> +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
> +	event->flags = 0;
> +	event->len = MAX_EVENT_SIZE;
> +
> +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
> +	if (ret < 0)
> +		return -errno;
> +
> +	return ret;
> +}
> +
> +static void *debugger_worker_loop(void *data)
> +{
> +	uint8_t buf[MAX_EVENT_SIZE];
> +	struct drm_xe_eudebug_event *e = (void *)buf;
> +	struct xe_eudebug_debugger *d = data;
> +	struct pollfd p = {
> +		.events = POLLIN,
> +		.revents = 0,
> +	};
> +	int timeout_ms = 100, ret;
> +
> +	igt_assert(d->master_fd >= 0);
> +
> +	do {
> +		p.fd = d->fd;
> +		ret = poll(&p, 1, timeout_ms);
> +
> +		if (ret == -1) {
> +			igt_info("poll failed with errno %d\n", errno);
> +			break;
> +		}
> +
> +		if (ret == 1 && (p.revents & POLLIN)) {
> +			int err = xe_eudebug_read_event(d->fd, e);
> +
> +			if (!err) {
> +				++d->event_count;
> +
> +				xe_eudebug_event_log_write(d->log, e);
> +				debugger_run_triggers(d, e);
> +			} else {
> +				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;
> +	return NULL;
> +}
> +
> +/**
> + * xe_eudebug_debugger_available:
> + * @fd: Xe file descriptor
> + *
> + * Returns: true it debugger connection is available, false otherwise.
> + */
> +bool xe_eudebug_debugger_available(int fd)
> +{
> +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
> +	int debugfd;
> +
> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> +	if (debugfd >= 0)
> +		close(debugfd);
> +
> +	return debugfd >= 0;
> +}
> +
> +/**
> + * xe_eudebug_debugger_create:
> + * @master_fd: xe client used to open the debugger connection
> + * @flags: flags stored in a debugger structure, can be used at will
> + * of the caller, i.e. to be used inside triggers.
> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> + * can be shared between client and debugger. Can be NULL.
> + *
> + * Returns: newly created xe_eudebug_debugger structure with its
> + * event log initialized. Note that to open the connection
> + * you need call @xe_eudebug_debugger_attach.
> + */
> +struct xe_eudebug_debugger *
> +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
> +{
> +	struct xe_eudebug_debugger *d;
> +
> +	d = calloc(1, sizeof(*d));
> +	d->flags = flags;
> +	igt_assert(d);
> +	IGT_INIT_LIST_HEAD(&d->triggers);
> +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
> +	d->fd = -1;
> +	d->master_fd = master_fd;
> +	d->ptr = data;
> +
> +	return d;
> +}
> +
> +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
> +{
> +	struct event_trigger *t, *tmp;
> +
> +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
> +		free(t);
> +}
> +
> +/**
> + * xe_eudebug_debugger_destroy:
> + * @d: pointer to the debugger
> + *
> + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
> + * connection was still opened it terminates it.
> + */
> +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
> +{
> +	if (d->worker_state)
> +		xe_eudebug_debugger_stop_worker(d, 1);
> +
> +	if (d->target_pid)
> +		xe_eudebug_debugger_dettach(d);
> +
> +	xe_eudebug_event_log_destroy(d->log);
> +	debugger_destroy_triggers(d);
> +	free(d);
> +}
> +
> +/**
> + * xe_eudebug_debugger_attach:
> + * @d: pointer to the debugger
> + * @c: pointer to the client
> + *
> + * Opens the xe eu debugger connection to the process described by @c (c->pid)
> + *
> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> + */
> +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
> +			       struct xe_eudebug_client *c)
> +{
> +	int ret;
> +
> +	igt_assert_eq(d->fd, -1);
> +	igt_assert_neq(c->pid, 0);
> +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
> +
> +	if (ret < 0)
> +		return ret;
> +
> +	d->fd = ret;
> +	d->target_pid = c->pid;
> +	d->p_client[0] = c->p_in[0];
> +	d->p_client[1] = c->p_in[1];
> +
> +	igt_debug("debugger connected to %lu\n", d->target_pid);
> +
> +	return 0;
> +}
> +
> +/**
> + * xe_eudebug_debugger_dettach:
> + * @d: pointer to the debugger
> + *
> + * Closes previously opened xe eu debugger connection. Asserts if
> + * the debugger has active session.
> + */
> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
> +{
> +	igt_assert(d->target_pid);
> +	close(d->fd);
> +	d->target_pid = 0;
> +	d->fd = -1;
> +}
> +
> +/**
> + * xe_eudebug_debugger_add_trigger:
> + * @d: pointer to the debugger
> + * @type: the type of the event which activates the trigger
> + * @fn: function to be called when event of @type was read by the debugger.
> + *
> + * Adds function @fn to the list of triggers activated when event of @type
> + * has been read by worker.
> + * Note: Triggers are activated by the worker.
> + */
> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
> +				     int type, xe_eudebug_trigger_fn fn)
> +{
> +	struct event_trigger *t;
> +
> +	t = calloc(1, sizeof(*t));
> +	IGT_INIT_LIST_HEAD(&t->link);
> +	t->type = type;
> +	t->fn = fn;
> +
> +	igt_list_add_tail(&t->link, &d->triggers);
> +	igt_debug("added trigger %p\n", t);
> +}
> +
> +/**
> + * xe_eudebug_debugger_start_worker:
> + * @d: pointer to the debugger
> + *
> + * Starts the debugger worker. Worker is resposible for reading all
> + * incoming events from the debugger, put then into debugger log and
> + * execute appropriate event triggers. Note that using the debuggers
> + * event log while worker is running is not safe.
> + */
> +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
> +{
> +	int ret;
> +
> +	d->worker_state = true;
> +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
> +
> +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
> +}
> +
> +/**
> + * xe_eudebug_debugger_stop_worker:
> + * @d: pointer to the debugger
> + *
> + * Stops the debugger worker. Event log is sorted by seqno after closure.
> + */
> +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
> +				     int timeout_s)
> +{
> +	struct timespec t = {};
> +	int ret;
> +
> +	igt_assert(d->worker_state);
> +
> +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
> +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
> +	t.tv_sec += timeout_s;
> +
> +	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_assert_f(ret == 0 || ret != ESRCH,
> +		     "pthread join failed with error %d!\n", ret);
> +
> +	event_log_sort(d->log);
> +}
> +
> +/**
> + * xe_eudebug_debugger_signal_stage:
> + * @d: pointer to the debugger
> + * @stage: stage to signal
> + *
> + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
> + * releasing it to proceed.
> + */
> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
> +{
> +	token_signal(d->p_client, CLIENT_STAGE, stage);
> +}
> +
> +/**
> + * xe_eudebug_debugger_wait_stage:
> + * @s: pointer to xe_eudebug_debugger structure
> + * @stage: stage to wait on
> + *
> + * Pauses debugger until the client has signalled the corresponding stage with
> + * xe_eudebug_client_signal_stage. This is only for situations where the actual
> + * event flow is not enough to coordinate between client/debugger and extra sync
> + * mechanism is needed.
> + */
> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
> +{
> +	u64 stage_in;
> +
> +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
> +
> +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
> +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
> +		  stage_in, stage);
> +
> +	igt_assert_eq(stage_in, stage);
> +}
> +
> +/**
> + * xe_eudebug_client_create:
> + * @master_fd: xe client used to open the debugger connection
> + * @work: function that opens xe device and executes arbitrary workload
> + * @flags: flags stored in a client structure, can be used at will
> + * of the caller, i.e. to provide the @work function an additional switch.
> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> + * can be shared between client and debugger. Accesible via client->ptr.
> + * Can be NULL.
> + *
> + * Forks and creates the debugger process. @work won't be called until
> + * xe_eudebug_client_start is called.
> + *
> + * Returns: newly created xe_eudebug_debugger structure with its
> + * event log initialized.
> + */
> +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
> +						   uint64_t flags, void *data)
> +{
> +	struct xe_eudebug_client *c;
> +
> +	c = calloc(1, sizeof(*c));
> +	c->flags = flags;
> +	igt_assert(c);
> +	igt_assert(!pipe(c->p_in));
> +	igt_assert(!pipe(c->p_out));
> +	c->seqno = 1;
> +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
> +	c->done = 0;
> +	c->ptr = data;
> +	c->master_fd = master_fd;
> +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
> +
> +	igt_fork(child, 1) {
> +		int mypid;
> +
> +		igt_assert_eq(c->pid, 0);
> +
> +		close(c->p_out[0]);
> +		c->p_out[0] = -1;
> +		close(c->p_in[1]);
> +		c->p_in[1] = -1;
> +
> +		mypid = getpid();
> +		client_signal(c, CLIENT_PID, mypid);
> +
> +		c->pid = client_wait_token(c, CLIENT_RUN);
> +		igt_assert_eq(c->pid, mypid);
> +		if (work)
> +			work(c);
> +
> +		client_signal(c, CLIENT_FINI, c->seqno);
> +
> +		event_log_write_to_fd(c->log, c->p_out[1]);
> +
> +		c->pid = client_wait_token(c, CLIENT_STOP);
> +		igt_assert_eq(c->pid, mypid);
> +	}
> +
> +	close(c->p_out[1]);
> +	c->p_out[1] = -1;
> +	close(c->p_in[0]);
> +	c->p_in[0] = -1;
> +
> +	c->pid = wait_from_client(c, CLIENT_PID);
> +
> +	igt_info("client running with pid %d\n", c->pid);
> +
> +	return c;
> +}
> +
> +/**
> + * xe_eudebug_client_stop:
> + * @c: pointer to xe_eudebug_client structure
> + *
> + * Waits for the end of client's work and exits the proccess.
> + */
> +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
> +{
> +	if (c->pid) {
> +		int waitstatus;
> +
> +		xe_eudebug_client_wait_done(c);
> +
> +		token_signal(c->p_in, CLIENT_STOP, c->pid);
> +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
> +			      c->pid);
> +		c->pid = 0;
> +	}
> +}
> +
> +/**
> + * xe_eudebug_client_destroy:
> + * @c: pointer to xe_eudebug_client structure to be freed
> + *
> + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
> + * client proccess has not terminated yet.
> + */
> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
> +{
> +	xe_eudebug_client_stop(c);
> +	pipe_close(c->p_in);
> +	pipe_close(c->p_out);
> +	xe_eudebug_event_log_destroy(c->log);
> +	free(c);
> +}
> +
> +/**
> + * xe_eudebug_client_get_seqno:
> + * @c: pointer to xe_eudebug_client structure
> + *
> + * Increments and returns current seqno value of the given client @c
> + *
> + * Returns: incremented seqno
> + */
> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
> +{
> +	return c->seqno++;
> +}
> +
> +/**
> + * xe_eudebug_client_start:
> + * @c: pointer to xe_eudebug_client structure
> + *
> + * Starts execution of client's work function within the client's proccess.
> + */
> +void xe_eudebug_client_start(struct xe_eudebug_client *c)
> +{
> +	token_signal(c->p_in, CLIENT_RUN, c->pid);
> +}
> +
> +/**
> + * xe_eudebug_client_wait_done:
> + * @c: pointer to xe_eudebug_client structure
> + *
> + * Waits for the client work end updates the event log.
> + * Doesn't terminate the client's proccess yet.
> + */
> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
> +{
> +	if (!c->done) {
> +		c->done = 1;
> +		c->seqno = wait_from_client(c, CLIENT_FINI);
> +		event_log_read_from_fd(c->log, c->p_out[0]);
> +	}
> +}
> +
> +/**
> + * xe_eudebug_client_signal_stage:
> + * @c: pointer to the client
> + * @stage: stage to signal
> + *
> + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
> + * releasing it to proceed.
> + */
> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
> +{
> +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
> +}
> +
> +/**
> + * xe_eudebug_client_wait_stage:
> + * @c: pointer to xe_eudebug_client structure
> + * @stage: stage to wait on
> + *
> + * Pauses client until the debugger has signalled the corresponding stage with
> + * xe_eudebug_debugger_signal_stage. This is only for situations where the
> + * actual event flow is not enough to coordinate between client/debugger and extra
> + * sync mechanism is needed.
> + *
> + */
> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
> +{
> +	u64 stage_in;
> +
> +	if (c->done) {
> +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
> +		return;
> +	}
> +
> +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
> +
> +	stage_in = client_wait_token(c, CLIENT_STAGE);
> +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
> +
> +	igt_assert_eq(stage_in, stage);
> +}
> +
> +
> +/**
> + * xe_eudebug_session_create:
> + * @fd: XE file descriptor
> + * @work: function passed to the xe_eudebug_client_create
> + * @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.
> + *
> + * Creates session together with client and debugger structures.
> + */
> +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
> +						     xe_eudebug_client_work_fn work,
> +						     unsigned int flags,
> +						     void *test_private)
> +{
> +	struct xe_eudebug_session *s;
> +
> +	s = calloc(1, sizeof(*s));
> +	igt_assert(s);
> +
> +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
> +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
> +	s->flags = flags;
> +
> +	return s;
> +}
> +
> +/**
> + * xe_eudebug_session_run:
> + * @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.
> + */
> +void xe_eudebug_session_run(struct xe_eudebug_session *s)
> +{
> +	struct xe_eudebug_debugger *debugger = s->d;
> +	struct xe_eudebug_client *client = s->c;
> +
> +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
> +
> +	xe_eudebug_debugger_start_worker(debugger);
> +
> +	xe_eudebug_client_start(client);
> +	xe_eudebug_client_wait_done(client);
> +
> +	xe_eudebug_debugger_stop_worker(debugger, 1);
> +
> +	xe_eudebug_event_log_print(debugger->log, true);
> +	xe_eudebug_event_log_print(client->log, true);
> +}
> +
> +/**
> + * xe_eudebug_session_check:
> + * @s: pointer to xe_eudebug_session structure
> + * @match_opposite: indicates whether check should match all
> + * create and destroy events.
> + * @filter: mask that represents events to be skipped during comparison, useful
> + * for events like 'VM_BIND' since they can be asymmetric
> + *
> + * Validate debugger's log against the log created by the client.
> + */
> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
> +{
> +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
> +
> +	if (match_opposite)
> +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
> +}
> +
> +/**
> + * xe_eudebug_session_destroy:
> + * @s: pointer to xe_eudebug_session structure
> + *
> + * Destroy session together with its debugger and client.
> + */
> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
> +{
> +	xe_eudebug_debugger_destroy(s->d);
> +	xe_eudebug_client_destroy(s->c);
> +
> +	free(s);
> +}
> +
> +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
> +
> +static void base_event(struct xe_eudebug_client *c,
> +		       struct drm_xe_eudebug_event *e,
> +		       uint32_t type,
> +		       uint32_t flags,
> +		       uint64_t size)
> +{
> +	e->type = type;
> +	e->flags = flags;
> +	e->seqno = xe_eudebug_client_get_seqno(c);
> +	e->len = size;
> +}
> +
> +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
> +{
> +	struct drm_xe_eudebug_event_client ec;
> +
> +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
> +
> +	ec.client_handle = client_fd;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&ec);
> +}
> +
> +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
> +{
> +	struct drm_xe_eudebug_event_vm evm;
> +
> +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
> +
> +	evm.client_handle = client_fd;
> +	evm.vm_handle = vm_id;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&evm);
> +}
> +
> +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
> +			     int client_fd, uint32_t vm_id,
> +			     uint32_t exec_queue_handle, uint16_t class,
> +			     uint16_t width)
> +{
> +	struct drm_xe_eudebug_event_exec_queue ee;
> +
> +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> +		   flags, sizeof(ee));
> +
> +	ee.client_handle = client_fd;
> +	ee.vm_handle = vm_id;
> +	ee.exec_queue_handle = exec_queue_handle;
> +	ee.engine_class = class;
> +	ee.width = width;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&ee);
> +}
> +
> +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
> +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
> +{
> +	struct drm_xe_eudebug_event_metadata em;
> +
> +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
> +		   flags, sizeof(em));
> +
> +	em.client_handle = client_fd;
> +	em.metadata_handle = id;
> +	em.type = type;
> +	em.len = len;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&em);
> +}
> +
> +static int enable_getset(int fd, bool *old, bool *new)
> +{
> +	static const char * const fname = "enable_eudebug";
> +	int ret = 0;
> +
> +	int sysfs, device_fd;
> +	bool val_before;
> +	struct stat st;
> +
> +	igt_assert(new || old);
> +
> +	igt_assert_eq(fstat(fd, &st), 0);
> +	sysfs = igt_sysfs_open(fd);
> +	if (sysfs < 0)
> +		return -1;
> +
> +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
> +	close(sysfs);
> +	if (device_fd < 0)
> +		return -1;
> +
> +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
> +		ret = -1;
> +		goto out;
> +	}
> +
> +	igt_debug("enable_eudebug before: %d\n", val_before);
> +
> +	if (old)
> +		*old = val_before;
> +
> +	ret = 0;
> +	if (new) {
> +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
> +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
> +		else
> +			ret = -1;
> +	}
> +
> +out:
> +	close(device_fd);
> +	return ret;
> +}
> +
> +/**
> + * xe_eudebug_enable
> + * @fd: xe client
> + * @enable: state toggle - true to enable, false to disable
> + *
> + * Enables/disables eudebug capability by writing to
> + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
> + *
> + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
> + * false when eudebugging was disabled.
> + */
> +bool xe_eudebug_enable(int fd, bool enable)
> +{
> +	bool old = false;
> +	int ret = enable_getset(fd, &old, &enable);
> +
> +	if (ret) {
> +		igt_skip_on(enable);
> +		old = false;
> +	}
> +
> +	return old;
> +}
> +
> +/* Eu debugger wrappers around resource creating xe ioctls. */
> +
> +/**
> + * xe_eudebug_client_open_driver:
> + * @c: pointer to xe_eudebug_client structure
> + *
> + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
> + * event in client's event log.
> + *
> + * Returns: valid DRM file descriptor
> + */
> +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
> +{
> +	int fd;
> +
> +	fd = drm_reopen_driver(c->master_fd);
> +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
> +
> +	return fd;
> +}
> +
> +/**
> + * xe_eudebug_client_close_driver:
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + *
> + * Calls close driver and logs the corresponding event in
> + * client's event log.
> + */
> +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
> +{
> +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
> +	close(fd);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_create:
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @flags: vm bind flags
> + * @ext: pointer to the first user extension
> + *
> + * Calls xe_vm_create() and logs corresponding events
> + * (including vm set metadata events) in client's event log.
> + *
> + * Returns: valid vm handle
> + */
> +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
> +				     uint32_t flags, uint64_t ext)
> +{
> +	uint32_t vm;
> +
> +	vm = xe_vm_create(fd, flags, ext);
> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
> +
> +	return vm;
> +}
> +
> +/**
> + * xe_eudebug_client_vm_destroy:
> + * @c: pointer to xe_eudebug_client structure
> + * fd: xe client
> + * vm: vm handle
> + *
> + * Calls xe_vm_destroy() and logs the corresponding event in
> + * client's event log.
> + */
> +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
> +{
> +	xe_vm_destroy(fd, vm);
> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
> +}
> +
> +/**
> + * xe_eudebug_client_exec_queue_create:
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @create: exec_queue create drm struct
> + *
> + * Calls xe exec queue create ioctl and logs the corresponding event in
> + * client's event log.
> + *
> + * Returns: valid exec queue handle
> + */
> +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
> +					     struct drm_xe_exec_queue_create *create)
> +{
> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> +
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
> +
> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
> +				 create->exec_queue_id, class, create->width);
> +
> +	return create->exec_queue_id;
> +}
> +
> +/**
> + * xe_eudebug_client_exec_queue_destroy:
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @create: exec_queue create drm struct which was used for creation
> + *
> + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
> + * client's event log.
> + */
> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> +					  struct drm_xe_exec_queue_create *create)
> +{
> +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> +
> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
> +				 create->exec_queue_id, class, create->width);
> +
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_bind_event:
> + * @c: pointer to xe_eudebug_client structure
> + * @event_flags: base event flags
> + * @fd: xe client
> + * @vm: vm handle
> + * @bind_flags: bind flags of vm_bind_event
> + * @num_binds: 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, int fd,
> +				     uint32_t vm, uint32_t bind_flags,
> +				     uint32_t num_binds, u64 *ref_seqno)
> +{
> +	struct drm_xe_eudebug_event_vm_bind evmb;
> +
> +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
> +		   event_flags, sizeof(evmb));
> +	evmb.client_handle = fd;
> +	evmb.vm_handle = vm;
> +	evmb.flags = bind_flags;
> +	evmb.num_binds = num_binds;
> +
> +	*ref_seqno = evmb.base.seqno;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_bind_op_event:
> + * @c: pointer to xe_eudebug_client structure
> + * @event_flags: base event flags
> + * @bind_ref_seqno: base vm bind reference seqno
> + * @op_ref_seqno: output, the vm_bind_op event seqno
> + * @addr: ppgtt address
> + * @size: size of the binding
> + * @num_extensions: number of vm bind op extensions
> + *
> + * Logs vm bind op event in client's event log.
> + */
> +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
> +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
> +					uint64_t addr, uint64_t range,
> +					uint64_t num_extensions)
> +{
> +	struct drm_xe_eudebug_event_vm_bind_op op;
> +
> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
> +		   event_flags, sizeof(op));
> +	op.vm_bind_ref_seqno = bind_ref_seqno;
> +	op.addr = addr;
> +	op.range = range;
> +	op.num_extensions = num_extensions;
> +
> +	*op_ref_seqno = op.base.seqno;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&op);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_bind_op_metadata_event:
> + * @c: pointer to xe_eudebug_client structure
> + * @event_flags: base event flags
> + * @op_ref_seqno: base vm bind op reference seqno
> + * @metadata_handle: metadata handle
> + * @metadata_cookie: metadata cookie
> + *
> + * Logs vm bind op metadata event in client's event log.
> + */
> +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)
> +{
> +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
> +
> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
> +		   event_flags, sizeof(op));
> +	op.vm_bind_op_ref_seqno = op_ref_seqno;
> +	op.metadata_handle = metadata_handle;
> +	op.metadata_cookie = metadata_cookie;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&op);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_bind_ufence_event:
> + * @c: pointer to xe_eudebug_client structure
> + * @event_flags: base event flags
> + * @ref_seqno: base vm bind event seqno
> + *
> + * Logs vm bind ufence event in client's event log.
> + */
> +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
> +					    uint64_t ref_seqno)
> +{
> +	struct drm_xe_eudebug_event_vm_bind_ufence f;
> +
> +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> +		   event_flags, sizeof(f));
> +	f.vm_bind_ref_seqno = ref_seqno;
> +
> +	xe_eudebug_event_log_write(c->log, (void *)&f);
> +}
> +
> +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
> +{
> +	while (num_syncs--)
> +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
> +			return true;
> +
> +	return false;
> +}
> +
> +#define for_each_metadata(__m, __ext)					\
> +	for ((__m) = from_user_pointer(__ext);				\
> +	     (__m);							\
> +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
> +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
> +
> +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
> +					int fd, uint32_t vm, uint32_t exec_queue,
> +					uint32_t bo, uint64_t offset,
> +					uint64_t addr, uint64_t size,
> +					uint32_t op, uint32_t flags,
> +					struct drm_xe_sync *sync,
> +					uint32_t num_syncs,
> +					uint32_t prefetch_region,
> +					uint8_t pat_index, uint64_t op_ext)
> +{
> +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
> +	const bool ufence = has_user_fence(sync, num_syncs);
> +	const uint32_t bind_flags = ufence ?
> +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
> +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
> +	uint32_t bind_base_flags = 0;
> +	int ret;
> +
> +	for_each_metadata(metadata, op_ext)
> +		num_metadata++;
> +
> +	switch (op) {
> +	case DRM_XE_VM_BIND_OP_MAP:
> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
> +		break;
> +	case DRM_XE_VM_BIND_OP_UNMAP:
> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
> +		igt_assert_eq(num_metadata, 0);
> +		igt_assert_eq(ufence, false);
> +		break;
> +	default:
> +		/* XXX unmap all? */
> +		igt_assert(op);
> +		break;
> +	}
> +
> +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
> +			    op, flags, sync, num_syncs, prefetch_region,
> +			    pat_index, 0, op_ext);
> +
> +	if (ret)
> +		return ret;
> +
> +	if (!bind_base_flags)
> +		return -EINVAL;
> +
> +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
> +					fd, vm, bind_flags, 1, &seqno);
> +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
> +					   seqno, &op_seqno, addr, size,
> +					   num_metadata);
> +
> +	for_each_metadata(metadata, op_ext)
> +		xe_eudebug_client_vm_bind_op_metadata_event(c,
> +							    DRM_XE_EUDEBUG_EVENT_CREATE,
> +							    op_seqno,
> +							    metadata->metadata_id,
> +							    metadata->cookie);
> +	if (ufence)
> +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
> +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
> +						       seqno);
> +	return ret;
> +}
> +
> +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
> +				       uint32_t vm, uint32_t bo,
> +				       uint64_t offset, uint64_t addr, uint64_t size,
> +				       uint32_t op,
> +				       uint32_t flags,
> +				       struct drm_xe_sync *sync,
> +				       uint32_t num_syncs,
> +				       uint64_t op_ext)
> +{
> +	const uint32_t exec_queue_id = 0;
> +	const uint32_t prefetch_region = 0;
> +
> +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
> +						  addr, size, op, flags,
> +						  sync, num_syncs, prefetch_region,
> +						  DEFAULT_PAT_INDEX, op_ext),
> +		      0);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_bind_flags
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @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, int fd, 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)
> +{
> +	_xe_eudebug_client_vm_bind(c, fd, 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
> + * @fd: xe client
> + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
> +					flags,
> +					sync, num_syncs, op_ext);
> +}
> +
> +/**
> + * xe_eudebug_client_vm_unbind_flags
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @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, int fd,
> +				       uint32_t vm, uint64_t offset,
> +				       uint64_t addr, uint64_t size, uint32_t flags,
> +				       struct drm_xe_sync *sync, uint32_t num_syncs)
> +{
> +	_xe_eudebug_client_vm_bind(c, fd, 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
> + * @fd: xe client
> + * @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, int fd, 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, fd, vm, offset, addr, size,
> +					  flags, sync, num_syncs);
> +}
> +
> +/**
> + * xe_eudebug_client_metadata_create:
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @type: debug metadata type
> + * @len: size of @data
> + * @data: debug metadata paylad
> + *
> + * Calls xe metadata create ioctl and logs the corresponding event in
> + * client's event log.
> + *
> + * Return: valid debug metadata id.
> + */
> +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
> +					   int type, size_t len, void *data)
> +{
> +	struct drm_xe_debug_metadata_create create = {
> +		.type = type,
> +		.user_addr = to_user_pointer(data),
> +		.len = len
> +	};
> +
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
> +
> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
> +
> +	return create.metadata_id;
> +}
> +
> +/**
> + * xe_eudebug_client_metadata_destroy:
> + * @c: pointer to xe_eudebug_client structure
> + * @fd: xe client
> + * @id: xe debug metadata handle
> + * @type: debug metadata type
> + * @len: size of debug metadata payload
> + *
> + * Calls xe metadata destroy ioctl and logs the corresponding event in
> + * client's event log.
> + */
> +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
> +					uint32_t id, int type, size_t len)
> +{
> +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
> +
> +
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
> +
> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
> +}
> +
> +void xe_eudebug_ack_ufence(int debugfd,
> +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
> +{
> +	struct drm_xe_eudebug_ack_event ack = { 0, };
> +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> +
> +	ack.type = f->base.type;
> +	ack.seqno = f->base.seqno;
> +
> +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> +	igt_debug("delivering ack for event: %s\n", event_str);
> +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
> +}
> diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
> new file mode 100644
> index 000000000..444f5a7b7
> --- /dev/null
> +++ b/lib/xe/xe_eudebug.h
> @@ -0,0 +1,206 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright © 2023 Intel Corporation
> + */
> +#include <fcntl.h>
> +#include <pthread.h>
> +#include <stdint.h>
> +#include <xe_drm.h>
> +
> +#include "igt_list.h"
> +
> +struct xe_eudebug_event_log {
> +	uint8_t *log;
> +	unsigned int head;
> +	unsigned int max_size;
> +	char name[80];
> +	pthread_mutex_t lock;
> +};
> +
> +struct xe_eudebug_debugger {
> +	int fd;
> +	uint64_t flags;
> +
> +	/* Used to smuggle private data */
> +	void *ptr;
> +
> +	struct xe_eudebug_event_log *log;
> +
> +	uint64_t event_count;
> +
> +	uint64_t target_pid;
> +
> +	struct igt_list_head triggers;
> +
> +	int master_fd;
> +
> +	pthread_t worker_thread;
> +	int worker_state;
> +
> +	int p_client[2];
> +};
> +
> +struct xe_eudebug_client {
> +	int pid;
> +	uint64_t seqno;
> +	uint64_t flags;
> +
> +	/* Used to smuggle private data */
> +	void *ptr;
> +
> +	struct xe_eudebug_event_log *log;
> +
> +	int done;
> +	int p_in[2];
> +	int p_out[2];
> +
> +	/* Used to pickup right device (the one used in debugger) */
> +	int master_fd;
> +
> +	int timeout_ms;
> +};
> +
> +struct xe_eudebug_session {
> +	uint64_t flags;
> +	struct xe_eudebug_client *c;
> +	struct xe_eudebug_debugger *d;
> +};
> +
> +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_event(_e, _log) \
> +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
> +		    (void *)(_log)->log; \
> +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
> +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
> +
> +#define xe_eudebug_assert(d, c)						\
> +	do {								\
> +		if (!(c)) {						\
> +			xe_eudebug_event_log_print((d)->log, true);	\
> +			igt_assert(c);					\
> +		}							\
> +	} while (0)
> +
> +#define xe_eudebug_assert_f(d, c, f...)					\
> +	do {								\
> +		if (!(c)) {						\
> +			xe_eudebug_event_log_print((d)->log, true);	\
> +			igt_assert_f(c, f);				\
> +		}							\
> +	} while (0)
> +
> +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
> +
> +/*
> + * Default abort timeout to use across xe_eudebug lib and tests if no specific
> + * timeout value is required.
> + */
> +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
> +
> +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
> +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
> +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
> +
> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
> +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);
> +struct xe_eudebug_event_log *
> +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
> +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
> +				  uint32_t filter);
> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
> +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
> +
> +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_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, int timeout_s);
> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
> +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
> +				     xe_eudebug_trigger_fn fn);
> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
> +
> +struct xe_eudebug_client *
> +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
> +void xe_eudebug_client_start(struct xe_eudebug_client *c);
> +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
> +
> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
> +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
> +
> +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 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,
> +					     struct drm_xe_exec_queue_create *create);
> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> +					  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,
> +				     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,
> +					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,
> +			   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,
> +				     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,
> +			       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,
> +				       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,
> +				 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,
> +						     void *test_private);
> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
> +void xe_eudebug_session_run(struct xe_eudebug_session *s);
> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
> -- 
> 2.34.1
> 

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Manszewski, Christoph]

Hi Zbigniew,

On 20.08.2024 10:14, Zbigniew Kempczyński wrote:
> On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
>> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>
>> Introduce library which simplifies testing of eu debug capability.
>> The library provides event log helpers together with asynchronous
>> abstraction for client proccess and the debugger itself.
>>
>> xe_eudebug_client creates its own proccess with user's work function,
>> and gives machanisms to synchronize beginning of execution and event
>> logging.
>>
>> xe_eudebug_debugger allows to attach to the given proccess, provides
>> asynchronous thread for event reading and introduces triggers -
>> a callback mechanism triggered every time subscribed event was read.
>>
>> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>> Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
>> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
>> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
>> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
>> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
>> ---
>>   lib/meson.build     |    1 +
>>   lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
>>   lib/xe/xe_eudebug.h |  206 ++++
>>   3 files changed, 2399 insertions(+)
>>   create mode 100644 lib/xe/xe_eudebug.c
>>   create mode 100644 lib/xe/xe_eudebug.h
>>
>> diff --git a/lib/meson.build b/lib/meson.build
>> index f711e60a7..969ca4101 100644
>> --- a/lib/meson.build
>> +++ b/lib/meson.build
>> @@ -111,6 +111,7 @@ lib_sources = [
>>   	'igt_msm.c',
>>   	'igt_dsc.c',
>>   	'xe/xe_gt.c',
>> +	'xe/xe_eudebug.c',
>>   	'xe/xe_ioctl.c',
>>   	'xe/xe_mmio.c',
>>   	'xe/xe_query.c',
> 
> As eudebug is quite big feature I think it should be separated and
> hidden behind a feature flag (check meson_options.txt), lets say
> 'xe_eudebug' which would be disabled by default. This way you can
> develop it upstream even if kernel side is not officially merged.
> I'm pragramatic and I see no reason to block not accepted feature
> especially this would imo speed up developement. A final step when
> kernel change would be accepted and merged would be to sync with
> uapi and remove local definitions.
> 
> I look forward maintainers comments is my attitude acceptable.

I agree that it is a good idea. The only problem that arises is for 
'xe_exec_sip'. We add a dependency on eudebug to this test - any ideas 
how to approach this correctly? The only thing that comes to my mind is 
conditional compilation with 'ifdef' statements but it doesn't appear to 
be pretty.

Thanks,
Christoph
> 
> --
> Zbigniew
> 
> 
>> diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
>> new file mode 100644
>> index 000000000..4eac87476
>> --- /dev/null
>> +++ b/lib/xe/xe_eudebug.c
>> @@ -0,0 +1,2192 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2023 Intel Corporation
>> + */
>> +
>> +#include <fcntl.h>
>> +#include <poll.h>
>> +#include <signal.h>
>> +#include <sys/select.h>
>> +#include <sys/stat.h>
>> +#include <sys/types.h>
>> +#include <sys/wait.h>
>> +
>> +#include "igt.h"
>> +#include "igt_sysfs.h"
>> +#include "intel_pat.h"
>> +#include "xe_eudebug.h"
>> +#include "xe_ioctl.h"
>> +
>> +struct event_trigger {
>> +	xe_eudebug_trigger_fn fn;
>> +	int type;
>> +	struct igt_list_head link;
>> +};
>> +
>> +struct seqno_list_entry {
>> +	struct igt_list_head link;
>> +	uint64_t seqno;
>> +};
>> +
>> +struct match_dto {
>> +	struct drm_xe_eudebug_event *target;
>> +	struct igt_list_head *seqno_list;
>> +	uint64_t client_handle;
>> +	uint32_t filter;
>> +
>> +	/* store latest 'EVENT_VM_BIND' seqno */
>> +	uint64_t *bind_seqno;
>> +	/* latest vm_bind_op seqno matching bind_seqno */
>> +	uint64_t *bind_op_seqno;
>> +};
>> +
>> +#define CLIENT_PID  1
>> +#define CLIENT_RUN  2
>> +#define CLIENT_FINI 3
>> +#define CLIENT_STOP 4
>> +#define CLIENT_STAGE 5
>> +#define DEBUGGER_STAGE 6
>> +
>> +#define DEBUGGER_WORKER_INACTIVE  0
>> +#define DEBUGGER_WORKER_ACTIVE  1
>> +#define DEBUGGER_WORKER_QUITTING 2
>> +
>> +static const char *type_to_str(unsigned int type)
>> +{
>> +	switch (type) {
>> +	case DRM_XE_EUDEBUG_EVENT_NONE:
>> +		return "none";
>> +	case DRM_XE_EUDEBUG_EVENT_READ:
>> +		return "read";
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN:
>> +		return "client";
>> +	case DRM_XE_EUDEBUG_EVENT_VM:
>> +		return "vm";
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
>> +		return "exec_queue";
>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
>> +		return "attention";
>> +	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_UFENCE:
>> +		return "vm_bind_ufence";
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA:
>> +		return "metadata";
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
>> +		return "vm_bind_op_metadata";
>> +	}
>> +
>> +	return "UNKNOWN";
>> +}
>> +
>> +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
>> +{
>> +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
>> +
>> +	return buf;
>> +}
>> +
>> +static const char *flags_to_str(unsigned int flags)
>> +{
>> +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
>> +			return "create|ack";
>> +		else
>> +			return "create";
>> +	}
>> +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
>> +		return "destroy";
>> +
>> +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
>> +		return "state-change";
>> +
>> +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
>> +
>> +	return "flags unknown";
>> +}
>> +
>> +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
>> +{
>> +	switch (e->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>> +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
>> +
>> +		sprintf(b, "handle=%llu", ec->client_handle);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>> +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, handle=%llu",
>> +			evm->client_handle, evm->vm_handle);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
>> +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
>> +			ee->client_handle, ee->vm_handle,
>> +			ee->exec_queue_handle, ee->engine_class, ee->width);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
>> +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
>> +			   "lrc_handle=%llu, bitmask_size=%d",
>> +			ea->client_handle, ea->exec_queue_handle,
>> +			ea->lrc_handle, ea->bitmask_size);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
>> +			evmb->client_handle, 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 = (void *)e;
>> +
>> +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
>> +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>> +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
>> +
>> +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>> +
>> +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
>> +			em->client_handle, em->metadata_handle, em->type, em->len);
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
>> +
>> +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
>> +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
>> +		break;
>> +	}
>> +	default:
>> +		strcpy(b, "<...>");
>> +	}
>> +
>> +	return b;
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_to_str:
>> + * @e: pointer to event
>> + * @buf: target to write string representation of @e
>> + * @len: size of target buffer @buf
>> + *
>> + * Creates string representation for given event.
>> + *
>> + * Returns: the written input buffer pointed by @buf.
>> + */
>> +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
>> +{
>> +	char a[256];
>> +	char b[256];
>> +
>> +	snprintf(buf, len, "(%llu) %15s:%s: %s",
>> +		 e->seqno,
>> +		 event_type_to_str(e, a),
>> +		 flags_to_str(e->flags),
>> +		 event_members_to_str(e, b));
>> +
>> +	return buf;
>> +}
>> +
>> +static void catch_child_failure(void)
>> +{
>> +	pid_t pid;
>> +	int status;
>> +
>> +	pid = waitpid(-1, &status, WNOHANG);
>> +
>> +	if (pid == 0 || pid == -1)
>> +		return;
>> +
>> +	if (!WIFEXITED(status))
>> +		return;
>> +
>> +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
>> +}
>> +
>> +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
>> +{
>> +	int ret;
>> +	int t = 0;
>> +	struct pollfd fd = {
>> +		.fd = pipe[0],
>> +		.events = POLLIN,
>> +		.revents = 0
>> +	};
>> +
>> +	/* When child fails we may get stuck forever. Check whether
>> +	 * the child process ended with an error.
>> +	 */
>> +	do {
>> +		const int interval_ms = 1000;
>> +
>> +		ret = poll(&fd, 1, interval_ms);
>> +
>> +		if (!ret) {
>> +			catch_child_failure();
>> +			t += interval_ms;
>> +		}
>> +	} while (!ret && t < timeout_ms);
>> +
>> +	if (ret > 0)
>> +		return read(pipe[0], buf, nbytes);
>> +
>> +	return 0;
>> +}
>> +
>> +static uint64_t pipe_read(int pipe[2], int timeout_ms)
>> +{
>> +	uint64_t in;
>> +	uint64_t ret;
>> +
>> +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
>> +	igt_assert(ret == sizeof(in));
>> +
>> +	return in;
>> +}
>> +
>> +static void pipe_signal(int pipe[2], uint64_t token)
>> +{
>> +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
>> +}
>> +
>> +static void pipe_close(int pipe[2])
>> +{
>> +	if (pipe[0] != -1)
>> +		close(pipe[0]);
>> +
>> +	if (pipe[1] != -1)
>> +		close(pipe[1]);
>> +}
>> +
>> +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
>> +{
>> +	uint64_t in;
>> +
>> +	in = pipe_read(p, timeout_ms);
>> +
>> +	igt_assert_eq(in, token);
>> +
>> +	return pipe_read(p, timeout_ms);
>> +}
>> +
>> +static uint64_t client_wait_token(struct xe_eudebug_client *c,
>> +				 const uint64_t token)
>> +{
>> +	return __wait_token(c->p_in, token, c->timeout_ms);
>> +}
>> +
>> +static uint64_t wait_from_client(struct xe_eudebug_client *c,
>> +				 const uint64_t token)
>> +{
>> +	return __wait_token(c->p_out, token, c->timeout_ms);
>> +}
>> +
>> +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
>> +{
>> +	pipe_signal(p, token);
>> +	pipe_signal(p, value);
>> +}
>> +
>> +static void client_signal(struct xe_eudebug_client *c,
>> +			  const uint64_t token,
>> +			  const uint64_t value)
>> +{
>> +	token_signal(c->p_out, token, value);
>> +}
>> +
>> +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
>> +{
>> +	struct drm_xe_eudebug_connect param = {
>> +		.pid = pid,
>> +		.flags = flags,
>> +	};
>> +	int debugfd;
>> +
>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>> +
>> +	if (debugfd < 0)
>> +		return -errno;
>> +
>> +	return debugfd;
>> +}
>> +
>> +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
>> +{
>> +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
>> +		      sizeof(l->head));
>> +
>> +	igt_assert_eq(write(fd, l->log, l->head), l->head);
>> +}
>> +
>> +static void read_all(int fd, void *buf, size_t nbytes)
>> +{
>> +	ssize_t remaining_size = nbytes;
>> +	ssize_t current_size = 0;
>> +	ssize_t read_size = 0;
>> +
>> +	do {
>> +		read_size = read(fd, buf + current_size, remaining_size);
>> +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
>> +
>> +		current_size += read_size;
>> +		remaining_size -= read_size;
>> +	} while (remaining_size > 0 && read_size > 0);
>> +
>> +	igt_assert_eq(current_size, nbytes);
>> +}
>> +
>> +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
>> +{
>> +	read_all(fd, &l->head, sizeof(l->head));
>> +	igt_assert_lt(l->head, l->max_size);
>> +
>> +	read_all(fd, l->log, l->head);
>> +}
>> +
>> +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
>> +
>> +static struct drm_xe_eudebug_event *
>> +event_cmp(struct xe_eudebug_event_log *l,
>> +	  struct drm_xe_eudebug_event *current,
>> +	  cmp_fn_t match,
>> +	  void *data)
>> +{
>> +	struct drm_xe_eudebug_event *e = current;
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		if (match(e, data))
>> +			return e;
>> +	}
>> +
>> +	return NULL;
>> +}
>> +
>> +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
>> +{
>> +	struct drm_xe_eudebug_event *b = data;
>> +
>> +	if (a->type == b->type &&
>> +	    a->flags == b->flags)
>> +		return 1;
>> +
>> +	return 0;
>> +}
>> +
>> +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
>> +{
>> +	struct drm_xe_eudebug_event *b = data;
>> +	int ret = 0;
>> +
>> +	ret = match_type_and_flags(a, data);
>> +	if (!ret)
>> +		return ret;
>> +
>> +	ret = 0;
>> +
>> +	switch (a->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
>> +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
>> +
>> +		if (ae->engine_class == be->engine_class && ae->width == be->width)
>> +			ret = 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
>> +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
>> +
>> +		if (ea->num_binds == eb->num_binds)
>> +			ret = 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>> +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
>> +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
>> +
>> +		if (ea->addr == eb->addr && ea->range == eb->range &&
>> +		    ea->num_extensions == eb->num_extensions)
>> +			ret = 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
>> +
>> +		if (ea->metadata_handle == eb->metadata_handle &&
>> +		    ea->metadata_cookie == eb->metadata_cookie)
>> +			ret = 1;
>> +		break;
>> +	}
>> +
>> +	default:
>> +		ret = 1;
>> +		break;
>> +	}
>> +
>> +	return ret;
>> +}
>> +
>> +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
>> +{
>> +	struct match_dto *md = (void *)data;
>> +	uint64_t *bind_seqno = md->bind_seqno;
>> +	uint64_t *bind_op_seqno = md->bind_op_seqno;
>> +	uint64_t h = md->client_handle;
>> +
>> +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
>> +		return 0;
>> +
>> +	switch (e->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>> +
>> +		if (client->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>> +
>> +		if (vm->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
>> +
>> +		if (ee->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
>> +
>> +		if (evmb->client_handle == h) {
>> +			*bind_seqno = evmb->base.seqno;
>> +			return 1;
>> +		}
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>> +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
>> +
>> +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
>> +			*bind_op_seqno = eo->base.seqno;
>> +			return 1;
>> +		}
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>> +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
>> +
>> +		if (ef->vm_bind_ref_seqno == *bind_seqno)
>> +			return 1;
>> +
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>> +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
>> +
>> +		if (em->client_handle == h)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
>> +
>> +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
>> +			return 1;
>> +		break;
>> +	}
>> +	default:
>> +		break;
>> +	}
>> +
>> +	return 0;
>> +}
>> +
>> +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
>> +{
>> +
>> +	struct drm_xe_eudebug_event *d = (void *)data;
>> +	int ret;
>> +
>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>> +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
>> +	ret = match_type_and_flags(e, data);
>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>> +
>> +	if (!ret)
>> +		return 0;
>> +
>> +	switch (e->type) {
>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>> +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
>> +
>> +		if (client->client_handle == filter->client_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>> +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
>> +
>> +		if (vm->vm_handle == filter->vm_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>> +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
>> +
>> +		if (ee->exec_queue_handle == filter->exec_queue_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>> +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
>> +
>> +		if (evmb->vm_handle == filter->vm_handle &&
>> +		    evmb->num_binds == filter->num_binds)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>> +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
>> +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
>> +
>> +		if (avmb->addr == filter->addr &&
>> +		    avmb->range == filter->range)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>> +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
>> +
>> +		if (em->metadata_handle == filter->metadata_handle)
>> +			return 1;
>> +		break;
>> +	}
>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
>> +
>> +		if (avmb->metadata_handle == filter->metadata_handle &&
>> +		    avmb->metadata_cookie == filter->metadata_cookie)
>> +			return 1;
>> +		break;
>> +	}
>> +
>> +	default:
>> +		break;
>> +	}
>> +	return 0;
>> +}
>> +
>> +static int match_full(struct drm_xe_eudebug_event *e, void *data)
>> +{
>> +	struct seqno_list_entry *sl;
>> +
>> +	struct match_dto *md = (void *)data;
>> +	int ret = 0;
>> +
>> +	ret = match_client_handle(e, md);
>> +	if (!ret)
>> +		return 0;
>> +
>> +	ret = match_fields(e, md->target);
>> +	if (!ret)
>> +		return 0;
>> +
>> +	igt_list_for_each_entry(sl, md->seqno_list, link) {
>> +		if (sl->seqno == e->seqno)
>> +			return 0;
>> +	}
>> +
>> +	return 1;
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +event_type_match(struct xe_eudebug_event_log *l,
>> +		 struct drm_xe_eudebug_event *target,
>> +		 struct drm_xe_eudebug_event *current)
>> +{
>> +	return event_cmp(l, current, match_type_and_flags, target);
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +client_match(struct xe_eudebug_event_log *l,
>> +	     uint64_t client_handle,
>> +	     struct drm_xe_eudebug_event *current,
>> +	     uint32_t filter,
>> +	     uint64_t *bind_seqno,
>> +	     uint64_t *bind_op_seqno)
>> +{
>> +	struct match_dto md = {
>> +		.client_handle = client_handle,
>> +		.filter = filter,
>> +		.bind_seqno = bind_seqno,
>> +		.bind_op_seqno = bind_op_seqno,
>> +	};
>> +
>> +	return event_cmp(l, current, match_client_handle, &md);
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +opposite_event_match(struct xe_eudebug_event_log *l,
>> +		    struct drm_xe_eudebug_event *target,
>> +		    struct drm_xe_eudebug_event *current)
>> +{
>> +	return event_cmp(l, current, match_opposite_resource, target);
>> +}
>> +
>> +static struct drm_xe_eudebug_event *
>> +event_match(struct xe_eudebug_event_log *l,
>> +	    struct drm_xe_eudebug_event *target,
>> +	    uint64_t client_handle,
>> +	    struct igt_list_head *seqno_list,
>> +	    uint64_t *bind_seqno,
>> +	    uint64_t *bind_op_seqno)
>> +{
>> +	struct match_dto md = {
>> +		.target = target,
>> +		.client_handle = client_handle,
>> +		.seqno_list = seqno_list,
>> +		.bind_seqno = bind_seqno,
>> +		.bind_op_seqno = bind_op_seqno,
>> +	};
>> +
>> +	return event_cmp(l, NULL, match_full, &md);
>> +}
>> +
>> +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
>> +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
>> +			   uint32_t filter)
>> +{
>> +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
>> +	struct drm_xe_eudebug_event_client *de = (void *)_de;
>> +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
>> +
>> +	struct igt_list_head matched_seqno_list;
>> +	struct drm_xe_eudebug_event *hc, *hd;
>> +	struct seqno_list_entry *entry, *tmp;
>> +
>> +	igt_assert(ce);
>> +	igt_assert(de);
>> +
>> +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
>> +
>> +	hc = NULL;
>> +	hd = NULL;
>> +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
>> +
>> +	do {
>> +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
>> +		if (!hc)
>> +			break;
>> +
>> +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
>> +
>> +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
>> +			     c->name,
>> +			     hc->seqno,
>> +			     hc->type,
>> +			     ce->client_handle);
>> +
>> +		igt_debug("comparing %s %llu vs %s %llu\n",
>> +			  c->name, hc->seqno, d->name, hd->seqno);
>> +
>> +		/*
>> +		 * Store the seqno of the event that was matched above,
>> +		 * inside 'matched_seqno_list', to avoid it getting matched
>> +		 * by subsequent 'event_match' calls.
>> +		 */
>> +		entry = malloc(sizeof(*entry));
>> +		entry->seqno = hd->seqno;
>> +		igt_list_add(&entry->link, &matched_seqno_list);
>> +	} while (hc);
>> +
>> +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
>> +		free(entry);
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_find_seqno:
>> + * @l: event log pointer
>> + * @seqno: seqno of event to be found
>> + *
>> + * Finds the event with given seqno in the event log.
>> + *
>> + * Returns: pointer to the event with given seqno within @l or NULL seqno is
>> + * not present.
>> + */
>> +struct drm_xe_eudebug_event *
>> +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
>> +{
>> +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
>> +
>> +	igt_assert_neq(seqno, 0);
>> +	/*
>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>> +	 * as our post processing of events is not optimized.
>> +	 */
>> +	igt_assert_lt(seqno, 10 * 1000 * 1000);
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		if (e->seqno == seqno) {
>> +			if (found) {
>> +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
>> +				xe_eudebug_event_log_print(l, false);
>> +				igt_assert(!found);
>> +			}
>> +			found = e;
>> +		}
>> +	}
>> +
>> +	return found;
>> +}
>> +
>> +static void event_log_sort(struct xe_eudebug_event_log *l)
>> +{
>> +	struct xe_eudebug_event_log *tmp;
>> +	struct drm_xe_eudebug_event *e = NULL;
>> +	uint64_t first_seqno = 0;
>> +	uint64_t last_seqno = 0;
>> +	uint64_t events = 0, added = 0;
>> +	uint64_t i;
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		if (e->seqno > last_seqno)
>> +			last_seqno = e->seqno;
>> +
>> +		if (e->seqno < first_seqno)
>> +			first_seqno = e->seqno;
>> +
>> +		events++;
>> +	}
>> +
>> +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
>> +
>> +	for (i = 1; i <= last_seqno; i++) {
>> +		e = xe_eudebug_event_log_find_seqno(l, i);
>> +		if (e) {
>> +			xe_eudebug_event_log_write(tmp, e);
>> +			added++;
>> +		}
>> +	}
>> +
>> +	igt_assert_eq(events, added);
>> +	igt_assert_eq(tmp->head, l->head);
>> +
>> +	memcpy(l->log, tmp->log, tmp->head);
>> +
>> +	xe_eudebug_event_log_destroy(tmp);
>> +}
>> +
>> +/**
>> + * xe_eudebug_connect:
>> + * @fd: Xe file descriptor
>> + * @pid: client PID
>> + * @flags: connection flags
>> + *
>> + * Opens the xe eu debugger connection to the process described by @pid
>> + *
>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>> + */
>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
>> +{
>> +	int ret;
>> +	uint64_t events = 0; /* events filtering not supported yet! */
>> +
>> +	ret = __xe_eudebug_connect(fd, pid, flags, events);
>> +
>> +	return ret;
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_create:
>> + * @name: event log identifier
>> + * @max_size: maximum size of created log
>> + *
>> + * Function creates an Eu Debugger event log with size equal to @max_size.
>> + *
>> + * Returns: pointer to just created log
>> + */
>> +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
>> +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
>> +{
>> +	struct xe_eudebug_event_log *l;
>> +
>> +	l = calloc(1, sizeof(*l));
>> +	igt_assert(l);
>> +	l->log = calloc(1, max_size);
>> +	igt_assert(l->log);
>> +	l->max_size = max_size;
>> +	strncpy(l->name, name, sizeof(l->name) - 1);
>> +	pthread_mutex_init(&l->lock, NULL);
>> +
>> +	return l;
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_destroy:
>> + * @l: event log pointer
>> + *
>> + * Frees given event log @l.
>> + */
>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
>> +{
>> +	pthread_mutex_destroy(&l->lock);
>> +	free(l->log);
>> +	free(l);
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_write:
>> + * @l: event log pointer
>> + * @e: event to be written to event log
>> + *
>> + * Writes event @e to the event log, thread-safe.
>> + */
>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
>> +{
>> +	igt_assert(e->seqno);
>> +	/*
>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>> +	 * as our post processing of events is not optimized.
>> +	 */
>> +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
>> +
>> +	pthread_mutex_lock(&l->lock);
>> +	igt_assert_lt(l->head + e->len, l->max_size);
>> +	memcpy(l->log + l->head, e, e->len);
>> +	l->head += e->len;
>> +
>> +#ifdef DEBUG_LOG
>> +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
>> +		 l->name, e->len, l->max_size - l->head);
>> +#endif
>> +	pthread_mutex_unlock(&l->lock);
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_print:
>> + * @l: event log pointer
>> + * @debug: when true function uses igt_debug instead of igt_info.
>> + *
>> + * Prints given event log.
>> + */
>> +void
>> +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
>> +{
>> +	struct drm_xe_eudebug_event *e = NULL;
>> +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
>> +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
>> +
>> +	igt_log(IGT_LOG_DOMAIN, level,
>> +		"event log '%s' (%u bytes):\n", l->name, l->head);
>> +
>> +	xe_eudebug_for_each_event(e, l) {
>> +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
>> +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
>> +	}
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_compare:
>> + * @a: event log pointer
>> + * @b: event log pointer
>> + * @filter: mask that represents events to be skipped during comparison, useful
>> + * for events like 'VM_BIND' since they can be asymmetric. Note that
>> + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
>> + *
>> + * Compares and asserts event logs @a, @b if the event
>> + * sequence matches.
>> + */
>> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
>> +				  uint32_t filter)
>> +{
>> +	struct drm_xe_eudebug_event *ae = NULL;
>> +	struct drm_xe_eudebug_event *be = NULL;
>> +
>> +	xe_eudebug_for_each_event(ae, a) {
>> +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
>> +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +			be = event_type_match(b, ae, be);
>> +
>> +			compare_client(a, ae, b, be, filter);
>> +			compare_client(b, be, a, ae, filter);
>> +		}
>> +	}
>> +}
>> +
>> +/**
>> + * xe_eudebug_event_log_match_opposite:
>> + * @l: event log pointer
>> + * @filter: mask that represents events to be skipped during comparison, useful
>> + * for events like 'VM_BIND' since they can be asymmetric
>> + *
>> + * Matches and asserts content of all opposite events (create vs destroy).
>> + */
>> +void
>> +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
>> +{
>> +	struct drm_xe_eudebug_event *ce = NULL;
>> +	struct drm_xe_eudebug_event *de = NULL;
>> +
>> +	xe_eudebug_for_each_event(ce, l) {
>> +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>> +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
>> +			int opposite_matching;
>> +
>> +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
>> +				continue;
>> +
>> +			/* No opposite matching for binds */
>> +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
>> +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
>> +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
>> +				continue;
>> +
>> +			de = opposite_event_match(l, ce, ce);
>> +
>> +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
>> +
>> +			igt_assert_eq(ce->len, de->len);
>> +			opposite_matching = memcmp((uint8_t *)de + offset,
>> +						   (uint8_t *)ce + offset,
>> +						   de->len - offset) == 0;
>> +
>> +			igt_assert_f(opposite_matching,
>> +				     "%s: create|destroy event not "
>> +				     "maching (%llu) vs (%llu)\n",
>> +				     l->name, de->seqno, ce->seqno);
>> +		}
>> +	}
>> +}
>> +
>> +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
>> +				  struct drm_xe_eudebug_event *e)
>> +{
>> +	struct event_trigger *t;
>> +
>> +	igt_list_for_each_entry(t, &d->triggers, link) {
>> +		if (e->type == t->type)
>> +			t->fn(d, e);
>> +	}
>> +}
>> +
>> +#define MAX_EVENT_SIZE (32 * 1024)
>> +static int
>> +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
>> +{
>> +	int ret;
>> +
>> +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
>> +	event->flags = 0;
>> +	event->len = MAX_EVENT_SIZE;
>> +
>> +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
>> +	if (ret < 0)
>> +		return -errno;
>> +
>> +	return ret;
>> +}
>> +
>> +static void *debugger_worker_loop(void *data)
>> +{
>> +	uint8_t buf[MAX_EVENT_SIZE];
>> +	struct drm_xe_eudebug_event *e = (void *)buf;
>> +	struct xe_eudebug_debugger *d = data;
>> +	struct pollfd p = {
>> +		.events = POLLIN,
>> +		.revents = 0,
>> +	};
>> +	int timeout_ms = 100, ret;
>> +
>> +	igt_assert(d->master_fd >= 0);
>> +
>> +	do {
>> +		p.fd = d->fd;
>> +		ret = poll(&p, 1, timeout_ms);
>> +
>> +		if (ret == -1) {
>> +			igt_info("poll failed with errno %d\n", errno);
>> +			break;
>> +		}
>> +
>> +		if (ret == 1 && (p.revents & POLLIN)) {
>> +			int err = xe_eudebug_read_event(d->fd, e);
>> +
>> +			if (!err) {
>> +				++d->event_count;
>> +
>> +				xe_eudebug_event_log_write(d->log, e);
>> +				debugger_run_triggers(d, e);
>> +			} else {
>> +				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;
>> +	return NULL;
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_available:
>> + * @fd: Xe file descriptor
>> + *
>> + * Returns: true it debugger connection is available, false otherwise.
>> + */
>> +bool xe_eudebug_debugger_available(int fd)
>> +{
>> +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
>> +	int debugfd;
>> +
>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>> +	if (debugfd >= 0)
>> +		close(debugfd);
>> +
>> +	return debugfd >= 0;
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_create:
>> + * @master_fd: xe client used to open the debugger connection
>> + * @flags: flags stored in a debugger structure, can be used at will
>> + * of the caller, i.e. to be used inside triggers.
>> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
>> + * can be shared between client and debugger. Can be NULL.
>> + *
>> + * Returns: newly created xe_eudebug_debugger structure with its
>> + * event log initialized. Note that to open the connection
>> + * you need call @xe_eudebug_debugger_attach.
>> + */
>> +struct xe_eudebug_debugger *
>> +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
>> +{
>> +	struct xe_eudebug_debugger *d;
>> +
>> +	d = calloc(1, sizeof(*d));
>> +	d->flags = flags;
>> +	igt_assert(d);
>> +	IGT_INIT_LIST_HEAD(&d->triggers);
>> +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
>> +	d->fd = -1;
>> +	d->master_fd = master_fd;
>> +	d->ptr = data;
>> +
>> +	return d;
>> +}
>> +
>> +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
>> +{
>> +	struct event_trigger *t, *tmp;
>> +
>> +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
>> +		free(t);
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_destroy:
>> + * @d: pointer to the debugger
>> + *
>> + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
>> + * connection was still opened it terminates it.
>> + */
>> +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
>> +{
>> +	if (d->worker_state)
>> +		xe_eudebug_debugger_stop_worker(d, 1);
>> +
>> +	if (d->target_pid)
>> +		xe_eudebug_debugger_dettach(d);
>> +
>> +	xe_eudebug_event_log_destroy(d->log);
>> +	debugger_destroy_triggers(d);
>> +	free(d);
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_attach:
>> + * @d: pointer to the debugger
>> + * @c: pointer to the client
>> + *
>> + * Opens the xe eu debugger connection to the process described by @c (c->pid)
>> + *
>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>> + */
>> +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
>> +			       struct xe_eudebug_client *c)
>> +{
>> +	int ret;
>> +
>> +	igt_assert_eq(d->fd, -1);
>> +	igt_assert_neq(c->pid, 0);
>> +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
>> +
>> +	if (ret < 0)
>> +		return ret;
>> +
>> +	d->fd = ret;
>> +	d->target_pid = c->pid;
>> +	d->p_client[0] = c->p_in[0];
>> +	d->p_client[1] = c->p_in[1];
>> +
>> +	igt_debug("debugger connected to %lu\n", d->target_pid);
>> +
>> +	return 0;
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_dettach:
>> + * @d: pointer to the debugger
>> + *
>> + * Closes previously opened xe eu debugger connection. Asserts if
>> + * the debugger has active session.
>> + */
>> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
>> +{
>> +	igt_assert(d->target_pid);
>> +	close(d->fd);
>> +	d->target_pid = 0;
>> +	d->fd = -1;
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_add_trigger:
>> + * @d: pointer to the debugger
>> + * @type: the type of the event which activates the trigger
>> + * @fn: function to be called when event of @type was read by the debugger.
>> + *
>> + * Adds function @fn to the list of triggers activated when event of @type
>> + * has been read by worker.
>> + * Note: Triggers are activated by the worker.
>> + */
>> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
>> +				     int type, xe_eudebug_trigger_fn fn)
>> +{
>> +	struct event_trigger *t;
>> +
>> +	t = calloc(1, sizeof(*t));
>> +	IGT_INIT_LIST_HEAD(&t->link);
>> +	t->type = type;
>> +	t->fn = fn;
>> +
>> +	igt_list_add_tail(&t->link, &d->triggers);
>> +	igt_debug("added trigger %p\n", t);
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_start_worker:
>> + * @d: pointer to the debugger
>> + *
>> + * Starts the debugger worker. Worker is resposible for reading all
>> + * incoming events from the debugger, put then into debugger log and
>> + * execute appropriate event triggers. Note that using the debuggers
>> + * event log while worker is running is not safe.
>> + */
>> +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
>> +{
>> +	int ret;
>> +
>> +	d->worker_state = true;
>> +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
>> +
>> +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_stop_worker:
>> + * @d: pointer to the debugger
>> + *
>> + * Stops the debugger worker. Event log is sorted by seqno after closure.
>> + */
>> +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
>> +				     int timeout_s)
>> +{
>> +	struct timespec t = {};
>> +	int ret;
>> +
>> +	igt_assert(d->worker_state);
>> +
>> +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
>> +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
>> +	t.tv_sec += timeout_s;
>> +
>> +	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_assert_f(ret == 0 || ret != ESRCH,
>> +		     "pthread join failed with error %d!\n", ret);
>> +
>> +	event_log_sort(d->log);
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_signal_stage:
>> + * @d: pointer to the debugger
>> + * @stage: stage to signal
>> + *
>> + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
>> + * releasing it to proceed.
>> + */
>> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
>> +{
>> +	token_signal(d->p_client, CLIENT_STAGE, stage);
>> +}
>> +
>> +/**
>> + * xe_eudebug_debugger_wait_stage:
>> + * @s: pointer to xe_eudebug_debugger structure
>> + * @stage: stage to wait on
>> + *
>> + * Pauses debugger until the client has signalled the corresponding stage with
>> + * xe_eudebug_client_signal_stage. This is only for situations where the actual
>> + * event flow is not enough to coordinate between client/debugger and extra sync
>> + * mechanism is needed.
>> + */
>> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
>> +{
>> +	u64 stage_in;
>> +
>> +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
>> +
>> +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
>> +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
>> +		  stage_in, stage);
>> +
>> +	igt_assert_eq(stage_in, stage);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_create:
>> + * @master_fd: xe client used to open the debugger connection
>> + * @work: function that opens xe device and executes arbitrary workload
>> + * @flags: flags stored in a client structure, can be used at will
>> + * of the caller, i.e. to provide the @work function an additional switch.
>> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
>> + * can be shared between client and debugger. Accesible via client->ptr.
>> + * Can be NULL.
>> + *
>> + * Forks and creates the debugger process. @work won't be called until
>> + * xe_eudebug_client_start is called.
>> + *
>> + * Returns: newly created xe_eudebug_debugger structure with its
>> + * event log initialized.
>> + */
>> +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
>> +						   uint64_t flags, void *data)
>> +{
>> +	struct xe_eudebug_client *c;
>> +
>> +	c = calloc(1, sizeof(*c));
>> +	c->flags = flags;
>> +	igt_assert(c);
>> +	igt_assert(!pipe(c->p_in));
>> +	igt_assert(!pipe(c->p_out));
>> +	c->seqno = 1;
>> +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
>> +	c->done = 0;
>> +	c->ptr = data;
>> +	c->master_fd = master_fd;
>> +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
>> +
>> +	igt_fork(child, 1) {
>> +		int mypid;
>> +
>> +		igt_assert_eq(c->pid, 0);
>> +
>> +		close(c->p_out[0]);
>> +		c->p_out[0] = -1;
>> +		close(c->p_in[1]);
>> +		c->p_in[1] = -1;
>> +
>> +		mypid = getpid();
>> +		client_signal(c, CLIENT_PID, mypid);
>> +
>> +		c->pid = client_wait_token(c, CLIENT_RUN);
>> +		igt_assert_eq(c->pid, mypid);
>> +		if (work)
>> +			work(c);
>> +
>> +		client_signal(c, CLIENT_FINI, c->seqno);
>> +
>> +		event_log_write_to_fd(c->log, c->p_out[1]);
>> +
>> +		c->pid = client_wait_token(c, CLIENT_STOP);
>> +		igt_assert_eq(c->pid, mypid);
>> +	}
>> +
>> +	close(c->p_out[1]);
>> +	c->p_out[1] = -1;
>> +	close(c->p_in[0]);
>> +	c->p_in[0] = -1;
>> +
>> +	c->pid = wait_from_client(c, CLIENT_PID);
>> +
>> +	igt_info("client running with pid %d\n", c->pid);
>> +
>> +	return c;
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_stop:
>> + * @c: pointer to xe_eudebug_client structure
>> + *
>> + * Waits for the end of client's work and exits the proccess.
>> + */
>> +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
>> +{
>> +	if (c->pid) {
>> +		int waitstatus;
>> +
>> +		xe_eudebug_client_wait_done(c);
>> +
>> +		token_signal(c->p_in, CLIENT_STOP, c->pid);
>> +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
>> +			      c->pid);
>> +		c->pid = 0;
>> +	}
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_destroy:
>> + * @c: pointer to xe_eudebug_client structure to be freed
>> + *
>> + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
>> + * client proccess has not terminated yet.
>> + */
>> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
>> +{
>> +	xe_eudebug_client_stop(c);
>> +	pipe_close(c->p_in);
>> +	pipe_close(c->p_out);
>> +	xe_eudebug_event_log_destroy(c->log);
>> +	free(c);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_get_seqno:
>> + * @c: pointer to xe_eudebug_client structure
>> + *
>> + * Increments and returns current seqno value of the given client @c
>> + *
>> + * Returns: incremented seqno
>> + */
>> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
>> +{
>> +	return c->seqno++;
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_start:
>> + * @c: pointer to xe_eudebug_client structure
>> + *
>> + * Starts execution of client's work function within the client's proccess.
>> + */
>> +void xe_eudebug_client_start(struct xe_eudebug_client *c)
>> +{
>> +	token_signal(c->p_in, CLIENT_RUN, c->pid);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_wait_done:
>> + * @c: pointer to xe_eudebug_client structure
>> + *
>> + * Waits for the client work end updates the event log.
>> + * Doesn't terminate the client's proccess yet.
>> + */
>> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
>> +{
>> +	if (!c->done) {
>> +		c->done = 1;
>> +		c->seqno = wait_from_client(c, CLIENT_FINI);
>> +		event_log_read_from_fd(c->log, c->p_out[0]);
>> +	}
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_signal_stage:
>> + * @c: pointer to the client
>> + * @stage: stage to signal
>> + *
>> + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
>> + * releasing it to proceed.
>> + */
>> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
>> +{
>> +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_wait_stage:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @stage: stage to wait on
>> + *
>> + * Pauses client until the debugger has signalled the corresponding stage with
>> + * xe_eudebug_debugger_signal_stage. This is only for situations where the
>> + * actual event flow is not enough to coordinate between client/debugger and extra
>> + * sync mechanism is needed.
>> + *
>> + */
>> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
>> +{
>> +	u64 stage_in;
>> +
>> +	if (c->done) {
>> +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
>> +		return;
>> +	}
>> +
>> +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
>> +
>> +	stage_in = client_wait_token(c, CLIENT_STAGE);
>> +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
>> +
>> +	igt_assert_eq(stage_in, stage);
>> +}
>> +
>> +
>> +/**
>> + * xe_eudebug_session_create:
>> + * @fd: XE file descriptor
>> + * @work: function passed to the xe_eudebug_client_create
>> + * @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.
>> + *
>> + * Creates session together with client and debugger structures.
>> + */
>> +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
>> +						     xe_eudebug_client_work_fn work,
>> +						     unsigned int flags,
>> +						     void *test_private)
>> +{
>> +	struct xe_eudebug_session *s;
>> +
>> +	s = calloc(1, sizeof(*s));
>> +	igt_assert(s);
>> +
>> +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
>> +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
>> +	s->flags = flags;
>> +
>> +	return s;
>> +}
>> +
>> +/**
>> + * xe_eudebug_session_run:
>> + * @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.
>> + */
>> +void xe_eudebug_session_run(struct xe_eudebug_session *s)
>> +{
>> +	struct xe_eudebug_debugger *debugger = s->d;
>> +	struct xe_eudebug_client *client = s->c;
>> +
>> +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
>> +
>> +	xe_eudebug_debugger_start_worker(debugger);
>> +
>> +	xe_eudebug_client_start(client);
>> +	xe_eudebug_client_wait_done(client);
>> +
>> +	xe_eudebug_debugger_stop_worker(debugger, 1);
>> +
>> +	xe_eudebug_event_log_print(debugger->log, true);
>> +	xe_eudebug_event_log_print(client->log, true);
>> +}
>> +
>> +/**
>> + * xe_eudebug_session_check:
>> + * @s: pointer to xe_eudebug_session structure
>> + * @match_opposite: indicates whether check should match all
>> + * create and destroy events.
>> + * @filter: mask that represents events to be skipped during comparison, useful
>> + * for events like 'VM_BIND' since they can be asymmetric
>> + *
>> + * Validate debugger's log against the log created by the client.
>> + */
>> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
>> +{
>> +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
>> +
>> +	if (match_opposite)
>> +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
>> +}
>> +
>> +/**
>> + * xe_eudebug_session_destroy:
>> + * @s: pointer to xe_eudebug_session structure
>> + *
>> + * Destroy session together with its debugger and client.
>> + */
>> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
>> +{
>> +	xe_eudebug_debugger_destroy(s->d);
>> +	xe_eudebug_client_destroy(s->c);
>> +
>> +	free(s);
>> +}
>> +
>> +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
>> +
>> +static void base_event(struct xe_eudebug_client *c,
>> +		       struct drm_xe_eudebug_event *e,
>> +		       uint32_t type,
>> +		       uint32_t flags,
>> +		       uint64_t size)
>> +{
>> +	e->type = type;
>> +	e->flags = flags;
>> +	e->seqno = xe_eudebug_client_get_seqno(c);
>> +	e->len = size;
>> +}
>> +
>> +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
>> +{
>> +	struct drm_xe_eudebug_event_client ec;
>> +
>> +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
>> +
>> +	ec.client_handle = client_fd;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&ec);
>> +}
>> +
>> +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
>> +{
>> +	struct drm_xe_eudebug_event_vm evm;
>> +
>> +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
>> +
>> +	evm.client_handle = client_fd;
>> +	evm.vm_handle = vm_id;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&evm);
>> +}
>> +
>> +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
>> +			     int client_fd, uint32_t vm_id,
>> +			     uint32_t exec_queue_handle, uint16_t class,
>> +			     uint16_t width)
>> +{
>> +	struct drm_xe_eudebug_event_exec_queue ee;
>> +
>> +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>> +		   flags, sizeof(ee));
>> +
>> +	ee.client_handle = client_fd;
>> +	ee.vm_handle = vm_id;
>> +	ee.exec_queue_handle = exec_queue_handle;
>> +	ee.engine_class = class;
>> +	ee.width = width;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&ee);
>> +}
>> +
>> +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
>> +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
>> +{
>> +	struct drm_xe_eudebug_event_metadata em;
>> +
>> +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
>> +		   flags, sizeof(em));
>> +
>> +	em.client_handle = client_fd;
>> +	em.metadata_handle = id;
>> +	em.type = type;
>> +	em.len = len;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&em);
>> +}
>> +
>> +static int enable_getset(int fd, bool *old, bool *new)
>> +{
>> +	static const char * const fname = "enable_eudebug";
>> +	int ret = 0;
>> +
>> +	int sysfs, device_fd;
>> +	bool val_before;
>> +	struct stat st;
>> +
>> +	igt_assert(new || old);
>> +
>> +	igt_assert_eq(fstat(fd, &st), 0);
>> +	sysfs = igt_sysfs_open(fd);
>> +	if (sysfs < 0)
>> +		return -1;
>> +
>> +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
>> +	close(sysfs);
>> +	if (device_fd < 0)
>> +		return -1;
>> +
>> +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
>> +		ret = -1;
>> +		goto out;
>> +	}
>> +
>> +	igt_debug("enable_eudebug before: %d\n", val_before);
>> +
>> +	if (old)
>> +		*old = val_before;
>> +
>> +	ret = 0;
>> +	if (new) {
>> +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
>> +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
>> +		else
>> +			ret = -1;
>> +	}
>> +
>> +out:
>> +	close(device_fd);
>> +	return ret;
>> +}
>> +
>> +/**
>> + * xe_eudebug_enable
>> + * @fd: xe client
>> + * @enable: state toggle - true to enable, false to disable
>> + *
>> + * Enables/disables eudebug capability by writing to
>> + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
>> + *
>> + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
>> + * false when eudebugging was disabled.
>> + */
>> +bool xe_eudebug_enable(int fd, bool enable)
>> +{
>> +	bool old = false;
>> +	int ret = enable_getset(fd, &old, &enable);
>> +
>> +	if (ret) {
>> +		igt_skip_on(enable);
>> +		old = false;
>> +	}
>> +
>> +	return old;
>> +}
>> +
>> +/* Eu debugger wrappers around resource creating xe ioctls. */
>> +
>> +/**
>> + * xe_eudebug_client_open_driver:
>> + * @c: pointer to xe_eudebug_client structure
>> + *
>> + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
>> + * event in client's event log.
>> + *
>> + * Returns: valid DRM file descriptor
>> + */
>> +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
>> +{
>> +	int fd;
>> +
>> +	fd = drm_reopen_driver(c->master_fd);
>> +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
>> +
>> +	return fd;
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_close_driver:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + *
>> + * Calls close driver and logs the corresponding event in
>> + * client's event log.
>> + */
>> +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
>> +{
>> +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
>> +	close(fd);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_create:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @flags: vm bind flags
>> + * @ext: pointer to the first user extension
>> + *
>> + * Calls xe_vm_create() and logs corresponding events
>> + * (including vm set metadata events) in client's event log.
>> + *
>> + * Returns: valid vm handle
>> + */
>> +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
>> +				     uint32_t flags, uint64_t ext)
>> +{
>> +	uint32_t vm;
>> +
>> +	vm = xe_vm_create(fd, flags, ext);
>> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
>> +
>> +	return vm;
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_destroy:
>> + * @c: pointer to xe_eudebug_client structure
>> + * fd: xe client
>> + * vm: vm handle
>> + *
>> + * Calls xe_vm_destroy() and logs the corresponding event in
>> + * client's event log.
>> + */
>> +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
>> +{
>> +	xe_vm_destroy(fd, vm);
>> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_exec_queue_create:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @create: exec_queue create drm struct
>> + *
>> + * Calls xe exec queue create ioctl and logs the corresponding event in
>> + * client's event log.
>> + *
>> + * Returns: valid exec queue handle
>> + */
>> +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
>> +					     struct drm_xe_exec_queue_create *create)
>> +{
>> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
>> +
>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
>> +
>> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
>> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
>> +				 create->exec_queue_id, class, create->width);
>> +
>> +	return create->exec_queue_id;
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_exec_queue_destroy:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @create: exec_queue create drm struct which was used for creation
>> + *
>> + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
>> + * client's event log.
>> + */
>> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
>> +					  struct drm_xe_exec_queue_create *create)
>> +{
>> +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
>> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
>> +
>> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
>> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
>> +				 create->exec_queue_id, class, create->width);
>> +
>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_bind_event:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @event_flags: base event flags
>> + * @fd: xe client
>> + * @vm: vm handle
>> + * @bind_flags: bind flags of vm_bind_event
>> + * @num_binds: 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, int fd,
>> +				     uint32_t vm, uint32_t bind_flags,
>> +				     uint32_t num_binds, u64 *ref_seqno)
>> +{
>> +	struct drm_xe_eudebug_event_vm_bind evmb;
>> +
>> +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
>> +		   event_flags, sizeof(evmb));
>> +	evmb.client_handle = fd;
>> +	evmb.vm_handle = vm;
>> +	evmb.flags = bind_flags;
>> +	evmb.num_binds = num_binds;
>> +
>> +	*ref_seqno = evmb.base.seqno;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_bind_op_event:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @event_flags: base event flags
>> + * @bind_ref_seqno: base vm bind reference seqno
>> + * @op_ref_seqno: output, the vm_bind_op event seqno
>> + * @addr: ppgtt address
>> + * @size: size of the binding
>> + * @num_extensions: number of vm bind op extensions
>> + *
>> + * Logs vm bind op event in client's event log.
>> + */
>> +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
>> +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
>> +					uint64_t addr, uint64_t range,
>> +					uint64_t num_extensions)
>> +{
>> +	struct drm_xe_eudebug_event_vm_bind_op op;
>> +
>> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
>> +		   event_flags, sizeof(op));
>> +	op.vm_bind_ref_seqno = bind_ref_seqno;
>> +	op.addr = addr;
>> +	op.range = range;
>> +	op.num_extensions = num_extensions;
>> +
>> +	*op_ref_seqno = op.base.seqno;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&op);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_bind_op_metadata_event:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @event_flags: base event flags
>> + * @op_ref_seqno: base vm bind op reference seqno
>> + * @metadata_handle: metadata handle
>> + * @metadata_cookie: metadata cookie
>> + *
>> + * Logs vm bind op metadata event in client's event log.
>> + */
>> +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)
>> +{
>> +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
>> +
>> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
>> +		   event_flags, sizeof(op));
>> +	op.vm_bind_op_ref_seqno = op_ref_seqno;
>> +	op.metadata_handle = metadata_handle;
>> +	op.metadata_cookie = metadata_cookie;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&op);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_bind_ufence_event:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @event_flags: base event flags
>> + * @ref_seqno: base vm bind event seqno
>> + *
>> + * Logs vm bind ufence event in client's event log.
>> + */
>> +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
>> +					    uint64_t ref_seqno)
>> +{
>> +	struct drm_xe_eudebug_event_vm_bind_ufence f;
>> +
>> +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>> +		   event_flags, sizeof(f));
>> +	f.vm_bind_ref_seqno = ref_seqno;
>> +
>> +	xe_eudebug_event_log_write(c->log, (void *)&f);
>> +}
>> +
>> +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
>> +{
>> +	while (num_syncs--)
>> +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
>> +			return true;
>> +
>> +	return false;
>> +}
>> +
>> +#define for_each_metadata(__m, __ext)					\
>> +	for ((__m) = from_user_pointer(__ext);				\
>> +	     (__m);							\
>> +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
>> +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
>> +
>> +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
>> +					int fd, uint32_t vm, uint32_t exec_queue,
>> +					uint32_t bo, uint64_t offset,
>> +					uint64_t addr, uint64_t size,
>> +					uint32_t op, uint32_t flags,
>> +					struct drm_xe_sync *sync,
>> +					uint32_t num_syncs,
>> +					uint32_t prefetch_region,
>> +					uint8_t pat_index, uint64_t op_ext)
>> +{
>> +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
>> +	const bool ufence = has_user_fence(sync, num_syncs);
>> +	const uint32_t bind_flags = ufence ?
>> +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
>> +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
>> +	uint32_t bind_base_flags = 0;
>> +	int ret;
>> +
>> +	for_each_metadata(metadata, op_ext)
>> +		num_metadata++;
>> +
>> +	switch (op) {
>> +	case DRM_XE_VM_BIND_OP_MAP:
>> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
>> +		break;
>> +	case DRM_XE_VM_BIND_OP_UNMAP:
>> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
>> +		igt_assert_eq(num_metadata, 0);
>> +		igt_assert_eq(ufence, false);
>> +		break;
>> +	default:
>> +		/* XXX unmap all? */
>> +		igt_assert(op);
>> +		break;
>> +	}
>> +
>> +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
>> +			    op, flags, sync, num_syncs, prefetch_region,
>> +			    pat_index, 0, op_ext);
>> +
>> +	if (ret)
>> +		return ret;
>> +
>> +	if (!bind_base_flags)
>> +		return -EINVAL;
>> +
>> +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
>> +					fd, vm, bind_flags, 1, &seqno);
>> +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
>> +					   seqno, &op_seqno, addr, size,
>> +					   num_metadata);
>> +
>> +	for_each_metadata(metadata, op_ext)
>> +		xe_eudebug_client_vm_bind_op_metadata_event(c,
>> +							    DRM_XE_EUDEBUG_EVENT_CREATE,
>> +							    op_seqno,
>> +							    metadata->metadata_id,
>> +							    metadata->cookie);
>> +	if (ufence)
>> +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
>> +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
>> +						       seqno);
>> +	return ret;
>> +}
>> +
>> +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
>> +				       uint32_t vm, uint32_t bo,
>> +				       uint64_t offset, uint64_t addr, uint64_t size,
>> +				       uint32_t op,
>> +				       uint32_t flags,
>> +				       struct drm_xe_sync *sync,
>> +				       uint32_t num_syncs,
>> +				       uint64_t op_ext)
>> +{
>> +	const uint32_t exec_queue_id = 0;
>> +	const uint32_t prefetch_region = 0;
>> +
>> +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
>> +						  addr, size, op, flags,
>> +						  sync, num_syncs, prefetch_region,
>> +						  DEFAULT_PAT_INDEX, op_ext),
>> +		      0);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_bind_flags
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @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, int fd, 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)
>> +{
>> +	_xe_eudebug_client_vm_bind(c, fd, 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
>> + * @fd: xe client
>> + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
>> +					flags,
>> +					sync, num_syncs, op_ext);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_vm_unbind_flags
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @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, int fd,
>> +				       uint32_t vm, uint64_t offset,
>> +				       uint64_t addr, uint64_t size, uint32_t flags,
>> +				       struct drm_xe_sync *sync, uint32_t num_syncs)
>> +{
>> +	_xe_eudebug_client_vm_bind(c, fd, 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
>> + * @fd: xe client
>> + * @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, int fd, 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, fd, vm, offset, addr, size,
>> +					  flags, sync, num_syncs);
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_metadata_create:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @type: debug metadata type
>> + * @len: size of @data
>> + * @data: debug metadata paylad
>> + *
>> + * Calls xe metadata create ioctl and logs the corresponding event in
>> + * client's event log.
>> + *
>> + * Return: valid debug metadata id.
>> + */
>> +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
>> +					   int type, size_t len, void *data)
>> +{
>> +	struct drm_xe_debug_metadata_create create = {
>> +		.type = type,
>> +		.user_addr = to_user_pointer(data),
>> +		.len = len
>> +	};
>> +
>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
>> +
>> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
>> +
>> +	return create.metadata_id;
>> +}
>> +
>> +/**
>> + * xe_eudebug_client_metadata_destroy:
>> + * @c: pointer to xe_eudebug_client structure
>> + * @fd: xe client
>> + * @id: xe debug metadata handle
>> + * @type: debug metadata type
>> + * @len: size of debug metadata payload
>> + *
>> + * Calls xe metadata destroy ioctl and logs the corresponding event in
>> + * client's event log.
>> + */
>> +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
>> +					uint32_t id, int type, size_t len)
>> +{
>> +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
>> +
>> +
>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
>> +
>> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
>> +}
>> +
>> +void xe_eudebug_ack_ufence(int debugfd,
>> +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
>> +{
>> +	struct drm_xe_eudebug_ack_event ack = { 0, };
>> +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
>> +
>> +	ack.type = f->base.type;
>> +	ack.seqno = f->base.seqno;
>> +
>> +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
>> +	igt_debug("delivering ack for event: %s\n", event_str);
>> +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
>> +}
>> diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
>> new file mode 100644
>> index 000000000..444f5a7b7
>> --- /dev/null
>> +++ b/lib/xe/xe_eudebug.h
>> @@ -0,0 +1,206 @@
>> +/* SPDX-License-Identifier: MIT */
>> +/*
>> + * Copyright © 2023 Intel Corporation
>> + */
>> +#include <fcntl.h>
>> +#include <pthread.h>
>> +#include <stdint.h>
>> +#include <xe_drm.h>
>> +
>> +#include "igt_list.h"
>> +
>> +struct xe_eudebug_event_log {
>> +	uint8_t *log;
>> +	unsigned int head;
>> +	unsigned int max_size;
>> +	char name[80];
>> +	pthread_mutex_t lock;
>> +};
>> +
>> +struct xe_eudebug_debugger {
>> +	int fd;
>> +	uint64_t flags;
>> +
>> +	/* Used to smuggle private data */
>> +	void *ptr;
>> +
>> +	struct xe_eudebug_event_log *log;
>> +
>> +	uint64_t event_count;
>> +
>> +	uint64_t target_pid;
>> +
>> +	struct igt_list_head triggers;
>> +
>> +	int master_fd;
>> +
>> +	pthread_t worker_thread;
>> +	int worker_state;
>> +
>> +	int p_client[2];
>> +};
>> +
>> +struct xe_eudebug_client {
>> +	int pid;
>> +	uint64_t seqno;
>> +	uint64_t flags;
>> +
>> +	/* Used to smuggle private data */
>> +	void *ptr;
>> +
>> +	struct xe_eudebug_event_log *log;
>> +
>> +	int done;
>> +	int p_in[2];
>> +	int p_out[2];
>> +
>> +	/* Used to pickup right device (the one used in debugger) */
>> +	int master_fd;
>> +
>> +	int timeout_ms;
>> +};
>> +
>> +struct xe_eudebug_session {
>> +	uint64_t flags;
>> +	struct xe_eudebug_client *c;
>> +	struct xe_eudebug_debugger *d;
>> +};
>> +
>> +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_event(_e, _log) \
>> +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
>> +		    (void *)(_log)->log; \
>> +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
>> +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
>> +
>> +#define xe_eudebug_assert(d, c)						\
>> +	do {								\
>> +		if (!(c)) {						\
>> +			xe_eudebug_event_log_print((d)->log, true);	\
>> +			igt_assert(c);					\
>> +		}							\
>> +	} while (0)
>> +
>> +#define xe_eudebug_assert_f(d, c, f...)					\
>> +	do {								\
>> +		if (!(c)) {						\
>> +			xe_eudebug_event_log_print((d)->log, true);	\
>> +			igt_assert_f(c, f);				\
>> +		}							\
>> +	} while (0)
>> +
>> +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
>> +
>> +/*
>> + * Default abort timeout to use across xe_eudebug lib and tests if no specific
>> + * timeout value is required.
>> + */
>> +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
>> +
>> +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
>> +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
>> +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
>> +
>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
>> +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);
>> +struct xe_eudebug_event_log *
>> +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
>> +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
>> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
>> +				  uint32_t filter);
>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
>> +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
>> +
>> +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_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, int timeout_s);
>> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
>> +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
>> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
>> +				     xe_eudebug_trigger_fn fn);
>> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
>> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
>> +
>> +struct xe_eudebug_client *
>> +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
>> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
>> +void xe_eudebug_client_start(struct xe_eudebug_client *c);
>> +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
>> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
>> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
>> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
>> +
>> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
>> +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
>> +
>> +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 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,
>> +					     struct drm_xe_exec_queue_create *create);
>> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
>> +					  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,
>> +				     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,
>> +					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,
>> +			   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,
>> +				     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,
>> +			       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,
>> +				       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,
>> +				 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,
>> +						     void *test_private);
>> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
>> +void xe_eudebug_session_run(struct xe_eudebug_session *s);
>> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
>> -- 
>> 2.34.1
>>

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Kamil Konieczny]

Hi Manszewski,,
On 2024-08-20 at 18:14:07 +0200, Manszewski, Christoph wrote:
> Hi Zbigniew,
> 
> On 20.08.2024 10:14, Zbigniew Kempczyński wrote:
> > On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
> > > From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> > > 
> > > Introduce library which simplifies testing of eu debug capability.
> > > The library provides event log helpers together with asynchronous
> > > abstraction for client proccess and the debugger itself.
> > > 
> > > xe_eudebug_client creates its own proccess with user's work function,
> > > and gives machanisms to synchronize beginning of execution and event
> > > logging.
> > > 
> > > xe_eudebug_debugger allows to attach to the given proccess, provides
> > > asynchronous thread for event reading and introduces triggers -
> > > a callback mechanism triggered every time subscribed event was read.
> > > 
> > > Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> > > Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
> > > Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> > > Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
> > > Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> > > Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> > > ---
> > >   lib/meson.build     |    1 +
> > >   lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
> > >   lib/xe/xe_eudebug.h |  206 ++++
> > >   3 files changed, 2399 insertions(+)
> > >   create mode 100644 lib/xe/xe_eudebug.c
> > >   create mode 100644 lib/xe/xe_eudebug.h
> > > 
> > > diff --git a/lib/meson.build b/lib/meson.build
> > > index f711e60a7..969ca4101 100644
> > > --- a/lib/meson.build
> > > +++ b/lib/meson.build
> > > @@ -111,6 +111,7 @@ lib_sources = [
> > >   	'igt_msm.c',
> > >   	'igt_dsc.c',
> > >   	'xe/xe_gt.c',
> > > +	'xe/xe_eudebug.c',
> > >   	'xe/xe_ioctl.c',
> > >   	'xe/xe_mmio.c',
> > >   	'xe/xe_query.c',
> > 
> > As eudebug is quite big feature I think it should be separated and
> > hidden behind a feature flag (check meson_options.txt), lets say
> > 'xe_eudebug' which would be disabled by default. This way you can
> > develop it upstream even if kernel side is not officially merged.
> > I'm pragramatic and I see no reason to block not accepted feature
> > especially this would imo speed up developement. A final step when
> > kernel change would be accepted and merged would be to sync with
> > uapi and remove local definitions.
> > 
> > I look forward maintainers comments is my attitude acceptable.
> 
> I agree that it is a good idea. The only problem that arises is for
> 'xe_exec_sip'. We add a dependency on eudebug to this test - any ideas how
> to approach this correctly? The only thing that comes to my mind is
> conditional compilation with 'ifdef' statements but it doesn't appear to be
> pretty.

What about adding skips in added tests if kernel do not support eudebug?

This way you can have it without conditional compilation with
ifdef/meson and also have it compile-time tested (if CI support test-with
for Xe kernels).

Regards,
Kamil

> 
> Thanks,
> Christoph
> > 
> > --
> > Zbigniew
> > 
> > 
> > > diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
> > > new file mode 100644
> > > index 000000000..4eac87476
> > > --- /dev/null
> > > +++ b/lib/xe/xe_eudebug.c
> > > @@ -0,0 +1,2192 @@
> > > +// SPDX-License-Identifier: MIT
> > > +/*
> > > + * Copyright © 2023 Intel Corporation
> > > + */
> > > +
> > > +#include <fcntl.h>
> > > +#include <poll.h>
> > > +#include <signal.h>
> > > +#include <sys/select.h>
> > > +#include <sys/stat.h>
> > > +#include <sys/types.h>
> > > +#include <sys/wait.h>
> > > +
> > > +#include "igt.h"
> > > +#include "igt_sysfs.h"
> > > +#include "intel_pat.h"
> > > +#include "xe_eudebug.h"
> > > +#include "xe_ioctl.h"
> > > +
> > > +struct event_trigger {
> > > +	xe_eudebug_trigger_fn fn;
> > > +	int type;
> > > +	struct igt_list_head link;
> > > +};
> > > +
> > > +struct seqno_list_entry {
> > > +	struct igt_list_head link;
> > > +	uint64_t seqno;
> > > +};
> > > +
> > > +struct match_dto {
> > > +	struct drm_xe_eudebug_event *target;
> > > +	struct igt_list_head *seqno_list;
> > > +	uint64_t client_handle;
> > > +	uint32_t filter;
> > > +
> > > +	/* store latest 'EVENT_VM_BIND' seqno */
> > > +	uint64_t *bind_seqno;
> > > +	/* latest vm_bind_op seqno matching bind_seqno */
> > > +	uint64_t *bind_op_seqno;
> > > +};
> > > +
> > > +#define CLIENT_PID  1
> > > +#define CLIENT_RUN  2
> > > +#define CLIENT_FINI 3
> > > +#define CLIENT_STOP 4
> > > +#define CLIENT_STAGE 5
> > > +#define DEBUGGER_STAGE 6
> > > +
> > > +#define DEBUGGER_WORKER_INACTIVE  0
> > > +#define DEBUGGER_WORKER_ACTIVE  1
> > > +#define DEBUGGER_WORKER_QUITTING 2
> > > +
> > > +static const char *type_to_str(unsigned int type)
> > > +{
> > > +	switch (type) {
> > > +	case DRM_XE_EUDEBUG_EVENT_NONE:
> > > +		return "none";
> > > +	case DRM_XE_EUDEBUG_EVENT_READ:
> > > +		return "read";
> > > +	case DRM_XE_EUDEBUG_EVENT_OPEN:
> > > +		return "client";
> > > +	case DRM_XE_EUDEBUG_EVENT_VM:
> > > +		return "vm";
> > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
> > > +		return "exec_queue";
> > > +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
> > > +		return "attention";
> > > +	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_UFENCE:
> > > +		return "vm_bind_ufence";
> > > +	case DRM_XE_EUDEBUG_EVENT_METADATA:
> > > +		return "metadata";
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
> > > +		return "vm_bind_op_metadata";
> > > +	}
> > > +
> > > +	return "UNKNOWN";
> > > +}
> > > +
> > > +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
> > > +{
> > > +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
> > > +
> > > +	return buf;
> > > +}
> > > +
> > > +static const char *flags_to_str(unsigned int flags)
> > > +{
> > > +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
> > > +			return "create|ack";
> > > +		else
> > > +			return "create";
> > > +	}
> > > +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> > > +		return "destroy";
> > > +
> > > +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
> > > +		return "state-change";
> > > +
> > > +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
> > > +
> > > +	return "flags unknown";
> > > +}
> > > +
> > > +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
> > > +{
> > > +	switch (e->type) {
> > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
> > > +
> > > +		sprintf(b, "handle=%llu", ec->client_handle);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
> > > +
> > > +		sprintf(b, "client_handle=%llu, handle=%llu",
> > > +			evm->client_handle, evm->vm_handle);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> > > +
> > > +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
> > > +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
> > > +			ee->client_handle, ee->vm_handle,
> > > +			ee->exec_queue_handle, ee->engine_class, ee->width);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
> > > +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
> > > +
> > > +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
> > > +			   "lrc_handle=%llu, bitmask_size=%d",
> > > +			ea->client_handle, ea->exec_queue_handle,
> > > +			ea->lrc_handle, ea->bitmask_size);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> > > +
> > > +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
> > > +			evmb->client_handle, 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 = (void *)e;
> > > +
> > > +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
> > > +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> > > +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
> > > +
> > > +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> > > +
> > > +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
> > > +			em->client_handle, em->metadata_handle, em->type, em->len);
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
> > > +
> > > +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
> > > +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
> > > +		break;
> > > +	}
> > > +	default:
> > > +		strcpy(b, "<...>");
> > > +	}
> > > +
> > > +	return b;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_to_str:
> > > + * @e: pointer to event
> > > + * @buf: target to write string representation of @e
> > > + * @len: size of target buffer @buf
> > > + *
> > > + * Creates string representation for given event.
> > > + *
> > > + * Returns: the written input buffer pointed by @buf.
> > > + */
> > > +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
> > > +{
> > > +	char a[256];
> > > +	char b[256];
> > > +
> > > +	snprintf(buf, len, "(%llu) %15s:%s: %s",
> > > +		 e->seqno,
> > > +		 event_type_to_str(e, a),
> > > +		 flags_to_str(e->flags),
> > > +		 event_members_to_str(e, b));
> > > +
> > > +	return buf;
> > > +}
> > > +
> > > +static void catch_child_failure(void)
> > > +{
> > > +	pid_t pid;
> > > +	int status;
> > > +
> > > +	pid = waitpid(-1, &status, WNOHANG);
> > > +
> > > +	if (pid == 0 || pid == -1)
> > > +		return;
> > > +
> > > +	if (!WIFEXITED(status))
> > > +		return;
> > > +
> > > +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
> > > +}
> > > +
> > > +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
> > > +{
> > > +	int ret;
> > > +	int t = 0;
> > > +	struct pollfd fd = {
> > > +		.fd = pipe[0],
> > > +		.events = POLLIN,
> > > +		.revents = 0
> > > +	};
> > > +
> > > +	/* When child fails we may get stuck forever. Check whether
> > > +	 * the child process ended with an error.
> > > +	 */
> > > +	do {
> > > +		const int interval_ms = 1000;
> > > +
> > > +		ret = poll(&fd, 1, interval_ms);
> > > +
> > > +		if (!ret) {
> > > +			catch_child_failure();
> > > +			t += interval_ms;
> > > +		}
> > > +	} while (!ret && t < timeout_ms);
> > > +
> > > +	if (ret > 0)
> > > +		return read(pipe[0], buf, nbytes);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static uint64_t pipe_read(int pipe[2], int timeout_ms)
> > > +{
> > > +	uint64_t in;
> > > +	uint64_t ret;
> > > +
> > > +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
> > > +	igt_assert(ret == sizeof(in));
> > > +
> > > +	return in;
> > > +}
> > > +
> > > +static void pipe_signal(int pipe[2], uint64_t token)
> > > +{
> > > +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
> > > +}
> > > +
> > > +static void pipe_close(int pipe[2])
> > > +{
> > > +	if (pipe[0] != -1)
> > > +		close(pipe[0]);
> > > +
> > > +	if (pipe[1] != -1)
> > > +		close(pipe[1]);
> > > +}
> > > +
> > > +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
> > > +{
> > > +	uint64_t in;
> > > +
> > > +	in = pipe_read(p, timeout_ms);
> > > +
> > > +	igt_assert_eq(in, token);
> > > +
> > > +	return pipe_read(p, timeout_ms);
> > > +}
> > > +
> > > +static uint64_t client_wait_token(struct xe_eudebug_client *c,
> > > +				 const uint64_t token)
> > > +{
> > > +	return __wait_token(c->p_in, token, c->timeout_ms);
> > > +}
> > > +
> > > +static uint64_t wait_from_client(struct xe_eudebug_client *c,
> > > +				 const uint64_t token)
> > > +{
> > > +	return __wait_token(c->p_out, token, c->timeout_ms);
> > > +}
> > > +
> > > +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
> > > +{
> > > +	pipe_signal(p, token);
> > > +	pipe_signal(p, value);
> > > +}
> > > +
> > > +static void client_signal(struct xe_eudebug_client *c,
> > > +			  const uint64_t token,
> > > +			  const uint64_t value)
> > > +{
> > > +	token_signal(c->p_out, token, value);
> > > +}
> > > +
> > > +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
> > > +{
> > > +	struct drm_xe_eudebug_connect param = {
> > > +		.pid = pid,
> > > +		.flags = flags,
> > > +	};
> > > +	int debugfd;
> > > +
> > > +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> > > +
> > > +	if (debugfd < 0)
> > > +		return -errno;
> > > +
> > > +	return debugfd;
> > > +}
> > > +
> > > +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
> > > +{
> > > +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
> > > +		      sizeof(l->head));
> > > +
> > > +	igt_assert_eq(write(fd, l->log, l->head), l->head);
> > > +}
> > > +
> > > +static void read_all(int fd, void *buf, size_t nbytes)
> > > +{
> > > +	ssize_t remaining_size = nbytes;
> > > +	ssize_t current_size = 0;
> > > +	ssize_t read_size = 0;
> > > +
> > > +	do {
> > > +		read_size = read(fd, buf + current_size, remaining_size);
> > > +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
> > > +
> > > +		current_size += read_size;
> > > +		remaining_size -= read_size;
> > > +	} while (remaining_size > 0 && read_size > 0);
> > > +
> > > +	igt_assert_eq(current_size, nbytes);
> > > +}
> > > +
> > > +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
> > > +{
> > > +	read_all(fd, &l->head, sizeof(l->head));
> > > +	igt_assert_lt(l->head, l->max_size);
> > > +
> > > +	read_all(fd, l->log, l->head);
> > > +}
> > > +
> > > +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
> > > +
> > > +static struct drm_xe_eudebug_event *
> > > +event_cmp(struct xe_eudebug_event_log *l,
> > > +	  struct drm_xe_eudebug_event *current,
> > > +	  cmp_fn_t match,
> > > +	  void *data)
> > > +{
> > > +	struct drm_xe_eudebug_event *e = current;
> > > +
> > > +	xe_eudebug_for_each_event(e, l) {
> > > +		if (match(e, data))
> > > +			return e;
> > > +	}
> > > +
> > > +	return NULL;
> > > +}
> > > +
> > > +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
> > > +{
> > > +	struct drm_xe_eudebug_event *b = data;
> > > +
> > > +	if (a->type == b->type &&
> > > +	    a->flags == b->flags)
> > > +		return 1;
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
> > > +{
> > > +	struct drm_xe_eudebug_event *b = data;
> > > +	int ret = 0;
> > > +
> > > +	ret = match_type_and_flags(a, data);
> > > +	if (!ret)
> > > +		return ret;
> > > +
> > > +	ret = 0;
> > > +
> > > +	switch (a->type) {
> > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
> > > +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
> > > +
> > > +		if (ae->engine_class == be->engine_class && ae->width == be->width)
> > > +			ret = 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
> > > +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
> > > +
> > > +		if (ea->num_binds == eb->num_binds)
> > > +			ret = 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
> > > +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
> > > +
> > > +		if (ea->addr == eb->addr && ea->range == eb->range &&
> > > +		    ea->num_extensions == eb->num_extensions)
> > > +			ret = 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
> > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
> > > +
> > > +		if (ea->metadata_handle == eb->metadata_handle &&
> > > +		    ea->metadata_cookie == eb->metadata_cookie)
> > > +			ret = 1;
> > > +		break;
> > > +	}
> > > +
> > > +	default:
> > > +		ret = 1;
> > > +		break;
> > > +	}
> > > +
> > > +	return ret;
> > > +}
> > > +
> > > +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
> > > +{
> > > +	struct match_dto *md = (void *)data;
> > > +	uint64_t *bind_seqno = md->bind_seqno;
> > > +	uint64_t *bind_op_seqno = md->bind_op_seqno;
> > > +	uint64_t h = md->client_handle;
> > > +
> > > +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
> > > +		return 0;
> > > +
> > > +	switch (e->type) {
> > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> > > +
> > > +		if (client->client_handle == h)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> > > +
> > > +		if (vm->client_handle == h)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
> > > +
> > > +		if (ee->client_handle == h)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
> > > +
> > > +		if (evmb->client_handle == h) {
> > > +			*bind_seqno = evmb->base.seqno;
> > > +			return 1;
> > > +		}
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
> > > +
> > > +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
> > > +			*bind_op_seqno = eo->base.seqno;
> > > +			return 1;
> > > +		}
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> > > +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
> > > +
> > > +		if (ef->vm_bind_ref_seqno == *bind_seqno)
> > > +			return 1;
> > > +
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
> > > +
> > > +		if (em->client_handle == h)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
> > > +
> > > +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	default:
> > > +		break;
> > > +	}
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
> > > +{
> > > +
> > > +	struct drm_xe_eudebug_event *d = (void *)data;
> > > +	int ret;
> > > +
> > > +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
> > > +	ret = match_type_and_flags(e, data);
> > > +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > +
> > > +	if (!ret)
> > > +		return 0;
> > > +
> > > +	switch (e->type) {
> > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> > > +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
> > > +
> > > +		if (client->client_handle == filter->client_handle)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> > > +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
> > > +
> > > +		if (vm->vm_handle == filter->vm_handle)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> > > +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
> > > +
> > > +		if (ee->exec_queue_handle == filter->exec_queue_handle)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> > > +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
> > > +
> > > +		if (evmb->vm_handle == filter->vm_handle &&
> > > +		    evmb->num_binds == filter->num_binds)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
> > > +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
> > > +
> > > +		if (avmb->addr == filter->addr &&
> > > +		    avmb->range == filter->range)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> > > +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
> > > +
> > > +		if (em->metadata_handle == filter->metadata_handle)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
> > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
> > > +
> > > +		if (avmb->metadata_handle == filter->metadata_handle &&
> > > +		    avmb->metadata_cookie == filter->metadata_cookie)
> > > +			return 1;
> > > +		break;
> > > +	}
> > > +
> > > +	default:
> > > +		break;
> > > +	}
> > > +	return 0;
> > > +}
> > > +
> > > +static int match_full(struct drm_xe_eudebug_event *e, void *data)
> > > +{
> > > +	struct seqno_list_entry *sl;
> > > +
> > > +	struct match_dto *md = (void *)data;
> > > +	int ret = 0;
> > > +
> > > +	ret = match_client_handle(e, md);
> > > +	if (!ret)
> > > +		return 0;
> > > +
> > > +	ret = match_fields(e, md->target);
> > > +	if (!ret)
> > > +		return 0;
> > > +
> > > +	igt_list_for_each_entry(sl, md->seqno_list, link) {
> > > +		if (sl->seqno == e->seqno)
> > > +			return 0;
> > > +	}
> > > +
> > > +	return 1;
> > > +}
> > > +
> > > +static struct drm_xe_eudebug_event *
> > > +event_type_match(struct xe_eudebug_event_log *l,
> > > +		 struct drm_xe_eudebug_event *target,
> > > +		 struct drm_xe_eudebug_event *current)
> > > +{
> > > +	return event_cmp(l, current, match_type_and_flags, target);
> > > +}
> > > +
> > > +static struct drm_xe_eudebug_event *
> > > +client_match(struct xe_eudebug_event_log *l,
> > > +	     uint64_t client_handle,
> > > +	     struct drm_xe_eudebug_event *current,
> > > +	     uint32_t filter,
> > > +	     uint64_t *bind_seqno,
> > > +	     uint64_t *bind_op_seqno)
> > > +{
> > > +	struct match_dto md = {
> > > +		.client_handle = client_handle,
> > > +		.filter = filter,
> > > +		.bind_seqno = bind_seqno,
> > > +		.bind_op_seqno = bind_op_seqno,
> > > +	};
> > > +
> > > +	return event_cmp(l, current, match_client_handle, &md);
> > > +}
> > > +
> > > +static struct drm_xe_eudebug_event *
> > > +opposite_event_match(struct xe_eudebug_event_log *l,
> > > +		    struct drm_xe_eudebug_event *target,
> > > +		    struct drm_xe_eudebug_event *current)
> > > +{
> > > +	return event_cmp(l, current, match_opposite_resource, target);
> > > +}
> > > +
> > > +static struct drm_xe_eudebug_event *
> > > +event_match(struct xe_eudebug_event_log *l,
> > > +	    struct drm_xe_eudebug_event *target,
> > > +	    uint64_t client_handle,
> > > +	    struct igt_list_head *seqno_list,
> > > +	    uint64_t *bind_seqno,
> > > +	    uint64_t *bind_op_seqno)
> > > +{
> > > +	struct match_dto md = {
> > > +		.target = target,
> > > +		.client_handle = client_handle,
> > > +		.seqno_list = seqno_list,
> > > +		.bind_seqno = bind_seqno,
> > > +		.bind_op_seqno = bind_op_seqno,
> > > +	};
> > > +
> > > +	return event_cmp(l, NULL, match_full, &md);
> > > +}
> > > +
> > > +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
> > > +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
> > > +			   uint32_t filter)
> > > +{
> > > +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
> > > +	struct drm_xe_eudebug_event_client *de = (void *)_de;
> > > +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
> > > +
> > > +	struct igt_list_head matched_seqno_list;
> > > +	struct drm_xe_eudebug_event *hc, *hd;
> > > +	struct seqno_list_entry *entry, *tmp;
> > > +
> > > +	igt_assert(ce);
> > > +	igt_assert(de);
> > > +
> > > +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
> > > +
> > > +	hc = NULL;
> > > +	hd = NULL;
> > > +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
> > > +
> > > +	do {
> > > +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
> > > +		if (!hc)
> > > +			break;
> > > +
> > > +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
> > > +
> > > +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
> > > +			     c->name,
> > > +			     hc->seqno,
> > > +			     hc->type,
> > > +			     ce->client_handle);
> > > +
> > > +		igt_debug("comparing %s %llu vs %s %llu\n",
> > > +			  c->name, hc->seqno, d->name, hd->seqno);
> > > +
> > > +		/*
> > > +		 * Store the seqno of the event that was matched above,
> > > +		 * inside 'matched_seqno_list', to avoid it getting matched
> > > +		 * by subsequent 'event_match' calls.
> > > +		 */
> > > +		entry = malloc(sizeof(*entry));
> > > +		entry->seqno = hd->seqno;
> > > +		igt_list_add(&entry->link, &matched_seqno_list);
> > > +	} while (hc);
> > > +
> > > +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
> > > +		free(entry);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_find_seqno:
> > > + * @l: event log pointer
> > > + * @seqno: seqno of event to be found
> > > + *
> > > + * Finds the event with given seqno in the event log.
> > > + *
> > > + * Returns: pointer to the event with given seqno within @l or NULL seqno is
> > > + * not present.
> > > + */
> > > +struct drm_xe_eudebug_event *
> > > +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
> > > +{
> > > +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
> > > +
> > > +	igt_assert_neq(seqno, 0);
> > > +	/*
> > > +	 * Try to catch if seqno is corrupted and prevent too long tests,
> > > +	 * as our post processing of events is not optimized.
> > > +	 */
> > > +	igt_assert_lt(seqno, 10 * 1000 * 1000);
> > > +
> > > +	xe_eudebug_for_each_event(e, l) {
> > > +		if (e->seqno == seqno) {
> > > +			if (found) {
> > > +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
> > > +				xe_eudebug_event_log_print(l, false);
> > > +				igt_assert(!found);
> > > +			}
> > > +			found = e;
> > > +		}
> > > +	}
> > > +
> > > +	return found;
> > > +}
> > > +
> > > +static void event_log_sort(struct xe_eudebug_event_log *l)
> > > +{
> > > +	struct xe_eudebug_event_log *tmp;
> > > +	struct drm_xe_eudebug_event *e = NULL;
> > > +	uint64_t first_seqno = 0;
> > > +	uint64_t last_seqno = 0;
> > > +	uint64_t events = 0, added = 0;
> > > +	uint64_t i;
> > > +
> > > +	xe_eudebug_for_each_event(e, l) {
> > > +		if (e->seqno > last_seqno)
> > > +			last_seqno = e->seqno;
> > > +
> > > +		if (e->seqno < first_seqno)
> > > +			first_seqno = e->seqno;
> > > +
> > > +		events++;
> > > +	}
> > > +
> > > +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
> > > +
> > > +	for (i = 1; i <= last_seqno; i++) {
> > > +		e = xe_eudebug_event_log_find_seqno(l, i);
> > > +		if (e) {
> > > +			xe_eudebug_event_log_write(tmp, e);
> > > +			added++;
> > > +		}
> > > +	}
> > > +
> > > +	igt_assert_eq(events, added);
> > > +	igt_assert_eq(tmp->head, l->head);
> > > +
> > > +	memcpy(l->log, tmp->log, tmp->head);
> > > +
> > > +	xe_eudebug_event_log_destroy(tmp);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_connect:
> > > + * @fd: Xe file descriptor
> > > + * @pid: client PID
> > > + * @flags: connection flags
> > > + *
> > > + * Opens the xe eu debugger connection to the process described by @pid
> > > + *
> > > + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> > > + */
> > > +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
> > > +{
> > > +	int ret;
> > > +	uint64_t events = 0; /* events filtering not supported yet! */
> > > +
> > > +	ret = __xe_eudebug_connect(fd, pid, flags, events);
> > > +
> > > +	return ret;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_create:
> > > + * @name: event log identifier
> > > + * @max_size: maximum size of created log
> > > + *
> > > + * Function creates an Eu Debugger event log with size equal to @max_size.
> > > + *
> > > + * Returns: pointer to just created log
> > > + */
> > > +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
> > > +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
> > > +{
> > > +	struct xe_eudebug_event_log *l;
> > > +
> > > +	l = calloc(1, sizeof(*l));
> > > +	igt_assert(l);
> > > +	l->log = calloc(1, max_size);
> > > +	igt_assert(l->log);
> > > +	l->max_size = max_size;
> > > +	strncpy(l->name, name, sizeof(l->name) - 1);
> > > +	pthread_mutex_init(&l->lock, NULL);
> > > +
> > > +	return l;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_destroy:
> > > + * @l: event log pointer
> > > + *
> > > + * Frees given event log @l.
> > > + */
> > > +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
> > > +{
> > > +	pthread_mutex_destroy(&l->lock);
> > > +	free(l->log);
> > > +	free(l);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_write:
> > > + * @l: event log pointer
> > > + * @e: event to be written to event log
> > > + *
> > > + * Writes event @e to the event log, thread-safe.
> > > + */
> > > +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
> > > +{
> > > +	igt_assert(e->seqno);
> > > +	/*
> > > +	 * Try to catch if seqno is corrupted and prevent too long tests,
> > > +	 * as our post processing of events is not optimized.
> > > +	 */
> > > +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
> > > +
> > > +	pthread_mutex_lock(&l->lock);
> > > +	igt_assert_lt(l->head + e->len, l->max_size);
> > > +	memcpy(l->log + l->head, e, e->len);
> > > +	l->head += e->len;
> > > +
> > > +#ifdef DEBUG_LOG
> > > +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
> > > +		 l->name, e->len, l->max_size - l->head);
> > > +#endif
> > > +	pthread_mutex_unlock(&l->lock);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_print:
> > > + * @l: event log pointer
> > > + * @debug: when true function uses igt_debug instead of igt_info.
> > > + *
> > > + * Prints given event log.
> > > + */
> > > +void
> > > +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
> > > +{
> > > +	struct drm_xe_eudebug_event *e = NULL;
> > > +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
> > > +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> > > +
> > > +	igt_log(IGT_LOG_DOMAIN, level,
> > > +		"event log '%s' (%u bytes):\n", l->name, l->head);
> > > +
> > > +	xe_eudebug_for_each_event(e, l) {
> > > +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> > > +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
> > > +	}
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_compare:
> > > + * @a: event log pointer
> > > + * @b: event log pointer
> > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > + * for events like 'VM_BIND' since they can be asymmetric. Note that
> > > + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
> > > + *
> > > + * Compares and asserts event logs @a, @b if the event
> > > + * sequence matches.
> > > + */
> > > +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
> > > +				  uint32_t filter)
> > > +{
> > > +	struct drm_xe_eudebug_event *ae = NULL;
> > > +	struct drm_xe_eudebug_event *be = NULL;
> > > +
> > > +	xe_eudebug_for_each_event(ae, a) {
> > > +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
> > > +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > +			be = event_type_match(b, ae, be);
> > > +
> > > +			compare_client(a, ae, b, be, filter);
> > > +			compare_client(b, be, a, ae, filter);
> > > +		}
> > > +	}
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_event_log_match_opposite:
> > > + * @l: event log pointer
> > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > + * for events like 'VM_BIND' since they can be asymmetric
> > > + *
> > > + * Matches and asserts content of all opposite events (create vs destroy).
> > > + */
> > > +void
> > > +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
> > > +{
> > > +	struct drm_xe_eudebug_event *ce = NULL;
> > > +	struct drm_xe_eudebug_event *de = NULL;
> > > +
> > > +	xe_eudebug_for_each_event(ce, l) {
> > > +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
> > > +			int opposite_matching;
> > > +
> > > +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
> > > +				continue;
> > > +
> > > +			/* No opposite matching for binds */
> > > +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
> > > +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
> > > +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
> > > +				continue;
> > > +
> > > +			de = opposite_event_match(l, ce, ce);
> > > +
> > > +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
> > > +
> > > +			igt_assert_eq(ce->len, de->len);
> > > +			opposite_matching = memcmp((uint8_t *)de + offset,
> > > +						   (uint8_t *)ce + offset,
> > > +						   de->len - offset) == 0;
> > > +
> > > +			igt_assert_f(opposite_matching,
> > > +				     "%s: create|destroy event not "
> > > +				     "maching (%llu) vs (%llu)\n",
> > > +				     l->name, de->seqno, ce->seqno);
> > > +		}
> > > +	}
> > > +}
> > > +
> > > +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
> > > +				  struct drm_xe_eudebug_event *e)
> > > +{
> > > +	struct event_trigger *t;
> > > +
> > > +	igt_list_for_each_entry(t, &d->triggers, link) {
> > > +		if (e->type == t->type)
> > > +			t->fn(d, e);
> > > +	}
> > > +}
> > > +
> > > +#define MAX_EVENT_SIZE (32 * 1024)
> > > +static int
> > > +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
> > > +{
> > > +	int ret;
> > > +
> > > +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
> > > +	event->flags = 0;
> > > +	event->len = MAX_EVENT_SIZE;
> > > +
> > > +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
> > > +	if (ret < 0)
> > > +		return -errno;
> > > +
> > > +	return ret;
> > > +}
> > > +
> > > +static void *debugger_worker_loop(void *data)
> > > +{
> > > +	uint8_t buf[MAX_EVENT_SIZE];
> > > +	struct drm_xe_eudebug_event *e = (void *)buf;
> > > +	struct xe_eudebug_debugger *d = data;
> > > +	struct pollfd p = {
> > > +		.events = POLLIN,
> > > +		.revents = 0,
> > > +	};
> > > +	int timeout_ms = 100, ret;
> > > +
> > > +	igt_assert(d->master_fd >= 0);
> > > +
> > > +	do {
> > > +		p.fd = d->fd;
> > > +		ret = poll(&p, 1, timeout_ms);
> > > +
> > > +		if (ret == -1) {
> > > +			igt_info("poll failed with errno %d\n", errno);
> > > +			break;
> > > +		}
> > > +
> > > +		if (ret == 1 && (p.revents & POLLIN)) {
> > > +			int err = xe_eudebug_read_event(d->fd, e);
> > > +
> > > +			if (!err) {
> > > +				++d->event_count;
> > > +
> > > +				xe_eudebug_event_log_write(d->log, e);
> > > +				debugger_run_triggers(d, e);
> > > +			} else {
> > > +				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;
> > > +	return NULL;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_available:
> > > + * @fd: Xe file descriptor
> > > + *
> > > + * Returns: true it debugger connection is available, false otherwise.
> > > + */
> > > +bool xe_eudebug_debugger_available(int fd)
> > > +{
> > > +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
> > > +	int debugfd;
> > > +
> > > +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> > > +	if (debugfd >= 0)
> > > +		close(debugfd);
> > > +
> > > +	return debugfd >= 0;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_create:
> > > + * @master_fd: xe client used to open the debugger connection
> > > + * @flags: flags stored in a debugger structure, can be used at will
> > > + * of the caller, i.e. to be used inside triggers.
> > > + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> > > + * can be shared between client and debugger. Can be NULL.
> > > + *
> > > + * Returns: newly created xe_eudebug_debugger structure with its
> > > + * event log initialized. Note that to open the connection
> > > + * you need call @xe_eudebug_debugger_attach.
> > > + */
> > > +struct xe_eudebug_debugger *
> > > +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
> > > +{
> > > +	struct xe_eudebug_debugger *d;
> > > +
> > > +	d = calloc(1, sizeof(*d));
> > > +	d->flags = flags;
> > > +	igt_assert(d);
> > > +	IGT_INIT_LIST_HEAD(&d->triggers);
> > > +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
> > > +	d->fd = -1;
> > > +	d->master_fd = master_fd;
> > > +	d->ptr = data;
> > > +
> > > +	return d;
> > > +}
> > > +
> > > +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
> > > +{
> > > +	struct event_trigger *t, *tmp;
> > > +
> > > +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
> > > +		free(t);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_destroy:
> > > + * @d: pointer to the debugger
> > > + *
> > > + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
> > > + * connection was still opened it terminates it.
> > > + */
> > > +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
> > > +{
> > > +	if (d->worker_state)
> > > +		xe_eudebug_debugger_stop_worker(d, 1);
> > > +
> > > +	if (d->target_pid)
> > > +		xe_eudebug_debugger_dettach(d);
> > > +
> > > +	xe_eudebug_event_log_destroy(d->log);
> > > +	debugger_destroy_triggers(d);
> > > +	free(d);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_attach:
> > > + * @d: pointer to the debugger
> > > + * @c: pointer to the client
> > > + *
> > > + * Opens the xe eu debugger connection to the process described by @c (c->pid)
> > > + *
> > > + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> > > + */
> > > +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
> > > +			       struct xe_eudebug_client *c)
> > > +{
> > > +	int ret;
> > > +
> > > +	igt_assert_eq(d->fd, -1);
> > > +	igt_assert_neq(c->pid, 0);
> > > +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
> > > +
> > > +	if (ret < 0)
> > > +		return ret;
> > > +
> > > +	d->fd = ret;
> > > +	d->target_pid = c->pid;
> > > +	d->p_client[0] = c->p_in[0];
> > > +	d->p_client[1] = c->p_in[1];
> > > +
> > > +	igt_debug("debugger connected to %lu\n", d->target_pid);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_dettach:
> > > + * @d: pointer to the debugger
> > > + *
> > > + * Closes previously opened xe eu debugger connection. Asserts if
> > > + * the debugger has active session.
> > > + */
> > > +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
> > > +{
> > > +	igt_assert(d->target_pid);
> > > +	close(d->fd);
> > > +	d->target_pid = 0;
> > > +	d->fd = -1;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_add_trigger:
> > > + * @d: pointer to the debugger
> > > + * @type: the type of the event which activates the trigger
> > > + * @fn: function to be called when event of @type was read by the debugger.
> > > + *
> > > + * Adds function @fn to the list of triggers activated when event of @type
> > > + * has been read by worker.
> > > + * Note: Triggers are activated by the worker.
> > > + */
> > > +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
> > > +				     int type, xe_eudebug_trigger_fn fn)
> > > +{
> > > +	struct event_trigger *t;
> > > +
> > > +	t = calloc(1, sizeof(*t));
> > > +	IGT_INIT_LIST_HEAD(&t->link);
> > > +	t->type = type;
> > > +	t->fn = fn;
> > > +
> > > +	igt_list_add_tail(&t->link, &d->triggers);
> > > +	igt_debug("added trigger %p\n", t);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_start_worker:
> > > + * @d: pointer to the debugger
> > > + *
> > > + * Starts the debugger worker. Worker is resposible for reading all
> > > + * incoming events from the debugger, put then into debugger log and
> > > + * execute appropriate event triggers. Note that using the debuggers
> > > + * event log while worker is running is not safe.
> > > + */
> > > +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
> > > +{
> > > +	int ret;
> > > +
> > > +	d->worker_state = true;
> > > +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
> > > +
> > > +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_stop_worker:
> > > + * @d: pointer to the debugger
> > > + *
> > > + * Stops the debugger worker. Event log is sorted by seqno after closure.
> > > + */
> > > +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
> > > +				     int timeout_s)
> > > +{
> > > +	struct timespec t = {};
> > > +	int ret;
> > > +
> > > +	igt_assert(d->worker_state);
> > > +
> > > +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
> > > +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
> > > +	t.tv_sec += timeout_s;
> > > +
> > > +	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_assert_f(ret == 0 || ret != ESRCH,
> > > +		     "pthread join failed with error %d!\n", ret);
> > > +
> > > +	event_log_sort(d->log);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_signal_stage:
> > > + * @d: pointer to the debugger
> > > + * @stage: stage to signal
> > > + *
> > > + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
> > > + * releasing it to proceed.
> > > + */
> > > +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
> > > +{
> > > +	token_signal(d->p_client, CLIENT_STAGE, stage);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_debugger_wait_stage:
> > > + * @s: pointer to xe_eudebug_debugger structure
> > > + * @stage: stage to wait on
> > > + *
> > > + * Pauses debugger until the client has signalled the corresponding stage with
> > > + * xe_eudebug_client_signal_stage. This is only for situations where the actual
> > > + * event flow is not enough to coordinate between client/debugger and extra sync
> > > + * mechanism is needed.
> > > + */
> > > +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
> > > +{
> > > +	u64 stage_in;
> > > +
> > > +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
> > > +
> > > +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
> > > +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
> > > +		  stage_in, stage);
> > > +
> > > +	igt_assert_eq(stage_in, stage);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_create:
> > > + * @master_fd: xe client used to open the debugger connection
> > > + * @work: function that opens xe device and executes arbitrary workload
> > > + * @flags: flags stored in a client structure, can be used at will
> > > + * of the caller, i.e. to provide the @work function an additional switch.
> > > + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> > > + * can be shared between client and debugger. Accesible via client->ptr.
> > > + * Can be NULL.
> > > + *
> > > + * Forks and creates the debugger process. @work won't be called until
> > > + * xe_eudebug_client_start is called.
> > > + *
> > > + * Returns: newly created xe_eudebug_debugger structure with its
> > > + * event log initialized.
> > > + */
> > > +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
> > > +						   uint64_t flags, void *data)
> > > +{
> > > +	struct xe_eudebug_client *c;
> > > +
> > > +	c = calloc(1, sizeof(*c));
> > > +	c->flags = flags;
> > > +	igt_assert(c);
> > > +	igt_assert(!pipe(c->p_in));
> > > +	igt_assert(!pipe(c->p_out));
> > > +	c->seqno = 1;
> > > +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
> > > +	c->done = 0;
> > > +	c->ptr = data;
> > > +	c->master_fd = master_fd;
> > > +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
> > > +
> > > +	igt_fork(child, 1) {
> > > +		int mypid;
> > > +
> > > +		igt_assert_eq(c->pid, 0);
> > > +
> > > +		close(c->p_out[0]);
> > > +		c->p_out[0] = -1;
> > > +		close(c->p_in[1]);
> > > +		c->p_in[1] = -1;
> > > +
> > > +		mypid = getpid();
> > > +		client_signal(c, CLIENT_PID, mypid);
> > > +
> > > +		c->pid = client_wait_token(c, CLIENT_RUN);
> > > +		igt_assert_eq(c->pid, mypid);
> > > +		if (work)
> > > +			work(c);
> > > +
> > > +		client_signal(c, CLIENT_FINI, c->seqno);
> > > +
> > > +		event_log_write_to_fd(c->log, c->p_out[1]);
> > > +
> > > +		c->pid = client_wait_token(c, CLIENT_STOP);
> > > +		igt_assert_eq(c->pid, mypid);
> > > +	}
> > > +
> > > +	close(c->p_out[1]);
> > > +	c->p_out[1] = -1;
> > > +	close(c->p_in[0]);
> > > +	c->p_in[0] = -1;
> > > +
> > > +	c->pid = wait_from_client(c, CLIENT_PID);
> > > +
> > > +	igt_info("client running with pid %d\n", c->pid);
> > > +
> > > +	return c;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_stop:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + *
> > > + * Waits for the end of client's work and exits the proccess.
> > > + */
> > > +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
> > > +{
> > > +	if (c->pid) {
> > > +		int waitstatus;
> > > +
> > > +		xe_eudebug_client_wait_done(c);
> > > +
> > > +		token_signal(c->p_in, CLIENT_STOP, c->pid);
> > > +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
> > > +			      c->pid);
> > > +		c->pid = 0;
> > > +	}
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_destroy:
> > > + * @c: pointer to xe_eudebug_client structure to be freed
> > > + *
> > > + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
> > > + * client proccess has not terminated yet.
> > > + */
> > > +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
> > > +{
> > > +	xe_eudebug_client_stop(c);
> > > +	pipe_close(c->p_in);
> > > +	pipe_close(c->p_out);
> > > +	xe_eudebug_event_log_destroy(c->log);
> > > +	free(c);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_get_seqno:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + *
> > > + * Increments and returns current seqno value of the given client @c
> > > + *
> > > + * Returns: incremented seqno
> > > + */
> > > +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
> > > +{
> > > +	return c->seqno++;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_start:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + *
> > > + * Starts execution of client's work function within the client's proccess.
> > > + */
> > > +void xe_eudebug_client_start(struct xe_eudebug_client *c)
> > > +{
> > > +	token_signal(c->p_in, CLIENT_RUN, c->pid);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_wait_done:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + *
> > > + * Waits for the client work end updates the event log.
> > > + * Doesn't terminate the client's proccess yet.
> > > + */
> > > +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
> > > +{
> > > +	if (!c->done) {
> > > +		c->done = 1;
> > > +		c->seqno = wait_from_client(c, CLIENT_FINI);
> > > +		event_log_read_from_fd(c->log, c->p_out[0]);
> > > +	}
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_signal_stage:
> > > + * @c: pointer to the client
> > > + * @stage: stage to signal
> > > + *
> > > + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
> > > + * releasing it to proceed.
> > > + */
> > > +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
> > > +{
> > > +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_wait_stage:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @stage: stage to wait on
> > > + *
> > > + * Pauses client until the debugger has signalled the corresponding stage with
> > > + * xe_eudebug_debugger_signal_stage. This is only for situations where the
> > > + * actual event flow is not enough to coordinate between client/debugger and extra
> > > + * sync mechanism is needed.
> > > + *
> > > + */
> > > +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
> > > +{
> > > +	u64 stage_in;
> > > +
> > > +	if (c->done) {
> > > +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
> > > +		return;
> > > +	}
> > > +
> > > +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
> > > +
> > > +	stage_in = client_wait_token(c, CLIENT_STAGE);
> > > +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
> > > +
> > > +	igt_assert_eq(stage_in, stage);
> > > +}
> > > +
> > > +
> > > +/**
> > > + * xe_eudebug_session_create:
> > > + * @fd: XE file descriptor
> > > + * @work: function passed to the xe_eudebug_client_create
> > > + * @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.
> > > + *
> > > + * Creates session together with client and debugger structures.
> > > + */
> > > +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
> > > +						     xe_eudebug_client_work_fn work,
> > > +						     unsigned int flags,
> > > +						     void *test_private)
> > > +{
> > > +	struct xe_eudebug_session *s;
> > > +
> > > +	s = calloc(1, sizeof(*s));
> > > +	igt_assert(s);
> > > +
> > > +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
> > > +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
> > > +	s->flags = flags;
> > > +
> > > +	return s;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_session_run:
> > > + * @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.
> > > + */
> > > +void xe_eudebug_session_run(struct xe_eudebug_session *s)
> > > +{
> > > +	struct xe_eudebug_debugger *debugger = s->d;
> > > +	struct xe_eudebug_client *client = s->c;
> > > +
> > > +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
> > > +
> > > +	xe_eudebug_debugger_start_worker(debugger);
> > > +
> > > +	xe_eudebug_client_start(client);
> > > +	xe_eudebug_client_wait_done(client);
> > > +
> > > +	xe_eudebug_debugger_stop_worker(debugger, 1);
> > > +
> > > +	xe_eudebug_event_log_print(debugger->log, true);
> > > +	xe_eudebug_event_log_print(client->log, true);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_session_check:
> > > + * @s: pointer to xe_eudebug_session structure
> > > + * @match_opposite: indicates whether check should match all
> > > + * create and destroy events.
> > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > + * for events like 'VM_BIND' since they can be asymmetric
> > > + *
> > > + * Validate debugger's log against the log created by the client.
> > > + */
> > > +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
> > > +{
> > > +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
> > > +
> > > +	if (match_opposite)
> > > +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_session_destroy:
> > > + * @s: pointer to xe_eudebug_session structure
> > > + *
> > > + * Destroy session together with its debugger and client.
> > > + */
> > > +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
> > > +{
> > > +	xe_eudebug_debugger_destroy(s->d);
> > > +	xe_eudebug_client_destroy(s->c);
> > > +
> > > +	free(s);
> > > +}
> > > +
> > > +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
> > > +
> > > +static void base_event(struct xe_eudebug_client *c,
> > > +		       struct drm_xe_eudebug_event *e,
> > > +		       uint32_t type,
> > > +		       uint32_t flags,
> > > +		       uint64_t size)
> > > +{
> > > +	e->type = type;
> > > +	e->flags = flags;
> > > +	e->seqno = xe_eudebug_client_get_seqno(c);
> > > +	e->len = size;
> > > +}
> > > +
> > > +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
> > > +{
> > > +	struct drm_xe_eudebug_event_client ec;
> > > +
> > > +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
> > > +
> > > +	ec.client_handle = client_fd;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&ec);
> > > +}
> > > +
> > > +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
> > > +{
> > > +	struct drm_xe_eudebug_event_vm evm;
> > > +
> > > +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
> > > +
> > > +	evm.client_handle = client_fd;
> > > +	evm.vm_handle = vm_id;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&evm);
> > > +}
> > > +
> > > +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
> > > +			     int client_fd, uint32_t vm_id,
> > > +			     uint32_t exec_queue_handle, uint16_t class,
> > > +			     uint16_t width)
> > > +{
> > > +	struct drm_xe_eudebug_event_exec_queue ee;
> > > +
> > > +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> > > +		   flags, sizeof(ee));
> > > +
> > > +	ee.client_handle = client_fd;
> > > +	ee.vm_handle = vm_id;
> > > +	ee.exec_queue_handle = exec_queue_handle;
> > > +	ee.engine_class = class;
> > > +	ee.width = width;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&ee);
> > > +}
> > > +
> > > +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
> > > +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
> > > +{
> > > +	struct drm_xe_eudebug_event_metadata em;
> > > +
> > > +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
> > > +		   flags, sizeof(em));
> > > +
> > > +	em.client_handle = client_fd;
> > > +	em.metadata_handle = id;
> > > +	em.type = type;
> > > +	em.len = len;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&em);
> > > +}
> > > +
> > > +static int enable_getset(int fd, bool *old, bool *new)
> > > +{
> > > +	static const char * const fname = "enable_eudebug";
> > > +	int ret = 0;
> > > +
> > > +	int sysfs, device_fd;
> > > +	bool val_before;
> > > +	struct stat st;
> > > +
> > > +	igt_assert(new || old);
> > > +
> > > +	igt_assert_eq(fstat(fd, &st), 0);
> > > +	sysfs = igt_sysfs_open(fd);
> > > +	if (sysfs < 0)
> > > +		return -1;
> > > +
> > > +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
> > > +	close(sysfs);
> > > +	if (device_fd < 0)
> > > +		return -1;
> > > +
> > > +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
> > > +		ret = -1;
> > > +		goto out;
> > > +	}
> > > +
> > > +	igt_debug("enable_eudebug before: %d\n", val_before);
> > > +
> > > +	if (old)
> > > +		*old = val_before;
> > > +
> > > +	ret = 0;
> > > +	if (new) {
> > > +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
> > > +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
> > > +		else
> > > +			ret = -1;
> > > +	}
> > > +
> > > +out:
> > > +	close(device_fd);
> > > +	return ret;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_enable
> > > + * @fd: xe client
> > > + * @enable: state toggle - true to enable, false to disable
> > > + *
> > > + * Enables/disables eudebug capability by writing to
> > > + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
> > > + *
> > > + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
> > > + * false when eudebugging was disabled.
> > > + */
> > > +bool xe_eudebug_enable(int fd, bool enable)
> > > +{
> > > +	bool old = false;
> > > +	int ret = enable_getset(fd, &old, &enable);
> > > +
> > > +	if (ret) {
> > > +		igt_skip_on(enable);
> > > +		old = false;
> > > +	}
> > > +
> > > +	return old;
> > > +}
> > > +
> > > +/* Eu debugger wrappers around resource creating xe ioctls. */
> > > +
> > > +/**
> > > + * xe_eudebug_client_open_driver:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + *
> > > + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
> > > + * event in client's event log.
> > > + *
> > > + * Returns: valid DRM file descriptor
> > > + */
> > > +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
> > > +{
> > > +	int fd;
> > > +
> > > +	fd = drm_reopen_driver(c->master_fd);
> > > +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
> > > +
> > > +	return fd;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_close_driver:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + *
> > > + * Calls close driver and logs the corresponding event in
> > > + * client's event log.
> > > + */
> > > +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
> > > +{
> > > +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
> > > +	close(fd);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_create:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @flags: vm bind flags
> > > + * @ext: pointer to the first user extension
> > > + *
> > > + * Calls xe_vm_create() and logs corresponding events
> > > + * (including vm set metadata events) in client's event log.
> > > + *
> > > + * Returns: valid vm handle
> > > + */
> > > +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
> > > +				     uint32_t flags, uint64_t ext)
> > > +{
> > > +	uint32_t vm;
> > > +
> > > +	vm = xe_vm_create(fd, flags, ext);
> > > +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
> > > +
> > > +	return vm;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_destroy:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * fd: xe client
> > > + * vm: vm handle
> > > + *
> > > + * Calls xe_vm_destroy() and logs the corresponding event in
> > > + * client's event log.
> > > + */
> > > +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
> > > +{
> > > +	xe_vm_destroy(fd, vm);
> > > +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_exec_queue_create:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @create: exec_queue create drm struct
> > > + *
> > > + * Calls xe exec queue create ioctl and logs the corresponding event in
> > > + * client's event log.
> > > + *
> > > + * Returns: valid exec queue handle
> > > + */
> > > +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
> > > +					     struct drm_xe_exec_queue_create *create)
> > > +{
> > > +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> > > +
> > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
> > > +
> > > +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> > > +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
> > > +				 create->exec_queue_id, class, create->width);
> > > +
> > > +	return create->exec_queue_id;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_exec_queue_destroy:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @create: exec_queue create drm struct which was used for creation
> > > + *
> > > + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
> > > + * client's event log.
> > > + */
> > > +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> > > +					  struct drm_xe_exec_queue_create *create)
> > > +{
> > > +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
> > > +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> > > +
> > > +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> > > +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
> > > +				 create->exec_queue_id, class, create->width);
> > > +
> > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_bind_event:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @event_flags: base event flags
> > > + * @fd: xe client
> > > + * @vm: vm handle
> > > + * @bind_flags: bind flags of vm_bind_event
> > > + * @num_binds: 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, int fd,
> > > +				     uint32_t vm, uint32_t bind_flags,
> > > +				     uint32_t num_binds, u64 *ref_seqno)
> > > +{
> > > +	struct drm_xe_eudebug_event_vm_bind evmb;
> > > +
> > > +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
> > > +		   event_flags, sizeof(evmb));
> > > +	evmb.client_handle = fd;
> > > +	evmb.vm_handle = vm;
> > > +	evmb.flags = bind_flags;
> > > +	evmb.num_binds = num_binds;
> > > +
> > > +	*ref_seqno = evmb.base.seqno;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_bind_op_event:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @event_flags: base event flags
> > > + * @bind_ref_seqno: base vm bind reference seqno
> > > + * @op_ref_seqno: output, the vm_bind_op event seqno
> > > + * @addr: ppgtt address
> > > + * @size: size of the binding
> > > + * @num_extensions: number of vm bind op extensions
> > > + *
> > > + * Logs vm bind op event in client's event log.
> > > + */
> > > +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
> > > +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
> > > +					uint64_t addr, uint64_t range,
> > > +					uint64_t num_extensions)
> > > +{
> > > +	struct drm_xe_eudebug_event_vm_bind_op op;
> > > +
> > > +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
> > > +		   event_flags, sizeof(op));
> > > +	op.vm_bind_ref_seqno = bind_ref_seqno;
> > > +	op.addr = addr;
> > > +	op.range = range;
> > > +	op.num_extensions = num_extensions;
> > > +
> > > +	*op_ref_seqno = op.base.seqno;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&op);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_bind_op_metadata_event:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @event_flags: base event flags
> > > + * @op_ref_seqno: base vm bind op reference seqno
> > > + * @metadata_handle: metadata handle
> > > + * @metadata_cookie: metadata cookie
> > > + *
> > > + * Logs vm bind op metadata event in client's event log.
> > > + */
> > > +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)
> > > +{
> > > +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
> > > +
> > > +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
> > > +		   event_flags, sizeof(op));
> > > +	op.vm_bind_op_ref_seqno = op_ref_seqno;
> > > +	op.metadata_handle = metadata_handle;
> > > +	op.metadata_cookie = metadata_cookie;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&op);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_bind_ufence_event:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @event_flags: base event flags
> > > + * @ref_seqno: base vm bind event seqno
> > > + *
> > > + * Logs vm bind ufence event in client's event log.
> > > + */
> > > +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
> > > +					    uint64_t ref_seqno)
> > > +{
> > > +	struct drm_xe_eudebug_event_vm_bind_ufence f;
> > > +
> > > +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> > > +		   event_flags, sizeof(f));
> > > +	f.vm_bind_ref_seqno = ref_seqno;
> > > +
> > > +	xe_eudebug_event_log_write(c->log, (void *)&f);
> > > +}
> > > +
> > > +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
> > > +{
> > > +	while (num_syncs--)
> > > +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
> > > +			return true;
> > > +
> > > +	return false;
> > > +}
> > > +
> > > +#define for_each_metadata(__m, __ext)					\
> > > +	for ((__m) = from_user_pointer(__ext);				\
> > > +	     (__m);							\
> > > +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
> > > +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
> > > +
> > > +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
> > > +					int fd, uint32_t vm, uint32_t exec_queue,
> > > +					uint32_t bo, uint64_t offset,
> > > +					uint64_t addr, uint64_t size,
> > > +					uint32_t op, uint32_t flags,
> > > +					struct drm_xe_sync *sync,
> > > +					uint32_t num_syncs,
> > > +					uint32_t prefetch_region,
> > > +					uint8_t pat_index, uint64_t op_ext)
> > > +{
> > > +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
> > > +	const bool ufence = has_user_fence(sync, num_syncs);
> > > +	const uint32_t bind_flags = ufence ?
> > > +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
> > > +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
> > > +	uint32_t bind_base_flags = 0;
> > > +	int ret;
> > > +
> > > +	for_each_metadata(metadata, op_ext)
> > > +		num_metadata++;
> > > +
> > > +	switch (op) {
> > > +	case DRM_XE_VM_BIND_OP_MAP:
> > > +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
> > > +		break;
> > > +	case DRM_XE_VM_BIND_OP_UNMAP:
> > > +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > +		igt_assert_eq(num_metadata, 0);
> > > +		igt_assert_eq(ufence, false);
> > > +		break;
> > > +	default:
> > > +		/* XXX unmap all? */
> > > +		igt_assert(op);
> > > +		break;
> > > +	}
> > > +
> > > +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
> > > +			    op, flags, sync, num_syncs, prefetch_region,
> > > +			    pat_index, 0, op_ext);
> > > +
> > > +	if (ret)
> > > +		return ret;
> > > +
> > > +	if (!bind_base_flags)
> > > +		return -EINVAL;
> > > +
> > > +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
> > > +					fd, vm, bind_flags, 1, &seqno);
> > > +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
> > > +					   seqno, &op_seqno, addr, size,
> > > +					   num_metadata);
> > > +
> > > +	for_each_metadata(metadata, op_ext)
> > > +		xe_eudebug_client_vm_bind_op_metadata_event(c,
> > > +							    DRM_XE_EUDEBUG_EVENT_CREATE,
> > > +							    op_seqno,
> > > +							    metadata->metadata_id,
> > > +							    metadata->cookie);
> > > +	if (ufence)
> > > +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
> > > +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
> > > +						       seqno);
> > > +	return ret;
> > > +}
> > > +
> > > +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
> > > +				       uint32_t vm, uint32_t bo,
> > > +				       uint64_t offset, uint64_t addr, uint64_t size,
> > > +				       uint32_t op,
> > > +				       uint32_t flags,
> > > +				       struct drm_xe_sync *sync,
> > > +				       uint32_t num_syncs,
> > > +				       uint64_t op_ext)
> > > +{
> > > +	const uint32_t exec_queue_id = 0;
> > > +	const uint32_t prefetch_region = 0;
> > > +
> > > +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
> > > +						  addr, size, op, flags,
> > > +						  sync, num_syncs, prefetch_region,
> > > +						  DEFAULT_PAT_INDEX, op_ext),
> > > +		      0);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_bind_flags
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @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, int fd, 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)
> > > +{
> > > +	_xe_eudebug_client_vm_bind(c, fd, 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
> > > + * @fd: xe client
> > > + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
> > > +					flags,
> > > +					sync, num_syncs, op_ext);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_vm_unbind_flags
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @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, int fd,
> > > +				       uint32_t vm, uint64_t offset,
> > > +				       uint64_t addr, uint64_t size, uint32_t flags,
> > > +				       struct drm_xe_sync *sync, uint32_t num_syncs)
> > > +{
> > > +	_xe_eudebug_client_vm_bind(c, fd, 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
> > > + * @fd: xe client
> > > + * @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, int fd, 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, fd, vm, offset, addr, size,
> > > +					  flags, sync, num_syncs);
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_metadata_create:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @type: debug metadata type
> > > + * @len: size of @data
> > > + * @data: debug metadata paylad
> > > + *
> > > + * Calls xe metadata create ioctl and logs the corresponding event in
> > > + * client's event log.
> > > + *
> > > + * Return: valid debug metadata id.
> > > + */
> > > +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
> > > +					   int type, size_t len, void *data)
> > > +{
> > > +	struct drm_xe_debug_metadata_create create = {
> > > +		.type = type,
> > > +		.user_addr = to_user_pointer(data),
> > > +		.len = len
> > > +	};
> > > +
> > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
> > > +
> > > +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
> > > +
> > > +	return create.metadata_id;
> > > +}
> > > +
> > > +/**
> > > + * xe_eudebug_client_metadata_destroy:
> > > + * @c: pointer to xe_eudebug_client structure
> > > + * @fd: xe client
> > > + * @id: xe debug metadata handle
> > > + * @type: debug metadata type
> > > + * @len: size of debug metadata payload
> > > + *
> > > + * Calls xe metadata destroy ioctl and logs the corresponding event in
> > > + * client's event log.
> > > + */
> > > +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
> > > +					uint32_t id, int type, size_t len)
> > > +{
> > > +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
> > > +
> > > +
> > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
> > > +
> > > +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
> > > +}
> > > +
> > > +void xe_eudebug_ack_ufence(int debugfd,
> > > +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
> > > +{
> > > +	struct drm_xe_eudebug_ack_event ack = { 0, };
> > > +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> > > +
> > > +	ack.type = f->base.type;
> > > +	ack.seqno = f->base.seqno;
> > > +
> > > +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> > > +	igt_debug("delivering ack for event: %s\n", event_str);
> > > +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
> > > +}
> > > diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
> > > new file mode 100644
> > > index 000000000..444f5a7b7
> > > --- /dev/null
> > > +++ b/lib/xe/xe_eudebug.h
> > > @@ -0,0 +1,206 @@
> > > +/* SPDX-License-Identifier: MIT */
> > > +/*
> > > + * Copyright © 2023 Intel Corporation
> > > + */
> > > +#include <fcntl.h>
> > > +#include <pthread.h>
> > > +#include <stdint.h>
> > > +#include <xe_drm.h>
> > > +
> > > +#include "igt_list.h"
> > > +
> > > +struct xe_eudebug_event_log {
> > > +	uint8_t *log;
> > > +	unsigned int head;
> > > +	unsigned int max_size;
> > > +	char name[80];
> > > +	pthread_mutex_t lock;
> > > +};
> > > +
> > > +struct xe_eudebug_debugger {
> > > +	int fd;
> > > +	uint64_t flags;
> > > +
> > > +	/* Used to smuggle private data */
> > > +	void *ptr;
> > > +
> > > +	struct xe_eudebug_event_log *log;
> > > +
> > > +	uint64_t event_count;
> > > +
> > > +	uint64_t target_pid;
> > > +
> > > +	struct igt_list_head triggers;
> > > +
> > > +	int master_fd;
> > > +
> > > +	pthread_t worker_thread;
> > > +	int worker_state;
> > > +
> > > +	int p_client[2];
> > > +};
> > > +
> > > +struct xe_eudebug_client {
> > > +	int pid;
> > > +	uint64_t seqno;
> > > +	uint64_t flags;
> > > +
> > > +	/* Used to smuggle private data */
> > > +	void *ptr;
> > > +
> > > +	struct xe_eudebug_event_log *log;
> > > +
> > > +	int done;
> > > +	int p_in[2];
> > > +	int p_out[2];
> > > +
> > > +	/* Used to pickup right device (the one used in debugger) */
> > > +	int master_fd;
> > > +
> > > +	int timeout_ms;
> > > +};
> > > +
> > > +struct xe_eudebug_session {
> > > +	uint64_t flags;
> > > +	struct xe_eudebug_client *c;
> > > +	struct xe_eudebug_debugger *d;
> > > +};
> > > +
> > > +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_event(_e, _log) \
> > > +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
> > > +		    (void *)(_log)->log; \
> > > +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
> > > +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
> > > +
> > > +#define xe_eudebug_assert(d, c)						\
> > > +	do {								\
> > > +		if (!(c)) {						\
> > > +			xe_eudebug_event_log_print((d)->log, true);	\
> > > +			igt_assert(c);					\
> > > +		}							\
> > > +	} while (0)
> > > +
> > > +#define xe_eudebug_assert_f(d, c, f...)					\
> > > +	do {								\
> > > +		if (!(c)) {						\
> > > +			xe_eudebug_event_log_print((d)->log, true);	\
> > > +			igt_assert_f(c, f);				\
> > > +		}							\
> > > +	} while (0)
> > > +
> > > +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
> > > +
> > > +/*
> > > + * Default abort timeout to use across xe_eudebug lib and tests if no specific
> > > + * timeout value is required.
> > > + */
> > > +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
> > > +
> > > +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
> > > +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
> > > +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
> > > +
> > > +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
> > > +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);
> > > +struct xe_eudebug_event_log *
> > > +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
> > > +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
> > > +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
> > > +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
> > > +				  uint32_t filter);
> > > +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
> > > +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
> > > +
> > > +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_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, int timeout_s);
> > > +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
> > > +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
> > > +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
> > > +				     xe_eudebug_trigger_fn fn);
> > > +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
> > > +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
> > > +
> > > +struct xe_eudebug_client *
> > > +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
> > > +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
> > > +void xe_eudebug_client_start(struct xe_eudebug_client *c);
> > > +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
> > > +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
> > > +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
> > > +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
> > > +
> > > +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
> > > +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
> > > +
> > > +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 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,
> > > +					     struct drm_xe_exec_queue_create *create);
> > > +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> > > +					  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,
> > > +				     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,
> > > +					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,
> > > +			   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,
> > > +				     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,
> > > +			       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,
> > > +				       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,
> > > +				 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,
> > > +						     void *test_private);
> > > +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
> > > +void xe_eudebug_session_run(struct xe_eudebug_session *s);
> > > +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
> > > -- 
> > > 2.34.1
> > > 

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Manszewski, Christoph]

Hi Kamil,

On 20.08.2024 19:45, Kamil Konieczny wrote:
> Hi Manszewski,,
> On 2024-08-20 at 18:14:07 +0200, Manszewski, Christoph wrote:
>> Hi Zbigniew,
>>
>> On 20.08.2024 10:14, Zbigniew Kempczyński wrote:
>>> On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
>>>> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>>>
>>>> Introduce library which simplifies testing of eu debug capability.
>>>> The library provides event log helpers together with asynchronous
>>>> abstraction for client proccess and the debugger itself.
>>>>
>>>> xe_eudebug_client creates its own proccess with user's work function,
>>>> and gives machanisms to synchronize beginning of execution and event
>>>> logging.
>>>>
>>>> xe_eudebug_debugger allows to attach to the given proccess, provides
>>>> asynchronous thread for event reading and introduces triggers -
>>>> a callback mechanism triggered every time subscribed event was read.
>>>>
>>>> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>>> Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
>>>> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
>>>> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
>>>> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
>>>> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
>>>> ---
>>>>    lib/meson.build     |    1 +
>>>>    lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
>>>>    lib/xe/xe_eudebug.h |  206 ++++
>>>>    3 files changed, 2399 insertions(+)
>>>>    create mode 100644 lib/xe/xe_eudebug.c
>>>>    create mode 100644 lib/xe/xe_eudebug.h
>>>>
>>>> diff --git a/lib/meson.build b/lib/meson.build
>>>> index f711e60a7..969ca4101 100644
>>>> --- a/lib/meson.build
>>>> +++ b/lib/meson.build
>>>> @@ -111,6 +111,7 @@ lib_sources = [
>>>>    	'igt_msm.c',
>>>>    	'igt_dsc.c',
>>>>    	'xe/xe_gt.c',
>>>> +	'xe/xe_eudebug.c',
>>>>    	'xe/xe_ioctl.c',
>>>>    	'xe/xe_mmio.c',
>>>>    	'xe/xe_query.c',
>>>
>>> As eudebug is quite big feature I think it should be separated and
>>> hidden behind a feature flag (check meson_options.txt), lets say
>>> 'xe_eudebug' which would be disabled by default. This way you can
>>> develop it upstream even if kernel side is not officially merged.
>>> I'm pragramatic and I see no reason to block not accepted feature
>>> especially this would imo speed up developement. A final step when
>>> kernel change would be accepted and merged would be to sync with
>>> uapi and remove local definitions.
>>>
>>> I look forward maintainers comments is my attitude acceptable.
>>
>> I agree that it is a good idea. The only problem that arises is for
>> 'xe_exec_sip'. We add a dependency on eudebug to this test - any ideas how
>> to approach this correctly? The only thing that comes to my mind is
>> conditional compilation with 'ifdef' statements but it doesn't appear to be
>> pretty.
> 
> What about adding skips in added tests if kernel do not support eudebug?

If the kernel doesn't support eudebug it skips already (see 
'xe_eudebug_enable' in the test fixtures).

Thanks,
Christoph
> 
> This way you can have it without conditional compilation with
> ifdef/meson and also have it compile-time tested (if CI support test-with
> for Xe kernels).
> 
> Regards,
> Kamil
> 
>>
>> Thanks,
>> Christoph
>>>
>>> --
>>> Zbigniew
>>>
>>>
>>>> diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
>>>> new file mode 100644
>>>> index 000000000..4eac87476
>>>> --- /dev/null
>>>> +++ b/lib/xe/xe_eudebug.c
>>>> @@ -0,0 +1,2192 @@
>>>> +// SPDX-License-Identifier: MIT
>>>> +/*
>>>> + * Copyright © 2023 Intel Corporation
>>>> + */
>>>> +
>>>> +#include <fcntl.h>
>>>> +#include <poll.h>
>>>> +#include <signal.h>
>>>> +#include <sys/select.h>
>>>> +#include <sys/stat.h>
>>>> +#include <sys/types.h>
>>>> +#include <sys/wait.h>
>>>> +
>>>> +#include "igt.h"
>>>> +#include "igt_sysfs.h"
>>>> +#include "intel_pat.h"
>>>> +#include "xe_eudebug.h"
>>>> +#include "xe_ioctl.h"
>>>> +
>>>> +struct event_trigger {
>>>> +	xe_eudebug_trigger_fn fn;
>>>> +	int type;
>>>> +	struct igt_list_head link;
>>>> +};
>>>> +
>>>> +struct seqno_list_entry {
>>>> +	struct igt_list_head link;
>>>> +	uint64_t seqno;
>>>> +};
>>>> +
>>>> +struct match_dto {
>>>> +	struct drm_xe_eudebug_event *target;
>>>> +	struct igt_list_head *seqno_list;
>>>> +	uint64_t client_handle;
>>>> +	uint32_t filter;
>>>> +
>>>> +	/* store latest 'EVENT_VM_BIND' seqno */
>>>> +	uint64_t *bind_seqno;
>>>> +	/* latest vm_bind_op seqno matching bind_seqno */
>>>> +	uint64_t *bind_op_seqno;
>>>> +};
>>>> +
>>>> +#define CLIENT_PID  1
>>>> +#define CLIENT_RUN  2
>>>> +#define CLIENT_FINI 3
>>>> +#define CLIENT_STOP 4
>>>> +#define CLIENT_STAGE 5
>>>> +#define DEBUGGER_STAGE 6
>>>> +
>>>> +#define DEBUGGER_WORKER_INACTIVE  0
>>>> +#define DEBUGGER_WORKER_ACTIVE  1
>>>> +#define DEBUGGER_WORKER_QUITTING 2
>>>> +
>>>> +static const char *type_to_str(unsigned int type)
>>>> +{
>>>> +	switch (type) {
>>>> +	case DRM_XE_EUDEBUG_EVENT_NONE:
>>>> +		return "none";
>>>> +	case DRM_XE_EUDEBUG_EVENT_READ:
>>>> +		return "read";
>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN:
>>>> +		return "client";
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM:
>>>> +		return "vm";
>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
>>>> +		return "exec_queue";
>>>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
>>>> +		return "attention";
>>>> +	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_UFENCE:
>>>> +		return "vm_bind_ufence";
>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA:
>>>> +		return "metadata";
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
>>>> +		return "vm_bind_op_metadata";
>>>> +	}
>>>> +
>>>> +	return "UNKNOWN";
>>>> +}
>>>> +
>>>> +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
>>>> +{
>>>> +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
>>>> +
>>>> +	return buf;
>>>> +}
>>>> +
>>>> +static const char *flags_to_str(unsigned int flags)
>>>> +{
>>>> +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>>>> +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
>>>> +			return "create|ack";
>>>> +		else
>>>> +			return "create";
>>>> +	}
>>>> +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
>>>> +		return "destroy";
>>>> +
>>>> +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
>>>> +		return "state-change";
>>>> +
>>>> +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
>>>> +
>>>> +	return "flags unknown";
>>>> +}
>>>> +
>>>> +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
>>>> +{
>>>> +	switch (e->type) {
>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>>>> +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
>>>> +
>>>> +		sprintf(b, "handle=%llu", ec->client_handle);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>>>> +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
>>>> +
>>>> +		sprintf(b, "client_handle=%llu, handle=%llu",
>>>> +			evm->client_handle, evm->vm_handle);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>>>> +
>>>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
>>>> +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
>>>> +			ee->client_handle, ee->vm_handle,
>>>> +			ee->exec_queue_handle, ee->engine_class, ee->width);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
>>>> +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
>>>> +
>>>> +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
>>>> +			   "lrc_handle=%llu, bitmask_size=%d",
>>>> +			ea->client_handle, ea->exec_queue_handle,
>>>> +			ea->lrc_handle, ea->bitmask_size);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>>>> +
>>>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
>>>> +			evmb->client_handle, 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 = (void *)e;
>>>> +
>>>> +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
>>>> +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
>>>> +
>>>> +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>>>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>>>> +
>>>> +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
>>>> +			em->client_handle, em->metadata_handle, em->type, em->len);
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
>>>> +
>>>> +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
>>>> +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
>>>> +		break;
>>>> +	}
>>>> +	default:
>>>> +		strcpy(b, "<...>");
>>>> +	}
>>>> +
>>>> +	return b;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_to_str:
>>>> + * @e: pointer to event
>>>> + * @buf: target to write string representation of @e
>>>> + * @len: size of target buffer @buf
>>>> + *
>>>> + * Creates string representation for given event.
>>>> + *
>>>> + * Returns: the written input buffer pointed by @buf.
>>>> + */
>>>> +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
>>>> +{
>>>> +	char a[256];
>>>> +	char b[256];
>>>> +
>>>> +	snprintf(buf, len, "(%llu) %15s:%s: %s",
>>>> +		 e->seqno,
>>>> +		 event_type_to_str(e, a),
>>>> +		 flags_to_str(e->flags),
>>>> +		 event_members_to_str(e, b));
>>>> +
>>>> +	return buf;
>>>> +}
>>>> +
>>>> +static void catch_child_failure(void)
>>>> +{
>>>> +	pid_t pid;
>>>> +	int status;
>>>> +
>>>> +	pid = waitpid(-1, &status, WNOHANG);
>>>> +
>>>> +	if (pid == 0 || pid == -1)
>>>> +		return;
>>>> +
>>>> +	if (!WIFEXITED(status))
>>>> +		return;
>>>> +
>>>> +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
>>>> +}
>>>> +
>>>> +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
>>>> +{
>>>> +	int ret;
>>>> +	int t = 0;
>>>> +	struct pollfd fd = {
>>>> +		.fd = pipe[0],
>>>> +		.events = POLLIN,
>>>> +		.revents = 0
>>>> +	};
>>>> +
>>>> +	/* When child fails we may get stuck forever. Check whether
>>>> +	 * the child process ended with an error.
>>>> +	 */
>>>> +	do {
>>>> +		const int interval_ms = 1000;
>>>> +
>>>> +		ret = poll(&fd, 1, interval_ms);
>>>> +
>>>> +		if (!ret) {
>>>> +			catch_child_failure();
>>>> +			t += interval_ms;
>>>> +		}
>>>> +	} while (!ret && t < timeout_ms);
>>>> +
>>>> +	if (ret > 0)
>>>> +		return read(pipe[0], buf, nbytes);
>>>> +
>>>> +	return 0;
>>>> +}
>>>> +
>>>> +static uint64_t pipe_read(int pipe[2], int timeout_ms)
>>>> +{
>>>> +	uint64_t in;
>>>> +	uint64_t ret;
>>>> +
>>>> +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
>>>> +	igt_assert(ret == sizeof(in));
>>>> +
>>>> +	return in;
>>>> +}
>>>> +
>>>> +static void pipe_signal(int pipe[2], uint64_t token)
>>>> +{
>>>> +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
>>>> +}
>>>> +
>>>> +static void pipe_close(int pipe[2])
>>>> +{
>>>> +	if (pipe[0] != -1)
>>>> +		close(pipe[0]);
>>>> +
>>>> +	if (pipe[1] != -1)
>>>> +		close(pipe[1]);
>>>> +}
>>>> +
>>>> +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
>>>> +{
>>>> +	uint64_t in;
>>>> +
>>>> +	in = pipe_read(p, timeout_ms);
>>>> +
>>>> +	igt_assert_eq(in, token);
>>>> +
>>>> +	return pipe_read(p, timeout_ms);
>>>> +}
>>>> +
>>>> +static uint64_t client_wait_token(struct xe_eudebug_client *c,
>>>> +				 const uint64_t token)
>>>> +{
>>>> +	return __wait_token(c->p_in, token, c->timeout_ms);
>>>> +}
>>>> +
>>>> +static uint64_t wait_from_client(struct xe_eudebug_client *c,
>>>> +				 const uint64_t token)
>>>> +{
>>>> +	return __wait_token(c->p_out, token, c->timeout_ms);
>>>> +}
>>>> +
>>>> +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
>>>> +{
>>>> +	pipe_signal(p, token);
>>>> +	pipe_signal(p, value);
>>>> +}
>>>> +
>>>> +static void client_signal(struct xe_eudebug_client *c,
>>>> +			  const uint64_t token,
>>>> +			  const uint64_t value)
>>>> +{
>>>> +	token_signal(c->p_out, token, value);
>>>> +}
>>>> +
>>>> +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
>>>> +{
>>>> +	struct drm_xe_eudebug_connect param = {
>>>> +		.pid = pid,
>>>> +		.flags = flags,
>>>> +	};
>>>> +	int debugfd;
>>>> +
>>>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>>>> +
>>>> +	if (debugfd < 0)
>>>> +		return -errno;
>>>> +
>>>> +	return debugfd;
>>>> +}
>>>> +
>>>> +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
>>>> +{
>>>> +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
>>>> +		      sizeof(l->head));
>>>> +
>>>> +	igt_assert_eq(write(fd, l->log, l->head), l->head);
>>>> +}
>>>> +
>>>> +static void read_all(int fd, void *buf, size_t nbytes)
>>>> +{
>>>> +	ssize_t remaining_size = nbytes;
>>>> +	ssize_t current_size = 0;
>>>> +	ssize_t read_size = 0;
>>>> +
>>>> +	do {
>>>> +		read_size = read(fd, buf + current_size, remaining_size);
>>>> +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
>>>> +
>>>> +		current_size += read_size;
>>>> +		remaining_size -= read_size;
>>>> +	} while (remaining_size > 0 && read_size > 0);
>>>> +
>>>> +	igt_assert_eq(current_size, nbytes);
>>>> +}
>>>> +
>>>> +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
>>>> +{
>>>> +	read_all(fd, &l->head, sizeof(l->head));
>>>> +	igt_assert_lt(l->head, l->max_size);
>>>> +
>>>> +	read_all(fd, l->log, l->head);
>>>> +}
>>>> +
>>>> +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
>>>> +
>>>> +static struct drm_xe_eudebug_event *
>>>> +event_cmp(struct xe_eudebug_event_log *l,
>>>> +	  struct drm_xe_eudebug_event *current,
>>>> +	  cmp_fn_t match,
>>>> +	  void *data)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *e = current;
>>>> +
>>>> +	xe_eudebug_for_each_event(e, l) {
>>>> +		if (match(e, data))
>>>> +			return e;
>>>> +	}
>>>> +
>>>> +	return NULL;
>>>> +}
>>>> +
>>>> +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *b = data;
>>>> +
>>>> +	if (a->type == b->type &&
>>>> +	    a->flags == b->flags)
>>>> +		return 1;
>>>> +
>>>> +	return 0;
>>>> +}
>>>> +
>>>> +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *b = data;
>>>> +	int ret = 0;
>>>> +
>>>> +	ret = match_type_and_flags(a, data);
>>>> +	if (!ret)
>>>> +		return ret;
>>>> +
>>>> +	ret = 0;
>>>> +
>>>> +	switch (a->type) {
>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>> +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
>>>> +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
>>>> +
>>>> +		if (ae->engine_class == be->engine_class && ae->width == be->width)
>>>> +			ret = 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>> +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
>>>> +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
>>>> +
>>>> +		if (ea->num_binds == eb->num_binds)
>>>> +			ret = 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
>>>> +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
>>>> +
>>>> +		if (ea->addr == eb->addr && ea->range == eb->range &&
>>>> +		    ea->num_extensions == eb->num_extensions)
>>>> +			ret = 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
>>>> +
>>>> +		if (ea->metadata_handle == eb->metadata_handle &&
>>>> +		    ea->metadata_cookie == eb->metadata_cookie)
>>>> +			ret = 1;
>>>> +		break;
>>>> +	}
>>>> +
>>>> +	default:
>>>> +		ret = 1;
>>>> +		break;
>>>> +	}
>>>> +
>>>> +	return ret;
>>>> +}
>>>> +
>>>> +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
>>>> +{
>>>> +	struct match_dto *md = (void *)data;
>>>> +	uint64_t *bind_seqno = md->bind_seqno;
>>>> +	uint64_t *bind_op_seqno = md->bind_op_seqno;
>>>> +	uint64_t h = md->client_handle;
>>>> +
>>>> +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
>>>> +		return 0;
>>>> +
>>>> +	switch (e->type) {
>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>>>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>>>> +
>>>> +		if (client->client_handle == h)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>>>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>>>> +
>>>> +		if (vm->client_handle == h)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>> +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
>>>> +
>>>> +		if (ee->client_handle == h)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
>>>> +
>>>> +		if (evmb->client_handle == h) {
>>>> +			*bind_seqno = evmb->base.seqno;
>>>> +			return 1;
>>>> +		}
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
>>>> +
>>>> +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
>>>> +			*bind_op_seqno = eo->base.seqno;
>>>> +			return 1;
>>>> +		}
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
>>>> +
>>>> +		if (ef->vm_bind_ref_seqno == *bind_seqno)
>>>> +			return 1;
>>>> +
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>>>> +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
>>>> +
>>>> +		if (em->client_handle == h)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
>>>> +
>>>> +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	default:
>>>> +		break;
>>>> +	}
>>>> +
>>>> +	return 0;
>>>> +}
>>>> +
>>>> +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
>>>> +{
>>>> +
>>>> +	struct drm_xe_eudebug_event *d = (void *)data;
>>>> +	int ret;
>>>> +
>>>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>>>> +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
>>>> +	ret = match_type_and_flags(e, data);
>>>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>>>> +
>>>> +	if (!ret)
>>>> +		return 0;
>>>> +
>>>> +	switch (e->type) {
>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>>>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>>>> +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
>>>> +
>>>> +		if (client->client_handle == filter->client_handle)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>>>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>>>> +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
>>>> +
>>>> +		if (vm->vm_handle == filter->vm_handle)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>>>> +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
>>>> +
>>>> +		if (ee->exec_queue_handle == filter->exec_queue_handle)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>>>> +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
>>>> +
>>>> +		if (evmb->vm_handle == filter->vm_handle &&
>>>> +		    evmb->num_binds == filter->num_binds)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
>>>> +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
>>>> +
>>>> +		if (avmb->addr == filter->addr &&
>>>> +		    avmb->range == filter->range)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>>>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>>>> +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
>>>> +
>>>> +		if (em->metadata_handle == filter->metadata_handle)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
>>>> +
>>>> +		if (avmb->metadata_handle == filter->metadata_handle &&
>>>> +		    avmb->metadata_cookie == filter->metadata_cookie)
>>>> +			return 1;
>>>> +		break;
>>>> +	}
>>>> +
>>>> +	default:
>>>> +		break;
>>>> +	}
>>>> +	return 0;
>>>> +}
>>>> +
>>>> +static int match_full(struct drm_xe_eudebug_event *e, void *data)
>>>> +{
>>>> +	struct seqno_list_entry *sl;
>>>> +
>>>> +	struct match_dto *md = (void *)data;
>>>> +	int ret = 0;
>>>> +
>>>> +	ret = match_client_handle(e, md);
>>>> +	if (!ret)
>>>> +		return 0;
>>>> +
>>>> +	ret = match_fields(e, md->target);
>>>> +	if (!ret)
>>>> +		return 0;
>>>> +
>>>> +	igt_list_for_each_entry(sl, md->seqno_list, link) {
>>>> +		if (sl->seqno == e->seqno)
>>>> +			return 0;
>>>> +	}
>>>> +
>>>> +	return 1;
>>>> +}
>>>> +
>>>> +static struct drm_xe_eudebug_event *
>>>> +event_type_match(struct xe_eudebug_event_log *l,
>>>> +		 struct drm_xe_eudebug_event *target,
>>>> +		 struct drm_xe_eudebug_event *current)
>>>> +{
>>>> +	return event_cmp(l, current, match_type_and_flags, target);
>>>> +}
>>>> +
>>>> +static struct drm_xe_eudebug_event *
>>>> +client_match(struct xe_eudebug_event_log *l,
>>>> +	     uint64_t client_handle,
>>>> +	     struct drm_xe_eudebug_event *current,
>>>> +	     uint32_t filter,
>>>> +	     uint64_t *bind_seqno,
>>>> +	     uint64_t *bind_op_seqno)
>>>> +{
>>>> +	struct match_dto md = {
>>>> +		.client_handle = client_handle,
>>>> +		.filter = filter,
>>>> +		.bind_seqno = bind_seqno,
>>>> +		.bind_op_seqno = bind_op_seqno,
>>>> +	};
>>>> +
>>>> +	return event_cmp(l, current, match_client_handle, &md);
>>>> +}
>>>> +
>>>> +static struct drm_xe_eudebug_event *
>>>> +opposite_event_match(struct xe_eudebug_event_log *l,
>>>> +		    struct drm_xe_eudebug_event *target,
>>>> +		    struct drm_xe_eudebug_event *current)
>>>> +{
>>>> +	return event_cmp(l, current, match_opposite_resource, target);
>>>> +}
>>>> +
>>>> +static struct drm_xe_eudebug_event *
>>>> +event_match(struct xe_eudebug_event_log *l,
>>>> +	    struct drm_xe_eudebug_event *target,
>>>> +	    uint64_t client_handle,
>>>> +	    struct igt_list_head *seqno_list,
>>>> +	    uint64_t *bind_seqno,
>>>> +	    uint64_t *bind_op_seqno)
>>>> +{
>>>> +	struct match_dto md = {
>>>> +		.target = target,
>>>> +		.client_handle = client_handle,
>>>> +		.seqno_list = seqno_list,
>>>> +		.bind_seqno = bind_seqno,
>>>> +		.bind_op_seqno = bind_op_seqno,
>>>> +	};
>>>> +
>>>> +	return event_cmp(l, NULL, match_full, &md);
>>>> +}
>>>> +
>>>> +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
>>>> +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
>>>> +			   uint32_t filter)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
>>>> +	struct drm_xe_eudebug_event_client *de = (void *)_de;
>>>> +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
>>>> +
>>>> +	struct igt_list_head matched_seqno_list;
>>>> +	struct drm_xe_eudebug_event *hc, *hd;
>>>> +	struct seqno_list_entry *entry, *tmp;
>>>> +
>>>> +	igt_assert(ce);
>>>> +	igt_assert(de);
>>>> +
>>>> +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
>>>> +
>>>> +	hc = NULL;
>>>> +	hd = NULL;
>>>> +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
>>>> +
>>>> +	do {
>>>> +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
>>>> +		if (!hc)
>>>> +			break;
>>>> +
>>>> +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
>>>> +
>>>> +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
>>>> +			     c->name,
>>>> +			     hc->seqno,
>>>> +			     hc->type,
>>>> +			     ce->client_handle);
>>>> +
>>>> +		igt_debug("comparing %s %llu vs %s %llu\n",
>>>> +			  c->name, hc->seqno, d->name, hd->seqno);
>>>> +
>>>> +		/*
>>>> +		 * Store the seqno of the event that was matched above,
>>>> +		 * inside 'matched_seqno_list', to avoid it getting matched
>>>> +		 * by subsequent 'event_match' calls.
>>>> +		 */
>>>> +		entry = malloc(sizeof(*entry));
>>>> +		entry->seqno = hd->seqno;
>>>> +		igt_list_add(&entry->link, &matched_seqno_list);
>>>> +	} while (hc);
>>>> +
>>>> +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
>>>> +		free(entry);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_find_seqno:
>>>> + * @l: event log pointer
>>>> + * @seqno: seqno of event to be found
>>>> + *
>>>> + * Finds the event with given seqno in the event log.
>>>> + *
>>>> + * Returns: pointer to the event with given seqno within @l or NULL seqno is
>>>> + * not present.
>>>> + */
>>>> +struct drm_xe_eudebug_event *
>>>> +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
>>>> +
>>>> +	igt_assert_neq(seqno, 0);
>>>> +	/*
>>>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>>>> +	 * as our post processing of events is not optimized.
>>>> +	 */
>>>> +	igt_assert_lt(seqno, 10 * 1000 * 1000);
>>>> +
>>>> +	xe_eudebug_for_each_event(e, l) {
>>>> +		if (e->seqno == seqno) {
>>>> +			if (found) {
>>>> +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
>>>> +				xe_eudebug_event_log_print(l, false);
>>>> +				igt_assert(!found);
>>>> +			}
>>>> +			found = e;
>>>> +		}
>>>> +	}
>>>> +
>>>> +	return found;
>>>> +}
>>>> +
>>>> +static void event_log_sort(struct xe_eudebug_event_log *l)
>>>> +{
>>>> +	struct xe_eudebug_event_log *tmp;
>>>> +	struct drm_xe_eudebug_event *e = NULL;
>>>> +	uint64_t first_seqno = 0;
>>>> +	uint64_t last_seqno = 0;
>>>> +	uint64_t events = 0, added = 0;
>>>> +	uint64_t i;
>>>> +
>>>> +	xe_eudebug_for_each_event(e, l) {
>>>> +		if (e->seqno > last_seqno)
>>>> +			last_seqno = e->seqno;
>>>> +
>>>> +		if (e->seqno < first_seqno)
>>>> +			first_seqno = e->seqno;
>>>> +
>>>> +		events++;
>>>> +	}
>>>> +
>>>> +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
>>>> +
>>>> +	for (i = 1; i <= last_seqno; i++) {
>>>> +		e = xe_eudebug_event_log_find_seqno(l, i);
>>>> +		if (e) {
>>>> +			xe_eudebug_event_log_write(tmp, e);
>>>> +			added++;
>>>> +		}
>>>> +	}
>>>> +
>>>> +	igt_assert_eq(events, added);
>>>> +	igt_assert_eq(tmp->head, l->head);
>>>> +
>>>> +	memcpy(l->log, tmp->log, tmp->head);
>>>> +
>>>> +	xe_eudebug_event_log_destroy(tmp);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_connect:
>>>> + * @fd: Xe file descriptor
>>>> + * @pid: client PID
>>>> + * @flags: connection flags
>>>> + *
>>>> + * Opens the xe eu debugger connection to the process described by @pid
>>>> + *
>>>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>>>> + */
>>>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
>>>> +{
>>>> +	int ret;
>>>> +	uint64_t events = 0; /* events filtering not supported yet! */
>>>> +
>>>> +	ret = __xe_eudebug_connect(fd, pid, flags, events);
>>>> +
>>>> +	return ret;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_create:
>>>> + * @name: event log identifier
>>>> + * @max_size: maximum size of created log
>>>> + *
>>>> + * Function creates an Eu Debugger event log with size equal to @max_size.
>>>> + *
>>>> + * Returns: pointer to just created log
>>>> + */
>>>> +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
>>>> +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
>>>> +{
>>>> +	struct xe_eudebug_event_log *l;
>>>> +
>>>> +	l = calloc(1, sizeof(*l));
>>>> +	igt_assert(l);
>>>> +	l->log = calloc(1, max_size);
>>>> +	igt_assert(l->log);
>>>> +	l->max_size = max_size;
>>>> +	strncpy(l->name, name, sizeof(l->name) - 1);
>>>> +	pthread_mutex_init(&l->lock, NULL);
>>>> +
>>>> +	return l;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_destroy:
>>>> + * @l: event log pointer
>>>> + *
>>>> + * Frees given event log @l.
>>>> + */
>>>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
>>>> +{
>>>> +	pthread_mutex_destroy(&l->lock);
>>>> +	free(l->log);
>>>> +	free(l);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_write:
>>>> + * @l: event log pointer
>>>> + * @e: event to be written to event log
>>>> + *
>>>> + * Writes event @e to the event log, thread-safe.
>>>> + */
>>>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
>>>> +{
>>>> +	igt_assert(e->seqno);
>>>> +	/*
>>>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>>>> +	 * as our post processing of events is not optimized.
>>>> +	 */
>>>> +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
>>>> +
>>>> +	pthread_mutex_lock(&l->lock);
>>>> +	igt_assert_lt(l->head + e->len, l->max_size);
>>>> +	memcpy(l->log + l->head, e, e->len);
>>>> +	l->head += e->len;
>>>> +
>>>> +#ifdef DEBUG_LOG
>>>> +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
>>>> +		 l->name, e->len, l->max_size - l->head);
>>>> +#endif
>>>> +	pthread_mutex_unlock(&l->lock);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_print:
>>>> + * @l: event log pointer
>>>> + * @debug: when true function uses igt_debug instead of igt_info.
>>>> + *
>>>> + * Prints given event log.
>>>> + */
>>>> +void
>>>> +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *e = NULL;
>>>> +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
>>>> +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
>>>> +
>>>> +	igt_log(IGT_LOG_DOMAIN, level,
>>>> +		"event log '%s' (%u bytes):\n", l->name, l->head);
>>>> +
>>>> +	xe_eudebug_for_each_event(e, l) {
>>>> +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
>>>> +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
>>>> +	}
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_compare:
>>>> + * @a: event log pointer
>>>> + * @b: event log pointer
>>>> + * @filter: mask that represents events to be skipped during comparison, useful
>>>> + * for events like 'VM_BIND' since they can be asymmetric. Note that
>>>> + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
>>>> + *
>>>> + * Compares and asserts event logs @a, @b if the event
>>>> + * sequence matches.
>>>> + */
>>>> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
>>>> +				  uint32_t filter)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *ae = NULL;
>>>> +	struct drm_xe_eudebug_event *be = NULL;
>>>> +
>>>> +	xe_eudebug_for_each_event(ae, a) {
>>>> +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
>>>> +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>>>> +			be = event_type_match(b, ae, be);
>>>> +
>>>> +			compare_client(a, ae, b, be, filter);
>>>> +			compare_client(b, be, a, ae, filter);
>>>> +		}
>>>> +	}
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_event_log_match_opposite:
>>>> + * @l: event log pointer
>>>> + * @filter: mask that represents events to be skipped during comparison, useful
>>>> + * for events like 'VM_BIND' since they can be asymmetric
>>>> + *
>>>> + * Matches and asserts content of all opposite events (create vs destroy).
>>>> + */
>>>> +void
>>>> +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
>>>> +{
>>>> +	struct drm_xe_eudebug_event *ce = NULL;
>>>> +	struct drm_xe_eudebug_event *de = NULL;
>>>> +
>>>> +	xe_eudebug_for_each_event(ce, l) {
>>>> +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>>>> +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
>>>> +			int opposite_matching;
>>>> +
>>>> +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
>>>> +				continue;
>>>> +
>>>> +			/* No opposite matching for binds */
>>>> +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
>>>> +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
>>>> +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
>>>> +				continue;
>>>> +
>>>> +			de = opposite_event_match(l, ce, ce);
>>>> +
>>>> +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
>>>> +
>>>> +			igt_assert_eq(ce->len, de->len);
>>>> +			opposite_matching = memcmp((uint8_t *)de + offset,
>>>> +						   (uint8_t *)ce + offset,
>>>> +						   de->len - offset) == 0;
>>>> +
>>>> +			igt_assert_f(opposite_matching,
>>>> +				     "%s: create|destroy event not "
>>>> +				     "maching (%llu) vs (%llu)\n",
>>>> +				     l->name, de->seqno, ce->seqno);
>>>> +		}
>>>> +	}
>>>> +}
>>>> +
>>>> +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
>>>> +				  struct drm_xe_eudebug_event *e)
>>>> +{
>>>> +	struct event_trigger *t;
>>>> +
>>>> +	igt_list_for_each_entry(t, &d->triggers, link) {
>>>> +		if (e->type == t->type)
>>>> +			t->fn(d, e);
>>>> +	}
>>>> +}
>>>> +
>>>> +#define MAX_EVENT_SIZE (32 * 1024)
>>>> +static int
>>>> +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
>>>> +{
>>>> +	int ret;
>>>> +
>>>> +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
>>>> +	event->flags = 0;
>>>> +	event->len = MAX_EVENT_SIZE;
>>>> +
>>>> +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
>>>> +	if (ret < 0)
>>>> +		return -errno;
>>>> +
>>>> +	return ret;
>>>> +}
>>>> +
>>>> +static void *debugger_worker_loop(void *data)
>>>> +{
>>>> +	uint8_t buf[MAX_EVENT_SIZE];
>>>> +	struct drm_xe_eudebug_event *e = (void *)buf;
>>>> +	struct xe_eudebug_debugger *d = data;
>>>> +	struct pollfd p = {
>>>> +		.events = POLLIN,
>>>> +		.revents = 0,
>>>> +	};
>>>> +	int timeout_ms = 100, ret;
>>>> +
>>>> +	igt_assert(d->master_fd >= 0);
>>>> +
>>>> +	do {
>>>> +		p.fd = d->fd;
>>>> +		ret = poll(&p, 1, timeout_ms);
>>>> +
>>>> +		if (ret == -1) {
>>>> +			igt_info("poll failed with errno %d\n", errno);
>>>> +			break;
>>>> +		}
>>>> +
>>>> +		if (ret == 1 && (p.revents & POLLIN)) {
>>>> +			int err = xe_eudebug_read_event(d->fd, e);
>>>> +
>>>> +			if (!err) {
>>>> +				++d->event_count;
>>>> +
>>>> +				xe_eudebug_event_log_write(d->log, e);
>>>> +				debugger_run_triggers(d, e);
>>>> +			} else {
>>>> +				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;
>>>> +	return NULL;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_available:
>>>> + * @fd: Xe file descriptor
>>>> + *
>>>> + * Returns: true it debugger connection is available, false otherwise.
>>>> + */
>>>> +bool xe_eudebug_debugger_available(int fd)
>>>> +{
>>>> +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
>>>> +	int debugfd;
>>>> +
>>>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>>>> +	if (debugfd >= 0)
>>>> +		close(debugfd);
>>>> +
>>>> +	return debugfd >= 0;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_create:
>>>> + * @master_fd: xe client used to open the debugger connection
>>>> + * @flags: flags stored in a debugger structure, can be used at will
>>>> + * of the caller, i.e. to be used inside triggers.
>>>> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
>>>> + * can be shared between client and debugger. Can be NULL.
>>>> + *
>>>> + * Returns: newly created xe_eudebug_debugger structure with its
>>>> + * event log initialized. Note that to open the connection
>>>> + * you need call @xe_eudebug_debugger_attach.
>>>> + */
>>>> +struct xe_eudebug_debugger *
>>>> +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
>>>> +{
>>>> +	struct xe_eudebug_debugger *d;
>>>> +
>>>> +	d = calloc(1, sizeof(*d));
>>>> +	d->flags = flags;
>>>> +	igt_assert(d);
>>>> +	IGT_INIT_LIST_HEAD(&d->triggers);
>>>> +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
>>>> +	d->fd = -1;
>>>> +	d->master_fd = master_fd;
>>>> +	d->ptr = data;
>>>> +
>>>> +	return d;
>>>> +}
>>>> +
>>>> +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
>>>> +{
>>>> +	struct event_trigger *t, *tmp;
>>>> +
>>>> +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
>>>> +		free(t);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_destroy:
>>>> + * @d: pointer to the debugger
>>>> + *
>>>> + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
>>>> + * connection was still opened it terminates it.
>>>> + */
>>>> +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
>>>> +{
>>>> +	if (d->worker_state)
>>>> +		xe_eudebug_debugger_stop_worker(d, 1);
>>>> +
>>>> +	if (d->target_pid)
>>>> +		xe_eudebug_debugger_dettach(d);
>>>> +
>>>> +	xe_eudebug_event_log_destroy(d->log);
>>>> +	debugger_destroy_triggers(d);
>>>> +	free(d);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_attach:
>>>> + * @d: pointer to the debugger
>>>> + * @c: pointer to the client
>>>> + *
>>>> + * Opens the xe eu debugger connection to the process described by @c (c->pid)
>>>> + *
>>>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>>>> + */
>>>> +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
>>>> +			       struct xe_eudebug_client *c)
>>>> +{
>>>> +	int ret;
>>>> +
>>>> +	igt_assert_eq(d->fd, -1);
>>>> +	igt_assert_neq(c->pid, 0);
>>>> +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
>>>> +
>>>> +	if (ret < 0)
>>>> +		return ret;
>>>> +
>>>> +	d->fd = ret;
>>>> +	d->target_pid = c->pid;
>>>> +	d->p_client[0] = c->p_in[0];
>>>> +	d->p_client[1] = c->p_in[1];
>>>> +
>>>> +	igt_debug("debugger connected to %lu\n", d->target_pid);
>>>> +
>>>> +	return 0;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_dettach:
>>>> + * @d: pointer to the debugger
>>>> + *
>>>> + * Closes previously opened xe eu debugger connection. Asserts if
>>>> + * the debugger has active session.
>>>> + */
>>>> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
>>>> +{
>>>> +	igt_assert(d->target_pid);
>>>> +	close(d->fd);
>>>> +	d->target_pid = 0;
>>>> +	d->fd = -1;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_add_trigger:
>>>> + * @d: pointer to the debugger
>>>> + * @type: the type of the event which activates the trigger
>>>> + * @fn: function to be called when event of @type was read by the debugger.
>>>> + *
>>>> + * Adds function @fn to the list of triggers activated when event of @type
>>>> + * has been read by worker.
>>>> + * Note: Triggers are activated by the worker.
>>>> + */
>>>> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
>>>> +				     int type, xe_eudebug_trigger_fn fn)
>>>> +{
>>>> +	struct event_trigger *t;
>>>> +
>>>> +	t = calloc(1, sizeof(*t));
>>>> +	IGT_INIT_LIST_HEAD(&t->link);
>>>> +	t->type = type;
>>>> +	t->fn = fn;
>>>> +
>>>> +	igt_list_add_tail(&t->link, &d->triggers);
>>>> +	igt_debug("added trigger %p\n", t);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_start_worker:
>>>> + * @d: pointer to the debugger
>>>> + *
>>>> + * Starts the debugger worker. Worker is resposible for reading all
>>>> + * incoming events from the debugger, put then into debugger log and
>>>> + * execute appropriate event triggers. Note that using the debuggers
>>>> + * event log while worker is running is not safe.
>>>> + */
>>>> +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
>>>> +{
>>>> +	int ret;
>>>> +
>>>> +	d->worker_state = true;
>>>> +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
>>>> +
>>>> +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_stop_worker:
>>>> + * @d: pointer to the debugger
>>>> + *
>>>> + * Stops the debugger worker. Event log is sorted by seqno after closure.
>>>> + */
>>>> +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
>>>> +				     int timeout_s)
>>>> +{
>>>> +	struct timespec t = {};
>>>> +	int ret;
>>>> +
>>>> +	igt_assert(d->worker_state);
>>>> +
>>>> +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
>>>> +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
>>>> +	t.tv_sec += timeout_s;
>>>> +
>>>> +	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_assert_f(ret == 0 || ret != ESRCH,
>>>> +		     "pthread join failed with error %d!\n", ret);
>>>> +
>>>> +	event_log_sort(d->log);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_signal_stage:
>>>> + * @d: pointer to the debugger
>>>> + * @stage: stage to signal
>>>> + *
>>>> + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
>>>> + * releasing it to proceed.
>>>> + */
>>>> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
>>>> +{
>>>> +	token_signal(d->p_client, CLIENT_STAGE, stage);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_debugger_wait_stage:
>>>> + * @s: pointer to xe_eudebug_debugger structure
>>>> + * @stage: stage to wait on
>>>> + *
>>>> + * Pauses debugger until the client has signalled the corresponding stage with
>>>> + * xe_eudebug_client_signal_stage. This is only for situations where the actual
>>>> + * event flow is not enough to coordinate between client/debugger and extra sync
>>>> + * mechanism is needed.
>>>> + */
>>>> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
>>>> +{
>>>> +	u64 stage_in;
>>>> +
>>>> +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
>>>> +
>>>> +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
>>>> +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
>>>> +		  stage_in, stage);
>>>> +
>>>> +	igt_assert_eq(stage_in, stage);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_create:
>>>> + * @master_fd: xe client used to open the debugger connection
>>>> + * @work: function that opens xe device and executes arbitrary workload
>>>> + * @flags: flags stored in a client structure, can be used at will
>>>> + * of the caller, i.e. to provide the @work function an additional switch.
>>>> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
>>>> + * can be shared between client and debugger. Accesible via client->ptr.
>>>> + * Can be NULL.
>>>> + *
>>>> + * Forks and creates the debugger process. @work won't be called until
>>>> + * xe_eudebug_client_start is called.
>>>> + *
>>>> + * Returns: newly created xe_eudebug_debugger structure with its
>>>> + * event log initialized.
>>>> + */
>>>> +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
>>>> +						   uint64_t flags, void *data)
>>>> +{
>>>> +	struct xe_eudebug_client *c;
>>>> +
>>>> +	c = calloc(1, sizeof(*c));
>>>> +	c->flags = flags;
>>>> +	igt_assert(c);
>>>> +	igt_assert(!pipe(c->p_in));
>>>> +	igt_assert(!pipe(c->p_out));
>>>> +	c->seqno = 1;
>>>> +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
>>>> +	c->done = 0;
>>>> +	c->ptr = data;
>>>> +	c->master_fd = master_fd;
>>>> +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
>>>> +
>>>> +	igt_fork(child, 1) {
>>>> +		int mypid;
>>>> +
>>>> +		igt_assert_eq(c->pid, 0);
>>>> +
>>>> +		close(c->p_out[0]);
>>>> +		c->p_out[0] = -1;
>>>> +		close(c->p_in[1]);
>>>> +		c->p_in[1] = -1;
>>>> +
>>>> +		mypid = getpid();
>>>> +		client_signal(c, CLIENT_PID, mypid);
>>>> +
>>>> +		c->pid = client_wait_token(c, CLIENT_RUN);
>>>> +		igt_assert_eq(c->pid, mypid);
>>>> +		if (work)
>>>> +			work(c);
>>>> +
>>>> +		client_signal(c, CLIENT_FINI, c->seqno);
>>>> +
>>>> +		event_log_write_to_fd(c->log, c->p_out[1]);
>>>> +
>>>> +		c->pid = client_wait_token(c, CLIENT_STOP);
>>>> +		igt_assert_eq(c->pid, mypid);
>>>> +	}
>>>> +
>>>> +	close(c->p_out[1]);
>>>> +	c->p_out[1] = -1;
>>>> +	close(c->p_in[0]);
>>>> +	c->p_in[0] = -1;
>>>> +
>>>> +	c->pid = wait_from_client(c, CLIENT_PID);
>>>> +
>>>> +	igt_info("client running with pid %d\n", c->pid);
>>>> +
>>>> +	return c;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_stop:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + *
>>>> + * Waits for the end of client's work and exits the proccess.
>>>> + */
>>>> +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
>>>> +{
>>>> +	if (c->pid) {
>>>> +		int waitstatus;
>>>> +
>>>> +		xe_eudebug_client_wait_done(c);
>>>> +
>>>> +		token_signal(c->p_in, CLIENT_STOP, c->pid);
>>>> +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
>>>> +			      c->pid);
>>>> +		c->pid = 0;
>>>> +	}
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_destroy:
>>>> + * @c: pointer to xe_eudebug_client structure to be freed
>>>> + *
>>>> + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
>>>> + * client proccess has not terminated yet.
>>>> + */
>>>> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
>>>> +{
>>>> +	xe_eudebug_client_stop(c);
>>>> +	pipe_close(c->p_in);
>>>> +	pipe_close(c->p_out);
>>>> +	xe_eudebug_event_log_destroy(c->log);
>>>> +	free(c);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_get_seqno:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + *
>>>> + * Increments and returns current seqno value of the given client @c
>>>> + *
>>>> + * Returns: incremented seqno
>>>> + */
>>>> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
>>>> +{
>>>> +	return c->seqno++;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_start:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + *
>>>> + * Starts execution of client's work function within the client's proccess.
>>>> + */
>>>> +void xe_eudebug_client_start(struct xe_eudebug_client *c)
>>>> +{
>>>> +	token_signal(c->p_in, CLIENT_RUN, c->pid);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_wait_done:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + *
>>>> + * Waits for the client work end updates the event log.
>>>> + * Doesn't terminate the client's proccess yet.
>>>> + */
>>>> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
>>>> +{
>>>> +	if (!c->done) {
>>>> +		c->done = 1;
>>>> +		c->seqno = wait_from_client(c, CLIENT_FINI);
>>>> +		event_log_read_from_fd(c->log, c->p_out[0]);
>>>> +	}
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_signal_stage:
>>>> + * @c: pointer to the client
>>>> + * @stage: stage to signal
>>>> + *
>>>> + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
>>>> + * releasing it to proceed.
>>>> + */
>>>> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
>>>> +{
>>>> +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_wait_stage:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @stage: stage to wait on
>>>> + *
>>>> + * Pauses client until the debugger has signalled the corresponding stage with
>>>> + * xe_eudebug_debugger_signal_stage. This is only for situations where the
>>>> + * actual event flow is not enough to coordinate between client/debugger and extra
>>>> + * sync mechanism is needed.
>>>> + *
>>>> + */
>>>> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
>>>> +{
>>>> +	u64 stage_in;
>>>> +
>>>> +	if (c->done) {
>>>> +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
>>>> +		return;
>>>> +	}
>>>> +
>>>> +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
>>>> +
>>>> +	stage_in = client_wait_token(c, CLIENT_STAGE);
>>>> +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
>>>> +
>>>> +	igt_assert_eq(stage_in, stage);
>>>> +}
>>>> +
>>>> +
>>>> +/**
>>>> + * xe_eudebug_session_create:
>>>> + * @fd: XE file descriptor
>>>> + * @work: function passed to the xe_eudebug_client_create
>>>> + * @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.
>>>> + *
>>>> + * Creates session together with client and debugger structures.
>>>> + */
>>>> +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
>>>> +						     xe_eudebug_client_work_fn work,
>>>> +						     unsigned int flags,
>>>> +						     void *test_private)
>>>> +{
>>>> +	struct xe_eudebug_session *s;
>>>> +
>>>> +	s = calloc(1, sizeof(*s));
>>>> +	igt_assert(s);
>>>> +
>>>> +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
>>>> +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
>>>> +	s->flags = flags;
>>>> +
>>>> +	return s;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_session_run:
>>>> + * @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.
>>>> + */
>>>> +void xe_eudebug_session_run(struct xe_eudebug_session *s)
>>>> +{
>>>> +	struct xe_eudebug_debugger *debugger = s->d;
>>>> +	struct xe_eudebug_client *client = s->c;
>>>> +
>>>> +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
>>>> +
>>>> +	xe_eudebug_debugger_start_worker(debugger);
>>>> +
>>>> +	xe_eudebug_client_start(client);
>>>> +	xe_eudebug_client_wait_done(client);
>>>> +
>>>> +	xe_eudebug_debugger_stop_worker(debugger, 1);
>>>> +
>>>> +	xe_eudebug_event_log_print(debugger->log, true);
>>>> +	xe_eudebug_event_log_print(client->log, true);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_session_check:
>>>> + * @s: pointer to xe_eudebug_session structure
>>>> + * @match_opposite: indicates whether check should match all
>>>> + * create and destroy events.
>>>> + * @filter: mask that represents events to be skipped during comparison, useful
>>>> + * for events like 'VM_BIND' since they can be asymmetric
>>>> + *
>>>> + * Validate debugger's log against the log created by the client.
>>>> + */
>>>> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
>>>> +{
>>>> +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
>>>> +
>>>> +	if (match_opposite)
>>>> +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_session_destroy:
>>>> + * @s: pointer to xe_eudebug_session structure
>>>> + *
>>>> + * Destroy session together with its debugger and client.
>>>> + */
>>>> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
>>>> +{
>>>> +	xe_eudebug_debugger_destroy(s->d);
>>>> +	xe_eudebug_client_destroy(s->c);
>>>> +
>>>> +	free(s);
>>>> +}
>>>> +
>>>> +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
>>>> +
>>>> +static void base_event(struct xe_eudebug_client *c,
>>>> +		       struct drm_xe_eudebug_event *e,
>>>> +		       uint32_t type,
>>>> +		       uint32_t flags,
>>>> +		       uint64_t size)
>>>> +{
>>>> +	e->type = type;
>>>> +	e->flags = flags;
>>>> +	e->seqno = xe_eudebug_client_get_seqno(c);
>>>> +	e->len = size;
>>>> +}
>>>> +
>>>> +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_client ec;
>>>> +
>>>> +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
>>>> +
>>>> +	ec.client_handle = client_fd;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&ec);
>>>> +}
>>>> +
>>>> +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_vm evm;
>>>> +
>>>> +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
>>>> +
>>>> +	evm.client_handle = client_fd;
>>>> +	evm.vm_handle = vm_id;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&evm);
>>>> +}
>>>> +
>>>> +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
>>>> +			     int client_fd, uint32_t vm_id,
>>>> +			     uint32_t exec_queue_handle, uint16_t class,
>>>> +			     uint16_t width)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_exec_queue ee;
>>>> +
>>>> +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>>>> +		   flags, sizeof(ee));
>>>> +
>>>> +	ee.client_handle = client_fd;
>>>> +	ee.vm_handle = vm_id;
>>>> +	ee.exec_queue_handle = exec_queue_handle;
>>>> +	ee.engine_class = class;
>>>> +	ee.width = width;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&ee);
>>>> +}
>>>> +
>>>> +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
>>>> +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_metadata em;
>>>> +
>>>> +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
>>>> +		   flags, sizeof(em));
>>>> +
>>>> +	em.client_handle = client_fd;
>>>> +	em.metadata_handle = id;
>>>> +	em.type = type;
>>>> +	em.len = len;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&em);
>>>> +}
>>>> +
>>>> +static int enable_getset(int fd, bool *old, bool *new)
>>>> +{
>>>> +	static const char * const fname = "enable_eudebug";
>>>> +	int ret = 0;
>>>> +
>>>> +	int sysfs, device_fd;
>>>> +	bool val_before;
>>>> +	struct stat st;
>>>> +
>>>> +	igt_assert(new || old);
>>>> +
>>>> +	igt_assert_eq(fstat(fd, &st), 0);
>>>> +	sysfs = igt_sysfs_open(fd);
>>>> +	if (sysfs < 0)
>>>> +		return -1;
>>>> +
>>>> +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
>>>> +	close(sysfs);
>>>> +	if (device_fd < 0)
>>>> +		return -1;
>>>> +
>>>> +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
>>>> +		ret = -1;
>>>> +		goto out;
>>>> +	}
>>>> +
>>>> +	igt_debug("enable_eudebug before: %d\n", val_before);
>>>> +
>>>> +	if (old)
>>>> +		*old = val_before;
>>>> +
>>>> +	ret = 0;
>>>> +	if (new) {
>>>> +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
>>>> +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
>>>> +		else
>>>> +			ret = -1;
>>>> +	}
>>>> +
>>>> +out:
>>>> +	close(device_fd);
>>>> +	return ret;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_enable
>>>> + * @fd: xe client
>>>> + * @enable: state toggle - true to enable, false to disable
>>>> + *
>>>> + * Enables/disables eudebug capability by writing to
>>>> + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
>>>> + *
>>>> + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
>>>> + * false when eudebugging was disabled.
>>>> + */
>>>> +bool xe_eudebug_enable(int fd, bool enable)
>>>> +{
>>>> +	bool old = false;
>>>> +	int ret = enable_getset(fd, &old, &enable);
>>>> +
>>>> +	if (ret) {
>>>> +		igt_skip_on(enable);
>>>> +		old = false;
>>>> +	}
>>>> +
>>>> +	return old;
>>>> +}
>>>> +
>>>> +/* Eu debugger wrappers around resource creating xe ioctls. */
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_open_driver:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + *
>>>> + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
>>>> + * event in client's event log.
>>>> + *
>>>> + * Returns: valid DRM file descriptor
>>>> + */
>>>> +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
>>>> +{
>>>> +	int fd;
>>>> +
>>>> +	fd = drm_reopen_driver(c->master_fd);
>>>> +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
>>>> +
>>>> +	return fd;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_close_driver:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + *
>>>> + * Calls close driver and logs the corresponding event in
>>>> + * client's event log.
>>>> + */
>>>> +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
>>>> +{
>>>> +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
>>>> +	close(fd);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_create:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @flags: vm bind flags
>>>> + * @ext: pointer to the first user extension
>>>> + *
>>>> + * Calls xe_vm_create() and logs corresponding events
>>>> + * (including vm set metadata events) in client's event log.
>>>> + *
>>>> + * Returns: valid vm handle
>>>> + */
>>>> +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
>>>> +				     uint32_t flags, uint64_t ext)
>>>> +{
>>>> +	uint32_t vm;
>>>> +
>>>> +	vm = xe_vm_create(fd, flags, ext);
>>>> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
>>>> +
>>>> +	return vm;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_destroy:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * fd: xe client
>>>> + * vm: vm handle
>>>> + *
>>>> + * Calls xe_vm_destroy() and logs the corresponding event in
>>>> + * client's event log.
>>>> + */
>>>> +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
>>>> +{
>>>> +	xe_vm_destroy(fd, vm);
>>>> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_exec_queue_create:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @create: exec_queue create drm struct
>>>> + *
>>>> + * Calls xe exec queue create ioctl and logs the corresponding event in
>>>> + * client's event log.
>>>> + *
>>>> + * Returns: valid exec queue handle
>>>> + */
>>>> +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
>>>> +					     struct drm_xe_exec_queue_create *create)
>>>> +{
>>>> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
>>>> +
>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
>>>> +
>>>> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
>>>> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
>>>> +				 create->exec_queue_id, class, create->width);
>>>> +
>>>> +	return create->exec_queue_id;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_exec_queue_destroy:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @create: exec_queue create drm struct which was used for creation
>>>> + *
>>>> + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
>>>> + * client's event log.
>>>> + */
>>>> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
>>>> +					  struct drm_xe_exec_queue_create *create)
>>>> +{
>>>> +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
>>>> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
>>>> +
>>>> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
>>>> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
>>>> +				 create->exec_queue_id, class, create->width);
>>>> +
>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_bind_event:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @event_flags: base event flags
>>>> + * @fd: xe client
>>>> + * @vm: vm handle
>>>> + * @bind_flags: bind flags of vm_bind_event
>>>> + * @num_binds: 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, int fd,
>>>> +				     uint32_t vm, uint32_t bind_flags,
>>>> +				     uint32_t num_binds, u64 *ref_seqno)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_vm_bind evmb;
>>>> +
>>>> +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
>>>> +		   event_flags, sizeof(evmb));
>>>> +	evmb.client_handle = fd;
>>>> +	evmb.vm_handle = vm;
>>>> +	evmb.flags = bind_flags;
>>>> +	evmb.num_binds = num_binds;
>>>> +
>>>> +	*ref_seqno = evmb.base.seqno;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_bind_op_event:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @event_flags: base event flags
>>>> + * @bind_ref_seqno: base vm bind reference seqno
>>>> + * @op_ref_seqno: output, the vm_bind_op event seqno
>>>> + * @addr: ppgtt address
>>>> + * @size: size of the binding
>>>> + * @num_extensions: number of vm bind op extensions
>>>> + *
>>>> + * Logs vm bind op event in client's event log.
>>>> + */
>>>> +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
>>>> +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
>>>> +					uint64_t addr, uint64_t range,
>>>> +					uint64_t num_extensions)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_vm_bind_op op;
>>>> +
>>>> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
>>>> +		   event_flags, sizeof(op));
>>>> +	op.vm_bind_ref_seqno = bind_ref_seqno;
>>>> +	op.addr = addr;
>>>> +	op.range = range;
>>>> +	op.num_extensions = num_extensions;
>>>> +
>>>> +	*op_ref_seqno = op.base.seqno;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&op);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_bind_op_metadata_event:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @event_flags: base event flags
>>>> + * @op_ref_seqno: base vm bind op reference seqno
>>>> + * @metadata_handle: metadata handle
>>>> + * @metadata_cookie: metadata cookie
>>>> + *
>>>> + * Logs vm bind op metadata event in client's event log.
>>>> + */
>>>> +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)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
>>>> +
>>>> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
>>>> +		   event_flags, sizeof(op));
>>>> +	op.vm_bind_op_ref_seqno = op_ref_seqno;
>>>> +	op.metadata_handle = metadata_handle;
>>>> +	op.metadata_cookie = metadata_cookie;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&op);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_bind_ufence_event:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @event_flags: base event flags
>>>> + * @ref_seqno: base vm bind event seqno
>>>> + *
>>>> + * Logs vm bind ufence event in client's event log.
>>>> + */
>>>> +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
>>>> +					    uint64_t ref_seqno)
>>>> +{
>>>> +	struct drm_xe_eudebug_event_vm_bind_ufence f;
>>>> +
>>>> +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>>>> +		   event_flags, sizeof(f));
>>>> +	f.vm_bind_ref_seqno = ref_seqno;
>>>> +
>>>> +	xe_eudebug_event_log_write(c->log, (void *)&f);
>>>> +}
>>>> +
>>>> +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
>>>> +{
>>>> +	while (num_syncs--)
>>>> +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
>>>> +			return true;
>>>> +
>>>> +	return false;
>>>> +}
>>>> +
>>>> +#define for_each_metadata(__m, __ext)					\
>>>> +	for ((__m) = from_user_pointer(__ext);				\
>>>> +	     (__m);							\
>>>> +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
>>>> +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
>>>> +
>>>> +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
>>>> +					int fd, uint32_t vm, uint32_t exec_queue,
>>>> +					uint32_t bo, uint64_t offset,
>>>> +					uint64_t addr, uint64_t size,
>>>> +					uint32_t op, uint32_t flags,
>>>> +					struct drm_xe_sync *sync,
>>>> +					uint32_t num_syncs,
>>>> +					uint32_t prefetch_region,
>>>> +					uint8_t pat_index, uint64_t op_ext)
>>>> +{
>>>> +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
>>>> +	const bool ufence = has_user_fence(sync, num_syncs);
>>>> +	const uint32_t bind_flags = ufence ?
>>>> +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
>>>> +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
>>>> +	uint32_t bind_base_flags = 0;
>>>> +	int ret;
>>>> +
>>>> +	for_each_metadata(metadata, op_ext)
>>>> +		num_metadata++;
>>>> +
>>>> +	switch (op) {
>>>> +	case DRM_XE_VM_BIND_OP_MAP:
>>>> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
>>>> +		break;
>>>> +	case DRM_XE_VM_BIND_OP_UNMAP:
>>>> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
>>>> +		igt_assert_eq(num_metadata, 0);
>>>> +		igt_assert_eq(ufence, false);
>>>> +		break;
>>>> +	default:
>>>> +		/* XXX unmap all? */
>>>> +		igt_assert(op);
>>>> +		break;
>>>> +	}
>>>> +
>>>> +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
>>>> +			    op, flags, sync, num_syncs, prefetch_region,
>>>> +			    pat_index, 0, op_ext);
>>>> +
>>>> +	if (ret)
>>>> +		return ret;
>>>> +
>>>> +	if (!bind_base_flags)
>>>> +		return -EINVAL;
>>>> +
>>>> +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
>>>> +					fd, vm, bind_flags, 1, &seqno);
>>>> +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
>>>> +					   seqno, &op_seqno, addr, size,
>>>> +					   num_metadata);
>>>> +
>>>> +	for_each_metadata(metadata, op_ext)
>>>> +		xe_eudebug_client_vm_bind_op_metadata_event(c,
>>>> +							    DRM_XE_EUDEBUG_EVENT_CREATE,
>>>> +							    op_seqno,
>>>> +							    metadata->metadata_id,
>>>> +							    metadata->cookie);
>>>> +	if (ufence)
>>>> +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
>>>> +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
>>>> +						       seqno);
>>>> +	return ret;
>>>> +}
>>>> +
>>>> +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
>>>> +				       uint32_t vm, uint32_t bo,
>>>> +				       uint64_t offset, uint64_t addr, uint64_t size,
>>>> +				       uint32_t op,
>>>> +				       uint32_t flags,
>>>> +				       struct drm_xe_sync *sync,
>>>> +				       uint32_t num_syncs,
>>>> +				       uint64_t op_ext)
>>>> +{
>>>> +	const uint32_t exec_queue_id = 0;
>>>> +	const uint32_t prefetch_region = 0;
>>>> +
>>>> +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
>>>> +						  addr, size, op, flags,
>>>> +						  sync, num_syncs, prefetch_region,
>>>> +						  DEFAULT_PAT_INDEX, op_ext),
>>>> +		      0);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_bind_flags
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @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, int fd, 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)
>>>> +{
>>>> +	_xe_eudebug_client_vm_bind(c, fd, 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
>>>> + * @fd: xe client
>>>> + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
>>>> +					flags,
>>>> +					sync, num_syncs, op_ext);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_vm_unbind_flags
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @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, int fd,
>>>> +				       uint32_t vm, uint64_t offset,
>>>> +				       uint64_t addr, uint64_t size, uint32_t flags,
>>>> +				       struct drm_xe_sync *sync, uint32_t num_syncs)
>>>> +{
>>>> +	_xe_eudebug_client_vm_bind(c, fd, 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
>>>> + * @fd: xe client
>>>> + * @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, int fd, 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, fd, vm, offset, addr, size,
>>>> +					  flags, sync, num_syncs);
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_metadata_create:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @type: debug metadata type
>>>> + * @len: size of @data
>>>> + * @data: debug metadata paylad
>>>> + *
>>>> + * Calls xe metadata create ioctl and logs the corresponding event in
>>>> + * client's event log.
>>>> + *
>>>> + * Return: valid debug metadata id.
>>>> + */
>>>> +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
>>>> +					   int type, size_t len, void *data)
>>>> +{
>>>> +	struct drm_xe_debug_metadata_create create = {
>>>> +		.type = type,
>>>> +		.user_addr = to_user_pointer(data),
>>>> +		.len = len
>>>> +	};
>>>> +
>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
>>>> +
>>>> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
>>>> +
>>>> +	return create.metadata_id;
>>>> +}
>>>> +
>>>> +/**
>>>> + * xe_eudebug_client_metadata_destroy:
>>>> + * @c: pointer to xe_eudebug_client structure
>>>> + * @fd: xe client
>>>> + * @id: xe debug metadata handle
>>>> + * @type: debug metadata type
>>>> + * @len: size of debug metadata payload
>>>> + *
>>>> + * Calls xe metadata destroy ioctl and logs the corresponding event in
>>>> + * client's event log.
>>>> + */
>>>> +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
>>>> +					uint32_t id, int type, size_t len)
>>>> +{
>>>> +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
>>>> +
>>>> +
>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
>>>> +
>>>> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
>>>> +}
>>>> +
>>>> +void xe_eudebug_ack_ufence(int debugfd,
>>>> +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
>>>> +{
>>>> +	struct drm_xe_eudebug_ack_event ack = { 0, };
>>>> +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
>>>> +
>>>> +	ack.type = f->base.type;
>>>> +	ack.seqno = f->base.seqno;
>>>> +
>>>> +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
>>>> +	igt_debug("delivering ack for event: %s\n", event_str);
>>>> +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
>>>> +}
>>>> diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
>>>> new file mode 100644
>>>> index 000000000..444f5a7b7
>>>> --- /dev/null
>>>> +++ b/lib/xe/xe_eudebug.h
>>>> @@ -0,0 +1,206 @@
>>>> +/* SPDX-License-Identifier: MIT */
>>>> +/*
>>>> + * Copyright © 2023 Intel Corporation
>>>> + */
>>>> +#include <fcntl.h>
>>>> +#include <pthread.h>
>>>> +#include <stdint.h>
>>>> +#include <xe_drm.h>
>>>> +
>>>> +#include "igt_list.h"
>>>> +
>>>> +struct xe_eudebug_event_log {
>>>> +	uint8_t *log;
>>>> +	unsigned int head;
>>>> +	unsigned int max_size;
>>>> +	char name[80];
>>>> +	pthread_mutex_t lock;
>>>> +};
>>>> +
>>>> +struct xe_eudebug_debugger {
>>>> +	int fd;
>>>> +	uint64_t flags;
>>>> +
>>>> +	/* Used to smuggle private data */
>>>> +	void *ptr;
>>>> +
>>>> +	struct xe_eudebug_event_log *log;
>>>> +
>>>> +	uint64_t event_count;
>>>> +
>>>> +	uint64_t target_pid;
>>>> +
>>>> +	struct igt_list_head triggers;
>>>> +
>>>> +	int master_fd;
>>>> +
>>>> +	pthread_t worker_thread;
>>>> +	int worker_state;
>>>> +
>>>> +	int p_client[2];
>>>> +};
>>>> +
>>>> +struct xe_eudebug_client {
>>>> +	int pid;
>>>> +	uint64_t seqno;
>>>> +	uint64_t flags;
>>>> +
>>>> +	/* Used to smuggle private data */
>>>> +	void *ptr;
>>>> +
>>>> +	struct xe_eudebug_event_log *log;
>>>> +
>>>> +	int done;
>>>> +	int p_in[2];
>>>> +	int p_out[2];
>>>> +
>>>> +	/* Used to pickup right device (the one used in debugger) */
>>>> +	int master_fd;
>>>> +
>>>> +	int timeout_ms;
>>>> +};
>>>> +
>>>> +struct xe_eudebug_session {
>>>> +	uint64_t flags;
>>>> +	struct xe_eudebug_client *c;
>>>> +	struct xe_eudebug_debugger *d;
>>>> +};
>>>> +
>>>> +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_event(_e, _log) \
>>>> +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
>>>> +		    (void *)(_log)->log; \
>>>> +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
>>>> +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
>>>> +
>>>> +#define xe_eudebug_assert(d, c)						\
>>>> +	do {								\
>>>> +		if (!(c)) {						\
>>>> +			xe_eudebug_event_log_print((d)->log, true);	\
>>>> +			igt_assert(c);					\
>>>> +		}							\
>>>> +	} while (0)
>>>> +
>>>> +#define xe_eudebug_assert_f(d, c, f...)					\
>>>> +	do {								\
>>>> +		if (!(c)) {						\
>>>> +			xe_eudebug_event_log_print((d)->log, true);	\
>>>> +			igt_assert_f(c, f);				\
>>>> +		}							\
>>>> +	} while (0)
>>>> +
>>>> +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
>>>> +
>>>> +/*
>>>> + * Default abort timeout to use across xe_eudebug lib and tests if no specific
>>>> + * timeout value is required.
>>>> + */
>>>> +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
>>>> +
>>>> +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
>>>> +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
>>>> +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
>>>> +
>>>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
>>>> +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);
>>>> +struct xe_eudebug_event_log *
>>>> +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
>>>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
>>>> +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
>>>> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
>>>> +				  uint32_t filter);
>>>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
>>>> +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
>>>> +
>>>> +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_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, int timeout_s);
>>>> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
>>>> +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
>>>> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
>>>> +				     xe_eudebug_trigger_fn fn);
>>>> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
>>>> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
>>>> +
>>>> +struct xe_eudebug_client *
>>>> +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
>>>> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
>>>> +void xe_eudebug_client_start(struct xe_eudebug_client *c);
>>>> +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
>>>> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
>>>> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
>>>> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
>>>> +
>>>> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
>>>> +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
>>>> +
>>>> +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 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,
>>>> +					     struct drm_xe_exec_queue_create *create);
>>>> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
>>>> +					  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,
>>>> +				     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,
>>>> +					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,
>>>> +			   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,
>>>> +				     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,
>>>> +			       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,
>>>> +				       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,
>>>> +				 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,
>>>> +						     void *test_private);
>>>> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
>>>> +void xe_eudebug_session_run(struct xe_eudebug_session *s);
>>>> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
>>>> -- 
>>>> 2.34.1
>>>>

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Zbigniew Kempczyński]

On Tue, Aug 20, 2024 at 07:45:18PM +0200, Kamil Konieczny wrote:
> Hi Manszewski,,
> On 2024-08-20 at 18:14:07 +0200, Manszewski, Christoph wrote:
> > Hi Zbigniew,
> > 
> > On 20.08.2024 10:14, Zbigniew Kempczyński wrote:
> > > On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
> > > > From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> > > > 
> > > > Introduce library which simplifies testing of eu debug capability.
> > > > The library provides event log helpers together with asynchronous
> > > > abstraction for client proccess and the debugger itself.
> > > > 
> > > > xe_eudebug_client creates its own proccess with user's work function,
> > > > and gives machanisms to synchronize beginning of execution and event
> > > > logging.
> > > > 
> > > > xe_eudebug_debugger allows to attach to the given proccess, provides
> > > > asynchronous thread for event reading and introduces triggers -
> > > > a callback mechanism triggered every time subscribed event was read.
> > > > 
> > > > Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> > > > Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
> > > > Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> > > > Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
> > > > Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> > > > Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> > > > ---
> > > >   lib/meson.build     |    1 +
> > > >   lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
> > > >   lib/xe/xe_eudebug.h |  206 ++++
> > > >   3 files changed, 2399 insertions(+)
> > > >   create mode 100644 lib/xe/xe_eudebug.c
> > > >   create mode 100644 lib/xe/xe_eudebug.h
> > > > 
> > > > diff --git a/lib/meson.build b/lib/meson.build
> > > > index f711e60a7..969ca4101 100644
> > > > --- a/lib/meson.build
> > > > +++ b/lib/meson.build
> > > > @@ -111,6 +111,7 @@ lib_sources = [
> > > >   	'igt_msm.c',
> > > >   	'igt_dsc.c',
> > > >   	'xe/xe_gt.c',
> > > > +	'xe/xe_eudebug.c',
> > > >   	'xe/xe_ioctl.c',
> > > >   	'xe/xe_mmio.c',
> > > >   	'xe/xe_query.c',
> > > 
> > > As eudebug is quite big feature I think it should be separated and
> > > hidden behind a feature flag (check meson_options.txt), lets say
> > > 'xe_eudebug' which would be disabled by default. This way you can
> > > develop it upstream even if kernel side is not officially merged.
> > > I'm pragramatic and I see no reason to block not accepted feature
> > > especially this would imo speed up developement. A final step when
> > > kernel change would be accepted and merged would be to sync with
> > > uapi and remove local definitions.
> > > 
> > > I look forward maintainers comments is my attitude acceptable.
> > 
> > I agree that it is a good idea. The only problem that arises is for
> > 'xe_exec_sip'. We add a dependency on eudebug to this test - any ideas how
> > to approach this correctly? The only thing that comes to my mind is
> > conditional compilation with 'ifdef' statements but it doesn't appear to be
> > pretty.
> 
> What about adding skips in added tests if kernel do not support eudebug?
> 
> This way you can have it without conditional compilation with
> ifdef/meson and also have it compile-time tested (if CI support test-with
> for Xe kernels).

IMO simplest is to migrate code to xe_exec_sip_eudebug.c.

--
Zbigniew


> 
> Regards,
> Kamil
> 
> > 
> > Thanks,
> > Christoph
> > > 
> > > --
> > > Zbigniew
> > > 
> > > 
> > > > diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
> > > > new file mode 100644
> > > > index 000000000..4eac87476
> > > > --- /dev/null
> > > > +++ b/lib/xe/xe_eudebug.c
> > > > @@ -0,0 +1,2192 @@
> > > > +// SPDX-License-Identifier: MIT
> > > > +/*
> > > > + * Copyright © 2023 Intel Corporation
> > > > + */
> > > > +
> > > > +#include <fcntl.h>
> > > > +#include <poll.h>
> > > > +#include <signal.h>
> > > > +#include <sys/select.h>
> > > > +#include <sys/stat.h>
> > > > +#include <sys/types.h>
> > > > +#include <sys/wait.h>
> > > > +
> > > > +#include "igt.h"
> > > > +#include "igt_sysfs.h"
> > > > +#include "intel_pat.h"
> > > > +#include "xe_eudebug.h"
> > > > +#include "xe_ioctl.h"
> > > > +
> > > > +struct event_trigger {
> > > > +	xe_eudebug_trigger_fn fn;
> > > > +	int type;
> > > > +	struct igt_list_head link;
> > > > +};
> > > > +
> > > > +struct seqno_list_entry {
> > > > +	struct igt_list_head link;
> > > > +	uint64_t seqno;
> > > > +};
> > > > +
> > > > +struct match_dto {
> > > > +	struct drm_xe_eudebug_event *target;
> > > > +	struct igt_list_head *seqno_list;
> > > > +	uint64_t client_handle;
> > > > +	uint32_t filter;
> > > > +
> > > > +	/* store latest 'EVENT_VM_BIND' seqno */
> > > > +	uint64_t *bind_seqno;
> > > > +	/* latest vm_bind_op seqno matching bind_seqno */
> > > > +	uint64_t *bind_op_seqno;
> > > > +};
> > > > +
> > > > +#define CLIENT_PID  1
> > > > +#define CLIENT_RUN  2
> > > > +#define CLIENT_FINI 3
> > > > +#define CLIENT_STOP 4
> > > > +#define CLIENT_STAGE 5
> > > > +#define DEBUGGER_STAGE 6
> > > > +
> > > > +#define DEBUGGER_WORKER_INACTIVE  0
> > > > +#define DEBUGGER_WORKER_ACTIVE  1
> > > > +#define DEBUGGER_WORKER_QUITTING 2
> > > > +
> > > > +static const char *type_to_str(unsigned int type)
> > > > +{
> > > > +	switch (type) {
> > > > +	case DRM_XE_EUDEBUG_EVENT_NONE:
> > > > +		return "none";
> > > > +	case DRM_XE_EUDEBUG_EVENT_READ:
> > > > +		return "read";
> > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN:
> > > > +		return "client";
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM:
> > > > +		return "vm";
> > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
> > > > +		return "exec_queue";
> > > > +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
> > > > +		return "attention";
> > > > +	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_UFENCE:
> > > > +		return "vm_bind_ufence";
> > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA:
> > > > +		return "metadata";
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
> > > > +		return "vm_bind_op_metadata";
> > > > +	}
> > > > +
> > > > +	return "UNKNOWN";
> > > > +}
> > > > +
> > > > +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
> > > > +{
> > > > +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
> > > > +
> > > > +	return buf;
> > > > +}
> > > > +
> > > > +static const char *flags_to_str(unsigned int flags)
> > > > +{
> > > > +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > > +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
> > > > +			return "create|ack";
> > > > +		else
> > > > +			return "create";
> > > > +	}
> > > > +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> > > > +		return "destroy";
> > > > +
> > > > +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
> > > > +		return "state-change";
> > > > +
> > > > +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
> > > > +
> > > > +	return "flags unknown";
> > > > +}
> > > > +
> > > > +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
> > > > +{
> > > > +	switch (e->type) {
> > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > > +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
> > > > +
> > > > +		sprintf(b, "handle=%llu", ec->client_handle);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > > +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
> > > > +
> > > > +		sprintf(b, "client_handle=%llu, handle=%llu",
> > > > +			evm->client_handle, evm->vm_handle);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> > > > +
> > > > +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
> > > > +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
> > > > +			ee->client_handle, ee->vm_handle,
> > > > +			ee->exec_queue_handle, ee->engine_class, ee->width);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
> > > > +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
> > > > +
> > > > +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
> > > > +			   "lrc_handle=%llu, bitmask_size=%d",
> > > > +			ea->client_handle, ea->exec_queue_handle,
> > > > +			ea->lrc_handle, ea->bitmask_size);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> > > > +
> > > > +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
> > > > +			evmb->client_handle, 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 = (void *)e;
> > > > +
> > > > +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
> > > > +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
> > > > +
> > > > +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > > +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> > > > +
> > > > +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
> > > > +			em->client_handle, em->metadata_handle, em->type, em->len);
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
> > > > +
> > > > +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
> > > > +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
> > > > +		break;
> > > > +	}
> > > > +	default:
> > > > +		strcpy(b, "<...>");
> > > > +	}
> > > > +
> > > > +	return b;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_to_str:
> > > > + * @e: pointer to event
> > > > + * @buf: target to write string representation of @e
> > > > + * @len: size of target buffer @buf
> > > > + *
> > > > + * Creates string representation for given event.
> > > > + *
> > > > + * Returns: the written input buffer pointed by @buf.
> > > > + */
> > > > +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
> > > > +{
> > > > +	char a[256];
> > > > +	char b[256];
> > > > +
> > > > +	snprintf(buf, len, "(%llu) %15s:%s: %s",
> > > > +		 e->seqno,
> > > > +		 event_type_to_str(e, a),
> > > > +		 flags_to_str(e->flags),
> > > > +		 event_members_to_str(e, b));
> > > > +
> > > > +	return buf;
> > > > +}
> > > > +
> > > > +static void catch_child_failure(void)
> > > > +{
> > > > +	pid_t pid;
> > > > +	int status;
> > > > +
> > > > +	pid = waitpid(-1, &status, WNOHANG);
> > > > +
> > > > +	if (pid == 0 || pid == -1)
> > > > +		return;
> > > > +
> > > > +	if (!WIFEXITED(status))
> > > > +		return;
> > > > +
> > > > +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
> > > > +}
> > > > +
> > > > +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
> > > > +{
> > > > +	int ret;
> > > > +	int t = 0;
> > > > +	struct pollfd fd = {
> > > > +		.fd = pipe[0],
> > > > +		.events = POLLIN,
> > > > +		.revents = 0
> > > > +	};
> > > > +
> > > > +	/* When child fails we may get stuck forever. Check whether
> > > > +	 * the child process ended with an error.
> > > > +	 */
> > > > +	do {
> > > > +		const int interval_ms = 1000;
> > > > +
> > > > +		ret = poll(&fd, 1, interval_ms);
> > > > +
> > > > +		if (!ret) {
> > > > +			catch_child_failure();
> > > > +			t += interval_ms;
> > > > +		}
> > > > +	} while (!ret && t < timeout_ms);
> > > > +
> > > > +	if (ret > 0)
> > > > +		return read(pipe[0], buf, nbytes);
> > > > +
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static uint64_t pipe_read(int pipe[2], int timeout_ms)
> > > > +{
> > > > +	uint64_t in;
> > > > +	uint64_t ret;
> > > > +
> > > > +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
> > > > +	igt_assert(ret == sizeof(in));
> > > > +
> > > > +	return in;
> > > > +}
> > > > +
> > > > +static void pipe_signal(int pipe[2], uint64_t token)
> > > > +{
> > > > +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
> > > > +}
> > > > +
> > > > +static void pipe_close(int pipe[2])
> > > > +{
> > > > +	if (pipe[0] != -1)
> > > > +		close(pipe[0]);
> > > > +
> > > > +	if (pipe[1] != -1)
> > > > +		close(pipe[1]);
> > > > +}
> > > > +
> > > > +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
> > > > +{
> > > > +	uint64_t in;
> > > > +
> > > > +	in = pipe_read(p, timeout_ms);
> > > > +
> > > > +	igt_assert_eq(in, token);
> > > > +
> > > > +	return pipe_read(p, timeout_ms);
> > > > +}
> > > > +
> > > > +static uint64_t client_wait_token(struct xe_eudebug_client *c,
> > > > +				 const uint64_t token)
> > > > +{
> > > > +	return __wait_token(c->p_in, token, c->timeout_ms);
> > > > +}
> > > > +
> > > > +static uint64_t wait_from_client(struct xe_eudebug_client *c,
> > > > +				 const uint64_t token)
> > > > +{
> > > > +	return __wait_token(c->p_out, token, c->timeout_ms);
> > > > +}
> > > > +
> > > > +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
> > > > +{
> > > > +	pipe_signal(p, token);
> > > > +	pipe_signal(p, value);
> > > > +}
> > > > +
> > > > +static void client_signal(struct xe_eudebug_client *c,
> > > > +			  const uint64_t token,
> > > > +			  const uint64_t value)
> > > > +{
> > > > +	token_signal(c->p_out, token, value);
> > > > +}
> > > > +
> > > > +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
> > > > +{
> > > > +	struct drm_xe_eudebug_connect param = {
> > > > +		.pid = pid,
> > > > +		.flags = flags,
> > > > +	};
> > > > +	int debugfd;
> > > > +
> > > > +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> > > > +
> > > > +	if (debugfd < 0)
> > > > +		return -errno;
> > > > +
> > > > +	return debugfd;
> > > > +}
> > > > +
> > > > +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
> > > > +{
> > > > +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
> > > > +		      sizeof(l->head));
> > > > +
> > > > +	igt_assert_eq(write(fd, l->log, l->head), l->head);
> > > > +}
> > > > +
> > > > +static void read_all(int fd, void *buf, size_t nbytes)
> > > > +{
> > > > +	ssize_t remaining_size = nbytes;
> > > > +	ssize_t current_size = 0;
> > > > +	ssize_t read_size = 0;
> > > > +
> > > > +	do {
> > > > +		read_size = read(fd, buf + current_size, remaining_size);
> > > > +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
> > > > +
> > > > +		current_size += read_size;
> > > > +		remaining_size -= read_size;
> > > > +	} while (remaining_size > 0 && read_size > 0);
> > > > +
> > > > +	igt_assert_eq(current_size, nbytes);
> > > > +}
> > > > +
> > > > +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
> > > > +{
> > > > +	read_all(fd, &l->head, sizeof(l->head));
> > > > +	igt_assert_lt(l->head, l->max_size);
> > > > +
> > > > +	read_all(fd, l->log, l->head);
> > > > +}
> > > > +
> > > > +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
> > > > +
> > > > +static struct drm_xe_eudebug_event *
> > > > +event_cmp(struct xe_eudebug_event_log *l,
> > > > +	  struct drm_xe_eudebug_event *current,
> > > > +	  cmp_fn_t match,
> > > > +	  void *data)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *e = current;
> > > > +
> > > > +	xe_eudebug_for_each_event(e, l) {
> > > > +		if (match(e, data))
> > > > +			return e;
> > > > +	}
> > > > +
> > > > +	return NULL;
> > > > +}
> > > > +
> > > > +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *b = data;
> > > > +
> > > > +	if (a->type == b->type &&
> > > > +	    a->flags == b->flags)
> > > > +		return 1;
> > > > +
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *b = data;
> > > > +	int ret = 0;
> > > > +
> > > > +	ret = match_type_and_flags(a, data);
> > > > +	if (!ret)
> > > > +		return ret;
> > > > +
> > > > +	ret = 0;
> > > > +
> > > > +	switch (a->type) {
> > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
> > > > +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
> > > > +
> > > > +		if (ae->engine_class == be->engine_class && ae->width == be->width)
> > > > +			ret = 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
> > > > +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
> > > > +
> > > > +		if (ea->num_binds == eb->num_binds)
> > > > +			ret = 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
> > > > +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
> > > > +
> > > > +		if (ea->addr == eb->addr && ea->range == eb->range &&
> > > > +		    ea->num_extensions == eb->num_extensions)
> > > > +			ret = 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
> > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
> > > > +
> > > > +		if (ea->metadata_handle == eb->metadata_handle &&
> > > > +		    ea->metadata_cookie == eb->metadata_cookie)
> > > > +			ret = 1;
> > > > +		break;
> > > > +	}
> > > > +
> > > > +	default:
> > > > +		ret = 1;
> > > > +		break;
> > > > +	}
> > > > +
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
> > > > +{
> > > > +	struct match_dto *md = (void *)data;
> > > > +	uint64_t *bind_seqno = md->bind_seqno;
> > > > +	uint64_t *bind_op_seqno = md->bind_op_seqno;
> > > > +	uint64_t h = md->client_handle;
> > > > +
> > > > +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
> > > > +		return 0;
> > > > +
> > > > +	switch (e->type) {
> > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > > +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> > > > +
> > > > +		if (client->client_handle == h)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > > +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> > > > +
> > > > +		if (vm->client_handle == h)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
> > > > +
> > > > +		if (ee->client_handle == h)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
> > > > +
> > > > +		if (evmb->client_handle == h) {
> > > > +			*bind_seqno = evmb->base.seqno;
> > > > +			return 1;
> > > > +		}
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
> > > > +
> > > > +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
> > > > +			*bind_op_seqno = eo->base.seqno;
> > > > +			return 1;
> > > > +		}
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
> > > > +
> > > > +		if (ef->vm_bind_ref_seqno == *bind_seqno)
> > > > +			return 1;
> > > > +
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > > +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
> > > > +
> > > > +		if (em->client_handle == h)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
> > > > +
> > > > +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	default:
> > > > +		break;
> > > > +	}
> > > > +
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
> > > > +{
> > > > +
> > > > +	struct drm_xe_eudebug_event *d = (void *)data;
> > > > +	int ret;
> > > > +
> > > > +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > > +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
> > > > +	ret = match_type_and_flags(e, data);
> > > > +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > > +
> > > > +	if (!ret)
> > > > +		return 0;
> > > > +
> > > > +	switch (e->type) {
> > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > > +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> > > > +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
> > > > +
> > > > +		if (client->client_handle == filter->client_handle)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > > +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> > > > +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
> > > > +
> > > > +		if (vm->vm_handle == filter->vm_handle)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> > > > +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
> > > > +
> > > > +		if (ee->exec_queue_handle == filter->exec_queue_handle)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> > > > +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
> > > > +
> > > > +		if (evmb->vm_handle == filter->vm_handle &&
> > > > +		    evmb->num_binds == filter->num_binds)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
> > > > +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
> > > > +
> > > > +		if (avmb->addr == filter->addr &&
> > > > +		    avmb->range == filter->range)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > > +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> > > > +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
> > > > +
> > > > +		if (em->metadata_handle == filter->metadata_handle)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
> > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
> > > > +
> > > > +		if (avmb->metadata_handle == filter->metadata_handle &&
> > > > +		    avmb->metadata_cookie == filter->metadata_cookie)
> > > > +			return 1;
> > > > +		break;
> > > > +	}
> > > > +
> > > > +	default:
> > > > +		break;
> > > > +	}
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +static int match_full(struct drm_xe_eudebug_event *e, void *data)
> > > > +{
> > > > +	struct seqno_list_entry *sl;
> > > > +
> > > > +	struct match_dto *md = (void *)data;
> > > > +	int ret = 0;
> > > > +
> > > > +	ret = match_client_handle(e, md);
> > > > +	if (!ret)
> > > > +		return 0;
> > > > +
> > > > +	ret = match_fields(e, md->target);
> > > > +	if (!ret)
> > > > +		return 0;
> > > > +
> > > > +	igt_list_for_each_entry(sl, md->seqno_list, link) {
> > > > +		if (sl->seqno == e->seqno)
> > > > +			return 0;
> > > > +	}
> > > > +
> > > > +	return 1;
> > > > +}
> > > > +
> > > > +static struct drm_xe_eudebug_event *
> > > > +event_type_match(struct xe_eudebug_event_log *l,
> > > > +		 struct drm_xe_eudebug_event *target,
> > > > +		 struct drm_xe_eudebug_event *current)
> > > > +{
> > > > +	return event_cmp(l, current, match_type_and_flags, target);
> > > > +}
> > > > +
> > > > +static struct drm_xe_eudebug_event *
> > > > +client_match(struct xe_eudebug_event_log *l,
> > > > +	     uint64_t client_handle,
> > > > +	     struct drm_xe_eudebug_event *current,
> > > > +	     uint32_t filter,
> > > > +	     uint64_t *bind_seqno,
> > > > +	     uint64_t *bind_op_seqno)
> > > > +{
> > > > +	struct match_dto md = {
> > > > +		.client_handle = client_handle,
> > > > +		.filter = filter,
> > > > +		.bind_seqno = bind_seqno,
> > > > +		.bind_op_seqno = bind_op_seqno,
> > > > +	};
> > > > +
> > > > +	return event_cmp(l, current, match_client_handle, &md);
> > > > +}
> > > > +
> > > > +static struct drm_xe_eudebug_event *
> > > > +opposite_event_match(struct xe_eudebug_event_log *l,
> > > > +		    struct drm_xe_eudebug_event *target,
> > > > +		    struct drm_xe_eudebug_event *current)
> > > > +{
> > > > +	return event_cmp(l, current, match_opposite_resource, target);
> > > > +}
> > > > +
> > > > +static struct drm_xe_eudebug_event *
> > > > +event_match(struct xe_eudebug_event_log *l,
> > > > +	    struct drm_xe_eudebug_event *target,
> > > > +	    uint64_t client_handle,
> > > > +	    struct igt_list_head *seqno_list,
> > > > +	    uint64_t *bind_seqno,
> > > > +	    uint64_t *bind_op_seqno)
> > > > +{
> > > > +	struct match_dto md = {
> > > > +		.target = target,
> > > > +		.client_handle = client_handle,
> > > > +		.seqno_list = seqno_list,
> > > > +		.bind_seqno = bind_seqno,
> > > > +		.bind_op_seqno = bind_op_seqno,
> > > > +	};
> > > > +
> > > > +	return event_cmp(l, NULL, match_full, &md);
> > > > +}
> > > > +
> > > > +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
> > > > +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
> > > > +			   uint32_t filter)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
> > > > +	struct drm_xe_eudebug_event_client *de = (void *)_de;
> > > > +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
> > > > +
> > > > +	struct igt_list_head matched_seqno_list;
> > > > +	struct drm_xe_eudebug_event *hc, *hd;
> > > > +	struct seqno_list_entry *entry, *tmp;
> > > > +
> > > > +	igt_assert(ce);
> > > > +	igt_assert(de);
> > > > +
> > > > +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
> > > > +
> > > > +	hc = NULL;
> > > > +	hd = NULL;
> > > > +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
> > > > +
> > > > +	do {
> > > > +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
> > > > +		if (!hc)
> > > > +			break;
> > > > +
> > > > +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
> > > > +
> > > > +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
> > > > +			     c->name,
> > > > +			     hc->seqno,
> > > > +			     hc->type,
> > > > +			     ce->client_handle);
> > > > +
> > > > +		igt_debug("comparing %s %llu vs %s %llu\n",
> > > > +			  c->name, hc->seqno, d->name, hd->seqno);
> > > > +
> > > > +		/*
> > > > +		 * Store the seqno of the event that was matched above,
> > > > +		 * inside 'matched_seqno_list', to avoid it getting matched
> > > > +		 * by subsequent 'event_match' calls.
> > > > +		 */
> > > > +		entry = malloc(sizeof(*entry));
> > > > +		entry->seqno = hd->seqno;
> > > > +		igt_list_add(&entry->link, &matched_seqno_list);
> > > > +	} while (hc);
> > > > +
> > > > +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
> > > > +		free(entry);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_find_seqno:
> > > > + * @l: event log pointer
> > > > + * @seqno: seqno of event to be found
> > > > + *
> > > > + * Finds the event with given seqno in the event log.
> > > > + *
> > > > + * Returns: pointer to the event with given seqno within @l or NULL seqno is
> > > > + * not present.
> > > > + */
> > > > +struct drm_xe_eudebug_event *
> > > > +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
> > > > +
> > > > +	igt_assert_neq(seqno, 0);
> > > > +	/*
> > > > +	 * Try to catch if seqno is corrupted and prevent too long tests,
> > > > +	 * as our post processing of events is not optimized.
> > > > +	 */
> > > > +	igt_assert_lt(seqno, 10 * 1000 * 1000);
> > > > +
> > > > +	xe_eudebug_for_each_event(e, l) {
> > > > +		if (e->seqno == seqno) {
> > > > +			if (found) {
> > > > +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
> > > > +				xe_eudebug_event_log_print(l, false);
> > > > +				igt_assert(!found);
> > > > +			}
> > > > +			found = e;
> > > > +		}
> > > > +	}
> > > > +
> > > > +	return found;
> > > > +}
> > > > +
> > > > +static void event_log_sort(struct xe_eudebug_event_log *l)
> > > > +{
> > > > +	struct xe_eudebug_event_log *tmp;
> > > > +	struct drm_xe_eudebug_event *e = NULL;
> > > > +	uint64_t first_seqno = 0;
> > > > +	uint64_t last_seqno = 0;
> > > > +	uint64_t events = 0, added = 0;
> > > > +	uint64_t i;
> > > > +
> > > > +	xe_eudebug_for_each_event(e, l) {
> > > > +		if (e->seqno > last_seqno)
> > > > +			last_seqno = e->seqno;
> > > > +
> > > > +		if (e->seqno < first_seqno)
> > > > +			first_seqno = e->seqno;
> > > > +
> > > > +		events++;
> > > > +	}
> > > > +
> > > > +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
> > > > +
> > > > +	for (i = 1; i <= last_seqno; i++) {
> > > > +		e = xe_eudebug_event_log_find_seqno(l, i);
> > > > +		if (e) {
> > > > +			xe_eudebug_event_log_write(tmp, e);
> > > > +			added++;
> > > > +		}
> > > > +	}
> > > > +
> > > > +	igt_assert_eq(events, added);
> > > > +	igt_assert_eq(tmp->head, l->head);
> > > > +
> > > > +	memcpy(l->log, tmp->log, tmp->head);
> > > > +
> > > > +	xe_eudebug_event_log_destroy(tmp);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_connect:
> > > > + * @fd: Xe file descriptor
> > > > + * @pid: client PID
> > > > + * @flags: connection flags
> > > > + *
> > > > + * Opens the xe eu debugger connection to the process described by @pid
> > > > + *
> > > > + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> > > > + */
> > > > +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
> > > > +{
> > > > +	int ret;
> > > > +	uint64_t events = 0; /* events filtering not supported yet! */
> > > > +
> > > > +	ret = __xe_eudebug_connect(fd, pid, flags, events);
> > > > +
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_create:
> > > > + * @name: event log identifier
> > > > + * @max_size: maximum size of created log
> > > > + *
> > > > + * Function creates an Eu Debugger event log with size equal to @max_size.
> > > > + *
> > > > + * Returns: pointer to just created log
> > > > + */
> > > > +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
> > > > +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
> > > > +{
> > > > +	struct xe_eudebug_event_log *l;
> > > > +
> > > > +	l = calloc(1, sizeof(*l));
> > > > +	igt_assert(l);
> > > > +	l->log = calloc(1, max_size);
> > > > +	igt_assert(l->log);
> > > > +	l->max_size = max_size;
> > > > +	strncpy(l->name, name, sizeof(l->name) - 1);
> > > > +	pthread_mutex_init(&l->lock, NULL);
> > > > +
> > > > +	return l;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_destroy:
> > > > + * @l: event log pointer
> > > > + *
> > > > + * Frees given event log @l.
> > > > + */
> > > > +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
> > > > +{
> > > > +	pthread_mutex_destroy(&l->lock);
> > > > +	free(l->log);
> > > > +	free(l);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_write:
> > > > + * @l: event log pointer
> > > > + * @e: event to be written to event log
> > > > + *
> > > > + * Writes event @e to the event log, thread-safe.
> > > > + */
> > > > +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
> > > > +{
> > > > +	igt_assert(e->seqno);
> > > > +	/*
> > > > +	 * Try to catch if seqno is corrupted and prevent too long tests,
> > > > +	 * as our post processing of events is not optimized.
> > > > +	 */
> > > > +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
> > > > +
> > > > +	pthread_mutex_lock(&l->lock);
> > > > +	igt_assert_lt(l->head + e->len, l->max_size);
> > > > +	memcpy(l->log + l->head, e, e->len);
> > > > +	l->head += e->len;
> > > > +
> > > > +#ifdef DEBUG_LOG
> > > > +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
> > > > +		 l->name, e->len, l->max_size - l->head);
> > > > +#endif
> > > > +	pthread_mutex_unlock(&l->lock);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_print:
> > > > + * @l: event log pointer
> > > > + * @debug: when true function uses igt_debug instead of igt_info.
> > > > + *
> > > > + * Prints given event log.
> > > > + */
> > > > +void
> > > > +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *e = NULL;
> > > > +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
> > > > +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> > > > +
> > > > +	igt_log(IGT_LOG_DOMAIN, level,
> > > > +		"event log '%s' (%u bytes):\n", l->name, l->head);
> > > > +
> > > > +	xe_eudebug_for_each_event(e, l) {
> > > > +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> > > > +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
> > > > +	}
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_compare:
> > > > + * @a: event log pointer
> > > > + * @b: event log pointer
> > > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > > + * for events like 'VM_BIND' since they can be asymmetric. Note that
> > > > + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
> > > > + *
> > > > + * Compares and asserts event logs @a, @b if the event
> > > > + * sequence matches.
> > > > + */
> > > > +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
> > > > +				  uint32_t filter)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *ae = NULL;
> > > > +	struct drm_xe_eudebug_event *be = NULL;
> > > > +
> > > > +	xe_eudebug_for_each_event(ae, a) {
> > > > +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
> > > > +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > > +			be = event_type_match(b, ae, be);
> > > > +
> > > > +			compare_client(a, ae, b, be, filter);
> > > > +			compare_client(b, be, a, ae, filter);
> > > > +		}
> > > > +	}
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_event_log_match_opposite:
> > > > + * @l: event log pointer
> > > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > > + * for events like 'VM_BIND' since they can be asymmetric
> > > > + *
> > > > + * Matches and asserts content of all opposite events (create vs destroy).
> > > > + */
> > > > +void
> > > > +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
> > > > +{
> > > > +	struct drm_xe_eudebug_event *ce = NULL;
> > > > +	struct drm_xe_eudebug_event *de = NULL;
> > > > +
> > > > +	xe_eudebug_for_each_event(ce, l) {
> > > > +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > > +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
> > > > +			int opposite_matching;
> > > > +
> > > > +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
> > > > +				continue;
> > > > +
> > > > +			/* No opposite matching for binds */
> > > > +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
> > > > +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
> > > > +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
> > > > +				continue;
> > > > +
> > > > +			de = opposite_event_match(l, ce, ce);
> > > > +
> > > > +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
> > > > +
> > > > +			igt_assert_eq(ce->len, de->len);
> > > > +			opposite_matching = memcmp((uint8_t *)de + offset,
> > > > +						   (uint8_t *)ce + offset,
> > > > +						   de->len - offset) == 0;
> > > > +
> > > > +			igt_assert_f(opposite_matching,
> > > > +				     "%s: create|destroy event not "
> > > > +				     "maching (%llu) vs (%llu)\n",
> > > > +				     l->name, de->seqno, ce->seqno);
> > > > +		}
> > > > +	}
> > > > +}
> > > > +
> > > > +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
> > > > +				  struct drm_xe_eudebug_event *e)
> > > > +{
> > > > +	struct event_trigger *t;
> > > > +
> > > > +	igt_list_for_each_entry(t, &d->triggers, link) {
> > > > +		if (e->type == t->type)
> > > > +			t->fn(d, e);
> > > > +	}
> > > > +}
> > > > +
> > > > +#define MAX_EVENT_SIZE (32 * 1024)
> > > > +static int
> > > > +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
> > > > +{
> > > > +	int ret;
> > > > +
> > > > +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
> > > > +	event->flags = 0;
> > > > +	event->len = MAX_EVENT_SIZE;
> > > > +
> > > > +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
> > > > +	if (ret < 0)
> > > > +		return -errno;
> > > > +
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +static void *debugger_worker_loop(void *data)
> > > > +{
> > > > +	uint8_t buf[MAX_EVENT_SIZE];
> > > > +	struct drm_xe_eudebug_event *e = (void *)buf;
> > > > +	struct xe_eudebug_debugger *d = data;
> > > > +	struct pollfd p = {
> > > > +		.events = POLLIN,
> > > > +		.revents = 0,
> > > > +	};
> > > > +	int timeout_ms = 100, ret;
> > > > +
> > > > +	igt_assert(d->master_fd >= 0);
> > > > +
> > > > +	do {
> > > > +		p.fd = d->fd;
> > > > +		ret = poll(&p, 1, timeout_ms);
> > > > +
> > > > +		if (ret == -1) {
> > > > +			igt_info("poll failed with errno %d\n", errno);
> > > > +			break;
> > > > +		}
> > > > +
> > > > +		if (ret == 1 && (p.revents & POLLIN)) {
> > > > +			int err = xe_eudebug_read_event(d->fd, e);
> > > > +
> > > > +			if (!err) {
> > > > +				++d->event_count;
> > > > +
> > > > +				xe_eudebug_event_log_write(d->log, e);
> > > > +				debugger_run_triggers(d, e);
> > > > +			} else {
> > > > +				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;
> > > > +	return NULL;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_available:
> > > > + * @fd: Xe file descriptor
> > > > + *
> > > > + * Returns: true it debugger connection is available, false otherwise.
> > > > + */
> > > > +bool xe_eudebug_debugger_available(int fd)
> > > > +{
> > > > +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
> > > > +	int debugfd;
> > > > +
> > > > +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> > > > +	if (debugfd >= 0)
> > > > +		close(debugfd);
> > > > +
> > > > +	return debugfd >= 0;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_create:
> > > > + * @master_fd: xe client used to open the debugger connection
> > > > + * @flags: flags stored in a debugger structure, can be used at will
> > > > + * of the caller, i.e. to be used inside triggers.
> > > > + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> > > > + * can be shared between client and debugger. Can be NULL.
> > > > + *
> > > > + * Returns: newly created xe_eudebug_debugger structure with its
> > > > + * event log initialized. Note that to open the connection
> > > > + * you need call @xe_eudebug_debugger_attach.
> > > > + */
> > > > +struct xe_eudebug_debugger *
> > > > +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
> > > > +{
> > > > +	struct xe_eudebug_debugger *d;
> > > > +
> > > > +	d = calloc(1, sizeof(*d));
> > > > +	d->flags = flags;
> > > > +	igt_assert(d);
> > > > +	IGT_INIT_LIST_HEAD(&d->triggers);
> > > > +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
> > > > +	d->fd = -1;
> > > > +	d->master_fd = master_fd;
> > > > +	d->ptr = data;
> > > > +
> > > > +	return d;
> > > > +}
> > > > +
> > > > +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
> > > > +{
> > > > +	struct event_trigger *t, *tmp;
> > > > +
> > > > +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
> > > > +		free(t);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_destroy:
> > > > + * @d: pointer to the debugger
> > > > + *
> > > > + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
> > > > + * connection was still opened it terminates it.
> > > > + */
> > > > +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
> > > > +{
> > > > +	if (d->worker_state)
> > > > +		xe_eudebug_debugger_stop_worker(d, 1);
> > > > +
> > > > +	if (d->target_pid)
> > > > +		xe_eudebug_debugger_dettach(d);
> > > > +
> > > > +	xe_eudebug_event_log_destroy(d->log);
> > > > +	debugger_destroy_triggers(d);
> > > > +	free(d);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_attach:
> > > > + * @d: pointer to the debugger
> > > > + * @c: pointer to the client
> > > > + *
> > > > + * Opens the xe eu debugger connection to the process described by @c (c->pid)
> > > > + *
> > > > + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> > > > + */
> > > > +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
> > > > +			       struct xe_eudebug_client *c)
> > > > +{
> > > > +	int ret;
> > > > +
> > > > +	igt_assert_eq(d->fd, -1);
> > > > +	igt_assert_neq(c->pid, 0);
> > > > +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
> > > > +
> > > > +	if (ret < 0)
> > > > +		return ret;
> > > > +
> > > > +	d->fd = ret;
> > > > +	d->target_pid = c->pid;
> > > > +	d->p_client[0] = c->p_in[0];
> > > > +	d->p_client[1] = c->p_in[1];
> > > > +
> > > > +	igt_debug("debugger connected to %lu\n", d->target_pid);
> > > > +
> > > > +	return 0;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_dettach:
> > > > + * @d: pointer to the debugger
> > > > + *
> > > > + * Closes previously opened xe eu debugger connection. Asserts if
> > > > + * the debugger has active session.
> > > > + */
> > > > +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
> > > > +{
> > > > +	igt_assert(d->target_pid);
> > > > +	close(d->fd);
> > > > +	d->target_pid = 0;
> > > > +	d->fd = -1;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_add_trigger:
> > > > + * @d: pointer to the debugger
> > > > + * @type: the type of the event which activates the trigger
> > > > + * @fn: function to be called when event of @type was read by the debugger.
> > > > + *
> > > > + * Adds function @fn to the list of triggers activated when event of @type
> > > > + * has been read by worker.
> > > > + * Note: Triggers are activated by the worker.
> > > > + */
> > > > +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
> > > > +				     int type, xe_eudebug_trigger_fn fn)
> > > > +{
> > > > +	struct event_trigger *t;
> > > > +
> > > > +	t = calloc(1, sizeof(*t));
> > > > +	IGT_INIT_LIST_HEAD(&t->link);
> > > > +	t->type = type;
> > > > +	t->fn = fn;
> > > > +
> > > > +	igt_list_add_tail(&t->link, &d->triggers);
> > > > +	igt_debug("added trigger %p\n", t);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_start_worker:
> > > > + * @d: pointer to the debugger
> > > > + *
> > > > + * Starts the debugger worker. Worker is resposible for reading all
> > > > + * incoming events from the debugger, put then into debugger log and
> > > > + * execute appropriate event triggers. Note that using the debuggers
> > > > + * event log while worker is running is not safe.
> > > > + */
> > > > +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
> > > > +{
> > > > +	int ret;
> > > > +
> > > > +	d->worker_state = true;
> > > > +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
> > > > +
> > > > +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_stop_worker:
> > > > + * @d: pointer to the debugger
> > > > + *
> > > > + * Stops the debugger worker. Event log is sorted by seqno after closure.
> > > > + */
> > > > +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
> > > > +				     int timeout_s)
> > > > +{
> > > > +	struct timespec t = {};
> > > > +	int ret;
> > > > +
> > > > +	igt_assert(d->worker_state);
> > > > +
> > > > +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
> > > > +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
> > > > +	t.tv_sec += timeout_s;
> > > > +
> > > > +	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_assert_f(ret == 0 || ret != ESRCH,
> > > > +		     "pthread join failed with error %d!\n", ret);
> > > > +
> > > > +	event_log_sort(d->log);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_signal_stage:
> > > > + * @d: pointer to the debugger
> > > > + * @stage: stage to signal
> > > > + *
> > > > + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
> > > > + * releasing it to proceed.
> > > > + */
> > > > +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
> > > > +{
> > > > +	token_signal(d->p_client, CLIENT_STAGE, stage);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_debugger_wait_stage:
> > > > + * @s: pointer to xe_eudebug_debugger structure
> > > > + * @stage: stage to wait on
> > > > + *
> > > > + * Pauses debugger until the client has signalled the corresponding stage with
> > > > + * xe_eudebug_client_signal_stage. This is only for situations where the actual
> > > > + * event flow is not enough to coordinate between client/debugger and extra sync
> > > > + * mechanism is needed.
> > > > + */
> > > > +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
> > > > +{
> > > > +	u64 stage_in;
> > > > +
> > > > +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
> > > > +
> > > > +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
> > > > +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
> > > > +		  stage_in, stage);
> > > > +
> > > > +	igt_assert_eq(stage_in, stage);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_create:
> > > > + * @master_fd: xe client used to open the debugger connection
> > > > + * @work: function that opens xe device and executes arbitrary workload
> > > > + * @flags: flags stored in a client structure, can be used at will
> > > > + * of the caller, i.e. to provide the @work function an additional switch.
> > > > + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> > > > + * can be shared between client and debugger. Accesible via client->ptr.
> > > > + * Can be NULL.
> > > > + *
> > > > + * Forks and creates the debugger process. @work won't be called until
> > > > + * xe_eudebug_client_start is called.
> > > > + *
> > > > + * Returns: newly created xe_eudebug_debugger structure with its
> > > > + * event log initialized.
> > > > + */
> > > > +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
> > > > +						   uint64_t flags, void *data)
> > > > +{
> > > > +	struct xe_eudebug_client *c;
> > > > +
> > > > +	c = calloc(1, sizeof(*c));
> > > > +	c->flags = flags;
> > > > +	igt_assert(c);
> > > > +	igt_assert(!pipe(c->p_in));
> > > > +	igt_assert(!pipe(c->p_out));
> > > > +	c->seqno = 1;
> > > > +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
> > > > +	c->done = 0;
> > > > +	c->ptr = data;
> > > > +	c->master_fd = master_fd;
> > > > +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
> > > > +
> > > > +	igt_fork(child, 1) {
> > > > +		int mypid;
> > > > +
> > > > +		igt_assert_eq(c->pid, 0);
> > > > +
> > > > +		close(c->p_out[0]);
> > > > +		c->p_out[0] = -1;
> > > > +		close(c->p_in[1]);
> > > > +		c->p_in[1] = -1;
> > > > +
> > > > +		mypid = getpid();
> > > > +		client_signal(c, CLIENT_PID, mypid);
> > > > +
> > > > +		c->pid = client_wait_token(c, CLIENT_RUN);
> > > > +		igt_assert_eq(c->pid, mypid);
> > > > +		if (work)
> > > > +			work(c);
> > > > +
> > > > +		client_signal(c, CLIENT_FINI, c->seqno);
> > > > +
> > > > +		event_log_write_to_fd(c->log, c->p_out[1]);
> > > > +
> > > > +		c->pid = client_wait_token(c, CLIENT_STOP);
> > > > +		igt_assert_eq(c->pid, mypid);
> > > > +	}
> > > > +
> > > > +	close(c->p_out[1]);
> > > > +	c->p_out[1] = -1;
> > > > +	close(c->p_in[0]);
> > > > +	c->p_in[0] = -1;
> > > > +
> > > > +	c->pid = wait_from_client(c, CLIENT_PID);
> > > > +
> > > > +	igt_info("client running with pid %d\n", c->pid);
> > > > +
> > > > +	return c;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_stop:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + *
> > > > + * Waits for the end of client's work and exits the proccess.
> > > > + */
> > > > +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
> > > > +{
> > > > +	if (c->pid) {
> > > > +		int waitstatus;
> > > > +
> > > > +		xe_eudebug_client_wait_done(c);
> > > > +
> > > > +		token_signal(c->p_in, CLIENT_STOP, c->pid);
> > > > +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
> > > > +			      c->pid);
> > > > +		c->pid = 0;
> > > > +	}
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_destroy:
> > > > + * @c: pointer to xe_eudebug_client structure to be freed
> > > > + *
> > > > + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
> > > > + * client proccess has not terminated yet.
> > > > + */
> > > > +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
> > > > +{
> > > > +	xe_eudebug_client_stop(c);
> > > > +	pipe_close(c->p_in);
> > > > +	pipe_close(c->p_out);
> > > > +	xe_eudebug_event_log_destroy(c->log);
> > > > +	free(c);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_get_seqno:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + *
> > > > + * Increments and returns current seqno value of the given client @c
> > > > + *
> > > > + * Returns: incremented seqno
> > > > + */
> > > > +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
> > > > +{
> > > > +	return c->seqno++;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_start:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + *
> > > > + * Starts execution of client's work function within the client's proccess.
> > > > + */
> > > > +void xe_eudebug_client_start(struct xe_eudebug_client *c)
> > > > +{
> > > > +	token_signal(c->p_in, CLIENT_RUN, c->pid);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_wait_done:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + *
> > > > + * Waits for the client work end updates the event log.
> > > > + * Doesn't terminate the client's proccess yet.
> > > > + */
> > > > +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
> > > > +{
> > > > +	if (!c->done) {
> > > > +		c->done = 1;
> > > > +		c->seqno = wait_from_client(c, CLIENT_FINI);
> > > > +		event_log_read_from_fd(c->log, c->p_out[0]);
> > > > +	}
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_signal_stage:
> > > > + * @c: pointer to the client
> > > > + * @stage: stage to signal
> > > > + *
> > > > + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
> > > > + * releasing it to proceed.
> > > > + */
> > > > +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
> > > > +{
> > > > +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_wait_stage:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @stage: stage to wait on
> > > > + *
> > > > + * Pauses client until the debugger has signalled the corresponding stage with
> > > > + * xe_eudebug_debugger_signal_stage. This is only for situations where the
> > > > + * actual event flow is not enough to coordinate between client/debugger and extra
> > > > + * sync mechanism is needed.
> > > > + *
> > > > + */
> > > > +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
> > > > +{
> > > > +	u64 stage_in;
> > > > +
> > > > +	if (c->done) {
> > > > +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
> > > > +		return;
> > > > +	}
> > > > +
> > > > +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
> > > > +
> > > > +	stage_in = client_wait_token(c, CLIENT_STAGE);
> > > > +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
> > > > +
> > > > +	igt_assert_eq(stage_in, stage);
> > > > +}
> > > > +
> > > > +
> > > > +/**
> > > > + * xe_eudebug_session_create:
> > > > + * @fd: XE file descriptor
> > > > + * @work: function passed to the xe_eudebug_client_create
> > > > + * @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.
> > > > + *
> > > > + * Creates session together with client and debugger structures.
> > > > + */
> > > > +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
> > > > +						     xe_eudebug_client_work_fn work,
> > > > +						     unsigned int flags,
> > > > +						     void *test_private)
> > > > +{
> > > > +	struct xe_eudebug_session *s;
> > > > +
> > > > +	s = calloc(1, sizeof(*s));
> > > > +	igt_assert(s);
> > > > +
> > > > +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
> > > > +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
> > > > +	s->flags = flags;
> > > > +
> > > > +	return s;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_session_run:
> > > > + * @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.
> > > > + */
> > > > +void xe_eudebug_session_run(struct xe_eudebug_session *s)
> > > > +{
> > > > +	struct xe_eudebug_debugger *debugger = s->d;
> > > > +	struct xe_eudebug_client *client = s->c;
> > > > +
> > > > +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
> > > > +
> > > > +	xe_eudebug_debugger_start_worker(debugger);
> > > > +
> > > > +	xe_eudebug_client_start(client);
> > > > +	xe_eudebug_client_wait_done(client);
> > > > +
> > > > +	xe_eudebug_debugger_stop_worker(debugger, 1);
> > > > +
> > > > +	xe_eudebug_event_log_print(debugger->log, true);
> > > > +	xe_eudebug_event_log_print(client->log, true);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_session_check:
> > > > + * @s: pointer to xe_eudebug_session structure
> > > > + * @match_opposite: indicates whether check should match all
> > > > + * create and destroy events.
> > > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > > + * for events like 'VM_BIND' since they can be asymmetric
> > > > + *
> > > > + * Validate debugger's log against the log created by the client.
> > > > + */
> > > > +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
> > > > +{
> > > > +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
> > > > +
> > > > +	if (match_opposite)
> > > > +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_session_destroy:
> > > > + * @s: pointer to xe_eudebug_session structure
> > > > + *
> > > > + * Destroy session together with its debugger and client.
> > > > + */
> > > > +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
> > > > +{
> > > > +	xe_eudebug_debugger_destroy(s->d);
> > > > +	xe_eudebug_client_destroy(s->c);
> > > > +
> > > > +	free(s);
> > > > +}
> > > > +
> > > > +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
> > > > +
> > > > +static void base_event(struct xe_eudebug_client *c,
> > > > +		       struct drm_xe_eudebug_event *e,
> > > > +		       uint32_t type,
> > > > +		       uint32_t flags,
> > > > +		       uint64_t size)
> > > > +{
> > > > +	e->type = type;
> > > > +	e->flags = flags;
> > > > +	e->seqno = xe_eudebug_client_get_seqno(c);
> > > > +	e->len = size;
> > > > +}
> > > > +
> > > > +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_client ec;
> > > > +
> > > > +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
> > > > +
> > > > +	ec.client_handle = client_fd;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&ec);
> > > > +}
> > > > +
> > > > +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_vm evm;
> > > > +
> > > > +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
> > > > +
> > > > +	evm.client_handle = client_fd;
> > > > +	evm.vm_handle = vm_id;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&evm);
> > > > +}
> > > > +
> > > > +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
> > > > +			     int client_fd, uint32_t vm_id,
> > > > +			     uint32_t exec_queue_handle, uint16_t class,
> > > > +			     uint16_t width)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_exec_queue ee;
> > > > +
> > > > +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> > > > +		   flags, sizeof(ee));
> > > > +
> > > > +	ee.client_handle = client_fd;
> > > > +	ee.vm_handle = vm_id;
> > > > +	ee.exec_queue_handle = exec_queue_handle;
> > > > +	ee.engine_class = class;
> > > > +	ee.width = width;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&ee);
> > > > +}
> > > > +
> > > > +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
> > > > +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_metadata em;
> > > > +
> > > > +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
> > > > +		   flags, sizeof(em));
> > > > +
> > > > +	em.client_handle = client_fd;
> > > > +	em.metadata_handle = id;
> > > > +	em.type = type;
> > > > +	em.len = len;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&em);
> > > > +}
> > > > +
> > > > +static int enable_getset(int fd, bool *old, bool *new)
> > > > +{
> > > > +	static const char * const fname = "enable_eudebug";
> > > > +	int ret = 0;
> > > > +
> > > > +	int sysfs, device_fd;
> > > > +	bool val_before;
> > > > +	struct stat st;
> > > > +
> > > > +	igt_assert(new || old);
> > > > +
> > > > +	igt_assert_eq(fstat(fd, &st), 0);
> > > > +	sysfs = igt_sysfs_open(fd);
> > > > +	if (sysfs < 0)
> > > > +		return -1;
> > > > +
> > > > +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
> > > > +	close(sysfs);
> > > > +	if (device_fd < 0)
> > > > +		return -1;
> > > > +
> > > > +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
> > > > +		ret = -1;
> > > > +		goto out;
> > > > +	}
> > > > +
> > > > +	igt_debug("enable_eudebug before: %d\n", val_before);
> > > > +
> > > > +	if (old)
> > > > +		*old = val_before;
> > > > +
> > > > +	ret = 0;
> > > > +	if (new) {
> > > > +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
> > > > +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
> > > > +		else
> > > > +			ret = -1;
> > > > +	}
> > > > +
> > > > +out:
> > > > +	close(device_fd);
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_enable
> > > > + * @fd: xe client
> > > > + * @enable: state toggle - true to enable, false to disable
> > > > + *
> > > > + * Enables/disables eudebug capability by writing to
> > > > + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
> > > > + *
> > > > + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
> > > > + * false when eudebugging was disabled.
> > > > + */
> > > > +bool xe_eudebug_enable(int fd, bool enable)
> > > > +{
> > > > +	bool old = false;
> > > > +	int ret = enable_getset(fd, &old, &enable);
> > > > +
> > > > +	if (ret) {
> > > > +		igt_skip_on(enable);
> > > > +		old = false;
> > > > +	}
> > > > +
> > > > +	return old;
> > > > +}
> > > > +
> > > > +/* Eu debugger wrappers around resource creating xe ioctls. */
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_open_driver:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + *
> > > > + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
> > > > + * event in client's event log.
> > > > + *
> > > > + * Returns: valid DRM file descriptor
> > > > + */
> > > > +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
> > > > +{
> > > > +	int fd;
> > > > +
> > > > +	fd = drm_reopen_driver(c->master_fd);
> > > > +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
> > > > +
> > > > +	return fd;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_close_driver:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + *
> > > > + * Calls close driver and logs the corresponding event in
> > > > + * client's event log.
> > > > + */
> > > > +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
> > > > +{
> > > > +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
> > > > +	close(fd);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_create:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @flags: vm bind flags
> > > > + * @ext: pointer to the first user extension
> > > > + *
> > > > + * Calls xe_vm_create() and logs corresponding events
> > > > + * (including vm set metadata events) in client's event log.
> > > > + *
> > > > + * Returns: valid vm handle
> > > > + */
> > > > +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
> > > > +				     uint32_t flags, uint64_t ext)
> > > > +{
> > > > +	uint32_t vm;
> > > > +
> > > > +	vm = xe_vm_create(fd, flags, ext);
> > > > +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
> > > > +
> > > > +	return vm;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_destroy:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * fd: xe client
> > > > + * vm: vm handle
> > > > + *
> > > > + * Calls xe_vm_destroy() and logs the corresponding event in
> > > > + * client's event log.
> > > > + */
> > > > +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
> > > > +{
> > > > +	xe_vm_destroy(fd, vm);
> > > > +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_exec_queue_create:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @create: exec_queue create drm struct
> > > > + *
> > > > + * Calls xe exec queue create ioctl and logs the corresponding event in
> > > > + * client's event log.
> > > > + *
> > > > + * Returns: valid exec queue handle
> > > > + */
> > > > +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
> > > > +					     struct drm_xe_exec_queue_create *create)
> > > > +{
> > > > +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> > > > +
> > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
> > > > +
> > > > +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> > > > +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
> > > > +				 create->exec_queue_id, class, create->width);
> > > > +
> > > > +	return create->exec_queue_id;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_exec_queue_destroy:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @create: exec_queue create drm struct which was used for creation
> > > > + *
> > > > + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
> > > > + * client's event log.
> > > > + */
> > > > +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> > > > +					  struct drm_xe_exec_queue_create *create)
> > > > +{
> > > > +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
> > > > +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> > > > +
> > > > +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> > > > +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
> > > > +				 create->exec_queue_id, class, create->width);
> > > > +
> > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_bind_event:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @event_flags: base event flags
> > > > + * @fd: xe client
> > > > + * @vm: vm handle
> > > > + * @bind_flags: bind flags of vm_bind_event
> > > > + * @num_binds: 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, int fd,
> > > > +				     uint32_t vm, uint32_t bind_flags,
> > > > +				     uint32_t num_binds, u64 *ref_seqno)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_vm_bind evmb;
> > > > +
> > > > +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
> > > > +		   event_flags, sizeof(evmb));
> > > > +	evmb.client_handle = fd;
> > > > +	evmb.vm_handle = vm;
> > > > +	evmb.flags = bind_flags;
> > > > +	evmb.num_binds = num_binds;
> > > > +
> > > > +	*ref_seqno = evmb.base.seqno;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_bind_op_event:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @event_flags: base event flags
> > > > + * @bind_ref_seqno: base vm bind reference seqno
> > > > + * @op_ref_seqno: output, the vm_bind_op event seqno
> > > > + * @addr: ppgtt address
> > > > + * @size: size of the binding
> > > > + * @num_extensions: number of vm bind op extensions
> > > > + *
> > > > + * Logs vm bind op event in client's event log.
> > > > + */
> > > > +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
> > > > +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
> > > > +					uint64_t addr, uint64_t range,
> > > > +					uint64_t num_extensions)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_vm_bind_op op;
> > > > +
> > > > +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
> > > > +		   event_flags, sizeof(op));
> > > > +	op.vm_bind_ref_seqno = bind_ref_seqno;
> > > > +	op.addr = addr;
> > > > +	op.range = range;
> > > > +	op.num_extensions = num_extensions;
> > > > +
> > > > +	*op_ref_seqno = op.base.seqno;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&op);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_bind_op_metadata_event:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @event_flags: base event flags
> > > > + * @op_ref_seqno: base vm bind op reference seqno
> > > > + * @metadata_handle: metadata handle
> > > > + * @metadata_cookie: metadata cookie
> > > > + *
> > > > + * Logs vm bind op metadata event in client's event log.
> > > > + */
> > > > +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)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
> > > > +
> > > > +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
> > > > +		   event_flags, sizeof(op));
> > > > +	op.vm_bind_op_ref_seqno = op_ref_seqno;
> > > > +	op.metadata_handle = metadata_handle;
> > > > +	op.metadata_cookie = metadata_cookie;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&op);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_bind_ufence_event:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @event_flags: base event flags
> > > > + * @ref_seqno: base vm bind event seqno
> > > > + *
> > > > + * Logs vm bind ufence event in client's event log.
> > > > + */
> > > > +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
> > > > +					    uint64_t ref_seqno)
> > > > +{
> > > > +	struct drm_xe_eudebug_event_vm_bind_ufence f;
> > > > +
> > > > +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> > > > +		   event_flags, sizeof(f));
> > > > +	f.vm_bind_ref_seqno = ref_seqno;
> > > > +
> > > > +	xe_eudebug_event_log_write(c->log, (void *)&f);
> > > > +}
> > > > +
> > > > +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
> > > > +{
> > > > +	while (num_syncs--)
> > > > +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
> > > > +			return true;
> > > > +
> > > > +	return false;
> > > > +}
> > > > +
> > > > +#define for_each_metadata(__m, __ext)					\
> > > > +	for ((__m) = from_user_pointer(__ext);				\
> > > > +	     (__m);							\
> > > > +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
> > > > +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
> > > > +
> > > > +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
> > > > +					int fd, uint32_t vm, uint32_t exec_queue,
> > > > +					uint32_t bo, uint64_t offset,
> > > > +					uint64_t addr, uint64_t size,
> > > > +					uint32_t op, uint32_t flags,
> > > > +					struct drm_xe_sync *sync,
> > > > +					uint32_t num_syncs,
> > > > +					uint32_t prefetch_region,
> > > > +					uint8_t pat_index, uint64_t op_ext)
> > > > +{
> > > > +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
> > > > +	const bool ufence = has_user_fence(sync, num_syncs);
> > > > +	const uint32_t bind_flags = ufence ?
> > > > +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
> > > > +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
> > > > +	uint32_t bind_base_flags = 0;
> > > > +	int ret;
> > > > +
> > > > +	for_each_metadata(metadata, op_ext)
> > > > +		num_metadata++;
> > > > +
> > > > +	switch (op) {
> > > > +	case DRM_XE_VM_BIND_OP_MAP:
> > > > +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
> > > > +		break;
> > > > +	case DRM_XE_VM_BIND_OP_UNMAP:
> > > > +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > > +		igt_assert_eq(num_metadata, 0);
> > > > +		igt_assert_eq(ufence, false);
> > > > +		break;
> > > > +	default:
> > > > +		/* XXX unmap all? */
> > > > +		igt_assert(op);
> > > > +		break;
> > > > +	}
> > > > +
> > > > +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
> > > > +			    op, flags, sync, num_syncs, prefetch_region,
> > > > +			    pat_index, 0, op_ext);
> > > > +
> > > > +	if (ret)
> > > > +		return ret;
> > > > +
> > > > +	if (!bind_base_flags)
> > > > +		return -EINVAL;
> > > > +
> > > > +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
> > > > +					fd, vm, bind_flags, 1, &seqno);
> > > > +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
> > > > +					   seqno, &op_seqno, addr, size,
> > > > +					   num_metadata);
> > > > +
> > > > +	for_each_metadata(metadata, op_ext)
> > > > +		xe_eudebug_client_vm_bind_op_metadata_event(c,
> > > > +							    DRM_XE_EUDEBUG_EVENT_CREATE,
> > > > +							    op_seqno,
> > > > +							    metadata->metadata_id,
> > > > +							    metadata->cookie);
> > > > +	if (ufence)
> > > > +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
> > > > +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
> > > > +						       seqno);
> > > > +	return ret;
> > > > +}
> > > > +
> > > > +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
> > > > +				       uint32_t vm, uint32_t bo,
> > > > +				       uint64_t offset, uint64_t addr, uint64_t size,
> > > > +				       uint32_t op,
> > > > +				       uint32_t flags,
> > > > +				       struct drm_xe_sync *sync,
> > > > +				       uint32_t num_syncs,
> > > > +				       uint64_t op_ext)
> > > > +{
> > > > +	const uint32_t exec_queue_id = 0;
> > > > +	const uint32_t prefetch_region = 0;
> > > > +
> > > > +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
> > > > +						  addr, size, op, flags,
> > > > +						  sync, num_syncs, prefetch_region,
> > > > +						  DEFAULT_PAT_INDEX, op_ext),
> > > > +		      0);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_bind_flags
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @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, int fd, 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)
> > > > +{
> > > > +	_xe_eudebug_client_vm_bind(c, fd, 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
> > > > + * @fd: xe client
> > > > + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
> > > > +					flags,
> > > > +					sync, num_syncs, op_ext);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_vm_unbind_flags
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @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, int fd,
> > > > +				       uint32_t vm, uint64_t offset,
> > > > +				       uint64_t addr, uint64_t size, uint32_t flags,
> > > > +				       struct drm_xe_sync *sync, uint32_t num_syncs)
> > > > +{
> > > > +	_xe_eudebug_client_vm_bind(c, fd, 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
> > > > + * @fd: xe client
> > > > + * @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, int fd, 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, fd, vm, offset, addr, size,
> > > > +					  flags, sync, num_syncs);
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_metadata_create:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @type: debug metadata type
> > > > + * @len: size of @data
> > > > + * @data: debug metadata paylad
> > > > + *
> > > > + * Calls xe metadata create ioctl and logs the corresponding event in
> > > > + * client's event log.
> > > > + *
> > > > + * Return: valid debug metadata id.
> > > > + */
> > > > +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
> > > > +					   int type, size_t len, void *data)
> > > > +{
> > > > +	struct drm_xe_debug_metadata_create create = {
> > > > +		.type = type,
> > > > +		.user_addr = to_user_pointer(data),
> > > > +		.len = len
> > > > +	};
> > > > +
> > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
> > > > +
> > > > +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
> > > > +
> > > > +	return create.metadata_id;
> > > > +}
> > > > +
> > > > +/**
> > > > + * xe_eudebug_client_metadata_destroy:
> > > > + * @c: pointer to xe_eudebug_client structure
> > > > + * @fd: xe client
> > > > + * @id: xe debug metadata handle
> > > > + * @type: debug metadata type
> > > > + * @len: size of debug metadata payload
> > > > + *
> > > > + * Calls xe metadata destroy ioctl and logs the corresponding event in
> > > > + * client's event log.
> > > > + */
> > > > +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
> > > > +					uint32_t id, int type, size_t len)
> > > > +{
> > > > +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
> > > > +
> > > > +
> > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
> > > > +
> > > > +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
> > > > +}
> > > > +
> > > > +void xe_eudebug_ack_ufence(int debugfd,
> > > > +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
> > > > +{
> > > > +	struct drm_xe_eudebug_ack_event ack = { 0, };
> > > > +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> > > > +
> > > > +	ack.type = f->base.type;
> > > > +	ack.seqno = f->base.seqno;
> > > > +
> > > > +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> > > > +	igt_debug("delivering ack for event: %s\n", event_str);
> > > > +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
> > > > +}
> > > > diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
> > > > new file mode 100644
> > > > index 000000000..444f5a7b7
> > > > --- /dev/null
> > > > +++ b/lib/xe/xe_eudebug.h
> > > > @@ -0,0 +1,206 @@
> > > > +/* SPDX-License-Identifier: MIT */
> > > > +/*
> > > > + * Copyright © 2023 Intel Corporation
> > > > + */
> > > > +#include <fcntl.h>
> > > > +#include <pthread.h>
> > > > +#include <stdint.h>
> > > > +#include <xe_drm.h>
> > > > +
> > > > +#include "igt_list.h"
> > > > +
> > > > +struct xe_eudebug_event_log {
> > > > +	uint8_t *log;
> > > > +	unsigned int head;
> > > > +	unsigned int max_size;
> > > > +	char name[80];
> > > > +	pthread_mutex_t lock;
> > > > +};
> > > > +
> > > > +struct xe_eudebug_debugger {
> > > > +	int fd;
> > > > +	uint64_t flags;
> > > > +
> > > > +	/* Used to smuggle private data */
> > > > +	void *ptr;
> > > > +
> > > > +	struct xe_eudebug_event_log *log;
> > > > +
> > > > +	uint64_t event_count;
> > > > +
> > > > +	uint64_t target_pid;
> > > > +
> > > > +	struct igt_list_head triggers;
> > > > +
> > > > +	int master_fd;
> > > > +
> > > > +	pthread_t worker_thread;
> > > > +	int worker_state;
> > > > +
> > > > +	int p_client[2];
> > > > +};
> > > > +
> > > > +struct xe_eudebug_client {
> > > > +	int pid;
> > > > +	uint64_t seqno;
> > > > +	uint64_t flags;
> > > > +
> > > > +	/* Used to smuggle private data */
> > > > +	void *ptr;
> > > > +
> > > > +	struct xe_eudebug_event_log *log;
> > > > +
> > > > +	int done;
> > > > +	int p_in[2];
> > > > +	int p_out[2];
> > > > +
> > > > +	/* Used to pickup right device (the one used in debugger) */
> > > > +	int master_fd;
> > > > +
> > > > +	int timeout_ms;
> > > > +};
> > > > +
> > > > +struct xe_eudebug_session {
> > > > +	uint64_t flags;
> > > > +	struct xe_eudebug_client *c;
> > > > +	struct xe_eudebug_debugger *d;
> > > > +};
> > > > +
> > > > +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_event(_e, _log) \
> > > > +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
> > > > +		    (void *)(_log)->log; \
> > > > +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
> > > > +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
> > > > +
> > > > +#define xe_eudebug_assert(d, c)						\
> > > > +	do {								\
> > > > +		if (!(c)) {						\
> > > > +			xe_eudebug_event_log_print((d)->log, true);	\
> > > > +			igt_assert(c);					\
> > > > +		}							\
> > > > +	} while (0)
> > > > +
> > > > +#define xe_eudebug_assert_f(d, c, f...)					\
> > > > +	do {								\
> > > > +		if (!(c)) {						\
> > > > +			xe_eudebug_event_log_print((d)->log, true);	\
> > > > +			igt_assert_f(c, f);				\
> > > > +		}							\
> > > > +	} while (0)
> > > > +
> > > > +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
> > > > +
> > > > +/*
> > > > + * Default abort timeout to use across xe_eudebug lib and tests if no specific
> > > > + * timeout value is required.
> > > > + */
> > > > +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
> > > > +
> > > > +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
> > > > +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
> > > > +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
> > > > +
> > > > +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
> > > > +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);
> > > > +struct xe_eudebug_event_log *
> > > > +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
> > > > +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
> > > > +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
> > > > +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
> > > > +				  uint32_t filter);
> > > > +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
> > > > +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
> > > > +
> > > > +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_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, int timeout_s);
> > > > +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
> > > > +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
> > > > +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
> > > > +				     xe_eudebug_trigger_fn fn);
> > > > +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
> > > > +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
> > > > +
> > > > +struct xe_eudebug_client *
> > > > +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
> > > > +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
> > > > +void xe_eudebug_client_start(struct xe_eudebug_client *c);
> > > > +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
> > > > +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
> > > > +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
> > > > +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
> > > > +
> > > > +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
> > > > +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
> > > > +
> > > > +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 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,
> > > > +					     struct drm_xe_exec_queue_create *create);
> > > > +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> > > > +					  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,
> > > > +				     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,
> > > > +					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,
> > > > +			   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,
> > > > +				     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,
> > > > +			       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,
> > > > +				       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,
> > > > +				 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,
> > > > +						     void *test_private);
> > > > +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
> > > > +void xe_eudebug_session_run(struct xe_eudebug_session *s);
> > > > +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
> > > > -- 
> > > > 2.34.1
> > > > 

Re: [PATCH i-g-t v3 11/14] tests/xe_exec_sip: Extend SIP interaction testing

[Zbigniew Kempczyński]

On Fri, Aug 09, 2024 at 02:38:10PM +0200, Christoph Manszewski wrote:
> Extend xe_exec_sip test by adding subtests that check SIP interaction
> sanity with regard to resets and hardware debugging capabilities like
> breakpoints, and invalid instruction exceptions.
> 
> Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> Signed-off-by: Dominik Karol Piątkowski <dominik.karol.piatkowski@intel.com>
> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> Signed-off-by: Andrzej Hajda <andrzej.hajda@intel.com>
> ---
>  tests/intel/xe_exec_sip.c | 332 +++++++++++++++++++++++++++++++++++---
>  1 file changed, 310 insertions(+), 22 deletions(-)
> 
> diff --git a/tests/intel/xe_exec_sip.c b/tests/intel/xe_exec_sip.c
> index 4b599e7f6..0db0dc4b8 100644
> --- a/tests/intel/xe_exec_sip.c
> +++ b/tests/intel/xe_exec_sip.c
> @@ -21,6 +21,7 @@
>  #include "gpgpu_shader.h"
>  #include "igt.h"
>  #include "igt_sysfs.h"
> +#include "xe/xe_eudebug.h"
>  #include "xe/xe_ioctl.h"
>  #include "xe/xe_query.h"
>  
> @@ -30,9 +31,29 @@
>  #define COLOR_C4 0xc4
>  
>  #define SHADER_CANARY 0x01010101
> +#define SIP_CANARY 0x02020202
>  
>  #define NSEC_PER_MSEC (1000 * 1000ull)
>  
> +#define SHADER_BREAKPOINT 0
> +#define SHADER_WRITE 1
> +#define SHADER_WAIT 2
> +#define SHADER_INV_INSTR_DISABLED 3
> +#define SHADER_INV_INSTR_THREAD_ENABLED 4
> +#define SHADER_INV_INSTR_WALKER_ENABLED 5
> +#define SHADER_HANG 6
> +#define SIP_WRITE 7
> +#define SIP_NULL 8
> +#define SIP_WAIT 9
> +#define SIP_HEAVY 10
> +#define SIP_INV_INSTR 11
> +
> +#define F_SUBMIT_TWICE	(1 << 0)
> +
> +/* Control Register cr0.1 bits for exception handling */
> +#define ILLEGAL_OPCODE_ENABLE BIT(12)
> +#define ILLEGAL_OPCODE_STATUS BIT(28)
> +
>  static struct intel_buf *
>  create_fill_buf(int fd, int width, int height, uint8_t color)
>  {
> @@ -52,24 +73,109 @@ create_fill_buf(int fd, int width, int height, uint8_t color)
>  	return buf;
>  }
>  
> -static struct gpgpu_shader *get_shader(int fd)
> +static struct gpgpu_shader *get_shader(int fd, const int shadertype)
>  {
>  	static struct gpgpu_shader *shader;
> +	uint32_t bad;
>  
>  	shader = gpgpu_shader_create(fd);
> +	if (shadertype == SHADER_INV_INSTR_WALKER_ENABLED)
> +		shader->illegal_opcode_exception_enable = true;
> +
>  	gpgpu_shader__write_dword(shader, SHADER_CANARY, 0);
> +
> +	switch (shadertype) {
> +	case SHADER_HANG:
> +		gpgpu_shader__label(shader, 0);
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__jump(shader, 0);
> +		break;
> +	case SHADER_WAIT:
> +		gpgpu_shader__wait(shader);
> +		break;
> +	case SHADER_WRITE:
> +		break;
> +	case SHADER_BREAKPOINT:
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__breakpoint(shader);
> +		break;
> +	case SHADER_INV_INSTR_THREAD_ENABLED:
> +		gpgpu_shader__set_exception(shader, ILLEGAL_OPCODE_ENABLE);
> +		/* fall through */
> +	case SHADER_INV_INSTR_DISABLED:
> +	case SHADER_INV_INSTR_WALKER_ENABLED:
> +		bad = (shadertype == SHADER_INV_INSTR_DISABLED) ? ILLEGAL_OPCODE_ENABLE : 0;
> +		gpgpu_shader__write_on_exception(shader, 1, 0, ILLEGAL_OPCODE_ENABLE, bad);
> +		gpgpu_shader__nop(shader);
> +		gpgpu_shader__nop(shader);
> +		/* modify second nop, set only opcode bits[6:0] */
> +		shader->instr[shader->size/4 - 1][0] = 0x7f;
> +		/* SIP should clear exception bit */
> +		bad = ILLEGAL_OPCODE_STATUS;
> +		gpgpu_shader__write_on_exception(shader, 2, 0, ILLEGAL_OPCODE_STATUS, bad);
> +		break;
> +	}
> +
>  	gpgpu_shader__eot(shader);
>  	return shader;
>  }
>  
> -static uint32_t gpgpu_shader(int fd, struct intel_bb *ibb, unsigned int threads,
> -			     unsigned int width, unsigned int height)
> +static struct gpgpu_shader *get_sip(int fd, const int siptype,
> +				    const int shadertype, unsigned int y_offset)
> +{
> +	static struct gpgpu_shader *sip;
> +
> +	if (siptype == SIP_NULL)
> +		return NULL;
> +
> +	sip = gpgpu_shader_create(fd);
> +	gpgpu_shader__write_dword(sip, SIP_CANARY, y_offset);
> +
> +	switch (siptype) {
> +	case SIP_WRITE:
> +		break;
> +	case SIP_WAIT:
> +		gpgpu_shader__wait(sip);
> +		break;
> +	case SIP_HEAVY:
> +		/* Depending on the generation, the production sip
> +		 * executes between 145 to 157 instructions.
> +		 * It performs at most 45 data port writes and 5 data port reads.
> +		 * Make sure our heavy sip is at least twice heavy as production one.
> +		 */
> +		gpgpu_shader__loop_begin(sip, 0);
> +		gpgpu_shader__write_dword(sip, 0xdeadbeef, y_offset);
> +		gpgpu_shader__write_dword(sip, SIP_CANARY, y_offset);
> +		gpgpu_shader__loop_end(sip, 0, 45);
> +
> +		gpgpu_shader__loop_begin(sip, 1);
> +		gpgpu_shader__jump_neq(sip, 1, y_offset, SIP_CANARY);
> +		gpgpu_shader__loop_end(sip, 1, 10);
> +
> +		gpgpu_shader__wait(sip);
> +		break;
> +	case SIP_INV_INSTR:
> +		gpgpu_shader__write_on_exception(sip, 1, y_offset, ILLEGAL_OPCODE_STATUS, 0);
> +		break;
> +	}
> +
> +	gpgpu_shader__end_system_routine(sip, shadertype == SHADER_BREAKPOINT);
> +	return sip;
> +}
> +
> +static uint32_t gpgpu_shader(int fd, struct intel_bb *ibb, const int shadertype, const int siptype,
> +			     unsigned int threads, unsigned int width, unsigned int height)
>  {
>  	struct intel_buf *buf = create_fill_buf(fd, width, height, COLOR_C4);
> -	struct gpgpu_shader *shader = get_shader(fd);
> +	struct gpgpu_shader *sip = get_sip(fd, siptype, shadertype, height / 2);
> +	struct gpgpu_shader *shader = get_shader(fd, shadertype);
>  
> -	gpgpu_shader_exec(ibb, buf, 1, threads, shader, NULL, 0, 0);
> +	gpgpu_shader_exec(ibb, buf, 1, threads, shader, sip, 0, 0);
> +
> +	if (sip)
> +		gpgpu_shader_destroy(sip);
>  	gpgpu_shader_destroy(shader);
> +
>  	return buf->handle;
>  }
>  
> @@ -83,11 +189,11 @@ static void check_fill_buf(uint8_t *ptr, const int width, const int x,
>  		     color, val, x, y);
>  }
>  
> -static void check_buf(int fd, uint32_t handle, int width, int height,
> -		      uint8_t poison_c)
> +static int check_buf(int fd, uint32_t handle, int width, int height,
> +		      int shadertype, int siptype, uint8_t poison_c)
>  {
>  	unsigned int sz = ALIGN(width * height, 4096);
> -	int thread_count = 0;
> +	int thread_count = 0, sip_count = 0;
>  	uint32_t *ptr;
>  	int i, j;
>  
> @@ -105,9 +211,87 @@ static void check_buf(int fd, uint32_t handle, int width, int height,
>  		i = 0;
>  	}
>  
> +	for (i = 0, j = height / 2; j < height; ++j) {
> +		if (ptr[j * width / 4] == SIP_CANARY) {
> +			++sip_count;
> +			i = 4;
> +		}
> +
> +		for (; i < width; i++)
> +			check_fill_buf((uint8_t *)ptr, width, i, j, poison_c);
> +
> +		i = 0;
> +	}
> +
>  	igt_assert(thread_count);
> +	if (shadertype == SHADER_INV_INSTR_DISABLED)
> +		igt_assert(!sip_count);
> +	else if ((siptype != SIP_NULL && xe_eudebug_debugger_available(fd)) ||
> +		 (siptype == SIP_INV_INSTR && shadertype != SHADER_INV_INSTR_DISABLED))
> +		igt_assert_f(thread_count == sip_count,
> +			     "Thread and SIP count mismatch, %d != %d\n",
> +			     thread_count, sip_count);
> +	else
> +		igt_assert(sip_count == 0);
>  
>  	munmap(ptr, sz);
> +
> +	return sip_count;
> +}
> +
> +#define USERCOREDUMP_FORMAT "usercoredumps/%d/%d"
> +static char *get_latest_usercoredump(int dir)
> +{
> +	char tmp[256];
> +	int i = 1;
> +
> +	do {
> +		snprintf(tmp, sizeof(tmp), USERCOREDUMP_FORMAT, getpid(), i++);
> +	} while (igt_sysfs_has_attr(dir, tmp));
> +
> +	snprintf(tmp, sizeof(tmp), USERCOREDUMP_FORMAT, getpid(), i-2);
> +	return igt_sysfs_get(dir, tmp);
> +}
> +
> +static void check_usercoredump(int fd, int sip, int dispatched)
> +{
> +	int dir = igt_debugfs_dir(fd);
> +	char *usercoredump, *str;
> +	unsigned int before, after;
> +	char match[256];
> +
> +	if (sip != SIP_WAIT && sip != SIP_HEAVY)
> +		return;
> +
> +	/* XXX reinstate when offline coredumps are implemented */
> +#ifndef XXX_ATTENTIONS_THROUGH_COREDUMPS
> +	return;
> +#endif
> +	usercoredump = get_latest_usercoredump(dir);
> +	igt_assert(usercoredump);
> +	igt_debug("%s\n", usercoredump);
> +
> +	snprintf(match, sizeof(match), "PID: %d", getpid());
> +	str = strstr(usercoredump, match);
> +	igt_assert(str);
> +
> +	snprintf(match, sizeof(match), "Comm: %s", igt_test_name());
> +	str = strstr(str, match);
> +	igt_assert(str);
> +
> +	str = strstr(str, "TD_ATT");
> +	igt_assert(str);
> +	igt_assert_eq(sscanf(str, "TD_ATT before (%d):", &before), 1);
> +	str = strstr(str + 1, "TD_ATT");
> +	igt_assert_eq(sscanf(str, "TD_ATT after (%d):", &after), 1);
> +
> +	igt_info("attentions %d before, %d after\n", before, after);
> +
> +	igt_assert_eq(before, dispatched);
> +	igt_assert_eq(after, dispatched);
> +
> +	free(usercoredump);
> +	close(dir);
>  }
>  
>  static uint64_t
> @@ -128,17 +312,58 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)
>   * Description: check basic shader with write operation
>   * Run type: BAT
>   *
> + * SUBTEST: sanity-after-timeout
> + * Description: check basic shader execution after job timeout
> + *
> + * SUBTEST: wait-writesip-nodebug
> + * Description: verify that we don't enter SIP after wait with debugging disabled.
> + *
> + * SUBTEST: invalidinstr-disabled
> + * Description: Verify that we don't enter SIP after running into an invalid
> + *		instruction when exception is not enabled.
> + *
> + * SUBTEST: invalidinstr-thread-enabled
> + * Description: Verify that we enter SIP after running into an invalid instruction
> + *              when exception is enabled from thread.
> + *
> + * SUBTEST: invalidinstr-walker-enabled
> + * Description: Verify that we enter SIP after running into an invalid instruction
> + *              when exception is enabled from COMPUTE_WALKER.
> + *
> + * SUBTEST: breakpoint-writesip-nodebug
> + * Description: verify that we don't enter SIP after hitting breakpoint in shader
> + *		when debugging is disabled.
> + *
> + * SUBTEST: breakpoint-writesip
> + * Description: Test that we enter SIP after hitting breakpoint in shader.
> + *
> + * SUBTEST: breakpoint-writesip-twice
> + * Description: Test twice that we enter SIP after hitting breakpoint in shader.
> + *
> + * SUBTEST: breakpoint-waitsip
> + * Description: Test that we reset after seeing the attention without the debugger.
> + *
> + * SUBTEST: breakpoint-waitsip-heavy
> + * Description:
> + *	Test that we reset after seeing the attention from heavy SIP, that resembles
> + *	the production one, without the debugger.
>   */
> -static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags)
> +static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *eci, uint32_t flags)
>  {
>  	unsigned int threads = 512;
>  	unsigned int height = max_t(threads, HEIGHT, threads * 2);
> -	uint32_t exec_queue_id, handle, vm_id;
>  	unsigned int width = WIDTH;
> +	struct drm_xe_ext_set_property ext = {
> +		.base.name = DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,
> +		.property = DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG,
> +		.value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE,
> +	};
>  	struct timespec ts = { };
> -	uint64_t timeout;
> +	int done = 0;
> +	uint32_t exec_queue_id, handle, vm_id;
>  	struct intel_bb *ibb;
> -	int fd;
> +	uint64_t timeout;
> +	int dispatched, fd;
>  
>  	igt_debug("Using %s\n", xe_engine_class_string(eci->engine_class));
>  
> @@ -152,19 +377,24 @@ static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags)
>  	timeout *= NSEC_PER_MSEC;
>  	timeout *= igt_run_in_simulation() ? 10 : 1;
>  
> -	exec_queue_id = xe_exec_queue_create(fd, vm_id, eci, 0);
> -	ibb = intel_bb_create_with_context(fd, exec_queue_id, vm_id, NULL, 4096);
> +	exec_queue_id = xe_exec_queue_create(fd, vm_id, eci,
> +					     xe_eudebug_debugger_available(fd) ?
> +					     to_user_pointer(&ext) : 0);
> +	do {
> +		ibb = intel_bb_create_with_context(fd, exec_queue_id, vm_id, NULL, 4096);
>  
> -	igt_nsec_elapsed(&ts);
> -	handle = gpgpu_shader(fd, ibb, threads, width, height);
> +		igt_nsec_elapsed(&ts);
> +		handle = gpgpu_shader(fd, ibb, shader, sip, threads, width, height);
>  
> -	intel_bb_sync(ibb);
> -	igt_assert_lt_u64(igt_nsec_elapsed(&ts), timeout);
> +		intel_bb_sync(ibb);
> +		igt_assert_lt_u64(igt_nsec_elapsed(&ts), timeout);
>  
> -	check_buf(fd, handle, width, height, COLOR_C4);
> +		dispatched = check_buf(fd, handle, width, height, shader, sip, COLOR_C4);
> +		check_usercoredump(fd, sip, dispatched);
>  
> -	gem_close(fd, handle);
> -	intel_bb_destroy(ibb);
> +		gem_close(fd, handle);
> +		intel_bb_destroy(ibb);
> +	} while (!done++ && (flags & F_SUBMIT_TWICE));
>  
>  	xe_exec_queue_destroy(fd, exec_queue_id);
>  	xe_vm_destroy(fd, vm_id);
> @@ -183,13 +413,71 @@ static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags)
>  igt_main
>  {
>  	struct drm_xe_engine_class_instance *eci;
> +	bool was_enabled;
>  	int fd;
>  
>  	igt_fixture
>  		fd = drm_open_driver(DRIVER_XE);
>  
>  	test_render_and_compute("sanity", fd, eci)
> -		test_sip(eci, 0);
> +		test_sip(SHADER_WRITE, SIP_NULL, eci, 0);
> +
> +	test_render_and_compute("sanity-after-timeout", fd, eci) {
> +		test_sip(SHADER_HANG, SIP_NULL, eci, 0);
> +
> +		xe_for_each_engine(fd, eci)
> +			if (eci->engine_class == DRM_XE_ENGINE_CLASS_RENDER ||
> +			    eci->engine_class == DRM_XE_ENGINE_CLASS_COMPUTE)
> +				test_sip(SHADER_WRITE, SIP_NULL, eci, 0);
> +	}
> +
> +	/* Debugger disabled (TD_CTL not set) */
> +	igt_subtest_group {
> +		igt_fixture {
> +			was_enabled = xe_eudebug_enable(fd, false);
> +			igt_require(!xe_eudebug_debugger_available(fd));
> +		}
> +
> +		test_render_and_compute("wait-writesip-nodebug", fd, eci)
> +			test_sip(SHADER_WAIT, SIP_WRITE, eci, 0);
> +
> +		test_render_and_compute("invalidinstr-disabled", fd, eci)
> +			test_sip(SHADER_INV_INSTR_DISABLED, SIP_INV_INSTR, eci, 0);
> +
> +		test_render_and_compute("invalidinstr-thread-enabled", fd, eci)
> +			test_sip(SHADER_INV_INSTR_THREAD_ENABLED, SIP_INV_INSTR, eci, 0);
> +
> +		test_render_and_compute("invalidinstr-walker-enabled", fd, eci)
> +			test_sip(SHADER_INV_INSTR_WALKER_ENABLED, SIP_INV_INSTR, eci, 0);
> +
> +		test_render_and_compute("breakpoint-writesip-nodebug", fd, eci)
> +			test_sip(SHADER_BREAKPOINT, SIP_WRITE, eci, 0);
> +
> +		igt_fixture
> +			xe_eudebug_enable(fd, was_enabled);
> +	}
> +
> +	/* Debugger enabled (TD_CTL set) */
> +	igt_subtest_group {
> +		igt_fixture {
> +			was_enabled = xe_eudebug_enable(fd, true);

Shouldn't this require the debugger to be available?

--
Zbigniew

> +		}
> +
> +		test_render_and_compute("breakpoint-writesip", fd, eci)
> +			test_sip(SHADER_BREAKPOINT, SIP_WRITE, eci, 0);
> +
> +		test_render_and_compute("breakpoint-writesip-twice", fd, eci)
> +			test_sip(SHADER_BREAKPOINT, SIP_WRITE, eci, F_SUBMIT_TWICE);
> +
> +		test_render_and_compute("breakpoint-waitsip", fd, eci)
> +			test_sip(SHADER_BREAKPOINT, SIP_WAIT, eci, 0);
> +
> +		test_render_and_compute("breakpoint-waitsip-heavy", fd, eci)
> +			test_sip(SHADER_BREAKPOINT, SIP_HEAVY, eci, 0);
> +
> +		igt_fixture
> +			xe_eudebug_enable(fd, was_enabled);
> +	}
>  
>  	igt_fixture
>  		drm_close_driver(fd);
> -- 
> 2.34.1
> 

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Kamil Konieczny]

Hi Zbigniew,
On 2024-08-21 at 11:31:40 +0200, Zbigniew Kempczyński wrote:
> On Tue, Aug 20, 2024 at 07:45:18PM +0200, Kamil Konieczny wrote:
> > Hi Manszewski,,
> > On 2024-08-20 at 18:14:07 +0200, Manszewski, Christoph wrote:
> > > Hi Zbigniew,
> > > 
> > > On 20.08.2024 10:14, Zbigniew Kempczyński wrote:
> > > > On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
> > > > > From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> > > > > 
> > > > > Introduce library which simplifies testing of eu debug capability.
> > > > > The library provides event log helpers together with asynchronous
> > > > > abstraction for client proccess and the debugger itself.
> > > > > 
> > > > > xe_eudebug_client creates its own proccess with user's work function,
> > > > > and gives machanisms to synchronize beginning of execution and event
> > > > > logging.
> > > > > 
> > > > > xe_eudebug_debugger allows to attach to the given proccess, provides
> > > > > asynchronous thread for event reading and introduces triggers -
> > > > > a callback mechanism triggered every time subscribed event was read.
> > > > > 
> > > > > Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
> > > > > Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
> > > > > Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
> > > > > Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
> > > > > Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
> > > > > Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
> > > > > ---
> > > > >   lib/meson.build     |    1 +
> > > > >   lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
> > > > >   lib/xe/xe_eudebug.h |  206 ++++
> > > > >   3 files changed, 2399 insertions(+)
> > > > >   create mode 100644 lib/xe/xe_eudebug.c
> > > > >   create mode 100644 lib/xe/xe_eudebug.h
> > > > > 
> > > > > diff --git a/lib/meson.build b/lib/meson.build
> > > > > index f711e60a7..969ca4101 100644
> > > > > --- a/lib/meson.build
> > > > > +++ b/lib/meson.build
> > > > > @@ -111,6 +111,7 @@ lib_sources = [
> > > > >   	'igt_msm.c',
> > > > >   	'igt_dsc.c',
> > > > >   	'xe/xe_gt.c',
> > > > > +	'xe/xe_eudebug.c',
> > > > >   	'xe/xe_ioctl.c',
> > > > >   	'xe/xe_mmio.c',
> > > > >   	'xe/xe_query.c',
> > > > 
> > > > As eudebug is quite big feature I think it should be separated and
> > > > hidden behind a feature flag (check meson_options.txt), lets say
> > > > 'xe_eudebug' which would be disabled by default. This way you can
> > > > develop it upstream even if kernel side is not officially merged.
> > > > I'm pragramatic and I see no reason to block not accepted feature
> > > > especially this would imo speed up developement. A final step when
> > > > kernel change would be accepted and merged would be to sync with
> > > > uapi and remove local definitions.
> > > > 
> > > > I look forward maintainers comments is my attitude acceptable.
> > > 
> > > I agree that it is a good idea. The only problem that arises is for
> > > 'xe_exec_sip'. We add a dependency on eudebug to this test - any ideas how
> > > to approach this correctly? The only thing that comes to my mind is
> > > conditional compilation with 'ifdef' statements but it doesn't appear to be
> > > pretty.
> > 
> > What about adding skips in added tests if kernel do not support eudebug?
> > 
> > This way you can have it without conditional compilation with
> > ifdef/meson and also have it compile-time tested (if CI support test-with
> > for Xe kernels).
> 
> IMO simplest is to migrate code to xe_exec_sip_eudebug.c.
> 

What about shorter name like xe_eudebug_sip.c ?

Regards,
Kamil

> --
> Zbigniew
> 
> 
> > 
> > Regards,
> > Kamil
> > 
> > > 
> > > Thanks,
> > > Christoph
> > > > 
> > > > --
> > > > Zbigniew
> > > > 
> > > > 
> > > > > diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
> > > > > new file mode 100644
> > > > > index 000000000..4eac87476
> > > > > --- /dev/null
> > > > > +++ b/lib/xe/xe_eudebug.c
> > > > > @@ -0,0 +1,2192 @@
> > > > > +// SPDX-License-Identifier: MIT
> > > > > +/*
> > > > > + * Copyright © 2023 Intel Corporation
> > > > > + */
> > > > > +
> > > > > +#include <fcntl.h>
> > > > > +#include <poll.h>
> > > > > +#include <signal.h>
> > > > > +#include <sys/select.h>
> > > > > +#include <sys/stat.h>
> > > > > +#include <sys/types.h>
> > > > > +#include <sys/wait.h>
> > > > > +
> > > > > +#include "igt.h"
> > > > > +#include "igt_sysfs.h"
> > > > > +#include "intel_pat.h"
> > > > > +#include "xe_eudebug.h"
> > > > > +#include "xe_ioctl.h"
> > > > > +
> > > > > +struct event_trigger {
> > > > > +	xe_eudebug_trigger_fn fn;
> > > > > +	int type;
> > > > > +	struct igt_list_head link;
> > > > > +};
> > > > > +
> > > > > +struct seqno_list_entry {
> > > > > +	struct igt_list_head link;
> > > > > +	uint64_t seqno;
> > > > > +};
> > > > > +
> > > > > +struct match_dto {
> > > > > +	struct drm_xe_eudebug_event *target;
> > > > > +	struct igt_list_head *seqno_list;
> > > > > +	uint64_t client_handle;
> > > > > +	uint32_t filter;
> > > > > +
> > > > > +	/* store latest 'EVENT_VM_BIND' seqno */
> > > > > +	uint64_t *bind_seqno;
> > > > > +	/* latest vm_bind_op seqno matching bind_seqno */
> > > > > +	uint64_t *bind_op_seqno;
> > > > > +};
> > > > > +
> > > > > +#define CLIENT_PID  1
> > > > > +#define CLIENT_RUN  2
> > > > > +#define CLIENT_FINI 3
> > > > > +#define CLIENT_STOP 4
> > > > > +#define CLIENT_STAGE 5
> > > > > +#define DEBUGGER_STAGE 6
> > > > > +
> > > > > +#define DEBUGGER_WORKER_INACTIVE  0
> > > > > +#define DEBUGGER_WORKER_ACTIVE  1
> > > > > +#define DEBUGGER_WORKER_QUITTING 2
> > > > > +
> > > > > +static const char *type_to_str(unsigned int type)
> > > > > +{
> > > > > +	switch (type) {
> > > > > +	case DRM_XE_EUDEBUG_EVENT_NONE:
> > > > > +		return "none";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_READ:
> > > > > +		return "read";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN:
> > > > > +		return "client";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM:
> > > > > +		return "vm";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
> > > > > +		return "exec_queue";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
> > > > > +		return "attention";
> > > > > +	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_UFENCE:
> > > > > +		return "vm_bind_ufence";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA:
> > > > > +		return "metadata";
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
> > > > > +		return "vm_bind_op_metadata";
> > > > > +	}
> > > > > +
> > > > > +	return "UNKNOWN";
> > > > > +}
> > > > > +
> > > > > +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
> > > > > +{
> > > > > +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
> > > > > +
> > > > > +	return buf;
> > > > > +}
> > > > > +
> > > > > +static const char *flags_to_str(unsigned int flags)
> > > > > +{
> > > > > +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > > > +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
> > > > > +			return "create|ack";
> > > > > +		else
> > > > > +			return "create";
> > > > > +	}
> > > > > +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
> > > > > +		return "destroy";
> > > > > +
> > > > > +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
> > > > > +		return "state-change";
> > > > > +
> > > > > +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
> > > > > +
> > > > > +	return "flags unknown";
> > > > > +}
> > > > > +
> > > > > +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
> > > > > +{
> > > > > +	switch (e->type) {
> > > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > > > +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
> > > > > +
> > > > > +		sprintf(b, "handle=%llu", ec->client_handle);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > > > +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
> > > > > +
> > > > > +		sprintf(b, "client_handle=%llu, handle=%llu",
> > > > > +			evm->client_handle, evm->vm_handle);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > > +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
> > > > > +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
> > > > > +			ee->client_handle, ee->vm_handle,
> > > > > +			ee->exec_queue_handle, ee->engine_class, ee->width);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
> > > > > +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
> > > > > +			   "lrc_handle=%llu, bitmask_size=%d",
> > > > > +			ea->client_handle, ea->exec_queue_handle,
> > > > > +			ea->lrc_handle, ea->bitmask_size);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
> > > > > +			evmb->client_handle, 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 = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
> > > > > +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
> > > > > +			em->client_handle, em->metadata_handle, em->type, em->len);
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
> > > > > +
> > > > > +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
> > > > > +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
> > > > > +		break;
> > > > > +	}
> > > > > +	default:
> > > > > +		strcpy(b, "<...>");
> > > > > +	}
> > > > > +
> > > > > +	return b;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_to_str:
> > > > > + * @e: pointer to event
> > > > > + * @buf: target to write string representation of @e
> > > > > + * @len: size of target buffer @buf
> > > > > + *
> > > > > + * Creates string representation for given event.
> > > > > + *
> > > > > + * Returns: the written input buffer pointed by @buf.
> > > > > + */
> > > > > +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
> > > > > +{
> > > > > +	char a[256];
> > > > > +	char b[256];
> > > > > +
> > > > > +	snprintf(buf, len, "(%llu) %15s:%s: %s",
> > > > > +		 e->seqno,
> > > > > +		 event_type_to_str(e, a),
> > > > > +		 flags_to_str(e->flags),
> > > > > +		 event_members_to_str(e, b));
> > > > > +
> > > > > +	return buf;
> > > > > +}
> > > > > +
> > > > > +static void catch_child_failure(void)
> > > > > +{
> > > > > +	pid_t pid;
> > > > > +	int status;
> > > > > +
> > > > > +	pid = waitpid(-1, &status, WNOHANG);
> > > > > +
> > > > > +	if (pid == 0 || pid == -1)
> > > > > +		return;
> > > > > +
> > > > > +	if (!WIFEXITED(status))
> > > > > +		return;
> > > > > +
> > > > > +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
> > > > > +}
> > > > > +
> > > > > +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
> > > > > +{
> > > > > +	int ret;
> > > > > +	int t = 0;
> > > > > +	struct pollfd fd = {
> > > > > +		.fd = pipe[0],
> > > > > +		.events = POLLIN,
> > > > > +		.revents = 0
> > > > > +	};
> > > > > +
> > > > > +	/* When child fails we may get stuck forever. Check whether
> > > > > +	 * the child process ended with an error.
> > > > > +	 */
> > > > > +	do {
> > > > > +		const int interval_ms = 1000;
> > > > > +
> > > > > +		ret = poll(&fd, 1, interval_ms);
> > > > > +
> > > > > +		if (!ret) {
> > > > > +			catch_child_failure();
> > > > > +			t += interval_ms;
> > > > > +		}
> > > > > +	} while (!ret && t < timeout_ms);
> > > > > +
> > > > > +	if (ret > 0)
> > > > > +		return read(pipe[0], buf, nbytes);
> > > > > +
> > > > > +	return 0;
> > > > > +}
> > > > > +
> > > > > +static uint64_t pipe_read(int pipe[2], int timeout_ms)
> > > > > +{
> > > > > +	uint64_t in;
> > > > > +	uint64_t ret;
> > > > > +
> > > > > +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
> > > > > +	igt_assert(ret == sizeof(in));
> > > > > +
> > > > > +	return in;
> > > > > +}
> > > > > +
> > > > > +static void pipe_signal(int pipe[2], uint64_t token)
> > > > > +{
> > > > > +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
> > > > > +}
> > > > > +
> > > > > +static void pipe_close(int pipe[2])
> > > > > +{
> > > > > +	if (pipe[0] != -1)
> > > > > +		close(pipe[0]);
> > > > > +
> > > > > +	if (pipe[1] != -1)
> > > > > +		close(pipe[1]);
> > > > > +}
> > > > > +
> > > > > +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
> > > > > +{
> > > > > +	uint64_t in;
> > > > > +
> > > > > +	in = pipe_read(p, timeout_ms);
> > > > > +
> > > > > +	igt_assert_eq(in, token);
> > > > > +
> > > > > +	return pipe_read(p, timeout_ms);
> > > > > +}
> > > > > +
> > > > > +static uint64_t client_wait_token(struct xe_eudebug_client *c,
> > > > > +				 const uint64_t token)
> > > > > +{
> > > > > +	return __wait_token(c->p_in, token, c->timeout_ms);
> > > > > +}
> > > > > +
> > > > > +static uint64_t wait_from_client(struct xe_eudebug_client *c,
> > > > > +				 const uint64_t token)
> > > > > +{
> > > > > +	return __wait_token(c->p_out, token, c->timeout_ms);
> > > > > +}
> > > > > +
> > > > > +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
> > > > > +{
> > > > > +	pipe_signal(p, token);
> > > > > +	pipe_signal(p, value);
> > > > > +}
> > > > > +
> > > > > +static void client_signal(struct xe_eudebug_client *c,
> > > > > +			  const uint64_t token,
> > > > > +			  const uint64_t value)
> > > > > +{
> > > > > +	token_signal(c->p_out, token, value);
> > > > > +}
> > > > > +
> > > > > +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_connect param = {
> > > > > +		.pid = pid,
> > > > > +		.flags = flags,
> > > > > +	};
> > > > > +	int debugfd;
> > > > > +
> > > > > +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> > > > > +
> > > > > +	if (debugfd < 0)
> > > > > +		return -errno;
> > > > > +
> > > > > +	return debugfd;
> > > > > +}
> > > > > +
> > > > > +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
> > > > > +{
> > > > > +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
> > > > > +		      sizeof(l->head));
> > > > > +
> > > > > +	igt_assert_eq(write(fd, l->log, l->head), l->head);
> > > > > +}
> > > > > +
> > > > > +static void read_all(int fd, void *buf, size_t nbytes)
> > > > > +{
> > > > > +	ssize_t remaining_size = nbytes;
> > > > > +	ssize_t current_size = 0;
> > > > > +	ssize_t read_size = 0;
> > > > > +
> > > > > +	do {
> > > > > +		read_size = read(fd, buf + current_size, remaining_size);
> > > > > +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
> > > > > +
> > > > > +		current_size += read_size;
> > > > > +		remaining_size -= read_size;
> > > > > +	} while (remaining_size > 0 && read_size > 0);
> > > > > +
> > > > > +	igt_assert_eq(current_size, nbytes);
> > > > > +}
> > > > > +
> > > > > +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
> > > > > +{
> > > > > +	read_all(fd, &l->head, sizeof(l->head));
> > > > > +	igt_assert_lt(l->head, l->max_size);
> > > > > +
> > > > > +	read_all(fd, l->log, l->head);
> > > > > +}
> > > > > +
> > > > > +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
> > > > > +
> > > > > +static struct drm_xe_eudebug_event *
> > > > > +event_cmp(struct xe_eudebug_event_log *l,
> > > > > +	  struct drm_xe_eudebug_event *current,
> > > > > +	  cmp_fn_t match,
> > > > > +	  void *data)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *e = current;
> > > > > +
> > > > > +	xe_eudebug_for_each_event(e, l) {
> > > > > +		if (match(e, data))
> > > > > +			return e;
> > > > > +	}
> > > > > +
> > > > > +	return NULL;
> > > > > +}
> > > > > +
> > > > > +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *b = data;
> > > > > +
> > > > > +	if (a->type == b->type &&
> > > > > +	    a->flags == b->flags)
> > > > > +		return 1;
> > > > > +
> > > > > +	return 0;
> > > > > +}
> > > > > +
> > > > > +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *b = data;
> > > > > +	int ret = 0;
> > > > > +
> > > > > +	ret = match_type_and_flags(a, data);
> > > > > +	if (!ret)
> > > > > +		return ret;
> > > > > +
> > > > > +	ret = 0;
> > > > > +
> > > > > +	switch (a->type) {
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > > +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
> > > > > +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
> > > > > +
> > > > > +		if (ae->engine_class == be->engine_class && ae->width == be->width)
> > > > > +			ret = 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
> > > > > +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
> > > > > +
> > > > > +		if (ea->num_binds == eb->num_binds)
> > > > > +			ret = 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
> > > > > +
> > > > > +		if (ea->addr == eb->addr && ea->range == eb->range &&
> > > > > +		    ea->num_extensions == eb->num_extensions)
> > > > > +			ret = 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
> > > > > +
> > > > > +		if (ea->metadata_handle == eb->metadata_handle &&
> > > > > +		    ea->metadata_cookie == eb->metadata_cookie)
> > > > > +			ret = 1;
> > > > > +		break;
> > > > > +	}
> > > > > +
> > > > > +	default:
> > > > > +		ret = 1;
> > > > > +		break;
> > > > > +	}
> > > > > +
> > > > > +	return ret;
> > > > > +}
> > > > > +
> > > > > +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
> > > > > +{
> > > > > +	struct match_dto *md = (void *)data;
> > > > > +	uint64_t *bind_seqno = md->bind_seqno;
> > > > > +	uint64_t *bind_op_seqno = md->bind_op_seqno;
> > > > > +	uint64_t h = md->client_handle;
> > > > > +
> > > > > +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
> > > > > +		return 0;
> > > > > +
> > > > > +	switch (e->type) {
> > > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > > > +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> > > > > +
> > > > > +		if (client->client_handle == h)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > > > +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> > > > > +
> > > > > +		if (vm->client_handle == h)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > > +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
> > > > > +
> > > > > +		if (ee->client_handle == h)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
> > > > > +
> > > > > +		if (evmb->client_handle == h) {
> > > > > +			*bind_seqno = evmb->base.seqno;
> > > > > +			return 1;
> > > > > +		}
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
> > > > > +
> > > > > +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
> > > > > +			*bind_op_seqno = eo->base.seqno;
> > > > > +			return 1;
> > > > > +		}
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
> > > > > +
> > > > > +		if (ef->vm_bind_ref_seqno == *bind_seqno)
> > > > > +			return 1;
> > > > > +
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
> > > > > +
> > > > > +		if (em->client_handle == h)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
> > > > > +
> > > > > +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	default:
> > > > > +		break;
> > > > > +	}
> > > > > +
> > > > > +	return 0;
> > > > > +}
> > > > > +
> > > > > +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
> > > > > +{
> > > > > +
> > > > > +	struct drm_xe_eudebug_event *d = (void *)data;
> > > > > +	int ret;
> > > > > +
> > > > > +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > > > +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
> > > > > +	ret = match_type_and_flags(e, data);
> > > > > +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > > > +
> > > > > +	if (!ret)
> > > > > +		return 0;
> > > > > +
> > > > > +	switch (e->type) {
> > > > > +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
> > > > > +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
> > > > > +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
> > > > > +
> > > > > +		if (client->client_handle == filter->client_handle)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM: {
> > > > > +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
> > > > > +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
> > > > > +
> > > > > +		if (vm->vm_handle == filter->vm_handle)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
> > > > > +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
> > > > > +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
> > > > > +
> > > > > +		if (ee->exec_queue_handle == filter->exec_queue_handle)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
> > > > > +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
> > > > > +
> > > > > +		if (evmb->vm_handle == filter->vm_handle &&
> > > > > +		    evmb->num_binds == filter->num_binds)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
> > > > > +
> > > > > +		if (avmb->addr == filter->addr &&
> > > > > +		    avmb->range == filter->range)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
> > > > > +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
> > > > > +
> > > > > +		if (em->metadata_handle == filter->metadata_handle)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
> > > > > +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
> > > > > +
> > > > > +		if (avmb->metadata_handle == filter->metadata_handle &&
> > > > > +		    avmb->metadata_cookie == filter->metadata_cookie)
> > > > > +			return 1;
> > > > > +		break;
> > > > > +	}
> > > > > +
> > > > > +	default:
> > > > > +		break;
> > > > > +	}
> > > > > +	return 0;
> > > > > +}
> > > > > +
> > > > > +static int match_full(struct drm_xe_eudebug_event *e, void *data)
> > > > > +{
> > > > > +	struct seqno_list_entry *sl;
> > > > > +
> > > > > +	struct match_dto *md = (void *)data;
> > > > > +	int ret = 0;
> > > > > +
> > > > > +	ret = match_client_handle(e, md);
> > > > > +	if (!ret)
> > > > > +		return 0;
> > > > > +
> > > > > +	ret = match_fields(e, md->target);
> > > > > +	if (!ret)
> > > > > +		return 0;
> > > > > +
> > > > > +	igt_list_for_each_entry(sl, md->seqno_list, link) {
> > > > > +		if (sl->seqno == e->seqno)
> > > > > +			return 0;
> > > > > +	}
> > > > > +
> > > > > +	return 1;
> > > > > +}
> > > > > +
> > > > > +static struct drm_xe_eudebug_event *
> > > > > +event_type_match(struct xe_eudebug_event_log *l,
> > > > > +		 struct drm_xe_eudebug_event *target,
> > > > > +		 struct drm_xe_eudebug_event *current)
> > > > > +{
> > > > > +	return event_cmp(l, current, match_type_and_flags, target);
> > > > > +}
> > > > > +
> > > > > +static struct drm_xe_eudebug_event *
> > > > > +client_match(struct xe_eudebug_event_log *l,
> > > > > +	     uint64_t client_handle,
> > > > > +	     struct drm_xe_eudebug_event *current,
> > > > > +	     uint32_t filter,
> > > > > +	     uint64_t *bind_seqno,
> > > > > +	     uint64_t *bind_op_seqno)
> > > > > +{
> > > > > +	struct match_dto md = {
> > > > > +		.client_handle = client_handle,
> > > > > +		.filter = filter,
> > > > > +		.bind_seqno = bind_seqno,
> > > > > +		.bind_op_seqno = bind_op_seqno,
> > > > > +	};
> > > > > +
> > > > > +	return event_cmp(l, current, match_client_handle, &md);
> > > > > +}
> > > > > +
> > > > > +static struct drm_xe_eudebug_event *
> > > > > +opposite_event_match(struct xe_eudebug_event_log *l,
> > > > > +		    struct drm_xe_eudebug_event *target,
> > > > > +		    struct drm_xe_eudebug_event *current)
> > > > > +{
> > > > > +	return event_cmp(l, current, match_opposite_resource, target);
> > > > > +}
> > > > > +
> > > > > +static struct drm_xe_eudebug_event *
> > > > > +event_match(struct xe_eudebug_event_log *l,
> > > > > +	    struct drm_xe_eudebug_event *target,
> > > > > +	    uint64_t client_handle,
> > > > > +	    struct igt_list_head *seqno_list,
> > > > > +	    uint64_t *bind_seqno,
> > > > > +	    uint64_t *bind_op_seqno)
> > > > > +{
> > > > > +	struct match_dto md = {
> > > > > +		.target = target,
> > > > > +		.client_handle = client_handle,
> > > > > +		.seqno_list = seqno_list,
> > > > > +		.bind_seqno = bind_seqno,
> > > > > +		.bind_op_seqno = bind_op_seqno,
> > > > > +	};
> > > > > +
> > > > > +	return event_cmp(l, NULL, match_full, &md);
> > > > > +}
> > > > > +
> > > > > +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
> > > > > +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
> > > > > +			   uint32_t filter)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
> > > > > +	struct drm_xe_eudebug_event_client *de = (void *)_de;
> > > > > +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
> > > > > +
> > > > > +	struct igt_list_head matched_seqno_list;
> > > > > +	struct drm_xe_eudebug_event *hc, *hd;
> > > > > +	struct seqno_list_entry *entry, *tmp;
> > > > > +
> > > > > +	igt_assert(ce);
> > > > > +	igt_assert(de);
> > > > > +
> > > > > +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
> > > > > +
> > > > > +	hc = NULL;
> > > > > +	hd = NULL;
> > > > > +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
> > > > > +
> > > > > +	do {
> > > > > +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
> > > > > +		if (!hc)
> > > > > +			break;
> > > > > +
> > > > > +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
> > > > > +
> > > > > +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
> > > > > +			     c->name,
> > > > > +			     hc->seqno,
> > > > > +			     hc->type,
> > > > > +			     ce->client_handle);
> > > > > +
> > > > > +		igt_debug("comparing %s %llu vs %s %llu\n",
> > > > > +			  c->name, hc->seqno, d->name, hd->seqno);
> > > > > +
> > > > > +		/*
> > > > > +		 * Store the seqno of the event that was matched above,
> > > > > +		 * inside 'matched_seqno_list', to avoid it getting matched
> > > > > +		 * by subsequent 'event_match' calls.
> > > > > +		 */
> > > > > +		entry = malloc(sizeof(*entry));
> > > > > +		entry->seqno = hd->seqno;
> > > > > +		igt_list_add(&entry->link, &matched_seqno_list);
> > > > > +	} while (hc);
> > > > > +
> > > > > +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
> > > > > +		free(entry);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_find_seqno:
> > > > > + * @l: event log pointer
> > > > > + * @seqno: seqno of event to be found
> > > > > + *
> > > > > + * Finds the event with given seqno in the event log.
> > > > > + *
> > > > > + * Returns: pointer to the event with given seqno within @l or NULL seqno is
> > > > > + * not present.
> > > > > + */
> > > > > +struct drm_xe_eudebug_event *
> > > > > +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
> > > > > +
> > > > > +	igt_assert_neq(seqno, 0);
> > > > > +	/*
> > > > > +	 * Try to catch if seqno is corrupted and prevent too long tests,
> > > > > +	 * as our post processing of events is not optimized.
> > > > > +	 */
> > > > > +	igt_assert_lt(seqno, 10 * 1000 * 1000);
> > > > > +
> > > > > +	xe_eudebug_for_each_event(e, l) {
> > > > > +		if (e->seqno == seqno) {
> > > > > +			if (found) {
> > > > > +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
> > > > > +				xe_eudebug_event_log_print(l, false);
> > > > > +				igt_assert(!found);
> > > > > +			}
> > > > > +			found = e;
> > > > > +		}
> > > > > +	}
> > > > > +
> > > > > +	return found;
> > > > > +}
> > > > > +
> > > > > +static void event_log_sort(struct xe_eudebug_event_log *l)
> > > > > +{
> > > > > +	struct xe_eudebug_event_log *tmp;
> > > > > +	struct drm_xe_eudebug_event *e = NULL;
> > > > > +	uint64_t first_seqno = 0;
> > > > > +	uint64_t last_seqno = 0;
> > > > > +	uint64_t events = 0, added = 0;
> > > > > +	uint64_t i;
> > > > > +
> > > > > +	xe_eudebug_for_each_event(e, l) {
> > > > > +		if (e->seqno > last_seqno)
> > > > > +			last_seqno = e->seqno;
> > > > > +
> > > > > +		if (e->seqno < first_seqno)
> > > > > +			first_seqno = e->seqno;
> > > > > +
> > > > > +		events++;
> > > > > +	}
> > > > > +
> > > > > +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
> > > > > +
> > > > > +	for (i = 1; i <= last_seqno; i++) {
> > > > > +		e = xe_eudebug_event_log_find_seqno(l, i);
> > > > > +		if (e) {
> > > > > +			xe_eudebug_event_log_write(tmp, e);
> > > > > +			added++;
> > > > > +		}
> > > > > +	}
> > > > > +
> > > > > +	igt_assert_eq(events, added);
> > > > > +	igt_assert_eq(tmp->head, l->head);
> > > > > +
> > > > > +	memcpy(l->log, tmp->log, tmp->head);
> > > > > +
> > > > > +	xe_eudebug_event_log_destroy(tmp);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_connect:
> > > > > + * @fd: Xe file descriptor
> > > > > + * @pid: client PID
> > > > > + * @flags: connection flags
> > > > > + *
> > > > > + * Opens the xe eu debugger connection to the process described by @pid
> > > > > + *
> > > > > + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> > > > > + */
> > > > > +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
> > > > > +{
> > > > > +	int ret;
> > > > > +	uint64_t events = 0; /* events filtering not supported yet! */
> > > > > +
> > > > > +	ret = __xe_eudebug_connect(fd, pid, flags, events);
> > > > > +
> > > > > +	return ret;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_create:
> > > > > + * @name: event log identifier
> > > > > + * @max_size: maximum size of created log
> > > > > + *
> > > > > + * Function creates an Eu Debugger event log with size equal to @max_size.
> > > > > + *
> > > > > + * Returns: pointer to just created log
> > > > > + */
> > > > > +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
> > > > > +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
> > > > > +{
> > > > > +	struct xe_eudebug_event_log *l;
> > > > > +
> > > > > +	l = calloc(1, sizeof(*l));
> > > > > +	igt_assert(l);
> > > > > +	l->log = calloc(1, max_size);
> > > > > +	igt_assert(l->log);
> > > > > +	l->max_size = max_size;
> > > > > +	strncpy(l->name, name, sizeof(l->name) - 1);
> > > > > +	pthread_mutex_init(&l->lock, NULL);
> > > > > +
> > > > > +	return l;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_destroy:
> > > > > + * @l: event log pointer
> > > > > + *
> > > > > + * Frees given event log @l.
> > > > > + */
> > > > > +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
> > > > > +{
> > > > > +	pthread_mutex_destroy(&l->lock);
> > > > > +	free(l->log);
> > > > > +	free(l);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_write:
> > > > > + * @l: event log pointer
> > > > > + * @e: event to be written to event log
> > > > > + *
> > > > > + * Writes event @e to the event log, thread-safe.
> > > > > + */
> > > > > +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
> > > > > +{
> > > > > +	igt_assert(e->seqno);
> > > > > +	/*
> > > > > +	 * Try to catch if seqno is corrupted and prevent too long tests,
> > > > > +	 * as our post processing of events is not optimized.
> > > > > +	 */
> > > > > +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
> > > > > +
> > > > > +	pthread_mutex_lock(&l->lock);
> > > > > +	igt_assert_lt(l->head + e->len, l->max_size);
> > > > > +	memcpy(l->log + l->head, e, e->len);
> > > > > +	l->head += e->len;
> > > > > +
> > > > > +#ifdef DEBUG_LOG
> > > > > +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
> > > > > +		 l->name, e->len, l->max_size - l->head);
> > > > > +#endif
> > > > > +	pthread_mutex_unlock(&l->lock);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_print:
> > > > > + * @l: event log pointer
> > > > > + * @debug: when true function uses igt_debug instead of igt_info.
> > > > > + *
> > > > > + * Prints given event log.
> > > > > + */
> > > > > +void
> > > > > +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *e = NULL;
> > > > > +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
> > > > > +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> > > > > +
> > > > > +	igt_log(IGT_LOG_DOMAIN, level,
> > > > > +		"event log '%s' (%u bytes):\n", l->name, l->head);
> > > > > +
> > > > > +	xe_eudebug_for_each_event(e, l) {
> > > > > +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> > > > > +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
> > > > > +	}
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_compare:
> > > > > + * @a: event log pointer
> > > > > + * @b: event log pointer
> > > > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > > > + * for events like 'VM_BIND' since they can be asymmetric. Note that
> > > > > + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
> > > > > + *
> > > > > + * Compares and asserts event logs @a, @b if the event
> > > > > + * sequence matches.
> > > > > + */
> > > > > +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
> > > > > +				  uint32_t filter)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *ae = NULL;
> > > > > +	struct drm_xe_eudebug_event *be = NULL;
> > > > > +
> > > > > +	xe_eudebug_for_each_event(ae, a) {
> > > > > +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
> > > > > +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > > > +			be = event_type_match(b, ae, be);
> > > > > +
> > > > > +			compare_client(a, ae, b, be, filter);
> > > > > +			compare_client(b, be, a, ae, filter);
> > > > > +		}
> > > > > +	}
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_event_log_match_opposite:
> > > > > + * @l: event log pointer
> > > > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > > > + * for events like 'VM_BIND' since they can be asymmetric
> > > > > + *
> > > > > + * Matches and asserts content of all opposite events (create vs destroy).
> > > > > + */
> > > > > +void
> > > > > +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event *ce = NULL;
> > > > > +	struct drm_xe_eudebug_event *de = NULL;
> > > > > +
> > > > > +	xe_eudebug_for_each_event(ce, l) {
> > > > > +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
> > > > > +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
> > > > > +			int opposite_matching;
> > > > > +
> > > > > +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
> > > > > +				continue;
> > > > > +
> > > > > +			/* No opposite matching for binds */
> > > > > +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
> > > > > +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
> > > > > +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
> > > > > +				continue;
> > > > > +
> > > > > +			de = opposite_event_match(l, ce, ce);
> > > > > +
> > > > > +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
> > > > > +
> > > > > +			igt_assert_eq(ce->len, de->len);
> > > > > +			opposite_matching = memcmp((uint8_t *)de + offset,
> > > > > +						   (uint8_t *)ce + offset,
> > > > > +						   de->len - offset) == 0;
> > > > > +
> > > > > +			igt_assert_f(opposite_matching,
> > > > > +				     "%s: create|destroy event not "
> > > > > +				     "maching (%llu) vs (%llu)\n",
> > > > > +				     l->name, de->seqno, ce->seqno);
> > > > > +		}
> > > > > +	}
> > > > > +}
> > > > > +
> > > > > +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
> > > > > +				  struct drm_xe_eudebug_event *e)
> > > > > +{
> > > > > +	struct event_trigger *t;
> > > > > +
> > > > > +	igt_list_for_each_entry(t, &d->triggers, link) {
> > > > > +		if (e->type == t->type)
> > > > > +			t->fn(d, e);
> > > > > +	}
> > > > > +}
> > > > > +
> > > > > +#define MAX_EVENT_SIZE (32 * 1024)
> > > > > +static int
> > > > > +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
> > > > > +{
> > > > > +	int ret;
> > > > > +
> > > > > +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
> > > > > +	event->flags = 0;
> > > > > +	event->len = MAX_EVENT_SIZE;
> > > > > +
> > > > > +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
> > > > > +	if (ret < 0)
> > > > > +		return -errno;
> > > > > +
> > > > > +	return ret;
> > > > > +}
> > > > > +
> > > > > +static void *debugger_worker_loop(void *data)
> > > > > +{
> > > > > +	uint8_t buf[MAX_EVENT_SIZE];
> > > > > +	struct drm_xe_eudebug_event *e = (void *)buf;
> > > > > +	struct xe_eudebug_debugger *d = data;
> > > > > +	struct pollfd p = {
> > > > > +		.events = POLLIN,
> > > > > +		.revents = 0,
> > > > > +	};
> > > > > +	int timeout_ms = 100, ret;
> > > > > +
> > > > > +	igt_assert(d->master_fd >= 0);
> > > > > +
> > > > > +	do {
> > > > > +		p.fd = d->fd;
> > > > > +		ret = poll(&p, 1, timeout_ms);
> > > > > +
> > > > > +		if (ret == -1) {
> > > > > +			igt_info("poll failed with errno %d\n", errno);
> > > > > +			break;
> > > > > +		}
> > > > > +
> > > > > +		if (ret == 1 && (p.revents & POLLIN)) {
> > > > > +			int err = xe_eudebug_read_event(d->fd, e);
> > > > > +
> > > > > +			if (!err) {
> > > > > +				++d->event_count;
> > > > > +
> > > > > +				xe_eudebug_event_log_write(d->log, e);
> > > > > +				debugger_run_triggers(d, e);
> > > > > +			} else {
> > > > > +				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;
> > > > > +	return NULL;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_available:
> > > > > + * @fd: Xe file descriptor
> > > > > + *
> > > > > + * Returns: true it debugger connection is available, false otherwise.
> > > > > + */
> > > > > +bool xe_eudebug_debugger_available(int fd)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
> > > > > +	int debugfd;
> > > > > +
> > > > > +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
> > > > > +	if (debugfd >= 0)
> > > > > +		close(debugfd);
> > > > > +
> > > > > +	return debugfd >= 0;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_create:
> > > > > + * @master_fd: xe client used to open the debugger connection
> > > > > + * @flags: flags stored in a debugger structure, can be used at will
> > > > > + * of the caller, i.e. to be used inside triggers.
> > > > > + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> > > > > + * can be shared between client and debugger. Can be NULL.
> > > > > + *
> > > > > + * Returns: newly created xe_eudebug_debugger structure with its
> > > > > + * event log initialized. Note that to open the connection
> > > > > + * you need call @xe_eudebug_debugger_attach.
> > > > > + */
> > > > > +struct xe_eudebug_debugger *
> > > > > +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
> > > > > +{
> > > > > +	struct xe_eudebug_debugger *d;
> > > > > +
> > > > > +	d = calloc(1, sizeof(*d));
> > > > > +	d->flags = flags;
> > > > > +	igt_assert(d);
> > > > > +	IGT_INIT_LIST_HEAD(&d->triggers);
> > > > > +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
> > > > > +	d->fd = -1;
> > > > > +	d->master_fd = master_fd;
> > > > > +	d->ptr = data;
> > > > > +
> > > > > +	return d;
> > > > > +}
> > > > > +
> > > > > +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
> > > > > +{
> > > > > +	struct event_trigger *t, *tmp;
> > > > > +
> > > > > +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
> > > > > +		free(t);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_destroy:
> > > > > + * @d: pointer to the debugger
> > > > > + *
> > > > > + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
> > > > > + * connection was still opened it terminates it.
> > > > > + */
> > > > > +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
> > > > > +{
> > > > > +	if (d->worker_state)
> > > > > +		xe_eudebug_debugger_stop_worker(d, 1);
> > > > > +
> > > > > +	if (d->target_pid)
> > > > > +		xe_eudebug_debugger_dettach(d);
> > > > > +
> > > > > +	xe_eudebug_event_log_destroy(d->log);
> > > > > +	debugger_destroy_triggers(d);
> > > > > +	free(d);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_attach:
> > > > > + * @d: pointer to the debugger
> > > > > + * @c: pointer to the client
> > > > > + *
> > > > > + * Opens the xe eu debugger connection to the process described by @c (c->pid)
> > > > > + *
> > > > > + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
> > > > > + */
> > > > > +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
> > > > > +			       struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	int ret;
> > > > > +
> > > > > +	igt_assert_eq(d->fd, -1);
> > > > > +	igt_assert_neq(c->pid, 0);
> > > > > +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
> > > > > +
> > > > > +	if (ret < 0)
> > > > > +		return ret;
> > > > > +
> > > > > +	d->fd = ret;
> > > > > +	d->target_pid = c->pid;
> > > > > +	d->p_client[0] = c->p_in[0];
> > > > > +	d->p_client[1] = c->p_in[1];
> > > > > +
> > > > > +	igt_debug("debugger connected to %lu\n", d->target_pid);
> > > > > +
> > > > > +	return 0;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_dettach:
> > > > > + * @d: pointer to the debugger
> > > > > + *
> > > > > + * Closes previously opened xe eu debugger connection. Asserts if
> > > > > + * the debugger has active session.
> > > > > + */
> > > > > +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
> > > > > +{
> > > > > +	igt_assert(d->target_pid);
> > > > > +	close(d->fd);
> > > > > +	d->target_pid = 0;
> > > > > +	d->fd = -1;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_add_trigger:
> > > > > + * @d: pointer to the debugger
> > > > > + * @type: the type of the event which activates the trigger
> > > > > + * @fn: function to be called when event of @type was read by the debugger.
> > > > > + *
> > > > > + * Adds function @fn to the list of triggers activated when event of @type
> > > > > + * has been read by worker.
> > > > > + * Note: Triggers are activated by the worker.
> > > > > + */
> > > > > +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
> > > > > +				     int type, xe_eudebug_trigger_fn fn)
> > > > > +{
> > > > > +	struct event_trigger *t;
> > > > > +
> > > > > +	t = calloc(1, sizeof(*t));
> > > > > +	IGT_INIT_LIST_HEAD(&t->link);
> > > > > +	t->type = type;
> > > > > +	t->fn = fn;
> > > > > +
> > > > > +	igt_list_add_tail(&t->link, &d->triggers);
> > > > > +	igt_debug("added trigger %p\n", t);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_start_worker:
> > > > > + * @d: pointer to the debugger
> > > > > + *
> > > > > + * Starts the debugger worker. Worker is resposible for reading all
> > > > > + * incoming events from the debugger, put then into debugger log and
> > > > > + * execute appropriate event triggers. Note that using the debuggers
> > > > > + * event log while worker is running is not safe.
> > > > > + */
> > > > > +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
> > > > > +{
> > > > > +	int ret;
> > > > > +
> > > > > +	d->worker_state = true;
> > > > > +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
> > > > > +
> > > > > +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_stop_worker:
> > > > > + * @d: pointer to the debugger
> > > > > + *
> > > > > + * Stops the debugger worker. Event log is sorted by seqno after closure.
> > > > > + */
> > > > > +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
> > > > > +				     int timeout_s)
> > > > > +{
> > > > > +	struct timespec t = {};
> > > > > +	int ret;
> > > > > +
> > > > > +	igt_assert(d->worker_state);
> > > > > +
> > > > > +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
> > > > > +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
> > > > > +	t.tv_sec += timeout_s;
> > > > > +
> > > > > +	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_assert_f(ret == 0 || ret != ESRCH,
> > > > > +		     "pthread join failed with error %d!\n", ret);
> > > > > +
> > > > > +	event_log_sort(d->log);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_signal_stage:
> > > > > + * @d: pointer to the debugger
> > > > > + * @stage: stage to signal
> > > > > + *
> > > > > + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
> > > > > + * releasing it to proceed.
> > > > > + */
> > > > > +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
> > > > > +{
> > > > > +	token_signal(d->p_client, CLIENT_STAGE, stage);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_debugger_wait_stage:
> > > > > + * @s: pointer to xe_eudebug_debugger structure
> > > > > + * @stage: stage to wait on
> > > > > + *
> > > > > + * Pauses debugger until the client has signalled the corresponding stage with
> > > > > + * xe_eudebug_client_signal_stage. This is only for situations where the actual
> > > > > + * event flow is not enough to coordinate between client/debugger and extra sync
> > > > > + * mechanism is needed.
> > > > > + */
> > > > > +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
> > > > > +{
> > > > > +	u64 stage_in;
> > > > > +
> > > > > +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
> > > > > +
> > > > > +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
> > > > > +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
> > > > > +		  stage_in, stage);
> > > > > +
> > > > > +	igt_assert_eq(stage_in, stage);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_create:
> > > > > + * @master_fd: xe client used to open the debugger connection
> > > > > + * @work: function that opens xe device and executes arbitrary workload
> > > > > + * @flags: flags stored in a client structure, can be used at will
> > > > > + * of the caller, i.e. to provide the @work function an additional switch.
> > > > > + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
> > > > > + * can be shared between client and debugger. Accesible via client->ptr.
> > > > > + * Can be NULL.
> > > > > + *
> > > > > + * Forks and creates the debugger process. @work won't be called until
> > > > > + * xe_eudebug_client_start is called.
> > > > > + *
> > > > > + * Returns: newly created xe_eudebug_debugger structure with its
> > > > > + * event log initialized.
> > > > > + */
> > > > > +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
> > > > > +						   uint64_t flags, void *data)
> > > > > +{
> > > > > +	struct xe_eudebug_client *c;
> > > > > +
> > > > > +	c = calloc(1, sizeof(*c));
> > > > > +	c->flags = flags;
> > > > > +	igt_assert(c);
> > > > > +	igt_assert(!pipe(c->p_in));
> > > > > +	igt_assert(!pipe(c->p_out));
> > > > > +	c->seqno = 1;
> > > > > +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
> > > > > +	c->done = 0;
> > > > > +	c->ptr = data;
> > > > > +	c->master_fd = master_fd;
> > > > > +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
> > > > > +
> > > > > +	igt_fork(child, 1) {
> > > > > +		int mypid;
> > > > > +
> > > > > +		igt_assert_eq(c->pid, 0);
> > > > > +
> > > > > +		close(c->p_out[0]);
> > > > > +		c->p_out[0] = -1;
> > > > > +		close(c->p_in[1]);
> > > > > +		c->p_in[1] = -1;
> > > > > +
> > > > > +		mypid = getpid();
> > > > > +		client_signal(c, CLIENT_PID, mypid);
> > > > > +
> > > > > +		c->pid = client_wait_token(c, CLIENT_RUN);
> > > > > +		igt_assert_eq(c->pid, mypid);
> > > > > +		if (work)
> > > > > +			work(c);
> > > > > +
> > > > > +		client_signal(c, CLIENT_FINI, c->seqno);
> > > > > +
> > > > > +		event_log_write_to_fd(c->log, c->p_out[1]);
> > > > > +
> > > > > +		c->pid = client_wait_token(c, CLIENT_STOP);
> > > > > +		igt_assert_eq(c->pid, mypid);
> > > > > +	}
> > > > > +
> > > > > +	close(c->p_out[1]);
> > > > > +	c->p_out[1] = -1;
> > > > > +	close(c->p_in[0]);
> > > > > +	c->p_in[0] = -1;
> > > > > +
> > > > > +	c->pid = wait_from_client(c, CLIENT_PID);
> > > > > +
> > > > > +	igt_info("client running with pid %d\n", c->pid);
> > > > > +
> > > > > +	return c;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_stop:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + *
> > > > > + * Waits for the end of client's work and exits the proccess.
> > > > > + */
> > > > > +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	if (c->pid) {
> > > > > +		int waitstatus;
> > > > > +
> > > > > +		xe_eudebug_client_wait_done(c);
> > > > > +
> > > > > +		token_signal(c->p_in, CLIENT_STOP, c->pid);
> > > > > +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
> > > > > +			      c->pid);
> > > > > +		c->pid = 0;
> > > > > +	}
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_destroy:
> > > > > + * @c: pointer to xe_eudebug_client structure to be freed
> > > > > + *
> > > > > + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
> > > > > + * client proccess has not terminated yet.
> > > > > + */
> > > > > +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	xe_eudebug_client_stop(c);
> > > > > +	pipe_close(c->p_in);
> > > > > +	pipe_close(c->p_out);
> > > > > +	xe_eudebug_event_log_destroy(c->log);
> > > > > +	free(c);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_get_seqno:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + *
> > > > > + * Increments and returns current seqno value of the given client @c
> > > > > + *
> > > > > + * Returns: incremented seqno
> > > > > + */
> > > > > +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	return c->seqno++;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_start:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + *
> > > > > + * Starts execution of client's work function within the client's proccess.
> > > > > + */
> > > > > +void xe_eudebug_client_start(struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	token_signal(c->p_in, CLIENT_RUN, c->pid);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_wait_done:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + *
> > > > > + * Waits for the client work end updates the event log.
> > > > > + * Doesn't terminate the client's proccess yet.
> > > > > + */
> > > > > +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	if (!c->done) {
> > > > > +		c->done = 1;
> > > > > +		c->seqno = wait_from_client(c, CLIENT_FINI);
> > > > > +		event_log_read_from_fd(c->log, c->p_out[0]);
> > > > > +	}
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_signal_stage:
> > > > > + * @c: pointer to the client
> > > > > + * @stage: stage to signal
> > > > > + *
> > > > > + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
> > > > > + * releasing it to proceed.
> > > > > + */
> > > > > +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
> > > > > +{
> > > > > +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_wait_stage:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @stage: stage to wait on
> > > > > + *
> > > > > + * Pauses client until the debugger has signalled the corresponding stage with
> > > > > + * xe_eudebug_debugger_signal_stage. This is only for situations where the
> > > > > + * actual event flow is not enough to coordinate between client/debugger and extra
> > > > > + * sync mechanism is needed.
> > > > > + *
> > > > > + */
> > > > > +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
> > > > > +{
> > > > > +	u64 stage_in;
> > > > > +
> > > > > +	if (c->done) {
> > > > > +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
> > > > > +		return;
> > > > > +	}
> > > > > +
> > > > > +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
> > > > > +
> > > > > +	stage_in = client_wait_token(c, CLIENT_STAGE);
> > > > > +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
> > > > > +
> > > > > +	igt_assert_eq(stage_in, stage);
> > > > > +}
> > > > > +
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_session_create:
> > > > > + * @fd: XE file descriptor
> > > > > + * @work: function passed to the xe_eudebug_client_create
> > > > > + * @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.
> > > > > + *
> > > > > + * Creates session together with client and debugger structures.
> > > > > + */
> > > > > +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
> > > > > +						     xe_eudebug_client_work_fn work,
> > > > > +						     unsigned int flags,
> > > > > +						     void *test_private)
> > > > > +{
> > > > > +	struct xe_eudebug_session *s;
> > > > > +
> > > > > +	s = calloc(1, sizeof(*s));
> > > > > +	igt_assert(s);
> > > > > +
> > > > > +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
> > > > > +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
> > > > > +	s->flags = flags;
> > > > > +
> > > > > +	return s;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_session_run:
> > > > > + * @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.
> > > > > + */
> > > > > +void xe_eudebug_session_run(struct xe_eudebug_session *s)
> > > > > +{
> > > > > +	struct xe_eudebug_debugger *debugger = s->d;
> > > > > +	struct xe_eudebug_client *client = s->c;
> > > > > +
> > > > > +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
> > > > > +
> > > > > +	xe_eudebug_debugger_start_worker(debugger);
> > > > > +
> > > > > +	xe_eudebug_client_start(client);
> > > > > +	xe_eudebug_client_wait_done(client);
> > > > > +
> > > > > +	xe_eudebug_debugger_stop_worker(debugger, 1);
> > > > > +
> > > > > +	xe_eudebug_event_log_print(debugger->log, true);
> > > > > +	xe_eudebug_event_log_print(client->log, true);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_session_check:
> > > > > + * @s: pointer to xe_eudebug_session structure
> > > > > + * @match_opposite: indicates whether check should match all
> > > > > + * create and destroy events.
> > > > > + * @filter: mask that represents events to be skipped during comparison, useful
> > > > > + * for events like 'VM_BIND' since they can be asymmetric
> > > > > + *
> > > > > + * Validate debugger's log against the log created by the client.
> > > > > + */
> > > > > +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
> > > > > +{
> > > > > +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
> > > > > +
> > > > > +	if (match_opposite)
> > > > > +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_session_destroy:
> > > > > + * @s: pointer to xe_eudebug_session structure
> > > > > + *
> > > > > + * Destroy session together with its debugger and client.
> > > > > + */
> > > > > +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
> > > > > +{
> > > > > +	xe_eudebug_debugger_destroy(s->d);
> > > > > +	xe_eudebug_client_destroy(s->c);
> > > > > +
> > > > > +	free(s);
> > > > > +}
> > > > > +
> > > > > +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
> > > > > +
> > > > > +static void base_event(struct xe_eudebug_client *c,
> > > > > +		       struct drm_xe_eudebug_event *e,
> > > > > +		       uint32_t type,
> > > > > +		       uint32_t flags,
> > > > > +		       uint64_t size)
> > > > > +{
> > > > > +	e->type = type;
> > > > > +	e->flags = flags;
> > > > > +	e->seqno = xe_eudebug_client_get_seqno(c);
> > > > > +	e->len = size;
> > > > > +}
> > > > > +
> > > > > +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_client ec;
> > > > > +
> > > > > +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
> > > > > +
> > > > > +	ec.client_handle = client_fd;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&ec);
> > > > > +}
> > > > > +
> > > > > +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_vm evm;
> > > > > +
> > > > > +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
> > > > > +
> > > > > +	evm.client_handle = client_fd;
> > > > > +	evm.vm_handle = vm_id;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&evm);
> > > > > +}
> > > > > +
> > > > > +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
> > > > > +			     int client_fd, uint32_t vm_id,
> > > > > +			     uint32_t exec_queue_handle, uint16_t class,
> > > > > +			     uint16_t width)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_exec_queue ee;
> > > > > +
> > > > > +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
> > > > > +		   flags, sizeof(ee));
> > > > > +
> > > > > +	ee.client_handle = client_fd;
> > > > > +	ee.vm_handle = vm_id;
> > > > > +	ee.exec_queue_handle = exec_queue_handle;
> > > > > +	ee.engine_class = class;
> > > > > +	ee.width = width;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&ee);
> > > > > +}
> > > > > +
> > > > > +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
> > > > > +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_metadata em;
> > > > > +
> > > > > +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
> > > > > +		   flags, sizeof(em));
> > > > > +
> > > > > +	em.client_handle = client_fd;
> > > > > +	em.metadata_handle = id;
> > > > > +	em.type = type;
> > > > > +	em.len = len;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&em);
> > > > > +}
> > > > > +
> > > > > +static int enable_getset(int fd, bool *old, bool *new)
> > > > > +{
> > > > > +	static const char * const fname = "enable_eudebug";
> > > > > +	int ret = 0;
> > > > > +
> > > > > +	int sysfs, device_fd;
> > > > > +	bool val_before;
> > > > > +	struct stat st;
> > > > > +
> > > > > +	igt_assert(new || old);
> > > > > +
> > > > > +	igt_assert_eq(fstat(fd, &st), 0);
> > > > > +	sysfs = igt_sysfs_open(fd);
> > > > > +	if (sysfs < 0)
> > > > > +		return -1;
> > > > > +
> > > > > +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
> > > > > +	close(sysfs);
> > > > > +	if (device_fd < 0)
> > > > > +		return -1;
> > > > > +
> > > > > +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
> > > > > +		ret = -1;
> > > > > +		goto out;
> > > > > +	}
> > > > > +
> > > > > +	igt_debug("enable_eudebug before: %d\n", val_before);
> > > > > +
> > > > > +	if (old)
> > > > > +		*old = val_before;
> > > > > +
> > > > > +	ret = 0;
> > > > > +	if (new) {
> > > > > +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
> > > > > +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
> > > > > +		else
> > > > > +			ret = -1;
> > > > > +	}
> > > > > +
> > > > > +out:
> > > > > +	close(device_fd);
> > > > > +	return ret;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_enable
> > > > > + * @fd: xe client
> > > > > + * @enable: state toggle - true to enable, false to disable
> > > > > + *
> > > > > + * Enables/disables eudebug capability by writing to
> > > > > + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
> > > > > + *
> > > > > + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
> > > > > + * false when eudebugging was disabled.
> > > > > + */
> > > > > +bool xe_eudebug_enable(int fd, bool enable)
> > > > > +{
> > > > > +	bool old = false;
> > > > > +	int ret = enable_getset(fd, &old, &enable);
> > > > > +
> > > > > +	if (ret) {
> > > > > +		igt_skip_on(enable);
> > > > > +		old = false;
> > > > > +	}
> > > > > +
> > > > > +	return old;
> > > > > +}
> > > > > +
> > > > > +/* Eu debugger wrappers around resource creating xe ioctls. */
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_open_driver:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + *
> > > > > + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
> > > > > + * event in client's event log.
> > > > > + *
> > > > > + * Returns: valid DRM file descriptor
> > > > > + */
> > > > > +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
> > > > > +{
> > > > > +	int fd;
> > > > > +
> > > > > +	fd = drm_reopen_driver(c->master_fd);
> > > > > +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
> > > > > +
> > > > > +	return fd;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_close_driver:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + *
> > > > > + * Calls close driver and logs the corresponding event in
> > > > > + * client's event log.
> > > > > + */
> > > > > +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
> > > > > +{
> > > > > +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
> > > > > +	close(fd);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_create:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @flags: vm bind flags
> > > > > + * @ext: pointer to the first user extension
> > > > > + *
> > > > > + * Calls xe_vm_create() and logs corresponding events
> > > > > + * (including vm set metadata events) in client's event log.
> > > > > + *
> > > > > + * Returns: valid vm handle
> > > > > + */
> > > > > +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
> > > > > +				     uint32_t flags, uint64_t ext)
> > > > > +{
> > > > > +	uint32_t vm;
> > > > > +
> > > > > +	vm = xe_vm_create(fd, flags, ext);
> > > > > +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
> > > > > +
> > > > > +	return vm;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_destroy:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * fd: xe client
> > > > > + * vm: vm handle
> > > > > + *
> > > > > + * Calls xe_vm_destroy() and logs the corresponding event in
> > > > > + * client's event log.
> > > > > + */
> > > > > +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
> > > > > +{
> > > > > +	xe_vm_destroy(fd, vm);
> > > > > +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_exec_queue_create:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @create: exec_queue create drm struct
> > > > > + *
> > > > > + * Calls xe exec queue create ioctl and logs the corresponding event in
> > > > > + * client's event log.
> > > > > + *
> > > > > + * Returns: valid exec queue handle
> > > > > + */
> > > > > +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
> > > > > +					     struct drm_xe_exec_queue_create *create)
> > > > > +{
> > > > > +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> > > > > +
> > > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
> > > > > +
> > > > > +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> > > > > +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
> > > > > +				 create->exec_queue_id, class, create->width);
> > > > > +
> > > > > +	return create->exec_queue_id;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_exec_queue_destroy:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @create: exec_queue create drm struct which was used for creation
> > > > > + *
> > > > > + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
> > > > > + * client's event log.
> > > > > + */
> > > > > +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> > > > > +					  struct drm_xe_exec_queue_create *create)
> > > > > +{
> > > > > +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
> > > > > +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
> > > > > +
> > > > > +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
> > > > > +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
> > > > > +				 create->exec_queue_id, class, create->width);
> > > > > +
> > > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_bind_event:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @event_flags: base event flags
> > > > > + * @fd: xe client
> > > > > + * @vm: vm handle
> > > > > + * @bind_flags: bind flags of vm_bind_event
> > > > > + * @num_binds: 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, int fd,
> > > > > +				     uint32_t vm, uint32_t bind_flags,
> > > > > +				     uint32_t num_binds, u64 *ref_seqno)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_vm_bind evmb;
> > > > > +
> > > > > +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
> > > > > +		   event_flags, sizeof(evmb));
> > > > > +	evmb.client_handle = fd;
> > > > > +	evmb.vm_handle = vm;
> > > > > +	evmb.flags = bind_flags;
> > > > > +	evmb.num_binds = num_binds;
> > > > > +
> > > > > +	*ref_seqno = evmb.base.seqno;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_bind_op_event:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @event_flags: base event flags
> > > > > + * @bind_ref_seqno: base vm bind reference seqno
> > > > > + * @op_ref_seqno: output, the vm_bind_op event seqno
> > > > > + * @addr: ppgtt address
> > > > > + * @size: size of the binding
> > > > > + * @num_extensions: number of vm bind op extensions
> > > > > + *
> > > > > + * Logs vm bind op event in client's event log.
> > > > > + */
> > > > > +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
> > > > > +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
> > > > > +					uint64_t addr, uint64_t range,
> > > > > +					uint64_t num_extensions)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_vm_bind_op op;
> > > > > +
> > > > > +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
> > > > > +		   event_flags, sizeof(op));
> > > > > +	op.vm_bind_ref_seqno = bind_ref_seqno;
> > > > > +	op.addr = addr;
> > > > > +	op.range = range;
> > > > > +	op.num_extensions = num_extensions;
> > > > > +
> > > > > +	*op_ref_seqno = op.base.seqno;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&op);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_bind_op_metadata_event:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @event_flags: base event flags
> > > > > + * @op_ref_seqno: base vm bind op reference seqno
> > > > > + * @metadata_handle: metadata handle
> > > > > + * @metadata_cookie: metadata cookie
> > > > > + *
> > > > > + * Logs vm bind op metadata event in client's event log.
> > > > > + */
> > > > > +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)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
> > > > > +
> > > > > +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
> > > > > +		   event_flags, sizeof(op));
> > > > > +	op.vm_bind_op_ref_seqno = op_ref_seqno;
> > > > > +	op.metadata_handle = metadata_handle;
> > > > > +	op.metadata_cookie = metadata_cookie;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&op);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_bind_ufence_event:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @event_flags: base event flags
> > > > > + * @ref_seqno: base vm bind event seqno
> > > > > + *
> > > > > + * Logs vm bind ufence event in client's event log.
> > > > > + */
> > > > > +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
> > > > > +					    uint64_t ref_seqno)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_event_vm_bind_ufence f;
> > > > > +
> > > > > +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
> > > > > +		   event_flags, sizeof(f));
> > > > > +	f.vm_bind_ref_seqno = ref_seqno;
> > > > > +
> > > > > +	xe_eudebug_event_log_write(c->log, (void *)&f);
> > > > > +}
> > > > > +
> > > > > +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
> > > > > +{
> > > > > +	while (num_syncs--)
> > > > > +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
> > > > > +			return true;
> > > > > +
> > > > > +	return false;
> > > > > +}
> > > > > +
> > > > > +#define for_each_metadata(__m, __ext)					\
> > > > > +	for ((__m) = from_user_pointer(__ext);				\
> > > > > +	     (__m);							\
> > > > > +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
> > > > > +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
> > > > > +
> > > > > +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
> > > > > +					int fd, uint32_t vm, uint32_t exec_queue,
> > > > > +					uint32_t bo, uint64_t offset,
> > > > > +					uint64_t addr, uint64_t size,
> > > > > +					uint32_t op, uint32_t flags,
> > > > > +					struct drm_xe_sync *sync,
> > > > > +					uint32_t num_syncs,
> > > > > +					uint32_t prefetch_region,
> > > > > +					uint8_t pat_index, uint64_t op_ext)
> > > > > +{
> > > > > +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
> > > > > +	const bool ufence = has_user_fence(sync, num_syncs);
> > > > > +	const uint32_t bind_flags = ufence ?
> > > > > +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
> > > > > +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
> > > > > +	uint32_t bind_base_flags = 0;
> > > > > +	int ret;
> > > > > +
> > > > > +	for_each_metadata(metadata, op_ext)
> > > > > +		num_metadata++;
> > > > > +
> > > > > +	switch (op) {
> > > > > +	case DRM_XE_VM_BIND_OP_MAP:
> > > > > +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
> > > > > +		break;
> > > > > +	case DRM_XE_VM_BIND_OP_UNMAP:
> > > > > +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
> > > > > +		igt_assert_eq(num_metadata, 0);
> > > > > +		igt_assert_eq(ufence, false);
> > > > > +		break;
> > > > > +	default:
> > > > > +		/* XXX unmap all? */
> > > > > +		igt_assert(op);
> > > > > +		break;
> > > > > +	}
> > > > > +
> > > > > +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
> > > > > +			    op, flags, sync, num_syncs, prefetch_region,
> > > > > +			    pat_index, 0, op_ext);
> > > > > +
> > > > > +	if (ret)
> > > > > +		return ret;
> > > > > +
> > > > > +	if (!bind_base_flags)
> > > > > +		return -EINVAL;
> > > > > +
> > > > > +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
> > > > > +					fd, vm, bind_flags, 1, &seqno);
> > > > > +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
> > > > > +					   seqno, &op_seqno, addr, size,
> > > > > +					   num_metadata);
> > > > > +
> > > > > +	for_each_metadata(metadata, op_ext)
> > > > > +		xe_eudebug_client_vm_bind_op_metadata_event(c,
> > > > > +							    DRM_XE_EUDEBUG_EVENT_CREATE,
> > > > > +							    op_seqno,
> > > > > +							    metadata->metadata_id,
> > > > > +							    metadata->cookie);
> > > > > +	if (ufence)
> > > > > +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
> > > > > +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
> > > > > +						       seqno);
> > > > > +	return ret;
> > > > > +}
> > > > > +
> > > > > +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
> > > > > +				       uint32_t vm, uint32_t bo,
> > > > > +				       uint64_t offset, uint64_t addr, uint64_t size,
> > > > > +				       uint32_t op,
> > > > > +				       uint32_t flags,
> > > > > +				       struct drm_xe_sync *sync,
> > > > > +				       uint32_t num_syncs,
> > > > > +				       uint64_t op_ext)
> > > > > +{
> > > > > +	const uint32_t exec_queue_id = 0;
> > > > > +	const uint32_t prefetch_region = 0;
> > > > > +
> > > > > +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
> > > > > +						  addr, size, op, flags,
> > > > > +						  sync, num_syncs, prefetch_region,
> > > > > +						  DEFAULT_PAT_INDEX, op_ext),
> > > > > +		      0);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_bind_flags
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @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, int fd, 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)
> > > > > +{
> > > > > +	_xe_eudebug_client_vm_bind(c, fd, 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
> > > > > + * @fd: xe client
> > > > > + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
> > > > > +					flags,
> > > > > +					sync, num_syncs, op_ext);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_vm_unbind_flags
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @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, int fd,
> > > > > +				       uint32_t vm, uint64_t offset,
> > > > > +				       uint64_t addr, uint64_t size, uint32_t flags,
> > > > > +				       struct drm_xe_sync *sync, uint32_t num_syncs)
> > > > > +{
> > > > > +	_xe_eudebug_client_vm_bind(c, fd, 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
> > > > > + * @fd: xe client
> > > > > + * @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, int fd, 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, fd, vm, offset, addr, size,
> > > > > +					  flags, sync, num_syncs);
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_metadata_create:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @type: debug metadata type
> > > > > + * @len: size of @data
> > > > > + * @data: debug metadata paylad
> > > > > + *
> > > > > + * Calls xe metadata create ioctl and logs the corresponding event in
> > > > > + * client's event log.
> > > > > + *
> > > > > + * Return: valid debug metadata id.
> > > > > + */
> > > > > +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
> > > > > +					   int type, size_t len, void *data)
> > > > > +{
> > > > > +	struct drm_xe_debug_metadata_create create = {
> > > > > +		.type = type,
> > > > > +		.user_addr = to_user_pointer(data),
> > > > > +		.len = len
> > > > > +	};
> > > > > +
> > > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
> > > > > +
> > > > > +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
> > > > > +
> > > > > +	return create.metadata_id;
> > > > > +}
> > > > > +
> > > > > +/**
> > > > > + * xe_eudebug_client_metadata_destroy:
> > > > > + * @c: pointer to xe_eudebug_client structure
> > > > > + * @fd: xe client
> > > > > + * @id: xe debug metadata handle
> > > > > + * @type: debug metadata type
> > > > > + * @len: size of debug metadata payload
> > > > > + *
> > > > > + * Calls xe metadata destroy ioctl and logs the corresponding event in
> > > > > + * client's event log.
> > > > > + */
> > > > > +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
> > > > > +					uint32_t id, int type, size_t len)
> > > > > +{
> > > > > +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
> > > > > +
> > > > > +
> > > > > +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
> > > > > +
> > > > > +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
> > > > > +}
> > > > > +
> > > > > +void xe_eudebug_ack_ufence(int debugfd,
> > > > > +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
> > > > > +{
> > > > > +	struct drm_xe_eudebug_ack_event ack = { 0, };
> > > > > +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
> > > > > +
> > > > > +	ack.type = f->base.type;
> > > > > +	ack.seqno = f->base.seqno;
> > > > > +
> > > > > +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
> > > > > +	igt_debug("delivering ack for event: %s\n", event_str);
> > > > > +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
> > > > > +}
> > > > > diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
> > > > > new file mode 100644
> > > > > index 000000000..444f5a7b7
> > > > > --- /dev/null
> > > > > +++ b/lib/xe/xe_eudebug.h
> > > > > @@ -0,0 +1,206 @@
> > > > > +/* SPDX-License-Identifier: MIT */
> > > > > +/*
> > > > > + * Copyright © 2023 Intel Corporation
> > > > > + */
> > > > > +#include <fcntl.h>
> > > > > +#include <pthread.h>
> > > > > +#include <stdint.h>
> > > > > +#include <xe_drm.h>
> > > > > +
> > > > > +#include "igt_list.h"
> > > > > +
> > > > > +struct xe_eudebug_event_log {
> > > > > +	uint8_t *log;
> > > > > +	unsigned int head;
> > > > > +	unsigned int max_size;
> > > > > +	char name[80];
> > > > > +	pthread_mutex_t lock;
> > > > > +};
> > > > > +
> > > > > +struct xe_eudebug_debugger {
> > > > > +	int fd;
> > > > > +	uint64_t flags;
> > > > > +
> > > > > +	/* Used to smuggle private data */
> > > > > +	void *ptr;
> > > > > +
> > > > > +	struct xe_eudebug_event_log *log;
> > > > > +
> > > > > +	uint64_t event_count;
> > > > > +
> > > > > +	uint64_t target_pid;
> > > > > +
> > > > > +	struct igt_list_head triggers;
> > > > > +
> > > > > +	int master_fd;
> > > > > +
> > > > > +	pthread_t worker_thread;
> > > > > +	int worker_state;
> > > > > +
> > > > > +	int p_client[2];
> > > > > +};
> > > > > +
> > > > > +struct xe_eudebug_client {
> > > > > +	int pid;
> > > > > +	uint64_t seqno;
> > > > > +	uint64_t flags;
> > > > > +
> > > > > +	/* Used to smuggle private data */
> > > > > +	void *ptr;
> > > > > +
> > > > > +	struct xe_eudebug_event_log *log;
> > > > > +
> > > > > +	int done;
> > > > > +	int p_in[2];
> > > > > +	int p_out[2];
> > > > > +
> > > > > +	/* Used to pickup right device (the one used in debugger) */
> > > > > +	int master_fd;
> > > > > +
> > > > > +	int timeout_ms;
> > > > > +};
> > > > > +
> > > > > +struct xe_eudebug_session {
> > > > > +	uint64_t flags;
> > > > > +	struct xe_eudebug_client *c;
> > > > > +	struct xe_eudebug_debugger *d;
> > > > > +};
> > > > > +
> > > > > +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_event(_e, _log) \
> > > > > +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
> > > > > +		    (void *)(_log)->log; \
> > > > > +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
> > > > > +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
> > > > > +
> > > > > +#define xe_eudebug_assert(d, c)						\
> > > > > +	do {								\
> > > > > +		if (!(c)) {						\
> > > > > +			xe_eudebug_event_log_print((d)->log, true);	\
> > > > > +			igt_assert(c);					\
> > > > > +		}							\
> > > > > +	} while (0)
> > > > > +
> > > > > +#define xe_eudebug_assert_f(d, c, f...)					\
> > > > > +	do {								\
> > > > > +		if (!(c)) {						\
> > > > > +			xe_eudebug_event_log_print((d)->log, true);	\
> > > > > +			igt_assert_f(c, f);				\
> > > > > +		}							\
> > > > > +	} while (0)
> > > > > +
> > > > > +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
> > > > > +
> > > > > +/*
> > > > > + * Default abort timeout to use across xe_eudebug lib and tests if no specific
> > > > > + * timeout value is required.
> > > > > + */
> > > > > +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
> > > > > +
> > > > > +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
> > > > > +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
> > > > > +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
> > > > > +
> > > > > +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
> > > > > +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);
> > > > > +struct xe_eudebug_event_log *
> > > > > +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
> > > > > +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
> > > > > +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
> > > > > +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
> > > > > +				  uint32_t filter);
> > > > > +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
> > > > > +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
> > > > > +
> > > > > +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_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, int timeout_s);
> > > > > +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
> > > > > +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
> > > > > +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
> > > > > +				     xe_eudebug_trigger_fn fn);
> > > > > +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
> > > > > +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
> > > > > +
> > > > > +struct xe_eudebug_client *
> > > > > +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
> > > > > +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
> > > > > +void xe_eudebug_client_start(struct xe_eudebug_client *c);
> > > > > +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
> > > > > +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
> > > > > +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
> > > > > +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
> > > > > +
> > > > > +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
> > > > > +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
> > > > > +
> > > > > +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 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,
> > > > > +					     struct drm_xe_exec_queue_create *create);
> > > > > +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
> > > > > +					  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,
> > > > > +				     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,
> > > > > +					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,
> > > > > +			   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,
> > > > > +				     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,
> > > > > +			       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,
> > > > > +				       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,
> > > > > +				 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,
> > > > > +						     void *test_private);
> > > > > +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
> > > > > +void xe_eudebug_session_run(struct xe_eudebug_session *s);
> > > > > +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
> > > > > -- 
> > > > > 2.34.1
> > > > > 

Re: [PATCH i-g-t v3 04/14] lib/xe_eudebug: Introduce eu debug testing framework

[Manszewski, Christoph]

Hi Kamil,

On 22.08.2024 17:39, Kamil Konieczny wrote:
> Hi Zbigniew,
> On 2024-08-21 at 11:31:40 +0200, Zbigniew Kempczyński wrote:
>> On Tue, Aug 20, 2024 at 07:45:18PM +0200, Kamil Konieczny wrote:
>>> Hi Manszewski,,
>>> On 2024-08-20 at 18:14:07 +0200, Manszewski, Christoph wrote:
>>>> Hi Zbigniew,
>>>>
>>>> On 20.08.2024 10:14, Zbigniew Kempczyński wrote:
>>>>> On Fri, Aug 09, 2024 at 02:38:03PM +0200, Christoph Manszewski wrote:
>>>>>> From: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>>>>>
>>>>>> Introduce library which simplifies testing of eu debug capability.
>>>>>> The library provides event log helpers together with asynchronous
>>>>>> abstraction for client proccess and the debugger itself.
>>>>>>
>>>>>> xe_eudebug_client creates its own proccess with user's work function,
>>>>>> and gives machanisms to synchronize beginning of execution and event
>>>>>> logging.
>>>>>>
>>>>>> xe_eudebug_debugger allows to attach to the given proccess, provides
>>>>>> asynchronous thread for event reading and introduces triggers -
>>>>>> a callback mechanism triggered every time subscribed event was read.
>>>>>>
>>>>>> Signed-off-by: Dominik Grzegorzek <dominik.grzegorzek@intel.com>
>>>>>> Signed-off-by: Mika Kuoppala <mika.kuaoppala@linux.intel.com>
>>>>>> Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
>>>>>> Signed-off-by: Maciej Patelczyk <maciej.patelczyk@intel.com>
>>>>>> Signed-off-by: Pawel Sikora <pawel.sikora@intel.com>
>>>>>> Signed-off-by: Karolina Stolarek <karolina.stolarek@intel.com>
>>>>>> ---
>>>>>>    lib/meson.build     |    1 +
>>>>>>    lib/xe/xe_eudebug.c | 2192 +++++++++++++++++++++++++++++++++++++++++++
>>>>>>    lib/xe/xe_eudebug.h |  206 ++++
>>>>>>    3 files changed, 2399 insertions(+)
>>>>>>    create mode 100644 lib/xe/xe_eudebug.c
>>>>>>    create mode 100644 lib/xe/xe_eudebug.h
>>>>>>
>>>>>> diff --git a/lib/meson.build b/lib/meson.build
>>>>>> index f711e60a7..969ca4101 100644
>>>>>> --- a/lib/meson.build
>>>>>> +++ b/lib/meson.build
>>>>>> @@ -111,6 +111,7 @@ lib_sources = [
>>>>>>    	'igt_msm.c',
>>>>>>    	'igt_dsc.c',
>>>>>>    	'xe/xe_gt.c',
>>>>>> +	'xe/xe_eudebug.c',
>>>>>>    	'xe/xe_ioctl.c',
>>>>>>    	'xe/xe_mmio.c',
>>>>>>    	'xe/xe_query.c',
>>>>>
>>>>> As eudebug is quite big feature I think it should be separated and
>>>>> hidden behind a feature flag (check meson_options.txt), lets say
>>>>> 'xe_eudebug' which would be disabled by default. This way you can
>>>>> develop it upstream even if kernel side is not officially merged.
>>>>> I'm pragramatic and I see no reason to block not accepted feature
>>>>> especially this would imo speed up developement. A final step when
>>>>> kernel change would be accepted and merged would be to sync with
>>>>> uapi and remove local definitions.
>>>>>
>>>>> I look forward maintainers comments is my attitude acceptable.
>>>>
>>>> I agree that it is a good idea. The only problem that arises is for
>>>> 'xe_exec_sip'. We add a dependency on eudebug to this test - any ideas how
>>>> to approach this correctly? The only thing that comes to my mind is
>>>> conditional compilation with 'ifdef' statements but it doesn't appear to be
>>>> pretty.
>>>
>>> What about adding skips in added tests if kernel do not support eudebug?
>>>
>>> This way you can have it without conditional compilation with
>>> ifdef/meson and also have it compile-time tested (if CI support test-with
>>> for Xe kernels).
>>
>> IMO simplest is to migrate code to xe_exec_sip_eudebug.c.
>>
> 
> What about shorter name like xe_eudebug_sip.c ?

Well that depends on the motivation. The name proposed by Zbyszek better 
undelines the fact that this is a variation of 'xe_exec_sip.c'. And 
eventually, after the eudebug feature gets merged to KMD, I would assume 
we could merge those two tests back into one.

Thanks,
Christoph
> 
> Regards,
> Kamil
> 
>> --
>> Zbigniew
>>
>>
>>>
>>> Regards,
>>> Kamil
>>>
>>>>
>>>> Thanks,
>>>> Christoph
>>>>>
>>>>> --
>>>>> Zbigniew
>>>>>
>>>>>
>>>>>> diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c
>>>>>> new file mode 100644
>>>>>> index 000000000..4eac87476
>>>>>> --- /dev/null
>>>>>> +++ b/lib/xe/xe_eudebug.c
>>>>>> @@ -0,0 +1,2192 @@
>>>>>> +// SPDX-License-Identifier: MIT
>>>>>> +/*
>>>>>> + * Copyright © 2023 Intel Corporation
>>>>>> + */
>>>>>> +
>>>>>> +#include <fcntl.h>
>>>>>> +#include <poll.h>
>>>>>> +#include <signal.h>
>>>>>> +#include <sys/select.h>
>>>>>> +#include <sys/stat.h>
>>>>>> +#include <sys/types.h>
>>>>>> +#include <sys/wait.h>
>>>>>> +
>>>>>> +#include "igt.h"
>>>>>> +#include "igt_sysfs.h"
>>>>>> +#include "intel_pat.h"
>>>>>> +#include "xe_eudebug.h"
>>>>>> +#include "xe_ioctl.h"
>>>>>> +
>>>>>> +struct event_trigger {
>>>>>> +	xe_eudebug_trigger_fn fn;
>>>>>> +	int type;
>>>>>> +	struct igt_list_head link;
>>>>>> +};
>>>>>> +
>>>>>> +struct seqno_list_entry {
>>>>>> +	struct igt_list_head link;
>>>>>> +	uint64_t seqno;
>>>>>> +};
>>>>>> +
>>>>>> +struct match_dto {
>>>>>> +	struct drm_xe_eudebug_event *target;
>>>>>> +	struct igt_list_head *seqno_list;
>>>>>> +	uint64_t client_handle;
>>>>>> +	uint32_t filter;
>>>>>> +
>>>>>> +	/* store latest 'EVENT_VM_BIND' seqno */
>>>>>> +	uint64_t *bind_seqno;
>>>>>> +	/* latest vm_bind_op seqno matching bind_seqno */
>>>>>> +	uint64_t *bind_op_seqno;
>>>>>> +};
>>>>>> +
>>>>>> +#define CLIENT_PID  1
>>>>>> +#define CLIENT_RUN  2
>>>>>> +#define CLIENT_FINI 3
>>>>>> +#define CLIENT_STOP 4
>>>>>> +#define CLIENT_STAGE 5
>>>>>> +#define DEBUGGER_STAGE 6
>>>>>> +
>>>>>> +#define DEBUGGER_WORKER_INACTIVE  0
>>>>>> +#define DEBUGGER_WORKER_ACTIVE  1
>>>>>> +#define DEBUGGER_WORKER_QUITTING 2
>>>>>> +
>>>>>> +static const char *type_to_str(unsigned int type)
>>>>>> +{
>>>>>> +	switch (type) {
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_NONE:
>>>>>> +		return "none";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_READ:
>>>>>> +		return "read";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN:
>>>>>> +		return "client";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM:
>>>>>> +		return "vm";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE:
>>>>>> +		return "exec_queue";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
>>>>>> +		return "attention";
>>>>>> +	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_UFENCE:
>>>>>> +		return "vm_bind_ufence";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA:
>>>>>> +		return "metadata";
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA:
>>>>>> +		return "vm_bind_op_metadata";
>>>>>> +	}
>>>>>> +
>>>>>> +	return "UNKNOWN";
>>>>>> +}
>>>>>> +
>>>>>> +static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf)
>>>>>> +{
>>>>>> +	sprintf(buf, "%s(%d)", type_to_str(e->type), e->type);
>>>>>> +
>>>>>> +	return buf;
>>>>>> +}
>>>>>> +
>>>>>> +static const char *flags_to_str(unsigned int flags)
>>>>>> +{
>>>>>> +	if (flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>>>>>> +		if (flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)
>>>>>> +			return "create|ack";
>>>>>> +		else
>>>>>> +			return "create";
>>>>>> +	}
>>>>>> +	if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY)
>>>>>> +		return "destroy";
>>>>>> +
>>>>>> +	if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE)
>>>>>> +		return "state-change";
>>>>>> +
>>>>>> +	igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK));
>>>>>> +
>>>>>> +	return "flags unknown";
>>>>>> +}
>>>>>> +
>>>>>> +static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)
>>>>>> +{
>>>>>> +	switch (e->type) {
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>>>>>> +		struct drm_xe_eudebug_event_client *ec = (struct drm_xe_eudebug_event_client *)e;
>>>>>> +
>>>>>> +		sprintf(b, "handle=%llu", ec->client_handle);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>>>>>> +		struct drm_xe_eudebug_event_vm *evm = (struct drm_xe_eudebug_event_vm *)e;
>>>>>> +
>>>>>> +		sprintf(b, "client_handle=%llu, handle=%llu",
>>>>>> +			evm->client_handle, evm->vm_handle);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>>>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, "
>>>>>> +			   "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d",
>>>>>> +			ee->client_handle, ee->vm_handle,
>>>>>> +			ee->exec_queue_handle, ee->engine_class, ee->width);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
>>>>>> +		struct drm_xe_eudebug_event_eu_attention *ea = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "client_handle=%llu, exec_queue_handle=%llu, "
>>>>>> +			   "lrc_handle=%llu, bitmask_size=%d",
>>>>>> +			ea->client_handle, ea->exec_queue_handle,
>>>>>> +			ea->lrc_handle, ea->bitmask_size);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u",
>>>>>> +			evmb->client_handle, 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 = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
>>>>>> +			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu",
>>>>>> +			em->client_handle, em->metadata_handle, em->type, em->len);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e;
>>>>>> +
>>>>>> +		sprintf(b, "vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu",
>>>>>> +			op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	default:
>>>>>> +		strcpy(b, "<...>");
>>>>>> +	}
>>>>>> +
>>>>>> +	return b;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_to_str:
>>>>>> + * @e: pointer to event
>>>>>> + * @buf: target to write string representation of @e
>>>>>> + * @len: size of target buffer @buf
>>>>>> + *
>>>>>> + * Creates string representation for given event.
>>>>>> + *
>>>>>> + * Returns: the written input buffer pointed by @buf.
>>>>>> + */
>>>>>> +const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len)
>>>>>> +{
>>>>>> +	char a[256];
>>>>>> +	char b[256];
>>>>>> +
>>>>>> +	snprintf(buf, len, "(%llu) %15s:%s: %s",
>>>>>> +		 e->seqno,
>>>>>> +		 event_type_to_str(e, a),
>>>>>> +		 flags_to_str(e->flags),
>>>>>> +		 event_members_to_str(e, b));
>>>>>> +
>>>>>> +	return buf;
>>>>>> +}
>>>>>> +
>>>>>> +static void catch_child_failure(void)
>>>>>> +{
>>>>>> +	pid_t pid;
>>>>>> +	int status;
>>>>>> +
>>>>>> +	pid = waitpid(-1, &status, WNOHANG);
>>>>>> +
>>>>>> +	if (pid == 0 || pid == -1)
>>>>>> +		return;
>>>>>> +
>>>>>> +	if (!WIFEXITED(status))
>>>>>> +		return;
>>>>>> +
>>>>>> +	igt_assert_f(WEXITSTATUS(status) == 0, "Client failed!\n");
>>>>>> +}
>>>>>> +
>>>>>> +static int safe_pipe_read(int pipe[2], void *buf, int nbytes, int timeout_ms)
>>>>>> +{
>>>>>> +	int ret;
>>>>>> +	int t = 0;
>>>>>> +	struct pollfd fd = {
>>>>>> +		.fd = pipe[0],
>>>>>> +		.events = POLLIN,
>>>>>> +		.revents = 0
>>>>>> +	};
>>>>>> +
>>>>>> +	/* When child fails we may get stuck forever. Check whether
>>>>>> +	 * the child process ended with an error.
>>>>>> +	 */
>>>>>> +	do {
>>>>>> +		const int interval_ms = 1000;
>>>>>> +
>>>>>> +		ret = poll(&fd, 1, interval_ms);
>>>>>> +
>>>>>> +		if (!ret) {
>>>>>> +			catch_child_failure();
>>>>>> +			t += interval_ms;
>>>>>> +		}
>>>>>> +	} while (!ret && t < timeout_ms);
>>>>>> +
>>>>>> +	if (ret > 0)
>>>>>> +		return read(pipe[0], buf, nbytes);
>>>>>> +
>>>>>> +	return 0;
>>>>>> +}
>>>>>> +
>>>>>> +static uint64_t pipe_read(int pipe[2], int timeout_ms)
>>>>>> +{
>>>>>> +	uint64_t in;
>>>>>> +	uint64_t ret;
>>>>>> +
>>>>>> +	ret = safe_pipe_read(pipe, &in, sizeof(in), timeout_ms);
>>>>>> +	igt_assert(ret == sizeof(in));
>>>>>> +
>>>>>> +	return in;
>>>>>> +}
>>>>>> +
>>>>>> +static void pipe_signal(int pipe[2], uint64_t token)
>>>>>> +{
>>>>>> +	igt_assert(write(pipe[1], &token, sizeof(token)) == sizeof(token));
>>>>>> +}
>>>>>> +
>>>>>> +static void pipe_close(int pipe[2])
>>>>>> +{
>>>>>> +	if (pipe[0] != -1)
>>>>>> +		close(pipe[0]);
>>>>>> +
>>>>>> +	if (pipe[1] != -1)
>>>>>> +		close(pipe[1]);
>>>>>> +}
>>>>>> +
>>>>>> +static uint64_t __wait_token(int p[2], const uint64_t token, int timeout_ms)
>>>>>> +{
>>>>>> +	uint64_t in;
>>>>>> +
>>>>>> +	in = pipe_read(p, timeout_ms);
>>>>>> +
>>>>>> +	igt_assert_eq(in, token);
>>>>>> +
>>>>>> +	return pipe_read(p, timeout_ms);
>>>>>> +}
>>>>>> +
>>>>>> +static uint64_t client_wait_token(struct xe_eudebug_client *c,
>>>>>> +				 const uint64_t token)
>>>>>> +{
>>>>>> +	return __wait_token(c->p_in, token, c->timeout_ms);
>>>>>> +}
>>>>>> +
>>>>>> +static uint64_t wait_from_client(struct xe_eudebug_client *c,
>>>>>> +				 const uint64_t token)
>>>>>> +{
>>>>>> +	return __wait_token(c->p_out, token, c->timeout_ms);
>>>>>> +}
>>>>>> +
>>>>>> +static void token_signal(int p[2], const uint64_t token, const uint64_t value)
>>>>>> +{
>>>>>> +	pipe_signal(p, token);
>>>>>> +	pipe_signal(p, value);
>>>>>> +}
>>>>>> +
>>>>>> +static void client_signal(struct xe_eudebug_client *c,
>>>>>> +			  const uint64_t token,
>>>>>> +			  const uint64_t value)
>>>>>> +{
>>>>>> +	token_signal(c->p_out, token, value);
>>>>>> +}
>>>>>> +
>>>>>> +static int __xe_eudebug_connect(int fd, pid_t pid, uint32_t flags, uint64_t events)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_connect param = {
>>>>>> +		.pid = pid,
>>>>>> +		.flags = flags,
>>>>>> +	};
>>>>>> +	int debugfd;
>>>>>> +
>>>>>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>>>>>> +
>>>>>> +	if (debugfd < 0)
>>>>>> +		return -errno;
>>>>>> +
>>>>>> +	return debugfd;
>>>>>> +}
>>>>>> +
>>>>>> +static void event_log_write_to_fd(struct xe_eudebug_event_log *l, int fd)
>>>>>> +{
>>>>>> +	igt_assert_eq(write(fd, &l->head, sizeof(l->head)),
>>>>>> +		      sizeof(l->head));
>>>>>> +
>>>>>> +	igt_assert_eq(write(fd, l->log, l->head), l->head);
>>>>>> +}
>>>>>> +
>>>>>> +static void read_all(int fd, void *buf, size_t nbytes)
>>>>>> +{
>>>>>> +	ssize_t remaining_size = nbytes;
>>>>>> +	ssize_t current_size = 0;
>>>>>> +	ssize_t read_size = 0;
>>>>>> +
>>>>>> +	do {
>>>>>> +		read_size = read(fd, buf + current_size, remaining_size);
>>>>>> +		igt_assert_f(read_size >= 0, "read failed: %s\n", strerror(errno));
>>>>>> +
>>>>>> +		current_size += read_size;
>>>>>> +		remaining_size -= read_size;
>>>>>> +	} while (remaining_size > 0 && read_size > 0);
>>>>>> +
>>>>>> +	igt_assert_eq(current_size, nbytes);
>>>>>> +}
>>>>>> +
>>>>>> +static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd)
>>>>>> +{
>>>>>> +	read_all(fd, &l->head, sizeof(l->head));
>>>>>> +	igt_assert_lt(l->head, l->max_size);
>>>>>> +
>>>>>> +	read_all(fd, l->log, l->head);
>>>>>> +}
>>>>>> +
>>>>>> +typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *);
>>>>>> +
>>>>>> +static struct drm_xe_eudebug_event *
>>>>>> +event_cmp(struct xe_eudebug_event_log *l,
>>>>>> +	  struct drm_xe_eudebug_event *current,
>>>>>> +	  cmp_fn_t match,
>>>>>> +	  void *data)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *e = current;
>>>>>> +
>>>>>> +	xe_eudebug_for_each_event(e, l) {
>>>>>> +		if (match(e, data))
>>>>>> +			return e;
>>>>>> +	}
>>>>>> +
>>>>>> +	return NULL;
>>>>>> +}
>>>>>> +
>>>>>> +static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *b = data;
>>>>>> +
>>>>>> +	if (a->type == b->type &&
>>>>>> +	    a->flags == b->flags)
>>>>>> +		return 1;
>>>>>> +
>>>>>> +	return 0;
>>>>>> +}
>>>>>> +
>>>>>> +static int match_fields(struct drm_xe_eudebug_event *a, void *data)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *b = data;
>>>>>> +	int ret = 0;
>>>>>> +
>>>>>> +	ret = match_type_and_flags(a, data);
>>>>>> +	if (!ret)
>>>>>> +		return ret;
>>>>>> +
>>>>>> +	ret = 0;
>>>>>> +
>>>>>> +	switch (a->type) {
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>>>> +		struct drm_xe_eudebug_event_exec_queue *ae = (void *)a;
>>>>>> +		struct drm_xe_eudebug_event_exec_queue *be = (void *)b;
>>>>>> +
>>>>>> +		if (ae->engine_class == be->engine_class && ae->width == be->width)
>>>>>> +			ret = 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind *ea = (void *)a;
>>>>>> +		struct drm_xe_eudebug_event_vm_bind *eb = (void *)b;
>>>>>> +
>>>>>> +		if (ea->num_binds == eb->num_binds)
>>>>>> +			ret = 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a;
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b;
>>>>>> +
>>>>>> +		if (ea->addr == eb->addr && ea->range == eb->range &&
>>>>>> +		    ea->num_extensions == eb->num_extensions)
>>>>>> +			ret = 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a;
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b;
>>>>>> +
>>>>>> +		if (ea->metadata_handle == eb->metadata_handle &&
>>>>>> +		    ea->metadata_cookie == eb->metadata_cookie)
>>>>>> +			ret = 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +
>>>>>> +	default:
>>>>>> +		ret = 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +
>>>>>> +	return ret;
>>>>>> +}
>>>>>> +
>>>>>> +static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
>>>>>> +{
>>>>>> +	struct match_dto *md = (void *)data;
>>>>>> +	uint64_t *bind_seqno = md->bind_seqno;
>>>>>> +	uint64_t *bind_op_seqno = md->bind_op_seqno;
>>>>>> +	uint64_t h = md->client_handle;
>>>>>> +
>>>>>> +	if (XE_EUDEBUG_EVENT_IS_FILTERED(e->type, md->filter))
>>>>>> +		return 0;
>>>>>> +
>>>>>> +	switch (e->type) {
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>>>>>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>>>>>> +
>>>>>> +		if (client->client_handle == h)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>>>>>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>>>>>> +
>>>>>> +		if (vm->client_handle == h)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>>>> +		struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e;
>>>>>> +
>>>>>> +		if (ee->client_handle == h)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e;
>>>>>> +
>>>>>> +		if (evmb->client_handle == h) {
>>>>>> +			*bind_seqno = evmb->base.seqno;
>>>>>> +			return 1;
>>>>>> +		}
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e;
>>>>>> +
>>>>>> +		if (eo->vm_bind_ref_seqno == *bind_seqno) {
>>>>>> +			*bind_op_seqno = eo->base.seqno;
>>>>>> +			return 1;
>>>>>> +		}
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_ufence *ef  = (struct drm_xe_eudebug_event_vm_bind_ufence *)e;
>>>>>> +
>>>>>> +		if (ef->vm_bind_ref_seqno == *bind_seqno)
>>>>>> +			return 1;
>>>>>> +
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e;
>>>>>> +
>>>>>> +		if (em->client_handle == h)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e;
>>>>>> +
>>>>>> +		if (eo->vm_bind_op_ref_seqno == *bind_op_seqno)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	default:
>>>>>> +		break;
>>>>>> +	}
>>>>>> +
>>>>>> +	return 0;
>>>>>> +}
>>>>>> +
>>>>>> +static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
>>>>>> +{
>>>>>> +
>>>>>> +	struct drm_xe_eudebug_event *d = (void *)data;
>>>>>> +	int ret;
>>>>>> +
>>>>>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>>>>>> +	d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK);
>>>>>> +	ret = match_type_and_flags(e, data);
>>>>>> +	d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY;
>>>>>> +
>>>>>> +	if (!ret)
>>>>>> +		return 0;
>>>>>> +
>>>>>> +	switch (e->type) {
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_OPEN: {
>>>>>> +		struct drm_xe_eudebug_event_client *client = (struct drm_xe_eudebug_event_client *)e;
>>>>>> +		struct drm_xe_eudebug_event_client *filter = (struct drm_xe_eudebug_event_client *)data;
>>>>>> +
>>>>>> +		if (client->client_handle == filter->client_handle)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM: {
>>>>>> +		struct drm_xe_eudebug_event_vm *vm = (struct drm_xe_eudebug_event_vm *)e;
>>>>>> +		struct drm_xe_eudebug_event_vm *filter = (struct drm_xe_eudebug_event_vm *)data;
>>>>>> +
>>>>>> +		if (vm->vm_handle == filter->vm_handle)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
>>>>>> +		struct drm_xe_eudebug_event_exec_queue *ee = (void *)e;
>>>>>> +		struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data;
>>>>>> +
>>>>>> +		if (ee->exec_queue_handle == filter->exec_queue_handle)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e;
>>>>>> +		struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data;
>>>>>> +
>>>>>> +		if (evmb->vm_handle == filter->vm_handle &&
>>>>>> +		    evmb->num_binds == filter->num_binds)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e;
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data;
>>>>>> +
>>>>>> +		if (avmb->addr == filter->addr &&
>>>>>> +		    avmb->range == filter->range)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_metadata *em = (void *)e;
>>>>>> +		struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data;
>>>>>> +
>>>>>> +		if (em->metadata_handle == filter->metadata_handle)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e;
>>>>>> +		struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data;
>>>>>> +
>>>>>> +		if (avmb->metadata_handle == filter->metadata_handle &&
>>>>>> +		    avmb->metadata_cookie == filter->metadata_cookie)
>>>>>> +			return 1;
>>>>>> +		break;
>>>>>> +	}
>>>>>> +
>>>>>> +	default:
>>>>>> +		break;
>>>>>> +	}
>>>>>> +	return 0;
>>>>>> +}
>>>>>> +
>>>>>> +static int match_full(struct drm_xe_eudebug_event *e, void *data)
>>>>>> +{
>>>>>> +	struct seqno_list_entry *sl;
>>>>>> +
>>>>>> +	struct match_dto *md = (void *)data;
>>>>>> +	int ret = 0;
>>>>>> +
>>>>>> +	ret = match_client_handle(e, md);
>>>>>> +	if (!ret)
>>>>>> +		return 0;
>>>>>> +
>>>>>> +	ret = match_fields(e, md->target);
>>>>>> +	if (!ret)
>>>>>> +		return 0;
>>>>>> +
>>>>>> +	igt_list_for_each_entry(sl, md->seqno_list, link) {
>>>>>> +		if (sl->seqno == e->seqno)
>>>>>> +			return 0;
>>>>>> +	}
>>>>>> +
>>>>>> +	return 1;
>>>>>> +}
>>>>>> +
>>>>>> +static struct drm_xe_eudebug_event *
>>>>>> +event_type_match(struct xe_eudebug_event_log *l,
>>>>>> +		 struct drm_xe_eudebug_event *target,
>>>>>> +		 struct drm_xe_eudebug_event *current)
>>>>>> +{
>>>>>> +	return event_cmp(l, current, match_type_and_flags, target);
>>>>>> +}
>>>>>> +
>>>>>> +static struct drm_xe_eudebug_event *
>>>>>> +client_match(struct xe_eudebug_event_log *l,
>>>>>> +	     uint64_t client_handle,
>>>>>> +	     struct drm_xe_eudebug_event *current,
>>>>>> +	     uint32_t filter,
>>>>>> +	     uint64_t *bind_seqno,
>>>>>> +	     uint64_t *bind_op_seqno)
>>>>>> +{
>>>>>> +	struct match_dto md = {
>>>>>> +		.client_handle = client_handle,
>>>>>> +		.filter = filter,
>>>>>> +		.bind_seqno = bind_seqno,
>>>>>> +		.bind_op_seqno = bind_op_seqno,
>>>>>> +	};
>>>>>> +
>>>>>> +	return event_cmp(l, current, match_client_handle, &md);
>>>>>> +}
>>>>>> +
>>>>>> +static struct drm_xe_eudebug_event *
>>>>>> +opposite_event_match(struct xe_eudebug_event_log *l,
>>>>>> +		    struct drm_xe_eudebug_event *target,
>>>>>> +		    struct drm_xe_eudebug_event *current)
>>>>>> +{
>>>>>> +	return event_cmp(l, current, match_opposite_resource, target);
>>>>>> +}
>>>>>> +
>>>>>> +static struct drm_xe_eudebug_event *
>>>>>> +event_match(struct xe_eudebug_event_log *l,
>>>>>> +	    struct drm_xe_eudebug_event *target,
>>>>>> +	    uint64_t client_handle,
>>>>>> +	    struct igt_list_head *seqno_list,
>>>>>> +	    uint64_t *bind_seqno,
>>>>>> +	    uint64_t *bind_op_seqno)
>>>>>> +{
>>>>>> +	struct match_dto md = {
>>>>>> +		.target = target,
>>>>>> +		.client_handle = client_handle,
>>>>>> +		.seqno_list = seqno_list,
>>>>>> +		.bind_seqno = bind_seqno,
>>>>>> +		.bind_op_seqno = bind_op_seqno,
>>>>>> +	};
>>>>>> +
>>>>>> +	return event_cmp(l, NULL, match_full, &md);
>>>>>> +}
>>>>>> +
>>>>>> +static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce,
>>>>>> +			   struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de,
>>>>>> +			   uint32_t filter)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_client *ce = (void *)_ce;
>>>>>> +	struct drm_xe_eudebug_event_client *de = (void *)_de;
>>>>>> +	uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0;
>>>>>> +
>>>>>> +	struct igt_list_head matched_seqno_list;
>>>>>> +	struct drm_xe_eudebug_event *hc, *hd;
>>>>>> +	struct seqno_list_entry *entry, *tmp;
>>>>>> +
>>>>>> +	igt_assert(ce);
>>>>>> +	igt_assert(de);
>>>>>> +
>>>>>> +	igt_debug("client: %llu -> %llu\n", ce->client_handle, de->client_handle);
>>>>>> +
>>>>>> +	hc = NULL;
>>>>>> +	hd = NULL;
>>>>>> +	IGT_INIT_LIST_HEAD(&matched_seqno_list);
>>>>>> +
>>>>>> +	do {
>>>>>> +		hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso);
>>>>>> +		if (!hc)
>>>>>> +			break;
>>>>>> +
>>>>>> +		hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso);
>>>>>> +
>>>>>> +		igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n",
>>>>>> +			     c->name,
>>>>>> +			     hc->seqno,
>>>>>> +			     hc->type,
>>>>>> +			     ce->client_handle);
>>>>>> +
>>>>>> +		igt_debug("comparing %s %llu vs %s %llu\n",
>>>>>> +			  c->name, hc->seqno, d->name, hd->seqno);
>>>>>> +
>>>>>> +		/*
>>>>>> +		 * Store the seqno of the event that was matched above,
>>>>>> +		 * inside 'matched_seqno_list', to avoid it getting matched
>>>>>> +		 * by subsequent 'event_match' calls.
>>>>>> +		 */
>>>>>> +		entry = malloc(sizeof(*entry));
>>>>>> +		entry->seqno = hd->seqno;
>>>>>> +		igt_list_add(&entry->link, &matched_seqno_list);
>>>>>> +	} while (hc);
>>>>>> +
>>>>>> +	igt_list_for_each_entry_safe(entry, tmp, &matched_seqno_list, link)
>>>>>> +		free(entry);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_find_seqno:
>>>>>> + * @l: event log pointer
>>>>>> + * @seqno: seqno of event to be found
>>>>>> + *
>>>>>> + * Finds the event with given seqno in the event log.
>>>>>> + *
>>>>>> + * Returns: pointer to the event with given seqno within @l or NULL seqno is
>>>>>> + * not present.
>>>>>> + */
>>>>>> +struct drm_xe_eudebug_event *
>>>>>> +xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *e = NULL, *found = NULL;
>>>>>> +
>>>>>> +	igt_assert_neq(seqno, 0);
>>>>>> +	/*
>>>>>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>>>>>> +	 * as our post processing of events is not optimized.
>>>>>> +	 */
>>>>>> +	igt_assert_lt(seqno, 10 * 1000 * 1000);
>>>>>> +
>>>>>> +	xe_eudebug_for_each_event(e, l) {
>>>>>> +		if (e->seqno == seqno) {
>>>>>> +			if (found) {
>>>>>> +				igt_warn("Found multiple events with the same seqno %lu\n", seqno);
>>>>>> +				xe_eudebug_event_log_print(l, false);
>>>>>> +				igt_assert(!found);
>>>>>> +			}
>>>>>> +			found = e;
>>>>>> +		}
>>>>>> +	}
>>>>>> +
>>>>>> +	return found;
>>>>>> +}
>>>>>> +
>>>>>> +static void event_log_sort(struct xe_eudebug_event_log *l)
>>>>>> +{
>>>>>> +	struct xe_eudebug_event_log *tmp;
>>>>>> +	struct drm_xe_eudebug_event *e = NULL;
>>>>>> +	uint64_t first_seqno = 0;
>>>>>> +	uint64_t last_seqno = 0;
>>>>>> +	uint64_t events = 0, added = 0;
>>>>>> +	uint64_t i;
>>>>>> +
>>>>>> +	xe_eudebug_for_each_event(e, l) {
>>>>>> +		if (e->seqno > last_seqno)
>>>>>> +			last_seqno = e->seqno;
>>>>>> +
>>>>>> +		if (e->seqno < first_seqno)
>>>>>> +			first_seqno = e->seqno;
>>>>>> +
>>>>>> +		events++;
>>>>>> +	}
>>>>>> +
>>>>>> +	tmp = xe_eudebug_event_log_create("tmp", l->max_size);
>>>>>> +
>>>>>> +	for (i = 1; i <= last_seqno; i++) {
>>>>>> +		e = xe_eudebug_event_log_find_seqno(l, i);
>>>>>> +		if (e) {
>>>>>> +			xe_eudebug_event_log_write(tmp, e);
>>>>>> +			added++;
>>>>>> +		}
>>>>>> +	}
>>>>>> +
>>>>>> +	igt_assert_eq(events, added);
>>>>>> +	igt_assert_eq(tmp->head, l->head);
>>>>>> +
>>>>>> +	memcpy(l->log, tmp->log, tmp->head);
>>>>>> +
>>>>>> +	xe_eudebug_event_log_destroy(tmp);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_connect:
>>>>>> + * @fd: Xe file descriptor
>>>>>> + * @pid: client PID
>>>>>> + * @flags: connection flags
>>>>>> + *
>>>>>> + * Opens the xe eu debugger connection to the process described by @pid
>>>>>> + *
>>>>>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>>>>>> + */
>>>>>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags)
>>>>>> +{
>>>>>> +	int ret;
>>>>>> +	uint64_t events = 0; /* events filtering not supported yet! */
>>>>>> +
>>>>>> +	ret = __xe_eudebug_connect(fd, pid, flags, events);
>>>>>> +
>>>>>> +	return ret;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_create:
>>>>>> + * @name: event log identifier
>>>>>> + * @max_size: maximum size of created log
>>>>>> + *
>>>>>> + * Function creates an Eu Debugger event log with size equal to @max_size.
>>>>>> + *
>>>>>> + * Returns: pointer to just created log
>>>>>> + */
>>>>>> +#define MAX_EVENT_LOG_SIZE (32 * 1024 * 1024)
>>>>>> +struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigned int max_size)
>>>>>> +{
>>>>>> +	struct xe_eudebug_event_log *l;
>>>>>> +
>>>>>> +	l = calloc(1, sizeof(*l));
>>>>>> +	igt_assert(l);
>>>>>> +	l->log = calloc(1, max_size);
>>>>>> +	igt_assert(l->log);
>>>>>> +	l->max_size = max_size;
>>>>>> +	strncpy(l->name, name, sizeof(l->name) - 1);
>>>>>> +	pthread_mutex_init(&l->lock, NULL);
>>>>>> +
>>>>>> +	return l;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_destroy:
>>>>>> + * @l: event log pointer
>>>>>> + *
>>>>>> + * Frees given event log @l.
>>>>>> + */
>>>>>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)
>>>>>> +{
>>>>>> +	pthread_mutex_destroy(&l->lock);
>>>>>> +	free(l->log);
>>>>>> +	free(l);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_write:
>>>>>> + * @l: event log pointer
>>>>>> + * @e: event to be written to event log
>>>>>> + *
>>>>>> + * Writes event @e to the event log, thread-safe.
>>>>>> + */
>>>>>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e)
>>>>>> +{
>>>>>> +	igt_assert(e->seqno);
>>>>>> +	/*
>>>>>> +	 * Try to catch if seqno is corrupted and prevent too long tests,
>>>>>> +	 * as our post processing of events is not optimized.
>>>>>> +	 */
>>>>>> +	igt_assert_lt(e->seqno, 10 * 1000 * 1000);
>>>>>> +
>>>>>> +	pthread_mutex_lock(&l->lock);
>>>>>> +	igt_assert_lt(l->head + e->len, l->max_size);
>>>>>> +	memcpy(l->log + l->head, e, e->len);
>>>>>> +	l->head += e->len;
>>>>>> +
>>>>>> +#ifdef DEBUG_LOG
>>>>>> +	igt_info("%s: wrote %u bytes to eventlog, free %u bytes\n",
>>>>>> +		 l->name, e->len, l->max_size - l->head);
>>>>>> +#endif
>>>>>> +	pthread_mutex_unlock(&l->lock);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_print:
>>>>>> + * @l: event log pointer
>>>>>> + * @debug: when true function uses igt_debug instead of igt_info.
>>>>>> + *
>>>>>> + * Prints given event log.
>>>>>> + */
>>>>>> +void
>>>>>> +xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *e = NULL;
>>>>>> +	int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO;
>>>>>> +	char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
>>>>>> +
>>>>>> +	igt_log(IGT_LOG_DOMAIN, level,
>>>>>> +		"event log '%s' (%u bytes):\n", l->name, l->head);
>>>>>> +
>>>>>> +	xe_eudebug_for_each_event(e, l) {
>>>>>> +		xe_eudebug_event_to_str(e, str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
>>>>>> +		igt_log(IGT_LOG_DOMAIN, level, "%s\n", str);
>>>>>> +	}
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_compare:
>>>>>> + * @a: event log pointer
>>>>>> + * @b: event log pointer
>>>>>> + * @filter: mask that represents events to be skipped during comparison, useful
>>>>>> + * for events like 'VM_BIND' since they can be asymmetric. Note that
>>>>>> + * 'DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched.
>>>>>> + *
>>>>>> + * Compares and asserts event logs @a, @b if the event
>>>>>> + * sequence matches.
>>>>>> + */
>>>>>> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b,
>>>>>> +				  uint32_t filter)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *ae = NULL;
>>>>>> +	struct drm_xe_eudebug_event *be = NULL;
>>>>>> +
>>>>>> +	xe_eudebug_for_each_event(ae, a) {
>>>>>> +		if (ae->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
>>>>>> +		    ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>>>>>> +			be = event_type_match(b, ae, be);
>>>>>> +
>>>>>> +			compare_client(a, ae, b, be, filter);
>>>>>> +			compare_client(b, be, a, ae, filter);
>>>>>> +		}
>>>>>> +	}
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_event_log_match_opposite:
>>>>>> + * @l: event log pointer
>>>>>> + * @filter: mask that represents events to be skipped during comparison, useful
>>>>>> + * for events like 'VM_BIND' since they can be asymmetric
>>>>>> + *
>>>>>> + * Matches and asserts content of all opposite events (create vs destroy).
>>>>>> + */
>>>>>> +void
>>>>>> +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event *ce = NULL;
>>>>>> +	struct drm_xe_eudebug_event *de = NULL;
>>>>>> +
>>>>>> +	xe_eudebug_for_each_event(ce, l) {
>>>>>> +		if (ce->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
>>>>>> +			uint8_t offset = sizeof(struct drm_xe_eudebug_event);
>>>>>> +			int opposite_matching;
>>>>>> +
>>>>>> +			if (XE_EUDEBUG_EVENT_IS_FILTERED(ce->type, filter))
>>>>>> +				continue;
>>>>>> +
>>>>>> +			/* No opposite matching for binds */
>>>>>> +			if ((ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND &&
>>>>>> +			     ce->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) ||
>>>>>> +			    ce->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
>>>>>> +				continue;
>>>>>> +
>>>>>> +			de = opposite_event_match(l, ce, ce);
>>>>>> +
>>>>>> +			igt_assert_f(de, "no opposite event of type %u found\n", ce->type);
>>>>>> +
>>>>>> +			igt_assert_eq(ce->len, de->len);
>>>>>> +			opposite_matching = memcmp((uint8_t *)de + offset,
>>>>>> +						   (uint8_t *)ce + offset,
>>>>>> +						   de->len - offset) == 0;
>>>>>> +
>>>>>> +			igt_assert_f(opposite_matching,
>>>>>> +				     "%s: create|destroy event not "
>>>>>> +				     "maching (%llu) vs (%llu)\n",
>>>>>> +				     l->name, de->seqno, ce->seqno);
>>>>>> +		}
>>>>>> +	}
>>>>>> +}
>>>>>> +
>>>>>> +static void debugger_run_triggers(struct xe_eudebug_debugger *d,
>>>>>> +				  struct drm_xe_eudebug_event *e)
>>>>>> +{
>>>>>> +	struct event_trigger *t;
>>>>>> +
>>>>>> +	igt_list_for_each_entry(t, &d->triggers, link) {
>>>>>> +		if (e->type == t->type)
>>>>>> +			t->fn(d, e);
>>>>>> +	}
>>>>>> +}
>>>>>> +
>>>>>> +#define MAX_EVENT_SIZE (32 * 1024)
>>>>>> +static int
>>>>>> +xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event)
>>>>>> +{
>>>>>> +	int ret;
>>>>>> +
>>>>>> +	event->type = DRM_XE_EUDEBUG_EVENT_READ;
>>>>>> +	event->flags = 0;
>>>>>> +	event->len = MAX_EVENT_SIZE;
>>>>>> +
>>>>>> +	ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event);
>>>>>> +	if (ret < 0)
>>>>>> +		return -errno;
>>>>>> +
>>>>>> +	return ret;
>>>>>> +}
>>>>>> +
>>>>>> +static void *debugger_worker_loop(void *data)
>>>>>> +{
>>>>>> +	uint8_t buf[MAX_EVENT_SIZE];
>>>>>> +	struct drm_xe_eudebug_event *e = (void *)buf;
>>>>>> +	struct xe_eudebug_debugger *d = data;
>>>>>> +	struct pollfd p = {
>>>>>> +		.events = POLLIN,
>>>>>> +		.revents = 0,
>>>>>> +	};
>>>>>> +	int timeout_ms = 100, ret;
>>>>>> +
>>>>>> +	igt_assert(d->master_fd >= 0);
>>>>>> +
>>>>>> +	do {
>>>>>> +		p.fd = d->fd;
>>>>>> +		ret = poll(&p, 1, timeout_ms);
>>>>>> +
>>>>>> +		if (ret == -1) {
>>>>>> +			igt_info("poll failed with errno %d\n", errno);
>>>>>> +			break;
>>>>>> +		}
>>>>>> +
>>>>>> +		if (ret == 1 && (p.revents & POLLIN)) {
>>>>>> +			int err = xe_eudebug_read_event(d->fd, e);
>>>>>> +
>>>>>> +			if (!err) {
>>>>>> +				++d->event_count;
>>>>>> +
>>>>>> +				xe_eudebug_event_log_write(d->log, e);
>>>>>> +				debugger_run_triggers(d, e);
>>>>>> +			} else {
>>>>>> +				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;
>>>>>> +	return NULL;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_available:
>>>>>> + * @fd: Xe file descriptor
>>>>>> + *
>>>>>> + * Returns: true it debugger connection is available, false otherwise.
>>>>>> + */
>>>>>> +bool xe_eudebug_debugger_available(int fd)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_connect param = { .pid = getpid() };
>>>>>> +	int debugfd;
>>>>>> +
>>>>>> +	debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, &param);
>>>>>> +	if (debugfd >= 0)
>>>>>> +		close(debugfd);
>>>>>> +
>>>>>> +	return debugfd >= 0;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_create:
>>>>>> + * @master_fd: xe client used to open the debugger connection
>>>>>> + * @flags: flags stored in a debugger structure, can be used at will
>>>>>> + * of the caller, i.e. to be used inside triggers.
>>>>>> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
>>>>>> + * can be shared between client and debugger. Can be NULL.
>>>>>> + *
>>>>>> + * Returns: newly created xe_eudebug_debugger structure with its
>>>>>> + * event log initialized. Note that to open the connection
>>>>>> + * you need call @xe_eudebug_debugger_attach.
>>>>>> + */
>>>>>> +struct xe_eudebug_debugger *
>>>>>> +xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
>>>>>> +{
>>>>>> +	struct xe_eudebug_debugger *d;
>>>>>> +
>>>>>> +	d = calloc(1, sizeof(*d));
>>>>>> +	d->flags = flags;
>>>>>> +	igt_assert(d);
>>>>>> +	IGT_INIT_LIST_HEAD(&d->triggers);
>>>>>> +	d->log = xe_eudebug_event_log_create("debugger", MAX_EVENT_LOG_SIZE);
>>>>>> +	d->fd = -1;
>>>>>> +	d->master_fd = master_fd;
>>>>>> +	d->ptr = data;
>>>>>> +
>>>>>> +	return d;
>>>>>> +}
>>>>>> +
>>>>>> +static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
>>>>>> +{
>>>>>> +	struct event_trigger *t, *tmp;
>>>>>> +
>>>>>> +	igt_list_for_each_entry_safe(t, tmp, &d->triggers, link)
>>>>>> +		free(t);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_destroy:
>>>>>> + * @d: pointer to the debugger
>>>>>> + *
>>>>>> + * Frees xe_eudebug_debugger structure pointed by @d. If the debugger
>>>>>> + * connection was still opened it terminates it.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
>>>>>> +{
>>>>>> +	if (d->worker_state)
>>>>>> +		xe_eudebug_debugger_stop_worker(d, 1);
>>>>>> +
>>>>>> +	if (d->target_pid)
>>>>>> +		xe_eudebug_debugger_dettach(d);
>>>>>> +
>>>>>> +	xe_eudebug_event_log_destroy(d->log);
>>>>>> +	debugger_destroy_triggers(d);
>>>>>> +	free(d);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_attach:
>>>>>> + * @d: pointer to the debugger
>>>>>> + * @c: pointer to the client
>>>>>> + *
>>>>>> + * Opens the xe eu debugger connection to the process described by @c (c->pid)
>>>>>> + *
>>>>>> + * Returns: 0 if the debugger was successfully attached, -errno otherwise.
>>>>>> + */
>>>>>> +int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d,
>>>>>> +			       struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	int ret;
>>>>>> +
>>>>>> +	igt_assert_eq(d->fd, -1);
>>>>>> +	igt_assert_neq(c->pid, 0);
>>>>>> +	ret = xe_eudebug_connect(d->master_fd, c->pid, 0);
>>>>>> +
>>>>>> +	if (ret < 0)
>>>>>> +		return ret;
>>>>>> +
>>>>>> +	d->fd = ret;
>>>>>> +	d->target_pid = c->pid;
>>>>>> +	d->p_client[0] = c->p_in[0];
>>>>>> +	d->p_client[1] = c->p_in[1];
>>>>>> +
>>>>>> +	igt_debug("debugger connected to %lu\n", d->target_pid);
>>>>>> +
>>>>>> +	return 0;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_dettach:
>>>>>> + * @d: pointer to the debugger
>>>>>> + *
>>>>>> + * Closes previously opened xe eu debugger connection. Asserts if
>>>>>> + * the debugger has active session.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d)
>>>>>> +{
>>>>>> +	igt_assert(d->target_pid);
>>>>>> +	close(d->fd);
>>>>>> +	d->target_pid = 0;
>>>>>> +	d->fd = -1;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_add_trigger:
>>>>>> + * @d: pointer to the debugger
>>>>>> + * @type: the type of the event which activates the trigger
>>>>>> + * @fn: function to be called when event of @type was read by the debugger.
>>>>>> + *
>>>>>> + * Adds function @fn to the list of triggers activated when event of @type
>>>>>> + * has been read by worker.
>>>>>> + * Note: Triggers are activated by the worker.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d,
>>>>>> +				     int type, xe_eudebug_trigger_fn fn)
>>>>>> +{
>>>>>> +	struct event_trigger *t;
>>>>>> +
>>>>>> +	t = calloc(1, sizeof(*t));
>>>>>> +	IGT_INIT_LIST_HEAD(&t->link);
>>>>>> +	t->type = type;
>>>>>> +	t->fn = fn;
>>>>>> +
>>>>>> +	igt_list_add_tail(&t->link, &d->triggers);
>>>>>> +	igt_debug("added trigger %p\n", t);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_start_worker:
>>>>>> + * @d: pointer to the debugger
>>>>>> + *
>>>>>> + * Starts the debugger worker. Worker is resposible for reading all
>>>>>> + * incoming events from the debugger, put then into debugger log and
>>>>>> + * execute appropriate event triggers. Note that using the debuggers
>>>>>> + * event log while worker is running is not safe.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
>>>>>> +{
>>>>>> +	int ret;
>>>>>> +
>>>>>> +	d->worker_state = true;
>>>>>> +	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
>>>>>> +
>>>>>> +	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_stop_worker:
>>>>>> + * @d: pointer to the debugger
>>>>>> + *
>>>>>> + * Stops the debugger worker. Event log is sorted by seqno after closure.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,
>>>>>> +				     int timeout_s)
>>>>>> +{
>>>>>> +	struct timespec t = {};
>>>>>> +	int ret;
>>>>>> +
>>>>>> +	igt_assert(d->worker_state);
>>>>>> +
>>>>>> +	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
>>>>>> +	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
>>>>>> +	t.tv_sec += timeout_s;
>>>>>> +
>>>>>> +	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_assert_f(ret == 0 || ret != ESRCH,
>>>>>> +		     "pthread join failed with error %d!\n", ret);
>>>>>> +
>>>>>> +	event_log_sort(d->log);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_signal_stage:
>>>>>> + * @d: pointer to the debugger
>>>>>> + * @stage: stage to signal
>>>>>> + *
>>>>>> + * Signals to client, waiting in xe_eudebug_client_wait_stage(),
>>>>>> + * releasing it to proceed.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage)
>>>>>> +{
>>>>>> +	token_signal(d->p_client, CLIENT_STAGE, stage);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_debugger_wait_stage:
>>>>>> + * @s: pointer to xe_eudebug_debugger structure
>>>>>> + * @stage: stage to wait on
>>>>>> + *
>>>>>> + * Pauses debugger until the client has signalled the corresponding stage with
>>>>>> + * xe_eudebug_client_signal_stage. This is only for situations where the actual
>>>>>> + * event flow is not enough to coordinate between client/debugger and extra sync
>>>>>> + * mechanism is needed.
>>>>>> + */
>>>>>> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage)
>>>>>> +{
>>>>>> +	u64 stage_in;
>>>>>> +
>>>>>> +	igt_debug("debugger xe client fd: %d pausing for stage %lu\n", s->d->master_fd, stage);
>>>>>> +
>>>>>> +	stage_in = wait_from_client(s->c, DEBUGGER_STAGE);
>>>>>> +	igt_debug("debugger xe client fd: %d stage %lu, expected %lu, stage\n", s->d->master_fd,
>>>>>> +		  stage_in, stage);
>>>>>> +
>>>>>> +	igt_assert_eq(stage_in, stage);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_create:
>>>>>> + * @master_fd: xe client used to open the debugger connection
>>>>>> + * @work: function that opens xe device and executes arbitrary workload
>>>>>> + * @flags: flags stored in a client structure, can be used at will
>>>>>> + * of the caller, i.e. to provide the @work function an additional switch.
>>>>>> + * @data: test's private data, allocated with MAP_SHARED | MAP_ANONYMOUS,
>>>>>> + * can be shared between client and debugger. Accesible via client->ptr.
>>>>>> + * Can be NULL.
>>>>>> + *
>>>>>> + * Forks and creates the debugger process. @work won't be called until
>>>>>> + * xe_eudebug_client_start is called.
>>>>>> + *
>>>>>> + * Returns: newly created xe_eudebug_debugger structure with its
>>>>>> + * event log initialized.
>>>>>> + */
>>>>>> +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_client_work_fn work,
>>>>>> +						   uint64_t flags, void *data)
>>>>>> +{
>>>>>> +	struct xe_eudebug_client *c;
>>>>>> +
>>>>>> +	c = calloc(1, sizeof(*c));
>>>>>> +	c->flags = flags;
>>>>>> +	igt_assert(c);
>>>>>> +	igt_assert(!pipe(c->p_in));
>>>>>> +	igt_assert(!pipe(c->p_out));
>>>>>> +	c->seqno = 1;
>>>>>> +	c->log = xe_eudebug_event_log_create("client", MAX_EVENT_LOG_SIZE);
>>>>>> +	c->done = 0;
>>>>>> +	c->ptr = data;
>>>>>> +	c->master_fd = master_fd;
>>>>>> +	c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_MS;
>>>>>> +
>>>>>> +	igt_fork(child, 1) {
>>>>>> +		int mypid;
>>>>>> +
>>>>>> +		igt_assert_eq(c->pid, 0);
>>>>>> +
>>>>>> +		close(c->p_out[0]);
>>>>>> +		c->p_out[0] = -1;
>>>>>> +		close(c->p_in[1]);
>>>>>> +		c->p_in[1] = -1;
>>>>>> +
>>>>>> +		mypid = getpid();
>>>>>> +		client_signal(c, CLIENT_PID, mypid);
>>>>>> +
>>>>>> +		c->pid = client_wait_token(c, CLIENT_RUN);
>>>>>> +		igt_assert_eq(c->pid, mypid);
>>>>>> +		if (work)
>>>>>> +			work(c);
>>>>>> +
>>>>>> +		client_signal(c, CLIENT_FINI, c->seqno);
>>>>>> +
>>>>>> +		event_log_write_to_fd(c->log, c->p_out[1]);
>>>>>> +
>>>>>> +		c->pid = client_wait_token(c, CLIENT_STOP);
>>>>>> +		igt_assert_eq(c->pid, mypid);
>>>>>> +	}
>>>>>> +
>>>>>> +	close(c->p_out[1]);
>>>>>> +	c->p_out[1] = -1;
>>>>>> +	close(c->p_in[0]);
>>>>>> +	c->p_in[0] = -1;
>>>>>> +
>>>>>> +	c->pid = wait_from_client(c, CLIENT_PID);
>>>>>> +
>>>>>> +	igt_info("client running with pid %d\n", c->pid);
>>>>>> +
>>>>>> +	return c;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_stop:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + *
>>>>>> + * Waits for the end of client's work and exits the proccess.
>>>>>> + */
>>>>>> +void xe_eudebug_client_stop(struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	if (c->pid) {
>>>>>> +		int waitstatus;
>>>>>> +
>>>>>> +		xe_eudebug_client_wait_done(c);
>>>>>> +
>>>>>> +		token_signal(c->p_in, CLIENT_STOP, c->pid);
>>>>>> +		igt_assert_eq(waitpid(c->pid, &waitstatus, 0),
>>>>>> +			      c->pid);
>>>>>> +		c->pid = 0;
>>>>>> +	}
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_destroy:
>>>>>> + * @c: pointer to xe_eudebug_client structure to be freed
>>>>>> + *
>>>>>> + * Frees the @c client structure. Note that it calls xe_eudebug_client_stop if
>>>>>> + * client proccess has not terminated yet.
>>>>>> + */
>>>>>> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	xe_eudebug_client_stop(c);
>>>>>> +	pipe_close(c->p_in);
>>>>>> +	pipe_close(c->p_out);
>>>>>> +	xe_eudebug_event_log_destroy(c->log);
>>>>>> +	free(c);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_get_seqno:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + *
>>>>>> + * Increments and returns current seqno value of the given client @c
>>>>>> + *
>>>>>> + * Returns: incremented seqno
>>>>>> + */
>>>>>> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	return c->seqno++;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_start:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + *
>>>>>> + * Starts execution of client's work function within the client's proccess.
>>>>>> + */
>>>>>> +void xe_eudebug_client_start(struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	token_signal(c->p_in, CLIENT_RUN, c->pid);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_wait_done:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + *
>>>>>> + * Waits for the client work end updates the event log.
>>>>>> + * Doesn't terminate the client's proccess yet.
>>>>>> + */
>>>>>> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	if (!c->done) {
>>>>>> +		c->done = 1;
>>>>>> +		c->seqno = wait_from_client(c, CLIENT_FINI);
>>>>>> +		event_log_read_from_fd(c->log, c->p_out[0]);
>>>>>> +	}
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_signal_stage:
>>>>>> + * @c: pointer to the client
>>>>>> + * @stage: stage to signal
>>>>>> + *
>>>>>> + * Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(),
>>>>>> + * releasing it to proceed.
>>>>>> + */
>>>>>> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage)
>>>>>> +{
>>>>>> +	token_signal(c->p_out, DEBUGGER_STAGE, stage);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_wait_stage:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @stage: stage to wait on
>>>>>> + *
>>>>>> + * Pauses client until the debugger has signalled the corresponding stage with
>>>>>> + * xe_eudebug_debugger_signal_stage. This is only for situations where the
>>>>>> + * actual event flow is not enough to coordinate between client/debugger and extra
>>>>>> + * sync mechanism is needed.
>>>>>> + *
>>>>>> + */
>>>>>> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
>>>>>> +{
>>>>>> +	u64 stage_in;
>>>>>> +
>>>>>> +	if (c->done) {
>>>>>> +		igt_warn("client: %d already done before %lu\n", c->pid, stage);
>>>>>> +		return;
>>>>>> +	}
>>>>>> +
>>>>>> +	igt_debug("client: %d pausing for stage %lu\n", c->pid, stage);
>>>>>> +
>>>>>> +	stage_in = client_wait_token(c, CLIENT_STAGE);
>>>>>> +	igt_debug("client: %d stage %lu, expected %lu, stage\n", c->pid, stage_in, stage);
>>>>>> +
>>>>>> +	igt_assert_eq(stage_in, stage);
>>>>>> +}
>>>>>> +
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_session_create:
>>>>>> + * @fd: XE file descriptor
>>>>>> + * @work: function passed to the xe_eudebug_client_create
>>>>>> + * @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.
>>>>>> + *
>>>>>> + * Creates session together with client and debugger structures.
>>>>>> + */
>>>>>> +struct xe_eudebug_session *xe_eudebug_session_create(int fd,
>>>>>> +						     xe_eudebug_client_work_fn work,
>>>>>> +						     unsigned int flags,
>>>>>> +						     void *test_private)
>>>>>> +{
>>>>>> +	struct xe_eudebug_session *s;
>>>>>> +
>>>>>> +	s = calloc(1, sizeof(*s));
>>>>>> +	igt_assert(s);
>>>>>> +
>>>>>> +	s->c = xe_eudebug_client_create(fd, work, flags, test_private);
>>>>>> +	s->d = xe_eudebug_debugger_create(fd, flags, test_private);
>>>>>> +	s->flags = flags;
>>>>>> +
>>>>>> +	return s;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_session_run:
>>>>>> + * @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.
>>>>>> + */
>>>>>> +void xe_eudebug_session_run(struct xe_eudebug_session *s)
>>>>>> +{
>>>>>> +	struct xe_eudebug_debugger *debugger = s->d;
>>>>>> +	struct xe_eudebug_client *client = s->c;
>>>>>> +
>>>>>> +	igt_assert_eq(xe_eudebug_debugger_attach(debugger, client), 0);
>>>>>> +
>>>>>> +	xe_eudebug_debugger_start_worker(debugger);
>>>>>> +
>>>>>> +	xe_eudebug_client_start(client);
>>>>>> +	xe_eudebug_client_wait_done(client);
>>>>>> +
>>>>>> +	xe_eudebug_debugger_stop_worker(debugger, 1);
>>>>>> +
>>>>>> +	xe_eudebug_event_log_print(debugger->log, true);
>>>>>> +	xe_eudebug_event_log_print(client->log, true);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_session_check:
>>>>>> + * @s: pointer to xe_eudebug_session structure
>>>>>> + * @match_opposite: indicates whether check should match all
>>>>>> + * create and destroy events.
>>>>>> + * @filter: mask that represents events to be skipped during comparison, useful
>>>>>> + * for events like 'VM_BIND' since they can be asymmetric
>>>>>> + *
>>>>>> + * Validate debugger's log against the log created by the client.
>>>>>> + */
>>>>>> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter)
>>>>>> +{
>>>>>> +	xe_eudebug_event_log_compare(s->c->log, s->d->log, filter);
>>>>>> +
>>>>>> +	if (match_opposite)
>>>>>> +		xe_eudebug_event_log_match_opposite(s->d->log, filter);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_session_destroy:
>>>>>> + * @s: pointer to xe_eudebug_session structure
>>>>>> + *
>>>>>> + * Destroy session together with its debugger and client.
>>>>>> + */
>>>>>> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s)
>>>>>> +{
>>>>>> +	xe_eudebug_debugger_destroy(s->d);
>>>>>> +	xe_eudebug_client_destroy(s->c);
>>>>>> +
>>>>>> +	free(s);
>>>>>> +}
>>>>>> +
>>>>>> +#define to_base(x) ((struct drm_xe_eudebug_event *)&x)
>>>>>> +
>>>>>> +static void base_event(struct xe_eudebug_client *c,
>>>>>> +		       struct drm_xe_eudebug_event *e,
>>>>>> +		       uint32_t type,
>>>>>> +		       uint32_t flags,
>>>>>> +		       uint64_t size)
>>>>>> +{
>>>>>> +	e->type = type;
>>>>>> +	e->flags = flags;
>>>>>> +	e->seqno = xe_eudebug_client_get_seqno(c);
>>>>>> +	e->len = size;
>>>>>> +}
>>>>>> +
>>>>>> +static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_client ec;
>>>>>> +
>>>>>> +	base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec));
>>>>>> +
>>>>>> +	ec.client_handle = client_fd;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&ec);
>>>>>> +}
>>>>>> +
>>>>>> +static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd, uint32_t vm_id)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_vm evm;
>>>>>> +
>>>>>> +	base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm));
>>>>>> +
>>>>>> +	evm.client_handle = client_fd;
>>>>>> +	evm.vm_handle = vm_id;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&evm);
>>>>>> +}
>>>>>> +
>>>>>> +static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,
>>>>>> +			     int client_fd, uint32_t vm_id,
>>>>>> +			     uint32_t exec_queue_handle, uint16_t class,
>>>>>> +			     uint16_t width)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_exec_queue ee;
>>>>>> +
>>>>>> +	base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
>>>>>> +		   flags, sizeof(ee));
>>>>>> +
>>>>>> +	ee.client_handle = client_fd;
>>>>>> +	ee.vm_handle = vm_id;
>>>>>> +	ee.exec_queue_handle = exec_queue_handle;
>>>>>> +	ee.engine_class = class;
>>>>>> +	ee.width = width;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&ee);
>>>>>> +}
>>>>>> +
>>>>>> +static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,
>>>>>> +			   int client_fd, uint32_t id, uint64_t type, uint64_t len)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_metadata em;
>>>>>> +
>>>>>> +	base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA,
>>>>>> +		   flags, sizeof(em));
>>>>>> +
>>>>>> +	em.client_handle = client_fd;
>>>>>> +	em.metadata_handle = id;
>>>>>> +	em.type = type;
>>>>>> +	em.len = len;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&em);
>>>>>> +}
>>>>>> +
>>>>>> +static int enable_getset(int fd, bool *old, bool *new)
>>>>>> +{
>>>>>> +	static const char * const fname = "enable_eudebug";
>>>>>> +	int ret = 0;
>>>>>> +
>>>>>> +	int sysfs, device_fd;
>>>>>> +	bool val_before;
>>>>>> +	struct stat st;
>>>>>> +
>>>>>> +	igt_assert(new || old);
>>>>>> +
>>>>>> +	igt_assert_eq(fstat(fd, &st), 0);
>>>>>> +	sysfs = igt_sysfs_open(fd);
>>>>>> +	if (sysfs < 0)
>>>>>> +		return -1;
>>>>>> +
>>>>>> +	device_fd = openat(sysfs, "device", O_DIRECTORY | O_RDONLY);
>>>>>> +	close(sysfs);
>>>>>> +	if (device_fd < 0)
>>>>>> +		return -1;
>>>>>> +
>>>>>> +	if (!__igt_sysfs_get_boolean(device_fd, fname, &val_before)) {
>>>>>> +		ret = -1;
>>>>>> +		goto out;
>>>>>> +	}
>>>>>> +
>>>>>> +	igt_debug("enable_eudebug before: %d\n", val_before);
>>>>>> +
>>>>>> +	if (old)
>>>>>> +		*old = val_before;
>>>>>> +
>>>>>> +	ret = 0;
>>>>>> +	if (new) {
>>>>>> +		if (__igt_sysfs_set_boolean(device_fd, fname, *new))
>>>>>> +			igt_assert_eq(igt_sysfs_get_boolean(device_fd, fname), *new);
>>>>>> +		else
>>>>>> +			ret = -1;
>>>>>> +	}
>>>>>> +
>>>>>> +out:
>>>>>> +	close(device_fd);
>>>>>> +	return ret;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_enable
>>>>>> + * @fd: xe client
>>>>>> + * @enable: state toggle - true to enable, false to disable
>>>>>> + *
>>>>>> + * Enables/disables eudebug capability by writing to
>>>>>> + * '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry.
>>>>>> + *
>>>>>> + * Returns: previous toggle value, i.e. true when eudebugging was enabled,
>>>>>> + * false when eudebugging was disabled.
>>>>>> + */
>>>>>> +bool xe_eudebug_enable(int fd, bool enable)
>>>>>> +{
>>>>>> +	bool old = false;
>>>>>> +	int ret = enable_getset(fd, &old, &enable);
>>>>>> +
>>>>>> +	if (ret) {
>>>>>> +		igt_skip_on(enable);
>>>>>> +		old = false;
>>>>>> +	}
>>>>>> +
>>>>>> +	return old;
>>>>>> +}
>>>>>> +
>>>>>> +/* Eu debugger wrappers around resource creating xe ioctls. */
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_open_driver:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + *
>>>>>> + * Calls drm_open_client(DRIVER_XE) and logs the corresponding
>>>>>> + * event in client's event log.
>>>>>> + *
>>>>>> + * Returns: valid DRM file descriptor
>>>>>> + */
>>>>>> +int xe_eudebug_client_open_driver(struct xe_eudebug_client *c)
>>>>>> +{
>>>>>> +	int fd;
>>>>>> +
>>>>>> +	fd = drm_reopen_driver(c->master_fd);
>>>>>> +	client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd);
>>>>>> +
>>>>>> +	return fd;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_close_driver:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + *
>>>>>> + * Calls close driver and logs the corresponding event in
>>>>>> + * client's event log.
>>>>>> + */
>>>>>> +void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)
>>>>>> +{
>>>>>> +	client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd);
>>>>>> +	close(fd);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_create:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @flags: vm bind flags
>>>>>> + * @ext: pointer to the first user extension
>>>>>> + *
>>>>>> + * Calls xe_vm_create() and logs corresponding events
>>>>>> + * (including vm set metadata events) in client's event log.
>>>>>> + *
>>>>>> + * Returns: valid vm handle
>>>>>> + */
>>>>>> +uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
>>>>>> +				     uint32_t flags, uint64_t ext)
>>>>>> +{
>>>>>> +	uint32_t vm;
>>>>>> +
>>>>>> +	vm = xe_vm_create(fd, flags, ext);
>>>>>> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm);
>>>>>> +
>>>>>> +	return vm;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_destroy:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * fd: xe client
>>>>>> + * vm: vm handle
>>>>>> + *
>>>>>> + * Calls xe_vm_destroy() and logs the corresponding event in
>>>>>> + * client's event log.
>>>>>> + */
>>>>>> +void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm)
>>>>>> +{
>>>>>> +	xe_vm_destroy(fd, vm);
>>>>>> +	vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_exec_queue_create:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @create: exec_queue create drm struct
>>>>>> + *
>>>>>> + * Calls xe exec queue create ioctl and logs the corresponding event in
>>>>>> + * client's event log.
>>>>>> + *
>>>>>> + * Returns: valid exec queue handle
>>>>>> + */
>>>>>> +uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
>>>>>> +					     struct drm_xe_exec_queue_create *create)
>>>>>> +{
>>>>>> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
>>>>>> +
>>>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_CREATE, create), 0);
>>>>>> +
>>>>>> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
>>>>>> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id,
>>>>>> +				 create->exec_queue_id, class, create->width);
>>>>>> +
>>>>>> +	return create->exec_queue_id;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_exec_queue_destroy:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @create: exec_queue create drm struct which was used for creation
>>>>>> + *
>>>>>> + * Calls xe exec_queue destroy ioctl and logs the corresponding event in
>>>>>> + * client's event log.
>>>>>> + */
>>>>>> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
>>>>>> +					  struct drm_xe_exec_queue_create *create)
>>>>>> +{
>>>>>> +	struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, };
>>>>>> +	uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0].engine_class;
>>>>>> +
>>>>>> +	if (class == DRM_XE_ENGINE_CLASS_COMPUTE || class == DRM_XE_ENGINE_CLASS_RENDER)
>>>>>> +		exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id,
>>>>>> +				 create->exec_queue_id, class, create->width);
>>>>>> +
>>>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY, &destroy), 0);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_bind_event:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @event_flags: base event flags
>>>>>> + * @fd: xe client
>>>>>> + * @vm: vm handle
>>>>>> + * @bind_flags: bind flags of vm_bind_event
>>>>>> + * @num_binds: 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, int fd,
>>>>>> +				     uint32_t vm, uint32_t bind_flags,
>>>>>> +				     uint32_t num_binds, u64 *ref_seqno)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_vm_bind evmb;
>>>>>> +
>>>>>> +	base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND,
>>>>>> +		   event_flags, sizeof(evmb));
>>>>>> +	evmb.client_handle = fd;
>>>>>> +	evmb.vm_handle = vm;
>>>>>> +	evmb.flags = bind_flags;
>>>>>> +	evmb.num_binds = num_binds;
>>>>>> +
>>>>>> +	*ref_seqno = evmb.base.seqno;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&evmb);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_bind_op_event:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @event_flags: base event flags
>>>>>> + * @bind_ref_seqno: base vm bind reference seqno
>>>>>> + * @op_ref_seqno: output, the vm_bind_op event seqno
>>>>>> + * @addr: ppgtt address
>>>>>> + * @size: size of the binding
>>>>>> + * @num_extensions: number of vm bind op extensions
>>>>>> + *
>>>>>> + * Logs vm bind op event in client's event log.
>>>>>> + */
>>>>>> +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
>>>>>> +					uint64_t bind_ref_seqno, uint64_t *op_ref_seqno,
>>>>>> +					uint64_t addr, uint64_t range,
>>>>>> +					uint64_t num_extensions)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_vm_bind_op op;
>>>>>> +
>>>>>> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
>>>>>> +		   event_flags, sizeof(op));
>>>>>> +	op.vm_bind_ref_seqno = bind_ref_seqno;
>>>>>> +	op.addr = addr;
>>>>>> +	op.range = range;
>>>>>> +	op.num_extensions = num_extensions;
>>>>>> +
>>>>>> +	*op_ref_seqno = op.base.seqno;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&op);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_bind_op_metadata_event:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @event_flags: base event flags
>>>>>> + * @op_ref_seqno: base vm bind op reference seqno
>>>>>> + * @metadata_handle: metadata handle
>>>>>> + * @metadata_cookie: metadata cookie
>>>>>> + *
>>>>>> + * Logs vm bind op metadata event in client's event log.
>>>>>> + */
>>>>>> +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)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_vm_bind_op_metadata op;
>>>>>> +
>>>>>> +	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,
>>>>>> +		   event_flags, sizeof(op));
>>>>>> +	op.vm_bind_op_ref_seqno = op_ref_seqno;
>>>>>> +	op.metadata_handle = metadata_handle;
>>>>>> +	op.metadata_cookie = metadata_cookie;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&op);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_bind_ufence_event:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @event_flags: base event flags
>>>>>> + * @ref_seqno: base vm bind event seqno
>>>>>> + *
>>>>>> + * Logs vm bind ufence event in client's event log.
>>>>>> + */
>>>>>> +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
>>>>>> +					    uint64_t ref_seqno)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_event_vm_bind_ufence f;
>>>>>> +
>>>>>> +	base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
>>>>>> +		   event_flags, sizeof(f));
>>>>>> +	f.vm_bind_ref_seqno = ref_seqno;
>>>>>> +
>>>>>> +	xe_eudebug_event_log_write(c->log, (void *)&f);
>>>>>> +}
>>>>>> +
>>>>>> +static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs)
>>>>>> +{
>>>>>> +	while (num_syncs--)
>>>>>> +		if (sync[num_syncs].type == DRM_XE_SYNC_TYPE_USER_FENCE)
>>>>>> +			return true;
>>>>>> +
>>>>>> +	return false;
>>>>>> +}
>>>>>> +
>>>>>> +#define for_each_metadata(__m, __ext)					\
>>>>>> +	for ((__m) = from_user_pointer(__ext);				\
>>>>>> +	     (__m);							\
>>>>>> +	     (__m) = from_user_pointer((__m)->base.next_extension))	\
>>>>>> +		if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG)
>>>>>> +
>>>>>> +static int  __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
>>>>>> +					int fd, uint32_t vm, uint32_t exec_queue,
>>>>>> +					uint32_t bo, uint64_t offset,
>>>>>> +					uint64_t addr, uint64_t size,
>>>>>> +					uint32_t op, uint32_t flags,
>>>>>> +					struct drm_xe_sync *sync,
>>>>>> +					uint32_t num_syncs,
>>>>>> +					uint32_t prefetch_region,
>>>>>> +					uint8_t pat_index, uint64_t op_ext)
>>>>>> +{
>>>>>> +	struct drm_xe_vm_bind_op_ext_attach_debug *metadata;
>>>>>> +	const bool ufence = has_user_fence(sync, num_syncs);
>>>>>> +	const uint32_t bind_flags = ufence ?
>>>>>> +		DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE : 0;
>>>>>> +	uint64_t seqno = 0, op_seqno = 0, num_metadata = 0;
>>>>>> +	uint32_t bind_base_flags = 0;
>>>>>> +	int ret;
>>>>>> +
>>>>>> +	for_each_metadata(metadata, op_ext)
>>>>>> +		num_metadata++;
>>>>>> +
>>>>>> +	switch (op) {
>>>>>> +	case DRM_XE_VM_BIND_OP_MAP:
>>>>>> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE;
>>>>>> +		break;
>>>>>> +	case DRM_XE_VM_BIND_OP_UNMAP:
>>>>>> +		bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY;
>>>>>> +		igt_assert_eq(num_metadata, 0);
>>>>>> +		igt_assert_eq(ufence, false);
>>>>>> +		break;
>>>>>> +	default:
>>>>>> +		/* XXX unmap all? */
>>>>>> +		igt_assert(op);
>>>>>> +		break;
>>>>>> +	}
>>>>>> +
>>>>>> +	ret = ___xe_vm_bind(fd, vm, exec_queue, bo, offset, addr, size,
>>>>>> +			    op, flags, sync, num_syncs, prefetch_region,
>>>>>> +			    pat_index, 0, op_ext);
>>>>>> +
>>>>>> +	if (ret)
>>>>>> +		return ret;
>>>>>> +
>>>>>> +	if (!bind_base_flags)
>>>>>> +		return -EINVAL;
>>>>>> +
>>>>>> +	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
>>>>>> +					fd, vm, bind_flags, 1, &seqno);
>>>>>> +	xe_eudebug_client_vm_bind_op_event(c, bind_base_flags,
>>>>>> +					   seqno, &op_seqno, addr, size,
>>>>>> +					   num_metadata);
>>>>>> +
>>>>>> +	for_each_metadata(metadata, op_ext)
>>>>>> +		xe_eudebug_client_vm_bind_op_metadata_event(c,
>>>>>> +							    DRM_XE_EUDEBUG_EVENT_CREATE,
>>>>>> +							    op_seqno,
>>>>>> +							    metadata->metadata_id,
>>>>>> +							    metadata->cookie);
>>>>>> +	if (ufence)
>>>>>> +		xe_eudebug_client_vm_bind_ufence_event(c, DRM_XE_EUDEBUG_EVENT_CREATE |
>>>>>> +						       DRM_XE_EUDEBUG_EVENT_NEED_ACK,
>>>>>> +						       seqno);
>>>>>> +	return ret;
>>>>>> +}
>>>>>> +
>>>>>> +static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
>>>>>> +				       uint32_t vm, uint32_t bo,
>>>>>> +				       uint64_t offset, uint64_t addr, uint64_t size,
>>>>>> +				       uint32_t op,
>>>>>> +				       uint32_t flags,
>>>>>> +				       struct drm_xe_sync *sync,
>>>>>> +				       uint32_t num_syncs,
>>>>>> +				       uint64_t op_ext)
>>>>>> +{
>>>>>> +	const uint32_t exec_queue_id = 0;
>>>>>> +	const uint32_t prefetch_region = 0;
>>>>>> +
>>>>>> +	igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm, exec_queue_id, bo, offset,
>>>>>> +						  addr, size, op, flags,
>>>>>> +						  sync, num_syncs, prefetch_region,
>>>>>> +						  DEFAULT_PAT_INDEX, op_ext),
>>>>>> +		      0);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_bind_flags
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @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, int fd, 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)
>>>>>> +{
>>>>>> +	_xe_eudebug_client_vm_bind(c, fd, 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
>>>>>> + * @fd: xe client
>>>>>> + * @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, int fd, 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, fd, vm, bo, offset, addr, size,
>>>>>> +					flags,
>>>>>> +					sync, num_syncs, op_ext);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_vm_unbind_flags
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @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, int fd,
>>>>>> +				       uint32_t vm, uint64_t offset,
>>>>>> +				       uint64_t addr, uint64_t size, uint32_t flags,
>>>>>> +				       struct drm_xe_sync *sync, uint32_t num_syncs)
>>>>>> +{
>>>>>> +	_xe_eudebug_client_vm_bind(c, fd, 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
>>>>>> + * @fd: xe client
>>>>>> + * @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, int fd, 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, fd, vm, offset, addr, size,
>>>>>> +					  flags, sync, num_syncs);
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_metadata_create:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @type: debug metadata type
>>>>>> + * @len: size of @data
>>>>>> + * @data: debug metadata paylad
>>>>>> + *
>>>>>> + * Calls xe metadata create ioctl and logs the corresponding event in
>>>>>> + * client's event log.
>>>>>> + *
>>>>>> + * Return: valid debug metadata id.
>>>>>> + */
>>>>>> +uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
>>>>>> +					   int type, size_t len, void *data)
>>>>>> +{
>>>>>> +	struct drm_xe_debug_metadata_create create = {
>>>>>> +		.type = type,
>>>>>> +		.user_addr = to_user_pointer(data),
>>>>>> +		.len = len
>>>>>> +	};
>>>>>> +
>>>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0);
>>>>>> +
>>>>>> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len);
>>>>>> +
>>>>>> +	return create.metadata_id;
>>>>>> +}
>>>>>> +
>>>>>> +/**
>>>>>> + * xe_eudebug_client_metadata_destroy:
>>>>>> + * @c: pointer to xe_eudebug_client structure
>>>>>> + * @fd: xe client
>>>>>> + * @id: xe debug metadata handle
>>>>>> + * @type: debug metadata type
>>>>>> + * @len: size of debug metadata payload
>>>>>> + *
>>>>>> + * Calls xe metadata destroy ioctl and logs the corresponding event in
>>>>>> + * client's event log.
>>>>>> + */
>>>>>> +void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
>>>>>> +					uint32_t id, int type, size_t len)
>>>>>> +{
>>>>>> +	struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id };
>>>>>> +
>>>>>> +
>>>>>> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0);
>>>>>> +
>>>>>> +	metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len);
>>>>>> +}
>>>>>> +
>>>>>> +void xe_eudebug_ack_ufence(int debugfd,
>>>>>> +			   const struct drm_xe_eudebug_event_vm_bind_ufence *f)
>>>>>> +{
>>>>>> +	struct drm_xe_eudebug_ack_event ack = { 0, };
>>>>>> +	char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN];
>>>>>> +
>>>>>> +	ack.type = f->base.type;
>>>>>> +	ack.seqno = f->base.seqno;
>>>>>> +
>>>>>> +	xe_eudebug_event_to_str((void *)f, event_str, XE_EUDEBUG_EVENT_STRING_MAX_LEN);
>>>>>> +	igt_debug("delivering ack for event: %s\n", event_str);
>>>>>> +	igt_assert_eq(igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0);
>>>>>> +}
>>>>>> diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h
>>>>>> new file mode 100644
>>>>>> index 000000000..444f5a7b7
>>>>>> --- /dev/null
>>>>>> +++ b/lib/xe/xe_eudebug.h
>>>>>> @@ -0,0 +1,206 @@
>>>>>> +/* SPDX-License-Identifier: MIT */
>>>>>> +/*
>>>>>> + * Copyright © 2023 Intel Corporation
>>>>>> + */
>>>>>> +#include <fcntl.h>
>>>>>> +#include <pthread.h>
>>>>>> +#include <stdint.h>
>>>>>> +#include <xe_drm.h>
>>>>>> +
>>>>>> +#include "igt_list.h"
>>>>>> +
>>>>>> +struct xe_eudebug_event_log {
>>>>>> +	uint8_t *log;
>>>>>> +	unsigned int head;
>>>>>> +	unsigned int max_size;
>>>>>> +	char name[80];
>>>>>> +	pthread_mutex_t lock;
>>>>>> +};
>>>>>> +
>>>>>> +struct xe_eudebug_debugger {
>>>>>> +	int fd;
>>>>>> +	uint64_t flags;
>>>>>> +
>>>>>> +	/* Used to smuggle private data */
>>>>>> +	void *ptr;
>>>>>> +
>>>>>> +	struct xe_eudebug_event_log *log;
>>>>>> +
>>>>>> +	uint64_t event_count;
>>>>>> +
>>>>>> +	uint64_t target_pid;
>>>>>> +
>>>>>> +	struct igt_list_head triggers;
>>>>>> +
>>>>>> +	int master_fd;
>>>>>> +
>>>>>> +	pthread_t worker_thread;
>>>>>> +	int worker_state;
>>>>>> +
>>>>>> +	int p_client[2];
>>>>>> +};
>>>>>> +
>>>>>> +struct xe_eudebug_client {
>>>>>> +	int pid;
>>>>>> +	uint64_t seqno;
>>>>>> +	uint64_t flags;
>>>>>> +
>>>>>> +	/* Used to smuggle private data */
>>>>>> +	void *ptr;
>>>>>> +
>>>>>> +	struct xe_eudebug_event_log *log;
>>>>>> +
>>>>>> +	int done;
>>>>>> +	int p_in[2];
>>>>>> +	int p_out[2];
>>>>>> +
>>>>>> +	/* Used to pickup right device (the one used in debugger) */
>>>>>> +	int master_fd;
>>>>>> +
>>>>>> +	int timeout_ms;
>>>>>> +};
>>>>>> +
>>>>>> +struct xe_eudebug_session {
>>>>>> +	uint64_t flags;
>>>>>> +	struct xe_eudebug_client *c;
>>>>>> +	struct xe_eudebug_debugger *d;
>>>>>> +};
>>>>>> +
>>>>>> +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_event(_e, _log) \
>>>>>> +	for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \
>>>>>> +		    (void *)(_log)->log; \
>>>>>> +	    (uint8_t *)(_e) < (_log)->log + (_log)->head; \
>>>>>> +	    (_e) = (void *)(uint8_t *)(_e) + (_e)->len)
>>>>>> +
>>>>>> +#define xe_eudebug_assert(d, c)						\
>>>>>> +	do {								\
>>>>>> +		if (!(c)) {						\
>>>>>> +			xe_eudebug_event_log_print((d)->log, true);	\
>>>>>> +			igt_assert(c);					\
>>>>>> +		}							\
>>>>>> +	} while (0)
>>>>>> +
>>>>>> +#define xe_eudebug_assert_f(d, c, f...)					\
>>>>>> +	do {								\
>>>>>> +		if (!(c)) {						\
>>>>>> +			xe_eudebug_event_log_print((d)->log, true);	\
>>>>>> +			igt_assert_f(c, f);				\
>>>>>> +		}							\
>>>>>> +	} while (0)
>>>>>> +
>>>>>> +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN		4096
>>>>>> +
>>>>>> +/*
>>>>>> + * Default abort timeout to use across xe_eudebug lib and tests if no specific
>>>>>> + * timeout value is required.
>>>>>> + */
>>>>>> +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS		25000ULL
>>>>>> +
>>>>>> +#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_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_UFENCE  BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
>>>>>> +#define XE_EUDEBUG_FILTER_ALL			GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)
>>>>>> +#define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)	((1UL << _e) & _f)
>>>>>> +
>>>>>> +int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
>>>>>> +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);
>>>>>> +struct xe_eudebug_event_log *
>>>>>> +xe_eudebug_event_log_create(const char *name, unsigned int max_size);
>>>>>> +void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l);
>>>>>> +void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug);
>>>>>> +void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d,
>>>>>> +				  uint32_t filter);
>>>>>> +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e);
>>>>>> +void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);
>>>>>> +
>>>>>> +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_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, int timeout_s);
>>>>>> +void xe_eudebug_debugger_dettach(struct xe_eudebug_debugger *d);
>>>>>> +void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);
>>>>>> +void xe_eudebug_debugger_add_trigger(struct xe_eudebug_debugger *d, int type,
>>>>>> +				     xe_eudebug_trigger_fn fn);
>>>>>> +void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t stage);
>>>>>> +void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage);
>>>>>> +
>>>>>> +struct xe_eudebug_client *
>>>>>> +xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_t flags, void *data);
>>>>>> +void xe_eudebug_client_destroy(struct xe_eudebug_client *c);
>>>>>> +void xe_eudebug_client_start(struct xe_eudebug_client *c);
>>>>>> +void xe_eudebug_client_stop(struct xe_eudebug_client *c);
>>>>>> +void xe_eudebug_client_wait_done(struct xe_eudebug_client *c);
>>>>>> +void xe_eudebug_client_signal_stage(struct xe_eudebug_client *c, uint64_t stage);
>>>>>> +void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);
>>>>>> +
>>>>>> +uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
>>>>>> +void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
>>>>>> +
>>>>>> +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 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,
>>>>>> +					     struct drm_xe_exec_queue_create *create);
>>>>>> +void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
>>>>>> +					  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,
>>>>>> +				     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,
>>>>>> +					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,
>>>>>> +			   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,
>>>>>> +				     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,
>>>>>> +			       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,
>>>>>> +				       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,
>>>>>> +				 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,
>>>>>> +						     void *test_private);
>>>>>> +void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
>>>>>> +void xe_eudebug_session_run(struct xe_eudebug_session *s);
>>>>>> +void xe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite, uint32_t filter);
>>>>>> -- 
>>>>>> 2.34.1
>>>>>>