From 3a9bea390a47fea5b91258da6d51ebfa139a254f Mon Sep 17 00:00:00 2001 From: Kolanupaka Naveena Date: Thu, 12 Jun 2025 11:50:52 +0530 Subject: [PATCH 01/33] Revert "Revert "drm-uapi-experimental/xe_drm_eudebug: Sync after exec_queue placement event addition"" This reverts commit 383649c1911ca1dfe2e26d01570aa6910421e09f. --- .../drm-uapi-experimental/xe_drm_eudebug.h | 31 ++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/include/drm-uapi-experimental/xe_drm_eudebug.h b/include/drm-uapi-experimental/xe_drm_eudebug.h index a1733f543..12d8ebc06 100644 --- a/include/drm-uapi-experimental/xe_drm_eudebug.h +++ b/include/drm-uapi-experimental/xe_drm_eudebug.h @@ -147,13 +147,14 @@ struct drm_xe_eudebug_event { #define DRM_XE_EUDEBUG_EVENT_OPEN 2 #define DRM_XE_EUDEBUG_EVENT_VM 3 #define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 -#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 -#define DRM_XE_EUDEBUG_EVENT_VM_BIND 6 -#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 -#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 -#define DRM_XE_EUDEBUG_EVENT_METADATA 9 -#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 -#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT 11 +#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS 5 +#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 6 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND 7 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 8 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 9 +#define DRM_XE_EUDEBUG_EVENT_METADATA 10 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 11 +#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT 12 __u16 flags; #define DRM_XE_EUDEBUG_EVENT_CREATE (1 << 0) @@ -189,6 +190,22 @@ struct drm_xe_eudebug_event_exec_queue { __u64 lrc_handle[]; }; +struct drm_xe_eudebug_event_exec_queue_placements { + struct drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 vm_handle; + __u64 exec_queue_handle; + __u64 lrc_handle; + __u32 num_placements; + __u32 pad; + /** + * @instances: user pointer to num_placements sized array of struct + * drm_xe_engine_class_instance + */ + __u64 instances[]; +}; + struct drm_xe_eudebug_event_eu_attention { struct drm_xe_eudebug_event base; From 28982055e7a6b5644a840506bb382362da6a4361 Mon Sep 17 00:00:00 2001 From: Kolanupaka Naveena Date: Thu, 12 Jun 2025 11:50:58 +0530 Subject: [PATCH 02/33] Revert "Revert "lib/xe_eudebug: Add support for exec queue placements events"" This reverts commit 839c3f3468c5a00e64f3959eec51c51d839cea57. --- lib/xe/xe_eudebug.c | 89 +++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 86 insertions(+), 3 deletions(-) diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c index 1d9cb8289..03a46e7da 100644 --- a/lib/xe/xe_eudebug.c +++ b/lib/xe/xe_eudebug.c @@ -135,6 +135,8 @@ static const char *type_to_str(unsigned int type) return "vm"; case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: return "exec_queue"; + case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: + return "exec_queue_placements"; case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: return "attention"; case DRM_XE_EUDEBUG_EVENT_VM_BIND: @@ -205,6 +207,27 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu ee->exec_queue_handle, ee->engine_class, ee->width); break; } + case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { + struct drm_xe_eudebug_event_exec_queue_placements *ee = igt_container_of(e, ee, + base); + struct drm_xe_engine_class_instance *instances = (void *)(ee->instances); + int i, l; + + l = sprintf(buf, "client_handle=%llu, vm_handle=%llu, " + "exec_queue_handle=%llu, lrc_handle=%llu, " + "num_placements=%d, gt_id=%d, mask=[", + ee->client_handle, ee->vm_handle, + ee->exec_queue_handle, ee->lrc_handle, + ee->num_placements, instances[0].gt_id); + + for (i = 0; i < ee->num_placements; i++) + l += sprintf(buf + l, "%s%d pad%d, ", + xe_engine_class_short_string(instances[i].engine_class), + instances[i].engine_instance, instances[i].pad); + buf[l - 2] = ']'; + + break; + } case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: { struct drm_xe_eudebug_event_eu_attention *ea = igt_container_of(e, ea, base); @@ -528,6 +551,19 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) ret = 1; break; } + case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { + struct drm_xe_eudebug_event_exec_queue_placements *ae = igt_container_of(a, ae, + base); + struct drm_xe_eudebug_event_exec_queue_placements *be = igt_container_of(b, be, + base); + + if (ae->num_placements == be->num_placements && + memcmp(ae->instances, be->instances, + sizeof(uint64_t) * ae->num_placements) == 0) + ret = 1; + + break; + } case DRM_XE_EUDEBUG_EVENT_VM_BIND: { struct drm_xe_eudebug_event_vm_bind *ea = igt_container_of(a, ea, base); struct drm_xe_eudebug_event_vm_bind *eb = igt_container_of(b, eb, base); @@ -595,6 +631,14 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data) return 1; break; } + case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { + struct drm_xe_eudebug_event_exec_queue_placements *ee = igt_container_of(e, ee, + base); + + if (ee->client_handle == h) + return 1; + break; + } case DRM_XE_EUDEBUG_EVENT_VM_BIND: { struct drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base); @@ -1102,10 +1146,11 @@ xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t fil if (XE_EUDEBUG_EVENT_IS_FILTERED(ev1->type, filter)) continue; - /* No opposite matching for binds */ + /* No opposite matching for some events */ if ((ev1->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND && ev1->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) || - ev1->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA) + ev1->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA || + ev1->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS) continue; ev2 = opposite_event_match(l, ev1, ev1); @@ -1882,6 +1927,36 @@ static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags, xe_eudebug_event_log_write(c->log, (void *)&ee); } +static void exec_queue_placements_event(struct xe_eudebug_client *c, + int client_fd, uint32_t vm_id, + uint32_t exec_queue_handle, + uint16_t width, uint16_t lrc_no, + uint16_t num_placements, + struct drm_xe_engine_class_instance *eci) +{ + struct drm_xe_eudebug_event_exec_queue_placements *ee; + struct drm_xe_engine_class_instance *instances; + size_t sz = sizeof(*ee) + num_placements * sizeof(uint64_t); + + ee = calloc(1, sz); + igt_assert(ee); + + base_event(c, to_base(*ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS, + DRM_XE_EUDEBUG_EVENT_CREATE, sz); + + ee->client_handle = client_fd; + ee->vm_handle = vm_id; + ee->exec_queue_handle = exec_queue_handle; + ee->num_placements = num_placements; + + instances = (struct drm_xe_engine_class_instance *)(ee->instances); + for (int j = 0; j < num_placements; j++) + instances[j] = eci[j * width + lrc_no]; + + xe_eudebug_event_log_write(c->log, (void *)ee); + free(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) { @@ -2136,10 +2211,18 @@ uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd ext->value & DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE) send = true; - if (send) + if (send) { exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id, create->exec_queue_id, class, create->width); + for (int i = 0; i < create->width; i++) { + exec_queue_placements_event(c, fd, create->vm_id, create->exec_queue_id, + create->width, i, + create->num_placements, + instances); + } + } + return create->exec_queue_id; } From b24a002a33b11863908904d9a762b0b7114b4d1f Mon Sep 17 00:00:00 2001 From: Smitha Balasubramanyam Date: Mon, 29 Jun 2026 13:41:17 +0530 Subject: [PATCH 03/33] xe/drm_uapi: Adapt xe_eudebug to prelim infrastructure --- include/drm-uapi/xe_drm.h | 4 +- include/drm-uapi/xe_drm_prelim.h | 416 ++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.c | 410 ++++++++++++++--------------- lib/xe/xe_eudebug.h | 47 ++-- tests/intel/xe_eudebug.c | 250 +++++++++--------- tests/intel/xe_eudebug_online.c | 316 +++++++++++------------ tests/intel/xe_eudebug_sriov.c | 6 +- tests/intel/xe_exec_sip_eudebug.c | 4 +- 8 files changed, 935 insertions(+), 518 deletions(-) create mode 100644 include/drm-uapi/xe_drm_prelim.h diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h index 5a96a7910..1b3a31796 100644 --- a/include/drm-uapi/xe_drm.h +++ b/include/drm-uapi/xe_drm.h @@ -145,7 +145,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 boundary with pointers encapsulated inside u64. + * the __user boundary with pointers encapsulated inside u64. * * Example chaining: * @@ -2609,6 +2609,8 @@ enum drm_xe_ras_error_component { [DRM_XE_RAS_ERR_COMP_SOC_INTERNAL] = "soc-internal" \ } +#include "xe_drm_prelim.h" + #if defined(__cplusplus) } #endif diff --git a/include/drm-uapi/xe_drm_prelim.h b/include/drm-uapi/xe_drm_prelim.h new file mode 100644 index 000000000..dbe880b00 --- /dev/null +++ b/include/drm-uapi/xe_drm_prelim.h @@ -0,0 +1,416 @@ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2023 Intel Corporation + */ + +#ifndef _XE_DRM_PRELIM_H_ +#define _XE_DRM_PRELIM_H_ + +#include "xe_drm.h" + +/** + * DOC: Xe PRELIM uAPI + * + * Reasoning: + * + * The DRM community imposes some strict requirements on the uAPI: + * + * - https://www.kernel.org/doc/html/latest/gpu/drm-uapi.html#open-source-userspace-requirements + * - "The open-source userspace must not be a toy/test application, but the real thing." + * - "The userspace patches must be against the canonical upstream, not some vendor fork." + * + * In some very specific cases, there will be a particular need to get a preliminary and + * non-upstream uAPI merged in some of our branches. When this happens, the uAPI cannot + * take a risk of conflicting IOCTL ranges with other preliminary uAPI or with a possible + * real user space uAPI that could win the race towards upstream. + * + * 'PRELIM' uAPIs are APIs that are not yet merged on upstream. They were designed to be + * in a different range in a way that the divergence with the upstream and other development + * branches can be controlled and the conflicts minimized. + * + * It is also a mechanism that prevents user space regressions since the prelim modification + * is always in a two-phase approach, where upstream and prelim can coexist for a period of + * time while the UMDs adjust to the changes. + * + * Rules: + * + * - Communication will happen on a specific Teams channel: KMD uAPI Changes + * - APIs to be considered Preliminary / WIP / Temporary to what will eventually be in upstream. + * It's designed to allow kernel and userspace to work together and make sure it works with all + * components before committing to support it forever in upstream (we don't want to break Linux's + * rule about not breaking userspace). + * - IOCTL in separate file (this one). + * - IOCTL, flags, enums, or any number that might conflict should be in separated range + * (i.e end of range like IOCTL numbers). + * - PRELIM prefix mandatory in any define, struct, or non-static functions in PRELIM source files + * called by other source files (i.e xe_perf_ioctl -> prelim_xe_perf_ioctl) + * - Code .c/.h using PRELIM should also be placed in prelim/ sub-directory for easier rebase. + * - Two-Phase removal: + * + * + When API needs to be modified in non-backwards compatible ways, the current PRELIM API + * cannot be removed (yet). + * + Either because it must change the behavior or because the final upstream one has landed. + * + If a new PRELIM is needed, it needs to be added as a new PRELIM_V without removing the + * PRELIM_V. + * + The previous one can only be removed after all user space components confirmed they are not + * using. + * + * Other prelim considerations: + * + * - Out of tree Sysfs and debugfs need to stay behind a 'prelim' directory. + * - Out of tree module-parameters need to be identified by a PRELIM prefix. + * (xe.prelim_my_awesome_param=not_default) + * - Internal/downstream declarations must be added here, not to xe_drm.h. + * - The values in xe_drm_prelim.h must also be kept synchronized with values in xe_drm.h. + * - PRELIM ioctl's: IOCTL numbers go down from 0x5f + */ + +/* + * IOCTL numbers listed below are reserved, they are taken up by other + * components. Please add an unreserved ioctl number here to reserve that + * number. + */ +/* SPDX-License-Identifier: MIT */ +/* + * Copyright © 2023 Intel Corporation + */ + +#define PRELIM_DRM_XE_EUDEBUG_CONNECT 0x5f +#define PRELIM_DRM_XE_DEBUG_METADATA_CREATE 0x5e +#define PRELIM_DRM_XE_DEBUG_METADATA_DESTROY 0x5d + +#define PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_EUDEBUG_CONNECT, struct prelim_drm_xe_eudebug_connect) +#define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_CREATE, struct prelim_drm_xe_debug_metadata_create) +#define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY DRM_IOW(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_DESTROY, struct prelim_drm_xe_debug_metadata_destroy) + +struct prelim_drm_xe_vm_bind_op_ext_attach_debug { + /** @base: base user extension */ + struct drm_xe_user_extension base; + + /** @id: Debug object id from create metadata */ + __u64 metadata_id; + + /** @flags: Flags */ + __u64 flags; + + /** @cookie: Cookie */ + __u64 cookie; + + /** @reserved: Reserved */ + __u64 reserved; +}; + +#define PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0 + +#define PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG 2 +#define PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE (1 << 0) + +/* + * Debugger ABI (ioctl and events) Version History: + * 0 - No debugger available + * 1 - Initial version + */ +#define PRELIM_DRM_XE_EUDEBUG_VERSION 1 + +struct prelim_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 prelim_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 prelim_drm_xe_debug_metadata_create { + /** @extensions: Pointer to the first extension struct, if any */ + __u64 extensions; + +#define PRELIM_DRM_XE_DEBUG_METADATA_ELF_BINARY 0 +#define PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE 1 +#define PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA 2 +#define PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA 3 +#define PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA 4 +#define PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM (1 + \ + PRELIM_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 prelim_drm_xe_debug_metadata_destroy - Destroy debug metadata + * + * Destroy debug metadata. + */ +struct prelim_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_prelim.h" + +/** + * Do a eudebug event read for a debugger connection. + * + * This ioctl is available in debug version 1. + */ +#define PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_EVENT _IO('j', 0x0) +#define PRELIM_DRM_XE_EUDEBUG_IOCTL_EU_CONTROL _IOWR('j', 0x2, struct prelim_drm_xe_eudebug_eu_control) +#define PRELIM_DRM_XE_EUDEBUG_IOCTL_ACK_EVENT _IOW('j', 0x4, struct prelim_drm_xe_eudebug_ack_event) +#define PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN _IOW('j', 0x1, struct prelim_drm_xe_eudebug_vm_open) +#define PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_METADATA _IOWR('j', 0x3, struct prelim_drm_xe_eudebug_read_metadata) + +/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */ +struct prelim_drm_xe_eudebug_event { + __u32 len; + + __u16 type; +#define PRELIM_DRM_XE_EUDEBUG_EVENT_NONE 0 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_READ 1 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN 2 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM 3 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND 6 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA 9 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT 11 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_SYNC_HOST 12 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS 13 + + __u16 flags; +#define PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE (1 << 0) +#define PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY (1 << 1) +#define PRELIM_DRM_XE_EUDEBUG_EVENT_STATE_CHANGE (1 << 2) +#define PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK (1 << 3) + + __u64 seqno; + __u64 reserved; +}; + +struct prelim_drm_xe_eudebug_event_client { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; /* This is unique per debug connection */ +}; + +struct prelim_drm_xe_eudebug_event_vm { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 vm_handle; +}; + +struct prelim_drm_xe_eudebug_event_exec_queue { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 vm_handle; + __u64 exec_queue_handle; + __u32 engine_class; + __u32 width; + __u64 lrc_handle[]; +}; + +struct prelim_drm_xe_eudebug_event_exec_queue_placements { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 vm_handle; + __u64 exec_queue_handle; + __u64 lrc_handle; + __u32 num_placements; + __u32 pad; + /** + * @instances: user pointer to num_placements sized array of struct + * drm_xe_engine_class_instance + */ + __u64 instances[]; +}; + +struct prelim_drm_xe_eudebug_event_eu_attention { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 exec_queue_handle; + __u64 lrc_handle; + __u32 flags; + __u32 bitmask_size; + __u8 bitmask[]; +}; + +struct prelim_drm_xe_eudebug_eu_control { + __u64 client_handle; + +#define PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL 0 +#define PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED 1 +#define PRELIM_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 + * PRELIM_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 prelim_drm_xe_eudebug_event_vm_bind { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 vm_handle; + + __u32 flags; +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0) + + __u32 num_binds; +}; + +struct prelim_drm_xe_eudebug_event_vm_bind_op { + struct prelim_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 prelim_drm_xe_eudebug_event_vm_bind_ufence { + struct prelim_drm_xe_eudebug_event base; + __u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */ +}; + +struct prelim_drm_xe_eudebug_ack_event { + __u32 type; + __u32 flags; /* MBZ */ + __u64 seqno; +}; + +struct prelim_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; + +#define DRM_XE_EUDEBUG_VM_SYNC_MAX_TIMEOUT_NSECS (10ULL * NSEC_PER_SEC) + /** @timeout_ns: Timeout value in nanoseconds operations (fsync) */ + __u64 timeout_ns; +}; + +struct prelim_drm_xe_eudebug_read_metadata { + __u64 client_handle; + __u64 metadata_handle; + __u32 flags; + __u32 reserved; + __u64 ptr; + __u64 size; +}; + +struct prelim_drm_xe_eudebug_event_metadata { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 metadata_handle; + /* XXX: Refer to xe_drm.h for fields */ + __u64 type; + __u64 len; +}; + +struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata { + struct prelim_drm_xe_eudebug_event base; + __u64 vm_bind_op_ref_seqno; /* *_event_vm_bind_op.base.seqno */ + + __u64 metadata_handle; + __u64 metadata_cookie; +}; + +struct prelim_drm_xe_eudebug_event_pagefault { + struct prelim_drm_xe_eudebug_event base; + + __u64 client_handle; + __u64 exec_queue_handle; + __u64 lrc_handle; + __u32 flags; + __u32 bitmask_size; + __u64 pagefault_address; + __u8 bitmask[]; +}; + +#endif /* _XE_DRM_PRELIM_H_ */ diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c index 03a46e7da..84ac5b71e 100644 --- a/lib/xe/xe_eudebug.c +++ b/lib/xe/xe_eudebug.c @@ -81,7 +81,7 @@ struct seqno_list_entry { }; struct match_dto { - struct drm_xe_eudebug_event *target; + struct prelim_drm_xe_eudebug_event *target; struct igt_list_head *seqno_list; uint64_t client_handle; uint32_t filter; @@ -125,38 +125,38 @@ static const char *token_to_str(uint64_t token) static const char *type_to_str(unsigned int type) { switch (type) { - case DRM_XE_EUDEBUG_EVENT_NONE: + case PRELIM_DRM_XE_EUDEBUG_EVENT_NONE: return "none"; - case DRM_XE_EUDEBUG_EVENT_READ: + case PRELIM_DRM_XE_EUDEBUG_EVENT_READ: return "read"; - case DRM_XE_EUDEBUG_EVENT_OPEN: + case PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN: return "client"; - case DRM_XE_EUDEBUG_EVENT_VM: + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM: return "vm"; - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: return "exec_queue"; - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: return "exec_queue_placements"; - case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: + case PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: return "attention"; - case DRM_XE_EUDEBUG_EVENT_VM_BIND: + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND: return "vm_bind"; - case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: return "vm_bind_op"; - case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: return "vm_bind_ufence"; - case DRM_XE_EUDEBUG_EVENT_METADATA: + case PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA: return "metadata"; - case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: return "vm_bind_op_metadata"; - case DRM_XE_EUDEBUG_EVENT_PAGEFAULT: + case PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT: return "pagefault"; } return "UNKNOWN"; } -static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *buf) +static const char *event_type_to_str(struct prelim_drm_xe_eudebug_event *e, char *buf) { sprintf(buf, "%s(%d)", type_to_str(e->type), e->type); @@ -165,41 +165,41 @@ static const char *event_type_to_str(struct drm_xe_eudebug_event *e, char *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) + if (flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + if (flags & PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK) return "create|ack"; else return "create"; } - if (flags & DRM_XE_EUDEBUG_EVENT_DESTROY) + if (flags & PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY) return "destroy"; - if (flags & DRM_XE_EUDEBUG_EVENT_STATE_CHANGE) + if (flags & PRELIM_DRM_XE_EUDEBUG_EVENT_STATE_CHANGE) return "state-change"; - igt_assert(!(flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)); + igt_assert(!(flags & PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK)); return "flags unknown"; } -static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *buf) +static const char *event_members_to_str(struct prelim_drm_xe_eudebug_event *e, char *buf) { switch (e->type) { - case DRM_XE_EUDEBUG_EVENT_OPEN: { - struct drm_xe_eudebug_event_client *ec = igt_container_of(e, ec, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN: { + struct prelim_drm_xe_eudebug_event_client *ec = igt_container_of(e, ec, base); sprintf(buf, "handle=%llu", ec->client_handle); break; } - case DRM_XE_EUDEBUG_EVENT_VM: { - struct drm_xe_eudebug_event_vm *evm = igt_container_of(e, evm, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM: { + struct prelim_drm_xe_eudebug_event_vm *evm = igt_container_of(e, evm, base); sprintf(buf, "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 = igt_container_of(e, ee, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: { + struct prelim_drm_xe_eudebug_event_exec_queue *ee = igt_container_of(e, ee, base); sprintf(buf, "client_handle=%llu, vm_handle=%llu, " "exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d", @@ -207,8 +207,8 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu ee->exec_queue_handle, ee->engine_class, ee->width); break; } - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { - struct drm_xe_eudebug_event_exec_queue_placements *ee = igt_container_of(e, ee, + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { + struct prelim_drm_xe_eudebug_event_exec_queue_placements *ee = igt_container_of(e, ee, base); struct drm_xe_engine_class_instance *instances = (void *)(ee->instances); int i, l; @@ -228,8 +228,8 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu break; } - case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: { - struct drm_xe_eudebug_event_eu_attention *ea = igt_container_of(e, ea, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: { + struct prelim_drm_xe_eudebug_event_eu_attention *ea = igt_container_of(e, ea, base); sprintf(buf, "client_handle=%llu, exec_queue_handle=%llu, " "lrc_handle=%llu, bitmask_size=%d", @@ -237,42 +237,42 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu ea->lrc_handle, ea->bitmask_size); break; } - case DRM_XE_EUDEBUG_EVENT_VM_BIND: { - struct drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND: { + struct prelim_drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base); sprintf(buf, "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 = igt_container_of(e, op, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: { + struct prelim_drm_xe_eudebug_event_vm_bind_op *op = igt_container_of(e, op, base); sprintf(buf, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu", op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions); break; } - case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: { - struct drm_xe_eudebug_event_vm_bind_ufence *f = igt_container_of(e, f, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: { + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *f = igt_container_of(e, f, base); sprintf(buf, "vm_bind_ref_seqno=%lld", f->vm_bind_ref_seqno); break; } - case DRM_XE_EUDEBUG_EVENT_METADATA: { - struct drm_xe_eudebug_event_metadata *em = igt_container_of(e, em, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA: { + struct prelim_drm_xe_eudebug_event_metadata *em = igt_container_of(e, em, base); sprintf(buf, "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 = igt_container_of(e, op, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: { + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *op = igt_container_of(e, op, base); sprintf(buf, "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; } - case DRM_XE_EUDEBUG_EVENT_PAGEFAULT: { - struct drm_xe_eudebug_event_pagefault *pf = igt_container_of(e, pf, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT: { + struct prelim_drm_xe_eudebug_event_pagefault *pf = igt_container_of(e, pf, base); sprintf(buf, "client_handle=%llu, exec_queue_handle=%llu, " "lrc_handle=%llu, bitmask_size=%d, pagefault_address=0x%llx", @@ -297,7 +297,7 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu * * 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) +const char *xe_eudebug_event_to_str(struct prelim_drm_xe_eudebug_event *e, char *buf, size_t len) { char a[256]; char b[256]; @@ -502,15 +502,15 @@ static void event_log_read_from_fd(struct xe_eudebug_event_log *l, int fd) read_all(fd, l->log, l->head); } -typedef int (*cmp_fn_t)(struct drm_xe_eudebug_event *, void *); +typedef int (*cmp_fn_t)(struct prelim_drm_xe_eudebug_event *, void *); -static struct drm_xe_eudebug_event * +static struct prelim_drm_xe_eudebug_event * event_cmp(struct xe_eudebug_event_log *l, - struct drm_xe_eudebug_event *current, + struct prelim_drm_xe_eudebug_event *current, cmp_fn_t match, void *data) { - struct drm_xe_eudebug_event *e = current; + struct prelim_drm_xe_eudebug_event *e = current; xe_eudebug_for_each_event(e, l) { if (match(e, data)) @@ -520,9 +520,9 @@ event_cmp(struct xe_eudebug_event_log *l, return NULL; } -static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data) +static int match_type_and_flags(struct prelim_drm_xe_eudebug_event *a, void *data) { - struct drm_xe_eudebug_event *b = data; + struct prelim_drm_xe_eudebug_event *b = data; if (a->type == b->type && a->flags == b->flags) @@ -531,9 +531,9 @@ static int match_type_and_flags(struct drm_xe_eudebug_event *a, void *data) return 0; } -static int match_fields(struct drm_xe_eudebug_event *a, void *data) +static int match_fields(struct prelim_drm_xe_eudebug_event *a, void *data) { - struct drm_xe_eudebug_event *b = data; + struct prelim_drm_xe_eudebug_event *b = data; int ret = 0; ret = match_type_and_flags(a, data); @@ -543,18 +543,18 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) ret = 0; switch (a->type) { - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: { - struct drm_xe_eudebug_event_exec_queue *ae = igt_container_of(a, ae, base); - struct drm_xe_eudebug_event_exec_queue *be = igt_container_of(b, be, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: { + struct prelim_drm_xe_eudebug_event_exec_queue *ae = igt_container_of(a, ae, base); + struct prelim_drm_xe_eudebug_event_exec_queue *be = igt_container_of(b, be, base); if (ae->engine_class == be->engine_class && ae->width == be->width) ret = 1; break; } - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { - struct drm_xe_eudebug_event_exec_queue_placements *ae = igt_container_of(a, ae, + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { + struct prelim_drm_xe_eudebug_event_exec_queue_placements *ae = igt_container_of(a, ae, base); - struct drm_xe_eudebug_event_exec_queue_placements *be = igt_container_of(b, be, + struct prelim_drm_xe_eudebug_event_exec_queue_placements *be = igt_container_of(b, be, base); if (ae->num_placements == be->num_placements && @@ -564,26 +564,26 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) break; } - case DRM_XE_EUDEBUG_EVENT_VM_BIND: { - struct drm_xe_eudebug_event_vm_bind *ea = igt_container_of(a, ea, base); - struct drm_xe_eudebug_event_vm_bind *eb = igt_container_of(b, eb, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND: { + struct prelim_drm_xe_eudebug_event_vm_bind *ea = igt_container_of(a, ea, base); + struct prelim_drm_xe_eudebug_event_vm_bind *eb = igt_container_of(b, eb, base); 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 = igt_container_of(a, ea, base); - struct drm_xe_eudebug_event_vm_bind_op *eb = igt_container_of(b, eb, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: { + struct prelim_drm_xe_eudebug_event_vm_bind_op *ea = igt_container_of(a, ea, base); + struct prelim_drm_xe_eudebug_event_vm_bind_op *eb = igt_container_of(b, eb, base); 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 = igt_container_of(a, ea, base); - struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = igt_container_of(b, eb, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: { + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *ea = igt_container_of(a, ea, base); + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *eb = igt_container_of(b, eb, base); if (ea->metadata_handle == eb->metadata_handle && ea->metadata_cookie == eb->metadata_cookie) @@ -599,7 +599,7 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) return ret; } -static int match_client_handle(struct drm_xe_eudebug_event *e, void *data) +static int match_client_handle(struct prelim_drm_xe_eudebug_event *e, void *data) { struct match_dto *md = data; uint64_t *bind_seqno = md->bind_seqno; @@ -610,37 +610,37 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data) return 0; switch (e->type) { - case DRM_XE_EUDEBUG_EVENT_OPEN: { - struct drm_xe_eudebug_event_client *client = igt_container_of(e, client, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN: { + struct prelim_drm_xe_eudebug_event_client *client = igt_container_of(e, client, base); if (client->client_handle == h) return 1; break; } - case DRM_XE_EUDEBUG_EVENT_VM: { - struct drm_xe_eudebug_event_vm *vm = igt_container_of(e, vm, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM: { + struct prelim_drm_xe_eudebug_event_vm *vm = igt_container_of(e, vm, base); if (vm->client_handle == h) return 1; break; } - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: { - struct drm_xe_eudebug_event_exec_queue *ee = igt_container_of(e, ee, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: { + struct prelim_drm_xe_eudebug_event_exec_queue *ee = igt_container_of(e, ee, base); if (ee->client_handle == h) return 1; break; } - case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { - struct drm_xe_eudebug_event_exec_queue_placements *ee = igt_container_of(e, ee, + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS: { + struct prelim_drm_xe_eudebug_event_exec_queue_placements *ee = igt_container_of(e, ee, base); if (ee->client_handle == h) return 1; break; } - case DRM_XE_EUDEBUG_EVENT_VM_BIND: { - struct drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND: { + struct prelim_drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base); if (evmb->client_handle == h) { *bind_seqno = evmb->base.seqno; @@ -648,8 +648,8 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data) } break; } - case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: { - struct drm_xe_eudebug_event_vm_bind_op *eo = igt_container_of(e, eo, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: { + struct prelim_drm_xe_eudebug_event_vm_bind_op *eo = igt_container_of(e, eo, base); if (eo->vm_bind_ref_seqno == *bind_seqno) { *bind_op_seqno = eo->base.seqno; @@ -657,23 +657,23 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data) } break; } - case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = igt_container_of(e, ef, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: { + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = igt_container_of(e, ef, base); if (ef->vm_bind_ref_seqno == *bind_seqno) return 1; break; } - case DRM_XE_EUDEBUG_EVENT_METADATA: { - struct drm_xe_eudebug_event_metadata *em = igt_container_of(e, em, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA: { + struct prelim_drm_xe_eudebug_event_metadata *em = igt_container_of(e, em, base); 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 = igt_container_of(e, eo, base); + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: { + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *eo = igt_container_of(e, eo, base); if (eo->vm_bind_op_ref_seqno == *bind_op_seqno) return 1; @@ -686,74 +686,74 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data) return 0; } -static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data) +static int match_opposite_resource(struct prelim_drm_xe_eudebug_event *e, void *data) { - struct drm_xe_eudebug_event *d = data; + struct prelim_drm_xe_eudebug_event *d = data; int ret; - d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY; - d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK); + d->flags ^= PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE | PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY; + d->flags &= ~(PRELIM_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; + d->flags ^= PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE | PRELIM_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 = igt_container_of(e, client, base); - struct drm_xe_eudebug_event_client *filter = data; + case PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN: { + struct prelim_drm_xe_eudebug_event_client *client = igt_container_of(e, client, base); + struct prelim_drm_xe_eudebug_event_client *filter = data; if (client->client_handle == filter->client_handle) return 1; break; } - case DRM_XE_EUDEBUG_EVENT_VM: { - struct drm_xe_eudebug_event_vm *vm = igt_container_of(e, vm, base); - struct drm_xe_eudebug_event_vm *filter = data; + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM: { + struct prelim_drm_xe_eudebug_event_vm *vm = igt_container_of(e, vm, base); + struct prelim_drm_xe_eudebug_event_vm *filter = 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 = igt_container_of(e, ee, base); - struct drm_xe_eudebug_event_exec_queue *filter = data; + case PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: { + struct prelim_drm_xe_eudebug_event_exec_queue *ee = igt_container_of(e, ee, base); + struct prelim_drm_xe_eudebug_event_exec_queue *filter = 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 = igt_container_of(e, evmb, base); - struct drm_xe_eudebug_event_vm_bind *filter = data; + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND: { + struct prelim_drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base); + struct prelim_drm_xe_eudebug_event_vm_bind *filter = 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 = igt_container_of(e, avmb, base); - struct drm_xe_eudebug_event_vm_bind_op *filter = data; + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: { + struct prelim_drm_xe_eudebug_event_vm_bind_op *avmb = igt_container_of(e, avmb, base); + struct prelim_drm_xe_eudebug_event_vm_bind_op *filter = 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 = igt_container_of(e, em, base); - struct drm_xe_eudebug_event_metadata *filter = data; + case PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA: { + struct prelim_drm_xe_eudebug_event_metadata *em = igt_container_of(e, em, base); + struct prelim_drm_xe_eudebug_event_metadata *filter = 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 = igt_container_of(e, avmb, + case PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: { + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *avmb = igt_container_of(e, avmb, base); - struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = data; + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *filter = data; if (avmb->metadata_handle == filter->metadata_handle && avmb->metadata_cookie == filter->metadata_cookie) @@ -767,7 +767,7 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data) return 0; } -static int match_full(struct drm_xe_eudebug_event *e, void *data) +static int match_full(struct prelim_drm_xe_eudebug_event *e, void *data) { struct seqno_list_entry *sl; @@ -790,18 +790,18 @@ static int match_full(struct drm_xe_eudebug_event *e, void *data) return 1; } -static struct drm_xe_eudebug_event * +static struct prelim_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) + struct prelim_drm_xe_eudebug_event *target, + struct prelim_drm_xe_eudebug_event *current) { return event_cmp(l, current, match_type_and_flags, target); } -static struct drm_xe_eudebug_event * +static struct prelim_drm_xe_eudebug_event * client_match(struct xe_eudebug_event_log *l, uint64_t client_handle, - struct drm_xe_eudebug_event *current, + struct prelim_drm_xe_eudebug_event *current, uint32_t filter, uint64_t *bind_seqno, uint64_t *bind_op_seqno) @@ -816,17 +816,17 @@ client_match(struct xe_eudebug_event_log *l, return event_cmp(l, current, match_client_handle, &md); } -static struct drm_xe_eudebug_event * +static struct prelim_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) + struct prelim_drm_xe_eudebug_event *target, + struct prelim_drm_xe_eudebug_event *current) { return event_cmp(l, current, match_opposite_resource, target); } -static struct drm_xe_eudebug_event * +static struct prelim_drm_xe_eudebug_event * event_match(struct xe_eudebug_event_log *l, - struct drm_xe_eudebug_event *target, + struct prelim_drm_xe_eudebug_event *target, uint64_t client_handle, struct igt_list_head *seqno_list, uint64_t *bind_seqno, @@ -843,16 +843,16 @@ event_match(struct xe_eudebug_event_log *l, return event_cmp(l, NULL, match_full, &md); } -static void compare_client(struct xe_eudebug_event_log *log1, struct drm_xe_eudebug_event *ev1, - struct xe_eudebug_event_log *log2, struct drm_xe_eudebug_event *ev2, +static void compare_client(struct xe_eudebug_event_log *log1, struct prelim_drm_xe_eudebug_event *ev1, + struct xe_eudebug_event_log *log2, struct prelim_drm_xe_eudebug_event *ev2, uint32_t filter) { - struct drm_xe_eudebug_event_client *ev1_client = igt_container_of(ev1, ev1_client, base); - struct drm_xe_eudebug_event_client *ev2_client = igt_container_of(ev2, ev2_client, base); + struct prelim_drm_xe_eudebug_event_client *ev1_client = igt_container_of(ev1, ev1_client, base); + struct prelim_drm_xe_eudebug_event_client *ev2_client = igt_container_of(ev2, ev2_client, base); uint64_t cbs = 0, dbs = 0, cbso = 0, dbso = 0; struct igt_list_head matched_seqno_list; - struct drm_xe_eudebug_event *evptr1, *evptr2; + struct prelim_drm_xe_eudebug_event *evptr1, *evptr2; struct seqno_list_entry *entry, *tmp; igt_assert(ev1_client); @@ -905,10 +905,10 @@ static void compare_client(struct xe_eudebug_event_log *log1, struct drm_xe_eude * Returns: pointer to the event with given seqno within @l or NULL seqno is * not present. */ -struct drm_xe_eudebug_event * +struct prelim_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; + struct prelim_drm_xe_eudebug_event *e = NULL, *found = NULL; igt_assert(l); igt_assert_neq(seqno, 0); @@ -936,7 +936,7 @@ xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno) static void event_log_sort(struct xe_eudebug_event_log *l) { struct xe_eudebug_event_log *tmp; - struct drm_xe_eudebug_event *e = NULL; + struct prelim_drm_xe_eudebug_event *e = NULL; uint64_t first_seqno = UINT64_MAX; uint64_t last_seqno = 0; uint64_t events = 0, added = 0; @@ -985,13 +985,13 @@ static void event_log_sort(struct xe_eudebug_event_log *l) */ static int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags) { - struct drm_xe_eudebug_connect param = { + struct prelim_drm_xe_eudebug_connect param = { .pid = pid, .flags = flags, }; int debugfd; - debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, ¶m); + debugfd = igt_ioctl(fd, PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT, ¶m); if (debugfd < 0) return -errno; @@ -1047,7 +1047,7 @@ void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l) * * 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) +void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct prelim_drm_xe_eudebug_event *e) { igt_assert(l); igt_assert(e); @@ -1075,7 +1075,7 @@ void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eu void xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug) { - struct drm_xe_eudebug_event *e = NULL; + struct prelim_drm_xe_eudebug_event *e = NULL; int level = debug ? IGT_LOG_DEBUG : IGT_LOG_INFO; char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN]; @@ -1096,7 +1096,7 @@ xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug) * @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. + * 'PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN' will always be matched. * * Compares and asserts event logs @a, @b if the event * sequence matches. @@ -1105,15 +1105,15 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *log1, struct xe_eudebug_event_log *log2, uint32_t filter) { - struct drm_xe_eudebug_event *ev1 = NULL; - struct drm_xe_eudebug_event *ev2 = NULL; + struct prelim_drm_xe_eudebug_event *ev1 = NULL; + struct prelim_drm_xe_eudebug_event *ev2 = NULL; igt_assert(log1); igt_assert(log2); xe_eudebug_for_each_event(ev1, log1) { - if (ev1->type == DRM_XE_EUDEBUG_EVENT_OPEN && - ev1->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { + if (ev1->type == PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN && + ev1->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { ev2 = event_type_match(log2, ev1, ev2); compare_client(log1, ev1, log2, ev2, filter); @@ -1133,24 +1133,24 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *log1, void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter) { - struct drm_xe_eudebug_event *ev1 = NULL; - struct drm_xe_eudebug_event *ev2 = NULL; + struct prelim_drm_xe_eudebug_event *ev1 = NULL; + struct prelim_drm_xe_eudebug_event *ev2 = NULL; igt_assert(l); xe_eudebug_for_each_event(ev1, l) { - if (ev1->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { - uint8_t offset = sizeof(struct drm_xe_eudebug_event); + if (ev1->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + uint8_t offset = sizeof(struct prelim_drm_xe_eudebug_event); int opposite_matching; if (XE_EUDEBUG_EVENT_IS_FILTERED(ev1->type, filter)) continue; /* No opposite matching for some events */ - if ((ev1->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND && - ev1->type <= DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) || - ev1->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA || - ev1->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS) + if ((ev1->type >= PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND && + ev1->type <= PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) || + ev1->type == PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA || + ev1->type == PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS) continue; ev2 = opposite_event_match(l, ev1, ev1); @@ -1170,7 +1170,7 @@ xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t fil } static void debugger_run_triggers(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { struct event_trigger *t; @@ -1181,15 +1181,15 @@ static void debugger_run_triggers(struct xe_eudebug_debugger *d, } static int -xe_eudebug_read_event(int fd, struct drm_xe_eudebug_event *event) +xe_eudebug_read_event(int fd, struct prelim_drm_xe_eudebug_event *event) { int ret; - event->type = DRM_XE_EUDEBUG_EVENT_READ; + event->type = PRELIM_DRM_XE_EUDEBUG_EVENT_READ; event->flags = 0; event->len = MAX_EVENT_SIZE; - ret = igt_ioctl(fd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event); + ret = igt_ioctl(fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event); if (ret < 0) return -errno; @@ -1211,7 +1211,7 @@ static void debugger_signal_handler(int sig, siginfo_t *info, void *context) static void *debugger_worker_loop(void *data) { uint8_t buf[MAX_EVENT_SIZE]; - struct drm_xe_eudebug_event *e = (void *)buf; + struct prelim_drm_xe_eudebug_event *e = (void *)buf; struct xe_eudebug_debugger *d = data; struct pollfd p = { .events = POLLIN, @@ -1280,10 +1280,10 @@ static void *debugger_worker_loop(void *data) */ bool xe_eudebug_debugger_available(int fd) { - struct drm_xe_eudebug_connect param = { .pid = getpid() }; + struct prelim_drm_xe_eudebug_connect param = { .pid = getpid() }; int debugfd; - debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, ¶m); + debugfd = igt_ioctl(fd, PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT, ¶m); if (debugfd >= 0) close(debugfd); @@ -1871,10 +1871,10 @@ void xe_eudebug_session_destroy(struct xe_eudebug_session *s) free(s); } -#define to_base(x) ((struct drm_xe_eudebug_event *)&(x)) +#define to_base(x) ((struct prelim_drm_xe_eudebug_event *)&(x)) static void base_event(struct xe_eudebug_client *c, - struct drm_xe_eudebug_event *e, + struct prelim_drm_xe_eudebug_event *e, uint32_t type, uint32_t flags, uint64_t size) @@ -1887,9 +1887,9 @@ static void base_event(struct xe_eudebug_client *c, static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd) { - struct drm_xe_eudebug_event_client ec; + struct prelim_drm_xe_eudebug_event_client ec; - base_event(c, to_base(ec), DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec)); + base_event(c, to_base(ec), PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, flags, sizeof(ec)); ec.client_handle = client_fd; @@ -1898,9 +1898,9 @@ static void client_event(struct xe_eudebug_client *c, uint32_t flags, int client 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; + struct prelim_drm_xe_eudebug_event_vm evm; - base_event(c, to_base(evm), DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm)); + base_event(c, to_base(evm), PRELIM_DRM_XE_EUDEBUG_EVENT_VM, flags, sizeof(evm)); evm.client_handle = client_fd; evm.vm_handle = vm_id; @@ -1913,9 +1913,9 @@ static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags, uint32_t exec_queue_handle, uint16_t class, uint16_t width) { - struct drm_xe_eudebug_event_exec_queue ee; + struct prelim_drm_xe_eudebug_event_exec_queue ee; - base_event(c, to_base(ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + base_event(c, to_base(ee), PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, flags, sizeof(ee)); ee.client_handle = client_fd; @@ -1934,15 +1934,15 @@ static void exec_queue_placements_event(struct xe_eudebug_client *c, uint16_t num_placements, struct drm_xe_engine_class_instance *eci) { - struct drm_xe_eudebug_event_exec_queue_placements *ee; + struct prelim_drm_xe_eudebug_event_exec_queue_placements *ee; struct drm_xe_engine_class_instance *instances; size_t sz = sizeof(*ee) + num_placements * sizeof(uint64_t); ee = calloc(1, sz); igt_assert(ee); - base_event(c, to_base(*ee), DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS, - DRM_XE_EUDEBUG_EVENT_CREATE, sz); + base_event(c, to_base(*ee), PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS, + PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, sz); ee->client_handle = client_fd; ee->vm_handle = vm_id; @@ -1960,9 +1960,9 @@ static void exec_queue_placements_event(struct xe_eudebug_client *c, 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; + struct prelim_drm_xe_eudebug_event_metadata em; - base_event(c, to_base(em), DRM_XE_EUDEBUG_EVENT_METADATA, + base_event(c, to_base(em), PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, flags, sizeof(em)); em.client_handle = client_fd; @@ -1973,7 +1973,7 @@ static void metadata_event(struct xe_eudebug_client *c, uint32_t flags, xe_eudebug_event_log_write(c->log, (void *)&em); } -#define EU_DEBUG_TOGGLE "device/enable_eudebug" +#define EU_DEBUG_TOGGLE "device/prelim_enable_eudebug" static char *get_card_name(int fd, char *card_name, size_t len) { @@ -2117,7 +2117,7 @@ int xe_eudebug_client_open_driver(struct xe_eudebug_client *c) igt_assert(c); fd = drm_reopen_driver(c->master_fd); - client_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd); + client_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, fd); return fd; } @@ -2133,7 +2133,7 @@ int xe_eudebug_client_open_driver(struct xe_eudebug_client *c) void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd) { igt_assert(c); - client_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd); + client_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY, fd); drm_close_driver(fd); } @@ -2156,7 +2156,7 @@ uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd, igt_assert(c); vm = xe_vm_create(fd, flags, ext); - vm_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm); + vm_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, fd, vm); return vm; } @@ -2174,7 +2174,7 @@ void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t { igt_assert(c); xe_vm_destroy(fd, vm); - vm_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm); + vm_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY, fd, vm); } /** @@ -2207,12 +2207,12 @@ uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd for (ext = from_user_pointer(create->extensions); ext; ext = from_user_pointer(ext->base.next_extension)) if (ext->base.name == DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY && - ext->property == DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG && - ext->value & DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE) + ext->property == PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG && + ext->value & PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE) send = true; if (send) { - exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id, + exec_queue_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, fd, create->vm_id, create->exec_queue_id, class, create->width); for (int i = 0; i < create->width; i++) { @@ -2254,12 +2254,12 @@ void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd, for (ext = from_user_pointer(create->extensions); ext; ext = from_user_pointer(ext->base.next_extension)) if (ext->base.name == DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY && - ext->property == DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG && - ext->value & DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE) + ext->property == PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG && + ext->value & PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE) send = true; if (send) - exec_queue_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, create->vm_id, + exec_queue_event(c, PRELIM_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); @@ -2281,12 +2281,12 @@ void xe_eudebug_client_vm_bind_event(struct xe_eudebug_client *c, uint32_t vm, uint32_t bind_flags, uint32_t num_binds, u64 *ref_seqno) { - struct drm_xe_eudebug_event_vm_bind evmb; + struct prelim_drm_xe_eudebug_event_vm_bind evmb; igt_assert(c); igt_assert(ref_seqno); - base_event(c, to_base(evmb), DRM_XE_EUDEBUG_EVENT_VM_BIND, + base_event(c, to_base(evmb), PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND, event_flags, sizeof(evmb)); evmb.client_handle = fd; evmb.vm_handle = vm; @@ -2315,12 +2315,12 @@ void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t ev uint64_t addr, uint64_t range, uint64_t num_extensions) { - struct drm_xe_eudebug_event_vm_bind_op op; + struct prelim_drm_xe_eudebug_event_vm_bind_op op; igt_assert(c); igt_assert(op_ref_seqno); - base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, + base_event(c, to_base(op), PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, event_flags, sizeof(op)); op.vm_bind_ref_seqno = bind_ref_seqno; op.addr = addr; @@ -2346,11 +2346,11 @@ 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; + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata op; igt_assert(c); - base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA, + base_event(c, to_base(op), PRELIM_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; @@ -2370,11 +2370,11 @@ void xe_eudebug_client_vm_bind_op_metadata_event(struct xe_eudebug_client *c, 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; + struct prelim_drm_xe_eudebug_event_vm_bind_ufence f; igt_assert(c); - base_event(c, to_base(f), DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + base_event(c, to_base(f), PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, event_flags, sizeof(f)); f.vm_bind_ref_seqno = ref_seqno; @@ -2394,7 +2394,7 @@ static bool has_user_fence(const struct drm_xe_sync *sync, uint32_t num_syncs) 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) + if ((__m)->base.name == PRELIM_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, @@ -2406,10 +2406,10 @@ static int __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, uint32_t prefetch_region, uint8_t pat_index, uint64_t op_ext) { - struct drm_xe_vm_bind_op_ext_attach_debug *metadata; + struct prelim_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; + PRELIM_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; @@ -2419,10 +2419,10 @@ static int __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, switch (op) { case DRM_XE_VM_BIND_OP_MAP: - bind_base_flags = DRM_XE_EUDEBUG_EVENT_CREATE; + bind_base_flags = PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE; break; case DRM_XE_VM_BIND_OP_UNMAP: - bind_base_flags = DRM_XE_EUDEBUG_EVENT_DESTROY; + bind_base_flags = PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY; igt_assert_eq(num_metadata, 0); igt_assert_eq(ufence, false); break; @@ -2442,7 +2442,7 @@ static int __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, if (!bind_base_flags) return -EINVAL; - xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE, + xe_eudebug_client_vm_bind_event(c, PRELIM_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, @@ -2450,13 +2450,13 @@ static int __xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, for_each_metadata(metadata, op_ext) xe_eudebug_client_vm_bind_op_metadata_event(c, - DRM_XE_EUDEBUG_EVENT_CREATE, + PRELIM_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, + xe_eudebug_client_vm_bind_ufence_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE | + PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK, seqno); return ret; } @@ -2596,16 +2596,16 @@ void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, int fd, uint32_t v 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 = { + struct prelim_drm_xe_debug_metadata_create create = { .type = type, .user_addr = to_user_pointer(data), .len = len }; igt_assert(c); - igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0); + igt_assert_eq(igt_ioctl(fd, PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE, &create), 0); - metadata_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len); + metadata_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, fd, create.metadata_id, type, len); return create.metadata_id; } @@ -2624,18 +2624,18 @@ uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd, 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 }; + struct prelim_drm_xe_debug_metadata_destroy destroy = { .metadata_id = id }; igt_assert(c); - igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0); + igt_assert_eq(igt_ioctl(fd, PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY, &destroy), 0); - metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type, len); + metadata_event(c, PRELIM_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) + const struct prelim_drm_xe_eudebug_event_vm_bind_ufence *f) { - struct drm_xe_eudebug_ack_event ack = { 0, }; + struct prelim_drm_xe_eudebug_ack_event ack = { 0, }; char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN]; igt_assert(f); @@ -2645,5 +2645,5 @@ void xe_eudebug_ack_ufence(int debugfd, 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); + igt_assert_eq(igt_ioctl(debugfd, PRELIM_DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &ack), 0); } diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h index 23f0d7e34..4f3c4887f 100644 --- a/lib/xe/xe_eudebug.h +++ b/lib/xe/xe_eudebug.h @@ -6,7 +6,6 @@ #include #include #include -#include #include "igt_core.h" #include "igt_list.h" @@ -84,7 +83,7 @@ struct xe_eudebug_session { typedef void (*xe_eudebug_client_work_fn)(struct xe_eudebug_client *); typedef void (*xe_eudebug_trigger_fn)(struct xe_eudebug_debugger *, - struct drm_xe_eudebug_event *); + struct prelim_drm_xe_eudebug_event *); #define xe_eudebug_for_each_engine(fd__, hwe__) \ xe_for_each_engine(fd__, hwe__) \ @@ -93,8 +92,8 @@ typedef void (*xe_eudebug_trigger_fn)(struct xe_eudebug_debugger *, #define MAX_EVENT_SIZE (32 * 1024) -static inline struct drm_xe_eudebug_event * -next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l) +static inline struct prelim_drm_xe_eudebug_event * +next_event(struct prelim_drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l) { uint8_t *start; uint8_t *end; @@ -108,7 +107,7 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l) return NULL; if (!e) - return (struct drm_xe_eudebug_event *)l->log; + return (struct prelim_drm_xe_eudebug_event *)l->log; start = (uint8_t *)e; @@ -127,7 +126,7 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l) igt_assert(end < l->log + l->head); - return (struct drm_xe_eudebug_event *)end; + return (struct prelim_drm_xe_eudebug_event *)end; } #define xe_eudebug_for_each_event(_e, _log) \ @@ -159,24 +158,24 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l) */ #define XE_EUDEBUG_DEFAULT_TIMEOUT_SEC 60ULL -#define XE_EUDEBUG_FILTER_EVENT_NONE BIT(DRM_XE_EUDEBUG_EVENT_NONE) -#define XE_EUDEBUG_FILTER_EVENT_READ BIT(DRM_XE_EUDEBUG_EVENT_READ) -#define XE_EUDEBUG_FILTER_EVENT_OPEN BIT(DRM_XE_EUDEBUG_EVENT_OPEN) -#define XE_EUDEBUG_FILTER_EVENT_VM BIT(DRM_XE_EUDEBUG_EVENT_VM) -#define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE) -#define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE_PLACEMENTS BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS) -#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_EVENT_METADATA BIT(DRM_XE_EUDEBUG_EVENT_METADATA) -#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_METADATA BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA) -#define XE_EUDEBUG_FILTER_EVENT_PAGEFAULT BIT(DRM_XE_EUDEBUG_EVENT_PAGEFAULT) -#define XE_EUDEBUG_FILTER_ALL GENMASK(DRM_XE_EUDEBUG_EVENT_PAGEFAULT, 0) +#define XE_EUDEBUG_FILTER_EVENT_NONE BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_NONE) +#define XE_EUDEBUG_FILTER_EVENT_READ BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_READ) +#define XE_EUDEBUG_FILTER_EVENT_OPEN BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN) +#define XE_EUDEBUG_FILTER_EVENT_VM BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_VM) +#define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE) +#define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE_PLACEMENTS BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS) +#define XE_EUDEBUG_FILTER_EVENT_EU_ATTENTION BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION) +#define XE_EUDEBUG_FILTER_EVENT_VM_BIND BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND) +#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP) +#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE) +#define XE_EUDEBUG_FILTER_EVENT_METADATA BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA) +#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_METADATA BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA) +#define XE_EUDEBUG_FILTER_EVENT_PAGEFAULT BIT(PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT) +#define XE_EUDEBUG_FILTER_ALL GENMASK(PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT, 0) #define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f) ((1UL << (_e)) & (_f)) -const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len); -struct drm_xe_eudebug_event * +const char *xe_eudebug_event_to_str(struct prelim_drm_xe_eudebug_event *e, char *buf, size_t len); +struct prelim_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); @@ -184,7 +183,7 @@ 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_write(struct xe_eudebug_event_log *l, struct prelim_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); @@ -242,7 +241,7 @@ void xe_eudebug_client_vm_bind_op_metadata_event(struct xe_eudebug_client *c, 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); + const struct prelim_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, diff --git a/tests/intel/xe_eudebug.c b/tests/intel/xe_eudebug.c index 6f5103a19..51f4dcb8d 100644 --- a/tests/intel/xe_eudebug.c +++ b/tests/intel/xe_eudebug.c @@ -70,15 +70,15 @@ static void test_sysfs_toggle(int fd) #define TEST_DISCOVERY (1 << 31) #define PAGE_SIZE SZ_4K -#define MDATA_SIZE (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM * PAGE_SIZE) +#define MDATA_SIZE (PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM * PAGE_SIZE) #define BO_ADDR 0x1a0000 -static struct drm_xe_vm_bind_op_ext_attach_debug * +static struct prelim_drm_xe_vm_bind_op_ext_attach_debug * basic_vm_bind_metadata_ext_prepare(int fd, struct xe_eudebug_client *c, uint8_t **data) { const uint32_t data_size = MDATA_SIZE; - struct drm_xe_vm_bind_op_ext_attach_debug *ext; + struct prelim_drm_xe_vm_bind_op_ext_attach_debug *ext; int i; *data = calloc(data_size, sizeof(**data)); @@ -87,26 +87,26 @@ basic_vm_bind_metadata_ext_prepare(int fd, struct xe_eudebug_client *c, uint8_t for (i = 0; i < data_size; i++) (*data)[i] = (i + i / PAGE_SIZE) % 256; - ext = calloc(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM, sizeof(*ext)); + ext = calloc(PRELIM_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; + for (i = 0; i < PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM; i++) { + ext[i].base.name = PRELIM_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) + if (i < PRELIM_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, + struct prelim_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++) + for (int i = 0; i < PRELIM_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); @@ -115,7 +115,7 @@ static void basic_vm_bind_metadata_ext_del(int fd, struct xe_eudebug_client *c, static void basic_vm_bind_client(int fd, struct xe_eudebug_client *c) { - struct drm_xe_vm_bind_op_ext_attach_debug *ext = NULL; + struct prelim_drm_xe_vm_bind_op_ext_attach_debug *ext = NULL; uint32_t vm = xe_eudebug_client_vm_create(c, fd, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0); size_t bo_size = xe_get_default_alignment(fd); bool test_discovery = c->flags & TEST_DISCOVERY; @@ -321,10 +321,10 @@ static void do_bind_list(struct xe_eudebug_client *c, } xe_vm_bind_array(bl->fd, bl->vm, 0, bl->bind_ops, bl->n, &uf_sync, sync ? 1 : 0); - xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE, + xe_eudebug_client_vm_bind_event(c, PRELIM_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, + xe_eudebug_client_vm_bind_op_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, ref_seqno, &op_ref_seqno, bl->bind_ops[i].addr, @@ -388,16 +388,16 @@ static void vm_bind_client(int fd, struct xe_eudebug_client *c) 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, + xe_eudebug_client_vm_bind_event(c, PRELIM_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, + xe_eudebug_client_vm_bind_op_event(c, PRELIM_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, + xe_eudebug_client_vm_bind_op_event(c, PRELIM_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, + xe_eudebug_client_vm_bind_op_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE, ref_seqno, &op_ref_seqno, bl->bind_ops[i].addr, bl->bind_ops[i].range, 0); @@ -417,9 +417,9 @@ static void vm_bind_client(int fd, struct xe_eudebug_client *c) 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, + xe_eudebug_client_vm_bind_event(c, PRELIM_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, + xe_eudebug_client_vm_bind_op_event(c, PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY, ref_seqno, &op_ref_seqno, 0, 0, 0); gem_close(fd, bo[0]); @@ -452,8 +452,8 @@ static void run_basic_client(struct xe_eudebug_client *c) struct drm_xe_engine_class_instance *hwe; struct drm_xe_ext_set_property eq_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, + .property = PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, + .value = PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, }; uint32_t vm; @@ -489,22 +489,22 @@ static void run_basic_client(struct xe_eudebug_client *c) xe_eudebug_client_close_driver(c, fd); } -static int read_event(int debugfd, struct drm_xe_eudebug_event *event) +static int read_event(int debugfd, struct prelim_drm_xe_eudebug_event *event) { int ret; - ret = igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event); + ret = igt_ioctl(debugfd, PRELIM_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) +static int __read_event(int debugfd, struct prelim_drm_xe_eudebug_event *event) { int ret; - ret = ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event); + ret = ioctl(debugfd, PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_EVENT, event); if (ret < 0) return -errno; @@ -528,11 +528,11 @@ static int poll_event(int fd, int timeout_ms) return ret == 1 && (p.revents & POLLIN); } -static int __debug_connect(int fd, int *debugfd, struct drm_xe_eudebug_connect *param) +static int __debug_connect(int fd, int *debugfd, struct prelim_drm_xe_eudebug_connect *param) { int ret = 0; - *debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT, param); + *debugfd = igt_ioctl(fd, PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT, param); if (*debugfd < 0) { ret = -errno; @@ -552,7 +552,7 @@ static int __debug_connect(int fd, int *debugfd, struct drm_xe_eudebug_connect * */ static void test_connect(int fd) { - struct drm_xe_eudebug_connect param = {}; + struct prelim_drm_xe_eudebug_connect param = {}; int debugfd, ret; pid_t *pid; @@ -636,7 +636,7 @@ static void switch_user(__uid_t uid, __gid_t gid) */ static void test_connect_user(int fd) { - struct drm_xe_eudebug_connect param = {}; + struct prelim_drm_xe_eudebug_connect param = {}; struct passwd *pwd, *pwd2; const char *user1 = "lp"; const char *user2 = "mail"; @@ -769,7 +769,7 @@ static void test_connect_user(int fd) */ static void test_close(int fd) { - struct drm_xe_eudebug_connect param = { 0, }; + struct prelim_drm_xe_eudebug_connect param = { 0, }; int debug_fd1, debug_fd2; int fd2; @@ -799,7 +799,7 @@ static void test_close(int fd) #define MAX_EVENT_SIZE (32 * 1024) static void test_read_event(int fd) { - struct drm_xe_eudebug_event *event; + struct prelim_drm_xe_eudebug_event *event; struct xe_eudebug_debugger *d; struct xe_eudebug_client *c; @@ -814,17 +814,17 @@ static void test_read_event(int fd) /* Negative read event - no events to read */ event->len = MAX_EVENT_SIZE; - event->type = DRM_XE_EUDEBUG_EVENT_READ; + event->type = PRELIM_DRM_XE_EUDEBUG_EVENT_READ; igt_assert_eq(read_event(d->fd, event), -ENOENT); xe_eudebug_client_start(c); /* Positive read event - client create */ igt_assert_eq(poll_event(d->fd, 500), 1); - event->type = DRM_XE_EUDEBUG_EVENT_READ; + event->type = PRELIM_DRM_XE_EUDEBUG_EVENT_READ; igt_assert_eq(read_event(d->fd, event), 0); - igt_assert_eq(event->type, DRM_XE_EUDEBUG_EVENT_OPEN); - igt_assert_eq(event->flags, DRM_XE_EUDEBUG_EVENT_CREATE); + igt_assert_eq(event->type, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN); + igt_assert_eq(event->flags, PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE); igt_assert_eq(poll_event(d->fd, 500), 1); @@ -832,10 +832,10 @@ static void test_read_event(int fd) /* Negative read event - bad event type */ event->len = MAX_EVENT_SIZE; - event->type = DRM_XE_EUDEBUG_EVENT_NONE; + event->type = PRELIM_DRM_XE_EUDEBUG_EVENT_NONE; igt_assert_eq(read_event(d->fd, event), -EINVAL); - event->type = DRM_XE_EUDEBUG_EVENT_READ; + event->type = PRELIM_DRM_XE_EUDEBUG_EVENT_READ; /* Negative read event - bad event len */ event->len = 0; @@ -860,8 +860,8 @@ static void test_read_event(int fd) /* Positive read event - client destroy */ igt_assert_eq(read_event(d->fd, event), 0); - igt_assert_eq(event->type, DRM_XE_EUDEBUG_EVENT_OPEN); - igt_assert_eq(event->flags, DRM_XE_EUDEBUG_EVENT_DESTROY); + igt_assert_eq(event->type, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN); + igt_assert_eq(event->flags, PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY); fcntl(d->fd, F_SETFL, fcntl(d->fd, F_GETFL) | O_NONBLOCK); igt_assert(fcntl(d->fd, F_GETFL) & O_NONBLOCK); @@ -870,7 +870,7 @@ static void test_read_event(int fd) igt_assert_eq(poll_event(d->fd, 500), 0); event->len = MAX_EVENT_SIZE; event->flags = 0; - event->type = DRM_XE_EUDEBUG_EVENT_READ; + event->type = PRELIM_DRM_XE_EUDEBUG_EVENT_READ; igt_assert_eq(__read_event(d->fd, event), -EAGAIN); xe_eudebug_client_wait_done(c); @@ -1063,8 +1063,8 @@ static void run_discovery_client(struct xe_eudebug_client *c) DRM_XE_VM_CREATE_FLAG_LR_MODE, 0); struct drm_xe_ext_set_property eq_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, + .property = PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, + .value = PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, }; struct drm_xe_exec_queue_create create = { .width = 1, @@ -1135,7 +1135,7 @@ static void *discovery_race_thread(void *data) igt_assert_eq(ret, 0); if (random() % 2) { - struct drm_xe_eudebug_event *e = NULL; + struct prelim_drm_xe_eudebug_event *e = NULL; int max_worker_waits = 30; int i = -1; @@ -1162,8 +1162,8 @@ static void *discovery_race_thread(void *data) igt_debug("Resources discovered: %" PRIu64 "\n", s->debugger->event_count); if (!s->client->done) { xe_eudebug_for_each_event(e, s->debugger->log) { - if (e->type == DRM_XE_EUDEBUG_EVENT_OPEN) { - struct drm_xe_eudebug_event_client *eo = (void *)e; + if (e->type == PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN) { + struct prelim_drm_xe_eudebug_event_client *eo = (void *)e; if (i >= 0) { igt_assert_eq(clients[i].vm_count, @@ -1184,13 +1184,13 @@ static void *discovery_race_thread(void *data) clients[i].vm_bind_op_count = 0; } - if (e->type == DRM_XE_EUDEBUG_EVENT_VM) + if (e->type == PRELIM_DRM_XE_EUDEBUG_EVENT_VM) clients[i].vm_count++; - if (e->type == DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE) + if (e->type == PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE) clients[i].exec_queue_count++; - if (e->type == DRM_XE_EUDEBUG_EVENT_VM_BIND_OP) + if (e->type == PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP) clients[i].vm_bind_op_count++; }; @@ -1362,11 +1362,11 @@ static void test_empty_discovery(int fd, unsigned int flags, int clients) } static void ufence_ack_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; - if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) xe_eudebug_ack_ufence(d->fd, ef); } @@ -1393,7 +1393,7 @@ static void test_client_with_trigger(int fd, unsigned int flags, int count, xe_eudebug_debugger_add_trigger(s[i]->debugger, type, trigger_fn); for (i = 0; i < count; i++) - xe_eudebug_debugger_add_trigger(s[i]->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s[i]->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); for (i = 0; i < count; i++) @@ -1515,7 +1515,7 @@ static void debugger_test_vma(struct xe_eudebug_debugger *d, uint64_t va_start, uint64_t va_length) { - struct drm_xe_eudebug_vm_open vo = { 0, }; + struct prelim_drm_xe_eudebug_vm_open vo = { 0, }; uint64_t *v1, *v2; uint64_t items = va_length / sizeof(uint64_t); uint64_t offset; @@ -1530,7 +1530,7 @@ static void debugger_test_vma(struct xe_eudebug_debugger *d, vo.client_handle = client_handle; vo.vm_handle = vm_handle; - fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lte(0, fd); r = pread(fd, v1, va_length, va_start); @@ -1570,19 +1570,19 @@ static void debugger_test_vma(struct xe_eudebug_debugger *d, } static void vm_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + struct prelim_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; + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + struct prelim_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 *) + eb = (struct prelim_drm_xe_eudebug_event_vm_bind *) xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno); igt_assert(eb); @@ -1627,7 +1627,7 @@ static void test_vm_access(int fd, unsigned int flags, int num_clients) xe_eudebug_for_each_engine(fd, hwe) test_client_with_trigger(fd, flags, num_clients, vm_access_client, - DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, + PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, vm_trigger, hwe, false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP | @@ -1640,7 +1640,7 @@ static void debugger_test_vma_parameters(struct xe_eudebug_debugger *d, uint64_t va_start, uint64_t va_length) { - struct drm_xe_eudebug_vm_open vo = { 0, }; + struct prelim_drm_xe_eudebug_vm_open vo = { 0, }; uint64_t *v; uint64_t items = va_length / sizeof(uint64_t); int fd; @@ -1652,19 +1652,19 @@ static void debugger_test_vma_parameters(struct xe_eudebug_debugger *d, /* 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); + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lt(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); + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lt(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); + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lte(0, fd); /* Negative pread - bad fd */ @@ -1735,19 +1735,19 @@ static void debugger_test_vma_parameters(struct xe_eudebug_debugger *d, } static void vm_trigger_access_parameters(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + struct prelim_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; + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + struct prelim_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 *) + eb = (struct prelim_drm_xe_eudebug_event_vm_bind *) xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno); igt_assert(eb); @@ -1789,7 +1789,7 @@ static void test_vm_access_parameters(int fd, unsigned int flags, int num_client xe_eudebug_for_each_engine(fd, hwe) test_client_with_trigger(fd, flags, num_clients, vm_access_client, - DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, + PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, vm_trigger_access_parameters, hwe, false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP | @@ -1799,7 +1799,7 @@ static void test_vm_access_parameters(int fd, unsigned int flags, int num_client 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; + struct prelim_drm_xe_vm_bind_op_ext_attach_debug *ext; uint8_t *data; size_t bo_size; uint32_t bo, vm; @@ -1816,7 +1816,7 @@ static void metadata_access_client(struct xe_eudebug_client *c) 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++) + for (i = 0; i < PRELIM_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); @@ -1835,7 +1835,7 @@ static void debugger_test_metadata(struct xe_eudebug_debugger *d, uint64_t type, uint64_t len) { - struct drm_xe_eudebug_read_metadata rm = { + struct prelim_drm_xe_eudebug_read_metadata rm = { .client_handle = client_handle, .metadata_handle = metadata_handle, .size = len, @@ -1848,7 +1848,7 @@ static void debugger_test_metadata(struct xe_eudebug_debugger *d, rm.ptr = to_user_pointer(data); - igt_assert_eq(igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0); + igt_assert_eq(igt_ioctl(d->fd, PRELIM_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); @@ -1860,14 +1860,14 @@ static void debugger_test_metadata(struct xe_eudebug_debugger *d, } static void metadata_read_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_metadata *em = (void *)e; + struct prelim_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) { + if (e->flags & PRELIM_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); @@ -1875,11 +1875,11 @@ static void metadata_read_trigger(struct xe_eudebug_debugger *d, } static void metadata_read_on_vm_bind_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_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; + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *em = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind *eb; /* For testing purpose client sets metadata_cookie = type */ @@ -1887,10 +1887,10 @@ static void metadata_read_on_vm_bind_trigger(struct xe_eudebug_debugger *d, * 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 *) + eo = (struct prelim_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 *) + eb = (struct prelim_drm_xe_eudebug_event_vm_bind *) xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno); igt_assert(eb); @@ -1907,12 +1907,12 @@ static void metadata_read_on_vm_bind_trigger(struct xe_eudebug_debugger *d, * SUBTEST: read-metadata * Functionality: metadata * Description: - * Exercise DRM_XE_EUDEBUG_IOCTL_READ_METADATA and debug metadata create|destroy events. + * Exercise PRELIM_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, + PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, metadata_read_trigger, NULL, true, 0); } @@ -1925,7 +1925,7 @@ static void test_metadata_read(int fd, unsigned int flags, int num_clients) 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, + PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA, metadata_read_on_vm_bind_trigger, NULL, true, 0); } @@ -2046,7 +2046,7 @@ static void basic_ufence_client(struct xe_eudebug_client *c) } struct ufence_priv { - struct drm_xe_eudebug_event_vm_bind_ufence ufence_events[UFENCE_EVENT_COUNT_MAX]; + struct prelim_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]; @@ -2088,14 +2088,14 @@ static void ack_fences(struct xe_eudebug_debugger *d) } static void basic_ufence_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; struct ufence_priv *priv = d->ptr; - if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN]; - struct drm_xe_eudebug_event_vm_bind *eb; + struct prelim_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); @@ -2106,11 +2106,11 @@ static void basic_ufence_trigger(struct xe_eudebug_debugger *d, memcpy(&priv->ufence_events[priv->ufence_event_count++], ef, sizeof(*ef)); - eb = (struct drm_xe_eudebug_event_vm_bind *) + eb = (struct prelim_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, + xe_eudebug_assert_f(d, eb->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE, "vm bind event does not have ufence: %s\n", event_str); } } @@ -2169,7 +2169,7 @@ static void test_basic_ufence(int fd, unsigned int flags) d = s->debugger; xe_eudebug_debugger_add_trigger(d, - DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, basic_ufence_trigger); igt_assert_eq(xe_eudebug_debugger_attach(d, c), 0); @@ -2271,8 +2271,8 @@ static void *vm_bind_clear_thread(void *data) igt_until_timeout(5) { struct drm_xe_ext_set_property eq_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, + .property = PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, + .value = PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, }; struct drm_xe_exec_queue_create eq_create = { 0 }; uint32_t clean_bo = 0; @@ -2415,30 +2415,30 @@ static void vm_bind_clear_client(struct xe_eudebug_client *c) } static void vm_bind_clear_test_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + struct prelim_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 (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { if (random() & 1) { - struct drm_xe_eudebug_vm_open vo = { 0, }; + struct prelim_drm_xe_eudebug_vm_open vo = { 0, }; uint32_t v = 0xc1c1c1c1; - struct drm_xe_eudebug_event_vm_bind *eb; + struct prelim_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 *) + eb = (struct prelim_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); + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lte(0, fd); delta = (random() % eo->range) & -4; @@ -2451,14 +2451,14 @@ static void vm_bind_clear_test_trigger(struct xe_eudebug_debugger *d, priv->bind_count++; } - if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY) + if (e->flags & PRELIM_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 prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; xe_eudebug_ack_ufence(d->fd, ef); } @@ -2484,9 +2484,9 @@ static void test_vm_bind_clear(int fd, uint32_t flags) priv = vm_bind_clear_priv_create(); s = xe_eudebug_session_create(fd, vm_bind_clear_client, flags, priv); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, vm_bind_clear_test_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, vm_bind_clear_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -2576,7 +2576,7 @@ static void debugger_test_vma_ufence(struct xe_eudebug_debugger *d, uint64_t va_start, uint64_t va_length) { - struct drm_xe_eudebug_vm_open vo = { 0, }; + struct prelim_drm_xe_eudebug_vm_open vo = { 0, }; uint32_t *v1, *v2; uint32_t items = va_length / sizeof(uint32_t); int fd; @@ -2590,7 +2590,7 @@ static void debugger_test_vma_ufence(struct xe_eudebug_debugger *d, vo.client_handle = client_handle; vo.vm_handle = vm_handle; - fd = igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lte(0, fd); r = pread(fd, v1, va_length, va_start); @@ -2619,14 +2619,14 @@ static void debugger_test_vma_ufence(struct xe_eudebug_debugger *d, } static void vma_ufence_op_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; struct ufence_priv *priv = d->ptr; - if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN]; - struct drm_xe_eudebug_event_vm_bind *eb; + struct prelim_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); @@ -2637,12 +2637,12 @@ static void vma_ufence_op_trigger(struct xe_eudebug_debugger *d, 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 *) + eb = (struct prelim_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, + xe_eudebug_assert_f(d, eb->flags & PRELIM_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; @@ -2652,15 +2652,15 @@ static void vma_ufence_op_trigger(struct xe_eudebug_debugger *d, } static void vma_ufence_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + struct prelim_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) { + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN]; - struct drm_xe_eudebug_event_vm_bind *eb; + struct prelim_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]; @@ -2673,11 +2673,11 @@ static void vma_ufence_trigger(struct xe_eudebug_debugger *d, memcpy(&priv->ufence_events[priv->ufence_event_count++], ef, sizeof(*ef)); - eb = (struct drm_xe_eudebug_event_vm_bind *) + eb = (struct prelim_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, + xe_eudebug_assert_f(d, eb->flags & PRELIM_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%" PRIu64 ", range 0x%" PRIu64 "\n", ef->vm_bind_ref_seqno, @@ -2713,10 +2713,10 @@ static void test_vma_ufence(int fd, unsigned int flags) s = xe_eudebug_session_create(fd, vma_ufence_client, flags, priv); xe_eudebug_debugger_add_trigger(s->debugger, - DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, + PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP, vma_ufence_op_trigger); xe_eudebug_debugger_add_trigger(s->debugger, - DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, vma_ufence_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -2746,10 +2746,10 @@ static void test_basic_exec_queues_enable(int fd) struct drm_xe_engine_class_instance *hwe; struct drm_xe_ext_set_property eq_ext = { .base.name = DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY, - .property = DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, + .property = PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, .value = 0, }; - const uint64_t success_value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE; + const uint64_t success_value = PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE; const uint64_t ext = to_user_pointer(&eq_ext); uint32_t vm_non_lr, vm_lr; diff --git a/tests/intel/xe_eudebug_online.c b/tests/intel/xe_eudebug_online.c index 6c8766a8e..aaf21d820 100644 --- a/tests/intel/xe_eudebug_online.c +++ b/tests/intel/xe_eudebug_online.c @@ -168,7 +168,7 @@ struct online_debug_data { int stepped_threads_count; struct timespec exception_arrived; int last_eu_control_seqno; - struct drm_xe_eudebug_event *exception_event; + struct prelim_drm_xe_eudebug_event *exception_event; int att_event_counter; uint32_t pf_thread_number; int num_threads_per_eu; @@ -343,11 +343,11 @@ static int count_canaries_neq(uint32_t *ptr, struct dim_t w_dim, uint32_t value) static const char *td_ctl_cmd_to_str(uint32_t cmd) { switch (cmd) { - case DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL: + case PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL: return "interrupt all"; - case DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED: + case PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED: return "stopped"; - case DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME: + case PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME: return "resume"; default: return "unknown command"; @@ -359,7 +359,7 @@ static int __eu_ctl(int debugfd, uint64_t client, uint8_t *bitmask, uint32_t *bitmask_size, uint32_t cmd, uint64_t *seqno) { - struct drm_xe_eudebug_eu_control control = { + struct prelim_drm_xe_eudebug_eu_control control = { .client_handle = lower_32_bits(client), .exec_queue_handle = exec_queue, .lrc_handle = lrc, @@ -371,7 +371,7 @@ static int __eu_ctl(int debugfd, uint64_t client, if (bitmask_size) control.bitmask_size = *bitmask_size; - ret = igt_ioctl(debugfd, DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &control); + ret = igt_ioctl(debugfd, PRELIM_DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &control); if (ret < 0) return -errno; @@ -423,7 +423,7 @@ static uint64_t eu_ctl_resume(int fd, int debugfd, uint64_t client, } return eu_ctl(debugfd, client, exec_queue, lrc, bitmask, &bitmask_size, - DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME); + PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME); } static inline uint64_t eu_ctl_stopped(int debugfd, uint64_t client, @@ -431,14 +431,14 @@ static inline uint64_t eu_ctl_stopped(int debugfd, uint64_t client, 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); + PRELIM_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); + PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL); } static struct online_debug_data * @@ -504,9 +504,9 @@ static void wait_for_workload_start(struct online_debug_data *data) } static void eu_attention_debug_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_eu_attention *att = (void *)e; + struct prelim_drm_xe_eudebug_event_eu_attention *att = (void *)e; uint32_t *ptr = (uint32_t *)att->bitmask; igt_debug("EVENT[%llu] eu-attenttion; threads=%d " @@ -520,9 +520,9 @@ static void eu_attention_debug_trigger(struct xe_eudebug_debugger *d, } static void eu_attention_reset_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_eu_attention *att = (void *)e; + struct prelim_drm_xe_eudebug_event_eu_attention *att = (void *)e; uint32_t *ptr = (uint32_t *)att->bitmask; struct online_debug_data *data = d->ptr; @@ -681,7 +681,7 @@ static int get_stepped_threads_count(struct online_debug_data *data, int threads } static void save_first_exception_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { struct online_debug_data *data = d->ptr; @@ -695,9 +695,9 @@ static void save_first_exception_trigger(struct xe_eudebug_debugger *d, #define MAX_PREEMPT_TIMEOUT 10ull static void eu_attention_resume_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_eu_attention *att = (void *) e; + struct prelim_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; @@ -773,9 +773,9 @@ static void eu_attention_resume_trigger(struct xe_eudebug_debugger *d, } static void eu_attention_resume_single_step_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_eu_attention *att = (void *) e; + struct prelim_drm_xe_eudebug_event_eu_attention *att = (void *) e; struct online_debug_data *data = d->ptr; const int threads = data->thread_count; uint32_t val; @@ -868,12 +868,12 @@ static void eu_attention_resume_single_step_trigger(struct xe_eudebug_debugger * } static void open_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_client *client = (void *)e; + struct prelim_drm_xe_eudebug_event_client *client = (void *)e; struct online_debug_data *data = d->ptr; - if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY) + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY) return; pthread_mutex_lock(&data->mutex); @@ -882,12 +882,12 @@ static void open_trigger(struct xe_eudebug_debugger *d, } static void exec_queue_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_exec_queue *eq = (void *)e; + struct prelim_drm_xe_eudebug_event_exec_queue *eq = (void *)e; struct online_debug_data *data = d->ptr; - if (e->flags & DRM_XE_EUDEBUG_EVENT_DESTROY) + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY) return; pthread_mutex_lock(&data->mutex); @@ -897,18 +897,18 @@ static void exec_queue_trigger(struct xe_eudebug_debugger *d, } static void vm_open_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm *vm = (void *)e; + struct prelim_drm_xe_eudebug_event_vm *vm = (void *)e; struct online_debug_data *data = d->ptr; - struct drm_xe_eudebug_vm_open vo = { + struct prelim_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); + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + fd = igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vo); igt_assert_lte(0, fd); pthread_mutex_lock(&data->mutex); @@ -930,7 +930,7 @@ static void read_metadata(struct xe_eudebug_debugger *d, uint64_t type, uint64_t len) { - struct drm_xe_eudebug_read_metadata rm = { + struct prelim_drm_xe_eudebug_read_metadata rm = { .client_handle = client_handle, .metadata_handle = metadata_handle, .size = len, @@ -942,15 +942,15 @@ static void read_metadata(struct xe_eudebug_debugger *d, igt_assert(metadata); rm.ptr = to_user_pointer(metadata); - igt_assert_eq(igt_ioctl(d->fd, DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0); + igt_assert_eq(igt_ioctl(d->fd, PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &rm), 0); pthread_mutex_lock(&data->mutex); switch (type) { - case DRM_XE_DEBUG_METADATA_ELF_BINARY: + case PRELIM_DRM_XE_DEBUG_METADATA_ELF_BINARY: data->bb_offset = metadata[0]; data->bb_size = metadata[1]; break; - case DRM_XE_DEBUG_METADATA_PROGRAM_MODULE: + case PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE: data->target_offset = metadata[0]; data->target_size = metadata[1]; break; @@ -962,11 +962,11 @@ static void read_metadata(struct xe_eudebug_debugger *d, free(metadata); } -static void create_metadata_trigger(struct xe_eudebug_debugger *d, struct drm_xe_eudebug_event *e) +static void create_metadata_trigger(struct xe_eudebug_debugger *d, struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_metadata *em = (void *)e; + struct prelim_drm_xe_eudebug_event_metadata *em = (void *)e; - if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) read_metadata(d, em->client_handle, em->metadata_handle, em->type, em->len); } @@ -998,9 +998,9 @@ static void overwrite_immediate_value_in_common_target_write(int vm_fd, uint64_t } static void eu_attention_resume_caching_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_eu_attention *att = (void *)e; + struct prelim_drm_xe_eudebug_event_eu_attention *att = (void *)e; struct online_debug_data *data = d->ptr; struct dim_t s_dim = surface_dimensions(data->thread_count); uint32_t *kernel_offset = &data->kernel_offset; @@ -1075,7 +1075,7 @@ static void eu_attention_resume_caching_trigger(struct xe_eudebug_debugger *d, } ret = __eu_ctl(d->fd, att->client_handle, att->exec_queue_handle, att->lrc_handle, - att->bitmask, &att->bitmask_size, DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME, + att->bitmask, &att->bitmask_size, PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME, &seqno); /* @@ -1134,8 +1134,8 @@ static void run_online_client(struct xe_eudebug_client *c) 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, + .property = PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, + .value = PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, }; struct drm_xe_exec_queue_create create = { .instances = to_user_pointer(&hwe), @@ -1183,10 +1183,10 @@ static void run_online_client(struct xe_eudebug_client *c) 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, + metadata_id[0] = xe_eudebug_client_metadata_create(c, fd, PRELIM_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, + PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE, 2 * sizeof(**metadata), metadata[1]); vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE; @@ -1242,10 +1242,10 @@ static void run_online_client(struct xe_eudebug_client *c) 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, + xe_eudebug_client_metadata_destroy(c, fd, metadata_id[0], PRELIM_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, + PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE, 2 * sizeof(**metadata)); intel_buf_destroy(buf); @@ -1307,18 +1307,18 @@ static int query_attention_bitmask_size(int fd, int gt) return max_eu_count * DIV_ROUND_UP(threads_per_eu, 8); } -static struct drm_xe_eudebug_event_exec_queue * +static struct prelim_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 prelim_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; + struct prelim_drm_xe_eudebug_event_exec_queue *ee; + struct prelim_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 (event->type == PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE && + event->flags == PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + ee = (struct prelim_drm_xe_eudebug_event_exec_queue *)event; if (ee->exec_queue_handle != ea->exec_queue_handle) continue; @@ -1345,9 +1345,9 @@ match_attention_with_exec_queue(struct xe_eudebug_event_log *log, */ 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 (current->type == PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE && + current->flags == PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY) { + uint8_t offset = sizeof(struct prelim_drm_xe_eudebug_event); if (memcmp((uint8_t *)current + offset, (uint8_t *)event + offset, @@ -1369,9 +1369,9 @@ match_attention_with_exec_queue(struct xe_eudebug_event_log *log, 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_pagefault *pf = NULL; - struct drm_xe_eudebug_event *event = NULL; + struct prelim_drm_xe_eudebug_event_eu_attention *ea = NULL; + struct prelim_drm_xe_eudebug_event_pagefault *pf = NULL; + struct prelim_drm_xe_eudebug_event *event = NULL; struct online_debug_data *data = s->client->ptr; bool expect_exception = flags & DISABLE_DEBUG_MODE ? false : true; int sum = 0; @@ -1385,14 +1385,14 @@ static void online_session_check(struct xe_eudebug_session *s, int flags) bitmask_size = query_attention_bitmask_size(s->debugger->master_fd, data->hwe.gt_id); xe_eudebug_for_each_event(event, s->debugger->log) { - if (event->type == DRM_XE_EUDEBUG_EVENT_EU_ATTENTION) { - ea = (struct drm_xe_eudebug_event_eu_attention *)event; + if (event->type == PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION) { + ea = (struct prelim_drm_xe_eudebug_event_eu_attention *)event; - igt_assert(event->flags == DRM_XE_EUDEBUG_EVENT_STATE_CHANGE); + igt_assert(event->flags == PRELIM_DRM_XE_EUDEBUG_EVENT_STATE_CHANGE); igt_assert_eq(ea->bitmask_size, bitmask_size); sum += igt_bitmap_hweight(ea->bitmask, bitmask_size * 8); igt_assert(match_attention_with_exec_queue(s->debugger->log, ea)); - } else if (event->type == DRM_XE_EUDEBUG_EVENT_PAGEFAULT) { + } else if (event->type == PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT) { uint32_t after_offset = bitmask_size / sizeof(uint32_t); uint32_t resolved_offset = bitmask_size / sizeof(uint32_t) * 2; uint32_t *ptr = NULL; @@ -1428,21 +1428,21 @@ static void online_session_check(struct xe_eudebug_session *s, int flags) } static void ufence_ack_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; - if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) xe_eudebug_ack_ufence(d->fd, ef); } static void ufence_ack_set_bp_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; struct online_debug_data *data = d->ptr; - if (e->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { set_breakpoint_once(d, data); xe_eudebug_ack_ufence(d->fd, ef); } @@ -1471,9 +1471,9 @@ static uint32_t get_thread_space_address(struct online_debug_data *data, int thr } static void pagefault_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *e) + struct prelim_drm_xe_eudebug_event *e) { - struct drm_xe_eudebug_event_pagefault *pf = igt_container_of(e, pf, base); + struct prelim_drm_xe_eudebug_event_pagefault *pf = igt_container_of(e, pf, base); struct online_debug_data *data = d->ptr; uint32_t attn_size = pf->bitmask_size / 3; int attn_size_as_u32 = attn_size / sizeof(uint32_t); @@ -1580,11 +1580,11 @@ static void test_basic_online(int fd, struct drm_xe_engine_class_instance *hwe, data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); xe_eudebug_session_run(s); @@ -1615,16 +1615,16 @@ static void test_set_breakpoint_online(int fd, struct drm_xe_engine_class_instan data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_set_bp_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); xe_eudebug_session_run(s); @@ -1682,17 +1682,17 @@ static void test_set_breakpoint_online_sigint_debugger(int fd, data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); s->client->allow_dead_client = true; - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_set_bp_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -1807,20 +1807,20 @@ static void test_pagefault_online(int fd, struct drm_xe_engine_class_instance *h } s = xe_eudebug_session_create(fd, run_online_client, data->flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_PAGEFAULT, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT, pagefault_trigger); xe_eudebug_session_run(s); @@ -1848,11 +1848,11 @@ static void test_preemption(int fd, struct drm_xe_engine_class_instance *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->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -1892,18 +1892,18 @@ static void test_reset_with_attention_online(int fd, struct drm_xe_engine_class_ data = online_debug_data_create(fd, hwe, flags); s1 = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s1->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s1->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_reset_trigger); - xe_eudebug_debugger_add_trigger(s1->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s1->debugger, PRELIM_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->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s2->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s2->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s2->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); xe_eudebug_session_run(s2); @@ -1945,18 +1945,18 @@ static void test_interrupt_all(int fd, struct drm_xe_engine_class_instance *hwe, data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -2026,13 +2026,13 @@ static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hw data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -2065,7 +2065,7 @@ static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hw */ igt_assert_eq(__eu_ctl(s->debugger->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); + PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL), -EINVAL); pthread_mutex_unlock(&debugee_data->mutex); xe_force_gt_reset_async(s->debugger->master_fd, debugee_data->hwe.gt_id); @@ -2121,18 +2121,18 @@ static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *h data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -2150,19 +2150,19 @@ static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *h igt_assert(__eu_ctl(s->debugger->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); + PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL); /* fail on invalid exec_queue_handle */ igt_assert(__eu_ctl(s->debugger->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); + PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL); /* fail on invalid client */ igt_assert(__eu_ctl(s->debugger->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); + PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL, NULL) == -EINVAL); /* * bitmask size must be aligned to sizeof(u32) for all commands @@ -2172,11 +2172,11 @@ static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *h igt_assert(__eu_ctl(s->debugger->fd, data->client_handle, data->exec_queue_handle, data->lrc_handle, attention_bitmask, &bitmask_size, - DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED, NULL) == -EINVAL); + PRELIM_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); + random_command = random() | (PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME + 1); igt_assert(__eu_ctl(s->debugger->fd, data->client_handle, data->exec_queue_handle, data->lrc_handle, attention_bitmask, &bitmask_size, random_command, NULL) == -EINVAL); @@ -2201,7 +2201,7 @@ static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *h } static void eu_attention_debugger_detach_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *event) + struct prelim_drm_xe_eudebug_event *event) { struct online_debug_data *data = d->ptr; uint64_t c_pid; @@ -2232,7 +2232,7 @@ static void eu_attention_debugger_detach_trigger(struct xe_eudebug_debugger *d, * a vm event being sent and vm_open_trigger being re-run, which would lead * to us trying to open a removed vm. Thus, remove this trigger from list. */ - xe_eudebug_debugger_remove_trigger(d, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_remove_trigger(d, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); /* Let the discovery worker discover resources */ sleep(2); @@ -2252,25 +2252,25 @@ static void eu_attention_debugger_detach_trigger(struct xe_eudebug_debugger *d, */ static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance *hwe, int flags) { - struct drm_xe_eudebug_event *e = NULL; + struct prelim_drm_xe_eudebug_event *e = NULL; struct online_debug_data *data; struct xe_eudebug_session *s; data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE, exec_queue_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debugger_detach_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0); @@ -2299,7 +2299,7 @@ static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance /* We expect workload reset, so no attention should be raised */ xe_eudebug_for_each_event(e, s->debugger->log) - igt_assert(e->type != DRM_XE_EUDEBUG_EVENT_EU_ATTENTION); + igt_assert(e->type != PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION); xe_eudebug_session_destroy(s); online_debug_data_destroy(data); @@ -2329,16 +2329,16 @@ static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, i data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_single_step_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); xe_eudebug_session_run(s); @@ -2348,7 +2348,7 @@ static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, i } static void eu_attention_debugger_ndetach_trigger(struct xe_eudebug_debugger *d, - struct drm_xe_eudebug_event *event) + struct prelim_drm_xe_eudebug_event *event) { struct online_debug_data *data = d->ptr; static int debugger_detach_count; @@ -2380,13 +2380,13 @@ static void test_debugger_reopen(int fd, struct drm_xe_engine_class_instance *hw s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debugger_ndetach_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); xe_eudebug_session_run(s); @@ -2430,16 +2430,16 @@ static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int f data = online_debug_data_create(fd, hwe, flags); s = xe_eudebug_session_create(fd, run_online_client, flags, data); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_OPEN, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_resume_caching_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_METADATA, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger); + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA, create_metadata_trigger); - xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); xe_eudebug_session_run(s); @@ -2542,7 +2542,7 @@ static void test_many_sessions_on_tiles(int fd, bool multi_tile) struct xe_eudebug_session **s; struct online_debug_data **data; struct drm_xe_engine_class_instance **hwe; - struct drm_xe_eudebug_event_eu_attention *eus; + struct prelim_drm_xe_eudebug_event_eu_attention *eus; uint64_t diff; int attempt_mask = 0, final_mask, should_break; int i; @@ -2558,11 +2558,11 @@ static void test_many_sessions_on_tiles(int fd, bool multi_tile) data[i] = online_debug_data_create(fd, hwe[i], flags); s[i] = xe_eudebug_session_create(fd, run_online_client, flags, data[i]); - xe_eudebug_debugger_add_trigger(s[i]->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s[i]->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, eu_attention_debug_trigger); - xe_eudebug_debugger_add_trigger(s[i]->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, + xe_eudebug_debugger_add_trigger(s[i]->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION, save_first_exception_trigger); - xe_eudebug_debugger_add_trigger(s[i]->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, + xe_eudebug_debugger_add_trigger(s[i]->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE, ufence_ack_trigger); igt_assert_eq(xe_eudebug_debugger_attach(s[i]->debugger, s[i]->client), 0); @@ -2589,7 +2589,7 @@ static void test_many_sessions_on_tiles(int fd, bool multi_tile) should_break = 1; usleep(WORKLOAD_DELAY_US); - eus = (struct drm_xe_eudebug_event_eu_attention *)data[i]->exception_event; + eus = (struct prelim_drm_xe_eudebug_event_eu_attention *)data[i]->exception_event; eu_ctl_resume(s[i]->debugger->master_fd, s[i]->debugger->fd, eus->client_handle, eus->exec_queue_handle, eus->lrc_handle, eus->bitmask, eus->bitmask_size); diff --git a/tests/intel/xe_eudebug_sriov.c b/tests/intel/xe_eudebug_sriov.c index 1f150d0ef..3833eb899 100644 --- a/tests/intel/xe_eudebug_sriov.c +++ b/tests/intel/xe_eudebug_sriov.c @@ -28,7 +28,7 @@ static bool has_vf_enable_eudebug_attr(int fd, unsigned int vf_num) sysfs = igt_sysfs_open(fd); igt_assert_fd(sysfs); /* vf_num is 1-based, but virtfn is 0-based */ - snprintf(path, sizeof(path), "device/virtfn%u/enable_eudebug", vf_num - 1); + snprintf(path, sizeof(path), "device/virtfn%u/prelim_enable_eudebug", vf_num - 1); ret = igt_sysfs_has_attr(sysfs, path); close(sysfs); @@ -62,7 +62,7 @@ static void test_deny_eudebug(int fd) igt_debug("VF%u probe failed\n", vf_num); err = true; } else if (has_vf_enable_eudebug_attr(fd, vf_num)) { - igt_debug("VF%u has enable_eudebug attribute\n", vf_num); + igt_debug("VF%u has prelim_enable_eudebug attribute\n", vf_num); err = true; } } @@ -71,7 +71,7 @@ static void test_deny_eudebug(int fd) sysfs = igt_sysfs_open(fd); igt_assert_fd(sysfs); - igt_assert_eq(igt_sysfs_printf(sysfs, "device/enable_eudebug", "1"), -EPERM); + igt_assert_eq(igt_sysfs_printf(sysfs, "device/prelim_enable_eudebug", "1"), -EPERM); close(sysfs); } diff --git a/tests/intel/xe_exec_sip_eudebug.c b/tests/intel/xe_exec_sip_eudebug.c index 20c2a1d82..70d3b93f1 100644 --- a/tests/intel/xe_exec_sip_eudebug.c +++ b/tests/intel/xe_exec_sip_eudebug.c @@ -257,8 +257,8 @@ static void test_sip(enum shader_type shader_type, enum sip_type sip_type, 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, + .property = PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG, + .value = PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, }; struct timespec ts = { }; uint32_t exec_queue_id, handle, vm_id; From 45e2e86f8ee4d8e5a945d60eb041282d5334a72b Mon Sep 17 00:00:00 2001 From: Christoph Manszewski Date: Thu, 22 Aug 2024 14:51:21 +0200 Subject: [PATCH 04/33] tests/intel-ci: meson_options: Enable EU debug build by default MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Kolanupaka Naveena Signed-off-by: Dominik Karol Piątkowski --- meson_options.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/meson_options.txt b/meson_options.txt index e23402b36..82800e5d0 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -44,7 +44,7 @@ option('xe_driver', option('xe_eudebug', type : 'feature', - value : 'disabled', + value : 'enabled', description : 'Build library and tests for Xe EU debugger') option('vmtb', From 7db963d282845e3a5eac54bff526cfd9724e29e4 Mon Sep 17 00:00:00 2001 From: Katarzyna Dec Date: Thu, 13 Jul 2023 12:37:28 +0000 Subject: [PATCH 05/33] tests/intel-ci: Add eudebug testlist MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit List of eudebug tests to be executed by regular validation runs. v2: Add missing tests v3: Add missing tests Signed-off-by: Katarzyna Piecielska Signed-off-by: Dominik Grzegorzek Signed-off-by: Christoph Manszewski Signed-off-by: Maciej Patelczyk Signed-off-by: Dominik Karol Piątkowski Signed-off-by: Pawel Sikora Signed-off-by: Karolina Stolarek Signed-off-by: Andrzej Hajda Signed-off-by: Kolanupaka Naveena --- tests/intel-ci/xe-eudebug.testlist | 100 +++++++++++++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 tests/intel-ci/xe-eudebug.testlist diff --git a/tests/intel-ci/xe-eudebug.testlist b/tests/intel-ci/xe-eudebug.testlist new file mode 100644 index 000000000..5a74aa9bd --- /dev/null +++ b/tests/intel-ci/xe-eudebug.testlist @@ -0,0 +1,100 @@ +#List of tests that we have in EUdebug and we want to execute +igt@xe_eudebug@attach-debug-metadata +igt@xe_eudebug@basic-client +igt@xe_eudebug@basic-client-th +igt@xe_eudebug@basic-close +igt@xe_eudebug@basic-connect +igt@xe_eudebug@basic-exec-queues +igt@xe_eudebug@basic-exec-queues-enable +igt@xe_eudebug@basic-read-event +igt@xe_eudebug@basic-vm-access +igt@xe_eudebug@basic-vm-access-faultable +igt@xe_eudebug@basic-vm-access-parameters +igt@xe_eudebug@basic-vm-access-parameters-faultable +igt@xe_eudebug@basic-vm-access-parameters-userptr +igt@xe_eudebug@basic-vm-access-parameters-userptr-faultable +igt@xe_eudebug@basic-vm-access-userptr +igt@xe_eudebug@basic-vm-access-userptr-faultable +igt@xe_eudebug@basic-vm-bind +igt@xe_eudebug@basic-vm-bind-discovery +igt@xe_eudebug@basic-vm-bind-extended +igt@xe_eudebug@basic-vm-bind-extended-discovery +igt@xe_eudebug@basic-vm-bind-metadata-discovery +igt@xe_eudebug@basic-vm-bind-ufence +igt@xe_eudebug@basic-vm-bind-ufence-delay-ack +igt@xe_eudebug@basic-vm-bind-ufence-reconnect +igt@xe_eudebug@basic-vm-bind-ufence-sigint-client +igt@xe_eudebug@basic-vm-bind-vm-destroy +igt@xe_eudebug@basic-vm-bind-vm-destroy-discovery +igt@xe_eudebug@basic-vms +igt@xe_eudebug@connect-user +igt@xe_eudebug@discovery-empty +igt@xe_eudebug@discovery-empty-clients +igt@xe_eudebug@multigpu-basic-client +igt@xe_eudebug@multigpu-basic-client-many +igt@xe_eudebug@multiple-sessions +igt@xe_eudebug@read-metadata +igt@xe_eudebug@sysfs-toggle +igt@xe_eudebug@vma-ufence +igt@xe_eudebug@vma-ufence-faultable +igt@xe_eudebug@vm-bind-clear +igt@xe_eudebug@vm-bind-clear-faultable +igt@xe_eudebug_online@basic-breakpoint +igt@xe_eudebug_online@breakpoint-many-sessions-single-tile +igt@xe_eudebug_online@breakpoint-many-sessions-tiles +igt@xe_eudebug_online@breakpoint-not-in-debug-mode +igt@xe_eudebug_online@debugger-reopen +igt@xe_eudebug_online@interrupt-all +igt@xe_eudebug_online@interrupt-all-set-breakpoint +igt@xe_eudebug_online@interrupt-all-set-breakpoint-faultable +igt@xe_eudebug_online@interrupt-other +igt@xe_eudebug_online@interrupt-other-debuggable +igt@xe_eudebug_online@interrupt-reconnect +igt@xe_eudebug_online@pagefault-read +igt@xe_eudebug_online@pagefault-read-stress +igt@xe_eudebug_online@pagefault-write +igt@xe_eudebug_online@pagefault-write-stress +igt@xe_eudebug_online@preempt-breakpoint +igt@xe_eudebug_online@reset-with-attention +igt@xe_eudebug_online@resume-dss +igt@xe_eudebug_online@resume-one +igt@xe_eudebug_online@set-breakpoint +igt@xe_eudebug_online@set-breakpoint-faultable +igt@xe_eudebug_online@set-breakpoint-sigint-debugger +igt@xe_eudebug_online@single-step +igt@xe_eudebug_online@single-step-one +igt@xe_eudebug_online@stopped-thread +igt@xe_eudebug_online@tdctl-parameters +igt@xe_eudebug_online@writes-caching-sram-bb-sram-target-sram +igt@xe_eudebug_online@writes-caching-sram-bb-sram-target-vram +igt@xe_eudebug_online@writes-caching-sram-bb-vram-target-sram +igt@xe_eudebug_online@writes-caching-sram-bb-vram-target-vram +igt@xe_eudebug_online@writes-caching-vram-bb-sram-target-sram +igt@xe_eudebug_online@writes-caching-vram-bb-sram-target-vram +igt@xe_eudebug_online@writes-caching-vram-bb-vram-target-sram +igt@xe_eudebug_online@writes-caching-vram-bb-vram-target-vram +igt@xe_eudebug_sriov@deny-eudebug +igt@xe_eudebug_sriov@deny-sriov +igt@xe_exec_sip@invalidinstr-disabled +igt@xe_exec_sip@invalidinstr-thread-enabled +igt@xe_exec_sip@invalidinstr-walker-enabled +igt@xe_exec_sip@sanity +igt@xe_exec_sip@sanity-after-timeout +igt@xe_exec_sip_eudebug@breakpoint-waitsip +igt@xe_exec_sip_eudebug@breakpoint-waitsip-heavy +igt@xe_exec_sip_eudebug@breakpoint-writesip +igt@xe_exec_sip_eudebug@breakpoint-writesip-nodebug +igt@xe_exec_sip_eudebug@breakpoint-writesip-twice +igt@xe_exec_sip_eudebug@wait-writesip-nodebug + +igt@xe_live_ktest@xe_eudebug + +#keep it as last so it is not affecting execution +igt@xe_eudebug@discovery-race +igt@xe_eudebug@discovery-race-sigint +igt@xe_eudebug@discovery-race-vmbind + +# tests written to show on offline demo, failing now, there is no point to fix +# as code dump KMD will change +#igt@xe_usercoredump@vma +#igt@xe_usercoredump@metadata From 5767e571ff017f030156c2687c96f2d6fb9c7984 Mon Sep 17 00:00:00 2001 From: Kolanupaka Naveena Date: Thu, 3 Jul 2025 11:36:59 +0530 Subject: [PATCH 06/33] tests/intel-ci: Add tests to block list which are expected to be skipped MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add tests to block list which are expected to be skipped as the supported kernel changes are not present. Signed-off-by: Kolanupaka Naveena Signed-off-by: Dominik Karol Piątkowski --- tests/intel-ci/xe.blocklist.txt | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tests/intel-ci/xe.blocklist.txt b/tests/intel-ci/xe.blocklist.txt index d5f2f44f2..b9c8586b7 100644 --- a/tests/intel-ci/xe.blocklist.txt +++ b/tests/intel-ci/xe.blocklist.txt @@ -125,6 +125,16 @@ igt@kms_chamelium_edid@hdmi-edid-stress-resolution-4k ################################################################## igt@xe_exec_compute_mode@non-blocking ################################################################## +# Tests are expected to be skipped because the required kernel +# changes are not present +################################################################## +igt@xe_exec_system_allocator@.* +igt@xe_pmu@.*fn-engine-activity.* +igt@xe_mmap@pci-membarrier.* +# fault-injection tests +igt@xe_fault_injection@* +################################################################## +################################################################## # Async flips with linear modifier are slower ################################################################## igt@kms_async_flips@async-flip-with-page-flip-events-linear.* From 7b2faeaca78cbfd0ee76862258877ba5e790f270 Mon Sep 17 00:00:00 2001 From: Katarzyna Piecielska Date: Fri, 4 Oct 2024 09:59:45 +0000 Subject: [PATCH 07/33] xe.fast-feedback: Update EU debugger test names MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit There was a change in names of caching tests. Now instead of 2 we have 8 tests. Let's fix it. Signed-off-by: Katarzyna Piecielska v2: Add missing tests v3: Add missing tests v4: Remove unnecessary tests v5: Rename xe-fast-feedback to xe.fast-feedback Signed-off-by: Dominik Karol Piątkowski --- tests/intel-ci/xe.fast-feedback.testlist | 61 ++++++++++++++++++++++++ 1 file changed, 61 insertions(+) diff --git a/tests/intel-ci/xe.fast-feedback.testlist b/tests/intel-ci/xe.fast-feedback.testlist index 64587cce1..5bb695cf5 100644 --- a/tests/intel-ci/xe.fast-feedback.testlist +++ b/tests/intel-ci/xe.fast-feedback.testlist @@ -314,3 +314,64 @@ igt@xe_evict@evict-small-cm igt@xe_evict@evict-small-external igt@xe_evict@evict-small-external-cm igt@xe_evict@evict-small-multi-vm + +# EU debugger tests +igt@xe_eudebug@attach-debug-metadata +igt@xe_eudebug@basic-client +igt@xe_eudebug@basic-client-th +igt@xe_eudebug@basic-close +igt@xe_eudebug@basic-connect +igt@xe_eudebug@basic-exec-queues +igt@xe_eudebug@basic-exec-queues-enable +igt@xe_eudebug@basic-read-event +igt@xe_eudebug@basic-vm-access +igt@xe_eudebug@basic-vm-access-parameters +igt@xe_eudebug@basic-vm-access-userptr +igt@xe_eudebug@basic-vm-bind +igt@xe_eudebug@basic-vm-bind-discovery +igt@xe_eudebug@basic-vm-bind-extended +igt@xe_eudebug@basic-vm-bind-extended-discovery +igt@xe_eudebug@basic-vm-bind-metadata-discovery +igt@xe_eudebug@basic-vm-bind-ufence +igt@xe_eudebug@basic-vm-bind-vm-destroy +igt@xe_eudebug@basic-vm-bind-vm-destroy-discovery +igt@xe_eudebug@basic-vms +igt@xe_eudebug@connect-user +igt@xe_eudebug@discovery-empty +igt@xe_eudebug@discovery-empty-clients +igt@xe_eudebug@multiple-sessions +igt@xe_eudebug@read-metadata +igt@xe_eudebug@sysfs-toggle +igt@xe_eudebug@vma-ufence +igt@xe_eudebug_online@basic-breakpoint +igt@xe_eudebug_online@breakpoint-not-in-debug-mode +igt@xe_eudebug_online@debugger-reopen +igt@xe_eudebug_online@interrupt-all +igt@xe_eudebug_online@interrupt-all-set-breakpoint +igt@xe_eudebug_online@interrupt-reconnect +igt@xe_eudebug_online@pagefault-read +igt@xe_eudebug_online@pagefault-write +igt@xe_eudebug_online@preempt-breakpoint +igt@xe_eudebug_online@reset-with-attention +igt@xe_eudebug_online@resume-dss +igt@xe_eudebug_online@resume-one +igt@xe_eudebug_online@set-breakpoint +igt@xe_eudebug_online@single-step +igt@xe_eudebug_online@single-step-one +igt@xe_eudebug_online@stopped-thread +igt@xe_eudebug_online@tdctl-parameters +igt@xe_eudebug_online@writes-caching-sram-bb-sram-target-vram +igt@xe_eudebug_online@writes-caching-sram-bb-vram-target-sram +igt@xe_eudebug_online@writes-caching-vram-bb-sram-target-sram +igt@xe_eudebug_online@writes-caching-vram-bb-sram-target-vram +igt@xe_eudebug_online@writes-caching-vram-bb-vram-target-sram +igt@xe_exec_sip@invalidinstr-disabled +igt@xe_exec_sip@invalidinstr-thread-enabled +igt@xe_exec_sip@invalidinstr-walker-enabled +igt@xe_exec_sip@sanity +igt@xe_exec_sip@sanity-after-timeout +igt@xe_exec_sip_eudebug@breakpoint-waitsip +igt@xe_exec_sip_eudebug@breakpoint-writesip +igt@xe_exec_sip_eudebug@breakpoint-writesip-nodebug +igt@xe_exec_sip_eudebug@breakpoint-writesip-twice +igt@xe_exec_sip_eudebug@wait-writesip-nodebug From 06fea35fabc06774c00c703393aa22938394cfcf Mon Sep 17 00:00:00 2001 From: Katarzyna Piecielska Date: Fri, 20 Dec 2024 10:47:21 +0000 Subject: [PATCH 08/33] xe.fast-feedback: Move ktests at the end MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Let's move ktests results at the end of fast-feedback and remove eudebug ktest as this is expected to skip. Signed-off-by: Katarzyna Piecielska v2: Rename xe-fast-feedback to xe.fast-feedback Signed-off-by: Dominik Karol Piątkowski --- tests/intel-ci/xe.fast-feedback.testlist | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/intel-ci/xe.fast-feedback.testlist b/tests/intel-ci/xe.fast-feedback.testlist index 5bb695cf5..06e6d2f3d 100644 --- a/tests/intel-ci/xe.fast-feedback.testlist +++ b/tests/intel-ci/xe.fast-feedback.testlist @@ -258,12 +258,6 @@ igt@xe_waitfence@reltime # driver in a broken state that is not otherwise noticed in that test. igt@core_hotunplug@unbind-rebind -# Run KUnit tests at the end -igt@xe_live_ktest@xe_bo@xe_ccs_migrate_kunit -igt@xe_live_ktest@xe_bo@xe_bo_evict_kunit -igt@xe_live_ktest@xe_dma_buf -igt@xe_live_ktest@xe_migrate - # Move fault_mode tests at the end to unblock execution igt@xe_exec_fault_mode@twice-basic igt@xe_exec_fault_mode@many-basic @@ -375,3 +369,9 @@ igt@xe_exec_sip_eudebug@breakpoint-writesip igt@xe_exec_sip_eudebug@breakpoint-writesip-nodebug igt@xe_exec_sip_eudebug@breakpoint-writesip-twice igt@xe_exec_sip_eudebug@wait-writesip-nodebug + +# Run KUnit tests at the end +igt@xe_live_ktest@xe_bo@xe_ccs_migrate_kunit +igt@xe_live_ktest@xe_bo@xe_bo_evict_kunit +igt@xe_live_ktest@xe_dma_buf +igt@xe_live_ktest@xe_migrate From f3a28d9e6f3739145ffb0e4873e84f6806e32413 Mon Sep 17 00:00:00 2001 From: Kolanupaka Naveena Date: Wed, 29 Oct 2025 16:45:27 +0530 Subject: [PATCH 09/33] tests/intel-ci: Update core blocklist of BMG MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Remove eudebug tests from the core blocklist of BMG as we have support for eudebug. Suggested-by: Gandi Ramadevi Signed-off-by: Kolanupaka Naveena Signed-off-by: Dominik Karol Piątkowski --- tests/intel-ci/xe.bmg.core.blocklist.txt | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/intel-ci/xe.bmg.core.blocklist.txt b/tests/intel-ci/xe.bmg.core.blocklist.txt index 628bc3d3b..50e241ef1 100644 --- a/tests/intel-ci/xe.bmg.core.blocklist.txt +++ b/tests/intel-ci/xe.bmg.core.blocklist.txt @@ -44,11 +44,6 @@ igt@.*@.*multi-queue.* ################################################################## # Expected skips, Kernel support not available ################################################################## -igt@xe_eudebug@.* -igt@xe_eudebug_online@.* -igt@xe_exec_sip@.* -igt@xe_exec_sip_eudebug@.* -igt@xe_live_ktest@xe_eudebug igt@xe_eudebug_sriov@deny-sriov igt@xe_eudebug_sriov@deny-eudebug ################################################################## From da0df6701b267fc113025acf0efbbf8a108b5b3e Mon Sep 17 00:00:00 2001 From: "Muppidi, Venkateswara Rao" Date: Tue, 27 Jan 2026 18:56:13 +0530 Subject: [PATCH 10/33] tests/intel/xe_test_config: Update test_config file Update test_config file to enable LNL/BMG eudebug runs on kobuk_6.17. Signed-off-by: Muppidi, Venkateswara Rao --- tests/intel/xe_test_config.json | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/intel/xe_test_config.json b/tests/intel/xe_test_config.json index cfdb369b8..63355b954 100644 --- a/tests/intel/xe_test_config.json +++ b/tests/intel/xe_test_config.json @@ -80,6 +80,9 @@ { "LNL": "../intel-ci/xe.lnl.core.blocklist.txt" }, { "BMG": "../intel-ci/xe.bmg.core.blocklist.txt" }, { "PTL": "../intel-ci/xe.ptl.core.blocklist.txt" }, + { "EUDEBUG-LNL": "../intel-ci/xe.lnl.eudebug.blocklist.txt" }, + { "EUDEBUG-BMG": "../intel-ci/xe.bmg.eudebug.blocklist.txt" }, + { "EUDEBUG-LNL, EUDEBUG-BMG": "../intel-ci/xe.eudebug.blocklist.txt" }, { "WCL": "../intel-ci/xe.wcl.core.blocklist.txt" }, { "all": "../intel-ci/xe.blocklist.txt" } ] From 8e00f4c054121265e82ba32ff757ce0896ac8c8d Mon Sep 17 00:00:00 2001 From: "Muppidi, Venkateswara Rao" Date: Mon, 16 Feb 2026 17:22:25 +0530 Subject: [PATCH 11/33] tests/intel/xe_test_config: Update test_config file for MPGPU Update test_config file to enable BMG multigpu runs on kobuk_6.17. Signed-off-by: Muppidi, Venkateswara Rao --- tests/intel/xe_test_config.json | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/intel/xe_test_config.json b/tests/intel/xe_test_config.json index 63355b954..9c3b0828a 100644 --- a/tests/intel/xe_test_config.json +++ b/tests/intel/xe_test_config.json @@ -82,6 +82,7 @@ { "PTL": "../intel-ci/xe.ptl.core.blocklist.txt" }, { "EUDEBUG-LNL": "../intel-ci/xe.lnl.eudebug.blocklist.txt" }, { "EUDEBUG-BMG": "../intel-ci/xe.bmg.eudebug.blocklist.txt" }, + { "MULTIGPU-BMG": "../intel-ci/xe.multigpu.blocklist.txt" }, { "EUDEBUG-LNL, EUDEBUG-BMG": "../intel-ci/xe.eudebug.blocklist.txt" }, { "WCL": "../intel-ci/xe.wcl.core.blocklist.txt" }, { "all": "../intel-ci/xe.blocklist.txt" } From 99e3dbd9e1c20884488a49969e3b175d1bc5d6ea Mon Sep 17 00:00:00 2001 From: Srinivasula Reddy Pondugula Date: Thu, 26 Feb 2026 18:34:17 +0000 Subject: [PATCH 12/33] tests/intel-ci: Add DKMS blocklist to unblock shard runs Signed-off-by: Srinivasula Reddy Pondugula --- tests/intel-ci/meson.build | 1 + tests/intel-ci/xe.bmg.dkms.blocklist.txt | 5 +++++ tests/intel/xe_test_config.json | 2 ++ 3 files changed, 8 insertions(+) create mode 100644 tests/intel-ci/xe.bmg.dkms.blocklist.txt diff --git a/tests/intel-ci/meson.build b/tests/intel-ci/meson.build index 3dab41898..78d0739b9 100644 --- a/tests/intel-ci/meson.build +++ b/tests/intel-ci/meson.build @@ -13,6 +13,7 @@ intelci_files = [ 'xe.blocklist.txt', 'xe.bmg.core.blocklist.txt', 'xe.bmg.display.blocklist.txt', + 'xe.bmg.dkms.blocklist.txt', 'xe.bmg.eudebug.blocklist.txt', 'xe.eudebug.blocklist.txt', 'xe.fast-feedback.testlist', diff --git a/tests/intel-ci/xe.bmg.dkms.blocklist.txt b/tests/intel-ci/xe.bmg.dkms.blocklist.txt new file mode 100644 index 000000000..650628634 --- /dev/null +++ b/tests/intel-ci/xe.bmg.dkms.blocklist.txt @@ -0,0 +1,5 @@ +########################################################################### +# Blocklisting Reload/Unload tests (DKMS, KV6.6) to unblock shard execution +########################################################################### +igt@xe_module_load@unload +igt@xe_module_load@(many-)?reload diff --git a/tests/intel/xe_test_config.json b/tests/intel/xe_test_config.json index 9c3b0828a..cfa9ac341 100644 --- a/tests/intel/xe_test_config.json +++ b/tests/intel/xe_test_config.json @@ -79,6 +79,8 @@ "include": [ { "LNL": "../intel-ci/xe.lnl.core.blocklist.txt" }, { "BMG": "../intel-ci/xe.bmg.core.blocklist.txt" }, + { "BMG-DKMS": "../intel-ci/xe.bmg.core.blocklist.txt" }, + { "BMG-DKMS": "../intel-ci/xe.bmg.dkms.blocklist.txt" }, { "PTL": "../intel-ci/xe.ptl.core.blocklist.txt" }, { "EUDEBUG-LNL": "../intel-ci/xe.lnl.eudebug.blocklist.txt" }, { "EUDEBUG-BMG": "../intel-ci/xe.bmg.eudebug.blocklist.txt" }, From b92b73c81a1b12f5aef3f78adf42125c1f109673 Mon Sep 17 00:00:00 2001 From: "Muppidi, Venkateswara Rao" Date: Tue, 24 Feb 2026 16:03:53 +0530 Subject: [PATCH 13/33] tests/intel-ci:Add tests to the blocklist that are expected to fail Add the tests to the blocklist that are expected to fail due to the absence of backport support in XKB-6.17. Tests: igt@xe_live_ktest@xe_dma_buf/xe_bo/xe_migrate igt@xe_pat@pat-index-all/pat-sanity igt@xe_configfs@gt-types-allowed igt@xe_configfs@ctx-restore* Signed-off-by: Muppidi, Venkateswara Rao --- tests/intel-ci/xe.blocklist.txt | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/intel-ci/xe.blocklist.txt b/tests/intel-ci/xe.blocklist.txt index b9c8586b7..19f8b744a 100644 --- a/tests/intel-ci/xe.blocklist.txt +++ b/tests/intel-ci/xe.blocklist.txt @@ -133,6 +133,32 @@ igt@xe_pmu@.*fn-engine-activity.* igt@xe_mmap@pci-membarrier.* # fault-injection tests igt@xe_fault_injection@* +################################################################### +#Everything below applies only to xekmd‑backports-6.17 &Xe DKMS KV6.6 +########################################################################## +#pat_sw_config debugfs not in xekmd-backport (new feature) +#Tests temporarily blocklisted for 6.17/Xe-DKMS KV6.6 +#TODO: Re-evaluate support when future kernel versions enable this feature. +############################################################################ +igt@xe_pat@(pat-index-all|pat-sanity) +############################################################################## +#gt_types_allowed sysfs not in xekmd-backport (new feature) +#Tests temporarily blocklisted for 6.17/Xe-DKMS KV6.6 +#TODO: Re-evaluate support when future kernel versions enable this feature. +############################################################################### +igt@xe_configfs@gt-types-allowed +####################################################################### +#ctx_restore_post_bb, ctx_restore_mid_bb sysfs not in xekmd-backport (new feature) +#Tests temporarily blocklisted for 6.17/Xe-DKMS KV6.6 +#TODO: Re-evaluate support when future kernel versions enable this feature. +###################################################################### +igt@xe_configfs@ctx-restore-(mid|post)-bb(-invalid)? +##################################################################### +#xekmd-backport/Xe DKMS KV6.6 is intended for production kernels. +#It does not support debug tests. Consequently, all klive tests have been +#blocklisted for kernel 6.17 & Xe DKMS 6.6. +#################################################################### +igt@xe_live_ktest@.* ################################################################## ################################################################## # Async flips with linear modifier are slower From 76e7ca5f62acb51fee8e4c4dc90adfd828511ddc Mon Sep 17 00:00:00 2001 From: Pravalika Gurram Date: Fri, 10 Apr 2026 12:20:22 +0530 Subject: [PATCH 14/33] drm-uapi: Align uapi headers with v6.17 Xekmd-backport Update 6.17 drm-uapi headers to align with latest v6.17 kernel, including prelim eudebug macro updates for debug interface support. Updated eudebug macros for v6.17 compatibility Signed-off-by: Pravalika Gurram --- include/drm-uapi/xe_drm_prelim.h | 32 ++++++++++++++++++++++++-------- 1 file changed, 24 insertions(+), 8 deletions(-) diff --git a/include/drm-uapi/xe_drm_prelim.h b/include/drm-uapi/xe_drm_prelim.h index dbe880b00..3c104cef5 100644 --- a/include/drm-uapi/xe_drm_prelim.h +++ b/include/drm-uapi/xe_drm_prelim.h @@ -65,6 +65,24 @@ * - PRELIM ioctl's: IOCTL numbers go down from 0x5f */ +/* + * Default marker for PRELIM values in shared flags/extensions + */ +#define PRELIM_DRM_XE_VALUE_INDICATOR (1 << 16) + +/* + * Default mask for PRELIM values created by PRELIM_DRM_XE_VALUE_INDICATOR. + * The PRELIM value shall be created by: + * PRELIM_DRM_XE_VALUE_INDICATOR | value + * and 'value' shall be smaller than MASK value. + */ +#define PRELIM_DRM_XE_VALUE_MASK 0xffff + +/* + * Value of the PRELIM flag/extension without PRELIM INDICATOR + */ +#define PRELIM_DRM_XE_VALUE(val) ((val) & PRELIM_DRM_XE_VALUE_MASK) + /* * IOCTL numbers listed below are reserved, they are taken up by other * components. Please add an unreserved ioctl number here to reserve that @@ -75,9 +93,9 @@ * Copyright © 2023 Intel Corporation */ -#define PRELIM_DRM_XE_EUDEBUG_CONNECT 0x5f -#define PRELIM_DRM_XE_DEBUG_METADATA_CREATE 0x5e -#define PRELIM_DRM_XE_DEBUG_METADATA_DESTROY 0x5d +#define PRELIM_DRM_XE_EUDEBUG_CONNECT 0x59 +#define PRELIM_DRM_XE_DEBUG_METADATA_CREATE 0x5b +#define PRELIM_DRM_XE_DEBUG_METADATA_DESTROY 0x5c #define PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_EUDEBUG_CONNECT, struct prelim_drm_xe_eudebug_connect) #define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_CREATE, struct prelim_drm_xe_debug_metadata_create) @@ -100,9 +118,9 @@ struct prelim_drm_xe_vm_bind_op_ext_attach_debug { __u64 reserved; }; -#define PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0 +#define PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG (PRELIM_DRM_XE_VALUE_INDICATOR) -#define PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG 2 +#define PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG (PRELIM_DRM_XE_VALUE_INDICATOR) #define PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE (1 << 0) /* @@ -170,8 +188,6 @@ struct prelim_drm_xe_debug_metadata_destroy { __u32 metadata_id; }; -#include "xe_drm_prelim.h" - /** * Do a eudebug event read for a debugger connection. * @@ -369,7 +385,7 @@ struct prelim_drm_xe_eudebug_vm_open { /** @flags: flags */ __u64 flags; -#define DRM_XE_EUDEBUG_VM_SYNC_MAX_TIMEOUT_NSECS (10ULL * NSEC_PER_SEC) +#define PRELIM_DRM_XE_EUDEBUG_VM_SYNC_MAX_TIMEOUT_NSECS (10ULL * NSEC_PER_SEC) /** @timeout_ns: Timeout value in nanoseconds operations (fsync) */ __u64 timeout_ns; }; From 0aefb6795647775ebd10059d3d23089e92461cf5 Mon Sep 17 00:00:00 2001 From: Pravalika Gurram Date: Fri, 10 Apr 2026 12:30:33 +0530 Subject: [PATCH 15/33] drm-uapi: Update prelim uapi with xe3p_lpg support Update preliminary uapi headers with xe3p_lpg platform support and eudebug interface enhancements. - Added xe3p_lpg platform definitions and feature flags - Updated eudebug macros for Xe3p-lpg compatibility - Also allign xe_drm.h - Add DRM_IOCTL_XE_EXEC_QUEUE_SET_PROPERTY in documentation Signed-off-by: Pravalika Gurram --- include/drm-uapi/xe_drm_prelim.h | 89 +++++++++++++++++--------------- 1 file changed, 47 insertions(+), 42 deletions(-) diff --git a/include/drm-uapi/xe_drm_prelim.h b/include/drm-uapi/xe_drm_prelim.h index 3c104cef5..928888d55 100644 --- a/include/drm-uapi/xe_drm_prelim.h +++ b/include/drm-uapi/xe_drm_prelim.h @@ -88,18 +88,16 @@ * components. Please add an unreserved ioctl number here to reserve that * number. */ -/* SPDX-License-Identifier: MIT */ -/* - * Copyright © 2023 Intel Corporation - */ - -#define PRELIM_DRM_XE_EUDEBUG_CONNECT 0x59 -#define PRELIM_DRM_XE_DEBUG_METADATA_CREATE 0x5b -#define PRELIM_DRM_XE_DEBUG_METADATA_DESTROY 0x5c +#define PRELIM_DRM_XE_DEBUG_METADATA_DESTROY 0x5c +#define PRELIM_DRM_XE_DEBUG_METADATA_CREATE 0x5b +#define PRELIM_DRM_XE_EUDEBUG_CONNECT 0x59 -#define PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_EUDEBUG_CONNECT, struct prelim_drm_xe_eudebug_connect) -#define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_CREATE, struct prelim_drm_xe_debug_metadata_create) -#define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY DRM_IOW(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_DESTROY, struct prelim_drm_xe_debug_metadata_destroy) +#define PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT \ + DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_EUDEBUG_CONNECT, struct prelim_drm_xe_eudebug_connect) +#define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE \ + DRM_IOWR(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_CREATE, struct prelim_drm_xe_debug_metadata_create) +#define PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY \ + DRM_IOW(DRM_COMMAND_BASE + PRELIM_DRM_XE_DEBUG_METADATA_DESTROY, struct prelim_drm_xe_debug_metadata_destroy) struct prelim_drm_xe_vm_bind_op_ext_attach_debug { /** @base: base user extension */ @@ -118,10 +116,11 @@ struct prelim_drm_xe_vm_bind_op_ext_attach_debug { __u64 reserved; }; -#define PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG (PRELIM_DRM_XE_VALUE_INDICATOR) +#define PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG (PRELIM_DRM_XE_VALUE_INDICATOR) #define PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG (PRELIM_DRM_XE_VALUE_INDICATOR) #define PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE (1 << 0) +#define PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_PAGEFAULT_ENABLE (1 << 1) /* * Debugger ABI (ioctl and events) Version History: @@ -204,19 +203,19 @@ struct prelim_drm_xe_eudebug_event { __u32 len; __u16 type; -#define PRELIM_DRM_XE_EUDEBUG_EVENT_NONE 0 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_READ 1 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN 2 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM 3 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND 6 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA 9 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT 11 -#define PRELIM_DRM_XE_EUDEBUG_EVENT_SYNC_HOST 12 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_NONE 0 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_READ 1 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN 2 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM 3 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND 6 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA 9 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT 11 +#define PRELIM_DRM_XE_EUDEBUG_EVENT_SYNC_HOST 12 #define PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS 13 __u16 flags; @@ -253,22 +252,6 @@ struct prelim_drm_xe_eudebug_event_exec_queue { __u64 lrc_handle[]; }; -struct prelim_drm_xe_eudebug_event_exec_queue_placements { - struct prelim_drm_xe_eudebug_event base; - - __u64 client_handle; - __u64 vm_handle; - __u64 exec_queue_handle; - __u64 lrc_handle; - __u32 num_placements; - __u32 pad; - /** - * @instances: user pointer to num_placements sized array of struct - * drm_xe_engine_class_instance - */ - __u64 instances[]; -}; - struct prelim_drm_xe_eudebug_event_eu_attention { struct prelim_drm_xe_eudebug_event base; @@ -286,7 +269,7 @@ struct prelim_drm_xe_eudebug_eu_control { #define PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL 0 #define PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED 1 #define PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME 2 - +#define PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_UNLOCK 3 __u32 cmd; __u32 flags; @@ -429,4 +412,26 @@ struct prelim_drm_xe_eudebug_event_pagefault { __u8 bitmask[]; }; +struct prelim_drm_xe_eudebug_event_sync_host { + struct prelim_drm_xe_eudebug_event base; + __u64 client_handle; + __u64 exec_queue_handle; + __u64 lrc_handle; +}; + +struct prelim_drm_xe_eudebug_event_exec_queue_placements { + struct prelim_drm_xe_eudebug_event base; + __u64 client_handle; + __u64 vm_handle; + __u64 exec_queue_handle; + __u64 lrc_handle; + __u32 num_placements; + __u32 pad; + /** + * @instances: user pointer to num_placements sized array of struct + * drm_xe_engine_class_instance + */ + __u64 instances[]; +}; + #endif /* _XE_DRM_PRELIM_H_ */ From f320e9ea9d65fdf6a241d829650b77fe4709603f Mon Sep 17 00:00:00 2001 From: Bommu Krishnaiah Date: Thu, 12 Mar 2026 19:41:53 +0530 Subject: [PATCH 16/33] tests/xe_eudebug: Fix vm-bind-clear-faultable false failure In faultable VM mode (DRM_XE_VM_CREATE_FLAG_FAULT_MODE), GPU memory accesses go through page fault handling. When the GPU writes the user fence timeline value back to fence_data via a page fault, the kernel implicitly creates a page table binding for that system memory page, generating an additional VM_BIND_OP event. The old vm_bind_clear_test_trigger fired on ALL VM_BIND_OP CREATE events and performed a zero-content check (v == 0) on the bound address. When triggered on the implicit fault-driven bind of the fence_data page, it found the previously written timeline value (e.g. 0x2) instead of zero, causing a spurious assertion failure: CRITICAL: Failed assertion: v == 0 CRITICAL: error: 0x2 != 0 Fix this by tagging only the clean_bo vm_bind with a metadata cookie (VM_BIND_CLEAR_CLEAN_COOKIE) via prelim_drm_xe_vm_bind_op_ext_attach_debug. Move the zero-content check into vm_bind_clear_ack_trigger, which operates on VM_BIND_UFENCE events, and gate the check behind vm_bind_clear_is_tagged_clean_bind(). Binds without the cookie (batch_bo, implicit fault binds, etc.) are acked immediately without the memory content check. Ensure proper initialization of helper variables to avoid compiler warnings. Fixes: igt@xe_eudebug@vm-bind-clear-faultable Signed-off-by: Krishnaiah Bommu --- tests/intel/xe_eudebug.c | 119 +++++++++++++++++++++++++++++++++------ 1 file changed, 103 insertions(+), 16 deletions(-) diff --git a/tests/intel/xe_eudebug.c b/tests/intel/xe_eudebug.c index 51f4dcb8d..49248fd0d 100644 --- a/tests/intel/xe_eudebug.c +++ b/tests/intel/xe_eudebug.c @@ -2224,6 +2224,8 @@ struct vm_bind_clear_priv { unsigned long sum; }; +#define VM_BIND_CLEAR_CLEAN_COOKIE 0x434c45414eULL + static struct vm_bind_clear_priv *vm_bind_clear_priv_create(void) { struct vm_bind_clear_priv *priv; @@ -2245,21 +2247,38 @@ static void *vm_bind_clear_thread(void *data) { const uint32_t CS_GPR0 = 0x600; const size_t batch_size = 16; + const uint32_t metadata_type = 0; struct drm_xe_sync uf_sync = { .type = DRM_XE_SYNC_TYPE_USER_FENCE, .flags = DRM_XE_SYNC_FLAG_SIGNAL, }; + struct prelim_drm_xe_vm_bind_op_ext_attach_debug clean_ext = { + .base.name = PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG, + .cookie = VM_BIND_CLEAR_CLEAN_COOKIE, + }; 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_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE; size_t bo_size = xe_bb_size(fd, batch_size); unsigned long count = 0; + uint8_t *metadata_data; + uint32_t metadata_id; uint64_t *fence_data; uint32_t vm; vm_flags |= (priv->c->flags & TEST_FAULTABLE) ? DRM_XE_VM_CREATE_FLAG_FAULT_MODE : 0; vm = xe_eudebug_client_vm_create(priv->c, fd, vm_flags, 0); + metadata_data = aligned_alloc(PAGE_SIZE, PAGE_SIZE); + igt_assert(metadata_data); + memset(metadata_data, 0, PAGE_SIZE); + + metadata_id = xe_eudebug_client_metadata_create(priv->c, fd, + metadata_type, + PAGE_SIZE, + metadata_data); + clean_ext.metadata_id = metadata_id; + /* init uf_sync */ fence_data = aligned_alloc(xe_get_default_alignment(fd), sizeof(*fence_data)); igt_assert(fence_data); @@ -2305,7 +2324,8 @@ static void *vm_bind_clear_thread(void *data) 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); + 0, &uf_sync, 1, + to_user_pointer(&clean_ext)); xe_wait_ufence(fd, fence_data, uf_sync.timeline_value, 0, XE_EUDEBUG_DEFAULT_TIMEOUT_SEC * NSEC_PER_SEC); @@ -2363,6 +2383,9 @@ static void *vm_bind_clear_thread(void *data) priv->sum = count; free(fence_data); + xe_eudebug_client_metadata_destroy(priv->c, fd, metadata_id, + metadata_type, PAGE_SIZE); + free(metadata_data); xe_eudebug_client_close_driver(priv->c, fd); return NULL; } @@ -2414,25 +2437,98 @@ static void vm_bind_clear_client(struct xe_eudebug_client *c) xe_eudebug_client_close_driver(c, fd); } +static struct prelim_drm_xe_eudebug_event_vm_bind_op * +vm_bind_clear_find_op_event_by_ref(struct xe_eudebug_event_log *log, uint64_t bind_ref_seqno) +{ + struct prelim_drm_xe_eudebug_event *e = NULL; + + xe_eudebug_for_each_event(e, log) { + struct prelim_drm_xe_eudebug_event_vm_bind_op *eo; + + if (e->type != PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP) + continue; + + if (!(e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE)) + continue; + + eo = (void *)e; + if (eo->vm_bind_ref_seqno == bind_ref_seqno) + return eo; + } + + return NULL; +} + +static bool vm_bind_clear_is_tagged_clean_bind(struct xe_eudebug_event_log *log, + uint64_t bind_ref_seqno) +{ + struct prelim_drm_xe_eudebug_event *e = NULL; + + xe_eudebug_for_each_event(e, log) { + struct prelim_drm_xe_eudebug_event_vm_bind_op_metadata *em; + struct prelim_drm_xe_eudebug_event_vm_bind_op *eo; + + if (e->type != PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA) + continue; + + if (!(e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE)) + continue; + + em = (void *)e; + if (em->metadata_cookie != VM_BIND_CLEAR_CLEAN_COOKIE) + continue; + + eo = (struct prelim_drm_xe_eudebug_event_vm_bind_op *) + xe_eudebug_event_log_find_seqno(log, em->vm_bind_op_ref_seqno); + if (!eo) + continue; + + if (eo->vm_bind_ref_seqno == bind_ref_seqno) + return true; + } + + return false; +} + static void vm_bind_clear_test_trigger(struct xe_eudebug_debugger *d, struct prelim_drm_xe_eudebug_event *e) { struct prelim_drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; struct vm_bind_clear_priv *priv = d->ptr; + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { + 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); + priv->bind_count++; + } + + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY) + priv->unbind_count++; +} + +static void vm_bind_clear_ack_trigger(struct xe_eudebug_debugger *d, + struct prelim_drm_xe_eudebug_event *e) +{ + struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE) { if (random() & 1) { struct prelim_drm_xe_eudebug_vm_open vo = { 0, }; - uint32_t v = 0xc1c1c1c1; - + struct prelim_drm_xe_eudebug_event_vm_bind_op *eo; struct prelim_drm_xe_eudebug_event_vm_bind *eb; + uint32_t v = 0xc1c1c1c1; 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); + eo = vm_bind_clear_find_op_event_by_ref(d->log, + ef->vm_bind_ref_seqno); + igt_assert(eo); + + if (!vm_bind_clear_is_tagged_clean_bind(d->log, + ef->vm_bind_ref_seqno)) + goto ack_ufence; eb = (struct prelim_drm_xe_eudebug_event_vm_bind *) - xe_eudebug_event_log_find_seqno(d->log, eo->vm_bind_ref_seqno); + xe_eudebug_event_log_find_seqno(d->log, ef->vm_bind_ref_seqno); igt_assert(eb); vo.client_handle = eb->client_handle; @@ -2448,18 +2544,9 @@ static void vm_bind_clear_test_trigger(struct xe_eudebug_debugger *d, close(fd); } - priv->bind_count++; } - if (e->flags & PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY) - priv->unbind_count++; -} - -static void vm_bind_clear_ack_trigger(struct xe_eudebug_debugger *d, - struct prelim_drm_xe_eudebug_event *e) -{ - struct prelim_drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; - +ack_ufence: xe_eudebug_ack_ufence(d->fd, ef); } From cda572ff6cde83db5953b2e33c041321afd1235e Mon Sep 17 00:00:00 2001 From: Srinivasula Reddy Pondugula Date: Wed, 15 Apr 2026 07:28:31 +0000 Subject: [PATCH 17/33] tests/intel-ci: Update DKMS blocklist to include reload-no-display Signed-off-by: Srinivasula Reddy Pondugula --- tests/intel-ci/xe.bmg.dkms.blocklist.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/intel-ci/xe.bmg.dkms.blocklist.txt b/tests/intel-ci/xe.bmg.dkms.blocklist.txt index 650628634..fa56763e0 100644 --- a/tests/intel-ci/xe.bmg.dkms.blocklist.txt +++ b/tests/intel-ci/xe.bmg.dkms.blocklist.txt @@ -2,4 +2,4 @@ # Blocklisting Reload/Unload tests (DKMS, KV6.6) to unblock shard execution ########################################################################### igt@xe_module_load@unload -igt@xe_module_load@(many-)?reload +igt@xe_module_load@(reload(-no-display)?|many-reload)$ From affbe4bf492e607f77ea0e2e1bf63f0ae689af73 Mon Sep 17 00:00:00 2001 From: Srinivasula Reddy Pondugula Date: Tue, 12 May 2026 17:42:14 +0000 Subject: [PATCH 18/33] tests/intel-ci: Add expected VF skips to sriov-vm blocklist Signed-off-by: Srinivasula Reddy Pondugula --- tests/intel-ci/xe.sriov-vf.blocklist.txt | 14 ++++++++++++-- tests/intel-ci/xe.sriov-vm.blocklist.txt | 14 ++++++++++++-- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/tests/intel-ci/xe.sriov-vf.blocklist.txt b/tests/intel-ci/xe.sriov-vf.blocklist.txt index 4a19aa943..fab92c523 100644 --- a/tests/intel-ci/xe.sriov-vf.blocklist.txt +++ b/tests/intel-ci/xe.sriov-vf.blocklist.txt @@ -10,7 +10,8 @@ igt@xe_module_load@.* # igt@sriov_basic.* igt@xe_eudebug_sriov.* -igt@xe_pmu@.*fn-engine-activity.* +igt@xe_pmu@.*engine-activity-.* +igt@xe_pmu@gt-c6-idle igt@xe_sriov.* # # display related tests @@ -58,6 +59,15 @@ igt@xe_pmu@gt-frequency # igt@xe_query@.*cs-cycles # +# survivability mode is not supported in VF. +# +igt@xe_configfs@survivability-mode +igt@xe_survivability@.* +# +# HWMON is not supported inside VF. +# +igt@intel_hwmon@hwmon-(read|write) +# # Tests that need to be executed in VM instead. # -igt@xe_live_ktest.* \ No newline at end of file +igt@xe_live_ktest.* diff --git a/tests/intel-ci/xe.sriov-vm.blocklist.txt b/tests/intel-ci/xe.sriov-vm.blocklist.txt index 6271b1a70..8407411dc 100644 --- a/tests/intel-ci/xe.sriov-vm.blocklist.txt +++ b/tests/intel-ci/xe.sriov-vm.blocklist.txt @@ -11,7 +11,8 @@ igt@xe_ccs@suspend-resume # igt@sriov_basic.* igt@xe_eudebug_sriov.* -igt@xe_pmu@.*fn-engine-activity.* +igt@xe_pmu@.*engine-activity-.* +igt@xe_pmu@gt-c6-idle igt@xe_sriov.* # # display related tests @@ -57,4 +58,13 @@ igt@xe_pmu@gt-frequency # # The feature query_cs_cycles is not supported on VF # -igt@xe_query@.*cs-cycles \ No newline at end of file +igt@xe_query@.*cs-cycles +# +# survivability mode is not supported in VF. +# +igt@xe_configfs@survivability-mode +igt@xe_survivability@.* +# +# HWMON is not supported inside VF. +# +igt@intel_hwmon@hwmon-(read|write) From e25f0f2c5e788ee1f32a984a73526ab3542c9113 Mon Sep 17 00:00:00 2001 From: Bommu Krishnaiah Date: Mon, 4 May 2026 11:29:56 +0530 Subject: [PATCH 19/33] fixup! tests/intel/xe_eudebug_sriov: Add new test for eudebug/SR-IOV exclusion The kernel returns -EBUSY (not -EPERM) when eudebug lockdown is attempted while VFs are already enabled, as xe_sriov_pf_lockdown() uses a guard that returns -EBUSY in that case. Update the expected return value and add a comment explaining the relationship to xe_sriov_pf_lockdown(). Signed-off-by: Bommu Krishnaiah --- tests/intel/xe_eudebug_sriov.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/intel/xe_eudebug_sriov.c b/tests/intel/xe_eudebug_sriov.c index 3833eb899..8173349dd 100644 --- a/tests/intel/xe_eudebug_sriov.c +++ b/tests/intel/xe_eudebug_sriov.c @@ -71,7 +71,12 @@ static void test_deny_eudebug(int fd) sysfs = igt_sysfs_open(fd); igt_assert_fd(sysfs); - igt_assert_eq(igt_sysfs_printf(sysfs, "device/prelim_enable_eudebug", "1"), -EPERM); + /* + * Enabling eudebug while VFs are already active must fail with -EBUSY, + * as the kernel lockdown guard rejects the request when VF enabling + * is in progress or VFs are enabled (xe_sriov_pf_lockdown()). + */ + igt_assert_eq(igt_sysfs_printf(sysfs, "device/prelim_enable_eudebug", "1"), -EBUSY); close(sysfs); } From 6d497a23fe9cb4510c8d6d33ce8727723ed0a6ca Mon Sep 17 00:00:00 2001 From: "Muppidi, Venkateswara Rao" Date: Mon, 25 May 2026 15:30:38 +0530 Subject: [PATCH 20/33] tests/intel-ci: Unblock SVM, add them to specific KV6.17 blocklist and remove duplicate entries Signed-off-by: Muppidi, Venkateswara Rao --- tests/intel-ci/xe.blocklist.txt | 1 - tests/intel-ci/xe.ptl.core.blocklist.txt | 1 - 2 files changed, 2 deletions(-) diff --git a/tests/intel-ci/xe.blocklist.txt b/tests/intel-ci/xe.blocklist.txt index 19f8b744a..cc9db44be 100644 --- a/tests/intel-ci/xe.blocklist.txt +++ b/tests/intel-ci/xe.blocklist.txt @@ -128,7 +128,6 @@ igt@xe_exec_compute_mode@non-blocking # Tests are expected to be skipped because the required kernel # changes are not present ################################################################## -igt@xe_exec_system_allocator@.* igt@xe_pmu@.*fn-engine-activity.* igt@xe_mmap@pci-membarrier.* # fault-injection tests diff --git a/tests/intel-ci/xe.ptl.core.blocklist.txt b/tests/intel-ci/xe.ptl.core.blocklist.txt index 8752e92cd..4364af58b 100644 --- a/tests/intel-ci/xe.ptl.core.blocklist.txt +++ b/tests/intel-ci/xe.ptl.core.blocklist.txt @@ -51,7 +51,6 @@ igt@xe_pm@d3hot-i2c # Expected skip for the platform as the tests need more than # one CCS engine ################################################################## -igt@xe_compute@ccs-mode-basic igt@xe_compute@ccs-mode-compute-kernel ################################################################# # Tests not applicable for the platform From a1d0ef925185beb3afc22ff4a15c7aa2994c6f9b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dominik=20Karol=20Pi=C4=85tkowski?= Date: Mon, 6 Jul 2026 14:56:05 +0200 Subject: [PATCH 21/33] tests/intel-ci: Adjust EUdebug tests in xe.fast-feedback.testlist Adjust xe.fast-feedback.testlist regarding EUdebug tests to have proper coverage of basic features. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Dominik Karol Piątkowski --- tests/intel-ci/xe.fast-feedback.testlist | 46 +----------------------- 1 file changed, 1 insertion(+), 45 deletions(-) diff --git a/tests/intel-ci/xe.fast-feedback.testlist b/tests/intel-ci/xe.fast-feedback.testlist index 06e6d2f3d..60265cc3d 100644 --- a/tests/intel-ci/xe.fast-feedback.testlist +++ b/tests/intel-ci/xe.fast-feedback.testlist @@ -310,64 +310,20 @@ igt@xe_evict@evict-small-external-cm igt@xe_evict@evict-small-multi-vm # EU debugger tests -igt@xe_eudebug@attach-debug-metadata -igt@xe_eudebug@basic-client -igt@xe_eudebug@basic-client-th -igt@xe_eudebug@basic-close igt@xe_eudebug@basic-connect -igt@xe_eudebug@basic-exec-queues -igt@xe_eudebug@basic-exec-queues-enable igt@xe_eudebug@basic-read-event -igt@xe_eudebug@basic-vm-access -igt@xe_eudebug@basic-vm-access-parameters -igt@xe_eudebug@basic-vm-access-userptr -igt@xe_eudebug@basic-vm-bind -igt@xe_eudebug@basic-vm-bind-discovery -igt@xe_eudebug@basic-vm-bind-extended -igt@xe_eudebug@basic-vm-bind-extended-discovery -igt@xe_eudebug@basic-vm-bind-metadata-discovery -igt@xe_eudebug@basic-vm-bind-ufence -igt@xe_eudebug@basic-vm-bind-vm-destroy -igt@xe_eudebug@basic-vm-bind-vm-destroy-discovery -igt@xe_eudebug@basic-vms -igt@xe_eudebug@connect-user -igt@xe_eudebug@discovery-empty -igt@xe_eudebug@discovery-empty-clients -igt@xe_eudebug@multiple-sessions -igt@xe_eudebug@read-metadata -igt@xe_eudebug@sysfs-toggle -igt@xe_eudebug@vma-ufence igt@xe_eudebug_online@basic-breakpoint -igt@xe_eudebug_online@breakpoint-not-in-debug-mode -igt@xe_eudebug_online@debugger-reopen igt@xe_eudebug_online@interrupt-all igt@xe_eudebug_online@interrupt-all-set-breakpoint -igt@xe_eudebug_online@interrupt-reconnect -igt@xe_eudebug_online@pagefault-read -igt@xe_eudebug_online@pagefault-write -igt@xe_eudebug_online@preempt-breakpoint -igt@xe_eudebug_online@reset-with-attention +igt@xe_eudebug_online@interrupt-all-set-breakpoint-faultable igt@xe_eudebug_online@resume-dss igt@xe_eudebug_online@resume-one -igt@xe_eudebug_online@set-breakpoint igt@xe_eudebug_online@single-step igt@xe_eudebug_online@single-step-one -igt@xe_eudebug_online@stopped-thread -igt@xe_eudebug_online@tdctl-parameters -igt@xe_eudebug_online@writes-caching-sram-bb-sram-target-vram -igt@xe_eudebug_online@writes-caching-sram-bb-vram-target-sram -igt@xe_eudebug_online@writes-caching-vram-bb-sram-target-sram -igt@xe_eudebug_online@writes-caching-vram-bb-sram-target-vram -igt@xe_eudebug_online@writes-caching-vram-bb-vram-target-sram igt@xe_exec_sip@invalidinstr-disabled igt@xe_exec_sip@invalidinstr-thread-enabled igt@xe_exec_sip@invalidinstr-walker-enabled -igt@xe_exec_sip@sanity -igt@xe_exec_sip@sanity-after-timeout -igt@xe_exec_sip_eudebug@breakpoint-waitsip igt@xe_exec_sip_eudebug@breakpoint-writesip -igt@xe_exec_sip_eudebug@breakpoint-writesip-nodebug -igt@xe_exec_sip_eudebug@breakpoint-writesip-twice igt@xe_exec_sip_eudebug@wait-writesip-nodebug # Run KUnit tests at the end From 7cc813c2704c31ca0580cd4c499c085c2b05b12c Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Muppidi Date: Fri, 24 Jul 2026 15:58:08 +0530 Subject: [PATCH 22/33] tests/intel-ci: Unblock exhaustive eviction tests from xe.bmg.core.blocklist Unblock exhaustive eviction tests from xe.bmg.core.blocklist.txt for backport/main Signed-off-by: Venkateswara Rao Muppidi --- tests/intel-ci/xe.bmg.core.blocklist.txt | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/tests/intel-ci/xe.bmg.core.blocklist.txt b/tests/intel-ci/xe.bmg.core.blocklist.txt index 50e241ef1..a79068b0d 100644 --- a/tests/intel-ci/xe.bmg.core.blocklist.txt +++ b/tests/intel-ci/xe.bmg.core.blocklist.txt @@ -52,16 +52,6 @@ igt@xe_eudebug_sriov@deny-eudebug igt@xe_oa@oa-tlb-invalidate igt@xe_oa@unprivileged-single-ctx-counters ################################################################## -# Temporarily blocking the tests until we have -# support for exhaustive eviction -################################################################## -igt@xe_evict@evict-(beng-)?cm-threads-large$ -igt@xe_evict@evict-(beng-)?mixed-many-threads-large$ -igt@xe_evict@evict-(beng-)?mixed-many-threads-small$ -igt@xe_evict@evict-(beng-)?mixed-threads-large$ -igt@xe_evict@evict-(beng-)?threads-large$ -igt@xe_evict@evict-(beng-)?large-multi-vm-cm$ -################################################################## # pxp support not available for BMG ################################################################## igt@xe_pxp@(?!pxp-bo-alloc$|pxp-queue-alloc$).* From 48cda9b32059e3e9f1de1ab854d5c7e29e57ac03 Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Muppidi Date: Fri, 24 Jul 2026 17:50:26 +0530 Subject: [PATCH 23/33] tests/intel-ci: Unblock multigpu-basic-client tests from xe.multigpu.blocklist unblock xe_eudebug@multigpu-basic-client* tests from xe.multigpu.blocklist.txt Signed-off-by: Venkateswara Rao Muppidi --- tests/intel-ci/xe.multigpu.blocklist.txt | 4 ---- 1 file changed, 4 deletions(-) diff --git a/tests/intel-ci/xe.multigpu.blocklist.txt b/tests/intel-ci/xe.multigpu.blocklist.txt index 5affcc8fa..8e849e1dc 100644 --- a/tests/intel-ci/xe.multigpu.blocklist.txt +++ b/tests/intel-ci/xe.multigpu.blocklist.txt @@ -2,7 +2,3 @@ # Blocklist for Xe MuitiGPU tests ##################################################### igt@(?!.*xe.*multigpu.*|xe_peer2peer.*).* -##################################################### -# Kernel support not available -##################################################### -igt@xe_eudebug@multigpu-basic-client* From dfa5e2949d604d100e31dcc9f8abecac81ae8d10 Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Muppidi Date: Wed, 29 Jul 2026 12:27:08 +0530 Subject: [PATCH 24/33] tests/intel-ci: Add page reclaim, prefetch fault tests to BMG Core blocklist Add the following tests to the xe.bmg.core blocklist - page reclaim - non-msix - gpgpu with offset-4X4 - prefetch fault - xa-app-transient-media - xe_eudebug_online@breakpoint-many-sessions-tiles - xe_compute@eu-busy-10s - xe_pat@l2-flush-opt-svm-pat-restrict Signed-off-by: Venkateswara Rao Muppidi --- tests/intel-ci/xe.bmg.core.blocklist.txt | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/tests/intel-ci/xe.bmg.core.blocklist.txt b/tests/intel-ci/xe.bmg.core.blocklist.txt index a79068b0d..2930ca203 100644 --- a/tests/intel-ci/xe.bmg.core.blocklist.txt +++ b/tests/intel-ci/xe.bmg.core.blocklist.txt @@ -17,6 +17,7 @@ igt@xe_media_fill@media-fill # Expected skip on xe1 & xe2 Platforms ################################################################## igt@xe_pat@pat-index-xe3p-xpc +igt@xe_gpgpu_fill@offset-4x4 ################################################################## # Expected skip - small bar not supported ################################################################## @@ -30,6 +31,7 @@ igt@xe_pm@.*d3cold.* # which have more than 1 COMPUTE ENGINE instance per tile. ################################################################## igt@xe_compute@ccs-mode-basic +igt@xe_compute@eu-busy-10s ################################################################## # Expected skip as tests not applicable for the platform ################################################################## @@ -61,3 +63,18 @@ igt@xe_fault_injection@exec-queue-create-fail-xe_pxp_exec_queue_add ################################################################## igt@xe_pm@d3hot-i2c ################################################################## +# Expected skip as tests not applicable for BMG +################################################################## +igt@xe_non_msix@walker-interrupt-notification-non-msix +igt@xe_pat@xa-app-transient-media-(?:on|off) +igt@xe_prefetch_fault@prefetch-fault(?:-svm)? +igt@xe_pat@l2-flush-opt-svm-pat-restrict +##################################################################### +#page reclaim/page reclaim hw assist support is not available for BMG +##################################################################### +igt@xe_page_reclaim@.* +#################################################################### +#many Tiles are not present in BMG +#################################################################### +igt@xe_eudebug_online@breakpoint-many-sessions-tiles +#################################################################### From 475875d5ee3054433967faee6241f12a3655a07b Mon Sep 17 00:00:00 2001 From: Aditya Chauhan Date: Thu, 30 Jul 2026 11:46:11 +0530 Subject: [PATCH 25/33] tests/intel-ci: Add blocklist for xe dkms kv5.15 Add Blocklist for xe dkms kv5.15 and add it to meson.build Signed-off-by: Aditya Chauhan --- tests/intel-ci/meson.build | 1 + tests/intel-ci/xe.dkms_kv5.15.blocklist.txt | 13 +++++++++++++ 2 files changed, 14 insertions(+) create mode 100644 tests/intel-ci/xe.dkms_kv5.15.blocklist.txt diff --git a/tests/intel-ci/meson.build b/tests/intel-ci/meson.build index 78d0739b9..c85cf62ae 100644 --- a/tests/intel-ci/meson.build +++ b/tests/intel-ci/meson.build @@ -15,6 +15,7 @@ intelci_files = [ 'xe.bmg.display.blocklist.txt', 'xe.bmg.dkms.blocklist.txt', 'xe.bmg.eudebug.blocklist.txt', + 'xe.dkms_kv5.15.blocklist.txt', 'xe.eudebug.blocklist.txt', 'xe.fast-feedback.testlist', 'xe-fast-feedback.testlist', diff --git a/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt b/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt new file mode 100644 index 000000000..ce88f8879 --- /dev/null +++ b/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt @@ -0,0 +1,13 @@ +##################################################### +# Blocklist for XE dkms kv5.15 +##################################################### +# No SVM support in KV5.15 DKMS +##################################################### +igt@xe_exec_system_allocator@.* +igt@.*svm.* +##################################################### +# No dma-buf support in KV5.15 DKMS +##################################################### +igt@xe_dma_buf_sync@.* +igt@xe_live_ktest@xe_dma_buf +##################################################### From ae481c3f52ca01214ebe795311e222126757ef00 Mon Sep 17 00:00:00 2001 From: Aditya Chauhan Date: Thu, 30 Jul 2026 17:54:31 +0530 Subject: [PATCH 26/33] tests/intel/xe_test_config: Add entries for BMG-DKMS_KV5.15 Add entries to xe_test_config.json file to ensure that blocklists are applied while generating testlists. Signed-off-by: Aditya Chauhan --- tests/intel/xe_test_config.json | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/intel/xe_test_config.json b/tests/intel/xe_test_config.json index cfa9ac341..dea8824f9 100644 --- a/tests/intel/xe_test_config.json +++ b/tests/intel/xe_test_config.json @@ -81,6 +81,9 @@ { "BMG": "../intel-ci/xe.bmg.core.blocklist.txt" }, { "BMG-DKMS": "../intel-ci/xe.bmg.core.blocklist.txt" }, { "BMG-DKMS": "../intel-ci/xe.bmg.dkms.blocklist.txt" }, + { "BMG-DKMS_KV5.15": "../intel-ci/xe.dkms_kv5.15.blocklist.txt" }, + { "BMG-DKMS_KV5.15": "../intel-ci/xe.bmg.core.blocklist.txt" }, + { "BMG-DKMS_KV5.15": "../intel-ci/xe.bmg.dkms.blocklist.txt" }, { "PTL": "../intel-ci/xe.ptl.core.blocklist.txt" }, { "EUDEBUG-LNL": "../intel-ci/xe.lnl.eudebug.blocklist.txt" }, { "EUDEBUG-BMG": "../intel-ci/xe.bmg.eudebug.blocklist.txt" }, From 850ddade338dc9280de94260b11ae2a20c3b6b55 Mon Sep 17 00:00:00 2001 From: Aditya Chauhan Date: Fri, 31 Jul 2026 13:23:16 +0530 Subject: [PATCH 27/33] tests/intel-ci: Update kv5.15 and bmg Core blocklists Update dkms kv5.15 and bmg core blocklist files Signed-off-by: Aditya Chauhan --- tests/intel-ci/xe.bmg.core.blocklist.txt | 13 +++++++++++++ tests/intel-ci/xe.dkms_kv5.15.blocklist.txt | 5 +++++ 2 files changed, 18 insertions(+) diff --git a/tests/intel-ci/xe.bmg.core.blocklist.txt b/tests/intel-ci/xe.bmg.core.blocklist.txt index 2930ca203..9205438f3 100644 --- a/tests/intel-ci/xe.bmg.core.blocklist.txt +++ b/tests/intel-ci/xe.bmg.core.blocklist.txt @@ -78,3 +78,16 @@ igt@xe_page_reclaim@.* #################################################################### igt@xe_eudebug_online@breakpoint-many-sessions-tiles #################################################################### +# Module load already happens in the setup phase +#################################################################### +igt@xe_module_load@load +#################################################################### +# MultiGPU is a separate config +#################################################################### +igt@(.*multigpu.*|xe_peer2peer.*).* +#################################################################### +# Expected behavior - CCS mode enabled only for platforms +# which have more than 1 COMPUTE ENGINE instance per tile. +#################################################################### +igt@xe_compute@ccs-mode-compute-kernel +#################################################################### diff --git a/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt b/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt index ce88f8879..ad7909e5b 100644 --- a/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt +++ b/tests/intel-ci/xe.dkms_kv5.15.blocklist.txt @@ -5,9 +5,14 @@ ##################################################### igt@xe_exec_system_allocator@.* igt@.*svm.* +igt@xe_madvise@atomic.* ##################################################### # No dma-buf support in KV5.15 DKMS ##################################################### igt@xe_dma_buf_sync@.* igt@xe_live_ktest@xe_dma_buf ##################################################### +# No SRIOV support in KV5.15 DKMS +##################################################### +igt@.*sriov.* +##################################################### From d7523d5f452da2905635eb62555772e1796dffee Mon Sep 17 00:00:00 2001 From: Venkateswara Rao Muppidi Date: Tue, 4 Aug 2026 20:42:33 +0530 Subject: [PATCH 28/33] tests/intel-ci: Add EUdebug,wedged-mode & pat-sw-hw tests to VF/VM blocklist Block EUdebug tests on SR-IOV VF/VM runs Block wedged-mode & pat-sw-hw tests on VF/VM runs Signed-off-by: Venkateswara Rao Muppidi --- tests/intel-ci/xe.sriov-vf.blocklist.txt | 10 +++++++++- tests/intel-ci/xe.sriov-vm.blocklist.txt | 10 +++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/tests/intel-ci/xe.sriov-vf.blocklist.txt b/tests/intel-ci/xe.sriov-vf.blocklist.txt index fab92c523..d86a29132 100644 --- a/tests/intel-ci/xe.sriov-vf.blocklist.txt +++ b/tests/intel-ci/xe.sriov-vf.blocklist.txt @@ -9,7 +9,6 @@ igt@xe_module_load@.* # tests applicable for PF only # igt@sriov_basic.* -igt@xe_eudebug_sriov.* igt@xe_pmu@.*engine-activity-.* igt@xe_pmu@gt-c6-idle igt@xe_sriov.* @@ -71,3 +70,12 @@ igt@intel_hwmon@hwmon-(read|write) # Tests that need to be executed in VM instead. # igt@xe_live_ktest.* +# +#EUdebug not supported in VF +igt@(xe.eudebug.|xe_exec_sip.).* +# +#driver rejects attempts to set wedged_mode=2 on a VF +igt@xe_wedged@wedged.* +# +#HW PAT may not be readable on VF +igt@xe_pat@pat-sw-hw.* diff --git a/tests/intel-ci/xe.sriov-vm.blocklist.txt b/tests/intel-ci/xe.sriov-vm.blocklist.txt index 8407411dc..38f71ff93 100644 --- a/tests/intel-ci/xe.sriov-vm.blocklist.txt +++ b/tests/intel-ci/xe.sriov-vm.blocklist.txt @@ -10,7 +10,6 @@ igt@xe_ccs@suspend-resume # tests applicable for PF only # igt@sriov_basic.* -igt@xe_eudebug_sriov.* igt@xe_pmu@.*engine-activity-.* igt@xe_pmu@gt-c6-idle igt@xe_sriov.* @@ -68,3 +67,12 @@ igt@xe_survivability@.* # HWMON is not supported inside VF. # igt@intel_hwmon@hwmon-(read|write) +# +#EUdebug not supported in VF +igt@(xe.eudebug.|xe_exec_sip.).* +# +#driver rejects attempts to set wedged_mode=2 on a VF +igt@xe_wedged@wedged.* +# +#HW PAT may not be readable on VF +igt@xe_pat@pat-sw-hw.* From 14a3fffa7b4d811f3c7f8c1fc600f140e441ec6a Mon Sep 17 00:00:00 2001 From: Kolanupaka Naveena Date: Wed, 1 Oct 2025 15:27:52 +0530 Subject: [PATCH 29/33] lib/xe/xe_eudebug: Introduce a new API for client create which accepts custom timeout MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The existing xe_eudebug_client_create() is creating the client with default timeout. But there is no way to create the client with custom timeout. Hence adding an API named xe_eudebug_client_create_timeout() that takes the timeout as input and creates the client with provided timeout value. Suggested-by: Christoph Manszewski Signed-off-by: Kolanupaka Naveena Reviewed-by: Dominik Karol Piątkowski Reviewed-by: Andrzej Hajda --- lib/xe/xe_eudebug.c | 34 +++++++++++++++++++++++++++++----- lib/xe/xe_eudebug.h | 3 +++ 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/lib/xe/xe_eudebug.c b/lib/xe/xe_eudebug.c index 84ac5b71e..8a8f0602c 100644 --- a/lib/xe/xe_eudebug.c +++ b/lib/xe/xe_eudebug.c @@ -1583,14 +1583,17 @@ void xe_eudebug_debugger_kill(struct xe_eudebug_debugger *d, int sig) } /** - * xe_eudebug_client_create: + * xe_eudebug_client_create_timeout: * @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 shared between client and debugger. Accessible via client->ptr. * Can be NULL. + * @timeout: time period during which the client is expected to finish + * its workload + * * * Forks and creates the debugger process. @work won't be called until * xe_eudebug_client_start is called. @@ -1598,8 +1601,8 @@ void xe_eudebug_debugger_kill(struct xe_eudebug_debugger *d, int sig) * 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 *xe_eudebug_client_create_timeout(int master_fd, xe_eudebug_client_work_fn work, + uint64_t flags, void *data, int timeout_s) { struct xe_eudebug_client *c; @@ -1614,7 +1617,7 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cli c->done = 0; c->ptr = data; c->master_fd = master_fd; - c->timeout_ms = XE_EUDEBUG_DEFAULT_TIMEOUT_SEC * MSEC_PER_SEC; + c->timeout_ms = timeout_s * MSEC_PER_SEC; c->allow_dead_client = false; pthread_mutex_init(&c->lock, NULL); @@ -1659,6 +1662,27 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cli return c; } +/** + * 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. Accessible via client->ptr. + * Can be NULL. + * + * Calls xe_eudebug_client_create_timeout() with default timeout + * + * 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) +{ + return xe_eudebug_client_create_timeout(master_fd, work, flags, data, XE_EUDEBUG_DEFAULT_TIMEOUT_SEC); +} + /** * xe_eudebug_client_stop: * @c: pointer to xe_eudebug_client structure diff --git a/lib/xe/xe_eudebug.h b/lib/xe/xe_eudebug.h index 4f3c4887f..e9af8ca58 100644 --- a/lib/xe/xe_eudebug.h +++ b/lib/xe/xe_eudebug.h @@ -204,6 +204,9 @@ void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t st void xe_eudebug_debugger_wait_stage(struct xe_eudebug_session *s, uint64_t stage); void xe_eudebug_debugger_kill(struct xe_eudebug_debugger *d, int sig); +struct xe_eudebug_client * +xe_eudebug_client_create_timeout(int master_fd, xe_eudebug_client_work_fn work, + uint64_t flags, void *data, int timeout_s); 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); From e2de39b33bd7294fc01f8551adcfbe294e0ebcdb Mon Sep 17 00:00:00 2001 From: Kolanupaka Naveena Date: Wed, 1 Oct 2025 15:36:46 +0530 Subject: [PATCH 30/33] tests/intel/xe_eudebug_online: Introduce client timeout for caching tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Use the new API to allow setting client timeout for caching tests. Signed-off-by: Kolanupaka Naveena Signed-off-by: Dominik Karol Piątkowski --- tests/intel/xe_eudebug_online.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/tests/intel/xe_eudebug_online.c b/tests/intel/xe_eudebug_online.c index aaf21d820..0cb2d4dbd 100644 --- a/tests/intel/xe_eudebug_online.c +++ b/tests/intel/xe_eudebug_online.c @@ -84,6 +84,8 @@ #define PAGE_SIZE 4096 +#define XE_EUDEBUG_DEFAULT_CACHING_TIMEOUT_SEC 60ULL + struct dim_t { uint32_t x; uint32_t y; @@ -1215,7 +1217,7 @@ static void run_online_client(struct xe_eudebug_client *c) 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_SEC * NSEC_PER_SEC); + igt_assert_lt_u64(igt_nsec_elapsed(&ts), c->timeout_ms * NSEC_PER_MSEC); if (!(c->flags & DO_NOT_EXPECT_CANARIES)) { ptr = xe_bo_mmap_ext(fd, buf->handle, buf->size, PROT_READ); @@ -2428,7 +2430,13 @@ static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int f igt_skip_on_f(!xe_has_vram(fd), "Device does not have VRAM.\n"); data = online_debug_data_create(fd, hwe, flags); - s = xe_eudebug_session_create(fd, run_online_client, flags, data); + + s = calloc(1, sizeof(*s)); + igt_assert(s); + + s->client = xe_eudebug_client_create_timeout(fd, run_online_client, flags, data, XE_EUDEBUG_DEFAULT_CACHING_TIMEOUT_SEC); + s->debugger = xe_eudebug_debugger_create(fd, flags, data); + s->flags = flags; xe_eudebug_debugger_add_trigger(s->debugger, PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN, open_trigger); From 1bcd7a27d214d2c6912c56bcc819324f075fbaad Mon Sep 17 00:00:00 2001 From: Smitha Balasubramanyam Date: Thu, 6 Aug 2026 15:45:19 +0530 Subject: [PATCH 31/33] tests/intel/xe_eudebug_online: Increase default caching timeout for slow path Increase XE_EUDEBUG_DEFAULT_CACHING_TIMEOUT_SEC, raising the effective timeout from 60 seconds to 120 seconds. The writes-caching-* tests can exceed the current timeout in slow-path configurations, leading to failures. Increase the timeout to provide additional execution headroom. Suggested-by: Maciej Patelczyk Signed-off-by: Sanjay Yadav Signed-off-by: Smitha Balasubramanyam Reviewed-by: Andrzej Hajda --- tests/intel/xe_eudebug_online.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/intel/xe_eudebug_online.c b/tests/intel/xe_eudebug_online.c index 0cb2d4dbd..1e2272e17 100644 --- a/tests/intel/xe_eudebug_online.c +++ b/tests/intel/xe_eudebug_online.c @@ -84,7 +84,7 @@ #define PAGE_SIZE 4096 -#define XE_EUDEBUG_DEFAULT_CACHING_TIMEOUT_SEC 60ULL +#define XE_EUDEBUG_DEFAULT_CACHING_TIMEOUT_SEC 120ULL struct dim_t { uint32_t x; From 51e3b92291da03b868700b5363a800614a680fc4 Mon Sep 17 00:00:00 2001 From: "Patil, Shivtej Eknath" Date: Fri, 7 Aug 2026 06:29:43 +0000 Subject: [PATCH 32/33] Add initial PR validation workflow --- .github/workflows/pr-validation.yml | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) create mode 100644 .github/workflows/pr-validation.yml diff --git a/.github/workflows/pr-validation.yml b/.github/workflows/pr-validation.yml new file mode 100644 index 000000000..e12a4c7e2 --- /dev/null +++ b/.github/workflows/pr-validation.yml @@ -0,0 +1,16 @@ +name: PR Validation + +on: + pull_request: + workflow_dispatch: + +jobs: + validate: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Print message + run: echo "Workflow triggered successfully" From 54f654314e8c5b0b7478df3c9ed087cef68f85b0 Mon Sep 17 00:00:00 2001 From: "Patil, Shivtej Eknath" Date: Fri, 7 Aug 2026 06:54:44 +0000 Subject: [PATCH 33/33] Trigger workflow test --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index b4b9a37ea..339c28074 100644 --- a/README.md +++ b/README.md @@ -188,3 +188,4 @@ Imported non-DRM uapi headers from airlied's drm-next branch. Then, commit with a note of which exact commit from airlied's branch was used to generate them. +