Test coverage for GPU debug support
Subsystems (2)
v2 cover Test coverage for GPU debug support
Hi,
In this series the eudebug kernel and validation team would like to add test coverage for GPU debug support recently proposed as an RFC.
(https://patchwork.freedesktop.org/series/136572/)
This series adds 'xe_eudebug' and 'xe_eudebug_online' tests together with a library that encapsulates common paths in current and future EU debugger scenarios. It also extends the 'xe_exec_sip' test and 'gpgpu_shader' library.
The aim of the 'xe_eudebug' test is to validate the eudebug resource tracking and event delivery mechanism. The 'xe_eudebug_online' test is dedicated for 'online' scenarios which means scenarios that exercise hardware exception handling and thread state manipulation.
The xe_eudebug library provides an abstraction over debugger and debuggee processes, asynchronous event reader, and event log buffers for post-mortem analysis.
Latest kernel code can be found here:
https://gitlab.freedesktop.org/miku/kernel/-/commits/eudebug-dev
Thank you in advance for any comments and insight.
v2:
- make sure to include all patches and verify that each individual patch compiles (Zbigniew)
Andrzej Hajda (6):
tests/xe_eudebug: Add userptr variant of basic-vm-access test lib/gpgpu_shader: Add write_on_exception template lib/gpgpu_shader: Add set/clear exception register (cr0.1) helpers lib/intel_batchbuffer: Add helper to get pointer at specified offset lib/gpgpu_shader: Allow enabling illegal opcode exceptions in shader tests/xe_exec_sip: Rework invalid instruction tests
Christoph Manszewski (17):
lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter lib/xe_eudebug: Add support for vm_bind events lib/xe_eudebug: Add support for user fence acking lib/xe_eudebug: Add support for dynamic debugger sysfs toggle tests/xe_eudebug: Add basic vm-bind coverage tests/xe_eudebug: Add support for dynamic debugger sysfs toggle tests/xe_eudebug: Add coverage for sysfs debugger toggle lib/xe_eudebug: Allow debugger to wait for client tests/xe_eudebug: Add vm-bind discovery tests tests/xe_eudebug: Add basic-vm-bind-ufence tests/xe_eudebug: Add vm-bind-clear test
lib/gpgpu_shader: Extend shader building library tests/xe_exec_sip: Port tests for shaders and sip tests/xe_exec_sip: Add support for dynamic debugger sysfs toggle tests/xe_eudebug_online: Add support for dynamic debugger sysfs toggle tests/xe_eudebug_online: Add subtests w/o long running mode tests/xe_live_ktest: Add xe_eudebug live test
Dominik Grzegorzek (18):
drm-uapi/xe: Sync with eudebug uapi
tests/xe_eudebug: Test eudebug connection lib/xe_eudebug: Introduce eu debug testing framework lib/xe_eudebug: Add exec_queue support
lib/xe_eudebug: Add attention events support lib/xe_eudebug: Add metadata support
tests/xe_eudebug: Test open close events tests/xe_eudebug: Exercise read_event ioctl tests/xe_eudebug: Add vm events sanity check tests/xe_eudebug: Race discovery against eudebug attach. tests/xe_eudebug: Introduce basic exec_queue testing tests/xe_eudebug: Include exec queues in discovery testing tests/xe_exec_sip: Check if we reset due to unhandled attention tests/xe_exec_sip: Check usercoredump for attentions tests/xe_eudebug_online: Debug client which runs workloads on EU tests/xe_eudebug_online: Set dynamic breakpoint on interrupt-all tests/xe_eudebug_online: What if user does not set debug mode? tests/xe_eudebug_online: Check if eu debugger disables preemption
timeout
Dominik Karol Piatkowski (1):
tests/xe_eudebug_online: Add caching tests
Dominik Karol Piątkowski (5):
tests/xe_eudebug: Add multigpu scenarios tests/xe_exec_sip: Add breakpoint-writesip-twice test tests/xe_exec_sip: Add breakpoint-waitsip-heavy test tests/xe_eudebug_online: Add tdctl-parameters test tests/xe_eudebug_online: Add single-step and single-step-one tests
Gwan-gyeong Mun (1):
lib/intel_batchbuffer: Add support for long-running mode execution
Jonathan Cavitt (2):
tests/xe_eudebug: Exercise lseek
tests/xe_eudebug: Test multiple bo sizes
Karolina Stolarek (6):
tests/xe_eudebug: Add discovery-race-vmbind subtest tests/xe_exec_sip: Add sanity-after-timeout test tests/xe_exec_sip: Add nodebug test cases lib/xe_eudebug: Expose xe_eudebug_connect tests/xe_eudebug_online: Add interrupt-reconnect test tests/xe_eudebug_online: Add multisession test cases
Kolanupaka Naveena (1):
tests/xe_eudebug_online: Adds debugger-reopen test
Maciej Patelczyk (3):
tests/xe_eudebug: Exercise debug metadata events sent to debugger tests/xe_eudebug: Add basic-vm-bind-metadata-discovery tests/xe_eudebug: Added connect-user test
Mika Kuoppala (2):
lib/xe_eudebug: Allow client to wait for debugger tests/xe_eudebug: Add vm open/pread/pwrite basic tests
Pawel Sikora (4):
tests/xe_eudebug: Add basic-vm-access-parameters test lib/xe_eudebug: Add mutex for log events write tests/xe_eudebug: Add basic-client-th test tests/xe_eudebug_online: Add reset-with-attention test
include/drm-uapi/xe_drm.h | 104 +- include/drm-uapi/xe_drm_eudebug.h | 226 +++ lib/gpgpu_shader.c | 474 +++++- lib/gpgpu_shader.h | 29 +- lib/iga64_generated_codes.c | 428 ++++- lib/intel_batchbuffer.c | 153 +- lib/intel_batchbuffer.h | 22 + lib/meson.build | 1 + lib/xe/xe_eudebug.c | 2192 ++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 206 +++ lib/xe/xe_ioctl.c | 20 +- lib/xe/xe_ioctl.h | 5 + tests/intel/xe_eudebug.c | 2425 +++++++++++++++++++++++++++++ tests/intel/xe_eudebug_online.c | 2117 +++++++++++++++++++++++++ tests/intel/xe_exec_sip.c | 332 +++- tests/intel/xe_live_ktest.c | 6 + tests/meson.build | 2 + 17 files changed, 8701 insertions(+), 41 deletions(-) create mode 100644 include/drm-uapi/xe_drm_eudebug.h create mode 100644 lib/xe/xe_eudebug.c create mode 100644 lib/xe/xe_eudebug.h create mode 100644 tests/intel/xe_eudebug.c create mode 100644 tests/intel/xe_eudebug_online.c
Signature · 1 line
2.34.1
PATCH v2 1/66 drm-uapi/xe: Sync with eudebug uapi
From: Dominik Grzegorzek <[email protected]>
Align with kernel commit 09411c6ecbef ("drm/xe/eudebug: Add debug metadata support for xe_eudebug") from:
https://gitlab.freedesktop.org/miku/kernel.git
which introduces most recent changes to the eudebug uapi.
--- include/drm-uapi/xe_drm.h | 104 +++++++++++++- include/drm-uapi/xe_drm_eudebug.h | 226 ++++++++++++++++++++++++++++++ 2 files changed, 324 insertions(+), 6 deletions(-) create mode 100644 include/drm-uapi/xe_drm_eudebug.h
include/drm-uapi/xe_drm.h +98 -6
@@ -3,8 +3,8 @@* Copyright © 2023 Intel Corporation */ -#ifndef _UAPI_XE_DRM_H_ -#define _UAPI_XE_DRM_H_ +#ifndef _XE_DRM_H_ +#define _XE_DRM_H_#include "drm.h"
@@ -102,7 +102,9 @@ extern "C" {#define DRM_XE_EXEC 0x09#define DRM_XE_WAIT_USER_FENCE 0x0a#define DRM_XE_OBSERVATION 0x0b - +#define DRM_XE_EUDEBUG_CONNECT 0x0c +#define DRM_XE_DEBUG_METADATA_CREATE 0x0d +#define DRM_XE_DEBUG_METADATA_DESTROY 0x0e/* Must be kept compact -- no holes */ #define DRM_IOCTL_XE_DEVICE_QUERY DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEVICE_QUERY, struct drm_xe_device_query)
@@ -117,6 +119,9 @@ extern "C" {#define DRM_IOCTL_XE_EXEC DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)#define DRM_IOCTL_XE_WAIT_USER_FENCE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)#define DRM_IOCTL_XE_OBSERVATION DRM_IOW(DRM_COMMAND_BASE + DRM_XE_OBSERVATION, struct drm_xe_observation_param) +#define DRM_IOCTL_XE_EUDEBUG_CONNECT DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_EUDEBUG_CONNECT, struct drm_xe_eudebug_connect) +#define DRM_IOCTL_XE_DEBUG_METADATA_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_CREATE, struct drm_xe_debug_metadata_create) +#define DRM_IOCTL_XE_DEBUG_METADATA_DESTROY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_DESTROY, struct drm_xe_debug_metadata_destroy)/** * DOC: Xe IOCTL Extensions
@@ -134,7 +139,7 @@ extern "C" {* redefine the interface more easily than an ever growing struct of * increasing complexity, and for large parts of that interface to be * entirely optional. The downside is more pointer chasing; chasing across -* the __user boundary with pointers encapsulated inside u64. +* the boundary with pointers encapsulated inside u64. * * Example chaining: *
@@ -881,6 +886,23 @@ struct drm_xe_vm_destroy {__u64 reserved[2 ]; }; +struct drm_xe_vm_bind_op_ext_attach_debug { +/** @base: base user extension */ +struct drm_xe_user_extension base; + +/** @id: Debug object id from create metadata */ +__u64 metadata_id; + +/** @flags: Flags */ +__u64 flags; + +/** @cookie: Cookie */ +__u64 cookie; + +/** @reserved: Reserved */ +__u64 reserved; +}; +/** * struct drm_xe_vm_bind_op - run bind operations *
@@ -905,7 +927,9 @@ struct drm_xe_vm_destroy {* handle MBZ, and the BO offset MBZ. This flag is intended to * implement VK sparse bindings. */ +struct drm_xe_vm_bind_op { +#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0/** @extensions: Pointer to the first extension struct, if any */ __u64 extensions;
@@ -1108,7 +1132,8 @@ struct drm_xe_exec_queue_create {#define DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY 0#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_PRIORITY 0#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_TIMESLICE 1 - +#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG 2 +#define DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE (1 << 0)/** @extensions: Pointer to the first extension struct, if any */ __u64 extensions;
@@ -1694,8 +1719,75 @@ struct drm_xe_oa_stream_info {__u64 reserved[3 ]; }; +/* +* Debugger ABI (ioctl and events) Version History: +* 0 - No debugger available +* 1 - Initial version +*/ +#define DRM_XE_EUDEBUG_VERSION 1 + +struct drm_xe_eudebug_connect { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +__u64 pid;/* input: Target process ID */ +__u32 flags;/* MBZ */ + +__u32 version;/* output: current ABI (ioctl / events) version */ +}; + +/* +* struct drm_xe_debug_metadata_create - Create debug metadata +* +* Add a region of user memory to be marked as debug metadata. +* When the debugger attaches, the metadata regions will be delivered +* for debugger. Debugger can then map these regions to help decode +* the program state. +* +* Returns handle to created metadata entry. +*/ +struct drm_xe_debug_metadata_create { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +#define DRM_XE_DEBUG_METADATA_ELF_BINARY 0 +#define DRM_XE_DEBUG_METADATA_PROGRAM_MODULE 1 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA 2 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA 3 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA 4 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM (1 + \ + WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA) + +/** @type: Type of metadata */ +__u64 type; + +/** @user_addr: pointer to start of the metadata */ +__u64 user_addr; + +/** @len: length, in bytes of the medata */ +__u64 len; + +/** @metadata_id: created metadata handle (out) */ +__u32 metadata_id; +}; + +/** +* struct drm_xe_debug_metadata_destroy - Destroy debug metadata +* +* Destroy debug metadata. +*/ +struct drm_xe_debug_metadata_destroy { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +/** @metadata_id: metadata handle to destroy */ +__u32 metadata_id; +}; + +#include "xe_drm_eudebug.h" +#if defined(__cplusplus) }#endif -#endif /* _UAPI_XE_DRM_H_ */ +#endif /* _XE_DRM_H_ */
include/drm-uapi/xe_drm_eudebug.h new file +226 -0
226 lines not on this page · raw message
Signature · 1 line
2.34.1
Re: [PATCH i-g-t v2 01/66] drm-uapi/xe: Sync with eudebug uapi
Hi Christoph,
Quoted 11 lines · Christoph Manszewski
From: Dominik Grzegorzek <[email protected]>
Align with kernel commit
09411c6ecbef("drm/xe/eudebug: Add debug metadata support forxe_eudebug") from:https://gitlab.freedesktop.org/miku/kernel.git
which introduces most recent changes to the eudebug uapi.
Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>
You should put here your s-o-b, to this and all other patches you sent. One more nit below.
Quoted 3 lines
--- include/drm-uapi/xe_drm.h | 104 +++++++++++++- include/drm-uapi/xe_drm_eudebug.h | 226 ++++++++++++++++++++++++++++++
Could that second change be in separate patch?
Or do the kernel counterpart have also two parts?
Quoted 8 lines
2 files changed, 324 insertions(+), 6 deletions(-) create mode 100644 include/drm-uapi/xe_drm_eudebug.hinclude/drm-uapi/xe_drm.h +0
-0
include/drm-uapi/xe_drm.h line 7
Quoted 7 lines
include/drm-uapi/xe_drm.h +2
-2@@ -3,8 +3,8 @@* Copyright © 2023 Intel Corporation */ -#ifndef _UAPI_XE_DRM_H_ -#define _UAPI_XE_DRM_H_ +#ifndef _XE_DRM_H_ +#define _XE_DRM_H_
Why are you touching this?
Regards,
Kamil
Quoted 389 lines
include/drm-uapi/xe_drm.h +96
-4#include "drm.h" @@ -102,7 +102,9 @@ extern "C" {#define DRM_XE_EXEC 0x09#define DRM_XE_WAIT_USER_FENCE 0x0a#define DRM_XE_OBSERVATION 0x0b - +#define DRM_XE_EUDEBUG_CONNECT 0x0c +#define DRM_XE_DEBUG_METADATA_CREATE 0x0d +#define DRM_XE_DEBUG_METADATA_DESTROY 0x0e/* Must be kept compact -- no holes */ #define DRM_IOCTL_XE_DEVICE_QUERY DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEVICE_QUERY, struct drm_xe_device_query)@@ -117,6 +119,9 @@ extern "C" {#define DRM_IOCTL_XE_EXEC DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)#define DRM_IOCTL_XE_WAIT_USER_FENCE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)#define DRM_IOCTL_XE_OBSERVATION DRM_IOW(DRM_COMMAND_BASE + DRM_XE_OBSERVATION, struct drm_xe_observation_param) +#define DRM_IOCTL_XE_EUDEBUG_CONNECT DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_EUDEBUG_CONNECT, struct drm_xe_eudebug_connect) +#define DRM_IOCTL_XE_DEBUG_METADATA_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_CREATE, struct drm_xe_debug_metadata_create) +#define DRM_IOCTL_XE_DEBUG_METADATA_DESTROY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_DESTROY, struct drm_xe_debug_metadata_destroy)/** * DOC: Xe IOCTL Extensions @@ -134,7 +139,7 @@ extern "C" {* redefine the interface more easily than an ever growing struct of * increasing complexity, and for large parts of that interface to be * entirely optional. The downside is more pointer chasing; chasing across -* the __user boundary with pointers encapsulated inside u64. +* the boundary with pointers encapsulated inside u64. * * Example chaining: * @@ -881,6 +886,23 @@ struct drm_xe_vm_destroy {__u64 reserved[2 ]; }; +struct drm_xe_vm_bind_op_ext_attach_debug { +/** @base: base user extension */ +struct drm_xe_user_extension base; + +/** @id: Debug object id from create metadata */ +__u64 metadata_id; + +/** @flags: Flags */ +__u64 flags; + +/** @cookie: Cookie */ +__u64 cookie; + +/** @reserved: Reserved */ +__u64 reserved; +}; +/** * struct drm_xe_vm_bind_op - run bind operations * @@ -905,7 +927,9 @@ struct drm_xe_vm_destroy {* handle MBZ, and the BO offset MBZ. This flag is intended to * implement VK sparse bindings. */ +struct drm_xe_vm_bind_op { +#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0/** @extensions: Pointer to the first extension struct, if any */ __u64 extensions;@@ -1108,7 +1132,8 @@ struct drm_xe_exec_queue_create {#define DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY 0#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_PRIORITY 0#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_TIMESLICE 1 - +#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG 2 +#define DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE (1 << 0)/** @extensions: Pointer to the first extension struct, if any */ __u64 extensions;@@ -1694,8 +1719,75 @@ struct drm_xe_oa_stream_info {__u64 reserved[3 ]; }; +/* +* Debugger ABI (ioctl and events) Version History: +* 0 - No debugger available +* 1 - Initial version +*/ +#define DRM_XE_EUDEBUG_VERSION 1 + +struct drm_xe_eudebug_connect { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +__u64 pid;/* input: Target process ID */ +__u32 flags;/* MBZ */ + +__u32 version;/* output: current ABI (ioctl / events) version */ +}; + +/* +* struct drm_xe_debug_metadata_create - Create debug metadata +* +* Add a region of user memory to be marked as debug metadata. +* When the debugger attaches, the metadata regions will be delivered +* for debugger. Debugger can then map these regions to help decode +* the program state. +* +* Returns handle to created metadata entry. +*/ +struct drm_xe_debug_metadata_create { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +#define DRM_XE_DEBUG_METADATA_ELF_BINARY 0 +#define DRM_XE_DEBUG_METADATA_PROGRAM_MODULE 1 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA 2 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA 3 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA 4 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM (1 + \ + WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA) + +/** @type: Type of metadata */ +__u64 type; + +/** @user_addr: pointer to start of the metadata */ +__u64 user_addr; + +/** @len: length, in bytes of the medata */ +__u64 len; + +/** @metadata_id: created metadata handle (out) */ +__u32 metadata_id; +}; + +/** +* struct drm_xe_debug_metadata_destroy - Destroy debug metadata +* +* Destroy debug metadata. +*/ +struct drm_xe_debug_metadata_destroy { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +/** @metadata_id: metadata handle to destroy */ +__u32 metadata_id; +}; + +#include "xe_drm_eudebug.h" +#if defined(__cplusplus) }#endif -#endif /* _UAPI_XE_DRM_H_ */ +#endif /* _XE_DRM_H_ */ include/drm-uapi/xe_drm_eudebug.h new file +226
-0@@ -0,0 +1,226 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2023 Intel Corporation +*/ + +#ifndef _XE_DRM_EUDEBUG_H_ +#define _XE_DRM_EUDEBUG_H_ + +#if defined(__cplusplus) +extern "C" { +#endif + +/** +* Do a eudebug event read for a debugger connection. +* +* This ioctl is available in debug version 1. +*/ +#define DRM_XE_EUDEBUG_IOCTL_READ_EVENT _IO('j', 0x0) +#define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL _IOWR('j', 0x2, struct drm_xe_eudebug_eu_control) +#define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT _IOW('j', 0x4, struct drm_xe_eudebug_ack_event) +#define DRM_XE_EUDEBUG_IOCTL_VM_OPEN _IOW('j', 0x1, struct drm_xe_eudebug_vm_open) +#define DRM_XE_EUDEBUG_IOCTL_READ_METADATA _IOWR('j', 0x3, struct drm_xe_eudebug_read_metadata) + +/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */ +struct drm_xe_eudebug_event { +__u32 len; + +__u16 type; +#define DRM_XE_EUDEBUG_EVENT_NONE 0 +#define DRM_XE_EUDEBUG_EVENT_READ 1 +#define DRM_XE_EUDEBUG_EVENT_OPEN 2 +#define DRM_XE_EUDEBUG_EVENT_VM 3 +#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 +#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND 6 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 +#define DRM_XE_EUDEBUG_EVENT_METADATA 9 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 +#define DRM_XE_EUDEBUG_EVENT_MAX_EVENT DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA + +__u16 flags; +#define DRM_XE_EUDEBUG_EVENT_CREATE (1 << 0) +#define DRM_XE_EUDEBUG_EVENT_DESTROY (1 << 1) +#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE (1 << 2) +#define DRM_XE_EUDEBUG_EVENT_NEED_ACK (1 << 3) + +__u64 seqno; +__u64 reserved; +}; + +struct drm_xe_eudebug_event_client { +struct drm_xe_eudebug_event base; + +__u64 client_handle;/* This is unique per debug connection */ +}; + +struct drm_xe_eudebug_event_vm { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 vm_handle; +}; + +struct drm_xe_eudebug_event_exec_queue { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 vm_handle; +__u64 exec_queue_handle; +__u32 engine_class; +__u32 width; +__u64 lrc_handle[]; +}; + +struct drm_xe_eudebug_event_eu_attention { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 exec_queue_handle; +__u64 lrc_handle; +__u32 flags; +__u32 bitmask_size; +__u8 bitmask[]; +}; + +struct drm_xe_eudebug_eu_control { +__u64 client_handle; + +#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL 0 +#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED 1 +#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME 2 +__u32 cmd; +__u32 flags; + +__u64 seqno; + +__u64 exec_queue_handle; +__u64 lrc_handle; +__u32 reserved; +__u32 bitmask_size; +__u64 bitmask_ptr; +}; + +/* +* When client (debuggee) does vm_bind_ioctl() following event +* sequence will be created (for the debugger): +* +* ┌───────────────────────┐ +* │ EVENT_VM_BIND ├───────┬─┬─┐ +* └───────────────────────┘ │ │ │ +* ┌───────────────────────┐ │ │ │ +* │ EVENT_VM_BIND_OP #1 ├───┘ │ │ +* └───────────────────────┘ │ │ +* ... │ │ +* ┌───────────────────────┐ │ │ +* │ EVENT_VM_BIND_OP #n ├─────┘ │ +* └───────────────────────┘ │ +* │ +* ┌───────────────────────┐ │ +* │ EVENT_UFENCE ├───────┘ +* └───────────────────────┘ +* +* All the events below VM_BIND will reference the VM_BIND +* they associate with, by field .vm_bind_ref_seqno. +* event_ufence will only be included if the client did +* attach sync of type UFENCE into its vm_bind_ioctl(). +* +* When EVENT_UFENCE is sent by the driver, all the OPs of +* the original VM_BIND are completed and the [addr,range] +* contained in them are present and modifiable through the +* vm accessors. Accessing [addr, range] before related ufence +* event will lead to undefined results as the actual bind +* operations are async and the backing storage might not +* be there on a moment of receiving the event. +* +* Client's UFENCE sync will be held by the driver: client's +* drm_xe_wait_ufence will not complete and the value of the ufence +* won't appear until ufence is acked by the debugger process calling +* DRM_XE_EUDEBUG_IOCTL_ACK_EVENT with the event_ufence.base.seqno. +* This will signal the fence, .value will update and the wait will +* complete allowing the client to continue. +* +*/ + +struct drm_xe_eudebug_event_vm_bind { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 vm_handle; + +__u32 flags; +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0) + +__u32 num_binds; +}; + +struct drm_xe_eudebug_event_vm_bind_op { +struct drm_xe_eudebug_event base; +__u64 vm_bind_ref_seqno;/* *_event_vm_bind.base.seqno */ +__u64 num_extensions; + +__u64 addr;/* XXX: Zero for unmap all? */ +__u64 range;/* XXX: Zero for unmap all? */ +}; + +struct drm_xe_eudebug_event_vm_bind_ufence { +struct drm_xe_eudebug_event base; +__u64 vm_bind_ref_seqno;/* *_event_vm_bind.base.seqno */ +}; + +struct drm_xe_eudebug_ack_event { +__u32 type; +__u32 flags;/* MBZ */ +__u64 seqno; +}; + +struct drm_xe_eudebug_vm_open { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +/** @client_handle: id of client */ +__u64 client_handle; + +/** @vm_handle: id of vm */ +__u64 vm_handle; + +/** @flags: flags */ +__u64 flags; + +/** @timeout_ns: Timeout value in nanoseconds operations (fsync) */ +__u64 timeout_ns; +}; + +struct drm_xe_eudebug_read_metadata { +__u64 client_handle; +__u64 metadata_handle; +__u32 flags; +__u32 reserved; +__u64 ptr; +__u64 size; +}; + +struct drm_xe_eudebug_event_metadata { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 metadata_handle; +/* XXX: Refer to xe_drm.h for fields */ +__u64 type; +__u64 len; +}; + +struct drm_xe_eudebug_event_vm_bind_op_metadata { +struct drm_xe_eudebug_event base; +__u64 vm_bind_op_ref_seqno;/* *_event_vm_bind_op.base.seqno */ + +__u64 metadata_handle; +__u64 metadata_cookie; +}; + +#if defined(__cplusplus) +} +#endif + +#endif Signature · 1 line
2.34.1
Re: [PATCH i-g-t v2 01/66] drm-uapi/xe: Sync with eudebug uapi
Hi Kamil,
Quoted 7 lines · Kamil Konieczny
Hi Christoph,
Quoted 5 lines · Christoph Manszewski
From: Dominik Grzegorzek <[email protected]>
Align with kernel commit
09411c6ecbef("drm/xe/eudebug: Add debug metadata support forxe_eudebug") from:
Quoted 8 lines
Quoted 6 lines
https://gitlab.freedesktop.org/miku/kernel.git
which introduces most recent changes to the eudebug uapi.
Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>You should put here your s-o-b, to this and all other patches you sent.
Ok, got it.
Quoted 8 lines
One more nit below.
Quoted 3 lines
--- include/drm-uapi/xe_drm.h | 104 +++++++++++++- include/drm-uapi/xe_drm_eudebug.h | 226 ++++++++++++++++++++++++++++++Could that second change be in separate patch?
Or do the kernel counterpart have also two parts?
Well I can split the kmd uapi sync into two patches but I am not sure what the benefit of that is.
Quoted 12 lines
Quoted 12 lines
2 files changed, 324 insertions(+), 6 deletions(-)create mode 100644
include/drm-uapi/xe_drm_eudebug.hinclude/drm-uapi/xe_drm.h +0
-0@@ -3,8 +3,8 @@* Copyright © 2023 Intel Corporation */
Quoted 6 lines
include/drm-uapi/xe_drm.h line 7
Quoted 4 lines
include/drm-uapi/xe_drm.h +2
-2-#ifndef _UAPI_XE_DRM_H_ -#define _UAPI_XE_DRM_H_ +#ifndef _XE_DRM_H_ +#define _XE_DRM_H_Why are you touching this?
Sorry - an oversight on my side, prolly copied the wrong header file from the kernel. I will use the correct one in the next series.
Thanks,
Christoph
Quoted 393 lines
Regards,
KamilQuoted 389 lines
include/drm-uapi/xe_drm.h +96
-4#include "drm.h" @@ -102,7 +102,9 @@ extern "C" {#define DRM_XE_EXEC 0x09#define DRM_XE_WAIT_USER_FENCE 0x0a#define DRM_XE_OBSERVATION 0x0b - +#define DRM_XE_EUDEBUG_CONNECT 0x0c +#define DRM_XE_DEBUG_METADATA_CREATE 0x0d +#define DRM_XE_DEBUG_METADATA_DESTROY 0x0e/* Must be kept compact -- no holes */ #define DRM_IOCTL_XE_DEVICE_QUERY DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEVICE_QUERY, struct drm_xe_device_query)@@ -117,6 +119,9 @@ extern "C" {#define DRM_IOCTL_XE_EXEC DRM_IOW(DRM_COMMAND_BASE + DRM_XE_EXEC, struct drm_xe_exec)#define DRM_IOCTL_XE_WAIT_USER_FENCE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_WAIT_USER_FENCE, struct drm_xe_wait_user_fence)#define DRM_IOCTL_XE_OBSERVATION DRM_IOW(DRM_COMMAND_BASE + DRM_XE_OBSERVATION, struct drm_xe_observation_param) +#define DRM_IOCTL_XE_EUDEBUG_CONNECT DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_EUDEBUG_CONNECT, struct drm_xe_eudebug_connect) +#define DRM_IOCTL_XE_DEBUG_METADATA_CREATE DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_CREATE, struct drm_xe_debug_metadata_create) +#define DRM_IOCTL_XE_DEBUG_METADATA_DESTROY DRM_IOW(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_DESTROY, struct drm_xe_debug_metadata_destroy)/** * DOC: Xe IOCTL Extensions @@ -134,7 +139,7 @@ extern "C" {* redefine the interface more easily than an ever growing struct of * increasing complexity, and for large parts of that interface to be * entirely optional. The downside is more pointer chasing; chasing across -* the __user boundary with pointers encapsulated inside u64. +* the boundary with pointers encapsulated inside u64. * * Example chaining: * @@ -881,6 +886,23 @@ struct drm_xe_vm_destroy {__u64 reserved[2 ]; }; +struct drm_xe_vm_bind_op_ext_attach_debug { +/** @base: base user extension */ +struct drm_xe_user_extension base; + +/** @id: Debug object id from create metadata */ +__u64 metadata_id; + +/** @flags: Flags */ +__u64 flags; + +/** @cookie: Cookie */ +__u64 cookie; + +/** @reserved: Reserved */ +__u64 reserved; +}; +/** * struct drm_xe_vm_bind_op - run bind operations * @@ -905,7 +927,9 @@ struct drm_xe_vm_destroy {* handle MBZ, and the BO offset MBZ. This flag is intended to * implement VK sparse bindings. */ +struct drm_xe_vm_bind_op { +#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0/** @extensions: Pointer to the first extension struct, if any */ __u64 extensions;@@ -1108,7 +1132,8 @@ struct drm_xe_exec_queue_create {#define DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY 0#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_PRIORITY 0#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_TIMESLICE 1 - +#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG 2 +#define DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE (1 << 0)/** @extensions: Pointer to the first extension struct, if any */ __u64 extensions;@@ -1694,8 +1719,75 @@ struct drm_xe_oa_stream_info {__u64 reserved[3 ]; }; +/* +* Debugger ABI (ioctl and events) Version History: +* 0 - No debugger available +* 1 - Initial version +*/ +#define DRM_XE_EUDEBUG_VERSION 1 + +struct drm_xe_eudebug_connect { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +__u64 pid;/* input: Target process ID */ +__u32 flags;/* MBZ */ + +__u32 version;/* output: current ABI (ioctl / events) version */ +}; + +/* +* struct drm_xe_debug_metadata_create - Create debug metadata +* +* Add a region of user memory to be marked as debug metadata. +* When the debugger attaches, the metadata regions will be delivered +* for debugger. Debugger can then map these regions to help decode +* the program state. +* +* Returns handle to created metadata entry. +*/ +struct drm_xe_debug_metadata_create { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +#define DRM_XE_DEBUG_METADATA_ELF_BINARY 0 +#define DRM_XE_DEBUG_METADATA_PROGRAM_MODULE 1 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA 2 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA 3 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA 4 +#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM (1 + \ + WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA) + +/** @type: Type of metadata */ +__u64 type; + +/** @user_addr: pointer to start of the metadata */ +__u64 user_addr; + +/** @len: length, in bytes of the medata */ +__u64 len; + +/** @metadata_id: created metadata handle (out) */ +__u32 metadata_id; +}; + +/** +* struct drm_xe_debug_metadata_destroy - Destroy debug metadata +* +* Destroy debug metadata. +*/ +struct drm_xe_debug_metadata_destroy { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +/** @metadata_id: metadata handle to destroy */ +__u32 metadata_id; +}; + +#include "xe_drm_eudebug.h" +#if defined(__cplusplus) }#endif -#endif /* _UAPI_XE_DRM_H_ */ +#endif /* _XE_DRM_H_ */ include/drm-uapi/xe_drm_eudebug.h new file +226
-0@@ -0,0 +1,226 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2023 Intel Corporation +*/ + +#ifndef _XE_DRM_EUDEBUG_H_ +#define _XE_DRM_EUDEBUG_H_ + +#if defined(__cplusplus) +extern "C" { +#endif + +/** +* Do a eudebug event read for a debugger connection. +* +* This ioctl is available in debug version 1. +*/ +#define DRM_XE_EUDEBUG_IOCTL_READ_EVENT _IO('j', 0x0) +#define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL _IOWR('j', 0x2, struct drm_xe_eudebug_eu_control) +#define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT _IOW('j', 0x4, struct drm_xe_eudebug_ack_event) +#define DRM_XE_EUDEBUG_IOCTL_VM_OPEN _IOW('j', 0x1, struct drm_xe_eudebug_vm_open) +#define DRM_XE_EUDEBUG_IOCTL_READ_METADATA _IOWR('j', 0x3, struct drm_xe_eudebug_read_metadata) + +/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */ +struct drm_xe_eudebug_event { +__u32 len; + +__u16 type; +#define DRM_XE_EUDEBUG_EVENT_NONE 0 +#define DRM_XE_EUDEBUG_EVENT_READ 1 +#define DRM_XE_EUDEBUG_EVENT_OPEN 2 +#define DRM_XE_EUDEBUG_EVENT_VM 3 +#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 +#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND 6 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 +#define DRM_XE_EUDEBUG_EVENT_METADATA 9 +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 +#define DRM_XE_EUDEBUG_EVENT_MAX_EVENT DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA + +__u16 flags; +#define DRM_XE_EUDEBUG_EVENT_CREATE (1 << 0) +#define DRM_XE_EUDEBUG_EVENT_DESTROY (1 << 1) +#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE (1 << 2) +#define DRM_XE_EUDEBUG_EVENT_NEED_ACK (1 << 3) + +__u64 seqno; +__u64 reserved; +}; + +struct drm_xe_eudebug_event_client { +struct drm_xe_eudebug_event base; + +__u64 client_handle;/* This is unique per debug connection */ +}; + +struct drm_xe_eudebug_event_vm { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 vm_handle; +}; + +struct drm_xe_eudebug_event_exec_queue { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 vm_handle; +__u64 exec_queue_handle; +__u32 engine_class; +__u32 width; +__u64 lrc_handle[]; +}; + +struct drm_xe_eudebug_event_eu_attention { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 exec_queue_handle; +__u64 lrc_handle; +__u32 flags; +__u32 bitmask_size; +__u8 bitmask[]; +}; + +struct drm_xe_eudebug_eu_control { +__u64 client_handle; + +#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL 0 +#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED 1 +#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME 2 +__u32 cmd; +__u32 flags; + +__u64 seqno; + +__u64 exec_queue_handle; +__u64 lrc_handle; +__u32 reserved; +__u32 bitmask_size; +__u64 bitmask_ptr; +}; + +/* +* When client (debuggee) does vm_bind_ioctl() following event +* sequence will be created (for the debugger): +* +* ┌───────────────────────┐ +* │ EVENT_VM_BIND ├───────┬─┬─┐ +* └───────────────────────┘ │ │ │ +* ┌───────────────────────┐ │ │ │ +* │ EVENT_VM_BIND_OP #1 ├───┘ │ │ +* └───────────────────────┘ │ │ +* ... │ │ +* ┌───────────────────────┐ │ │ +* │ EVENT_VM_BIND_OP #n ├─────┘ │ +* └───────────────────────┘ │ +* │ +* ┌───────────────────────┐ │ +* │ EVENT_UFENCE ├───────┘ +* └───────────────────────┘ +* +* All the events below VM_BIND will reference the VM_BIND +* they associate with, by field .vm_bind_ref_seqno. +* event_ufence will only be included if the client did +* attach sync of type UFENCE into its vm_bind_ioctl(). +* +* When EVENT_UFENCE is sent by the driver, all the OPs of +* the original VM_BIND are completed and the [addr,range] +* contained in them are present and modifiable through the +* vm accessors. Accessing [addr, range] before related ufence +* event will lead to undefined results as the actual bind +* operations are async and the backing storage might not +* be there on a moment of receiving the event. +* +* Client's UFENCE sync will be held by the driver: client's +* drm_xe_wait_ufence will not complete and the value of the ufence +* won't appear until ufence is acked by the debugger process calling +* DRM_XE_EUDEBUG_IOCTL_ACK_EVENT with the event_ufence.base.seqno. +* This will signal the fence, .value will update and the wait will +* complete allowing the client to continue. +* +*/ + +struct drm_xe_eudebug_event_vm_bind { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 vm_handle; + +__u32 flags; +#define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0) + +__u32 num_binds; +}; + +struct drm_xe_eudebug_event_vm_bind_op { +struct drm_xe_eudebug_event base; +__u64 vm_bind_ref_seqno;/* *_event_vm_bind.base.seqno */ +__u64 num_extensions; + +__u64 addr;/* XXX: Zero for unmap all? */ +__u64 range;/* XXX: Zero for unmap all? */ +}; + +struct drm_xe_eudebug_event_vm_bind_ufence { +struct drm_xe_eudebug_event base; +__u64 vm_bind_ref_seqno;/* *_event_vm_bind.base.seqno */ +}; + +struct drm_xe_eudebug_ack_event { +__u32 type; +__u32 flags;/* MBZ */ +__u64 seqno; +}; + +struct drm_xe_eudebug_vm_open { +/** @extensions: Pointer to the first extension struct, if any */ +__u64 extensions; + +/** @client_handle: id of client */ +__u64 client_handle; + +/** @vm_handle: id of vm */ +__u64 vm_handle; + +/** @flags: flags */ +__u64 flags; + +/** @timeout_ns: Timeout value in nanoseconds operations (fsync) */ +__u64 timeout_ns; +}; + +struct drm_xe_eudebug_read_metadata { +__u64 client_handle; +__u64 metadata_handle; +__u32 flags; +__u32 reserved; +__u64 ptr; +__u64 size; +}; + +struct drm_xe_eudebug_event_metadata { +struct drm_xe_eudebug_event base; + +__u64 client_handle; +__u64 metadata_handle; +/* XXX: Refer to xe_drm.h for fields */ +__u64 type; +__u64 len; +}; + +struct drm_xe_eudebug_event_vm_bind_op_metadata { +struct drm_xe_eudebug_event base; +__u64 vm_bind_op_ref_seqno;/* *_event_vm_bind_op.base.seqno */ + +__u64 metadata_handle; +__u64 metadata_cookie; +}; + +#if defined(__cplusplus) +} +#endif + +#endif Signature · 1 line
2.34.1
PATCH v2 2/66 tests/xe_eudebug: Test eudebug connection
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Add basic tests checking xe eudebug connection capability.
--- tests/intel/xe_eudebug.c | 135 +++++++++++++++++++++++++++++++++++++++ tests/meson.build | 1 + 2 files changed, 136 insertions(+) create mode 100644 tests/intel/xe_eudebug.c
tests/intel/xe_eudebug.c new file +135 -0
@@ -0,0 +1,135 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2023 Intel Corporation +*/ + +/** +* TEST: Test EU Debugger functionality +* Category: Core +* Mega feature: EUdebug +* Sub-category: EUdebug tests +* Functionality: eu debugger framework +* Test category: functionality test +*/ + +#include <xe_drm.h> +#include "igt.h" + +static int __debug_connect (int fd,int *debugfd,struct drm_xe_eudebug_connect *param) +{ +int ret =0 ; + + *debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , param); + +if (*debugfd <0 ) { + ret = -errno; +igt_assume (ret !=0 ); + } + + errno =0 ; +return ret; +} + +/** +* SUBTEST: basic-connect +* Description: +* Exercise XE_EUDEBG_CONNECT ioctl with passing +* valid and invalid params. +*/ +static void test_connect (int fd) +{ +struct drm_xe_eudebug_connect param = {}; +int debugfd, ret; +pid_t *pid; + + pid =mmap (NULL ,sizeof (pid_t),PROT_WRITE , +MAP_SHARED |MAP_ANON ,-1 ,0 ); + +/* get fresh unrelated pid */ +igt_fork (child,1 ) + *pid =getpid (); + +igt_waitchildren (); + param.pid = *pid; +munmap (pid,sizeof (pid_t)); + + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, param.pid ? -ENOENT : -EINVAL ); + + param.pid =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.pid =getpid (); + param.version =-1 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.version =0 ; + param.flags = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.flags =0 ; + param.extensions = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.extensions =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert_neq (debugfd,-1 ); +igt_assert_eq (ret,0 ); + +close (debugfd); +} + +/** +* SUBTEST: basic-close +* Description: +* Test whether eudebug can be reattached after closure. +*/ +static void test_close (int fd) +{ +struct drm_xe_eudebug_connect param = {0 , }; +int debug_fd1, debug_fd2; +int fd2; + + param.pid =getpid (); + +igt_assert_eq (__debug_connect (fd, &debug_fd1, ¶m),0 ); +igt_assert (debug_fd1 >=0 ); +igt_assert_eq (__debug_connect (fd, &debug_fd2, ¶m), -EBUSY ); +igt_assert_eq (debug_fd2,-1 ); + +close (debug_fd1); + fd2 =drm_open_driver (DRIVER_XE ); + +igt_assert_eq (__debug_connect (fd2, &debug_fd2, ¶m),0 ); +igt_assert (debug_fd2 >=0 ); +close (fd2); +close (debug_fd2); +close (debug_fd1); +} + +igt_main +{ +int fd; + + igt_fixture { + fd =drm_open_driver (DRIVER_XE ); + } + + igt_subtest("basic-connect") +test_connect (fd); + + igt_subtest("basic-close") +test_close (fd); + +igt_fixture +drm_close_driver (fd ); +}
tests/meson.build +1 -0
@@ -279,6 +279,7 @@ intel_xe_progs = [ 'xe_dma_buf_sync', 'xe_debugfs', 'xe_drm_fdinfo', + 'xe_eudebug', 'xe_evict', 'xe_evict_ccs', 'xe_exec_atomic',
Signature · 1 line
2.34.1
Re: [PATCH i-g-t v2 02/66] tests/xe_eudebug: Test eudebug connection
Quoted 19 lines · Christoph Manszewski
From: Dominik Grzegorzek <[email protected]>
Add basic tests checking xe eudebug connection capability.
Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 135 +++++++++++++++++++++++++++++++++++++++ tests/meson.build | 1 + 2 files changed, 136 insertions(+) create mode 100644 tests/intel/xe_eudebug.ctests/intel/xe_eudebug.c new file +0
-0
tests/intel/xe_eudebug.c line 3
Quoted 3 lines
tests/intel/xe_eudebug.c new file +3
-0@@ -0,0 +1,135 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2023 Intel Corporation
* Copyright © 2024 Intel Corporation
And thats for all the files.
Regards, Dominik
Quoted 144 lines
tests/intel/xe_eudebug.c new file +132
-0+*/ + +/** +* TEST: Test EU Debugger functionality +* Category: Core +* Mega feature: EUdebug +* Sub-category: EUdebug tests +* Functionality: eu debugger framework +* Test category: functionality test +*/ + +#include <xe_drm.h> +#include "igt.h" + +static int __debug_connect (int fd,int *debugfd,struct drm_xe_eudebug_connect *param) +{ +int ret =0 ; + + *debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , param); + +if (*debugfd <0 ) { + ret = -errno; +igt_assume (ret !=0 ); + } + + errno =0 ; +return ret; +} + +/** +* SUBTEST: basic-connect +* Description: +* Exercise XE_EUDEBG_CONNECT ioctl with passing +* valid and invalid params. +*/ +static void test_connect (int fd) +{ +struct drm_xe_eudebug_connect param = {}; +int debugfd, ret; +pid_t *pid; + + pid =mmap (NULL ,sizeof (pid_t),PROT_WRITE , +MAP_SHARED |MAP_ANON ,-1 ,0 ); + +/* get fresh unrelated pid */ +igt_fork (child,1 ) + *pid =getpid (); + +igt_waitchildren (); + param.pid = *pid; +munmap (pid,sizeof (pid_t)); + + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, param.pid ? -ENOENT : -EINVAL ); + + param.pid =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.pid =getpid (); + param.version =-1 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.version =0 ; + param.flags = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.flags =0 ; + param.extensions = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.extensions =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert_neq (debugfd,-1 ); +igt_assert_eq (ret,0 ); + +close (debugfd); +} + +/** +* SUBTEST: basic-close +* Description: +* Test whether eudebug can be reattached after closure. +*/ +static void test_close (int fd) +{ +struct drm_xe_eudebug_connect param = {0 , }; +int debug_fd1, debug_fd2; +int fd2; + + param.pid =getpid (); + +igt_assert_eq (__debug_connect (fd, &debug_fd1, ¶m),0 ); +igt_assert (debug_fd1 >=0 ); +igt_assert_eq (__debug_connect (fd, &debug_fd2, ¶m), -EBUSY ); +igt_assert_eq (debug_fd2,-1 ); + +close (debug_fd1); + fd2 =drm_open_driver (DRIVER_XE ); + +igt_assert_eq (__debug_connect (fd2, &debug_fd2, ¶m),0 ); +igt_assert (debug_fd2 >=0 ); +close (fd2); +close (debug_fd2); +close (debug_fd1); +} + +igt_main +{ +int fd; + + igt_fixture { + fd =drm_open_driver (DRIVER_XE ); + } + + igt_subtest("basic-connect") +test_connect (fd); + + igt_subtest("basic-close") +test_close (fd); + +igt_fixture +drm_close_driver (fd ); +}tests/meson.build +1
-0@@ -279,6 +279,7 @@ intel_xe_progs = [ 'xe_dma_buf_sync', 'xe_debugfs', 'xe_drm_fdinfo', + 'xe_eudebug', 'xe_evict', 'xe_evict_ccs', 'xe_exec_atomic',
Re: [PATCH i-g-t v2 02/66] tests/xe_eudebug: Test eudebug connection
Hi Dominik,
since this file was already published last year I was told by Kamil that leaving '2023' is the appropriate approach.
Thanks,
Christoph
Quoted 172 lines · Dominik
Quoted 19 lines · Christoph Manszewski
From: Dominik Grzegorzek <[email protected]>
Add basic tests checking xe eudebug connection capability.
Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 135 +++++++++++++++++++++++++++++++++++++++ tests/meson.build | 1 + 2 files changed, 136 insertions(+)create mode 100644
tests/intel/xe_eudebug.ctests/intel/xe_eudebug.c new file +0
-0tests/intel/xe_eudebug.c line 3
Quoted 3 lines
tests/intel/xe_eudebug.c new file +3
-0@@ -0,0 +1,135 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2023 Intel Corporation * Copyright © 2024 Intel Corporation
And thats for all the files.Regards, Dominik
Quoted 144 lines
tests/intel/xe_eudebug.c new file +132
-0+*/ + +/** +* TEST: Test EU Debugger functionality +* Category: Core +* Mega feature: EUdebug +* Sub-category: EUdebug tests +* Functionality: eu debugger framework +* Test category: functionality test +*/ + +#include <xe_drm.h> +#include "igt.h" + +static int __debug_connect (int fd,int *debugfd,struct drm_xe_eudebug_connect *param) +{ +int ret =0 ; + + *debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , param); + +if (*debugfd <0 ) { + ret = -errno; +igt_assume (ret !=0 ); + } + + errno =0 ; +return ret; +} + +/** +* SUBTEST: basic-connect +* Description: +* Exercise XE_EUDEBG_CONNECT ioctl with passing +* valid and invalid params. +*/ +static void test_connect (int fd) +{ +struct drm_xe_eudebug_connect param = {}; +int debugfd, ret; +pid_t *pid; + + pid =mmap (NULL ,sizeof (pid_t),PROT_WRITE , +MAP_SHARED |MAP_ANON ,-1 ,0 ); + +/* get fresh unrelated pid */ +igt_fork (child,1 ) + *pid =getpid (); + +igt_waitchildren (); + param.pid = *pid; +munmap (pid,sizeof (pid_t)); + + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, param.pid ? -ENOENT : -EINVAL ); + + param.pid =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.pid =getpid (); + param.version =-1 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.version =0 ; + param.flags = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.flags =0 ; + param.extensions = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.extensions =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert_neq (debugfd,-1 ); +igt_assert_eq (ret,0 ); + +close (debugfd); +} + +/** +* SUBTEST: basic-close +* Description: +* Test whether eudebug can be reattached after closure. +*/ +static void test_close (int fd) +{ +struct drm_xe_eudebug_connect param = {0 , }; +int debug_fd1, debug_fd2; +int fd2; + + param.pid =getpid (); + +igt_assert_eq (__debug_connect (fd, &debug_fd1, ¶m),0 ); +igt_assert (debug_fd1 >=0 ); +igt_assert_eq (__debug_connect (fd, &debug_fd2, ¶m), -EBUSY ); +igt_assert_eq (debug_fd2,-1 ); + +close (debug_fd1); + fd2 =drm_open_driver (DRIVER_XE ); + +igt_assert_eq (__debug_connect (fd2, &debug_fd2, ¶m),0 ); +igt_assert (debug_fd2 >=0 ); +close (fd2); +close (debug_fd2); +close (debug_fd1); +} + +igt_main +{ +int fd; + + igt_fixture { + fd =drm_open_driver (DRIVER_XE ); + } + + igt_subtest("basic-connect") +test_connect (fd); + + igt_subtest("basic-close") +test_close (fd); + +igt_fixture +drm_close_driver (fd ); +}tests/meson.build +1
-0@@ -279,6 +279,7 @@ intel_xe_progs = [ 'xe_dma_buf_sync', 'xe_debugfs', 'xe_drm_fdinfo', + 'xe_eudebug', 'xe_evict', 'xe_evict_ccs', 'xe_exec_atomic',
RE: [PATCH i-g-t v2 02/66] tests/xe_eudebug: Test eudebug connection
In reply to Christoph ManszewskiOn top of copyright year issue noticed by Dominik Grzegorzek, please fix the typo mentioned below. When both issues fixed:
Quoted 61 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 02/66] tests/xe_eudebug: Test eudebug connectionFrom: Dominik Grzegorzek <[email protected]>
Add basic tests checking xe eudebug connection capability.
Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 135 +++++++++++++++++++++++++++++++++++++++ tests/meson.build | 1 + 2 files changed, 136 insertions(+) create mode 100644 tests/intel/xe_eudebug.ctests/intel/xe_eudebug.c new file mode renamed from tests/intel/xe_eudebug.c +0
-0100644 index 000000000..44a491319
tests/intel/xe_eudebug.c new file +22
-0@@ -0,0 +1,135 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2023 Intel Corporation +*/ + +/** +* TEST: Test EU Debugger functionality +* Category: Core +* Mega feature: EUdebug +* Sub-category: EUdebug tests +* Functionality: eu debugger framework +* Test category: functionality test +*/ + +#include <xe_drm.h> +#include "igt.h" + +static int __debug_connect (int fd,int *debugfd,struct +drm_xe_eudebug_connect *param) { +int ret =0 ; + + *debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT,param);
tests/intel/xe_eudebug.c new file +4
-0+ +if (*debugfd <0 ) { + ret = -errno; +igt_assume (ret !=0 );
tests/intel/xe_eudebug.c line 36
Quoted 10 lines
tests/intel/xe_eudebug.c new file +10
-0+ } + + errno =0 ; +return ret; +} + +/** +* SUBTEST: basic-connect +* Description: +* Exercise XE_EUDEBG_CONNECT ioctl with passing
Typo in XE_EUDEBUG_CONNECT
Quoted 113 lines
+ * valid and invalid params.
+ */tests/intel/xe_eudebug.c new file +97
-0+static void test_connect (int fd) +{ +struct drm_xe_eudebug_connect param = {}; +int debugfd, ret; +pid_t *pid; + + pid =mmap (NULL ,sizeof (pid_t),PROT_WRITE , +MAP_SHARED |MAP_ANON ,-1 ,0 ); + +/* get fresh unrelated pid */ +igt_fork (child,1 ) + *pid =getpid (); + +igt_waitchildren (); + param.pid = *pid; +munmap (pid,sizeof (pid_t)); + + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, param.pid ? -ENOENT : -EINVAL ); + + param.pid =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.pid =getpid (); + param.version =-1 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.version =0 ; + param.flags = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.flags =0 ; + param.extensions = ~0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert (debugfd ==-1 ); +igt_assert_eq (ret, -EINVAL ); + + param.extensions =0 ; + ret =__debug_connect (fd, &debugfd, ¶m); +igt_assert_neq (debugfd,-1 ); +igt_assert_eq (ret,0 ); + +close (debugfd); +} + +/** +* SUBTEST: basic-close +* Description: +* Test whether eudebug can be reattached after closure. +*/ +static void test_close (int fd) +{ +struct drm_xe_eudebug_connect param = {0 , }; +int debug_fd1, debug_fd2; +int fd2; + + param.pid =getpid (); + +igt_assert_eq (__debug_connect (fd, &debug_fd1, ¶m),0 ); +igt_assert (debug_fd1 >=0 ); +igt_assert_eq (__debug_connect (fd, &debug_fd2, ¶m), -EBUSY ); +igt_assert_eq (debug_fd2,-1 ); + +close (debug_fd1); + fd2 =drm_open_driver (DRIVER_XE ); + +igt_assert_eq (__debug_connect (fd2, &debug_fd2, ¶m),0 ); +igt_assert (debug_fd2 >=0 ); +close (fd2); +close (debug_fd2); +close (debug_fd1); +} + +igt_main +{ +int fd; + + igt_fixture { + fd =drm_open_driver (DRIVER_XE ); + } + + igt_subtest("basic-connect") +test_connect (fd); + + igt_subtest("basic-close") +test_close (fd); + +igt_fixture +drm_close_driver (fd ); +}tests/meson.build index renamed from tests/meson.build +0
-0
e649466be..35bf8ed35100644tests/meson.build +1
-1@@ -279,6 +279,7 @@ intel_xe_progs = [ 'xe_dma_buf_sync', 'xe_debugfs', 'xe_drm_fdinfo', + 'xe_eudebug', 'xe_evict', 'xe_evict_ccs', 'xe_exec_atomic', --2.34.1
PATCH v2 3/66 lib/xe_eudebug: Introduce eu debug testing framework
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Introduce library which simplifies testing of eu debug capability. The library provides event log helpers together with asynchronous abstraction for client proccess and the debugger itself.
xe_eudebug_client creates its own proccess with user's work function, and gives machanisms to synchronize beginning of execution and event logging.
xe_eudebug_debugger allows to attach to the given proccess, provides asynchronous thread for event reading and introduces triggers - a callback mechanism triggered every time subscribed event was read.
--- lib/meson.build | 1 + lib/xe/xe_eudebug.c | 1191 +++++++++++++++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 143 ++++++ 3 files changed, 1335 insertions(+) create mode 100644 lib/xe/xe_eudebug.c create mode 100644 lib/xe/xe_eudebug.h
lib/meson.build +1 -0
@@ -111,6 +111,7 @@ lib_sources = [ 'igt_msm.c', 'igt_dsc.c', 'xe/xe_gt.c', + 'xe/xe_eudebug.c', 'xe/xe_ioctl.c', 'xe/xe_mmio.c', 'xe/xe_query.c',
lib/xe/xe_eudebug.c new file +1191 -0
1,191 lines not on this page · raw message
lib/xe/xe_eudebug.h new file +143 -0
143 lines not on this page · raw message
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 03/66] lib/xe_eudebug: Introduce eu debug testing framework
Comments inline.
Thanks,
Dominik Karol
Quoted 976 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 03/66]lib/xe_eudebug: Introduce eu debug testing frameworkFrom: Dominik Grzegorzek <[email protected]>
Introduce library which simplifies testing of eu debug capability. The library provides event log helpers together with asynchronous abstraction for client proccess and the debugger itself.
xe_eudebug_clientcreates its own proccess with user's work function, and gives machanisms to synchronize beginning of execution and event logging.
xe_eudebug_debuggerallows to attach to the given proccess, provides asynchronous thread for event reading and introduces triggers - a callback mechanism triggered every time subscribed event was read.Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Christoph Manszewski <[email protected]>Cc Christoph Manszewski <[email protected]>--- lib/meson.build | 1 + lib/xe/xe_eudebug.c | 1191 +++++++++++++++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 143 ++++++ 3 files changed, 1335 insertions(+) create mode 100644 lib/xe/xe_eudebug.c create mode 100644 lib/xe/xe_eudebug.hlib/meson.build index f711e60a7..969ca4101 renamed from lib/meson.build +0
-0100644
lib/meson.build +1
-0@@ -111,6 +111,7 @@ lib_sources = [ 'igt_msm.c', 'igt_dsc.c', 'xe/xe_gt.c', + 'xe/xe_eudebug.c', 'xe/xe_ioctl.c', 'xe/xe_mmio.c', 'xe/xe_query.c',lib/xe/xe_eudebug.c new file +78
-0@@ -0,0 +1,1191 @@ +// SPDX-License-Identifier: MIT +/* +* Copyright © 2023 Intel Corporation +*/ + +#include <fcntl.h> +#include <poll.h> +#include <signal.h> +#include <sys/select.h> +#include <sys/types.h> +#include <sys/wait.h> + +#include "igt.h" +#include "xe_eudebug.h" +#include "xe_ioctl.h" + +struct event_trigger { +xe_eudebug_trigger_fn fn; +int type; +struct igt_list_head link; +}; + +#define CLIENT_PID 1 +#define CLIENT_RUN 2 +#define CLIENT_FINI 3 +#define CLIENT_STOP 4 + +#define DEBUGGER_WORKER_INACTIVE 0 +#define DEBUGGER_WORKER_ACTIVE 1 +#define DEBUGGER_WORKER_QUITTING 2 + +static const char *type_to_str (unsigned int type) { +switch (type) { +case DRM_XE_EUDEBUG_EVENT_NONE : +return "none" ; +case DRM_XE_EUDEBUG_EVENT_READ : +return "read" ; +case DRM_XE_EUDEBUG_EVENT_OPEN : +return "client" ; +case DRM_XE_EUDEBUG_EVENT_VM : +return "vm" ; + } + +return "UNKNOWN" ; +} + +static const char *event_type_to_str (struct drm_xe_eudebug_event *e, +char *buf) { +sprintf (buf,"%s(%d)" ,type_to_str (e->type), e->type); + +return buf; +} + +static const char *flags_to_str (unsigned int flags) { +if (flags &DRM_XE_EUDEBUG_EVENT_CREATE ) +return "create" ; + +if (flags &DRM_XE_EUDEBUG_EVENT_DESTROY ) +return "destroy" ; + +if (flags &DRM_XE_EUDEBUG_EVENT_STATE_CHANGE ) +return "state-change" ; + +return "flags unknown" ; +} + +static const char *event_members_to_str (struct drm_xe_eudebug_event *e, +char *b) { +switch (e->type) { +case DRM_XE_EUDEBUG_EVENT_OPEN : { +struct drm_xe_eudebug_event_client *ec = (struct +drm_xe_eudebug_event_client *)e; + +sprintf (b,"handle=%llu" , ec->client_handle); +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM : { + struct drm_xe_eudebug_event_vm *evm = (struct
drm_xe_eudebug_event_vmlib/xe/xe_eudebug.c new file +113
-0+*)e; + +sprintf (b,"client_handle=%llu, handle=%llu" , + evm->client_handle, evm->vm_handle); +break ; + } +default : +strcpy (b,"<...>" ); + } + +return b; +} + +/** +* xe_eudebug_event_to_str: +* @e: pointer to event +* @buf: target to write string representation of @e +* @len: size of target buffer @buf +* +* Creates string representation for given event. +* +* Returns: the written input buffer pointed by @buf. +*/ +const char *xe_eudebug_event_to_str (struct drm_xe_eudebug_event *e, +char *buf,size_t len) { +char a[256 ]; +char b[256 ]; + +snprintf (buf, len,"(%llu) %15s:%s: %s" , + e->seqno, +event_type_to_str (e, a), +flags_to_str (e->flags), +event_members_to_str (e, b)); + +return buf; +} + +static void catch_child_failure (void ) +{ +pid_t pid; +int status; + + pid =waitpid (-1 , &status,WNOHANG ); + +if (pid ==0 || pid ==-1 ) +return ; + +if (!WIFEXITED (status)) +return ; + +igt_assert_f (WEXITSTATUS (status) ==0 ,"Client failed!\n" ); } + +static int safe_pipe_read (int pipe[2 ],void *buf,int nbytes) { +int ret; +struct pollfd fd = { + .fd = pipe[0 ], + .events =POLLIN , + .revents =0 + }; + +/* When child fails we may get stuck forever. Check whether +* the child process ended with an error. +*/ +do { + ret =poll (&fd,1 ,1000 ); + +if (!ret) +catch_child_failure (); + }while (!ret); + +return read (pipe[0 ], buf, nbytes); +} + +static uint64_t pipe_wait_u64 (int pipe[2 ]) { +uint64_t in; +uint64_t ret; + + ret =safe_pipe_read (pipe, &in,sizeof (in)); +igt_assert (ret ==sizeof (in)); + +return in; +} + +#define pipe_wait pipe_wait_u64 + +static void pipe_wait_token (int pipe[2 ],uint64_t token) { +uint64_t in; + + in =pipe_wait_u64 (pipe); +igt_assert_eq (token, in); +} + +static void pipe_signal (int pipe[2 ],uint64_t token) { +igt_assert (write (pipe[1 ], &token,sizeof (token)) ==sizeof (token)); } + +static void pipe_close (int pipe[2 ]) +{ +if (pipe[0 ] !=-1 ) +close (pipe[0 ]); + +if (pipe[1 ] !=-1 ) +close (pipe[1 ]); +} + +static int __xe_eudebug_connect (int fd,pid_t pid,uint32_t flags, +uint64_t events) { +struct drm_xe_eudebug_connect param = { + .pid = pid, + .flags = flags, + }; +int debugfd; + + debugfd = igt_ioctl(fd, DRM_IOCTL_XE_EUDEBUG_CONNECT,¶m);
lib/xe/xe_eudebug.c new file +31
-0+ +if (debugfd <0 ) +return -errno; + +return debugfd; +} + +static int xe_eudebug_connect (int fd,pid_t pid,uint32_t flags) { +int ret; +uint64_t events =0 ;/* events filtering not supported yet! */ + + ret =__xe_eudebug_connect (fd, pid, flags, events); + +return ret; +} + +static void event_log_write_to_fd (struct xe_eudebug_event_log *l,int +fd) { +igt_assert_eq (write (fd, &l->head,sizeof (l->head)), +sizeof (l->head)); + +igt_assert_eq (write (fd, l->log, l->head), l->head); } + +static void read_all(int fd, void *buf, size_t nbytes) { + ssize_t remaining_size = nbytes; + ssize_t current_size = 0; + ssize_t read_size = 0; + + do { + read_size = read(fd, buf + current_size, remaining_size); + igt_assert_f(read_size >= 0, "read failed: %s\n",strerror(errno));
lib/xe/xe_eudebug.c new file +60
-0+ + current_size += read_size; + remaining_size -= read_size; + }while (remaining_size >0 && read_size >0 ); + +igt_assert_eq (current_size, nbytes); +} + +static void event_log_read_from_fd (struct xe_eudebug_event_log *l,int +fd) { +read_all (fd, &l->head,sizeof (l->head)); +igt_assert_lt (l->head, l->max_size); + +read_all (fd, l->log, l->head); +} + +typedef int (*cmp_fn_t )(struct drm_xe_eudebug_event *,void *); + +static struct drm_xe_eudebug_event * +event_cmp (struct xe_eudebug_event_log *l, +struct drm_xe_eudebug_event *current, +cmp_fn_t match, +void *data) +{ +struct drm_xe_eudebug_event *e = current; + +xe_eudebug_for_each_event (e, l) { +if (match (e, data)) +return e; + } + +return NULL ; +} + +static int match_type_and_flags (struct drm_xe_eudebug_event *a,void +*data) { +struct drm_xe_eudebug_event *b = data; + +if (a->type == b->type && + a->flags == b->flags) +return 1 ; + +return 0 ; +} + +static int match_client_handle (struct drm_xe_eudebug_event *e,void +*data) { +uint64_t h = *(uint64_t *)data; + +switch (e->type) { +case DRM_XE_EUDEBUG_EVENT_OPEN : { +struct drm_xe_eudebug_event_client *client = (struct +drm_xe_eudebug_event_client *)e; + +if (client->client_handle == h) +return 1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM : { + struct drm_xe_eudebug_event_vm *vm = (struct
drm_xe_eudebug_event_vmlib/xe/xe_eudebug.c new file +20
-0+*)e; + +if (vm->client_handle == h) +return 1 ; +break ; + } +default : +break ; + } + +return 0 ; +} + +static int match_opposite_resource (struct drm_xe_eudebug_event *e,void +*data) { + +struct drm_xe_eudebug_event *d = (void *)data; +int ret; + + d->flags ^= DRM_XE_EUDEBUG_EVENT_CREATE |
DRM_XE_EUDEBUG_EVENT_DESTROY;lib/xe/xe_eudebug.c new file +10
-0+ ret =match_type_and_flags (e, data); + d->flags ^=DRM_XE_EUDEBUG_EVENT_CREATE | +DRM_XE_EUDEBUG_EVENT_DESTROY ; + +if (!ret) +return 0 ; + +switch (e->type) { +case DRM_XE_EUDEBUG_EVENT_OPEN : { + struct drm_xe_eudebug_event_client *client = (struct
drm_xe_eudebug_event_client*)e;lib/xe/xe_eudebug.c new file +9
-0+struct drm_xe_eudebug_event_client *filter = (struct +drm_xe_eudebug_event_client *)data; + +if (client->client_handle == filter->client_handle) +return 1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM : { + struct drm_xe_eudebug_event_vm *vm = (struct
drm_xe_eudebug_event_vm*)e;lib/xe/xe_eudebug.c new file +32
-0+struct drm_xe_eudebug_event_vm *filter = (struct +drm_xe_eudebug_event_vm *)data; + +if (vm->vm_handle == filter->vm_handle) +return 1 ; +break ; + } +default : +break ; + } +return 0 ; +} + +static struct drm_xe_eudebug_event * +event_type_match (struct xe_eudebug_event_log *l, +struct drm_xe_eudebug_event *filter, +struct drm_xe_eudebug_event *current) { +return event_cmp (l, current, match_type_and_flags, filter); } + +static struct drm_xe_eudebug_event * +client_match (struct xe_eudebug_event_log *l, +uint64_t client_handle, +struct drm_xe_eudebug_event *current) { +return event_cmp (l, current, match_client_handle, &client_handle); } + +static struct drm_xe_eudebug_event * +opposite_event_match (struct xe_eudebug_event_log *l, +struct drm_xe_eudebug_event *filter, +struct drm_xe_eudebug_event *current) { +return event_cmp (l, current, match_opposite_resource, filter); } + +static void compare_client(struct xe_eudebug_event_log *c, struct
drm_xe_eudebug_event*_ce,lib/xe/xe_eudebug.c new file +1
-0+struct xe_eudebug_event_log *d, struct
drm_xe_eudebug_event*_de)lib/xe/xe_eudebug.c new file +22
-0+{ + struct drm_xe_eudebug_event_client *ce = (void *)_ce; + struct drm_xe_eudebug_event_client *de = (void *)_de; + struct drm_xe_eudebug_event *hc, *hd; + + igt_assert(ce); + igt_assert(de); + + igt_debug("client: %llu -> %llu\n", ce->client_handle, +de->client_handle); + + hc = NULL; + hd = NULL; + + do { + hc = client_match(c, ce->client_handle, hc); + if (!hc) + break; + + hd = client_match(d, de->client_handle, hd); + + igt_assert_f(hd, "%s (%llu): no matching event type %u foundfor client %llu\n",
lib/xe/xe_eudebug.c new file +40
-0+ c->name, + hc->seqno, + hc->type, + ce->client_handle); + +igt_debug ("comparing %s %llu vs %s %llu\n" , + c->name, hc->seqno, d->name, hd->seqno); + +igt_assert_eq (hc->type, hd->type); +igt_assert_eq (hc->flags, hd->flags); + }while (hc); +} + +/** +* xe_eudebug_event_log_find_seqno: +* @l: event log pointer +* @seqno: seqno of event to be found +* +* Finds the event with given seqno in the event log. +* +* Returns: pointer to the event with given seqno within @l or NULL +seqno is +* not present. +*/ +struct drm_xe_eudebug_event * +xe_eudebug_event_log_find_seqno (struct xe_eudebug_event_log *l, +uint64_t seqno) { +struct drm_xe_eudebug_event *e =NULL , *found =NULL ; + +igt_assert_neq (seqno,0 ); +/* +* Try to catch if seqno is corrupted and prevent too long tests, +* as our post processing of events is not optimized. +*/ +igt_assert_lt (seqno,10 *1000 *1000 ); + +xe_eudebug_for_each_event (e, l) { +if (e->seqno == seqno) { +if (found) { + igt_warn("Found multiple events with thesame seqno %lu\n", seqno);
lib/xe/xe_eudebug.c new file +122
-0+xe_eudebug_event_log_print (l, false); +igt_assert (!found); + } + found = e; + } + } + +return found; +} + +static void event_log_sort (struct xe_eudebug_event_log *l) { +struct xe_eudebug_event_log *tmp; +struct drm_xe_eudebug_event *e =NULL ; +uint64_t first_seqno =0 ; +uint64_t last_seqno =0 ; +uint64_t events =0 , added =0 ; +uint64_t i; + +xe_eudebug_for_each_event (e, l) { +if (e->seqno > last_seqno) + last_seqno = e->seqno; + +if (e->seqno < first_seqno) + first_seqno = e->seqno; + + events++; + } + + tmp =xe_eudebug_event_log_create ("tmp" , l->max_size); + +for (i =1 ; i <= last_seqno; i++) { + e =xe_eudebug_event_log_find_seqno (l, i); +if (e) { +xe_eudebug_event_log_write (tmp, e); + added++; + } + } + +igt_assert_eq (events, added); +igt_assert_eq (tmp->head, l->head); + +memcpy (l->log, tmp->log, tmp->head); + +xe_eudebug_event_log_destroy (tmp); +} + +/** +* xe_eudebug_event_log_create: +* @name: event log identifier +* @max_size: maximum size of created log +* +* Function creates an Eu Debugger event log with size equal to @max_size. +* +* Returns: pointer to just created log */ #define MAX_EVENT_LOG_SIZE +(32 * 1024 * 1024) struct xe_eudebug_event_log +*xe_eudebug_event_log_create (const char *name,unsigned int max_size) { +struct xe_eudebug_event_log *l; + + l =calloc (1 ,sizeof (*l)); +igt_assert (l); + l->log =calloc (1 , max_size); +igt_assert (l->log); + l->max_size = max_size; +strncpy (l->name, name,sizeof (l->name) -1 ); + +return l; +} + +/** +* xe_eudebug_event_log_destroy: +* @l: event log pointer +* +* Frees given event log @l. +*/ +void xe_eudebug_event_log_destroy (struct xe_eudebug_event_log *l) { +free (l->log); +free (l); +} + +/** +* xe_eudebug_event_log_write: +* @l: event log pointer +* @e: event to be written to event log +* +* Writes event @e to the event log. +*/ +void xe_eudebug_event_log_write (struct xe_eudebug_event_log *l,struct +drm_xe_eudebug_event *e) { +igt_assert (e->seqno); +/* +* Try to catch if seqno is corrupted and prevent too long tests, +* as our post processing of events is not optimized. +*/ +igt_assert_lt (e->seqno,10 *1000 *1000 ); + +igt_assert_lt (l->head + e->len, l->max_size); +memcpy (l->log + l->head, e, e->len); + l->head += e->len; + +#ifdef DEBUG_LOG +igt_info ("%s: wrote %u bytes to eventlog, free %u bytes\n" , + l->name, e->len, l->max_size - l->head);#endif } + +/** +* xe_eudebug_event_log_print: +* @l: event log pointer +* @debug: when true function uses igt_debug instead of igt_info. +* +* Prints given event log. +*/ +void +xe_eudebug_event_log_print (struct xe_eudebug_event_log *l,bool debug) +{ +struct drm_xe_eudebug_event *e =NULL ; +int level = debug ?IGT_LOG_DEBUG :IGT_LOG_INFO ; +char str[XE_EUDEBUG_EVENT_STRING_MAX_LEN ]; + +igt_log (IGT_LOG_DOMAIN , level, +"event log '%s' (%u bytes):\n" , l->name, l->head); + +xe_eudebug_for_each_event (e, l) { + xe_eudebug_event_to_str(e, str,
XE_EUDEBUG_EVENT_STRING_MAX_LEN);lib/xe/xe_eudebug.c new file +42
-0+igt_log (IGT_LOG_DOMAIN , level,"%s\n" , str); + } +} + +/** +* xe_eudebug_event_log_compare: +* @a: event log pointer +* @b: event log pointer +* +* Compares and asserts event logs @a, @b if the event +* sequence matches. +*/ +void xe_eudebug_event_log_compare (struct xe_eudebug_event_log *a, +struct xe_eudebug_event_log *b) { +struct drm_xe_eudebug_event *ae =NULL ; +struct drm_xe_eudebug_event *be =NULL ; + +xe_eudebug_for_each_event (ae, a) { +if (ae->type ==DRM_XE_EUDEBUG_EVENT_OPEN && + ae->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { + be =event_type_match (b, ae, be); + +compare_client (a, ae, b, be); +compare_client (b, be, a, ae); + } + } +} + +/** +* xe_eudebug_event_log_match_opposite: +* @l: event log pointer +* +* Matches and asserts content of all opposite events (create vs destroy). +*/ +void +xe_eudebug_event_log_match_opposite (struct xe_eudebug_event_log *l) { +struct drm_xe_eudebug_event *ce =NULL ; +struct drm_xe_eudebug_event *de =NULL ; + +xe_eudebug_for_each_event (ce, l) { +if (ce->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { + uint8_t offset = sizeof(struct
drm_xe_eudebug_event);lib/xe/xe_eudebug.c new file +5
-0+int opposite_matching; + + de =opposite_event_match (l, ce, ce); + + igt_assert_f(de, "no opposite event of type %ufound\n",
ce->type);lib/xe/xe_eudebug.c new file +72
-0+ +igt_assert_eq (ce->len, de->len); + opposite_matching =memcmp ((uint8_t *)de + offset, + (uint8_t *)ce + offset, + de->len - offset) ==0 ; + +igt_assert_f (opposite_matching, +"%s: create|destroy event not " +"maching (%llu) vs (%llu)\n" , + l->name, de->seqno, ce->seqno); + } + } +} + +static void debugger_run_triggers (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct event_trigger *t; + +igt_list_for_each_entry (t, &d->triggers, link) { +if (e->type == t->type) + t->fn (d, e); + } +} + +#define MAX_EVENT_SIZE (32 * 1024) +static int +xe_eudebug_read_event (int fd,struct drm_xe_eudebug_event *event) { +int ret; + + event->type =DRM_XE_EUDEBUG_EVENT_READ ; + event->flags =0 ; + event->len =MAX_EVENT_SIZE ; + + ret =igt_ioctl (fd,DRM_XE_EUDEBUG_IOCTL_READ_EVENT , event); +if (ret <0 ) +return -errno; + +return ret; +} + +static void *debugger_worker_loop (void *data) { +uint8_t buf[MAX_EVENT_SIZE ]; +struct drm_xe_eudebug_event *e = (void *)buf; +struct xe_eudebug_debugger *d = data; +struct pollfd p = { + .events =POLLIN , + .revents =0 , + }; +int timeout_ms =100 , ret; + +igt_assert (d->master_fd >=0 ); + + do { + p.fd = d->fd; + ret = poll(&p, 1, timeout_ms); + + if (ret == -1) { + igt_info("poll failed with errno %d\n", errno); + break; + } + + if (ret == 1 && (p.revents & POLLIN)) { + int err = xe_eudebug_read_event(d->fd, e); + + if (!err) { + ++d->event_count; + + xe_eudebug_event_log_write(d->log, e); + debugger_run_triggers(d, e); + } else { + igt_info("xe_eudebug_read_event returned%d\n", ret);
lib/xe/xe_eudebug.c new file +3
-0+ } + } + } while ((ret && READ_ONCE(d->worker_state) ==
DEBUGGER_WORKER_QUITTING) ||lib/xe/xe_eudebug.c new file +1
-0+ READ_ONCE(d->worker_state) ==
DEBUGGER_WORKER_ACTIVE);lib/xe/xe_eudebug.c new file +27
-0+ + d->worker_state =DEBUGGER_WORKER_INACTIVE ; +return NULL ; +} + +/** +* xe_eudebug_debugger_create: +* @master_fd: xe client used to open the debugger connection +* @flags: flags stored in a debugger structure, can be used at will +* of the caller, i.e. to be used inside triggers. +* @data: test's private data, allocated with MAP_SHARED | +MAP_ANONYMOUS, +* can be shared between client and debugger. Can be NULL. +* +* Returns: newly created xe_eudebug_debugger structure with its +* event log initialized. Note that to open the connection +* you need call @xe_eudebug_debugger_attach. +*/ +struct xe_eudebug_debugger * +xe_eudebug_debugger_create (int master_fd,uint64_t flags,void *data) { +struct xe_eudebug_debugger *d; + + d =calloc (1 ,sizeof (*d)); + d->flags = flags; +igt_assert (d); +IGT_INIT_LIST_HEAD (&d->triggers); + d->log = xe_eudebug_event_log_create("debugger",
MAX_EVENT_LOG_SIZE);lib/xe/xe_eudebug.c new file +112
-0+ d->fd =-1 ; + d->master_fd = master_fd; + d->ptr = data; + +return d; +} + +static void debugger_destroy_triggers (struct xe_eudebug_debugger *d) { +struct event_trigger *t, *tmp; + +igt_list_for_each_entry_safe (t, tmp, &d->triggers, link) +free (t); +} + +/** +* xe_eudebug_debugger_destroy: +* @d: pointer to the debugger +* +* Frees xe_eudebug_debugger structure pointed by @d. If the debugger +* connection was still opened it terminates it. +*/ +void xe_eudebug_debugger_destroy (struct xe_eudebug_debugger *d) { +if (d->worker_state) +xe_eudebug_debugger_stop_worker (d,1 ); + +if (d->target_pid) +xe_eudebug_debugger_dettach (d); + +xe_eudebug_event_log_destroy (d->log); +debugger_destroy_triggers (d); +free (d); +} + +/** +* xe_eudebug_debugger_attach: +* @d: pointer to the debugger +* @target: pid of the process to attach debugger +* +* Opens the xe eu debugger connection to the @target proccess. +* +* Returns: 0 if the debugger was successfully attached, -errno otherwise. +*/ +int xe_eudebug_debugger_attach (struct xe_eudebug_debugger *d,pid_t +target) { +int ret; + +igt_assert_eq (d->fd,-1 ); + ret =xe_eudebug_connect (d->master_fd, target,0 ); + +if (ret <0 ) +return ret; + + d->fd = ret; + d->target_pid = target; + +igt_debug ("debugger connected to %lu\n" , d->target_pid); + +return 0 ; +} + +/** +* xe_eudebug_debugger_dettach: +* @d: pointer to the debugger +* +* Closes previously opened xe eu debugger connection. Asserts if +* the debugger has active session. +*/ +void xe_eudebug_debugger_dettach (struct xe_eudebug_debugger *d) { +igt_assert (d->target_pid); +close (d->fd); + d->target_pid =0 ; + d->fd =-1 ; +} + +/** +* xe_eudebug_debugger_add_trigger: +* @d: pointer to the debugger +* @type: the type of the event which activates the trigger +* @fn: function to be called when event of @type was read by the debugger. +* +* Adds function @fn to the list of triggers activated when event of +@type +* has been read by worker. +* Note: Triggers are activated by the worker. +*/ +void xe_eudebug_debugger_add_trigger (struct xe_eudebug_debugger *d, +int type,xe_eudebug_trigger_fn fn) { +struct event_trigger *t; + + t =calloc (1 ,sizeof (*t)); +IGT_INIT_LIST_HEAD (&t->link); + t->type = type; + t->fn = fn; + +igt_list_add_tail (&t->link, &d->triggers); +igt_debug ("added trigger %p\n" , t); +} + +/** +* xe_eudebug_debugger_start_worker: +* @d: pointer to the debugger +* +* Starts the debugger worker. Worker is resposible for reading all +* incoming events from the debugger, put then into debugger log and +* execute appropriate event triggers. Note that using the debuggers +* event log while worker is running is not safe. +*/ +void xe_eudebug_debugger_start_worker (struct xe_eudebug_debugger *d) { +int ret; + + d->worker_state = true; + ret = pthread_create(&d->worker_thread, NULL,
&debugger_worker_loop,lib/xe/xe_eudebug.c new file +19
-0+d); + +igt_assert_f (ret ==0 ,"Debugger worker thread creation failed!" ); } + +/** +* xe_eudebug_debugger_stop_worker: +* @d: pointer to the debugger +* +* Stops the debugger worker. Event log is sorted by seqno after closure. +*/ +void xe_eudebug_debugger_stop_worker (struct xe_eudebug_debugger *d, +int timeout_s) +{ +struct timespec t = {}; +int ret; + +igt_assert (d->worker_state); + + d->worker_state =DEBUGGER_WORKER_QUITTING ;/* First time be polite. */
lib/xe/xe_eudebug.c new file +34
-0+igt_assert_eq (clock_gettime (CLOCK_REALTIME , &t),0 ); + t.tv_sec += timeout_s; + + ret =pthread_timedjoin_np (d->worker_thread,NULL , &t); + +if (ret ==ETIMEDOUT ) { + d->worker_state =DEBUGGER_WORKER_INACTIVE ; + ret =pthread_join (d->worker_thread,NULL ); + } + +igt_assert_f (ret ==0 || ret !=ESRCH , +"pthread join failed with error %d!\n" , ret); + +event_log_sort (d->log); +} + +/** +* xe_eudebug_client_create: +* @master_fd: xe client used to open the debugger connection +* @work: function that opens xe device and executes arbitrary workload +* @flags: flags stored in a client structure, can be used at will +* of the caller, i.e. to provide the @work function an additional switch. +* @data: test's private data, allocated with MAP_SHARED | +MAP_ANONYMOUS, +* can be shared between client and debugger. Accesible via client->ptr. +* Can be NULL. +* +* Forks and creates the debugger process. @work won't be called until +* xe_eudebug_client_start is called. +* +* Returns: newly created xe_eudebug_debugger structure with its +* event log initialized. +*/ +struct xe_eudebug_client *xe_eudebug_client_create(int master_fd,
xe_eudebug_client_work_fnwork,lib/xe/xe_eudebug.c new file +11
-0+ uint64_t flags, void *data) +{ + struct xe_eudebug_client *c; + + c =calloc (1 ,sizeof (*c)); + c->flags = flags; +igt_assert (c); +igt_assert (!pipe (c->p_in)); +igt_assert (!pipe (c->p_out)); + c->seqno =1 ; + c->log = xe_eudebug_event_log_create("client",
MAX_EVENT_LOG_SIZE);lib/xe/xe_eudebug.c new file +31
-0+ c->done =0 ; + c->ptr = data; + c->master_fd = master_fd; + + igt_fork(child, 1) { +igt_assert_eq (c->pid,0 ); + +close (c->p_out[0 ]); + c->p_out[0 ] =-1 ; +close (c->p_in[1 ]); + c->p_in[1 ] =-1 ; + +pipe_signal (c->p_out,CLIENT_PID ); +pipe_signal (c->p_out,getpid ()); + +pipe_wait_token (c->p_in,CLIENT_RUN ); +work (c); +pipe_signal (c->p_out,CLIENT_FINI ); + +igt_assert_eq (c->pid,0 ); +event_log_write_to_fd (c->log, c->p_out[1 ]); +pipe_signal (c->p_out, c->seqno); +pipe_wait_token (c->p_in,CLIENT_STOP ); + } + +close (c->p_out[1 ]); + c->p_out[1 ] =-1 ; +close (c->p_in[0 ]); + c->p_in[0 ] =-1 ; + +pipe_wait_token (c->p_out,CLIENT_PID );
lib/xe/xe_eudebug.c line 925
Quoted 10 lines
lib/xe/xe_eudebug.c new file +10
-0+ c->pid =pipe_wait (c->p_out); + +igt_info ("client running with pid %d\n" , c->pid); + +return c; +} + +/** +* xe_eudebug_client_stop: +* @c: pointer to xe_eudbug_client structure
Typo: xe_eudebug_client
Quoted 9 lines
+ *
+ * Waits for the end of client's work and exits the proccess.
+ */lib/xe/xe_eudebug.c new file +6
-0+void xe_eudebug_client_stop (struct xe_eudebug_client *c) { +if (c->pid) { +int waitstatus; + +xe_eudebug_client_wait_done (c); +
lib/xe/xe_eudebug.c line 945
Quoted 10 lines
lib/xe/xe_eudebug.c new file +10
-0+pipe_signal (c->p_in,CLIENT_STOP ); +igt_assert_eq (waitpid (c->pid, &waitstatus,0 ), + c->pid); + c->pid =0 ; + } +} + +/** +* xe_eudebug_client_destroy: +* @c: pointer to xe_eudbug_client structure to be freed
Typo: xe_eudebug_client
Quoted 6 lines
+ *
+ * Frees the @c client structure. Note that it callslib/xe/xe_eudebug.c new file +4
-0+xe_eudebug_client_stop if +* client proccess has not terminated yet. +*/ +void xe_eudebug_client_destroy (struct xe_eudebug_client *c) {
lib/xe/xe_eudebug.c line 961
Quoted 10 lines
lib/xe/xe_eudebug.c new file +10
-0+xe_eudebug_client_stop (c); +pipe_close (c->p_in); +pipe_close (c->p_out); +xe_eudebug_event_log_destroy (c->log); +free (c); +} + +/** +* xe_eudebug_client_get_seqno: +* @c: pointer to xe_eudbug_client structure
Typo: xe_eudebug_client
Quoted 385 lines
+ *
+ * Increments and returns current seqno value of the given client @c
+ *
+ * Returns: incremented seqno
+ */lib/xe/xe_eudebug.c new file +43
-0+uint64_t xe_eudebug_client_get_seqno (struct xe_eudebug_client *c) { +return c->seqno++; +} + +/** +* xe_eudebug_client_start: +* @c: pointer to xe_eudebug_client structure +* +* Starts execution of client's work function within the client's proccess. +*/ +void xe_eudebug_client_start (struct xe_eudebug_client *c) { +pipe_signal (c->p_in,CLIENT_RUN ); +} + +/** +* xe_eudebug_client_wait_done: +* @c: pointer to xe_eudebug_client structure +* +* Waits for the client work end updates the event log. +* Doesn't terminate the client's proccess yet. +*/ +void xe_eudebug_client_wait_done (struct xe_eudebug_client *c) { +if (!c->done) { + c->done =1 ; +pipe_wait_token (c->p_out,CLIENT_FINI ); +event_log_read_from_fd (c->log, c->p_out[0 ]); + c->seqno =pipe_wait (c->p_out); + } +} + +/** +* xe_eudebug_session_create: +* @fd: XE file descriptor +* @work: function passed to the xe_eudebug_client_create +* @flags: flags passed to client and debugger +* @test_private: test's data, allocated with MAP_SHARED | +MAP_ANONYMOUS, +* passed to client and debugger. Can be NULL. +* +* Creates session together with client and debugger structures. +*/ +struct xe_eudebug_session *xe_eudebug_session_create(int fd, +
xe_eudebug_client_work_fnwork,lib/xe/xe_eudebug.c new file +28
-0+unsigned int flags, + void *test_private) +{ + struct xe_eudebug_session *s; + + s =calloc (1 ,sizeof (*s)); +igt_assert (s); + + s->c =xe_eudebug_client_create (fd, work, flags, test_private); + s->d =xe_eudebug_debugger_create (fd, flags, test_private); + s->flags = flags; + +return s; +} + +/** +* xe_eudebug_session_run: +* @s: pointer to xe_eudebug_session structure +* +* Attaches debugger to client's proccess, starts debugger's +* async event reader, starts client and once client finish +* it stops debugger worker. +*/ +void xe_eudebug_session_run (struct xe_eudebug_session *s) { +struct xe_eudebug_debugger *debugger = s->d; +struct xe_eudebug_client *client = s->c; + + igt_assert_eq(xe_eudebug_debugger_attach(debugger, client->pid),0);
lib/xe/xe_eudebug.c new file +147
-0+ +xe_eudebug_debugger_start_worker (debugger); + +xe_eudebug_client_start (client); +xe_eudebug_client_wait_done (client); + +xe_eudebug_debugger_stop_worker (debugger,1 ); + +xe_eudebug_event_log_print (debugger->log, true); +xe_eudebug_event_log_print (client->log, true); } + +/** +* xe_eudebug_session_check: +* @s: pointer to xe_eudebug_session structure +* @match_opposite: indicates whether check should match all +* create and destroy events. +* +* Validate debugger's log against the log created by the client. +*/ +void xe_eudebug_session_check (struct xe_eudebug_session *s,bool +match_opposite) { +xe_eudebug_event_log_compare (s->c->log, s->d->log); + +if (match_opposite) +xe_eudebug_event_log_match_opposite (s->d->log); +} + +/** +* xe_eudebug_session_destroy: +* @s: pointer to xe_eudebug_session structure +* +* Destroy session together with its debugger and client. +*/ +void xe_eudebug_session_destroy (struct xe_eudebug_session *s) { +xe_eudebug_debugger_destroy (s->d); +xe_eudebug_client_destroy (s->c); + +free (s); +} + +#define to_base (x) ((struct drm_xe_eudebug_event *)&x) + +static void base_event (struct xe_eudebug_client *c, +struct drm_xe_eudebug_event *e, +uint32_t type, +uint32_t flags, +uint64_t size) +{ + e->type = type; + e->flags = flags; + e->seqno =xe_eudebug_client_get_seqno (c); + e->len = size; +} + +static void client_event (struct xe_eudebug_client *c,uint32_t flags, +int client_fd) { +struct drm_xe_eudebug_event_client ec; + +base_event (c,to_base (ec),DRM_XE_EUDEBUG_EVENT_OPEN , flags, +sizeof (ec)); + + ec.client_handle = client_fd; + +xe_eudebug_event_log_write (c->log, (void *)&ec); } + +static void vm_event (struct xe_eudebug_client *c,uint32_t flags,int +client_fd,uint32_t vm_id) { +struct drm_xe_eudebug_event_vm evm; + +base_event (c,to_base (evm),DRM_XE_EUDEBUG_EVENT_VM , flags, +sizeof (evm)); + + evm.client_handle = client_fd; + evm.vm_handle = vm_id; + +xe_eudebug_event_log_write (c->log, (void *)&evm); } + +/* Eu debugger wrappers around resource creating xe ioctls. */ + +/** +* xe_eudebug_client_open_driver: +* @c: pointer to xe_eudebug_client structure +* +* Calls drm_open_client(DRIVER_XE) and logs the corresponding +* event in client's event log. +* +* Returns: valid DRM file descriptor +*/ +int xe_eudebug_client_open_driver (struct xe_eudebug_client *c) { +int fd; + + fd =drm_reopen_driver (c->master_fd); +client_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , fd); + +return fd; +} + +/** +* xe_eudebug_client_close_driver: +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* +* Calls close driver and logs the corresponding event in +* client's event log. +*/ +void xe_eudebug_client_close_driver (struct xe_eudebug_client *c,int +fd) { +client_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , fd); +close (fd); +} + +/** +* xe_eudebug_client_vm_create: +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @flags: vm bind flags +* @ext: pointer to the first user extension +* +* Calls xe_vm_create() and logs the corresponding event in +* client's event log. +* +* Returns: valid vm handle +*/ +uint32_t xe_eudebug_client_vm_create (struct xe_eudebug_client *c,int fd, +uint32_t flags,uint64_t ext) +{ +uint32_t vm; + + vm =xe_vm_create (fd, flags, ext); +vm_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , fd, vm); + +return vm; +} + +/** +* xe_eudebug_client_vm_destroy: +* @c: pointer to xe_eudebug_client structure +* fd: xe client +* vm: vm handle +* +* Calls xe_vm_destroy() and logs the corresponding event in +* client's event log. +*/ +void xe_eudebug_client_vm_destroy (struct xe_eudebug_client *c,int fd, +uint32_t vm) { +xe_vm_destroy (fd, vm); +vm_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , fd, vm); }lib/xe/xe_eudebug.h new file +75
-0@@ -0,0 +1,143 @@ +/* SPDX-License-Identifier: MIT */ +/* +* Copyright © 2023 Intel Corporation +*/ +#include <fcntl.h> +#include <pthread.h> +#include <stdint.h> +#include <xe_drm.h> + +#include "igt_list.h" + +struct xe_eudebug_event_log { +uint8_t *log; +unsigned int head; +unsigned int max_size; +char name[80 ]; +}; + +struct xe_eudebug_debugger { +int fd; +uint64_t flags; + +/* Used to smuggle private data */ +void *ptr; + +struct xe_eudebug_event_log *log; + +uint64_t event_count; + +uint64_t target_pid; + +struct igt_list_head triggers; + +int master_fd; + +pthread_t worker_thread; +int worker_state; + +}; + +struct xe_eudebug_client { +int pid; +uint64_t seqno; +uint64_t flags; + +/* Used to smuggle private data */ +void *ptr; + +struct xe_eudebug_event_log *log; + +int done; +int p_in[2 ]; +int p_out[2 ]; + +/* Used to pickup right device (the one used in debugger) */ +int master_fd; +}; + +struct xe_eudebug_session { +uint64_t flags; +struct xe_eudebug_client *c; +struct xe_eudebug_debugger *d; +}; + +typedef void (*xe_eudebug_client_work_fn )(struct xe_eudebug_client *); +typedef void (*xe_eudebug_trigger_fn )(struct xe_eudebug_debugger *, +struct drm_xe_eudebug_event *); + +#define xe_eudebug_for_each_event (_e, _log) \ + for ((_e) = (_e) ? (void *)(uint8_t *)(_e) + (_e)->len : \ + (void *)(_log)->log; \ + (uint8_t *)(_e) < (_log)->log + (_log)->head; \ + (_e) = (void *)(uint8_t *)(_e) + (_e)->len) + +#define xe_eudebug_assert (d, c)\lib/xe/xe_eudebug.h new file +42
-0+do { \ +if (!(c)) { \ +xe_eudebug_event_log_print ((d)->log, true); \ +igt_assert (c); \ + } \ + } while (0) + +#define xe_eudebug_assert_f(d, c, f...) \ + do { \ + if (!(c)) { \ + xe_eudebug_event_log_print((d)->log, true); \ + igt_assert_f(c, f); \ + } \ + } while (0) + +#define XE_EUDEBUG_EVENT_STRING_MAX_LEN 4096 + +/* +* Default abort timeout to use across xe_eudebug lib and tests if no +specific +* timeout value is required. +*/ +#define XE_EUDEBUG_DEFAULT_TIMEOUT_MS 25000ULL + +const char *xe_eudebug_event_to_str (struct drm_xe_eudebug_event *e, +char *buf,size_t len);struct drm_xe_eudebug_event * +xe_eudebug_event_log_find_seqno (struct xe_eudebug_event_log *l, +uint64_t seqno);struct xe_eudebug_event_log * +xe_eudebug_event_log_create (const char *name,unsigned int max_size); +void xe_eudebug_event_log_destroy (struct xe_eudebug_event_log *l);void +xe_eudebug_event_log_print (struct xe_eudebug_event_log *l,bool debug); +void xe_eudebug_event_log_compare (struct xe_eudebug_event_log *c, +struct xe_eudebug_event_log *d);void xe_eudebug_event_log_write (struct +xe_eudebug_event_log *l,struct drm_xe_eudebug_event *e);void +xe_eudebug_event_log_match_opposite (struct xe_eudebug_event_log *l); + +struct xe_eudebug_debugger * +xe_eudebug_debugger_create (int xe,uint64_t flags,void *data);void +xe_eudebug_debugger_destroy (struct xe_eudebug_debugger *d);int +xe_eudebug_debugger_attach (struct xe_eudebug_debugger *d,pid_t pid); +void xe_eudebug_debugger_start_worker (struct xe_eudebug_debugger *d); +void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,int
+timeout_s); void xe_eudebug_debugger_dettach(structxe_eudebug_debuggerlib/xe/xe_eudebug.h new file +2
-0+*d); void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, +void *ptr); void xe_eudebug_debugger_add_trigger(struct
xe_eudebug_debugger*d, int type,lib/xe/xe_eudebug.h new file +21
-0+ xe_eudebug_trigger_fn fn); + +struct xe_eudebug_client * +xe_eudebug_client_create (int xe,xe_eudebug_client_work_fn work, +uint64_t flags,void *data);void xe_eudebug_client_destroy (struct +xe_eudebug_client *c);void xe_eudebug_client_start (struct +xe_eudebug_client *c);void xe_eudebug_client_stop (struct +xe_eudebug_client *c);void xe_eudebug_client_wait_done (struct +xe_eudebug_client *c);uint64_t xe_eudebug_client_get_seqno (struct +xe_eudebug_client *c);void xe_eudebug_client_set_data (struct +xe_eudebug_client *c,void *ptr); + +int xe_eudebug_client_open_driver (struct xe_eudebug_client *c);void +xe_eudebug_client_close_driver (struct xe_eudebug_client *c,int fd); +uint32_t xe_eudebug_client_vm_create (struct xe_eudebug_client *c,int fd, +uint32_t flags,uint64_t ext);void +xe_eudebug_client_vm_destroy (struct xe_eudebug_client *c,int fd, +uint32_t vm); + +struct xe_eudebug_session *xe_eudebug_session_create(int fd, +
xe_eudebug_client_work_fnwork,lib/xe/xe_eudebug.h new file +7
-1+unsigned int flags, + void *test_private); +void xe_eudebug_session_destroy (struct xe_eudebug_session *s);void +xe_eudebug_session_run (struct xe_eudebug_session *s);void +xe_eudebug_session_check (struct xe_eudebug_session *s,bool +match_opposite); + --2.34.1
PATCH v2 4/66 lib/xe_eudebug: Allow client to wait for debugger
In reply to Christoph ManszewskiFrom: Mika Kuoppala <[email protected]>
In some tests, we need to pause the client into a certain stage it has setup so that debugger can then examine that setup and crosscheck.
Add a possibility to pause client and debugger to signal continuation.
We need to take into account that the debugger might disappear before signaling continuation so a timeout mechanism for all pipe token reads needs to be added.
--- lib/xe/xe_eudebug.c | 159 +++++++++++++++++++++++++++++++++----------- lib/xe/xe_eudebug.h | 8 ++- 2 files changed, 129 insertions(+), 38 deletions(-)
lib/xe/xe_eudebug.c +122 -37
@@ -24,6 +24,7 @@ struct event_trigger {#define CLIENT_RUN 2#define CLIENT_FINI 3#define CLIENT_STOP 4 +#define CLIENT_STAGE 5#define DEBUGGER_WORKER_INACTIVE 0#define DEBUGGER_WORKER_ACTIVE 1
@@ -129,9 +130,10 @@ static void catch_child_failure(void)igt_assert_f (WEXITSTATUS (status) ==0 ,"Client failed!\n" ); } -static int safe_pipe_read (int pipe[2 ],void *buf,int nbytes) +static int safe_pipe_read (int pipe[2 ],void *buf,int nbytes,int timeout_ms) {int ret; +int t =0 ;struct pollfd fd = { .fd = pipe[0 ], .events =POLLIN ,
@@ -142,36 +144,33 @@ static int safe_pipe_read(int pipe[2], void *buf, int nbytes)* the child process ended with an error. */ do { - ret =poll (&fd,1 ,1000 ); +const int interval_ms =1000 ; -if (!ret) + ret =poll (&fd,1 , interval_ms); + +if (!ret) {catch_child_failure (); - }while (!ret); + t += interval_ms; + } + }while (!ret && t < timeout_ms); -return read (pipe[0 ], buf, nbytes); +if (ret >0 ) +return read (pipe[0 ], buf, nbytes); + +return 0 ; } -static uint64_t pipe_wait_u64 (int pipe[2 ]) +static uint64_t pipe_read (int pipe[2 ],int timeout_ms) {uint64_t in;uint64_t ret; - ret =safe_pipe_read (pipe, &in,sizeof (in)); + ret =safe_pipe_read (pipe, &in,sizeof (in), timeout_ms);igt_assert (ret ==sizeof (in));return in; } -#define pipe_wait pipe_wait_u64 - -static void pipe_wait_token (int pipe[2 ],uint64_t token) -{ -uint64_t in; - - in =pipe_wait_u64 (pipe); -igt_assert_eq (token, in); -} -static void pipe_signal (int pipe[2 ],uint64_t token) {igt_assert (write (pipe[1 ], &token,sizeof (token)) ==sizeof (token));
@@ -186,6 +185,42 @@ static void pipe_close(int pipe[2])close (pipe[1 ]); } +static uint64_t __wait_token (int p[2 ],const uint64_t token,int timeout_ms) +{ +uint64_t in; + + in =pipe_read (p, timeout_ms); + +igt_assert_eq (in, token); + +return pipe_read (p, timeout_ms); +} + +static uint64_t client_wait_token (struct xe_eudebug_client *c, +const uint64_t token) +{ +return __wait_token (c->p_in, token, c->timeout_ms); +} + +static uint64_t wait_from_client (struct xe_eudebug_client *c, +const uint64_t token) +{ +return __wait_token (c->p_out, token, c->timeout_ms); +} + +static void token_signal (int p[2 ],const uint64_t token,const uint64_t value) +{ +pipe_signal (p, token); +pipe_signal (p, value); +} + +static void client_signal (struct xe_eudebug_client *c, +const uint64_t token, +const uint64_t value) +{ +token_signal (c->p_out, token, value); +} +static int __xe_eudebug_connect (int fd,pid_t pid,uint32_t flags,uint64_t events) {struct drm_xe_eudebug_connect param = {
@@ -741,24 +776,28 @@ void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)/** * xe_eudebug_debugger_attach: * @d: pointer to the debugger -* @target: pid of the process to attach debugger +* @c: pointer to the client * -* Opens the xe eu debugger connection to the @target proccess. +* Opens the xe eu debugger connection to the process described by @c (c->pid) * * Returns: 0 if the debugger was successfully attached, -errno otherwise. */ -int xe_eudebug_debugger_attach (struct xe_eudebug_debugger *d,pid_t target) +int xe_eudebug_debugger_attach (struct xe_eudebug_debugger *d, +struct xe_eudebug_client *c) {int ret;igt_assert_eq (d->fd,-1 ); - ret =xe_eudebug_connect (d->master_fd, target,0 ); +igt_assert_neq (c->pid,0 ); + ret =xe_eudebug_connect (d->master_fd, c->pid,0 );if (ret <0 )return ret; d->fd = ret; - d->target_pid = target; + d->target_pid = c->pid; + d->p_client[0 ] = c->p_in[0 ]; + d->p_client[1 ] = c->p_in[1 ];igt_debug ("debugger connected to %lu\n" , d->target_pid);
@@ -854,6 +893,19 @@ void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d,event_log_sort (d->log); } +/** +* xe_eudebug_debugger_signal_stage: +* @d: pointer to the debugger +* @stage: stage to signal +* +* Signals to client, waiting in xe_eudebug_client_wait_stage(), +* releasing it to proceed. +*/ +void xe_eudebug_debugger_signal_stage (struct xe_eudebug_debugger *d,uint64_t stage) +{ +token_signal (d->p_client,CLIENT_STAGE , stage); +} +/** * xe_eudebug_client_create: * @master_fd: xe client used to open the debugger connection
@@ -885,8 +937,11 @@ 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_MS ; igt_fork(child, 1) { +int mypid; +igt_assert_eq (c->pid,0 );close (c->p_out[0 ]);
@@ -894,17 +949,20 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cliclose (c->p_in[1 ]); c->p_in[1 ] =-1 ; -pipe_signal (c->p_out,CLIENT_PID ); -pipe_signal (c->p_out,getpid ()); + mypid =getpid (); +client_signal (c,CLIENT_PID , mypid); -pipe_wait_token (c->p_in,CLIENT_RUN ); -work (c); -pipe_signal (c->p_out,CLIENT_FINI ); + c->pid =client_wait_token (c,CLIENT_RUN ); +igt_assert_eq (c->pid, mypid); +if (work) +work (c); + +client_signal (c,CLIENT_FINI , c->seqno); -igt_assert_eq (c->pid,0 );event_log_write_to_fd (c->log, c->p_out[1 ]); -pipe_signal (c->p_out, c->seqno); -pipe_wait_token (c->p_in,CLIENT_STOP ); + + c->pid =client_wait_token (c,CLIENT_STOP ); +igt_assert_eq (c->pid, mypid); }close (c->p_out[1 ]);
@@ -912,8 +970,7 @@ struct xe_eudebug_client *xe_eudebug_client_create(int master_fd, xe_eudebug_cliclose (c->p_in[0 ]); c->p_in[0 ] =-1 ; -pipe_wait_token (c->p_out,CLIENT_PID ); - c->pid =pipe_wait (c->p_out); + c->pid =wait_from_client (c,CLIENT_PID );igt_info ("client running with pid %d\n" , c->pid);
@@ -933,7 +990,7 @@ void xe_eudebug_client_stop(struct xe_eudebug_client *c)xe_eudebug_client_wait_done (c); -pipe_signal (c->p_in,CLIENT_STOP ); +token_signal (c->p_in,CLIENT_STOP , c->pid);igt_assert_eq (waitpid (c->pid, &waitstatus,0 ), c->pid); c->pid =0 ;
@@ -977,7 +1034,7 @@ uint64_t xe_eudebug_client_get_seqno(struct xe_eudebug_client *c)*/ void xe_eudebug_client_start (struct xe_eudebug_client *c) { -pipe_signal (c->p_in,CLIENT_RUN ); +token_signal (c->p_in,CLIENT_RUN , c->pid); }/**
@@ -991,12 +1048,40 @@ void xe_eudebug_client_wait_done(struct xe_eudebug_client *c) {if (!c->done) { c->done =1 ; -pipe_wait_token (c->p_out,CLIENT_FINI ); + c->seqno =wait_from_client (c,CLIENT_FINI );event_log_read_from_fd (c->log, c->p_out[0 ]); - c->seqno =pipe_wait (c->p_out); } } +/** +* xe_eudebug_client_wait_stage: +* @c: pointer to xe_eudebug_client structure +* @stage: stage to wait on +* +* Pauses client until the debugger has signalled the corresponding stage with +* xe_eudebug_debugger_signal_stage. This is only for situations where the +* actual event flow is not enough to coordinate between client/debugger and extra +* sync mechanism is needed. +* +*/ +void xe_eudebug_client_wait_stage (struct xe_eudebug_client *c,uint64_t stage) +{ +u64 stage_in; + +if (c->done) { +igt_warn ("client: %d already done before %lu\n" , c->pid, stage); +return ; + } + +igt_debug ("client: %d pausing for stage %lu\n" , c->pid, stage); + + stage_in =client_wait_token (c,CLIENT_STAGE ); +igt_debug ("client: %d stage %lu, expected %lu, stage\n" , c->pid, stage_in, stage); + +igt_assert_eq (stage_in, stage); +} + +/** * xe_eudebug_session_create: * @fd: XE file descriptor
@@ -1037,7 +1122,7 @@ void xe_eudebug_session_run(struct xe_eudebug_session *s)struct xe_eudebug_debugger *debugger = s->d;struct xe_eudebug_client *client = s->c; -igt_assert_eq (xe_eudebug_debugger_attach (debugger, client->pid),0 ); +igt_assert_eq (xe_eudebug_debugger_attach (debugger, client),0 );xe_eudebug_debugger_start_worker (debugger);
lib/xe/xe_eudebug.h +7 -1
@@ -36,6 +36,7 @@ struct xe_eudebug_debugger {pthread_t worker_thread;int worker_state; +int p_client[2 ]; };struct xe_eudebug_client {
@@ -54,6 +55,8 @@ struct xe_eudebug_client {/* Used to pickup right device (the one used in debugger) */ int master_fd; + +int timeout_ms; };struct xe_eudebug_session {
@@ -110,13 +113,14 @@ void xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l);struct xe_eudebug_debugger *xe_eudebug_debugger_create (int xe,uint64_t flags,void *data);void xe_eudebug_debugger_destroy (struct xe_eudebug_debugger *d); -int xe_eudebug_debugger_attach (struct xe_eudebug_debugger *d,pid_t pid); +int xe_eudebug_debugger_attach (struct xe_eudebug_debugger *d,struct xe_eudebug_client *c);void xe_eudebug_debugger_start_worker (struct xe_eudebug_debugger *d);void xe_eudebug_debugger_stop_worker (struct xe_eudebug_debugger *d,int timeout_s);void xe_eudebug_debugger_dettach (struct xe_eudebug_debugger *d);void xe_eudebug_debugger_set_data (struct xe_eudebug_debugger *c,void *ptr);void xe_eudebug_debugger_add_trigger (struct xe_eudebug_debugger *d,int type,xe_eudebug_trigger_fn fn); +void xe_eudebug_debugger_signal_stage (struct xe_eudebug_debugger *d,uint64_t stage);struct xe_eudebug_client *xe_eudebug_client_create (int xe,xe_eudebug_client_work_fn work,uint64_t flags,void *data);
@@ -124,6 +128,8 @@ void xe_eudebug_client_destroy(struct xe_eudebug_client *c);void xe_eudebug_client_start (struct xe_eudebug_client *c);void xe_eudebug_client_stop (struct xe_eudebug_client *c);void xe_eudebug_client_wait_done (struct xe_eudebug_client *c); +void xe_eudebug_client_wait_stage (struct xe_eudebug_client *c,uint64_t stage); +uint64_t xe_eudebug_client_get_seqno (struct xe_eudebug_client *c);void xe_eudebug_client_set_data (struct xe_eudebug_client *c,void *ptr);
Signature · 1 line
2.34.1
PATCH v2 5/66 lib/xe_eudebug: Add exec_queue support
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Add support for exec_queue events to eudebug library.
Check event specific fields in post mortem log check. (Christoph)
--- lib/xe/xe_eudebug.c | 188 +++++++++++++++++++++++++++++++++++++++++++- lib/xe/xe_eudebug.h | 5 +- 2 files changed, 189 insertions(+), 4 deletions(-)
lib/xe/xe_eudebug.c +185 -3
@@ -20,6 +20,17 @@ struct event_trigger {struct igt_list_head link; }; +struct seqno_list_entry { +struct igt_list_head link; +uint64_t seqno; +}; + +struct match_dto { +struct drm_xe_eudebug_event *target; +struct igt_list_head *seqno_list; +uint64_t client_handle; +}; +#define CLIENT_PID 1#define CLIENT_RUN 2#define CLIENT_FINI 3
@@ -41,6 +52,8 @@ static const char *type_to_str(unsigned int type)return "client" ;case DRM_XE_EUDEBUG_EVENT_VM :return "vm" ; +case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE : +return "exec_queue" ; }return "UNKNOWN" ;
@@ -83,6 +96,15 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b) evm->client_handle, evm->vm_handle);break ; } +case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE : { +struct drm_xe_eudebug_event_exec_queue *ee = (void *)e; + +sprintf (b,"client_handle=%llu, vm_handle=%llu, " +"exec_queue_handle=%llu, engine_class=%d, exec_queue_width=%d" , + ee->client_handle, ee->vm_handle, + ee->exec_queue_handle, ee->engine_class, ee->width); +break ; + }default :strcpy (b,"<...>" ); }
@@ -309,6 +331,34 @@ 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) +{ +struct drm_xe_eudebug_event *b = data; +int ret =0 ; + + ret =match_type_and_flags (a, data); +if (!ret) +return ret; + + ret =0 ; + +switch (a->type) { +case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE : { +struct drm_xe_eudebug_event_exec_queue *ae = (void *)a; +struct drm_xe_eudebug_event_exec_queue *be = (void *)b; + +if (ae->engine_class == be->engine_class && ae->width == be->width) + ret =1 ; +break ; + } +default : + ret =1 ; +break ; + } + +return ret; +} +static int match_client_handle (struct drm_xe_eudebug_event *e,void *data) {uint64_t h = *(uint64_t *)data;
@@ -328,6 +378,13 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE : { +struct drm_xe_eudebug_event_exec_queue *ee = (struct drm_xe_eudebug_event_exec_queue *)e; + +if (ee->client_handle == h) +return 1 ; +break ; + }default :break ; }
@@ -365,12 +422,43 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE : { +struct drm_xe_eudebug_event_exec_queue *ee = (void *)e; +struct drm_xe_eudebug_event_exec_queue *filter = (struct drm_xe_eudebug_event_exec_queue *)data; + +if (ee->exec_queue_handle == filter->exec_queue_handle) +return 1 ; +break ; + }default :break ; }return 0 ; } +static int match_full (struct drm_xe_eudebug_event *e,void *data) +{ +struct seqno_list_entry *sl; + +struct match_dto *md = (void *)data; +int ret =0 ; + + ret =match_client_handle (e, &md->client_handle); +if (!ret) +return 0 ; + + ret =match_fields (e, md->target); +if (!ret) +return 0 ; + +igt_list_for_each_entry (sl, md->seqno_list, link) { +if (sl->seqno == e->seqno) +return 0 ; + } + +return 1 ; +} +static struct drm_xe_eudebug_event * event_type_match(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *filter,
@@ -395,6 +483,21 @@ opposite_event_match(struct xe_eudebug_event_log *l,return event_cmp (l, current, match_opposite_resource, filter); } +static struct drm_xe_eudebug_event * +event_match (struct xe_eudebug_event_log *l, +struct drm_xe_eudebug_event *target, +uint64_t client_handle, +struct igt_list_head *seqno_list) +{ +struct match_dto md = { + .target = target, + .client_handle = client_handle, + .seqno_list = seqno_list, + }; + +return event_cmp (l,NULL , match_full, &md); +} +static void compare_client (struct xe_eudebug_event_log *c,struct drm_xe_eudebug_event *_ce,struct xe_eudebug_event_log *d,struct drm_xe_eudebug_event *_de) {
@@ -402,6 +505,9 @@ static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebugstruct drm_xe_eudebug_event_client *de = (void *)_de;struct drm_xe_eudebug_event *hc, *hd; +struct igt_list_head matched_seqno_list; +struct seqno_list_entry *entry, *tmp; +igt_assert (ce);igt_assert (de);
@@ -409,13 +515,14 @@ static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug hc =NULL ; hd =NULL ; +IGT_INIT_LIST_HEAD (&matched_seqno_list); do { hc = client_match(c, ce->client_handle, hc); if (!hc) break; - hd = client_match(d, de->client_handle, hd); + hd = event_match(d, hc, de->client_handle, &matched_seqno_list); igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n", c->name,
@@ -426,9 +533,18 @@ static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebugigt_debug ("comparing %s %llu vs %s %llu\n" , c->name, hc->seqno, d->name, hd->seqno); -igt_assert_eq (hc->type, hd->type); -igt_assert_eq (hc->flags, hd->flags); +/* +* Store the seqno of the event that was matched above, +* inside 'matched_seqno_list', to avoid it getting matched +* by subsequent 'event_match' calls. +*/ + entry =malloc (sizeof (*entry)); + entry->seqno = hd->seqno; +igt_list_add (&entry->link, &matched_seqno_list); }while (hc); + +igt_list_for_each_entry_safe (entry, tmp, &matched_seqno_list, link) +free (entry); }/**
@@ -1202,6 +1318,25 @@ static void vm_event(struct xe_eudebug_client *c, uint32_t flags, int client_fd,xe_eudebug_event_log_write (c->log, (void *)&evm); } +static void exec_queue_event (struct xe_eudebug_client *c,uint32_t flags, +int client_fd,uint32_t vm_id, +uint32_t exec_queue_handle,uint16_t class, +uint16_t width) +{ +struct drm_xe_eudebug_event_exec_queue ee; + +base_event (c,to_base (ee),DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE , + flags,sizeof (ee)); + + ee.client_handle = client_fd; + ee.vm_handle = vm_id; + ee.exec_queue_handle = exec_queue_handle; + ee.engine_class = class; + ee.width = width; + +xe_eudebug_event_log_write (c->log, (void *)&ee); +} +/* Eu debugger wrappers around resource creating xe ioctls. */ /**
@@ -1274,3 +1409,50 @@ void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_txe_vm_destroy (fd, vm);vm_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , fd, vm); } + +/** +* xe_eudebug_client_exec_queue_create: +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @create: exec_queue create drm struct +* +* Calls xe exec queue create ioctl and logs the corresponding event in +* client's event log. +* +* Returns: valid exec queue handle +*/ +uint32_t xe_eudebug_client_exec_queue_create (struct xe_eudebug_client *c,int fd, +struct drm_xe_exec_queue_create *create) +{ +uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0 ].engine_class; + +igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_EXEC_QUEUE_CREATE , create),0 ); + +if (class ==DRM_XE_ENGINE_CLASS_COMPUTE || class ==DRM_XE_ENGINE_CLASS_RENDER ) +exec_queue_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , fd, create->vm_id, + create->exec_queue_id, class, create->width); + +return create->exec_queue_id; +} + +/** +* xe_eudebug_client_exec_queue_destroy: +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @create: exec_queue create drm struct which was used for creation +* +* Calls xe exec_queue destroy ioctl and logs the corresponding event in +* client's event log. +*/ +void xe_eudebug_client_exec_queue_destroy (struct xe_eudebug_client *c,int fd, +struct drm_xe_exec_queue_create *create) +{ +struct drm_xe_exec_queue_destroy destroy = { .exec_queue_id = create->exec_queue_id, }; +uint16_t class = ((struct drm_xe_engine_class_instance *)(create->instances))[0 ].engine_class; + +if (class ==DRM_XE_ENGINE_CLASS_COMPUTE || class ==DRM_XE_ENGINE_CLASS_RENDER ) +exec_queue_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , fd, create->vm_id, + create->exec_queue_id, class, create->width); + +igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_EXEC_QUEUE_DESTROY , &destroy),0 ); +}
lib/xe/xe_eudebug.h +4 -1
@@ -138,6 +138,10 @@ void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd);uint32_t xe_eudebug_client_vm_create (struct xe_eudebug_client *c,int fd,uint32_t flags,uint64_t ext);void xe_eudebug_client_vm_destroy (struct xe_eudebug_client *c,int fd,uint32_t vm); +uint32_t xe_eudebug_client_exec_queue_create (struct xe_eudebug_client *c,int fd, +struct drm_xe_exec_queue_create *create); +void xe_eudebug_client_exec_queue_destroy (struct xe_eudebug_client *c,int fd, +struct drm_xe_exec_queue_create *create); struct xe_eudebug_session *xe_eudebug_session_create(int fd, xe_eudebug_client_work_fn work,
@@ -146,4 +150,3 @@ struct xe_eudebug_session *xe_eudebug_session_create(int fd,void xe_eudebug_session_destroy (struct xe_eudebug_session *s);void xe_eudebug_session_run (struct xe_eudebug_session *s);void xe_eudebug_session_check (struct xe_eudebug_session *s,bool match_opposite); -
Signature · 1 line
2.34.1
PATCH v2 6/66 lib/xe_eudebug: Add attention events support
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Respect attention events in eu debugger library.
--- lib/xe/xe_eudebug.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
lib/xe/xe_eudebug.c +11 -0
@@ -54,6 +54,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_EU_ATTENTION : +return "attention" ; }return "UNKNOWN" ;
@@ -105,6 +107,15 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b) ee->exec_queue_handle, ee->engine_class, ee->width);break ; } +case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION : { +struct drm_xe_eudebug_event_eu_attention *ea = (void *)e; + +sprintf (b,"client_handle=%llu, exec_queue_handle=%llu, " +"lrc_handle=%llu, bitmask_size=%d" , + ea->client_handle, ea->exec_queue_handle, + ea->lrc_handle, ea->bitmask_size); +break ; + }default :strcpy (b,"<...>" ); }
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 06/66] lib/xe_eudebug: Add attention events support
Quoted 58 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 06/66]lib/xe_eudebug: Add attention events supportFrom: Dominik Grzegorzek <[email protected]>
Respect attention events in eu debugger library.
Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- lib/xe/xe_eudebug.c | 11 +++++++++++ 1 file changed, 11 insertions(+)lib/xe/xe_eudebug.c index renamed from lib/xe/xe_eudebug.c +0
-0
c84c9d9b7..8a57aaae3100644lib/xe/xe_eudebug.c +11
-0@@ -54,6 +54,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_EU_ATTENTION : +return "attention" ; }return "UNKNOWN" ;@@ -105,6 +107,15 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b) ee->exec_queue_handle, ee->engine_class, ee- >width);break ; } +case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION : { +struct drm_xe_eudebug_event_eu_attention *ea = (void *)e; + +sprintf (b,"client_handle=%llu, exec_queue_handle=%llu, " +"lrc_handle=%llu, bitmask_size=%d" , + ea->client_handle, ea->exec_queue_handle, + ea->lrc_handle, ea->bitmask_size); +break ; + }default :lib/xe/xe_eudebug.c +0
-1strcpy (b,"<...>" ); } --2.34.1
PATCH v2 7/66 lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter
In reply to Christoph ManszewskiCurrently there is no way to set drm_xe_vm_bind_op extension field. Add vm_bind wrapper that allows pass this field as a parameter.
--- lib/xe/xe_ioctl.c | 20 ++++++++++++++++---- lib/xe/xe_ioctl.h | 5 +++++ 2 files changed, 21 insertions(+), 4 deletions(-)
lib/xe/xe_ioctl.c +16 -4
@@ -96,15 +96,17 @@ void xe_vm_bind_array(int fd, uint32_t vm, uint32_t exec_queue,igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_VM_BIND , &bind),0 ); } -int __xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, -uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, -uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, -uint32_t prefetch_region,uint8_t pat_index,uint64_t ext) +int ___xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, +uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, +uint32_t prefetch_region,uint8_t pat_index,uint64_t ext, +uint64_t op_ext) {struct drm_xe_vm_bind bind = { .extensions = ext, .vm_id = vm, .num_binds =1 , + .bind.extensions = op_ext, .bind.obj = bo, .bind.obj_offset = offset, .bind.range = size,
@@ -125,6 +127,16 @@ int __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo,return 0 ; } +int __xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, +uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, +uint32_t prefetch_region,uint8_t pat_index,uint64_t ext) +{ +return ___xe_vm_bind (fd, vm, exec_queue, bo, offset, addr, size, op, + flags, sync, num_syncs, prefetch_region, + pat_index, ext,0 ); +} + void __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo, uint64_t offset, uint64_t addr, uint64_t size, uint32_t op, uint32_t flags, struct drm_xe_sync *sync,
lib/xe/xe_ioctl.h +5 -0
@@ -20,6 +20,11 @@uint32_t xe_cs_prefetch_size (int fd);uint64_t xe_bb_size (int fd,uint64_t reqsize);uint32_t xe_vm_create (int fd,uint32_t flags,uint64_t ext); +int ___xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, +uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, +uint32_t prefetch_region,uint8_t pat_index,uint64_t ext, +uint64_t op_ext); int __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo, uint64_t offset, uint64_t addr, uint64_t size, uint32_t op, uint32_t flags, struct drm_xe_sync *sync, uint32_t num_syncs,
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 07/66] lib/xe_ioctl: Add wrapper with vm_bind_op extension parameter
Quoted 92 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 07/66]lib/xe_ioctl: Add wrapper withvm_bind_opextension parameterCurrently there is no way to set
drm_xe_vm_bind_opextension field. Addvm_bindwrapper that allows pass this field as a parameter.Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Christoph Manszewski <[email protected]>--- lib/xe/xe_ioctl.c | 20 ++++++++++++++++---- lib/xe/xe_ioctl.h | 5 +++++ 2 files changed, 21 insertions(+), 4 deletions(-)lib/xe/xe_ioctl.c index ae43ffd15..6d8388918 renamed from lib/xe/xe_ioctl.c +0
-0100644
lib/xe/xe_ioctl.c +6
-4@@ -96,15 +96,17 @@ void xe_vm_bind_array(int fd, uint32_t vm, uint32_t exec_queue,igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_VM_BIND , &bind),0 ); } -int __xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, -uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, -uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, -uint32_t prefetch_region,uint8_t pat_index,uint64_t ext) +int ___xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, +uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, +uint32_t prefetch_region,uint8_t pat_index,uint64_t ext, +uint64_t op_ext) {struct drm_xe_vm_bind bind = { .extensions = ext, .vm_id = vm, .num_binds =1 , + .bind.extensions = op_ext, .bind.obj = bo,lib/xe/xe_ioctl.c +9
-0.bind.obj_offset = offset, .bind.range = size,@@ -125,6 +127,16 @@ int __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo, return 0; } +int __xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, +uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, +uint32_t prefetch_region,uint8_t pat_index,uint64_t ext) { +return ___xe_vm_bind (fd, vm, exec_queue, bo, offset, addr, size, op, + flags, sync, num_syncs, prefetch_region, + pat_index, ext,0 ); +} + void __xe_vm_bind_assert(int fd, uint32_t vm, uint32_t exec_queue,
uint32_tbo,lib/xe/xe_ioctl.c +0
-0uint64_t offset, uint64_t addr, uint64_t size, uint32_t op, uint32_t flags, struct drm_xe_sync*sync, diff --git
a/lib/xe/xe_ioctl.hb/lib/xe/xe_ioctl.hindexb27c0053f..18cc2b72b100644lib/xe/xe_ioctl.h +5
-0@@ -20,6 +20,11 @@uint32_t xe_cs_prefetch_size (int fd);uint64_t xe_bb_size (int fd,uint64_t reqsize);uint32_t xe_vm_create (int fd,uint32_t flags,uint64_t ext); +int ___xe_vm_bind (int fd,uint32_t vm,uint32_t exec_queue,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size,uint32_t op, +uint32_t flags,struct drm_xe_sync *sync,uint32_t num_syncs, +uint32_t prefetch_region,uint8_t pat_index,uint64_t ext, +uint64_t op_ext); int __xe_vm_bind(int fd, uint32_t vm, uint32_t exec_queue, uint32_t bo, uint64_t offset, uint64_t addr, uint64_t size, uint32_t op,
uint32_tflags, structdrm_xe_sync*sync,uint32_tnum_syncs,
--
2.34.1
PATCH v2 8/66 lib/xe_eudebug: Add support for vm_bind events
In reply to Christoph ManszewskiAdd support for logging and filtering vm_bind events.
--- lib/xe/xe_eudebug.c | 488 +++++++++++++++++++++++++++++++++++++++++--- lib/xe/xe_eudebug.h | 45 +++- 2 files changed, 507 insertions(+), 26 deletions(-)
lib/xe/xe_eudebug.c +465 -23
@@ -11,6 +11,7 @@#include <sys/wait.h> #include "igt.h" +#include "intel_pat.h" #include "xe_eudebug.h" #include "xe_ioctl.h"
@@ -29,6 +30,12 @@ struct match_dto {struct drm_xe_eudebug_event *target;struct igt_list_head *seqno_list;uint64_t client_handle; +uint32_t filter; + +/* store latest 'EVENT_VM_BIND' seqno */ +uint64_t *bind_seqno; +/* latest vm_bind_op seqno matching bind_seqno */ +uint64_t *bind_op_seqno; };#define CLIENT_PID 1
@@ -56,6 +63,12 @@ static const char *type_to_str(unsigned int type)return "exec_queue" ;case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION :return "attention" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND : +return "vm_bind" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : +return "vm_bind_op" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE : +return "vm_bind_ufence" ; }return "UNKNOWN" ;
@@ -70,15 +83,20 @@ 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 ) -return "create" ; - +if (flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +if (flags &DRM_XE_EUDEBUG_EVENT_NEED_ACK ) +return "create|ack" ; +else +return "create" ; + }if (flags &DRM_XE_EUDEBUG_EVENT_DESTROY )return "destroy" ;if (flags &DRM_XE_EUDEBUG_EVENT_STATE_CHANGE )return "state-change" ; +igt_assert (!(flags &DRM_XE_EUDEBUG_EVENT_NEED_ACK )); +return "flags unknown" ; }
@@ -116,6 +134,26 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b) ea->lrc_handle, ea->bitmask_size);break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e; + +sprintf (b,"client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u" , + evmb->client_handle, evmb->vm_handle, evmb->flags, evmb->num_binds); +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *op = (void *)e; + +sprintf (b,"vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu" , + op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions); +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE : { +struct drm_xe_eudebug_event_vm_bind_ufence *f = (void *)e; + +sprintf (b,"vm_bind_ref_seqno=%lld" , f->vm_bind_ref_seqno); +break ; + }default :strcpy (b,"<...>" ); }
@@ -362,6 +400,23 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) ret =1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *ea = (void *)a; +struct drm_xe_eudebug_event_vm_bind *eb = (void *)b; + +if (ea->num_binds == eb->num_binds) + ret =1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a; +struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b; + +if (ea->addr == eb->addr && ea->range == eb->range && + ea->num_extensions == eb->num_extensions) + ret =1 ; +break ; + }default : ret =1 ;break ;
@@ -372,7 +427,13 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data)static int match_client_handle (struct drm_xe_eudebug_event *e,void *data) { -uint64_t h = *(uint64_t *)data; +struct match_dto *md = (void *)data; +uint64_t *bind_seqno = md->bind_seqno; +uint64_t *bind_op_seqno = md->bind_op_seqno; +uint64_t h = md->client_handle; + +if (XE_EUDEBUG_EVENT_IS_FILTERED (e->type, md->filter)) +return 0 ;switch (e->type) {case DRM_XE_EUDEBUG_EVENT_OPEN : {
@@ -396,6 +457,32 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *evmb = (struct drm_xe_eudebug_event_vm_bind *)e; + +if (evmb->client_handle == h) { + *bind_seqno = evmb->base.seqno; +return 1 ; + } +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *eo = (struct drm_xe_eudebug_event_vm_bind_op *)e; + +if (eo->vm_bind_ref_seqno == *bind_seqno) { + *bind_op_seqno = eo->base.seqno; +return 1 ; + } +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE : { +struct drm_xe_eudebug_event_vm_bind_ufence *ef = (struct drm_xe_eudebug_event_vm_bind_ufence *)e; + +if (ef->vm_bind_ref_seqno == *bind_seqno) +return 1 ; + +break ; + }default :break ; }
@@ -410,6 +497,7 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)int ret; d->flags ^=DRM_XE_EUDEBUG_EVENT_CREATE |DRM_XE_EUDEBUG_EVENT_DESTROY ; + d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK ); ret =match_type_and_flags (e, data); d->flags ^=DRM_XE_EUDEBUG_EVENT_CREATE |DRM_XE_EUDEBUG_EVENT_DESTROY ;
@@ -441,6 +529,24 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e; +struct drm_xe_eudebug_event_vm_bind *filter = (struct drm_xe_eudebug_event_vm_bind *)data; + +if (evmb->vm_handle == filter->vm_handle && + evmb->num_binds == filter->num_binds) +return 1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e; +struct drm_xe_eudebug_event_vm_bind_op *filter = (struct drm_xe_eudebug_event_vm_bind_op *)data; + +if (avmb->addr == filter->addr && + avmb->range == filter->range) +return 1 ; +break ; + }default :break ; }
@@ -454,7 +560,7 @@ static int match_full(struct drm_xe_eudebug_event *e, void *data)struct match_dto *md = (void *)data;int ret =0 ; - ret =match_client_handle (e, &md->client_handle); + ret =match_client_handle (e, md);if (!ret)return 0 ;
@@ -472,51 +578,67 @@ static int match_full(struct drm_xe_eudebug_event *e, void *data)static struct drm_xe_eudebug_event *event_type_match (struct xe_eudebug_event_log *l, -struct drm_xe_eudebug_event *filter, +struct drm_xe_eudebug_event *target,struct drm_xe_eudebug_event *current) { -return event_cmp (l, current, match_type_and_flags, filter); +return event_cmp (l, current, match_type_and_flags, target); }static struct drm_xe_eudebug_event *client_match (struct xe_eudebug_event_log *l,uint64_t client_handle, -struct drm_xe_eudebug_event *current) +struct drm_xe_eudebug_event *current, +uint32_t filter, +uint64_t *bind_seqno, +uint64_t *bind_op_seqno) { -return event_cmp (l, current, match_client_handle, &client_handle); +struct match_dto md = { + .client_handle = client_handle, + .filter = filter, + .bind_seqno = bind_seqno, + .bind_op_seqno = bind_op_seqno, + }; + +return event_cmp (l, current, match_client_handle, &md); }static struct drm_xe_eudebug_event *opposite_event_match (struct xe_eudebug_event_log *l, -struct drm_xe_eudebug_event *filter, +struct drm_xe_eudebug_event *target,struct drm_xe_eudebug_event *current) { -return event_cmp (l, current, match_opposite_resource, filter); +return event_cmp (l, current, match_opposite_resource, target); }static struct drm_xe_eudebug_event *event_match (struct xe_eudebug_event_log *l,struct drm_xe_eudebug_event *target,uint64_t client_handle, -struct igt_list_head *seqno_list) +struct igt_list_head *seqno_list, +uint64_t *bind_seqno, +uint64_t *bind_op_seqno) {struct match_dto md = { .target = target, .client_handle = client_handle, .seqno_list = seqno_list, + .bind_seqno = bind_seqno, + .bind_op_seqno = bind_op_seqno, };return event_cmp (l,NULL , match_full, &md); }static void compare_client (struct xe_eudebug_event_log *c,struct drm_xe_eudebug_event *_ce, -struct xe_eudebug_event_log *d,struct drm_xe_eudebug_event *_de) +struct xe_eudebug_event_log *d,struct drm_xe_eudebug_event *_de, +uint32_t filter) {struct drm_xe_eudebug_event_client *ce = (void *)_ce;struct drm_xe_eudebug_event_client *de = (void *)_de; -struct drm_xe_eudebug_event *hc, *hd; +uint64_t cbs =0 , dbs =0 , cbso =0 , dbso =0 ;struct igt_list_head matched_seqno_list; +struct drm_xe_eudebug_event *hc, *hd;struct seqno_list_entry *entry, *tmp;igt_assert (ce);
@@ -529,11 +651,11 @@ static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebugIGT_INIT_LIST_HEAD (&matched_seqno_list); do { - hc = client_match(c, ce->client_handle, hc); + hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso); if (!hc) break; - hd = event_match(d, hc, de->client_handle, &matched_seqno_list); + hd = event_match(d, hc, de->client_handle, &matched_seqno_list, &dbs, &dbso); igt_assert_f(hd, "%s (%llu): no matching event type %u found for client %llu\n", c->name,
@@ -720,11 +842,15 @@ xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug)* xe_eudebug_event_log_compare: * @a: event log pointer * @b: event log pointer +* @filter: mask that represents events to be skipped during comparison, useful +* for events like 'VM_BIND' since they can be asymmetric. Note that +* 'DRM_XE_EUDEUBG_EVENT_OPEN' will always be matched. * * Compares and asserts event logs @a, @b if the event * sequence matches. */ -void xe_eudebug_event_log_compare (struct xe_eudebug_event_log *a,struct xe_eudebug_event_log *b) +void xe_eudebug_event_log_compare (struct xe_eudebug_event_log *a,struct xe_eudebug_event_log *b, +uint32_t filter) {struct drm_xe_eudebug_event *ae =NULL ;struct drm_xe_eudebug_event *be =NULL ;
@@ -734,8 +860,8 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eude ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { be =event_type_match (b, ae, be); -compare_client (a, ae, b, be); -compare_client (b, be, a, ae); +compare_client (a, ae, b, be, filter); +compare_client (b, be, a, ae, filter); } } }
@@ -743,11 +869,13 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eude/** * xe_eudebug_event_log_match_opposite: * @l: event log pointer +* @filter: mask that represents events to be skipped during comparison, useful +* for events like 'VM_BIND' since they can be asymmetric * * Matches and asserts content of all opposite events (create vs destroy). */ void -xe_eudebug_event_log_match_opposite (struct xe_eudebug_event_log *l) +xe_eudebug_event_log_match_opposite (struct xe_eudebug_event_log *l,uint32_t filter) {struct drm_xe_eudebug_event *ce =NULL ;struct drm_xe_eudebug_event *de =NULL ;
@@ -757,6 +885,14 @@ xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l)uint8_t offset =sizeof (struct drm_xe_eudebug_event );int opposite_matching; +if (XE_EUDEBUG_EVENT_IS_FILTERED (ce->type, filter)) +continue ; + +/* No opposite matching for binds */ +if (ce->type >=DRM_XE_EUDEBUG_EVENT_VM_BIND && + ce->type <=DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE ) +continue ; + de =opposite_event_match (l, ce, ce);igt_assert_f (de,"no opposite event of type %u found\n" , ce->type);
@@ -1267,15 +1403,17 @@ void xe_eudebug_session_run(struct xe_eudebug_session *s)* @s: pointer to xe_eudebug_session structure * @match_opposite: indicates whether check should match all * create and destroy events. +* @filter: mask that represents events to be skipped during comparison, useful +* for events like 'VM_BIND' since they can be asymmetric * * Validate debugger's log against the log created by the client. */ -void xe_eudebug_session_check (struct xe_eudebug_session *s,bool match_opposite) +void xe_eudebug_session_check (struct xe_eudebug_session *s,bool match_opposite,uint32_t filter) { -xe_eudebug_event_log_compare (s->c->log, s->d->log); +xe_eudebug_event_log_compare (s->c->log, s->d->log, filter);if (match_opposite) -xe_eudebug_event_log_match_opposite (s->d->log); +xe_eudebug_event_log_match_opposite (s->d->log, filter); }/**
@@ -1467,3 +1605,307 @@ void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_EXEC_QUEUE_DESTROY , &destroy),0 ); } + +/** +* xe_eudebug_client_vm_bind_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @fd: xe client +* @vm: vm handle +* @bind_flags: bind flags of vm_bind_event +* @num_binds: number of bind (operations) for event +* @ref_seqno: base vm bind reference seqno +* Logs vm bind event in client's event log. +*/ +void xe_eudebug_client_vm_bind_event (struct xe_eudebug_client *c, +uint32_t event_flags,int fd, +uint32_t vm,uint32_t bind_flags, +uint32_t num_binds,u64 *ref_seqno) +{ +struct drm_xe_eudebug_event_vm_bind evmb; + +base_event (c,to_base (evmb),DRM_XE_EUDEBUG_EVENT_VM_BIND , + event_flags,sizeof (evmb)); + evmb.client_handle = fd; + evmb.vm_handle = vm; + evmb.flags = bind_flags; + evmb.num_binds = num_binds; + + *ref_seqno = evmb.base.seqno; + +xe_eudebug_event_log_write (c->log, (void *)&evmb); +} + +/** +* xe_eudebug_client_vm_bind_op_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @bind_ref_seqno: base vm bind reference seqno +* @op_ref_seqno: output, the vm_bind_op event seqno +* @addr: ppgtt address +* @size: size of the binding +* @num_extensions: number of vm bind op extensions +* +* Logs vm bind op event in client's event log. +*/ +void xe_eudebug_client_vm_bind_op_event (struct xe_eudebug_client *c,uint32_t event_flags, +uint64_t bind_ref_seqno,uint64_t *op_ref_seqno, +uint64_t addr,uint64_t range, +uint64_t num_extensions) +{ +struct drm_xe_eudebug_event_vm_bind_op op; + +base_event (c,to_base (op),DRM_XE_EUDEBUG_EVENT_VM_BIND_OP , + event_flags,sizeof (op)); + op.vm_bind_ref_seqno = bind_ref_seqno; + op.addr = addr; + op.range = range; + op.num_extensions = num_extensions; + + *op_ref_seqno = op.base.seqno; + +xe_eudebug_event_log_write (c->log, (void *)&op); +} + +/** +* xe_eudebug_client_vm_bind_op_metadata_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @op_ref_seqno: base vm bind op reference seqno +* @metadata_handle: metadata handle +* @metadata_cookie: metadata cookie +* +* Logs vm bind op metadata event in client's event log. +*/ +void xe_eudebug_client_vm_bind_op_metadata_event (struct xe_eudebug_client *c, +uint32_t event_flags,uint64_t op_ref_seqno, +uint64_t metadata_handle,uint64_t metadata_cookie) +{ +struct drm_xe_eudebug_event_vm_bind_op_metadata op; + +base_event (c,to_base (op),DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA , + event_flags,sizeof (op)); + op.vm_bind_op_ref_seqno = op_ref_seqno; + op.metadata_handle = metadata_handle; + op.metadata_cookie = metadata_cookie; + +xe_eudebug_event_log_write (c->log, (void *)&op); +} + +/** +* xe_eudebug_client_vm_bind_ufence_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @ref_seqno: base vm bind event seqno +* +* Logs vm bind ufence event in client's event log. +*/ +void xe_eudebug_client_vm_bind_ufence_event (struct xe_eudebug_client *c,uint32_t event_flags, +uint64_t ref_seqno) +{ +struct drm_xe_eudebug_event_vm_bind_ufence f; + +base_event (c,to_base (f),DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE , + event_flags,sizeof (f)); + f.vm_bind_ref_seqno = ref_seqno; + +xe_eudebug_event_log_write (c->log, (void *)&f); +} + +static bool has_user_fence (const struct drm_xe_sync *sync,uint32_t num_syncs) +{ +while (num_syncs--) +if (sync[num_syncs].type ==DRM_XE_SYNC_TYPE_USER_FENCE ) +return true; + +return false; +} + +#define for_each_metadata (__m, __ext) \ + for ((__m) = from_user_pointer(__ext); \ + (__m); \ + (__m) = from_user_pointer((__m)->base.next_extension)) \ + if ((__m)->base.name == XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG) + +static int __xe_eudebug_client_vm_bind (struct xe_eudebug_client *c, +int fd,uint32_t vm,uint32_t exec_queue, +uint32_t bo,uint64_t offset, +uint64_t addr,uint64_t size, +uint32_t op,uint32_t flags, +struct drm_xe_sync *sync, +uint32_t num_syncs, +uint32_t prefetch_region, +uint8_t pat_index,uint64_t op_ext) +{ +struct drm_xe_vm_bind_op_ext_attach_debug *metadata; +const bool ufence =has_user_fence (sync, num_syncs); +const uint32_t bind_flags = ufence ? +DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE :0 ; +uint64_t seqno =0 , op_seqno =0 , num_metadata =0 ; +uint32_t bind_base_flags =0 ; +int ret; + +for_each_metadata (metadata, op_ext) + num_metadata++; + +switch (op) { +case DRM_XE_VM_BIND_OP_MAP : + bind_base_flags =DRM_XE_EUDEBUG_EVENT_CREATE ; +break ; +case DRM_XE_VM_BIND_OP_UNMAP : + bind_base_flags =DRM_XE_EUDEBUG_EVENT_DESTROY ; +igt_assert_eq (num_metadata,0 ); +igt_assert_eq (ufence, false); +break ; +default : +/* XXX unmap all? */ +igt_assert (op); +break ; + } + + ret =___xe_vm_bind (fd, vm, exec_queue, bo, offset, addr, size, + op, flags, sync, num_syncs, prefetch_region, + pat_index,0 , op_ext); + +if (ret) +return ret; + +if (!bind_base_flags) +return -EINVAL ; + +xe_eudebug_client_vm_bind_event (c,DRM_XE_EUDEBUG_EVENT_STATE_CHANGE , + fd, vm, bind_flags,1 , &seqno); +xe_eudebug_client_vm_bind_op_event (c, bind_base_flags, + seqno, &op_seqno, addr, size, + num_metadata); + +for_each_metadata (metadata, op_ext) +xe_eudebug_client_vm_bind_op_metadata_event (c, +DRM_XE_EUDEBUG_EVENT_CREATE , + op_seqno, + metadata->metadata_id, + metadata->cookie); +if (ufence) +xe_eudebug_client_vm_bind_ufence_event (c,DRM_XE_EUDEBUG_EVENT_CREATE | +DRM_XE_EUDEBUG_EVENT_NEED_ACK , + seqno); +return ret; +} + +static void _xe_eudebug_client_vm_bind (struct xe_eudebug_client *c,int fd, +uint32_t vm,uint32_t bo, +uint64_t offset,uint64_t addr,uint64_t size, +uint32_t op, +uint32_t flags, +struct drm_xe_sync *sync, +uint32_t num_syncs, +uint64_t op_ext) +{ +const uint32_t exec_queue_id =0 ; +const uint32_t prefetch_region =0 ; + +igt_assert_eq (__xe_eudebug_client_vm_bind (c, fd, vm, exec_queue_id, bo, offset, + addr, size, op, flags, + sync, num_syncs, prefetch_region, +DEFAULT_PAT_INDEX , op_ext), +0 ); +} + +/** +* xe_eudebug_client_vm_bind_flags +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @bo: buffer object handle +* @offset: offset within buffer object +* @addr: ppgtt address +* @size: size of the binding +* @flags: vm_bind flags +* @sync: sync objects +* @num_syncs: number of sync objects +* @op_ext: BIND_OP extensions +* +* Calls xe vm_bind ioctl and logs the corresponding event in client's event log. +*/ +void xe_eudebug_client_vm_bind_flags (struct xe_eudebug_client *c,int fd,uint32_t vm, +uint32_t bo,uint64_t offset, +uint64_t addr,uint64_t size,uint32_t flags, +struct drm_xe_sync *sync,uint32_t num_syncs, +uint64_t op_ext) +{ +_xe_eudebug_client_vm_bind (c, fd, vm, bo, offset, addr, size, +DRM_XE_VM_BIND_OP_MAP , flags, + sync, num_syncs, op_ext); +} + +/** +* xe_eudebug_client_vm_bind +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @bo: buffer object handle +* @offset: offset within buffer object +* @addr: ppgtt address +* @size: size of the binding +* +* Calls xe vm_bind ioctl and logs the corresponding event in client's event log. +*/ +void xe_eudebug_client_vm_bind (struct xe_eudebug_client *c,int fd,uint32_t vm, +uint32_t bo,uint64_t offset, +uint64_t addr,uint64_t size) +{ +const uint32_t flags =0 ; +struct drm_xe_sync *sync =NULL ; +const uint32_t num_syncs =0 ; +const uint64_t op_ext =0 ; + +xe_eudebug_client_vm_bind_flags (c, fd, vm, bo, offset, addr, size, + flags, + sync, num_syncs, op_ext); +} + +/** +* xe_eudebug_client_vm_unbind_flags +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @offset: offset +* @addr: ppgtt address +* @size: size of the binding +* @flags: vm_bind flags +* @sync: sync objects +* @num_syncs: number of sync objects +* +* Calls xe vm_unbind ioctl and logs the corresponding event in client's event log. +*/ +void xe_eudebug_client_vm_unbind_flags (struct xe_eudebug_client *c,int fd, +uint32_t vm,uint64_t offset, +uint64_t addr,uint64_t size,uint32_t flags, +struct drm_xe_sync *sync,uint32_t num_syncs) +{ +_xe_eudebug_client_vm_bind (c, fd, vm,0 , offset, addr, size, +DRM_XE_VM_BIND_OP_UNMAP , flags, + sync, num_syncs,0 ); +} + +/** +* xe_eudebug_client_vm_unbind +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @offset: offset +* @addr: ppgtt address +* @size: size of the binding +* +* Calls xe vm_unbind ioctl and logs the corresponding event in client's event log. +*/ +void xe_eudebug_client_vm_unbind (struct xe_eudebug_client *c,int fd,uint32_t vm, +uint64_t offset,uint64_t addr,uint64_t size) +{ +const uint32_t flags =0 ; +struct drm_xe_sync *sync =NULL ; +const uint32_t num_syncs =0 ; + +xe_eudebug_client_vm_unbind_flags (c, fd, vm, offset, addr, size, + flags, sync, num_syncs); +}
lib/xe/xe_eudebug.h +42 -3
67 lines not on this page · raw message
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 08/66] lib/xe_eudebug: Add support for vm_bind events
Comments below.
Thanks,
Dominik Karol
Quoted 350 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 08/66]lib/xe_eudebug: Add support forvm_bindeventsAdd support for logging and filtering
vm_bindevents.Signed-off-by Christoph Manszewski <[email protected]>Signed-off-by Maciej Patelczyk <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- lib/xe/xe_eudebug.c | 488 +++++++++++++++++++++++++++++++++++++++++--- lib/xe/xe_eudebug.h | 45 +++- 2 files changed, 507 insertions(+), 26 deletions(-)lib/xe/xe_eudebug.c index renamed from lib/xe/xe_eudebug.c +0
-0
8a57aaae3..2d1a7092c100644lib/xe/xe_eudebug.c +32
-3@@ -11,6 +11,7 @@#include <sys/wait.h> #include "igt.h" +#include "intel_pat.h" #include "xe_eudebug.h" #include "xe_ioctl.h" @@ -29,6 +30,12 @@ struct match_dto {struct drm_xe_eudebug_event *target;struct igt_list_head *seqno_list;uint64_t client_handle; +uint32_t filter; + +/* store latest 'EVENT_VM_BIND' seqno */ +uint64_t *bind_seqno; +/* latest vm_bind_op seqno matching bind_seqno */ +uint64_t *bind_op_seqno; };#define CLIENT_PID 1@@ -56,6 +63,12 @@ static const char *type_to_str(unsigned int type)return "exec_queue" ;case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION :return "attention" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND : +return "vm_bind" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : +return "vm_bind_op" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE : +return "vm_bind_ufence" ; }return "UNKNOWN" ;@@ -70,15 +83,20 @@ 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 ) -return "create" ; - +if (flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +if (flags &DRM_XE_EUDEBUG_EVENT_NEED_ACK ) +return "create|ack" ; +else +return "create" ; + }if (flags &DRM_XE_EUDEBUG_EVENT_DESTROY )return "destroy" ;if (flags &DRM_XE_EUDEBUG_EVENT_STATE_CHANGE )return "state-change" ; +igt_assert (!(flags &DRM_XE_EUDEBUG_EVENT_NEED_ACK )); +return "flags unknown" ; }@@ -116,6 +134,26 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b) ea->lrc_handle, ea->bitmask_size);break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e; + + sprintf(b, "client_handle=%llu, vm_handle=%llu, flags=0x%x, num_binds=%u", + evmb->client_handle, evmb->vm_handle, evmb- >flags, evmb->num_binds); +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *op = (void *)e; + + sprintf(b, "vm_bind_ref_seqno=%lld, addr=%016llx,range=%llu num_extensions=%llu",
lib/xe/xe_eudebug.c +1
-0+ op->vm_bind_ref_seqno, op->addr, op->range, op-Quoted 1 line
num_extensions);lib/xe/xe_eudebug.c +4
-0+break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE : { + struct drm_xe_eudebug_event_vm_bind_ufence *f = (void*)e;
lib/xe/xe_eudebug.c +2
-0+ + sprintf(b, "vm_bind_ref_seqno=%lld", f-Quoted 1 line
vm_bind_ref_seqno);lib/xe/xe_eudebug.c +19
-0+break ; + }default :strcpy (b,"<...>" ); }@@ -362,6 +400,23 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) ret =1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *ea = (void *)a; +struct drm_xe_eudebug_event_vm_bind *eb = (void *)b; + +if (ea->num_binds == eb->num_binds) + ret =1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *ea = (void *)a; +struct drm_xe_eudebug_event_vm_bind_op *eb = (void *)b; + +if (ea->addr == eb->addr && ea->range == eb->range && + ea->num_extensions == eb->num_extensions) + ret =1 ; +break ; + }default : ret =1 ;lib/xe/xe_eudebug.c +7
-1break ;@@ -372,7 +427,13 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data)static int match_client_handle (struct drm_xe_eudebug_event *e,void *data) { -uint64_t h = *(uint64_t *)data; +struct match_dto *md = (void *)data; +uint64_t *bind_seqno = md->bind_seqno; +uint64_t *bind_op_seqno = md->bind_op_seqno; +uint64_t h = md->client_handle; + +if (XE_EUDEBUG_EVENT_IS_FILTERED (e->type, md->filter)) +return 0 ;switch (e->type) {lib/xe/xe_eudebug.c +30
-0case DRM_XE_EUDEBUG_EVENT_OPEN : {@@ -396,6 +457,32 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *evmb = (struct +drm_xe_eudebug_event_vm_bind *)e; + +if (evmb->client_handle == h) { + *bind_seqno = evmb->base.seqno; +return 1 ; + } +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *eo = (struct +drm_xe_eudebug_event_vm_bind_op *)e; + +if (eo->vm_bind_ref_seqno == *bind_seqno) { + *bind_op_seqno = eo->base.seqno; +return 1 ; + } +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE : { +struct drm_xe_eudebug_event_vm_bind_ufence *ef = (struct +drm_xe_eudebug_event_vm_bind_ufence *)e; + +if (ef->vm_bind_ref_seqno == *bind_seqno) +return 1 ; + +break ; + }default :break ; }@@ -410,6 +497,7 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)int ret; d->flags ^=DRM_XE_EUDEBUG_EVENT_CREATE |DRM_XE_EUDEBUG_EVENT_DESTROY ; + d->flags &= ~(DRM_XE_EUDEBUG_EVENT_NEED_ACK ); ret =match_type_and_flags (e, data);
d->flags^=DRM_XE_EUDEBUG_EVENT_CREATE|DRM_XE_EUDEBUG_EVENT_DESTROY;lib/xe/xe_eudebug.c +46
-10@@ -441,6 +529,24 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND : { +struct drm_xe_eudebug_event_vm_bind *evmb = (void *)e; +struct drm_xe_eudebug_event_vm_bind *filter = (struct +drm_xe_eudebug_event_vm_bind *)data; + +if (evmb->vm_handle == filter->vm_handle && + evmb->num_binds == filter->num_binds) +return 1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP : { +struct drm_xe_eudebug_event_vm_bind_op *avmb = (void *)e; +struct drm_xe_eudebug_event_vm_bind_op *filter = (struct +drm_xe_eudebug_event_vm_bind_op *)data; + +if (avmb->addr == filter->addr && + avmb->range == filter->range) +return 1 ; +break ; + }default :break ; }@@ -454,7 +560,7 @@ static int match_full(struct drm_xe_eudebug_event *e, void *data)struct match_dto *md = (void *)data;int ret =0 ; - ret =match_client_handle (e, &md->client_handle); + ret =match_client_handle (e, md);if (!ret)return 0 ;@@ -472,51 +578,67 @@ static int match_full(struct drm_xe_eudebug_event *e, void *data)static struct drm_xe_eudebug_event *event_type_match (struct xe_eudebug_event_log *l, -struct drm_xe_eudebug_event *filter, +struct drm_xe_eudebug_event *target,struct drm_xe_eudebug_event *current) { -return event_cmp (l, current, match_type_and_flags, filter); +return event_cmp (l, current, match_type_and_flags, target); }static struct drm_xe_eudebug_event *client_match (struct xe_eudebug_event_log *l,uint64_t client_handle, -struct drm_xe_eudebug_event *current) +struct drm_xe_eudebug_event *current, +uint32_t filter, +uint64_t *bind_seqno, +uint64_t *bind_op_seqno) { -return event_cmp (l, current, match_client_handle, &client_handle); +struct match_dto md = { + .client_handle = client_handle, + .filter = filter, + .bind_seqno = bind_seqno, + .bind_op_seqno = bind_op_seqno, + }; + +return event_cmp (l, current, match_client_handle, &md); }static struct drm_xe_eudebug_event *opposite_event_match (struct xe_eudebug_event_log *l, -struct drm_xe_eudebug_event *filter, +struct drm_xe_eudebug_event *target,struct drm_xe_eudebug_event *current) { -return event_cmp (l, current, match_opposite_resource, filter); +return event_cmp (l, current, match_opposite_resource, target); }static struct drm_xe_eudebug_event *event_match (struct xe_eudebug_event_log *l,struct drm_xe_eudebug_event *target,uint64_t client_handle, -struct igt_list_head *seqno_list) +struct igt_list_head *seqno_list, +uint64_t *bind_seqno, +uint64_t *bind_op_seqno) {struct match_dto md = { .target = target, .client_handle = client_handle, .seqno_list = seqno_list, + .bind_seqno = bind_seqno, + .bind_op_seqno = bind_op_seqno, };return event_cmp (l,NULL , match_full, &md); } static void compare_client(struct xe_eudebug_event_log *c, struct drm_xe_eudebug_event *_ce, - struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de) + struct xe_eudebug_event_log *d, struct drm_xe_eudebug_event *_de, + uint32_t filter) { struct drm_xe_eudebug_event_client *ce = (void *)_ce;struct drm_xe_eudebug_event_client *de = (void *)_de; -struct drm_xe_eudebug_event *hc, *hd; +uint64_t cbs =0 , dbs =0 , cbso =0 , dbso =0 ;struct igt_list_head matched_seqno_list; +struct drm_xe_eudebug_event *hc, *hd;struct seqno_list_entry *entry, *tmp;lib/xe/xe_eudebug.c +0
-0igt_assert (ce);@@ -529,11 +651,11 @@ static void compare_client(struct
xe_eudebug_event_log*c, structdrm_xe_eudebuglib/xe/xe_eudebug.c +1
-2IGT_INIT_LIST_HEAD (&matched_seqno_list); do { - hc = client_match(c, ce->client_handle, hc); + hc = client_match(c, ce->client_handle, hc, filter, &cbs, &cbso); if (!hc) break; - hd = event_match(d, hc, de->client_handle,
&matched_seqno_list);lib/xe/xe_eudebug.c +1
-0+ hd = event_match(d, hc, de->client_handle,
&matched_seqno_list, &dbs,
+&dbso);igt_assert_f(hd, "%s (%llu): no matching event type %u found
for client %llu\n",lib/xe/xe_eudebug.c +0
-0c->name,
lib/xe/xe_eudebug.c xe_eudebug_event_log_print(struct · line 849
Quoted 8 lines
lib/xe/xe_eudebug.c +4
-0@@ -720,11 +842,15 @@ xe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug) * xe_eudebug_event_log_compare: * @a: event log pointer * @b: event log pointer + * @filter: mask that represents events to be skipped during + comparison, useful + * for events like 'VM_BIND' since they can be asymmetric. Note that + * 'DRM_XE_EUDEUBG_EVENT_OPEN' will always be matched.
Typo: DRM_XE_EUDEBUG_EVENT_OPEN
Quoted 437 lines
lib/xe/xe_eudebug.c +2
-1* * Compares and asserts event logs @a, @b if the event * sequence matches. */ -void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *a, struct xe_eudebug_event_log *b) +void xe_eudebug_event_log_compare (struct xe_eudebug_event_log *a,struct xe_eudebug_event_log *b, +uint32_t filter) {struct drm_xe_eudebug_event *ae =NULL ; struct drm_xe_eudebug_event *be = NULL; @@ -734,8 +860,8 @@void xe_eudebug_event_log_compare(struct
xe_eudebug_event_log*a, structxe_eudelib/xe/xe_eudebug.c +2
-2ae->flags & DRM_XE_EUDEBUG_EVENT_CREATE) { be =event_type_match (b, ae, be); -compare_client (a, ae, b, be); -compare_client (b, be, a, ae); +compare_client (a, ae, b, be, filter); +compare_client (b, be, a, ae, filter); } } }@@ -743,11 +869,13 @@ void xe_eudebug_event_log_compare(struct
xe_eudebug_event_log*a, structxe_eude
/**
*xe_eudebug_event_log_match_opposite:
* @l: event log pointer
+ * @filter: mask that represents events to be skipped during
+ comparison, useful
+ * for events like 'VM_BIND' since they can be asymmetric
*
* Matches and asserts content of all opposite events (create vs destroy). */
voidlib/xe/xe_eudebug.c +2
-1-xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l) +xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, +uint32_t filter) {struct drm_xe_eudebug_event *ce =NULL ; struct drm_xe_eudebug_event *de = NULL; @@ -757,6 +885,14 @@
xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l)
uint8_toffset = sizeof(structdrm_xe_eudebug_event);lib/xe/xe_eudebug.c +5
-0int opposite_matching; +if (XE_EUDEBUG_EVENT_IS_FILTERED (ce->type, filter)) +continue ; + +/* No opposite matching for binds */ + if (ce->type >= DRM_XE_EUDEBUG_EVENT_VM_BIND&&
lib/xe/xe_eudebug.c +1
-0+ ce->type <=
DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)lib/xe/xe_eudebug.c +2
-0+continue ; + de =opposite_event_match (l, ce, ce); igt_assert_f(de, "no opposite event of type %ufound\n",
ce->type); @@ -1267,15 +1403,17 @@ voidxe_eudebug_session_run(struct xe_eudebug_session *s)
* @s: pointer toxe_eudebug_sessionstructure
* @match_opposite: indicates whether check should match all
* create and destroy events.
+ * @filter: mask that represents events to be skipped during
+ comparison, useful
+ * for events like 'VM_BIND' since they can be asymmetric *
* Validate debugger's log against the log created by the client. */
-voidxe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite)lib/xe/xe_eudebug.c +4
-2+void xe_eudebug_session_check (struct xe_eudebug_session *s,bool +match_opposite,uint32_t filter) { -xe_eudebug_event_log_compare (s->c->log, s->d->log); +xe_eudebug_event_log_compare (s->c->log, s->d->log, filter);if (match_opposite) -xe_eudebug_event_log_match_opposite (s->d->log); +xe_eudebug_event_log_match_opposite (s->d->log, filter); }/** @@ -1467,3 +1605,307 @@ void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd, igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_EXEC_QUEUE_DESTROY,&destroy), 0); }
lib/xe/xe_eudebug.c +19
-0+ +/** +* xe_eudebug_client_vm_bind_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @fd: xe client +* @vm: vm handle +* @bind_flags: bind flags of vm_bind_event +* @num_binds: number of bind (operations) for event +* @ref_seqno: base vm bind reference seqno +* Logs vm bind event in client's event log. +*/ +void xe_eudebug_client_vm_bind_event (struct xe_eudebug_client *c, +uint32_t event_flags,int fd, +uint32_t vm,uint32_t bind_flags, +uint32_t num_binds,u64 *ref_seqno) { +struct drm_xe_eudebug_event_vm_bind evmb; + + base_event(c, to_base(evmb),
DRM_XE_EUDEBUG_EVENT_VM_BIND,lib/xe/xe_eudebug.c +23
-0+ event_flags, sizeof(evmb)); + evmb.client_handle = fd; + evmb.vm_handle = vm; + evmb.flags = bind_flags; + evmb.num_binds = num_binds; + + *ref_seqno = evmb.base.seqno; + +xe_eudebug_event_log_write (c->log, (void *)&evmb); } + +/** +* xe_eudebug_client_vm_bind_op_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @bind_ref_seqno: base vm bind reference seqno +* @op_ref_seqno: output, the vm_bind_op event seqno +* @addr: ppgtt address +* @size: size of the binding +* @num_extensions: number of vm bind op extensions +* +* Logs vm bind op event in client's event log. +*/ +void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c,
uint32_tevent_flags,lib/xe/xe_eudebug.c +1
-0+uint64_t bind_ref_seqno, uint64_t
*op_ref_seqno,lib/xe/xe_eudebug.c +6
-0+ uint64_t addr, uint64_t range, + uint64_t num_extensions) +{ + struct drm_xe_eudebug_event_vm_bind_op op; + + base_event(c, to_base(op),
DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,lib/xe/xe_eudebug.c +21
-0+ event_flags, sizeof(op)); + op.vm_bind_ref_seqno = bind_ref_seqno; + op.addr = addr; + op.range = range; + op.num_extensions = num_extensions; + + *op_ref_seqno = op.base.seqno; + +xe_eudebug_event_log_write (c->log, (void *)&op); } + +/** +* xe_eudebug_client_vm_bind_op_metadata_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @op_ref_seqno: base vm bind op reference seqno +* @metadata_handle: metadata handle +* @metadata_cookie: metadata cookie +* +* Logs vm bind op metadata event in client's event log. +*/ +void xe_eudebug_client_vm_bind_op_metadata_event(struct
xe_eudebug_client*c,lib/xe/xe_eudebug.c +1
-0+ uint32_t event_flags,
uint64_top_ref_seqno,lib/xe/xe_eudebug.c +1
-0+ uint64_t metadata_handle,
uint64_tmetadata_cookie) {lib/xe/xe_eudebug.c +3
-0+struct drm_xe_eudebug_event_vm_bind_op_metadata op; + + base_event(c, to_base(op),
DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA,lib/xe/xe_eudebug.c +16
-0+ event_flags, sizeof(op)); + op.vm_bind_op_ref_seqno = op_ref_seqno; + op.metadata_handle = metadata_handle; + op.metadata_cookie = metadata_cookie; + +xe_eudebug_event_log_write (c->log, (void *)&op); } + +/** +* xe_eudebug_client_vm_bind_ufence_event: +* @c: pointer to xe_eudebug_client structure +* @event_flags: base event flags +* @ref_seqno: base vm bind event seqno +* +* Logs vm bind ufence event in client's event log. +*/ +void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client*c,
uint32_tevent_flags,lib/xe/xe_eudebug.c +5
-0+ uint64_t ref_seqno) +{ +struct drm_xe_eudebug_event_vm_bind_ufence f; + + base_event(c, to_base(f),
DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,lib/xe/xe_eudebug.c +9
-0+ event_flags, sizeof(f)); + f.vm_bind_ref_seqno = ref_seqno; + +xe_eudebug_event_log_write (c->log, (void *)&f); } + +static bool has_user_fence (const struct drm_xe_sync *sync,uint32_t +num_syncs) { +while (num_syncs--) + if (sync[num_syncs].type ==
DRM_XE_SYNC_TYPE_USER_FENCE)lib/xe/xe_eudebug.c +6
-0+return true; + +return false; +} + +#define for_each_metadata (__m, __ext)\lib/xe/xe_eudebug.c +4
-0+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)lib/xe/xe_eudebug.c +3
-0+ +static int __xe_eudebug_client_vm_bind (struct xe_eudebug_client *c, + int fd, uint32_t vm, uint32_t
exec_queue,lib/xe/xe_eudebug.c +44
-0+ uint32_t bo, uint64_t offset, + uint64_t addr, uint64_t size, + uint32_t op, uint32_t flags, + struct drm_xe_sync *sync, + uint32_t num_syncs, + uint32_t prefetch_region, + uint8_t pat_index, uint64_t op_ext) { + struct drm_xe_vm_bind_op_ext_attach_debug *metadata; +const bool ufence =has_user_fence (sync, num_syncs); +const uint32_t bind_flags = ufence ? +DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE :0 ; +uint64_t seqno =0 , op_seqno =0 , num_metadata =0 ; +uint32_t bind_base_flags =0 ; +int ret; + +for_each_metadata (metadata, op_ext) + num_metadata++; + +switch (op) { +case DRM_XE_VM_BIND_OP_MAP : + bind_base_flags =DRM_XE_EUDEBUG_EVENT_CREATE ; +break ; +case DRM_XE_VM_BIND_OP_UNMAP : + bind_base_flags =DRM_XE_EUDEBUG_EVENT_DESTROY ; +igt_assert_eq (num_metadata,0 ); +igt_assert_eq (ufence, false); +break ; +default : +/* XXX unmap all? */ +igt_assert (op); +break ; + } + + ret =___xe_vm_bind (fd, vm, exec_queue, bo, offset, addr, size, + op, flags, sync, num_syncs, prefetch_region, + pat_index,0 , op_ext); + +if (ret) +return ret; + +if (!bind_base_flags) +return -EINVAL ; + + xe_eudebug_client_vm_bind_event(c,
DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,lib/xe/xe_eudebug.c +8
-0+ fd, vm, bind_flags, 1, &seqno); +xe_eudebug_client_vm_bind_op_event (c, bind_base_flags, + seqno, &op_seqno, addr, size, + num_metadata); + +for_each_metadata (metadata, op_ext) + xe_eudebug_client_vm_bind_op_metadata_event(c, +
DRM_XE_EUDEBUG_EVENT_CREATE,lib/xe/xe_eudebug.c +2
-0+ op_seqno, + metadata-Quoted 1 line
metadata_id,lib/xe/xe_eudebug.c +3
-0+ metadata->cookie); +if (ufence) + xe_eudebug_client_vm_bind_ufence_event(c,
DRM_XE_EUDEBUG_EVENT_CREATE|
+DRM_XE_EUDEBUG_EVENT_NEED_ACK,lib/xe/xe_eudebug.c +7
-0+ seqno); +return ret; +} + +static void _xe_eudebug_client_vm_bind (struct xe_eudebug_client *c,int fd, +uint32_t vm,uint32_t bo, + uint64_t offset, uint64_t addr, uint64_tsize,
lib/xe/xe_eudebug.c +10
-0+uint32_t op, + uint32_t flags, + struct drm_xe_sync *sync, + uint32_t num_syncs, + uint64_t op_ext) +{ + const uint32_t exec_queue_id = 0; +const uint32_t prefetch_region =0 ; + + igt_assert_eq(__xe_eudebug_client_vm_bind(c, fd, vm,
exec_queue_id, bo, offset,lib/xe/xe_eudebug.c +2
-0+ addr, size, op, flags, + sync, num_syncs,
prefetch_region,lib/xe/xe_eudebug.c +1
-0+ DEFAULT_PAT_INDEX,
op_ext),lib/xe/xe_eudebug.c +20
-0+ 0); +} + +/** +* xe_eudebug_client_vm_bind_flags +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @bo: buffer object handle +* @offset: offset within buffer object +* @addr: ppgtt address +* @size: size of the binding +* @flags: vm_bind flags +* @sync: sync objects +* @num_syncs: number of sync objects +* @op_ext: BIND_OP extensions +* +* Calls xe vm_bind ioctl and logs the corresponding event in client's event log. +*/ +void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, int fd,
uint32_tvm,lib/xe/xe_eudebug.c +3
-0+ uint32_t bo, uint64_t offset, + uint64_t addr, uint64_t size, uint32_t flags, + struct drm_xe_sync *sync, uint32_t
num_syncs,lib/xe/xe_eudebug.c +20
-0+ uint64_t op_ext) +{ +_xe_eudebug_client_vm_bind (c, fd, vm, bo, offset, addr, size, +DRM_XE_VM_BIND_OP_MAP , flags, + sync, num_syncs, op_ext); +} + +/** +* xe_eudebug_client_vm_bind +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @bo: buffer object handle +* @offset: offset within buffer object +* @addr: ppgtt address +* @size: size of the binding +* +* Calls xe vm_bind ioctl and logs the corresponding event in client's event log. +*/ +void xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
uint32_tvm,lib/xe/xe_eudebug.c +25
-0+ uint32_t bo, uint64_t offset, + uint64_t addr, uint64_t size) { + const uint32_t flags = 0; +struct drm_xe_sync *sync =NULL ; +const uint32_t num_syncs =0 ; +const uint64_t op_ext =0 ; + +xe_eudebug_client_vm_bind_flags (c, fd, vm, bo, offset, addr, size, + flags, + sync, num_syncs, op_ext); +} + +/** +* xe_eudebug_client_vm_unbind_flags +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @offset: offset +* @addr: ppgtt address +* @size: size of the binding +* @flags: vm_bind flags +* @sync: sync objects +* @num_syncs: number of sync objects +* +* Calls xe vm_unbind ioctl and logs the corresponding event in client's event log.
+ */
+void xe_eudebug_client_vm_unbind_flags(structxe_eudebug_client*c, int fd,lib/xe/xe_eudebug.c +2
-0+ uint32_t vm, uint64_t offset, + uint64_t addr, uint64_t size, uint32_tflags,
lib/xe/xe_eudebug.c +1
-0+struct drm_xe_sync *sync, uint32_t
num_syncs) {lib/xe/xe_eudebug.c +15
-0+_xe_eudebug_client_vm_bind (c, fd, vm,0 , offset, addr, size, +DRM_XE_VM_BIND_OP_UNMAP , flags, + sync, num_syncs,0 ); +} + +/** +* xe_eudebug_client_vm_unbind +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @vm: vm handle +* @offset: offset +* @addr: ppgtt address +* @size: size of the binding +* +* Calls xe vm_unbind ioctl and logs the corresponding event in client's event log.
+ */
+void xe_eudebug_client_vm_unbind(structxe_eudebug_client*c, int fd,uint32_tvm,lib/xe/xe_eudebug.c +1
-0+ uint64_t offset, uint64_t addr, uint64_t size){
lib/xe/xe_eudebug.c +7
-0+const uint32_t flags =0 ; +struct drm_xe_sync *sync =NULL ; +const uint32_t num_syncs =0 ; + +xe_eudebug_client_vm_unbind_flags (c, fd, vm, offset, addr, size, + flags, sync, num_syncs); +}lib/xe/xe_eudebug.h index renamed from lib/xe/xe_eudebug.h +0
-0
8dc153d27..1592704ab100644lib/xe/xe_eudebug.h +3
-0@@ -99,6 +99,18 @@ typedef void (*xe_eudebug_trigger_fn)(structxe_eudebug_debugger *, */ #define XE_EUDEBUG_DEFAULT_TIMEOUT_MS 25000ULL +#define XE_EUDEBUG_FILTER_EVENT_NONE BIT(DRM_XE_EUDEBUG_EVENT_NONE) +#define XE_EUDEBUG_FILTER_EVENT_READ BIT (DRM_XE_EUDEBUG_EVENT_READ) +#define XE_EUDEBUG_FILTER_EVENT_OPEN
BIT(DRM_XE_EUDEBUG_EVENT_OPEN)
+#defineXE_EUDEBUG_FILTER_EVENT_VM
BIT(DRM_XE_EUDEBUG_EVENT_VM)
+#defineXE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE
BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE)
+#defineXE_EUDEBUG_FILTER_EVENT_EU_ATTENTION
Quoted 8 lines
BIT(DRM_XE_EUDEBUG_EVENT_EU_ATTENTION)
+#defineXE_EUDEBUG_FILTER_EVENT_VM_BIND
BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND)
+#defineXE_EUDEBUG_FILTER_EVENT_VM_BIND_OP
BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP)
+#defineXE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCEBIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
+#defineXE_EUDEUBG_FILTER_ALL
Typo: XE_EUDEBUG_FILTER_ALL
Quoted 84 lines
GENMASK(DRM_XE_EUDEBUG_EVENT_MAX_EVENT, 0)lib/xe/xe_eudebug.h +2
-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_tlen); structdrm_xe_eudebug_event*xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno); @@ -106,9 +118,10 @@ structxe_eudebug_event_log*xe_eudebug_event_log_create(const char *name, unsigned int max_size); voidxe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l); voidxe_eudebug_event_log_print(struct xe_eudebug_event_log *l, bool debug); - voidxe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudebug_event_log *d);
+void xe_eudebug_event_log_compare(structxe_eudebug_event_log*c, structxe_eudebug_event_log*d,lib/xe/xe_eudebug.h +1
-0+ uint32_t filter); void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct
drm_xe_eudebug_event*e); -voidxe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l);lib/xe/xe_eudebug.h +3
-0+void xe_eudebug_event_log_match_opposite (struct xe_eudebug_event_log +*l,uint32_t filter);struct xe_eudebug_debugger * xe_eudebug_debugger_create(int xe, uint64_t flags, void *data); @@ -142,6 +155,32 @@ uint32_t xe_eudebug_client_exec_queue_create(struct
xe_eudebug_client*c, int fd
structdrm_xe_exec_queue_create
*create); void xe_eudebug_client_exec_queue_destroy(structxe_eudebug_client*c, int fd,
structdrm_xe_exec_queue_create
*create);
+void xe_eudebug_client_vm_bind_event(structxe_eudebug_client*c,uint32_tevent_flags, int fd,lib/xe/xe_eudebug.h +2
-0+ uint32_t vm, uint32_t bind_flags, + uint32_t num_ops, uint64_t *ref_seqno);void
+xe_eudebug_client_vm_bind_op_event(structxe_eudebug_client*c,uint32_tevent_flags,lib/xe/xe_eudebug.h +1
-0+uint64_t ref_seqno, uint64_t
*op_ref_seqno,lib/xe/xe_eudebug.h +3
-0+ uint64_t addr, uint64_t range, + uint64_t num_extensions); +void xe_eudebug_client_vm_bind_op_metadata_event(struct
xe_eudebug_client*c,lib/xe/xe_eudebug.h +1
-0+ uint32_t event_flags,
uint64_top_ref_seqno,lib/xe/xe_eudebug.h +1
-0+ uint64_t metadata_handle,
uint64_tmetadata_cookie); void +xe_eudebug_client_vm_bind_ufence_event(structxe_eudebug_client*c,uint32_tevent_flags,lib/xe/xe_eudebug.h +2
-0+ uint64_t ref_seqno); +void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, int fd,
uint32_tvm,lib/xe/xe_eudebug.h +3
-0+ uint32_t bo, uint64_t offset, + uint64_t addr, uint64_t size, uint32_t flags, + struct drm_xe_sync *sync, uint32_t
num_syncs,lib/xe/xe_eudebug.h +2
-0+ uint64_t op_ext); +void xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd,
uint32_tvm,lib/xe/xe_eudebug.h +5
-0+ uint32_t bo, uint64_t offset, + uint64_t addr, uint64_t size); void +xe_eudebug_client_vm_unbind_flags (struct xe_eudebug_client *c,int fd, +uint32_t vm,uint64_t offset, + uint64_t addr, uint64_t size, uint32_tflags,
lib/xe/xe_eudebug.h +1
-0+struct drm_xe_sync *sync, uint32_t
num_syncs); void
+xe_eudebug_client_vm_unbind(structxe_eudebug_client*c, int fd,uint32_tvm,lib/xe/xe_eudebug.h +1
-0+ uint64_t offset, uint64_t addr, uint64_t size); struct xe_eudebug_session *xe_eudebug_session_create(int fd,
xe_eudebug_client_work_fnwork, @@ -149,4 +188,4 @@ structxe_eudebug_session*xe_eudebug_session_create(int fd,
void*test_private);
voidxe_eudebug_session_destroy(struct xe_eudebug_session *s); voidxe_eudebug_session_run(struct xe_eudebug_session *s); -voidxe_eudebug_session_check(struct xe_eudebug_session *s, bool match_opposite);lib/xe/xe_eudebug.h +2
-1+void xe_eudebug_session_check (struct xe_eudebug_session *s,bool +match_opposite,uint32_t filter); --2.34.1
PATCH v2 9/66 lib/xe_eudebug: Add metadata support
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Support metadata events in debugger library by:
- Adding metadata events to log checking functions.
- Introducing eudebug vm_bind wrapper which allows to attach debug metadata and cookie
- Implementing xe_eudebug_client_metadata_create|destroy wrappers.
--- lib/xe/xe_eudebug.c | 136 ++++++++++++++++++++++++++++++++++++++++++-- lib/xe/xe_eudebug.h | 6 ++ 2 files changed, 138 insertions(+), 4 deletions(-)
lib/xe/xe_eudebug.c +132 -4
@@ -69,6 +69,10 @@ static const char *type_to_str(unsigned int type)return "vm_bind_op" ;case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE :return "vm_bind_ufence" ; +case DRM_XE_EUDEBUG_EVENT_METADATA : +return "metadata" ; +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA : +return "vm_bind_op_metadata" ; }return "UNKNOWN" ;
@@ -154,6 +158,20 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *b)sprintf (b,"vm_bind_ref_seqno=%lld" , f->vm_bind_ref_seqno);break ; } +case DRM_XE_EUDEBUG_EVENT_METADATA : { +struct drm_xe_eudebug_event_metadata *em = (void *)e; + +sprintf (b,"client_handle=%llu, metadata_handle=%llu, type=%llu, len=%llu" , + em->client_handle, em->metadata_handle, em->type, em->len); +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA : { +struct drm_xe_eudebug_event_vm_bind_op_metadata *op = (void *)e; + +sprintf (b,"vm_bind_op_ref_seqno=%lld, metadata_handle=%llu, metadata_cookie=%llu" , + op->vm_bind_op_ref_seqno, op->metadata_handle, op->metadata_cookie); +break ; + }default :strcpy (b,"<...>" ); }
@@ -417,6 +435,16 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data) ret =1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA : { +struct drm_xe_eudebug_event_vm_bind_op_metadata *ea = (void *)a; +struct drm_xe_eudebug_event_vm_bind_op_metadata *eb = (void *)b; + +if (ea->metadata_handle == eb->metadata_handle && + ea->metadata_cookie == eb->metadata_cookie) + ret =1 ; +break ; + } +default : ret =1 ;break ;
@@ -483,6 +511,20 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)break ; } +case DRM_XE_EUDEBUG_EVENT_METADATA : { +struct drm_xe_eudebug_event_metadata *em = (struct drm_xe_eudebug_event_metadata *)e; + +if (em->client_handle == h) +return 1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA : { +struct drm_xe_eudebug_event_vm_bind_op_metadata *eo = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)e; + +if (eo->vm_bind_op_ref_seqno == *bind_op_seqno) +return 1 ; +break ; + }default :break ; }
@@ -547,6 +589,24 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)return 1 ;break ; } +case DRM_XE_EUDEBUG_EVENT_METADATA : { +struct drm_xe_eudebug_event_metadata *em = (void *)e; +struct drm_xe_eudebug_event_metadata *filter = (struct drm_xe_eudebug_event_metadata *)data; + +if (em->metadata_handle == filter->metadata_handle) +return 1 ; +break ; + } +case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA : { +struct drm_xe_eudebug_event_vm_bind_op_metadata *avmb = (void *)e; +struct drm_xe_eudebug_event_vm_bind_op_metadata *filter = (struct drm_xe_eudebug_event_vm_bind_op_metadata *)data; + +if (avmb->metadata_handle == filter->metadata_handle && + avmb->metadata_cookie == filter->metadata_cookie) +return 1 ; +break ; + } +default :break ; }
@@ -889,8 +949,9 @@ xe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filcontinue ;/* No opposite matching for binds */ -if (ce->type >=DRM_XE_EUDEBUG_EVENT_VM_BIND && - ce->type <=DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE ) +if ((ce->type >=DRM_XE_EUDEBUG_EVENT_VM_BIND && + ce->type <=DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE ) || + ce->type ==DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA )continue ; de =opposite_event_match (l, ce, ce);
@@ -1486,6 +1547,22 @@ static void exec_queue_event(struct xe_eudebug_client *c, uint32_t flags,xe_eudebug_event_log_write (c->log, (void *)&ee); } +static void metadata_event (struct xe_eudebug_client *c,uint32_t flags, +int client_fd,uint32_t id,uint64_t type,uint64_t len) +{ +struct drm_xe_eudebug_event_metadata em; + +base_event (c,to_base (em),DRM_XE_EUDEBUG_EVENT_METADATA , + flags,sizeof (em)); + + em.client_handle = client_fd; + em.metadata_handle = id; + em.type = type; + em.len = len; + +xe_eudebug_event_log_write (c->log, (void *)&em); +} +/* Eu debugger wrappers around resource creating xe ioctls. */ /**
@@ -1528,8 +1605,8 @@ void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd)* @flags: vm bind flags * @ext: pointer to the first user extension * -* Calls xe_vm_create() and logs the corresponding event in -* client's event log. +* Calls xe_vm_create() and logs corresponding events +* (including vm set metadata events) in client's event log. * * Returns: valid vm handle */
@@ -1909,3 +1986,54 @@ void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, int fd, uint32_t vxe_eudebug_client_vm_unbind_flags (c, fd, vm, offset, addr, size, flags, sync, num_syncs); } + +/** +* xe_eudebug_client_metadata_create: +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @type: debug metadata type +* @len: size of @data +* @data: debug metadata paylad +* +* Calls xe metadata create ioctl and logs the corresponding event in +* client's event log. +* +* Return: valid debug metadata id. +*/ +uint32_t xe_eudebug_client_metadata_create (struct xe_eudebug_client *c,int fd, +int type,size_t len,void *data) +{ +struct drm_xe_debug_metadata_create create = { + .type = type, + .user_addr =to_user_pointer (data), + .len = len + }; + +igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_DEBUG_METADATA_CREATE , &create),0 ); + +metadata_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , fd, create.metadata_id, type, len); + +return create.metadata_id; +} + +/** +* xe_eudebug_client_metadata_destroy: +* @c: pointer to xe_eudebug_client structure +* @fd: xe client +* @id: xe debug metadata handle +* @type: debug metadata type +* @len: size of debug metadata payload +* +* Calls xe metadata destroy ioctl and logs the corresponding event in +* client's event log. +*/ +void xe_eudebug_client_metadata_destroy (struct xe_eudebug_client *c,int fd, +uint32_t id,int type,size_t len) +{ +struct drm_xe_debug_metadata_destroy destroy = { .metadata_id = id }; + + +igt_assert_eq (igt_ioctl (fd,DRM_IOCTL_XE_DEBUG_METADATA_DESTROY , &destroy),0 ); + +metadata_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , fd, id, type, len); +}
lib/xe/xe_eudebug.h +6 -0
@@ -167,6 +167,7 @@ void xe_eudebug_client_vm_bind_op_metadata_event(struct xe_eudebug_client *c, uint64_t metadata_handle, uint64_t metadata_cookie);void xe_eudebug_client_vm_bind_ufence_event (struct xe_eudebug_client *c,uint32_t event_flags,uint64_t ref_seqno); + void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, int fd, uint32_t vm, uint32_t bo, uint64_t offset, uint64_t addr, uint64_t size, uint32_t flags,
@@ -182,6 +183,11 @@ void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c, int fd,void xe_eudebug_client_vm_unbind (struct xe_eudebug_client *c,int fd,uint32_t vm,uint64_t offset,uint64_t addr,uint64_t size); +uint32_t xe_eudebug_client_metadata_create (struct xe_eudebug_client *c,int fd, +int type,size_t len,void *data); +void xe_eudebug_client_metadata_destroy (struct xe_eudebug_client *c,int fd, +uint32_t id,int type,size_t len); + struct xe_eudebug_session *xe_eudebug_session_create(int fd, xe_eudebug_client_work_fn work, unsigned int flags,
Signature · 1 line
2.34.1
PATCH v2 10/66 lib/xe_eudebug: Add support for user fence acking
In reply to Christoph ManszewskiIf the debugee uses user fences for synchronization, the debugger will recieve a 'UFENCE_EVENT' and the fence won't be released untill the debugger acks it. Note that for the fence to release, both the job completion and debugger ack are required. Add a library function to ack user fences.
--- lib/xe/xe_eudebug.c | 14 ++++++++++++++ lib/xe/xe_eudebug.h | 2 ++ 2 files changed, 16 insertions(+)
lib/xe/xe_eudebug.c +14 -0
@@ -2037,3 +2037,17 @@ void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,metadata_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , fd, id, type, len); } + +void xe_eudebug_ack_ufence (int debugfd, +const struct drm_xe_eudebug_event_vm_bind_ufence *f) +{ +struct drm_xe_eudebug_ack_event ack = {0 , }; +char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN ]; + + ack.type = f->base.type; + ack.seqno = f->base.seqno; + +xe_eudebug_event_to_str ((void *)f, event_str,XE_EUDEBUG_EVENT_STRING_MAX_LEN ); +igt_debug ("delivering ack for event: %s\n" , event_str); +igt_assert_eq (igt_ioctl (debugfd,DRM_XE_EUDEBUG_IOCTL_ACK_EVENT , &ack),0 ); +}
lib/xe/xe_eudebug.h +2 -0
@@ -167,6 +167,8 @@ void xe_eudebug_client_vm_bind_op_metadata_event(struct xe_eudebug_client *c, uint64_t metadata_handle, uint64_t metadata_cookie);void xe_eudebug_client_vm_bind_ufence_event (struct xe_eudebug_client *c,uint32_t event_flags,uint64_t ref_seqno); +void xe_eudebug_ack_ufence (int debugfd, +const struct drm_xe_eudebug_event_vm_bind_ufence *f); void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, int fd, uint32_t vm, uint32_t bo, uint64_t offset,
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 10/66] lib/xe_eudebug: Add support for user fence acking
With issues addressed:
Quoted 16 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 10/66]lib/xe_eudebug: Add support for user fence acking
Quoted 1 line
If the debugee uses user fences for synchronization, the debugger will recieve
Typo: receive
Quoted 1 line
a '
UFENCE_EVENT' and the fence won't be released untill the debugger acks it.
Typo: until
Quoted 56 lines
Note that for the fence to release, both the job completion and debugger ack are required. Add a library function to ack user fences.
Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Christoph Manszewski <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- lib/xe/xe_eudebug.c | 14 ++++++++++++++ lib/xe/xe_eudebug.h | 2 ++ 2 files changed, 16 insertions(+)lib/xe/xe_eudebug.c index renamed from lib/xe/xe_eudebug.c +0
-0
8164a2d50..af7cc5fc4100644lib/xe/xe_eudebug.c +0
-0@@ -2037,3 +2037,17 @@ void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd, metadata_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, fd, id, type,len); }
lib/xe/xe_eudebug.c +3
-0+ +void xe_eudebug_ack_ufence(int debugfd, + const struct
drm_xe_eudebug_event_vm_bind_ufence*f) {lib/xe/xe_eudebug.c +7
-0+struct drm_xe_eudebug_ack_event ack = {0 , }; +char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN ]; + + ack.type = f->base.type; + ack.seqno = f->base.seqno; + + xe_eudebug_event_to_str((void *)f, event_str,
XE_EUDEBUG_EVENT_STRING_MAX_LEN);lib/xe/xe_eudebug.c +2
-0+igt_debug ("delivering ack for event: %s\n" , event_str); + igt_assert_eq(igt_ioctl(debugfd,
DRM_XE_EUDEBUG_IOCTL_ACK_EVENT,
+&ack), 0); }lib/xe/xe_eudebug.h index renamed from lib/xe/xe_eudebug.h +0
-0
24336981f..ec75634f5100644lib/xe/xe_eudebug.h +0
-0@@ -167,6 +167,8 @@ voidxe_eudebug_client_vm_bind_op_metadata_event(struct
xe_eudebug_client*c,
uint64_tmetadata_handle,uint64_tmetadata_cookie); void xe_eudebug_client_vm_bind_ufence_event(structxe_eudebug_client*c,uint32_tevent_flags,lib/xe/xe_eudebug.h +2
-0uint64_t ref_seqno); +void xe_eudebug_ack_ufence(int debugfd, + const struct
drm_xe_eudebug_event_vm_bind_ufence*f);void xe_eudebug_client_vm_bind_flags(struct
xe_eudebug_client*c, int fd,uint32_tvm,
uint32_tbo,uint64_toffset,
--
2.34.1
PATCH v2 11/66 lib/xe_eudebug: Add support for dynamic debugger sysfs toggle
In reply to Christoph ManszewskiThe debugger now uses a dedicated sysfs entry:
/sys/class/drm/card<N>/device/enable_eudebug
to toggle the debugger on/off. This change adds helper functons for toggling the debugger.
--- lib/xe/xe_eudebug.c | 88 +++++++++++++++++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 3 ++ 2 files changed, 91 insertions(+)
lib/xe/xe_eudebug.c +88 -0
@@ -7,10 +7,12 @@#include <poll.h> #include <signal.h> #include <sys/select.h> +#include <sys/stat.h> #include <sys/types.h> #include <sys/wait.h> #include "igt.h" +#include "igt_sysfs.h" #include "intel_pat.h" #include "xe_eudebug.h" #include "xe_ioctl.h"
@@ -1040,6 +1042,24 @@ static void *debugger_worker_loop(void *data)return NULL ; } +/** +* xe_eudebug_debugger_available: +* @fd: Xe file descriptor +* +* Returns: true it debugger connection is available, false otherwise. +*/ +bool xe_eudebug_debugger_available (int fd) +{ +struct drm_xe_eudebug_connect param = { .pid =getpid () }; +int debugfd; + + debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , ¶m); +if (debugfd >=0 ) +close (debugfd); + +return debugfd >=0 ; +} +/** * xe_eudebug_debugger_create: * @master_fd: xe client used to open the debugger connection
@@ -1563,6 +1583,74 @@ static void metadata_event(struct xe_eudebug_client *c, uint32_t flags,xe_eudebug_event_log_write (c->log, (void *)&em); } +static int enable_getset (int fd,bool *old,bool *new) +{ +static const char *const fname ="enable_eudebug" ; +int ret =0 ; + +int sysfs, device_fd; +bool val_before; +struct stat st; + +igt_assert (new || old); + +igt_assert_eq (fstat (fd, &st),0 ); + sysfs =igt_sysfs_open (fd); +if (sysfs <0 ) +return -1 ; + + device_fd =openat (sysfs,"device" ,O_DIRECTORY |O_RDONLY ); +close (sysfs); +if (device_fd <0 ) +return -1 ; + +if (!__igt_sysfs_get_boolean (device_fd, fname, &val_before)) { + ret =-1 ; + goto out; + } + +igt_debug ("enable_eudebug before: %d\n" , val_before); + +if (old) + *old = val_before; + + ret =0 ; +if (new) { +if (__igt_sysfs_set_boolean (device_fd, fname, *new)) +igt_assert_eq (igt_sysfs_get_boolean (device_fd, fname), *new); +else + ret =-1 ; + } + +out: +close (device_fd); +return ret; +} + +/** +* xe_eudebug_enable +* @fd: xe client +* @enable: state toggle - true to enable, false to disable +* +* Enables/disables eudebug capability by writing to +* '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry. +* +* Returns: previous toggle value, i.e. true when eudebugging was enabled, +* false when eudebugging was disabled. +*/ +bool xe_eudebug_enable (int fd,bool enable) +{ +bool old = false; +int ret =enable_getset (fd, &old, &enable); + +if (ret) { +igt_skip_on (enable); + old = false; + } + +return old; +} +/* Eu debugger wrappers around resource creating xe ioctls. */ /**
lib/xe/xe_eudebug.h +3 -0
@@ -123,6 +123,7 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *c, struct xe_eudevoid xe_eudebug_event_log_write (struct xe_eudebug_event_log *l,struct drm_xe_eudebug_event *e);void xe_eudebug_event_log_match_opposite (struct xe_eudebug_event_log *l,uint32_t filter); +bool xe_eudebug_debugger_available (int fd);struct xe_eudebug_debugger *xe_eudebug_debugger_create (int xe,uint64_t flags,void *data);void xe_eudebug_debugger_destroy (struct xe_eudebug_debugger *d);
@@ -146,6 +147,8 @@ void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);uint64_t xe_eudebug_client_get_seqno (struct xe_eudebug_client *c);void xe_eudebug_client_set_data (struct xe_eudebug_client *c,void *ptr); +bool xe_eudebug_enable (int fd,bool enable); +int xe_eudebug_client_open_driver (struct xe_eudebug_client *c);void xe_eudebug_client_close_driver (struct xe_eudebug_client *c,int fd); uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 11/66] lib/xe_eudebug: Add support for dynamic debugger sysfs toggle
With typo fixed:
Quoted 16 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 11/66]lib/xe_eudebug: Add support for dynamic debugger sysfs toggle
Quoted 5 lines
The debugger now uses a dedicated sysfs entry:
/sys/class/drm/card<N>/device/enable_eudebug
to toggle the debugger on/off. This change adds helper functons for toggling
Typo: functions
Quoted 155 lines
the debugger.
Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Christoph Manszewski <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- lib/xe/xe_eudebug.c | 88 +++++++++++++++++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 3 ++ 2 files changed, 91 insertions(+)lib/xe/xe_eudebug.c index renamed from lib/xe/xe_eudebug.c +0
-0
af7cc5fc4..36eef25c7100644lib/xe/xe_eudebug.c +20
-0@@ -7,10 +7,12 @@#include <poll.h> #include <signal.h> #include <sys/select.h> +#include <sys/stat.h> #include <sys/types.h> #include <sys/wait.h> #include "igt.h" +#include "igt_sysfs.h" #include "intel_pat.h" #include "xe_eudebug.h" #include "xe_ioctl.h" @@ -1040,6 +1042,24 @@ static void *debugger_worker_loop(void *data)return NULL ; } +/** +* xe_eudebug_debugger_available: +* @fd: Xe file descriptor +* +* Returns: true it debugger connection is available, false otherwise. +*/ +bool xe_eudebug_debugger_available (int fd) { +struct drm_xe_eudebug_connect param = { .pid =getpid () }; +int debugfd; + + debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , ¶m); +if (debugfd >=0 ) +close (debugfd); + +return debugfd >=0 ; +} +/** * xe_eudebug_debugger_create: * @master_fd: xe client used to open the debugger connection @@ -1563,6 +1583,74 @@ static void metadata_event(struct xe_eudebug_client *c,
uint32_tflags,lib/xe/xe_eudebug.c +34
-0xe_eudebug_event_log_write (c->log, (void *)&em); } +static int enable_getset (int fd,bool *old,bool *new) { +static const char *const fname ="enable_eudebug" ; +int ret =0 ; + +int sysfs, device_fd; +bool val_before; +struct stat st; + +igt_assert (new || old); + +igt_assert_eq (fstat (fd, &st),0 ); + sysfs =igt_sysfs_open (fd); +if (sysfs <0 ) +return -1 ; + + device_fd =openat (sysfs,"device" ,O_DIRECTORY |O_RDONLY ); +close (sysfs); +if (device_fd <0 ) +return -1 ; + +if (!__igt_sysfs_get_boolean (device_fd, fname, &val_before)) { + ret =-1 ; + goto out; + } + +igt_debug ("enable_eudebug before: %d\n" , val_before); + +if (old) + *old = val_before; + + ret =0 ; +if (new) { +if (__igt_sysfs_set_boolean (device_fd, fname, *new)) + igt_assert_eq(igt_sysfs_get_boolean(device_fd,fname), *new);
lib/xe/xe_eudebug.c +33
-0+else + ret =-1 ; + } + +out: +close (device_fd); +return ret; +} + +/** +* xe_eudebug_enable +* @fd: xe client +* @enable: state toggle - true to enable, false to disable +* +* Enables/disables eudebug capability by writing to +* '/sys/class/drm/card<N>/device/enable_eudebug' sysfs entry. +* +* Returns: previous toggle value, i.e. true when eudebugging was +enabled, +* false when eudebugging was disabled. +*/ +bool xe_eudebug_enable (int fd,bool enable) { +bool old = false; +int ret =enable_getset (fd, &old, &enable); + +if (ret) { +igt_skip_on (enable); + old = false; + } + +return old; +} +/* Eu debugger wrappers around resource creating xe ioctls. */ /** lib/xe/xe_eudebug.h index renamed from lib/xe/xe_eudebug.h +0
-0
ec75634f5..1343cb25c100644lib/xe/xe_eudebug.h +0
-0@@ -123,6 +123,7 @@ void xe_eudebug_event_log_compare(struct
xe_eudebug_event_log*c, structxe_eudevoidxe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eudebug_event *e); voidxe_eudebug_event_log_match_opposite(struct xe_eudebug_event_log *l, uint32_t filter);+bool
xe_eudebug_debugger_available(int fd);
structxe_eudebug_debugger*
xe_eudebug_debugger_create(int xe, uint64_t flags, void *data); voidxe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d); @@ -146,6 +147,8 @@ voidxe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage);uint64_txe_eudebug_client_get_seqno(struct xe_eudebug_client *c); voidxe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);lib/xe/xe_eudebug.h +2
-0+bool xe_eudebug_enable (int fd,bool enable); +int xe_eudebug_client_open_driver (struct xe_eudebug_client *c);void
xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd);uint32_txe_eudebug_client_vm_create(structxe_eudebug_client*c, int fd, --
2.34.1
PATCH v2 12/66 tests/xe_eudebug: Test open close events
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Introduce basic tests which validate client create/destroy events sent on xe drm client open/close.
--- tests/intel/xe_eudebug.c | 49 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-)
tests/intel/xe_eudebug.c +48 -1
@@ -12,8 +12,16 @@* Test category: functionality test */ -#include <xe_drm.h> #include "igt.h" +#include "xe/xe_eudebug.h" + +static void run_basic_client (struct xe_eudebug_client *c) +{ +int fd; + + fd =xe_eudebug_client_open_driver (c); +xe_eudebug_client_close_driver (c, fd); +}static int __debug_connect (int fd,int *debugfd,struct drm_xe_eudebug_connect *param) {
@@ -116,6 +124,39 @@ static void test_close(int fd)close (debug_fd1); } +/** +* SUBTEST: basic-client +* Description: +* Attach the debugger to process which opens and closes xe drm client. +* +* SUBTEST: multiple-sessions +* Description: +* Simultaneously attach many debuggers to many processes. +* Each process opens and closes xe drm client. +*/ + +static void test_basic_sessions (int fd,unsigned int flags,int count) +{ +struct xe_eudebug_session **s; +int i; + + s =calloc (count,sizeof (*s)); + +igt_assert (s); + +for (i =0 ; i < count; i++) + s[i] =xe_eudebug_session_create (fd, run_basic_client, flags,NULL ); + +for (i =0 ; i < count; i++) +xe_eudebug_session_run (s[i]); + +for (i =0 ; i < count; i++) +xe_eudebug_session_check (s[i], true,0 ); + +for (i =0 ; i < count; i++) +xe_eudebug_session_destroy (s[i]); +} + igt_main {int fd;
@@ -130,6 +171,12 @@ igt_main igt_subtest("basic-close")test_close (fd); + igt_subtest("basic-client") +test_basic_sessions (fd,0 ,1 ); + + igt_subtest("multiple-sessions") +test_basic_sessions (fd,0 ,4 ); +igt_fixture drm_close_driver (fd ); }
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 12/66] tests/xe_eudebug: Test open close events
Quoted 104 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:44 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 12/66] tests/xe_eudebug: Test open close eventsFrom: Dominik Grzegorzek <[email protected]>
Introduce basic tests which validate client create/destroy events sent on xe drm client open/close.
Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 49 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 48 insertions(+), 1 deletion(-)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
44a491319..7ca0138a2100644tests/intel/xe_eudebug.c +7
-1@@ -12,8 +12,16 @@* Test category: functionality test */ -#include <xe_drm.h> #include "igt.h" +#include "xe/xe_eudebug.h" + +static void run_basic_client (struct xe_eudebug_client *c) { +int fd; + + fd =xe_eudebug_client_open_driver (c); +xe_eudebug_client_close_driver (c, fd); } static int __debug_connect(int fd, int *debugfd, struct
drm_xe_eudebug_connect*param) { @@ -116,6 +124,39 @@ static voidtest_close(int fd)tests/intel/xe_eudebug.c +22
-0close (debug_fd1); } +/** +* SUBTEST: basic-client +* Description: +* Attach the debugger to process which opens and closes xe drm client. +* +* SUBTEST: multiple-sessions +* Description: +* Simultaneously attach many debuggers to many processes. +* Each process opens and closes xe drm client. +*/ + +static void test_basic_sessions (int fd,unsigned int flags,int count) +{ +struct xe_eudebug_session **s; +int i; + + s =calloc (count,sizeof (*s)); + +igt_assert (s); + +for (i =0 ; i < count; i++) + s[i] = xe_eudebug_session_create(fd, run_basic_client, flags,NULL);
tests/intel/xe_eudebug.c +17
-1+ +for (i =0 ; i < count; i++) +xe_eudebug_session_run (s[i]); + +for (i =0 ; i < count; i++) +xe_eudebug_session_check (s[i], true,0 ); + +for (i =0 ; i < count; i++) +xe_eudebug_session_destroy (s[i]); +} + igt_main {int fd;@@ -130,6 +171,12 @@ igt_main igt_subtest("basic-close")test_close (fd); + igt_subtest("basic-client") +test_basic_sessions (fd,0 ,1 ); + + igt_subtest("multiple-sessions") +test_basic_sessions (fd,0 ,4 ); +igt_fixture drm_close_driver (fd ); } --2.34.1
PATCH v2 13/66 tests/xe_eudebug: Exercise read_event ioctl
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Introduce synchronous test, which validates eu debugger read_event ioctl.
--- tests/intel/xe_eudebug.c | 109 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 108 insertions(+), 1 deletion(-)
tests/intel/xe_eudebug.c +108 -1
@@ -12,6 +12,9 @@* Test category: functionality test */ +#include <poll.h> +#include <sys/ioctl.h> +#include "igt.h" #include "xe/xe_eudebug.h"
@@ -23,6 +26,45 @@ 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) +{ +int ret; + + ret =igt_ioctl (debugfd,DRM_XE_EUDEBUG_IOCTL_READ_EVENT , event); +if (ret <0 ) +return -errno; + +return ret; +} + +static int __read_event (int debugfd,struct drm_xe_eudebug_event *event) +{ +int ret; + + ret =ioctl (debugfd,DRM_XE_EUDEBUG_IOCTL_READ_EVENT , event); +if (ret <0 ) +return -errno; + +return ret; +} + +static int poll_event (int fd,int timeout_ms) +{ +int ret; + +struct pollfd p = { + .fd = fd, + .events =POLLIN , + .revents =0 , + }; + + ret =poll (&p,1 , timeout_ms); +if (ret ==-1 ) +return -errno; + +return ret ==1 && (p.revents &POLLIN ); +} +static int __debug_connect (int fd,int *debugfd,struct drm_xe_eudebug_connect *param) {int ret =0 ;
@@ -124,6 +166,69 @@ static void test_close(int fd)close (debug_fd1); } +/** +* SUBTEST: basic-read-event +* Description: +* Synchronously exercise eu debugger event polling and reading. +*/ +#define MAX_EVENT_SIZE (32 * 1024) +static void test_read_event (int fd) +{ +struct drm_xe_eudebug_event *event; +struct xe_eudebug_debugger *d; +struct xe_eudebug_client *c; + + event =malloc (MAX_EVENT_SIZE ); +igt_assert (event); +memset (event,0 ,sizeof (*event)); + + c =xe_eudebug_client_create (fd, run_basic_client,0 ,NULL ); + d =xe_eudebug_debugger_create (fd,0 ,NULL ); + +igt_assert_eq (xe_eudebug_debugger_attach (d, c),0 ); +igt_assert_eq (poll_event (d->fd,500 ),0 ); + + event->len =1 ; + event->type =DRM_XE_EUDEBUG_EVENT_NONE ; +igt_assert_eq (read_event (d->fd, event), -EINVAL ); + + event->len =MAX_EVENT_SIZE ; + event->type =DRM_XE_EUDEBUG_EVENT_NONE ; +igt_assert_eq (read_event (d->fd, event), -EINVAL ); + +xe_eudebug_client_start (c); + +igt_assert_eq (poll_event (d->fd,500 ),1 ); + event->type =DRM_XE_EUDEBUG_EVENT_READ ; +igt_assert_eq (read_event (d->fd, event),0 ); + +igt_assert_eq (poll_event (d->fd,500 ),1 ); + event->len =MAX_EVENT_SIZE ; + event->flags =0 ; + event->type =DRM_XE_EUDEBUG_EVENT_READ ; +igt_assert_eq (read_event (d->fd, event),0 ); + +fcntl (d->fd,F_SETFL ,fcntl (d->fd,F_GETFL ) |O_NONBLOCK ); +igt_assert (fcntl (d->fd,F_GETFL ) &O_NONBLOCK ); + +igt_assert_eq (poll_event (d->fd,500 ),0 ); + event->len =MAX_EVENT_SIZE ; + event->flags =0 ; + event->type =DRM_XE_EUDEBUG_EVENT_READ ; +igt_assert_eq (__read_event (d->fd, event), -EAGAIN ); + +xe_eudebug_client_wait_done (c); +xe_eudebug_client_stop (c); + +igt_assert_eq (poll_event (d->fd,500 ),0 ); +igt_assert_eq (__read_event (d->fd, event), -EAGAIN ); + +xe_eudebug_debugger_destroy (d); +xe_eudebug_client_destroy (c); + +free (event); +} +/** * SUBTEST: basic-client * Description:
@@ -134,7 +239,6 @@ static void test_close(int fd)* Simultaneously attach many debuggers to many processes. * Each process opens and closes xe drm client. */ -static void test_basic_sessions (int fd,unsigned int flags,int count) {struct xe_eudebug_session **s;
@@ -171,6 +275,9 @@ igt_main igt_subtest("basic-close")test_close (fd); + igt_subtest("basic-read-event") +test_read_event (fd); + igt_subtest("basic-client")test_basic_sessions (fd,0 ,1 );
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 13/66] tests/xe_eudebug: Exercise read_event ioctl
Quoted 174 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 13/66] tests/xe_eudebug: Exerciseread_eventioctlFrom: Dominik Grzegorzek <[email protected]>
Introduce synchronous test, which validates eu debugger
read_eventioctl.Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 109 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 108 insertions(+), 1 deletion(-)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
7ca0138a2..0cef652e2100644tests/intel/xe_eudebug.c +106
-2@@ -12,6 +12,9 @@* Test category: functionality test */ +#include <poll.h> +#include <sys/ioctl.h> +#include "igt.h" #include "xe/xe_eudebug.h" @@ -23,6 +26,45 @@ 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) +{ +int ret; + + ret =igt_ioctl (debugfd,DRM_XE_EUDEBUG_IOCTL_READ_EVENT , event); +if (ret <0 ) +return -errno; + +return ret; +} + +static int __read_event (int debugfd,struct drm_xe_eudebug_event +*event) { +int ret; + + ret =ioctl (debugfd,DRM_XE_EUDEBUG_IOCTL_READ_EVENT , event); +if (ret <0 ) +return -errno; + +return ret; +} + +static int poll_event (int fd,int timeout_ms) { +int ret; + +struct pollfd p = { + .fd = fd, + .events =POLLIN , + .revents =0 , + }; + + ret =poll (&p,1 , timeout_ms); +if (ret ==-1 ) +return -errno; + +return ret ==1 && (p.revents &POLLIN ); } +static int __debug_connect (int fd,int *debugfd,struct drm_xe_eudebug_connect *param) {int ret =0 ;@@ -124,6 +166,69 @@ static void test_close(int fd)close (debug_fd1); } +/** +* SUBTEST: basic-read-event +* Description: +* Synchronously exercise eu debugger event polling and reading. +*/ +#define MAX_EVENT_SIZE (32 * 1024) +static void test_read_event (int fd) +{ +struct drm_xe_eudebug_event *event; +struct xe_eudebug_debugger *d; +struct xe_eudebug_client *c; + + event =malloc (MAX_EVENT_SIZE ); +igt_assert (event); +memset (event,0 ,sizeof (*event)); + + c =xe_eudebug_client_create (fd, run_basic_client,0 ,NULL ); + d =xe_eudebug_debugger_create (fd,0 ,NULL ); + +igt_assert_eq (xe_eudebug_debugger_attach (d, c),0 ); +igt_assert_eq (poll_event (d->fd,500 ),0 ); + + event->len =1 ; + event->type =DRM_XE_EUDEBUG_EVENT_NONE ; +igt_assert_eq (read_event (d->fd, event), -EINVAL ); + + event->len =MAX_EVENT_SIZE ; + event->type =DRM_XE_EUDEBUG_EVENT_NONE ; +igt_assert_eq (read_event (d->fd, event), -EINVAL ); + +xe_eudebug_client_start (c); + +igt_assert_eq (poll_event (d->fd,500 ),1 ); + event->type =DRM_XE_EUDEBUG_EVENT_READ ; +igt_assert_eq (read_event (d->fd, event),0 ); + +igt_assert_eq (poll_event (d->fd,500 ),1 ); + event->len =MAX_EVENT_SIZE ; + event->flags =0 ; + event->type =DRM_XE_EUDEBUG_EVENT_READ ; +igt_assert_eq (read_event (d->fd, event),0 ); + +fcntl (d->fd,F_SETFL ,fcntl (d->fd,F_GETFL ) |O_NONBLOCK ); +igt_assert (fcntl (d->fd,F_GETFL ) &O_NONBLOCK ); + +igt_assert_eq (poll_event (d->fd,500 ),0 ); + event->len =MAX_EVENT_SIZE ; + event->flags =0 ; + event->type =DRM_XE_EUDEBUG_EVENT_READ ; +igt_assert_eq (__read_event (d->fd, event), -EAGAIN ); + +xe_eudebug_client_wait_done (c); +xe_eudebug_client_stop (c); + +igt_assert_eq (poll_event (d->fd,500 ),0 ); +igt_assert_eq (__read_event (d->fd, event), -EAGAIN ); + +xe_eudebug_debugger_destroy (d); +xe_eudebug_client_destroy (c); + +free (event); +} +/** * SUBTEST: basic-client * Description: @@ -134,7 +239,6 @@ static void test_close(int fd)* Simultaneously attach many debuggers to many processes. * Each process opens and closes xe drm client. */ -static void test_basic_sessions (int fd,unsigned int flags,int count) {struct xe_eudebug_session **s;@@ -171,6 +275,9 @@ igt_main igt_subtest("basic-close")test_close (fd); + igt_subtest("basic-read-event") +test_read_event (fd); + igt_subtest("basic-client")test_basic_sessions (fd,0 ,1 ); --2.34.1
PATCH v2 14/66 tests/xe_eudebug: Add vm events sanity check
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Add basic test validating eudebug vm events.
--- tests/intel/xe_eudebug.c | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-)
tests/intel/xe_eudebug.c +26 -2
@@ -18,11 +18,27 @@#include "igt.h" #include "xe/xe_eudebug.h" +#define CREATE_VMS (1 << 0)static void run_basic_client (struct xe_eudebug_client *c) { -int fd; +int fd, i; fd =xe_eudebug_client_open_driver (c); + +if (c->flags &CREATE_VMS ) { +const uint32_t flags[] = { +DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE , +DRM_XE_VM_CREATE_FLAG_LR_MODE , + }; +uint32_t vms[ARRAY_SIZE (flags)]; + +for (i =0 ; i <ARRAY_SIZE (flags); i++) + vms[i] =xe_eudebug_client_vm_create (c, fd, flags[i],0 ); + +for (i--; i >=0 ; i--) +xe_eudebug_client_vm_destroy (c, fd, vms[i]); + } +xe_eudebug_client_close_driver (c, fd); }
@@ -238,7 +254,12 @@ static void test_read_event(int fd)* Description: * Simultaneously attach many debuggers to many processes. * Each process opens and closes xe drm client. +* +* SUBTEST: basic-vms +* Description: +* Attach the debugger to process which creates and destroys a few vms. */ +static void test_basic_sessions (int fd,unsigned int flags,int count) {struct xe_eudebug_session **s;
@@ -282,7 +303,10 @@ igt_maintest_basic_sessions (fd,0 ,1 ); igt_subtest("multiple-sessions") -test_basic_sessions (fd,0 ,4 ); +test_basic_sessions (fd,CREATE_VMS ,4 ); + + igt_subtest("basic-vms") +test_basic_sessions (fd,CREATE_VMS ,1 );igt_fixture drm_close_driver (fd );
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 14/66] tests/xe_eudebug: Add vm events sanity check
Quoted 84 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 14/66] tests/xe_eudebug: Add vm events sanity checkFrom: Dominik Grzegorzek <[email protected]>
Add basic test validating eudebug vm events.
Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
0cef652e2..7c1c21a33100644tests/intel/xe_eudebug.c +26
-3@@ -18,11 +18,27 @@#include "igt.h" #include "xe/xe_eudebug.h" +#define CREATE_VMS (1 << 0)static void run_basic_client (struct xe_eudebug_client *c) { -int fd; +int fd, i; fd =xe_eudebug_client_open_driver (c); + +if (c->flags &CREATE_VMS ) { +const uint32_t flags[] = { +DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE , +DRM_XE_VM_CREATE_FLAG_LR_MODE , + }; +uint32_t vms[ARRAY_SIZE (flags)]; + +for (i =0 ; i <ARRAY_SIZE (flags); i++) + vms[i] =xe_eudebug_client_vm_create (c, fd, flags[i],0 ); + +for (i--; i >=0 ; i--) +xe_eudebug_client_vm_destroy (c, fd, vms[i]); + } +xe_eudebug_client_close_driver (c, fd); }@@ -238,7 +254,12 @@ static void test_read_event(int fd)* Description: * Simultaneously attach many debuggers to many processes. * Each process opens and closes xe drm client. +* +* SUBTEST: basic-vms +* Description: +* Attach the debugger to process which creates and destroys a few vms. */ +static void test_basic_sessions (int fd,unsigned int flags,int count) {struct xe_eudebug_session **s;@@ -282,7 +303,10 @@ igt_maintest_basic_sessions (fd,0 ,1 ); igt_subtest("multiple-sessions") -test_basic_sessions (fd,0 ,4 ); +test_basic_sessions (fd,CREATE_VMS ,4 ); + + igt_subtest("basic-vms") +test_basic_sessions (fd,CREATE_VMS ,1 );igt_fixture drm_close_driver (fd ); --2.34.1
PATCH v2 15/66 tests/xe_eudebug: Race discovery against eudebug attach.
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Validate eu debug resource discovery in a pretty cruel way. Add subtests:
1) discovery-race - spawns N client proccesses, which create N+N*N resources each, then it creates M debugger threads competing for an access to the client proccess. After successful attach, with probability of 0.5 read and assert discovered resources, immediately detach otherwise.
2) discovery-empty[|-clients] - same as 1#, but destroy resources in flight (explicetly or by closing the client). Expect the last discovery not sending any events.
Currently N = 4, M = 3.
--- tests/intel/xe_eudebug.c | 254 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 254 insertions(+)
tests/intel/xe_eudebug.c +254 -0
@@ -282,6 +282,251 @@ static void test_basic_sessions(int fd, unsigned int flags, int count)xe_eudebug_session_destroy (s[i]); } +#define RESOURCE_COUNT 16 +#define PRIMARY_THREAD (1 << 0) +#define DISCOVERY_CLOSE_CLIENT (1 << 1) +#define DISCOVERY_DESTROY_RESOURCES (1 << 2) +static void run_discovery_client (struct xe_eudebug_client *c) +{ +int fd[RESOURCE_COUNT ], i; +bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES |DISCOVERY_CLOSE_CLIENT ); + +srand (getpid ()); + +for (i =0 ; i <RESOURCE_COUNT ; i++) { + fd[i] =xe_eudebug_client_open_driver (c); + +/* +* Give the debugger a break in event stream after every +* other client, that allows to read discovery and dettach in quiet. +*/ +if (random () %2 ==0 && !skip_sleep) +sleep (1 ); + +for (int j =0 ; j <RESOURCE_COUNT ; j++) { +uint32_t vm =xe_eudebug_client_vm_create (c, fd[i],0 ,0 ); + +if (c->flags &DISCOVERY_DESTROY_RESOURCES ) +xe_eudebug_client_vm_destroy (c, fd[i], vm); + } + +if (c->flags &DISCOVERY_CLOSE_CLIENT ) +xe_eudebug_client_close_driver (c, fd[i]); + } +} + +/** +* SUBTEST: discovery-%s +* Description: Race discovery against %arg[1] and the debugger dettach. +* +* arg[1]: +* +* @race: resources creation +* @empty: resources destruction +* @empty-clients: client closure +*/ +static void *discovery_race_thread (void *data) +{ +struct { +uint64_t client_handle; +int vm_count; + } clients[RESOURCE_COUNT ]; +struct xe_eudebug_session *s = data; +int expected =RESOURCE_COUNT * (1 +RESOURCE_COUNT ); +const int tries =100 ; +bool done = false; +int ret =0 ; + +for (int try =0 ; try < tries && !done; try++) { + + ret =xe_eudebug_debugger_attach (s->d, s->c); + +if (ret == -EBUSY ) { +usleep (100000 ); +continue ; + } + +igt_assert_eq (ret,0 ); + +if (random () %2 ) { +struct drm_xe_eudebug_event *e =NULL ; +int i =-1 ; + +xe_eudebug_debugger_start_worker (s->d); +sleep (1 ); +xe_eudebug_debugger_stop_worker (s->d,1 ); +igt_debug ("Resources discovered: %lu\n" , s->d->event_count); + +xe_eudebug_for_each_event (e, s->d->log) { +if (e->type ==DRM_XE_EUDEBUG_EVENT_OPEN ) { +struct drm_xe_eudebug_event_client *eo = (void *)e; + +if (i >=0 ) { +igt_assert_eq (clients[i].vm_count, +RESOURCE_COUNT ); + } + +igt_assert (++i <RESOURCE_COUNT ); + clients[i].client_handle = eo->client_handle; + clients[i].vm_count =0 ; + } + +if (e->type ==DRM_XE_EUDEBUG_EVENT_VM ) + clients[i].vm_count++; + }; + +igt_assert_lte (0 , i); + +for (int j =0 ; j < i; j++) +for (int k =0 ; k < i; k++) { +if (k == j) +continue ; + +igt_assert_neq (clients[j].client_handle, + clients[k].client_handle); + } + +if (s->d->event_count >= expected) + done = true; + } + +xe_eudebug_debugger_dettach (s->d); + s->d->log->head =0 ; + s->d->event_count =0 ; + } + +/* Primary thread must read everything */ +if (s->flags &PRIMARY_THREAD ) { +while ((ret =xe_eudebug_debugger_attach (s->d, s->c)) == -EBUSY ) +usleep (100000 ); + +igt_assert_eq (ret,0 ); + +xe_eudebug_debugger_start_worker (s->d); +xe_eudebug_client_wait_done (s->c); + +if (READ_ONCE (s->d->event_count) != expected) +sleep (5 ); + +xe_eudebug_debugger_stop_worker (s->d,1 ); +xe_eudebug_debugger_dettach (s->d); + } + +return NULL ; +} + +static void test_race_discovery (int fd,unsigned int flags,int clients) +{ +const int debuggers_per_client =3 ; +int count = clients * debuggers_per_client; +struct xe_eudebug_session *sessions, *s; +struct xe_eudebug_client *c; +pthread_t *threads; +int i, j; + + sessions =calloc (count,sizeof (*sessions)); + threads =calloc (count,sizeof (*threads)); + +for (i =0 ; i < clients; i++) { + c =xe_eudebug_client_create (fd, run_discovery_client, flags,NULL ); +for (j =0 ; j < debuggers_per_client; j++) { + s = &sessions[i * debuggers_per_client + j]; + s->c = c; + s->d =xe_eudebug_debugger_create (fd, flags,NULL ); + s->flags = flags | (!j ?PRIMARY_THREAD :0 ); + } + } + +for (i =0 ; i < count; i++) { +if (sessions[i].flags &PRIMARY_THREAD ) +xe_eudebug_client_start (sessions[i].c); + +pthread_create (&threads[i],NULL , discovery_race_thread, &sessions[i]); + } + +for (i =0 ; i < count; i++) +pthread_join (threads[i],NULL ); + +for (i = count -1 ; i >0 ; i--) { +if (sessions[i].flags &PRIMARY_THREAD ) { +igt_assert_eq (sessions[i].c->seqno-1 , sessions[i].d->event_count); + +xe_eudebug_event_log_compare (sessions[0 ].d->log, + sessions[i].d->log,0 ); + +xe_eudebug_client_destroy (sessions[i].c); + } +xe_eudebug_debugger_destroy (sessions[i].d); + } +} + +static void *attach_dettach_thread (void *data) +{ +struct xe_eudebug_session *s = data; +const int tries =100 ; +int ret =0 ; + +for (int try =0 ; try < tries; try++) { + + ret =xe_eudebug_debugger_attach (s->d, s->c); + +if (ret == -EBUSY ) { +usleep (100000 ); +continue ; + } + +igt_assert_eq (ret,0 ); + +if (random () %2 ==0 ) { +xe_eudebug_debugger_start_worker (s->d); +xe_eudebug_debugger_stop_worker (s->d,1 ); + } + +xe_eudebug_debugger_dettach (s->d); + s->d->log->head =0 ; + s->d->event_count =0 ; + } + +return NULL ; +} + +static void test_empty_discovery (int fd,unsigned int flags,int clients) +{ +struct xe_eudebug_session **s; +pthread_t *threads; +int i, expected = flags &DISCOVERY_CLOSE_CLIENT ?0 :RESOURCE_COUNT ; + +igt_assert (flags & (DISCOVERY_DESTROY_RESOURCES |DISCOVERY_CLOSE_CLIENT )); + + s =calloc (clients,sizeof (struct xe_eudebug_session *)); + threads =calloc (clients,sizeof (*threads)); + +for (i =0 ; i < clients; i++) + s[i] =xe_eudebug_session_create (fd, run_discovery_client, flags,NULL ); + +for (i =0 ; i < clients; i++) { +xe_eudebug_client_start (s[i]->c); + +pthread_create (&threads[i],NULL , attach_dettach_thread, s[i]); + } + +for (i =0 ; i < clients; i++) +pthread_join (threads[i],NULL ); + +for (i =0 ; i < clients; i++) { +xe_eudebug_client_wait_done (s[i]->c); +igt_assert_eq (xe_eudebug_debugger_attach (s[i]->d, s[i]->c),0 ); + +xe_eudebug_debugger_start_worker (s[i]->d); +xe_eudebug_debugger_stop_worker (s[i]->d,5 ); +xe_eudebug_debugger_dettach (s[i]->d); + +igt_assert_eq (s[i]->d->event_count, expected); + +xe_eudebug_session_destroy (s[i]); + } +} + igt_main {int fd;
@@ -308,6 +553,15 @@ igt_main igt_subtest("basic-vms")test_basic_sessions (fd,CREATE_VMS ,1 ); + igt_subtest("discovery-race") +test_race_discovery (fd,0 ,4 ); + + igt_subtest("discovery-empty") +test_empty_discovery (fd,DISCOVERY_CLOSE_CLIENT ,16 ); + + igt_subtest("discovery-empty-clients") +test_empty_discovery (fd,DISCOVERY_DESTROY_RESOURCES ,16 ); +igt_fixture drm_close_driver (fd ); }
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 15/66] tests/xe_eudebug: Race discovery against eudebug attach.
Comment below.
Thanks,
Dominik Karol
Quoted 21 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 15/66] tests/xe_eudebug: Race discovery against eudebug attach.From: Dominik Grzegorzek <[email protected]>
Validate eu debug resource discovery in a pretty cruel way. Add subtests:
Quoted 8 lines
1) discovery-race - spawns N client proccesses, which create N+N*N resources each, then it creates M debugger threads competing for an access to the client proccess. After successful attach, with probability of 0.5 read and assert discovered resources, immediately detach otherwise.
2) discovery-empty[|-clients] - same as 1#, but destroy resources in flight (explicetly or by closing the client).
Typo: explicitly
Quoted 306 lines
Expect the last discovery not sending any events.
Currently N = 4, M = 3.
Signed-off-by Dominik Grzegorzek <[email protected]>Signed-off-by Karolina Stolarek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 254 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 254 insertions(+)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
7c1c21a33..d97e7914e100644tests/intel/xe_eudebug.c +17
-0@@ -282,6 +282,251 @@ static void test_basic_sessions(int fd, unsigned int flags, int count)xe_eudebug_session_destroy (s[i]); } +#define RESOURCE_COUNT 16 +#define PRIMARY_THREAD (1 << 0) +#define DISCOVERY_CLOSE_CLIENT (1 << 1) +#define DISCOVERY_DESTROY_RESOURCES (1 << 2) +static void run_discovery_client (struct xe_eudebug_client *c) { +int fd[RESOURCE_COUNT ], i; +bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES | +DISCOVERY_CLOSE_CLIENT ); + +srand (getpid ()); + +for (i =0 ; i <RESOURCE_COUNT ; i++) { + fd[i] =xe_eudebug_client_open_driver (c); + +/* +* Give the debugger a break in event stream after every +* other client, that allows to read discovery and dettach in quiet.
tests/intel/xe_eudebug.c +6
-0+*/ +if (random () %2 ==0 && !skip_sleep) +sleep (1 ); + +for (int j =0 ; j <RESOURCE_COUNT ; j++) { + uint32_t vm = xe_eudebug_client_vm_create(c, fd[i],0, 0);
tests/intel/xe_eudebug.c +50
-0+ +if (c->flags &DISCOVERY_DESTROY_RESOURCES ) +xe_eudebug_client_vm_destroy (c, fd[i], vm); + } + +if (c->flags &DISCOVERY_CLOSE_CLIENT ) +xe_eudebug_client_close_driver (c, fd[i]); + } +} + +/** +* SUBTEST: discovery-%s +* Description: Race discovery against %arg[1] and the debugger dettach. +* +* arg[1]: +* +* @race: resources creation +* @empty: resources destruction +* @empty-clients: client closure +*/ +static void *discovery_race_thread (void *data) { +struct { +uint64_t client_handle; +int vm_count; + } clients[RESOURCE_COUNT ]; +struct xe_eudebug_session *s = data; +int expected =RESOURCE_COUNT * (1 +RESOURCE_COUNT ); +const int tries =100 ; +bool done = false; +int ret =0 ; + +for (int try =0 ; try < tries && !done; try++) { + + ret =xe_eudebug_debugger_attach (s->d, s->c); + +if (ret == -EBUSY ) { +usleep (100000 ); +continue ; + } + +igt_assert_eq (ret,0 ); + +if (random () %2 ) { +struct drm_xe_eudebug_event *e =NULL ; +int i =-1 ; + +xe_eudebug_debugger_start_worker (s->d); +sleep (1 ); +xe_eudebug_debugger_stop_worker (s->d,1 ); + igt_debug("Resources discovered: %lu\n", s->d-Quoted 1 line
event_count);tests/intel/xe_eudebug.c +3
-0+ +xe_eudebug_for_each_event (e, s->d->log) { + if (e->type ==
DRM_XE_EUDEBUG_EVENT_OPEN) {tests/intel/xe_eudebug.c +1
-0+struct drm_xe_eudebug_event_client *eo = (void *)e;
tests/intel/xe_eudebug.c +3
-0+ +if (i >=0 ) { +igt_assert_eq(clients[i].vm_count,
+RESOURCE_COUNT);tests/intel/xe_eudebug.c +4
-0+ } + +igt_assert (++i <RESOURCE_COUNT ); + clients[i].client_handle = eo-Quoted 1 line
client_handle;tests/intel/xe_eudebug.c +4
-0+ clients[i].vm_count =0 ; + } + + if (e->type ==
DRM_XE_EUDEBUG_EVENT_VM)tests/intel/xe_eudebug.c +11
-0+ clients[i].vm_count++; + }; + +igt_assert_lte (0 , i); + +for (int j =0 ; j < i; j++) +for (int k =0 ; k < i; k++) { +if (k == j) +continue ; + +igt_assert_neq(clients[j].client_handle,
tests/intel/xe_eudebug.c +15
-0+ clients[k].client_handle); + } + +if (s->d->event_count >= expected) + done = true; + } + +xe_eudebug_debugger_dettach (s->d); + s->d->log->head =0 ; + s->d->event_count =0 ; + } + +/* Primary thread must read everything */ +if (s->flags &PRIMARY_THREAD ) { + while ((ret = xe_eudebug_debugger_attach(s->d, s->c)) == -EBUSY)
tests/intel/xe_eudebug.c +31
-0+usleep (100000 ); + +igt_assert_eq (ret,0 ); + +xe_eudebug_debugger_start_worker (s->d); +xe_eudebug_client_wait_done (s->c); + +if (READ_ONCE (s->d->event_count) != expected) +sleep (5 ); + +xe_eudebug_debugger_stop_worker (s->d,1 ); +xe_eudebug_debugger_dettach (s->d); + } + +return NULL ; +} + +static void test_race_discovery (int fd,unsigned int flags,int +clients) { +const int debuggers_per_client =3 ; +int count = clients * debuggers_per_client; +struct xe_eudebug_session *sessions, *s; +struct xe_eudebug_client *c; +pthread_t *threads; +int i, j; + + sessions =calloc (count,sizeof (*sessions)); + threads =calloc (count,sizeof (*threads)); + +for (i =0 ; i < clients; i++) { + c = xe_eudebug_client_create(fd, run_discovery_client, flags,NULL);
tests/intel/xe_eudebug.c +13
-0+for (j =0 ; j < debuggers_per_client; j++) { + s = &sessions[i * debuggers_per_client + j]; + s->c = c; + s->d =xe_eudebug_debugger_create (fd, flags,NULL ); + s->flags = flags | (!j ?PRIMARY_THREAD :0 ); + } + } + +for (i =0 ; i < count; i++) { +if (sessions[i].flags &PRIMARY_THREAD ) +xe_eudebug_client_start (sessions[i].c); + + pthread_create(&threads[i], NULL, discovery_race_thread,&sessions[i]);
tests/intel/xe_eudebug.c +8
-0+ } + +for (i =0 ; i < count; i++) +pthread_join (threads[i],NULL ); + +for (i = count -1 ; i >0 ; i--) { +if (sessions[i].flags &PRIMARY_THREAD ) { + igt_assert_eq(sessions[i].c->seqno-1, sessions[i].d-Quoted 1 line
event_count);tests/intel/xe_eudebug.c +44
-0+ +xe_eudebug_event_log_compare (sessions[0 ].d->log, + sessions[i].d->log,0 ); + +xe_eudebug_client_destroy (sessions[i].c); + } +xe_eudebug_debugger_destroy (sessions[i].d); + } +} + +static void *attach_dettach_thread (void *data) { +struct xe_eudebug_session *s = data; +const int tries =100 ; +int ret =0 ; + +for (int try =0 ; try < tries; try++) { + + ret =xe_eudebug_debugger_attach (s->d, s->c); + +if (ret == -EBUSY ) { +usleep (100000 ); +continue ; + } + +igt_assert_eq (ret,0 ); + +if (random () %2 ==0 ) { +xe_eudebug_debugger_start_worker (s->d); +xe_eudebug_debugger_stop_worker (s->d,1 ); + } + +xe_eudebug_debugger_dettach (s->d); + s->d->log->head =0 ; + s->d->event_count =0 ; + } + +return NULL ; +} + +static void test_empty_discovery (int fd,unsigned int flags,int +clients) { +struct xe_eudebug_session **s; +pthread_t *threads; + int i, expected = flags & DISCOVERY_CLOSE_CLIENT ? 0 :
RESOURCE_COUNT;tests/intel/xe_eudebug.c +9
-0+ +igt_assert (flags & (DISCOVERY_DESTROY_RESOURCES | +DISCOVERY_CLOSE_CLIENT )); + + s =calloc (clients,sizeof (struct xe_eudebug_session *)); + threads =calloc (clients,sizeof (*threads)); + +for (i =0 ; i < clients; i++) + s[i] = xe_eudebug_session_create(fd, run_discovery_client,flags,
tests/intel/xe_eudebug.c +6
-0+NULL); + +for (i =0 ; i < clients; i++) { +xe_eudebug_client_start (s[i]->c); + + pthread_create(&threads[i], NULL, attach_dettach_thread,s[i]);
tests/intel/xe_eudebug.c +8
-0+ } + +for (i =0 ; i < clients; i++) +pthread_join (threads[i],NULL ); + +for (i =0 ; i < clients; i++) { +xe_eudebug_client_wait_done (s[i]->c); + igt_assert_eq(xe_eudebug_debugger_attach(s[i]->d, s[i]->c),0);
tests/intel/xe_eudebug.c +20
-0+ +xe_eudebug_debugger_start_worker (s[i]->d); +xe_eudebug_debugger_stop_worker (s[i]->d,5 ); +xe_eudebug_debugger_dettach (s[i]->d); + +igt_assert_eq (s[i]->d->event_count, expected); + +xe_eudebug_session_destroy (s[i]); + } +} + igt_main {int fd;@@ -308,6 +553,15 @@ igt_main igt_subtest("basic-vms")test_basic_sessions (fd,CREATE_VMS ,1 ); + igt_subtest("discovery-race") +test_race_discovery (fd,0 ,4 ); + + igt_subtest("discovery-empty") +test_empty_discovery (fd,DISCOVERY_CLOSE_CLIENT ,16 ); + + igt_subtest("discovery-empty-clients") +test_empty_discovery (fd,DISCOVERY_DESTROY_RESOURCES ,16 ); +igt_fixture drm_close_driver (fd );}
--
2.34.1
PATCH v2 16/66 tests/xe_eudebug: Introduce basic exec_queue testing
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Exercise events send by the debugger on exec_queue create/destroy.
--- tests/intel/xe_eudebug.c | 64 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 60 insertions(+), 4 deletions(-)
tests/intel/xe_eudebug.c +60 -4
@@ -17,13 +17,16 @@#include "igt.h" #include "xe/xe_eudebug.h" +#include "xe/xe_query.h" #define CREATE_VMS (1 << 0) +#define CREATE_EXEC_QUEUES (1 << 1)static void run_basic_client (struct xe_eudebug_client *c) {int fd, i; fd =xe_eudebug_client_open_driver (c); +xe_device_get (fd);if (c->flags &CREATE_VMS ) { const uint32_t flags[] = {
@@ -39,6 +42,51 @@ static void run_basic_client(struct xe_eudebug_client *c)xe_eudebug_client_vm_destroy (c, fd, vms[i]); } +if (c->flags &CREATE_EXEC_QUEUES ) { +struct drm_xe_exec_queue_create *create; +struct drm_xe_engine_class_instance *hwe; +struct drm_xe_engine_class_instance bind_sync = { + .engine_class =DRM_XE_ENGINE_CLASS_VM_BIND , + .engine_instance =0 , + }; +struct drm_xe_engine_class_instance bind_async = { + .engine_class =DRM_XE_ENGINE_CLASS_VM_BIND , + .engine_instance =0 , + }; +uint32_t vm; + + create =calloc ((xe_number_engines (fd) +2 ),sizeof (*create)); + + vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); + + i =0 ; +xe_for_each_engine (fd, hwe) { + create[i].instances =to_user_pointer (hwe); + create[i].vm_id = vm; + create[i].width =1 ; + create[i].num_placements =1 ; +xe_eudebug_client_exec_queue_create (c, fd, &create[i++]); + } + + create[i].instances =to_user_pointer (&bind_sync), + create[i].vm_id = vm; + create[i].width =1 , + create[i].num_placements =1 , +xe_eudebug_client_exec_queue_create (c, fd, &create[i++]); + + create[i].instances =to_user_pointer (&bind_async), + create[i].vm_id = vm; + create[i].width =1 , + create[i].num_placements =1 , +xe_eudebug_client_exec_queue_create (c, fd, &create[i]); + +for (; i >=0 ; i--) +xe_eudebug_client_exec_queue_destroy (c, fd, &create[i]); + +xe_eudebug_client_vm_destroy (c, fd, vm); + } + +xe_device_put (fd);xe_eudebug_client_close_driver (c, fd); }
@@ -253,11 +301,16 @@ static void test_read_event(int fd)* SUBTEST: multiple-sessions * Description: * Simultaneously attach many debuggers to many processes. -* Each process opens and closes xe drm client. +* Each process opens and closes xe drm client and creates few resources. * -* SUBTEST: basic-vms +* SUBTEST: basic-%s * Description: -* Attach the debugger to process which creates and destroys a few vms. +* Attach the debugger to process which creates and destroys a few %arg[1]. +* +* arg[1]: +* +* @vms: vms +* @exec-queues: exec queues */ static void test_basic_sessions (int fd,unsigned int flags,int count)
@@ -548,11 +601,14 @@ igt_maintest_basic_sessions (fd,0 ,1 ); igt_subtest("multiple-sessions") -test_basic_sessions (fd,CREATE_VMS ,4 ); +test_basic_sessions (fd,CREATE_VMS |CREATE_EXEC_QUEUES ,4 ); igt_subtest("basic-vms")test_basic_sessions (fd,CREATE_VMS ,1 ); + igt_subtest("basic-exec-queues") +test_basic_sessions (fd,CREATE_EXEC_QUEUES ,1 ); + igt_subtest("discovery-race")test_race_discovery (fd,0 ,4 );
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 16/66] tests/xe_eudebug: Introduce basic exec_queue testing
Quoted 142 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 16/66] tests/xe_eudebug: Introduce basicexec_queuetestingFrom: Dominik Grzegorzek <[email protected]>
Exercise events send by the debugger on
exec_queuecreate/destroy.Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 64 +++++++++++++++++++++++++++++++++++++--- 1 file changed, 60 insertions(+), 4 deletions(-)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
d97e7914e..4051eac53100644tests/intel/xe_eudebug.c +48
-0@@ -17,13 +17,16 @@#include "igt.h" #include "xe/xe_eudebug.h" +#include "xe/xe_query.h" #define CREATE_VMS (1 << 0) +#define CREATE_EXEC_QUEUES (1 << 1)static void run_basic_client (struct xe_eudebug_client *c) {int fd, i; fd =xe_eudebug_client_open_driver (c); +xe_device_get (fd);if (c->flags &CREATE_VMS ) { const uint32_t flags[] = {@@ -39,6 +42,51 @@ static void run_basic_client(struct xe_eudebug_client *c)xe_eudebug_client_vm_destroy (c, fd, vms[i]); } +if (c->flags &CREATE_EXEC_QUEUES ) { +struct drm_xe_exec_queue_create *create; +struct drm_xe_engine_class_instance *hwe; +struct drm_xe_engine_class_instance bind_sync = { + .engine_class =DRM_XE_ENGINE_CLASS_VM_BIND , + .engine_instance =0 , + }; +struct drm_xe_engine_class_instance bind_async = { + .engine_class =DRM_XE_ENGINE_CLASS_VM_BIND , + .engine_instance =0 , + }; +uint32_t vm; + + create =calloc ((xe_number_engines (fd) +2 ),sizeof (*create)); + + vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); + + i =0 ; +xe_for_each_engine (fd, hwe) { + create[i].instances =to_user_pointer (hwe); + create[i].vm_id = vm; + create[i].width =1 ; + create[i].num_placements =1 ; +xe_eudebug_client_exec_queue_create (c, fd, &create[i++]); + } + + create[i].instances =to_user_pointer (&bind_sync), + create[i].vm_id = vm; + create[i].width =1 , + create[i].num_placements =1 , +xe_eudebug_client_exec_queue_create (c, fd, &create[i++]); + + create[i].instances =to_user_pointer (&bind_async), + create[i].vm_id = vm; + create[i].width =1 , + create[i].num_placements =1 , +xe_eudebug_client_exec_queue_create (c, fd, &create[i]); + +for (; i >=0 ; i--) +xe_eudebug_client_exec_queue_destroy (c, fd, &create[i]); + +xe_eudebug_client_vm_destroy (c, fd, vm); + } + +xe_device_put (fd);tests/intel/xe_eudebug.c +1
-1xe_eudebug_client_close_driver (c, fd); }@@ -253,11 +301,16 @@ static void test_read_event(int fd)* SUBTEST: multiple-sessions * Description: * Simultaneously attach many debuggers to many processes. -* Each process opens and closes xe drm client. +* Each process opens and closes xe drm client and creates few resources.
*
- * SUBTEST: basic-vms
+ * SUBTEST: basic-%s
* Description:
- * Attach the debugger to process which creates and destroys a few vms.
+ * Attach the debugger to process which creates and destroys a few
%arg[1].
+ *
+ * arg[1]:
+ *
+ * @vms: vms
+ * @exec-queues: exec queues
*/static void
test_basic_sessions(int fd, unsigned int flags, int count)@@ -
548,11 +601,14 @@igt_maintests/intel/xe_eudebug.c +1
-1test_basic_sessions (fd,0 ,1 ); igt_subtest("multiple-sessions") -test_basic_sessions (fd,CREATE_VMS ,4 ); + test_basic_sessions(fd, CREATE_VMS |
CREATE_EXEC_QUEUES, 4);tests/intel/xe_eudebug.c +3
-1igt_subtest("basic-vms")test_basic_sessions (fd,CREATE_VMS ,1 ); + igt_subtest("basic-exec-queues") +test_basic_sessions (fd,CREATE_EXEC_QUEUES ,1 ); + igt_subtest("discovery-race")test_race_discovery (fd,0 ,4 ); --2.34.1
PATCH v2 17/66 tests/xe_eudebug: Include exec queues in discovery testing
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Extend discovery-* subtests to create exec_queue resources.
--- tests/intel/xe_eudebug.c | 41 ++++++++++++++++++++++++++++++++++++---- 1 file changed, 37 insertions(+), 4 deletions(-)
tests/intel/xe_eudebug.c +37 -4
@@ -341,6 +341,7 @@ static void test_basic_sessions(int fd, unsigned int flags, int count)#define DISCOVERY_DESTROY_RESOURCES (1 << 2)static void run_discovery_client (struct xe_eudebug_client *c) { +struct drm_xe_engine_class_instance *hwe =NULL ;int fd[RESOURCE_COUNT ], i;bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES |DISCOVERY_CLOSE_CLIENT );
@@ -349,6 +350,20 @@ static void run_discovery_client(struct xe_eudebug_client *c)for (i =0 ; i <RESOURCE_COUNT ; i++) { fd[i] =xe_eudebug_client_open_driver (c); +if (!i) { +bool found = false; + +xe_device_get (fd[0 ]); +xe_for_each_engine (fd[0 ], hwe) { +if (hwe->engine_class ==DRM_XE_ENGINE_CLASS_COMPUTE || + hwe->engine_class ==DRM_XE_ENGINE_CLASS_RENDER ) { + found = true; +break ; + } + } +igt_assert (found); + } +/* * Give the debugger a break in event stream after every * other client, that allows to read discovery and dettach in quiet.
@@ -357,15 +372,25 @@ static void run_discovery_client(struct xe_eudebug_client *c)sleep (1 );for (int j =0 ; j <RESOURCE_COUNT ; j++) { -uint32_t vm =xe_eudebug_client_vm_create (c, fd[i],0 ,0 ); +struct drm_xe_exec_queue_create create = { + .width =1 , + .num_placements =1 , + .vm_id =xe_eudebug_client_vm_create (c, fd[i],0 ,0 ), + .instances =to_user_pointer (hwe) + }; -if (c->flags &DISCOVERY_DESTROY_RESOURCES ) -xe_eudebug_client_vm_destroy (c, fd[i], vm); +xe_eudebug_client_exec_queue_create (c, fd[i], &create); + +if (c->flags &DISCOVERY_DESTROY_RESOURCES ) { +xe_eudebug_client_exec_queue_destroy (c, fd[i], &create); +xe_eudebug_client_vm_destroy (c, fd[i], create.vm_id); + } }if (c->flags &DISCOVERY_CLOSE_CLIENT )xe_eudebug_client_close_driver (c, fd[i]); } +xe_device_put (fd[0 ]); }/**
@@ -383,9 +408,10 @@ static void *discovery_race_thread(void *data)struct {uint64_t client_handle;int vm_count; +int exec_queue_count; } clients[RESOURCE_COUNT ];struct xe_eudebug_session *s = data; -int expected =RESOURCE_COUNT * (1 +RESOURCE_COUNT ); +int expected =RESOURCE_COUNT * (1 +2 *RESOURCE_COUNT );const int tries =100 ;bool done = false;int ret =0 ;
@@ -417,15 +443,22 @@ static void *discovery_race_thread(void *data)if (i >=0 ) {igt_assert_eq (clients[i].vm_count,RESOURCE_COUNT ); + +igt_assert_eq (clients[i].exec_queue_count, +RESOURCE_COUNT ); }igt_assert (++i <RESOURCE_COUNT ); clients[i].client_handle = eo->client_handle; clients[i].vm_count =0 ; + clients[i].exec_queue_count =0 ; }if (e->type ==DRM_XE_EUDEBUG_EVENT_VM ) clients[i].vm_count++; + +if (e->type ==DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE ) + clients[i].exec_queue_count++; };igt_assert_lte (0 , i);
Signature · 1 line
2.34.1
PATCH v2 18/66 tests/xe_eudebug: Add vm open/pread/pwrite basic tests
In reply to Christoph ManszewskiFrom: Mika Kuoppala <[email protected]>
Add basic tests for opening, writing and reading into client's vm.
--- tests/intel/xe_eudebug.c | 276 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 276 insertions(+)
tests/intel/xe_eudebug.c +276 -0
@@ -16,9 +16,139 @@#include <sys/ioctl.h> #include "igt.h" +#include "intel_pat.h" +#include "lib/igt_syncobj.h" #include "xe/xe_eudebug.h" +#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#define BO_ADDR 0x1a0000 +#define BO_ITEMS 4096 +#define MIN_BO_SIZE (BO_ITEMS * sizeof(uint64_t)) + +struct bind_list { +int fd; +uint32_t vm; +uint32_t *bo; +struct drm_xe_vm_bind_op *bind_ops; +unsigned int n; +}; + +static void bo_prime (int fd,uint32_t bo,const uint64_t addr,const uint64_t size) +{ +uint64_t *d; +uint64_t i; + + d =xe_bo_map (fd, bo, size); +igt_assert (d); + +for (i =0 ; i < size/sizeof (*d); i++) + d[i] = addr + i; + +munmap (d, size); +} + +static void bo_check (int fd,uint32_t bo,const uint64_t addr,const uint64_t size) +{ +uint64_t *d; +uint64_t i; + + d =xe_bo_map (fd, bo, size); +igt_assert (d); + +for (i =0 ; i < size/sizeof (*d); i++) +igt_assert_eq (d[i], addr + i +1 ); + +munmap (d, size); +} + +static uint32_t *vm_create_objects (int fd,uint32_t bo_placement,uint32_t vm,unsigned int size, +unsigned int n) +{ +uint32_t *bo; +unsigned int i; + + bo =calloc (n,sizeof (*bo)); +igt_assert (bo); + +for (i =0 ; i < n; i++) { + bo[i] =xe_bo_create (fd, vm, size, bo_placement,0 ); +igt_assert (bo[i]); + } + +return bo; +} + +static struct bind_list *create_bind_list (int fd,uint32_t bo_placement, +uint32_t vm,unsigned int n) +{ +const unsigned int bo_size =max_t (bo_size,xe_get_default_alignment (fd),MIN_BO_SIZE ); +struct bind_list *bl; +unsigned int i; + + bl =malloc (sizeof (*bl)); + bl->fd = fd; + bl->vm = vm; + bl->bo =vm_create_objects (fd, bo_placement, vm, bo_size, n); + bl->n = n; + bl->bind_ops =calloc (n,sizeof (*bl->bind_ops)); +igt_assert (bl->bind_ops); + +for (i =0 ; i < n; i++) { +struct drm_xe_vm_bind_op *o = &bl->bind_ops[i]; + + o->range = bo_size; + o->addr =BO_ADDR +2 * i * bo_size; + o->flags =0 ; + o->pat_index =intel_get_pat_idx_wb (fd); + o->prefetch_mem_region_instance =0 ; + o->reserved[0 ] =0 ; + o->reserved[1 ] =0 ; + } + +for (i =0 ; i < bl->n; i++) { +struct drm_xe_vm_bind_op *o = &bl->bind_ops[i]; + +igt_debug ("bo %d: addr 0x%llx, range 0x%llx\n" , i, o->addr, o->range); +bo_prime (fd, bl->bo[i], o->addr, o->range); + } + +return bl; +} + +static void do_bind_list (struct xe_eudebug_client *c, +struct bind_list *bl,struct drm_xe_sync *sync) +{ +int i; +uint64_t ref_seqno =0 , op_ref_seqno =0 ; + +xe_vm_bind_array (bl->fd, bl->vm,0 , bl->bind_ops, bl->n, sync, sync ?1 :0 ); +xe_eudebug_client_vm_bind_event (c,DRM_XE_EUDEBUG_EVENT_STATE_CHANGE , + bl->fd, bl->vm,0 , bl->n, &ref_seqno); +for (i =0 ; i < bl->n; i++) +xe_eudebug_client_vm_bind_op_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , + ref_seqno, + &op_ref_seqno, + bl->bind_ops[i].addr, + bl->bind_ops[i].range, +0 ); + +if (sync) +igt_assert (syncobj_wait (bl->fd, &sync->handle,1 ,INT64_MAX ,0 ,NULL )); +} + +static void check_bind_list (struct bind_list *bl) +{ +unsigned int i; + +for (i =0 ; i < bl->n; i++) { +igt_debug ("%d: checking 0x%llx (%lld)\n" , + i, bl->bind_ops[i].addr, bl->bind_ops[i].addr); +bo_check (bl->fd, bl->bo[i], bl->bind_ops[i].addr, + bl->bind_ops[i].range); + } +} +#define CREATE_VMS (1 << 0)#define CREATE_EXEC_QUEUES (1 << 1)static void run_basic_client (struct xe_eudebug_client *c)
@@ -613,6 +743,149 @@ static void test_empty_discovery(int fd, unsigned int flags, int clients) } } +typedef void (*client_run_t )(struct xe_eudebug_client *); + +static void test_client_with_trigger (int fd,unsigned int flags,int count, +client_run_t client_fn,int type, +xe_eudebug_trigger_fn trigger_fn, +struct drm_xe_engine_class_instance *hwe, +bool match_opposite,uint32_t event_filter) +{ +struct xe_eudebug_session **s; +int i; + + s =calloc (count,sizeof (*s)); + +igt_assert (s); + +for (i =0 ; i < count; i++) + s[i] =xe_eudebug_session_create (fd, client_fn, flags, hwe); + +if (trigger_fn) +for (i =0 ; i < count; i++) +xe_eudebug_debugger_add_trigger (s[i]->d, type, trigger_fn); + +for (i =0 ; i < count; i++) +xe_eudebug_session_run (s[i]); + +for (i =0 ; i < count; i++) +xe_eudebug_session_check (s[i], match_opposite, event_filter); + +for (i =0 ; i < count; i++) +xe_eudebug_session_destroy (s[i]); +} + +static void vm_access_client (struct xe_eudebug_client *c) +{ +struct drm_xe_sync sync = { + .flags =DRM_XE_SYNC_TYPE_SYNCOBJ |DRM_XE_SYNC_FLAG_SIGNAL , }; +struct drm_xe_engine_class_instance *hwe = c->ptr; +struct bind_list *bl; +uint32_t vm; +int fd, i; + +igt_debug ("Using %s\n" ,xe_engine_class_string (hwe->engine_class)); + + fd =xe_eudebug_client_open_driver (c); +xe_device_get (fd); + + vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); + + bl =create_bind_list (fd,vram_if_possible (fd, hwe->gt_id), vm,4 ); + sync.handle =syncobj_create (bl->fd,0 ); +do_bind_list (c, bl, &sync); +syncobj_destroy (bl->fd, sync.handle); + +for (i =0 ; i < bl->n; i++) +xe_eudebug_client_wait_stage (c, bl->bind_ops[i].addr); + +check_bind_list (bl); + +xe_eudebug_client_vm_destroy (c, fd, vm); + +xe_device_put (fd); +xe_eudebug_client_close_driver (c, fd); +} + +static void debugger_test_vma (struct xe_eudebug_debugger *d, +uint64_t client_handle, +uint64_t vm_handle, +uint64_t va_start, +uint64_t va_length) +{ +struct drm_xe_eudebug_vm_open vo = {0 , }; +uint64_t *v; +uint64_t items = va_length /sizeof (uint64_t ); +int fd; +int r, i; + + v =malloc (va_length); +igt_assert (v); + + vo.client_handle = client_handle; + vo.vm_handle = vm_handle; + + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert_lte (0 , fd); + + r =pread (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); + +for (i =0 ; i < items; i++) +igt_assert_eq (v[i], va_start + i); + +for (i =0 ; i < items; i++) + v[i] = va_start + i +1 ; + + r =pwrite (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); + +fsync (fd); + +close (fd); +free (v); +} + +static void vm_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +struct drm_xe_eudebug_event_vm_bind *eb; + +igt_debug ("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n" , + eo->vm_bind_ref_seqno, + eo->addr, + eo->range); + + eb = (struct drm_xe_eudebug_event_vm_bind *) +xe_eudebug_event_log_find_seqno (d->log, eo->vm_bind_ref_seqno); +igt_assert (eb); + +debugger_test_vma (d, eb->client_handle, eb->vm_handle, + eo->addr, eo->range); +xe_eudebug_debugger_signal_stage (d, eo->addr); + } +} + +/** +* SUBTEST: basic-vm-access +* Description: +* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the vm fd +*/ +static void test_vm_access (int fd,unsigned int flags,int num_clients) +{ +struct drm_xe_engine_class_instance *hwe; + +xe_for_each_engine (fd, hwe) +test_client_with_trigger (fd, flags, num_clients, + vm_access_client, +DRM_XE_EUDEBUG_EVENT_VM_BIND_OP , + vm_trigger, hwe, + false,XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP ); +} + igt_main {int fd;
@@ -633,6 +906,9 @@ igt_main igt_subtest("basic-client")test_basic_sessions (fd,0 ,1 ); + igt_subtest("basic-vm-access") +test_vm_access (fd,0 ,1 ); + igt_subtest("multiple-sessions")test_basic_sessions (fd,CREATE_VMS |CREATE_EXEC_QUEUES ,4 );
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 18/66] tests/xe_eudebug: Add vm open/pread/pwrite basic tests
Comment below.
Thanks,
Dominik Karol
Quoted 303 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 18/66] tests/xe_eudebug: Add vm open/pread/pwrite basic testsFrom: Mika Kuoppala <[email protected]>
Add basic tests for opening, writing and reading into client's vm.
Signed-off-by Mika Kuoppala <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- tests/intel/xe_eudebug.c | 276 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 276 insertions(+)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
9497e73e9..5080fdf5b100644tests/intel/xe_eudebug.c +103
-0@@ -16,9 +16,139 @@#include <sys/ioctl.h> #include "igt.h" +#include "intel_pat.h" +#include "lib/igt_syncobj.h" #include "xe/xe_eudebug.h" +#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#define BO_ADDR 0x1a0000 +#define BO_ITEMS 4096 +#define MIN_BO_SIZE (BO_ITEMS * sizeof(uint64_t)) + +struct bind_list { +int fd; +uint32_t vm; +uint32_t *bo; +struct drm_xe_vm_bind_op *bind_ops; +unsigned int n; +}; + +static void bo_prime (int fd,uint32_t bo,const uint64_t addr,const +uint64_t size) { +uint64_t *d; +uint64_t i; + + d =xe_bo_map (fd, bo, size); +igt_assert (d); + +for (i =0 ; i < size/sizeof (*d); i++) + d[i] = addr + i; + +munmap (d, size); +} + +static void bo_check (int fd,uint32_t bo,const uint64_t addr,const +uint64_t size) { +uint64_t *d; +uint64_t i; + + d =xe_bo_map (fd, bo, size); +igt_assert (d); + +for (i =0 ; i < size/sizeof (*d); i++) +igt_assert_eq (d[i], addr + i +1 ); + +munmap (d, size); +} + +static uint32_t *vm_create_objects (int fd,uint32_t bo_placement,uint32_t vm,unsigned int size, +unsigned int n) +{ +uint32_t *bo; +unsigned int i; + + bo =calloc (n,sizeof (*bo)); +igt_assert (bo); + +for (i =0 ; i < n; i++) { + bo[i] =xe_bo_create (fd, vm, size, bo_placement,0 ); +igt_assert (bo[i]); + } + +return bo; +} + +static struct bind_list *create_bind_list (int fd,uint32_t bo_placement, +uint32_t vm,unsigned int n) +{ +const unsigned int bo_size =max_t (bo_size,xe_get_default_alignment (fd),MIN_BO_SIZE ); +struct bind_list *bl; +unsigned int i; + + bl =malloc (sizeof (*bl)); + bl->fd = fd; + bl->vm = vm; + bl->bo =vm_create_objects (fd, bo_placement, vm, bo_size, n); + bl->n = n; + bl->bind_ops =calloc (n,sizeof (*bl->bind_ops)); +igt_assert (bl->bind_ops); + +for (i =0 ; i < n; i++) { +struct drm_xe_vm_bind_op *o = &bl->bind_ops[i]; + + o->range = bo_size; + o->addr =BO_ADDR +2 * i * bo_size; + o->flags =0 ; + o->pat_index =intel_get_pat_idx_wb (fd); + o->prefetch_mem_region_instance =0 ; + o->reserved[0 ] =0 ; + o->reserved[1 ] =0 ; + } + +for (i =0 ; i < bl->n; i++) { +struct drm_xe_vm_bind_op *o = &bl->bind_ops[i]; + +igt_debug ("bo %d: addr 0x%llx, range 0x%llx\n" , i, o->addr, o- >range); +bo_prime (fd, bl->bo[i], o->addr, o->range); + } + +return bl; +} + +static void do_bind_list (struct xe_eudebug_client *c, +struct bind_list *bl,struct drm_xe_sync *sync) { +int i; +uint64_t ref_seqno =0 , op_ref_seqno =0 ; + + xe_vm_bind_array(bl->fd, bl->vm, 0, bl->bind_ops, bl->n, sync, sync ?1 : 0);
tests/intel/xe_eudebug.c +1
-0+ xe_eudebug_client_vm_bind_event(c,
DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,tests/intel/xe_eudebug.c +3
-0+ 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,tests/intel/xe_eudebug.c +8
-0+ ref_seqno, + &op_ref_seqno, + bl->bind_ops[i].addr, + bl->bind_ops[i].range, + 0); + +if (sync) + igt_assert(syncobj_wait(bl->fd, &sync->handle, 1,
INT64_MAX, 0,tests/intel/xe_eudebug.c +14
-0+NULL)); } + +static void check_bind_list (struct bind_list *bl) { +unsigned int i; + +for (i =0 ; i < bl->n; i++) { +igt_debug ("%d: checking 0x%llx (%lld)\n" , + i, bl->bind_ops[i].addr, bl->bind_ops[i].addr); +bo_check (bl->fd, bl->bo[i], bl->bind_ops[i].addr, + bl->bind_ops[i].range); + } +} +#define CREATE_VMS (1 << 0)#define CREATE_EXEC_QUEUES (1 << 1) static void run_basic_client(struct xe_eudebug_client *c) @@ -613,6 +743,149 @@ static void test_empty_discovery(int fd, unsigned int flags, intclients)
tests/intel/xe_eudebug.c +7
-0} } +typedef void (*client_run_t )(struct xe_eudebug_client *); + +static void test_client_with_trigger (int fd,unsigned int flags,int count, +client_run_t client_fn,int type, +xe_eudebug_trigger_fn trigger_fn, +struct drm_xe_engine_class_instance *hwe, + bool match_opposite, uint32_t
event_filter) {tests/intel/xe_eudebug.c +13
-0+struct xe_eudebug_session **s; +int i; + + s =calloc (count,sizeof (*s)); + +igt_assert (s); + +for (i =0 ; i < count; i++) + s[i] =xe_eudebug_session_create (fd, client_fn, flags, hwe); + +if (trigger_fn) +for (i =0 ; i < count; i++) + xe_eudebug_debugger_add_trigger(s[i]->d, type,
trigger_fn);tests/intel/xe_eudebug.c +6
-0+ +for (i =0 ; i < count; i++) +xe_eudebug_session_run (s[i]); + +for (i =0 ; i < count; i++) + xe_eudebug_session_check(s[i], match_opposite,
event_filter);tests/intel/xe_eudebug.c +8
-0+ +for (i =0 ; i < count; i++) +xe_eudebug_session_destroy (s[i]); +} + +static void vm_access_client(struct xe_eudebug_client *c) { + struct drm_xe_sync sync = { + .flags = DRM_XE_SYNC_TYPE_SYNCOBJ |
DRM_XE_SYNC_FLAG_SIGNAL, };tests/intel/xe_eudebug.c +74
-0+struct drm_xe_engine_class_instance *hwe = c->ptr; +struct bind_list *bl; +uint32_t vm; +int fd, i; + +igt_debug ("Using %s\n" ,xe_engine_class_string (hwe->engine_class)); + + fd =xe_eudebug_client_open_driver (c); +xe_device_get (fd); + + vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); + + bl =create_bind_list (fd,vram_if_possible (fd, hwe->gt_id), vm,4 ); + sync.handle =syncobj_create (bl->fd,0 ); +do_bind_list (c, bl, &sync); +syncobj_destroy (bl->fd, sync.handle); + +for (i =0 ; i < bl->n; i++) +xe_eudebug_client_wait_stage (c, bl->bind_ops[i].addr); + +check_bind_list (bl); + +xe_eudebug_client_vm_destroy (c, fd, vm); + +xe_device_put (fd); +xe_eudebug_client_close_driver (c, fd); } + +static void debugger_test_vma (struct xe_eudebug_debugger *d, +uint64_t client_handle, +uint64_t vm_handle, +uint64_t va_start, +uint64_t va_length) +{ +struct drm_xe_eudebug_vm_open vo = {0 , }; +uint64_t *v; +uint64_t items = va_length /sizeof (uint64_t ); +int fd; +int r, i; + + v =malloc (va_length); +igt_assert (v); + + vo.client_handle = client_handle; + vo.vm_handle = vm_handle; + + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert_lte (0 , fd); + + r =pread (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); + +for (i =0 ; i < items; i++) +igt_assert_eq (v[i], va_start + i); + +for (i =0 ; i < items; i++) + v[i] = va_start + i +1 ; + + r =pwrite (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); + +fsync (fd); + +close (fd); +free (v); +} + +static void vm_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) { +struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +struct drm_xe_eudebug_event_vm_bind *eb; + + igt_debug("vm bind op event received with ref %lld, addr0x%llx, range 0x%llx\n",
tests/intel/xe_eudebug.c +6
-0+ eo->vm_bind_ref_seqno, + eo->addr, + eo->range); + + eb = (struct drm_xe_eudebug_event_vm_bind *) + xe_eudebug_event_log_find_seqno(d->log, eo-Quoted 1 line
vm_bind_ref_seqno);tests/intel/xe_eudebug.c +2
-0+igt_assert (eb); +
tests/intel/xe_eudebug.c static void test_empty_discovery(int fd, unsigned int flags, int clients) · line 875
Quoted 10 lines
tests/intel/xe_eudebug.c +10
-0+debugger_test_vma (d, eb->client_handle, eb->vm_handle, + eo->addr, eo->range); +xe_eudebug_debugger_signal_stage (d, eo->addr); + } +} + +/** +* SUBTEST: basic-vm-access +* Description: +* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the vm fd
Typo: XE_EUDEBUG_VM_OPEN
Quoted 31 lines
+ */
tests/intel/xe_eudebug.c +8
-0+static void test_vm_access (int fd,unsigned int flags,int num_clients) +{ +struct drm_xe_engine_class_instance *hwe; + +xe_for_each_engine (fd, hwe) + test_client_with_trigger(fd, flags, num_clients, + vm_access_client, +
DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,tests/intel/xe_eudebug.c +2
-0+ vm_trigger, hwe, + false,
XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP);tests/intel/xe_eudebug.c +5
-1+} + igt_main {int fd;@@ -633,6 +906,9 @@ igt_main igt_subtest("basic-client")test_basic_sessions (fd,0 ,1 ); + igt_subtest("basic-vm-access") +test_vm_access (fd,0 ,1 ); + igt_subtest("multiple-sessions")test_basic_sessions (fd,CREATE_VMS |CREATE_EXEC_QUEUES ,4 ); --2.34.1
PATCH v2 19/66 tests/xe_eudebug: Add basic vm-bind coverage
In reply to Christoph ManszewskiAdd basic coverage for vm-bind event delivery mechanism that enables the user to track client vm-bind ioctl calls.
--- tests/intel/xe_eudebug.c | 117 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 109 insertions(+), 8 deletions(-)
tests/intel/xe_eudebug.c +109 -8
@@ -22,6 +22,41 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +#define CREATE_VMS (1 << 0) +#define CREATE_EXEC_QUEUES (1 << 1) +#define VM_BIND (1 << 2) +#define VM_BIND_VM_DESTROY (1 << 3) +#define VM_BIND_EXTENDED (1 << 4) + +static void basic_vm_bind_client (int fd,struct xe_eudebug_client *c) +{ +uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); +size_t bo_size =xe_get_default_alignment (fd); +uint32_t bo =xe_bo_create (fd,0 , bo_size, +system_memory (fd),0 ); +uint64_t addr =0x1a0000 ; + +xe_eudebug_client_vm_bind (c, fd, vm, bo,0 , addr, bo_size); +xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr, bo_size); + +gem_close (fd, bo); +xe_eudebug_client_vm_destroy (c, fd, vm); +} + +static void basic_vm_bind_vm_destroy_client (int fd,struct xe_eudebug_client *c) +{ +uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); +size_t bo_size =xe_get_default_alignment (fd); +uint32_t bo =xe_bo_create (fd,0 , bo_size, +system_memory (fd),0 ); +uint64_t addr =0x1a0000 ; + +xe_eudebug_client_vm_bind (c, fd, vm, bo,0 , addr, bo_size); +xe_eudebug_client_vm_destroy (c, fd, vm); + +gem_close (fd, bo); +} +#define BO_ADDR 0x1a0000#define BO_ITEMS 4096#define MIN_BO_SIZE (BO_ITEMS * sizeof(uint64_t))
@@ -149,8 +184,41 @@ static void check_bind_list(struct bind_list *bl) } } -#define CREATE_VMS (1 << 0) -#define CREATE_EXEC_QUEUES (1 << 1) +static void vm_bind_client (int fd,struct xe_eudebug_client *c) +{ +uint64_t op_ref_seqno, ref_seqno; +struct bind_list *bl; +size_t bo_size =3 *xe_get_default_alignment (fd); +uint32_t bo[2 ] = { +xe_bo_create (fd,0 , bo_size,system_memory (fd),0 ), +xe_bo_create (fd,0 , bo_size,system_memory (fd),0 ), + }; +uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); +uint64_t addr[] = {0x2a0000 ,0x3a0000 }; +uint64_t rebind_bo_offset =2 * bo_size /3 ; +uint64_t size = bo_size /3 ; + +xe_eudebug_client_vm_bind (c, fd, vm, bo[0 ],0 , addr[0 ], bo_size); +xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr[0 ] + size, size); + +xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ],0 , addr[1 ], bo_size); +xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ], rebind_bo_offset, addr[1 ], size); + + bl =create_bind_list (fd,system_memory (fd), vm,4 ); +do_bind_list (c, bl,NULL ); + +xe_vm_unbind_all_async (fd, vm,0 , bo[1 ],NULL ,0 ); + +xe_eudebug_client_vm_bind_event (c,DRM_XE_EUDEBUG_EVENT_STATE_CHANGE , fd, vm,0 , +1 , &ref_seqno); +xe_eudebug_client_vm_bind_op_event (c,DRM_XE_EUDEBUG_EVENT_DESTROY , ref_seqno, + &op_ref_seqno,0 ,0 ,0 ); + +gem_close (fd, bo[0 ]); +gem_close (fd, bo[1 ]); +xe_eudebug_client_vm_destroy (c, fd, vm); +} +static void run_basic_client (struct xe_eudebug_client *c) {int fd, i;
@@ -216,6 +284,15 @@ static void run_basic_client(struct xe_eudebug_client *c)xe_eudebug_client_vm_destroy (c, fd, vm); } +if (c->flags &VM_BIND ) +basic_vm_bind_client (fd, c); + +if (c->flags &VM_BIND_EXTENDED ) +vm_bind_client (fd, c); + +if (c->flags &VM_BIND_VM_DESTROY ) +basic_vm_bind_vm_destroy_client (fd, c); +xe_device_put (fd);xe_eudebug_client_close_driver (c, fd); }
@@ -437,13 +514,28 @@ static void test_read_event(int fd)* Description: * Attach the debugger to process which creates and destroys a few %arg[1]. * +* SUBTEST: basic-vm-bind +* Description: +* Attach the debugger to a process that performs synchronous vm bind +* and vm unbind. +* +* SUBTEST: basic-vm-bind-vm-destroy +* Description: +* Attach the debugger to a process that performs vm bind, and destroys +* the vm without unbinding. Make sure that we don't get unbind events. +* +* SUBTEST: basic-vm-bind-extended +* Description: +* Attach the debugger to a process that performs bind, bind array, rebind, +* partial unbind, unbind and unbind all operations. +* * arg[1]: * * @vms: vms * @exec-queues: exec queues */ -static void test_basic_sessions (int fd,unsigned int flags,int count) +static void test_basic_sessions (int fd,unsigned int flags,int count,bool match_opposite) {struct xe_eudebug_session **s;int i;
@@ -459,7 +551,7 @@ static void test_basic_sessions(int fd, unsigned int flags, int count)xe_eudebug_session_run (s[i]);for (i =0 ; i < count; i++) -xe_eudebug_session_check (s[i], true,0 ); +xe_eudebug_session_check (s[i], match_opposite,0 );for (i =0 ; i < count; i++)xe_eudebug_session_destroy (s[i]);
@@ -904,19 +996,28 @@ igt_maintest_read_event (fd); igt_subtest("basic-client") -test_basic_sessions (fd,0 ,1 ); +test_basic_sessions (fd,0 ,1 , true); igt_subtest("basic-vm-access")test_vm_access (fd,0 ,1 ); igt_subtest("multiple-sessions") -test_basic_sessions (fd,CREATE_VMS |CREATE_EXEC_QUEUES ,4 ); +test_basic_sessions (fd,CREATE_VMS |CREATE_EXEC_QUEUES ,4 , true); igt_subtest("basic-vms") -test_basic_sessions (fd,CREATE_VMS ,1 ); +test_basic_sessions (fd,CREATE_VMS ,1 , true); igt_subtest("basic-exec-queues") -test_basic_sessions (fd,CREATE_EXEC_QUEUES ,1 ); +test_basic_sessions (fd,CREATE_EXEC_QUEUES ,1 , true); + + igt_subtest("basic-vm-bind") +test_basic_sessions (fd,VM_BIND ,1 , true); + + igt_subtest("basic-vm-bind-vm-destroy") +test_basic_sessions (fd,VM_BIND_VM_DESTROY ,1 , false); + + igt_subtest("basic-vm-bind-extended") +test_basic_sessions (fd,VM_BIND_EXTENDED ,1 , true); igt_subtest("discovery-race")test_race_discovery (fd,0 ,4 );
Signature · 1 line
2.34.1
PATCH v2 20/66 tests/xe_eudebug: Exercise debug metadata events sent to debugger
In reply to Christoph ManszewskiFrom: Maciej Patelczyk <[email protected]>
Add tests which exercise setting debug metadata and correctness of events received by currently attached debugger.
Extended the attach-debug-metadata so that it has multimple metadatas per bind. (Maciej)
--- tests/intel/xe_eudebug.c | 164 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+)
tests/intel/xe_eudebug.c +164 -0
@@ -27,6 +27,7 @@#define VM_BIND (1 << 2)#define VM_BIND_VM_DESTROY (1 << 3)#define VM_BIND_EXTENDED (1 << 4) +#define VM_METADATA (1 << 5)static void basic_vm_bind_client (int fd,struct xe_eudebug_client *c) {
@@ -978,6 +979,163 @@ static void test_vm_access(int fd, unsigned int flags, int num_clients) false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP); } +#define PAGE_SIZE 4096 +#define MDATA_SIZE (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM * PAGE_SIZE) +static void metadata_access_client (struct xe_eudebug_client *c) +{ +const uint64_t addr =0x1a0000 ; +struct drm_xe_vm_bind_op_ext_attach_debug *ext; +uint8_t *data; +size_t bo_size; +uint32_t bo, vm; +int fd, i; + + fd =xe_eudebug_client_open_driver (c); +xe_device_get (fd); + + bo_size =xe_get_default_alignment (fd); + vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); + bo =xe_bo_create (fd, vm, bo_size,system_memory (fd),0 ); + + data =calloc (MDATA_SIZE ,sizeof (*data)); +igt_assert (data); + +for (i =0 ; i <MDATA_SIZE ; i++) + data[i] =0xff & (i + (i >PAGE_SIZE )); + + ext =calloc (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA +1 ,sizeof (*ext)); +igt_assert (ext); + +for (i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA +1 ; i++) { + ext[i].base.name =XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG ; + ext[i].metadata_id =xe_eudebug_client_metadata_create (c, fd, i, + (i +1 ) *PAGE_SIZE , data); + ext[i].cookie = i; + +if (i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA ) + ext[i].base.next_extension =to_user_pointer (&ext[i+1 ]); + } + +xe_eudebug_client_vm_bind_flags (c, fd, vm, bo,0 , addr, + bo_size,0 ,NULL ,0 ,to_user_pointer (ext)); + +for (i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM ; i++) +xe_eudebug_client_wait_stage (c, i); + +xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr, bo_size); + +for (i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA +1 ; i++) +xe_eudebug_client_metadata_destroy (c, fd, ext[i].metadata_id, i, (i +1 ) *PAGE_SIZE ); + +close (bo); +xe_eudebug_client_vm_destroy (c, fd, vm); + +xe_device_put (fd); +xe_eudebug_client_close_driver (c, fd); + +free (data); +free (ext); +} + +static void debugger_test_metadata (struct xe_eudebug_debugger *d, +uint64_t client_handle, +uint64_t metadata_handle, +uint64_t type, +uint64_t len) +{ +struct drm_xe_eudebug_read_metadata rm = { + .client_handle = client_handle, + .metadata_handle = metadata_handle, + .size = len, + }; +uint8_t *data; +int i; + + data =malloc (len); +igt_assert (data); + + rm.ptr =to_user_pointer (data); + +igt_assert_eq (igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_READ_METADATA , &rm),0 ); + +/* syntetic check, test sets different size per metadata type */ +igt_assert_eq ((type +1 ) *PAGE_SIZE , rm.size); + +for (i =0 ; i < rm.size; i++) +igt_assert_eq (data[i],0xff & (i + (i >PAGE_SIZE ))); + +free (data); +} + +static void metadata_read_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_metadata *em = (void *)e; + +/* syntetic check, test sets different size per metadata type */ +igt_assert_eq ((em->type +1 ) *PAGE_SIZE , em->len); + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +debugger_test_metadata (d, em->client_handle, em->metadata_handle, + em->type, em->len); +xe_eudebug_debugger_signal_stage (d, em->type); + } +} + +static void metadata_read_on_vm_bind_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_vm_bind_op_metadata *em = (void *)e; +struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; +struct drm_xe_eudebug_event_vm_bind *eb; + +/* For testing purpose client sets metadata_cookie = type */ + +/* +* Metadata event has a reference to vm-bind-op event which has a reference +* to vm-bind event which contains proper client-handle. +*/ + eo = (struct drm_xe_eudebug_event_vm_bind_op *) +xe_eudebug_event_log_find_seqno (d->log, em->vm_bind_op_ref_seqno); +igt_assert (eo); + eb = (struct drm_xe_eudebug_event_vm_bind *) +xe_eudebug_event_log_find_seqno (d->log, eo->vm_bind_ref_seqno); +igt_assert (eb); + +debugger_test_metadata (d, + eb->client_handle, + em->metadata_handle, + em->metadata_cookie, +MDATA_SIZE );/* max size */ + +xe_eudebug_debugger_signal_stage (d, em->metadata_cookie); +} + +/** +* SUBTEST: read-metadata +* Description: +* Exercise DRM_XE_EUDEBUG_IOCTL_READ_METADATA and debug metadata create|destroy events. +*/ +static void test_metadata_read (int fd,unsigned int flags,int num_clients) +{ +test_client_with_trigger (fd, flags, num_clients, metadata_access_client, +DRM_XE_EUDEBUG_EVENT_METADATA , metadata_read_trigger, +NULL , true,0 ); +} + +/** +* SUBTEST: attach-debug-metadata +* Description: +* Read debug metadata when vm_bind has it attached. +*/ +static void test_metadata_attach (int fd,unsigned int flags,int num_clients) +{ +test_client_with_trigger (fd, flags, num_clients, metadata_access_client, +DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA , + metadata_read_on_vm_bind_trigger, +NULL , true,0 ); +} + igt_main {int fd;
@@ -1019,6 +1177,12 @@ igt_main igt_subtest("basic-vm-bind-extended")test_basic_sessions (fd,VM_BIND_EXTENDED ,1 , true); + igt_subtest("read-metadata") +test_metadata_read (fd,0 ,1 ); + + igt_subtest("attach-debug-metadata") +test_metadata_attach (fd,0 ,1 ); + igt_subtest("discovery-race")test_race_discovery (fd,0 ,4 );
Signature · 1 line
2.34.1
PATCH v2 21/66 tests/xe_eudebug: Add support for dynamic debugger sysfs toggle
In reply to Christoph ManszewskiFrom now on the debugger is disabled by default so it is required to enable the debugger before using it. This change addresses that fact by calling necessary library functions within test fixtures.
--- tests/intel/xe_eudebug.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)
tests/intel/xe_eudebug.c +5 -1
@@ -1138,10 +1138,12 @@ static void test_metadata_attach(int fd, unsigned int flags, int num_clients) igt_main { +bool was_enabled;int fd; igt_fixture { fd =drm_open_driver (DRIVER_XE ); + was_enabled =xe_eudebug_enable (fd, true); }igt_subtest ("basic-connect" )
@@ -1192,6 +1194,8 @@ igt_main igt_subtest("discovery-empty-clients")test_empty_discovery (fd,DISCOVERY_DESTROY_RESOURCES ,16 ); -igt_fixture + igt_fixture { +xe_eudebug_enable (fd, was_enabled);drm_close_driver (fd); + } }
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 21/66] tests/xe_eudebug: Add support for dynamic debugger sysfs toggle
Quoted 58 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 21/66] tests/xe_eudebug: Add support for dynamic debugger sysfs toggleFrom now on the debugger is disabled by default so it is required to enable the debugger before using it. This change addresses that fact by calling necessary library functions within test fixtures.
Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Christoph Manszewski <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- tests/intel/xe_eudebug.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
577985ba7..de8edb485100644tests/intel/xe_eudebug.c +2
-0@@ -1138,10 +1138,12 @@ static void test_metadata_attach(int fd, unsigned int flags, int num_clients) igt_main { + bool was_enabled;int fd; igt_fixture { fd =drm_open_driver (DRIVER_XE ); + was_enabled =xe_eudebug_enable (fd, true); }tests/intel/xe_eudebug.c +3
-1igt_subtest ("basic-connect" )@@ -1192,6 +1194,8 @@ igt_main igt_subtest("discovery-empty-clients")test_empty_discovery (fd,DISCOVERY_DESTROY_RESOURCES ,16 ); -igt_fixture + igt_fixture { +xe_eudebug_enable (fd, was_enabled);drm_close_driver (fd); + }}
--
2.34.1
PATCH v2 22/66 tests/xe_eudebug: Add coverage for sysfs debugger toggle
In reply to Christoph ManszewskiAdd subtest for checking sysfs debugger toggle logic and debugger state.
--- tests/intel/xe_eudebug.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
tests/intel/xe_eudebug.c +27 -0
@@ -22,6 +22,30 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +/** +* SUBTEST: sysfs-toggle +* Description: +* Excercise the debugger enable/disable sysfs toggle logic +*/ +static void test_sysfs_toggle (int fd) +{ +xe_eudebug_enable (fd, false); +igt_assert (!xe_eudebug_debugger_available (fd)); + +xe_eudebug_enable (fd, true); +igt_assert (xe_eudebug_debugger_available (fd)); +xe_eudebug_enable (fd, true); +igt_assert (xe_eudebug_debugger_available (fd)); + +xe_eudebug_enable (fd, false); +igt_assert (!xe_eudebug_debugger_available (fd)); +xe_eudebug_enable (fd, false); +igt_assert (!xe_eudebug_debugger_available (fd)); + +xe_eudebug_enable (fd, true); +igt_assert (xe_eudebug_debugger_available (fd)); +} +#define CREATE_VMS (1 << 0)#define CREATE_EXEC_QUEUES (1 << 1)#define VM_BIND (1 << 2)
@@ -1146,6 +1170,9 @@ igt_main was_enabled =xe_eudebug_enable (fd, true); } + igt_subtest("sysfs-toggle") +test_sysfs_toggle (fd); + igt_subtest("basic-connect")test_connect (fd);
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 22/66] tests/xe_eudebug: Add coverage for sysfs debugger toggle
With typo fixed:
Quoted 29 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 22/66] tests/xe_eudebug: Add coverage for sysfs debugger toggleAdd subtest for checking sysfs debugger toggle logic and debugger state.
Signed-off-by Christoph Manszewski <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- tests/intel/xe_eudebug.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
de8edb485..b565785e3100644
tests/intel/xe_eudebug.c line 28
Quoted 7 lines
tests/intel/xe_eudebug.c +4
-0@@ -22,6 +22,30 @@#include "xe/xe_ioctl.h" #include "xe/xe_query.h" +/** +* SUBTEST: sysfs-toggle +* Description: +* Excercise the debugger enable/disable sysfs toggle logic
Typo: Exercise
Quoted 35 lines
tests/intel/xe_eudebug.c +23
-1+*/ +static void test_sysfs_toggle (int fd) +{ +xe_eudebug_enable (fd, false); +igt_assert (!xe_eudebug_debugger_available (fd)); + +xe_eudebug_enable (fd, true); +igt_assert (xe_eudebug_debugger_available (fd)); +xe_eudebug_enable (fd, true); +igt_assert (xe_eudebug_debugger_available (fd)); + +xe_eudebug_enable (fd, false); +igt_assert (!xe_eudebug_debugger_available (fd)); +xe_eudebug_enable (fd, false); +igt_assert (!xe_eudebug_debugger_available (fd)); + +xe_eudebug_enable (fd, true); +igt_assert (xe_eudebug_debugger_available (fd)); +} +#define CREATE_VMS (1 << 0)#define CREATE_EXEC_QUEUES (1 << 1)#define VM_BIND (1 << 2)@@ -1146,6 +1170,9 @@ igt_main was_enabled =xe_eudebug_enable (fd, true); } + igt_subtest("sysfs-toggle") +test_sysfs_toggle (fd); + igt_subtest("basic-connect")test_connect (fd); --2.34.1
PATCH v2 23/66 lib/xe_eudebug: Allow debugger to wait for client
In reply to Christoph ManszewskiIn some tests, we need to pause the debugger at a certain stage as the point at which the client performs certain activities, determines the executed code path in the driver.
Add a possibility to pause debugger and to signal continuation by the client.
--- lib/xe/xe_eudebug.c | 37 +++++++++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 2 ++ 2 files changed, 39 insertions(+)
lib/xe/xe_eudebug.c +37 -0
@@ -45,6 +45,7 @@ struct match_dto {#define CLIENT_FINI 3#define CLIENT_STOP 4#define CLIENT_STAGE 5 +#define DEBUGGER_STAGE 6#define DEBUGGER_WORKER_INACTIVE 0#define DEBUGGER_WORKER_ACTIVE 1
@@ -1250,6 +1251,29 @@ void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t sttoken_signal (d->p_client,CLIENT_STAGE , stage); } +/** +* xe_eudebug_debugger_wait_stage: +* @s: pointer to xe_eudebug_debugger structure +* @stage: stage to wait on +* +* Pauses debugger until the client has signalled the corresponding stage with +* xe_eudebug_client_signal_stage. This is only for situatuons where the actual +* event flow is not enough to coordinate between client/debugger and extra sync +* mechanism is needed. +*/ +void xe_eudebug_debugger_wait_stage (struct xe_eudebug_session *s,uint64_t stage) +{ +u64 stage_in; + +igt_debug ("debugger xe client fd: %d pausing for stage %lu\n" , s->d->master_fd, stage); + + stage_in =wait_from_client (s->c,DEBUGGER_STAGE ); +igt_debug ("debugger xe client fd: %d stage %lu, expected %lu, stage\n" , s->d->master_fd, + stage_in, stage); + +igt_assert_eq (stage_in, stage); +} +/** * xe_eudebug_client_create: * @master_fd: xe client used to open the debugger connection
@@ -1397,6 +1421,19 @@ void xe_eudebug_client_wait_done(struct xe_eudebug_client *c) } } +/** +* xe_eudebug_client_signal_stage: +* @c: pointer to the client +* @stage: stage to signal +* +* Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(), +* releasing it to proceed. +*/ +void xe_eudebug_client_signal_stage (struct xe_eudebug_client *c,uint64_t stage) +{ +token_signal (c->p_out,DEBUGGER_STAGE , stage); +} +/** * xe_eudebug_client_wait_stage: * @c: pointer to xe_eudebug_client structure
lib/xe/xe_eudebug.h +2 -0
@@ -135,6 +135,7 @@ void xe_eudebug_debugger_set_data(struct xe_eudebug_debugger *c, void *ptr);void xe_eudebug_debugger_add_trigger (struct xe_eudebug_debugger *d,int type,xe_eudebug_trigger_fn fn);void xe_eudebug_debugger_signal_stage (struct xe_eudebug_debugger *d,uint64_t stage); +void xe_eudebug_debugger_wait_stage (struct xe_eudebug_session *s,uint64_t stage);struct xe_eudebug_client *xe_eudebug_client_create (int xe,xe_eudebug_client_work_fn work,uint64_t flags,void *data);
@@ -142,6 +143,7 @@ void xe_eudebug_client_destroy(struct xe_eudebug_client *c);void xe_eudebug_client_start (struct xe_eudebug_client *c);void xe_eudebug_client_stop (struct xe_eudebug_client *c);void xe_eudebug_client_wait_done (struct xe_eudebug_client *c); +void xe_eudebug_client_signal_stage (struct xe_eudebug_client *c,uint64_t stage);void xe_eudebug_client_wait_stage (struct xe_eudebug_client *c,uint64_t stage);uint64_t xe_eudebug_client_get_seqno (struct xe_eudebug_client *c);
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 23/66] lib/xe_eudebug: Allow debugger to wait for client
With typo fixed:
Quoted 45 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 23/66]lib/xe_eudebug: Allow debugger to wait for clientIn some tests, we need to pause the debugger at a certain stage as the point at which the client performs certain activities, determines the executed code path in the driver.
Add a possibility to pause debugger and to signal continuation by the client.
Signed-off-by Christoph Manszewski <[email protected]>Cc Karolina Stolarek <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- lib/xe/xe_eudebug.c | 37 +++++++++++++++++++++++++++++++++++++ lib/xe/xe_eudebug.h | 2 ++ 2 files changed, 39 insertions(+)lib/xe/xe_eudebug.c index renamed from lib/xe/xe_eudebug.c +0
-0
36eef25c7..ed1e382c7100644lib/xe/xe_eudebug.c +1
-0@@ -45,6 +45,7 @@ struct match_dto {#define CLIENT_FINI 3#define CLIENT_STOP 4#define CLIENT_STAGE 5 +#define DEBUGGER_STAGE 6#define DEBUGGER_WORKER_INACTIVE 0#define DEBUGGER_WORKER_ACTIVE 1@@ -1250,6 +1251,29 @@ void xe_eudebug_debugger_signal_stage(struct
xe_eudebug_debugger*d,uint64_tstlib/xe/xe_eudebug.c +0
-0token_signal (d->p_client,CLIENT_STAGE , stage); }
lib/xe/xe_eudebug.c void xe_eudebug_debugger_signal_stage(struct xe_eudebug_debugger *d, uint64_t st
Quoted 10 lines
lib/xe/xe_eudebug.c +9
-0+/** +* xe_eudebug_debugger_wait_stage: +* @s: pointer to xe_eudebug_debugger structure +* @stage: stage to wait on +* +* Pauses debugger until the client has signalled the corresponding +stage with +* xe_eudebug_client_signal_stage. This is only for situatuons where +the actual
Typo: situations
Quoted 69 lines
+ * event flow is not enough to coordinate between client/debugger and
lib/xe/xe_eudebug.c +12
-0+extra sync +* mechanism is needed. +*/ +void xe_eudebug_debugger_wait_stage (struct xe_eudebug_session *s, +uint64_t stage) { +u64 stage_in; + +igt_debug ("debugger xe client fd: %d pausing for stage %lu\n" , +s->d->master_fd, stage); + + stage_in =wait_from_client (s->c,DEBUGGER_STAGE ); + igt_debug("debugger xe client fd: %d stage %lu, expected %lu,stage\n",
s->d->master_fd,lib/xe/xe_eudebug.c +6
-0+ stage_in, stage); + +igt_assert_eq (stage_in, stage); +} +/** * xe_eudebug_client_create: * @master_fd: xe client used to open the debugger connection @@ -1397,6 +1421,19 @@ void xe_eudebug_client_wait_done(struct xe_eudebug_client *c)
lib/xe/xe_eudebug.c +12
-0} } +/** +* xe_eudebug_client_signal_stage: +* @c: pointer to the client +* @stage: stage to signal +* +* Signals to debugger, waiting in xe_eudebug_debugger_wait_stage(), +* releasing it to proceed. +*/ +void xe_eudebug_client_signal_stage (struct xe_eudebug_client *c, +uint64_t stage) { +token_signal (c->p_out,DEBUGGER_STAGE , stage); } +/** * xe_eudebug_client_wait_stage: * @c: pointer to xe_eudebug_client structure diff --git a/lib/xe/xe_eudebug.h
b/lib/xe/xe_eudebug.hindex1343cb25c..81c33417f100644lib/xe/xe_eudebug.h +0
-0@@ -135,6 +135,7 @@ void xe_eudebug_debugger_set_data(struct
xe_eudebug_debugger*c, void *ptr); void xe_eudebug_debugger_add_trigger(structxe_eudebug_debugger*d, int type,
xe_eudebug_trigger_fnfn);
void xe_eudebug_debugger_signal_stage(structxe_eudebug_debugger*d,uint64_tstage);lib/xe/xe_eudebug.h +2
-0+void xe_eudebug_debugger_wait_stage (struct xe_eudebug_session *s, +uint64_t stage);struct xe_eudebug_client * xe_eudebug_client_create(int xe, xe_eudebug_client_work_fn work, uint64_tflags, void *data); @@ -142,6 +143,7 @@ void
xe_eudebug_client_destroy(struct xe_eudebug_client *c); voidxe_eudebug_client_start(struct xe_eudebug_client *c); voidxe_eudebug_client_stop(struct xe_eudebug_client *c); voidxe_eudebug_client_wait_done(struct xe_eudebug_client *c);lib/xe/xe_eudebug.h +2
-0+void xe_eudebug_client_signal_stage (struct xe_eudebug_client *c, +uint64_t stage); void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_tstage);
uint64_txe_eudebug_client_get_seqno(struct xe_eudebug_client *c);
--
2.34.1
PATCH v2 24/66 tests/xe_eudebug: Add vm-bind discovery tests
In reply to Christoph ManszewskiExtend vm-bind testing by adding variations of existing subtests, that exercise the eu debugger's discovery mechanism, by attaching after relevant vm-bind operations were performed by the client.
--- tests/intel/xe_eudebug.c | 133 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 125 insertions(+), 8 deletions(-)
tests/intel/xe_eudebug.c +125 -8
@@ -46,22 +46,33 @@ static void test_sysfs_toggle(int fd)igt_assert (xe_eudebug_debugger_available (fd)); } +#define STAGE_PRE_DEBUG_RESOURCES_DONE 1 +#define STAGE_DISCOVERY_DONE 2 +#define CREATE_VMS (1 << 0)#define CREATE_EXEC_QUEUES (1 << 1)#define VM_BIND (1 << 2)#define VM_BIND_VM_DESTROY (1 << 3)#define VM_BIND_EXTENDED (1 << 4)#define VM_METADATA (1 << 5) +#define TEST_DISCOVERY (1 << 31)static void basic_vm_bind_client (int fd,struct xe_eudebug_client *c) {uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 );size_t bo_size =xe_get_default_alignment (fd); +bool test_discovery = c->flags &TEST_DISCOVERY ;uint32_t bo =xe_bo_create (fd,0 , bo_size,system_memory (fd),0 );uint64_t addr =0x1a0000 ;xe_eudebug_client_vm_bind (c, fd, vm, bo,0 , addr, bo_size); + +if (test_discovery) { +xe_eudebug_client_signal_stage (c,STAGE_PRE_DEBUG_RESOURCES_DONE ); +xe_eudebug_client_wait_stage (c,STAGE_DISCOVERY_DONE ); + } +xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr, bo_size);gem_close (fd, bo);
@@ -72,12 +83,25 @@ static void basic_vm_bind_vm_destroy_client(int fd, struct xe_eudebug_client *c) {uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 );size_t bo_size =xe_get_default_alignment (fd); +bool test_discovery = c->flags &TEST_DISCOVERY ;uint32_t bo =xe_bo_create (fd,0 , bo_size,system_memory (fd),0 );uint64_t addr =0x1a0000 ; -xe_eudebug_client_vm_bind (c, fd, vm, bo,0 , addr, bo_size); -xe_eudebug_client_vm_destroy (c, fd, vm); +if (test_discovery) { + vm =xe_vm_create (fd,0 ,0 ); + +xe_vm_bind_async (fd, vm,0 , bo,0 , addr, bo_size,NULL ,0 ); + +xe_vm_destroy (fd, vm); + +xe_eudebug_client_signal_stage (c,STAGE_PRE_DEBUG_RESOURCES_DONE ); +xe_eudebug_client_wait_stage (c,STAGE_DISCOVERY_DONE ); + }else { + vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); +xe_eudebug_client_vm_bind (c, fd, vm, bo,0 , addr, bo_size); +xe_eudebug_client_vm_destroy (c, fd, vm); + }gem_close (fd, bo); }
@@ -213,6 +237,7 @@ static void vm_bind_client(int fd, struct xe_eudebug_client *c) {uint64_t op_ref_seqno, ref_seqno;struct bind_list *bl; +bool test_discovery = c->flags &TEST_DISCOVERY ;size_t bo_size =3 *xe_get_default_alignment (fd);uint32_t bo[2 ] = {xe_bo_create (fd,0 , bo_size,system_memory (fd),0 ),
@@ -222,15 +247,48 @@ static void vm_bind_client(int fd, struct xe_eudebug_client *c)uint64_t addr[] = {0x2a0000 ,0x3a0000 };uint64_t rebind_bo_offset =2 * bo_size /3 ;uint64_t size = bo_size /3 ; +int i =0 ; + +if (test_discovery) { +xe_vm_bind_async (fd, vm,0 , bo[0 ],0 , addr[0 ], bo_size,NULL ,0 ); + +xe_vm_unbind_async (fd, vm,0 ,0 , addr[0 ] + size, size,NULL ,0 ); -xe_eudebug_client_vm_bind (c, fd, vm, bo[0 ],0 , addr[0 ], bo_size); -xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr[0 ] + size, size); +xe_vm_bind_async (fd, vm,0 , bo[1 ],0 , addr[1 ], bo_size,NULL ,0 ); -xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ],0 , addr[1 ], bo_size); -xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ], rebind_bo_offset, addr[1 ], size); +xe_vm_bind_async (fd, vm,0 , bo[1 ], rebind_bo_offset, addr[1 ], size,NULL ,0 ); - bl =create_bind_list (fd,system_memory (fd), vm,4 ); -do_bind_list (c, bl,NULL ); + bl =create_bind_list (fd,system_memory (fd), vm,4 ); +xe_vm_bind_array (bl->fd, bl->vm,0 , bl->bind_ops, bl->n,NULL ,0 ); + +xe_vm_unbind_all_async (fd, vm,0 , bo[0 ],NULL ,0 ); + +xe_eudebug_client_vm_bind_event (c,DRM_XE_EUDEBUG_EVENT_STATE_CHANGE , + bl->fd, bl->vm,0 , bl->n +2 , &ref_seqno); + +xe_eudebug_client_vm_bind_op_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , ref_seqno, + &op_ref_seqno, addr[1 ], size,0 ); +xe_eudebug_client_vm_bind_op_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , ref_seqno, + &op_ref_seqno, addr[1 ] + size, size *2 ,0 ); + +for (i =0 ; i < bl->n; i++) +xe_eudebug_client_vm_bind_op_event (c,DRM_XE_EUDEBUG_EVENT_CREATE , + ref_seqno, &op_ref_seqno, + bl->bind_ops[i].addr, + bl->bind_ops[i].range,0 ); + +xe_eudebug_client_signal_stage (c,STAGE_PRE_DEBUG_RESOURCES_DONE ); +xe_eudebug_client_wait_stage (c,STAGE_DISCOVERY_DONE ); + }else { +xe_eudebug_client_vm_bind (c, fd, vm, bo[0 ],0 , addr[0 ], bo_size); +xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr[0 ] + size, size); + +xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ],0 , addr[1 ], bo_size); +xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ], rebind_bo_offset, addr[1 ], size); + + bl =create_bind_list (fd,system_memory (fd), vm,4 ); +do_bind_list (c, bl,NULL ); + }xe_vm_unbind_all_async (fd, vm,0 , bo[1 ],NULL ,0 );
@@ -582,6 +640,56 @@ static void test_basic_sessions(int fd, unsigned int flags, int count, bool matcxe_eudebug_session_destroy (s[i]); } +/** +* SUBTEST: basic-vm-bind-discovery +* Description: +* Attach the debugger to a process that performs vm-bind before attaching +* and check if the discovery process reports it. +* +* SUBTEST: basic-vm-bind-vm-destroy-discovery +* Description: +* Attach the debugger to a process that performs vm bind, and destroys +* the vm without unbinding before attaching. Make sure that we don't get +* any bind/unbind and vm create/destroy events. +* +* SUBTEST: basic-vm-bind-extended-discovery +* Description: +* Attach the debugger to a process that performs bind, bind array, rebind, +* partial unbind, and unbind all operations before attaching. Ensure that +* we get a only a singe 'VM_BIND' event from the discovery worker. +*/ +static void test_basic_discovery (int fd,unsigned int flags,bool match_opposite) +{ +struct xe_eudebug_debugger *d; +struct xe_eudebug_session *s; +struct xe_eudebug_client *c; + + s =xe_eudebug_session_create (fd, run_basic_client, flags |TEST_DISCOVERY ,NULL ); + + c = s->c; + d = s->d; + +xe_eudebug_client_start (c); +xe_eudebug_debugger_wait_stage (s,STAGE_PRE_DEBUG_RESOURCES_DONE ); + +igt_assert_eq (xe_eudebug_debugger_attach (d, c),0 ); +xe_eudebug_debugger_start_worker (d); + +/* give the worker time to do it's job */ +sleep (2 ); +xe_eudebug_debugger_signal_stage (d,STAGE_DISCOVERY_DONE ); + +xe_eudebug_client_wait_done (c); + +xe_eudebug_debugger_stop_worker (d,1 ); + +xe_eudebug_event_log_print (d->log, true); +xe_eudebug_event_log_print (c->log, true); + +xe_eudebug_session_check (s, match_opposite,0 ); +xe_eudebug_session_destroy (s); +} +#define RESOURCE_COUNT 16#define PRIMARY_THREAD (1 << 0)#define DISCOVERY_CLOSE_CLIENT (1 << 1)
@@ -1200,12 +1308,21 @@ igt_main igt_subtest("basic-vm-bind")test_basic_sessions (fd,VM_BIND ,1 , true); + igt_subtest("basic-vm-bind-discovery") +test_basic_discovery (fd,VM_BIND , true); + igt_subtest("basic-vm-bind-vm-destroy")test_basic_sessions (fd,VM_BIND_VM_DESTROY ,1 , false); + igt_subtest("basic-vm-bind-vm-destroy-discovery") +test_basic_discovery (fd,VM_BIND_VM_DESTROY , false); + igt_subtest("basic-vm-bind-extended")test_basic_sessions (fd,VM_BIND_EXTENDED ,1 , true); + igt_subtest("basic-vm-bind-extended-discovery") +test_basic_discovery (fd,VM_BIND_EXTENDED , true); + igt_subtest("read-metadata")test_metadata_read (fd,0 ,1 );
Signature · 1 line
2.34.1
PATCH v2 25/66 tests/xe_eudebug: Add basic-vm-bind-metadata-discovery
In reply to Christoph ManszewskiFrom: Maciej Patelczyk <[email protected]>
Added VM BIND Discovery type test that shall detect attached metadata.
--- tests/intel/xe_eudebug.c | 89 +++++++++++++++++++++++++++++----------- 1 file changed, 64 insertions(+), 25 deletions(-)
tests/intel/xe_eudebug.c +64 -25
@@ -55,18 +55,67 @@ static void test_sysfs_toggle(int fd)#define VM_BIND_VM_DESTROY (1 << 3)#define VM_BIND_EXTENDED (1 << 4)#define VM_METADATA (1 << 5) +#define VM_BIND_METADATA (1 << 6)#define TEST_DISCOVERY (1 << 31) +#define PAGE_SIZE 4096 +static struct drm_xe_vm_bind_op_ext_attach_debug * +basic_vm_bind_metadata_ext_prepare (int fd,struct xe_eudebug_client *c, +uint8_t **data,uint32_t data_size) +{ +struct drm_xe_vm_bind_op_ext_attach_debug *ext; +int i; + + *data =calloc (data_size,sizeof (*data)); +igt_assert (*data); + +for (i =0 ; i < data_size; i++) + (*data)[i] =0xff & (i + (i >PAGE_SIZE )); + + + ext =calloc (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM ,sizeof (*ext)); +igt_assert (ext); + +for (i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM ; i++) { + ext[i].base.name =XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG ; + ext[i].metadata_id =xe_eudebug_client_metadata_create (c, fd, i, + (i +1 ) *PAGE_SIZE , *data); + ext[i].cookie = i; + +if (i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM -1 ) + ext[i].base.next_extension =to_user_pointer (&ext[i+1 ]); + } +return ext; +} + +static void basic_vm_bind_metadata_ext_del (int fd,struct xe_eudebug_client *c, +struct drm_xe_vm_bind_op_ext_attach_debug *ext, +uint8_t *data) +{ +for (int i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM ; i++) +xe_eudebug_client_metadata_destroy (c, fd, ext[i].metadata_id, + i, (i +1 ) *PAGE_SIZE ); +free (ext); +free (data); +} +static void basic_vm_bind_client (int fd,struct xe_eudebug_client *c) { +struct drm_xe_vm_bind_op_ext_attach_debug *ext =NULL ;uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 );size_t bo_size =xe_get_default_alignment (fd);bool test_discovery = c->flags &TEST_DISCOVERY ; +bool test_metadata = c->flags &VM_BIND_METADATA ;uint32_t bo =xe_bo_create (fd,0 , bo_size,system_memory (fd),0 );uint64_t addr =0x1a0000 ; +uint8_t *data =NULL ; + +if (test_metadata) + ext =basic_vm_bind_metadata_ext_prepare (fd, c, &data,PAGE_SIZE ); -xe_eudebug_client_vm_bind (c, fd, vm, bo,0 , addr, bo_size); +xe_eudebug_client_vm_bind_flags (c, fd, vm, bo,0 , addr, + bo_size,0 ,NULL ,0 ,to_user_pointer (ext));if (test_discovery) {xe_eudebug_client_signal_stage (c,STAGE_PRE_DEBUG_RESOURCES_DONE );
@@ -75,6 +124,9 @@ static void basic_vm_bind_client(int fd, struct xe_eudebug_client *c)xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr, bo_size); +if (test_metadata) +basic_vm_bind_metadata_ext_del (fd, c, ext, data); +gem_close (fd, bo);xe_eudebug_client_vm_destroy (c, fd, vm); }
@@ -367,7 +419,7 @@ static void run_basic_client(struct xe_eudebug_client *c)xe_eudebug_client_vm_destroy (c, fd, vm); } -if (c->flags &VM_BIND ) +if (c->flags &VM_BIND || c->flags &VM_BIND_METADATA )basic_vm_bind_client (fd, c);if (c->flags &VM_BIND_EXTENDED )
@@ -646,6 +698,11 @@ static void test_basic_sessions(int fd, unsigned int flags, int count, bool matc* Attach the debugger to a process that performs vm-bind before attaching * and check if the discovery process reports it. * +* SUBTEST: basic-vm-bind-metadata-discovery +* Description: +* Attach the debugger to a process that performs vm-bind with metadata attached +* before attaching and check if the discovery process reports it. +* * SUBTEST: basic-vm-bind-vm-destroy-discovery * Description: * Attach the debugger to a process that performs vm bind, and destroys
@@ -1129,24 +1186,7 @@ static void metadata_access_client(struct xe_eudebug_client *c) vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); bo =xe_bo_create (fd, vm, bo_size,system_memory (fd),0 ); - data =calloc (MDATA_SIZE ,sizeof (*data)); -igt_assert (data); - -for (i =0 ; i <MDATA_SIZE ; i++) - data[i] =0xff & (i + (i >PAGE_SIZE )); - - ext =calloc (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA +1 ,sizeof (*ext)); -igt_assert (ext); - -for (i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA +1 ; i++) { - ext[i].base.name =XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG ; - ext[i].metadata_id =xe_eudebug_client_metadata_create (c, fd, i, - (i +1 ) *PAGE_SIZE , data); - ext[i].cookie = i; - -if (i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA ) - ext[i].base.next_extension =to_user_pointer (&ext[i+1 ]); - } + ext =basic_vm_bind_metadata_ext_prepare (fd, c, &data,MDATA_SIZE );xe_eudebug_client_vm_bind_flags (c, fd, vm, bo,0 , addr, bo_size,0 ,NULL ,0 ,to_user_pointer (ext));
@@ -1156,17 +1196,13 @@ static void metadata_access_client(struct xe_eudebug_client *c)xe_eudebug_client_vm_unbind (c, fd, vm,0 , addr, bo_size); -for (i =0 ; i <WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA +1 ; i++) -xe_eudebug_client_metadata_destroy (c, fd, ext[i].metadata_id, i, (i +1 ) *PAGE_SIZE ); +basic_vm_bind_metadata_ext_del (fd, c, ext, data);close (bo);xe_eudebug_client_vm_destroy (c, fd, vm);xe_device_put (fd);xe_eudebug_client_close_driver (c, fd); - -free (data); -free (ext); } static void debugger_test_metadata(struct xe_eudebug_debugger *d,
@@ -1311,6 +1347,9 @@ igt_main igt_subtest("basic-vm-bind-discovery")test_basic_discovery (fd,VM_BIND , true); + igt_subtest("basic-vm-bind-metadata-discovery") +test_basic_discovery (fd,VM_BIND_METADATA , true); + igt_subtest("basic-vm-bind-vm-destroy")test_basic_sessions (fd,VM_BIND_VM_DESTROY ,1 , false);
Signature · 1 line
2.34.1
PATCH v2 26/66 tests/xe_eudebug: Add basic-vm-access-parameters test
In reply to Christoph ManszewskiFrom: Pawel Sikora <[email protected]>
This new test checks negative scenarios of VM_OPEN ioctl and pread/pwrite usage.
--- tests/intel/xe_eudebug.c | 143 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+)
tests/intel/xe_eudebug.c +143 -0
@@ -1168,6 +1168,146 @@ static void test_vm_access(int fd, unsigned int flags, int num_clients) false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP); } +static void debugger_test_vma_parameters (struct xe_eudebug_debugger *d, +uint64_t client_handle, +uint64_t vm_handle, +uint64_t va_start, +uint64_t va_length) +{ +struct drm_xe_eudebug_vm_open vo = {0 , }; +uint64_t *v; +uint64_t items = va_length /sizeof (uint64_t ); +int fd; +int r, i; + + v =malloc (va_length); +igt_assert (v); + +/* Negative VM open - bad client handle */ + vo.client_handle = client_handle +123 ; + vo.vm_handle = vm_handle; + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert (fd <0 ); + +/* Negative VM open - bad vm handle */ + vo.client_handle = client_handle; + vo.vm_handle = vm_handle +123 ; + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert (fd <0 ); + +/* Positive VM open */ + vo.client_handle = client_handle; + vo.vm_handle = vm_handle; + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert_lte (0 , fd); + +/* Negative pread - bad fd */ + r =pread (fd +123 , v, va_length, va_start); +igt_assert (r <0 ); + +/* Negative pread - bad va_start */ + r =pread (fd, v, va_length,0 ); +igt_assert (r <0 ); + +/* Negative pread - bad va_start */ + r =pread (fd, v, va_length, va_start -1 ); +igt_assert (r <0 ); + +/* Positive pread - zero va_length */ + r =pread (fd, v,0 , va_start); +igt_assert_eq (r,0 ); + +/* Negative pread - out of range */ + r =pread (fd, v, va_length +1 , va_start); +igt_assert_eq (r, va_length); + +/* Negative pread - bad va_start */ + r =pread (fd, v,1 , va_start + va_length); +igt_assert (r <0 ); + +/* Positive pread - whole range */ + r =pread (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); + +/* Positive pread */ + r =pread (fd, v,1 , va_start + va_length -1 ); +igt_assert_eq (r,1 ); + +for (i =0 ; i < items; i++) +igt_assert_eq (v[i], va_start + i); + +for (i =0 ; i < items; i++) + v[i] = va_start + i +1 ; + +/* Negative pwrite - bad fd */ + r =pwrite (fd +123 , v, va_length, va_start); +igt_assert (r <0 ); + +/* Negative pwrite - bad va_start */ + r =pwrite (fd, v, va_length,-1 ); +igt_assert (r <0 ); + +/* Negative pwrite - zero va_start */ + r =pwrite (fd, v, va_length,0 ); +igt_assert (r <0 ); + +/* Negative pwrite - bad va_length */ + r =pwrite (fd, v, va_length +1 , va_start); +igt_assert_eq (r, va_length); + +/* Positive pwrite - zero va_length */ + r =pwrite (fd, v,0 , va_start); +igt_assert_eq (r,0 ); + +/* Positive pwrite */ + r =pwrite (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); +fsync (fd); + +close (fd); +free (v); +} + +static void vm_trigger_access_parameters (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +struct drm_xe_eudebug_event_vm_bind *eb; + +igt_debug ("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n" , + eo->vm_bind_ref_seqno, + eo->addr, + eo->range); + + eb = (struct drm_xe_eudebug_event_vm_bind *) +xe_eudebug_event_log_find_seqno (d->log, eo->vm_bind_ref_seqno); +igt_assert (eb); + +debugger_test_vma_parameters (d, eb->client_handle, eb->vm_handle, + eo->addr, eo->range); +xe_eudebug_debugger_signal_stage (d, eo->addr); + } +} + +/** +* SUBTEST: basic-vm-access-parameters +* Description: +* Check negative scenarios of VM_OPEN ioctl and pread/pwrite usage. +*/ +static void test_vm_access_parameters (int fd,unsigned int flags,int num_clients) +{ +struct drm_xe_engine_class_instance *hwe; + +xe_for_each_engine (fd, hwe) +test_client_with_trigger (fd, flags, num_clients, + vm_access_client, +DRM_XE_EUDEBUG_EVENT_VM_BIND_OP , + vm_trigger_access_parameters, hwe, + false,XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP ); +} +#define PAGE_SIZE 4096#define MDATA_SIZE (WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM * PAGE_SIZE)static void metadata_access_client (struct xe_eudebug_client *c)
@@ -1332,6 +1472,9 @@ igt_main igt_subtest("basic-vm-access")test_vm_access (fd,0 ,1 ); + igt_subtest("basic-vm-access-parameters") +test_vm_access_parameters (fd,0 ,1 ); + igt_subtest("multiple-sessions")test_basic_sessions (fd,CREATE_VMS |CREATE_EXEC_QUEUES ,4 , true);
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 26/66] tests/xe_eudebug: Add basic-vm-access-parameters test
Quoted 199 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 26/66] tests/xe_eudebug: Add basic-vm-access- parameters testFrom: Pawel Sikora <[email protected]>
This new test checks negative scenarios of
VM_OPENioctl and pread/pwrite usage.Signed-off-by Pawel Sikora <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_eudebug.c | 143 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
d4036ba05..ab856727e100644tests/intel/xe_eudebug.c +114
-0@@ -1168,6 +1168,146 @@ static void test_vm_access(int fd, unsigned int flags, int num_clients) false, XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP); } +static void debugger_test_vma_parameters (struct xe_eudebug_debugger *d, +uint64_t client_handle, +uint64_t vm_handle, +uint64_t va_start, +uint64_t va_length) +{ +struct drm_xe_eudebug_vm_open vo = {0 , }; +uint64_t *v; +uint64_t items = va_length /sizeof (uint64_t ); +int fd; +int r, i; + + v =malloc (va_length); +igt_assert (v); + +/* Negative VM open - bad client handle */ + vo.client_handle = client_handle +123 ; + vo.vm_handle = vm_handle; + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert (fd <0 ); + +/* Negative VM open - bad vm handle */ + vo.client_handle = client_handle; + vo.vm_handle = vm_handle +123 ; + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert (fd <0 ); + +/* Positive VM open */ + vo.client_handle = client_handle; + vo.vm_handle = vm_handle; + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert_lte (0 , fd); + +/* Negative pread - bad fd */ + r =pread (fd +123 , v, va_length, va_start); +igt_assert (r <0 ); + +/* Negative pread - bad va_start */ + r =pread (fd, v, va_length,0 ); +igt_assert (r <0 ); + +/* Negative pread - bad va_start */ + r =pread (fd, v, va_length, va_start -1 ); +igt_assert (r <0 ); + +/* Positive pread - zero va_length */ + r =pread (fd, v,0 , va_start); +igt_assert_eq (r,0 ); + +/* Negative pread - out of range */ + r =pread (fd, v, va_length +1 , va_start); +igt_assert_eq (r, va_length); + +/* Negative pread - bad va_start */ + r =pread (fd, v,1 , va_start + va_length); +igt_assert (r <0 ); + +/* Positive pread - whole range */ + r =pread (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); + +/* Positive pread */ + r =pread (fd, v,1 , va_start + va_length -1 ); +igt_assert_eq (r,1 ); + +for (i =0 ; i < items; i++) +igt_assert_eq (v[i], va_start + i); + +for (i =0 ; i < items; i++) + v[i] = va_start + i +1 ; + +/* Negative pwrite - bad fd */ + r =pwrite (fd +123 , v, va_length, va_start); +igt_assert (r <0 ); + +/* Negative pwrite - bad va_start */ + r =pwrite (fd, v, va_length,-1 ); +igt_assert (r <0 ); + +/* Negative pwrite - zero va_start */ + r =pwrite (fd, v, va_length,0 ); +igt_assert (r <0 ); + +/* Negative pwrite - bad va_length */ + r =pwrite (fd, v, va_length +1 , va_start); +igt_assert_eq (r, va_length); + +/* Positive pwrite - zero va_length */ + r =pwrite (fd, v,0 , va_start); +igt_assert_eq (r,0 ); + +/* Positive pwrite */ + r =pwrite (fd, v, va_length, va_start); +igt_assert_eq (r, va_length); +fsync (fd); + +close (fd); +free (v); +} + +static void vm_trigger_access_parameters (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) { +struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +struct drm_xe_eudebug_event_vm_bind *eb; + + igt_debug("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n", + eo->vm_bind_ref_seqno, + eo->addr, + eo->range); + + eb = (struct drm_xe_eudebug_event_vm_bind *) + xe_eudebug_event_log_find_seqno(d->log, eo-Quoted 1 line
vm_bind_ref_seqno);tests/intel/xe_eudebug.c +3
-0+igt_assert (eb); + + debugger_test_vma_parameters(d, eb->client_handle, eb-Quoted 1 line
vm_handle,tests/intel/xe_eudebug.c +18
-0+ eo->addr, eo->range); +xe_eudebug_debugger_signal_stage (d, eo->addr); + } +} + +/** +* SUBTEST: basic-vm-access-parameters +* Description: +* Check negative scenarios of VM_OPEN ioctl and pread/pwrite usage. +*/ +static void test_vm_access_parameters (int fd,unsigned int flags,int +num_clients) { +struct drm_xe_engine_class_instance *hwe; + +xe_for_each_engine (fd, hwe) + test_client_with_trigger(fd, flags, num_clients, + vm_access_client, +
DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,tests/intel/xe_eudebug.c +2
-0+ vm_trigger_access_parameters, hwe, + false,
XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP);tests/intel/xe_eudebug.c +2
-0+} +#define PAGE_SIZE 4096#define MDATA_SIZE (
WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM*PAGE_SIZE) static voidmetadata_access_client(struct xe_eudebug_client *c)@@ -1332,6 +1472,9 @@igt_maintests/intel/xe_eudebug.c +3
-0igt_subtest("basic-vm-access")test_vm_access (fd,0 ,1 ); + igt_subtest("basic-vm-access-parameters") +test_vm_access_parameters (fd,0 ,1 ); + igt_subtest("multiple-sessions") test_basic_sessions(fd, CREATE_VMS |
CREATE_EXEC_QUEUES, 4, true);--
2.34.1
PATCH v2 27/66 lib/xe_eudebug: Add mutex for log events write
In reply to Christoph ManszewskiFrom: Pawel Sikora <[email protected]>
Make 'xe_eudebug_event_log_write' to be thread-safe.
--- lib/xe/xe_eudebug.c | 6 +++++- lib/xe/xe_eudebug.h | 1 + 2 files changed, 6 insertions(+), 1 deletion(-)
lib/xe/xe_eudebug.c +5 -1
@@ -836,6 +836,7 @@ struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsigigt_assert (l->log); l->max_size = max_size;strncpy (l->name, name,sizeof (l->name) -1 ); +pthread_mutex_init (&l->lock,NULL );return l; }
@@ -848,6 +849,7 @@ struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsig*/ void xe_eudebug_event_log_destroy (struct xe_eudebug_event_log *l) { +pthread_mutex_destroy (&l->lock);free (l->log);free (l); }
@@ -857,7 +859,7 @@ void xe_eudebug_event_log_destroy(struct xe_eudebug_event_log *l)* @l: event log pointer * @e: event to be written to event log * -* Writes event @e to the event log. +* Writes event @e to the event log, thread-safe. */ void xe_eudebug_event_log_write (struct xe_eudebug_event_log *l,struct drm_xe_eudebug_event *e) {
@@ -868,6 +870,7 @@ void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_eu*/ igt_assert_lt (e->seqno,10 *1000 *1000 ); +pthread_mutex_lock (&l->lock);igt_assert_lt (l->head + e->len, l->max_size);memcpy (l->log + l->head, e, e->len); l->head += e->len;
@@ -876,6 +879,7 @@ void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct drm_xe_euigt_info ("%s: wrote %u bytes to eventlog, free %u bytes\n" , l->name, e->len, l->max_size - l->head);#endif +pthread_mutex_unlock (&l->lock); }/**
lib/xe/xe_eudebug.h +1 -0
@@ -14,6 +14,7 @@ struct xe_eudebug_event_log {unsigned int head;unsigned int max_size;char name[80 ]; +pthread_mutex_t lock; };struct xe_eudebug_debugger {
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 27/66] lib/xe_eudebug: Add mutex for log events write
Quoted 89 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 27/66]lib/xe_eudebug: Add mutex for log events writeFrom: Pawel Sikora <[email protected]>
Make '
xe_eudebug_event_log_write' to be thread-safe.Signed-off-by Pawel Sikora <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- lib/xe/xe_eudebug.c | 6 +++++- lib/xe/xe_eudebug.h | 1 + 2 files changed, 6 insertions(+), 1 deletion(-)lib/xe/xe_eudebug.c index renamed from lib/xe/xe_eudebug.c +0
-0
ed1e382c7..254a7261a100644lib/xe/xe_eudebug.c +1
-0@@ -836,6 +836,7 @@ struct xe_eudebug_event_log *xe_eudebug_event_log_create(const char *name, unsig igt_assert(l->log); l->max_size = max_size; strncpy(l->name, name, sizeof(l->name) - 1); + pthread_mutex_init(&l->lock, NULL);return l;}
lib/xe/xe_eudebug.c +2
-1@@ -848,6 +849,7 @@ struct xe_eudebug_event_log*xe_eudebug_event_log_create(const char *name, unsig */ void xe_eudebug_event_log_destroy (struct xe_eudebug_event_log *l) { +pthread_mutex_destroy (&l->lock);free (l->log);free (l); }@@ -857,7 +859,7 @@ void xe_eudebug_event_log_destroy(structxe_eudebug_event_log *l) * @l: event log pointer * @e: event to be written to event log * -* Writes event @e to the event log. +* Writes event @e to the event log, thread-safe. */ void xe_eudebug_event_log_write(struct xe_eudebug_event_log *l, struct
drm_xe_eudebug_event*e) { @@ -868,6 +870,7 @@ void xe_eudebug_event_log_write(structxe_eudebug_event_log*l, structdrm_xe_eulib/xe/xe_eudebug.c +1
-0*/ igt_assert_lt (e->seqno,10 *1000 *1000 ); +pthread_mutex_lock (&l->lock);igt_assert_lt (l->head + e->len, l->max_size);memcpy (l->log + l->head, e, e->len); l->head += e->len;@@ -876,6 +879,7 @@ void xe_eudebug_event_log_write(struct
xe_eudebug_event_log*l, structdrm_xe_eulib/xe/xe_eudebug.c +1
-0igt_info ("%s: wrote %u bytes to eventlog, free %u bytes\n" , l->name, e->len, l->max_size - l->head);#endif +pthread_mutex_unlock (&l->lock); }/** lib/xe/xe_eudebug.h index renamed from lib/xe/xe_eudebug.h +0
-0
81c33417f..a499cc977100644lib/xe/xe_eudebug.h +1
-1@@ -14,6 +14,7 @@ struct xe_eudebug_event_log {unsigned int head;unsigned int max_size;char name[80 ]; +pthread_mutex_t lock; };struct xe_eudebug_debugger { --2.34.1
PATCH v2 28/66 tests/xe_eudebug: Add basic-client-th test
In reply to Christoph ManszewskiFrom: Pawel Sikora <[email protected]>
Add basic-client-th test which is a multithreaded version of basic-client.
Create random number of VMs in random number of threads.
--- tests/intel/xe_eudebug.c | 77 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+)
tests/intel/xe_eudebug.c +77 -0
@@ -13,6 +13,7 @@*/ #include <poll.h> +#include <pthread.h> #include <sys/ioctl.h> #include "igt.h"
@@ -640,6 +641,10 @@ static void test_read_event(int fd)* Description: * Attach the debugger to process which opens and closes xe drm client. * +* SUBTEST: basic-client-th +* Description: +* Create client basic resources (vms) in multiple threads +* * SUBTEST: multiple-sessions * Description: * Simultaneously attach many debuggers to many processes.
@@ -1057,6 +1062,75 @@ static void test_client_with_trigger(int fd, unsigned int flags, int count,xe_eudebug_session_destroy (s[i]); } +struct thread_fn_args { +struct xe_eudebug_client *client; +int fd; +}; + +static void *basic_client_th (void *data) +{ +struct thread_fn_args *f = data; +struct xe_eudebug_client *c = f->client; +uint32_t *vms; +int fd, i, num_vms; + + fd = f->fd; +igt_assert (fd); + +xe_device_get (fd); + + num_vms =2 +rand () %16 ; + vms =calloc (num_vms,sizeof (*vms)); +igt_assert (vms); +igt_debug ("Create %d client vms\n" , num_vms); + +for (i =0 ; i < num_vms; i++) + vms[i] =xe_eudebug_client_vm_create (c, fd,DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE ,0 ); + +for (i =0 ; i < num_vms; i++) +xe_eudebug_client_vm_destroy (c, fd, vms[i]); + +xe_device_put (fd); +free (vms); + +return NULL ; +} + +static void run_basic_client_th (struct xe_eudebug_client *c) +{ +struct thread_fn_args *args; +int i, num_threads, fd; +pthread_t *threads; + + args =calloc (1 ,sizeof (*args)); +igt_assert (args); + + num_threads =2 +random () %16 ; +igt_debug ("Run on %d threads\n" , num_threads); + threads =calloc (num_threads,sizeof (*threads)); +igt_assert (threads); + + fd =xe_eudebug_client_open_driver (c); + args->client = c; + args->fd = fd; + +for (i =0 ; i < num_threads; i++) +pthread_create (&threads[i],NULL , basic_client_th, args); + +for (i =0 ; i < num_threads; i++) +pthread_join (threads[i],NULL ); + +xe_eudebug_client_close_driver (c, fd); +free (args); +free (threads); +} + +static void test_basic_sessions_th (int fd,unsigned int flags,int num_clients,bool match_opposite) +{ +test_client_with_trigger (fd, flags, num_clients, run_basic_client_th, +0 ,NULL ,NULL , match_opposite,0 ); +} +static void vm_access_client (struct xe_eudebug_client *c) {struct drm_xe_sync sync = {
@@ -1469,6 +1543,9 @@ igt_main igt_subtest("basic-client")test_basic_sessions (fd,0 ,1 , true); + igt_subtest("basic-client-th") +test_basic_sessions_th (fd,0 ,1 , true); + igt_subtest("basic-vm-access")test_vm_access (fd,0 ,1 );
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 28/66] tests/xe_eudebug: Add basic-client-th test
Quoted 137 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 28/66] tests/xe_eudebug: Add basic-client-th testFrom: Pawel Sikora <[email protected]>
Add basic-client-th test which is a multithreaded version of basic-client.
Create random number of VMs in random number of threads.
Signed-off-by Pawel Sikora <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- tests/intel/xe_eudebug.c | 77 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
ab856727e..022b39f1f100644tests/intel/xe_eudebug.c +75
-1@@ -13,6 +13,7 @@*/ #include <poll.h> +#include <pthread.h> #include <sys/ioctl.h> #include "igt.h" @@ -640,6 +641,10 @@ static void test_read_event(int fd)* Description: * Attach the debugger to process which opens and closes xe drm client. * +* SUBTEST: basic-client-th +* Description: +* Create client basic resources (vms) in multiple threads +* * SUBTEST: multiple-sessions * Description: * Simultaneously attach many debuggers to many processes. @@ -1057,6 +1062,75 @@ static void test_client_with_trigger(int fd, unsigned int flags, int count,xe_eudebug_session_destroy (s [i]); } +struct thread_fn_args { +struct xe_eudebug_client *client; +int fd; +}; + +static void *basic_client_th (void *data) { +struct thread_fn_args *f = data; +struct xe_eudebug_client *c = f->client; +uint32_t *vms; +int fd, i, num_vms; + + fd = f->fd; +igt_assert (fd); + +xe_device_get (fd); + + num_vms =2 +rand () %16 ; + vms =calloc (num_vms,sizeof (*vms)); +igt_assert (vms); +igt_debug ("Create %d client vms\n" , num_vms); + +for (i =0 ; i < num_vms; i++) + vms[i] =xe_eudebug_client_vm_create (c, fd, +DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE ,0 ); + +for (i =0 ; i < num_vms; i++) +xe_eudebug_client_vm_destroy (c, fd, vms[i]); + +xe_device_put (fd); +free (vms); + +return NULL ; +} + +static void run_basic_client_th (struct xe_eudebug_client *c) { +struct thread_fn_args *args; +int i, num_threads, fd; +pthread_t *threads; + + args =calloc (1 ,sizeof (*args)); +igt_assert (args); + + num_threads =2 +random () %16 ; +igt_debug ("Run on %d threads\n" , num_threads); + threads =calloc (num_threads,sizeof (*threads)); +igt_assert (threads); + + fd =xe_eudebug_client_open_driver (c); + args->client = c; + args->fd = fd; + +for (i =0 ; i < num_threads; i++) +pthread_create (&threads[i],NULL , basic_client_th, args); + +for (i =0 ; i < num_threads; i++) +pthread_join (threads[i],NULL ); + +xe_eudebug_client_close_driver (c, fd); +free (args); +free (threads); +} + +static void test_basic_sessions_th (int fd,unsigned int flags,int +num_clients,bool match_opposite) { +test_client_with_trigger (fd, flags, num_clients, run_basic_client_th, +0 ,NULL ,NULL , match_opposite,0 ); } +static void vm_access_client (struct xe_eudebug_client *c) {struct drm_xe_sync sync = {@@ -1469,6 +1543,9 @@ igt_main igt_subtest("basic-client")test_basic_sessions (fd,0 ,1 , true); + igt_subtest("basic-client-th") +test_basic_sessions_th (fd,0 ,1 , true); + igt_subtest("basic-vm-access")test_vm_access (fd,0 ,1 ); --2.34.1
PATCH v2 29/66 tests/xe_eudebug: Added connect-user test
In reply to Christoph ManszewskiFrom: Maciej Patelczyk <[email protected]>
Verify the connection:
* user to user
* user to root
* root to user
* user to other user
The test uses two known non-privileged users lp and mail to verify the scenarios. Test drops root privileges to one of users if necessary.
ptrace cannot access process which is not dumpable. The default value of this property is stored in '/proc/sys/fs/suid_dumpable'. If process drops privileges then it gets the value from mentioned suid_dumpable.
In our case the value after switching userm, to non privileged one, is 2 (SUID_DUMP_ROOT). Enforce it to be 1 (SUID_DUMP_USER).
--- tests/intel/xe_eudebug.c | 164 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 164 insertions(+)
tests/intel/xe_eudebug.c +164 -0
@@ -12,9 +12,12 @@* Test category: functionality test */ +#include <grp.h> #include <poll.h> #include <pthread.h> +#include <pwd.h> #include <sys/ioctl.h> +#include <sys/prctl.h> #include "igt.h" #include "intel_pat.h"
@@ -545,6 +548,164 @@ static void test_connect(int fd)close (debugfd); } +static void switch_user (__uid_t uid,__gid_t gid) +{ +struct group *gr; +__gid_t gr_v; + +/* Users other then root need to belong to video group */ + gr =getgrnam ("video" ); +igt_assert (gr); + +/* Drop all */ +igt_assert_eq (setgroups (1 , &gr->gr_gid),0 ); +igt_assert_eq (setgid (gid),0 ); +igt_assert_eq (setuid (uid),0 ); + +igt_assert_eq (getgroups (1 , &gr_v),1 ); +igt_assert_eq (gr_v, gr->gr_gid); +igt_assert_eq (getgid (), gid); +igt_assert_eq (getuid (), uid); + +igt_assert_eq (prctl (PR_SET_DUMPABLE ,1L ),0 ); +} + +/** +* SUBTEST: connect-user +* Description: +* Verify unprivileged XE_EUDEBG_CONNECT ioctl. +* Check: +* - user debugger to user workload connection +* - user debugger to other user workload connection +* - user debugger to privileged workload connection +*/ +static void test_connect_user (int fd) +{ +struct drm_xe_eudebug_connect param = {}; +struct passwd *pwd, *pwd2; +const char *user1 ="lp" ; +const char *user2 ="mail" ; +int debugfd, ret, i; +int p1[2 ], p2[2 ]; +__uid_t u1, u2; +__gid_t g1, g2; +int newfd; +pid_t pid; + +#define NUM_USER_TESTS 4 +#define P_APP 0 +#define P_GDB 1 +struct conn_user { +/* u[0] - process uid, u[1] - gdb uid */ +__uid_t u[P_GDB +1 ]; +/* g[0] - process gid, g[1] - gdb gid */ +__gid_t g[P_GDB +1 ]; +/* Expected fd from open */ +int ret; +/* Skip this test case */ +int skip; +const char *desc; + } test[NUM_USER_TESTS ] = {}; + +igt_assert (!pipe (p1)); +igt_assert (!pipe (p2)); + + pwd =getpwnam (user1); +igt_require (pwd); + u1 = pwd->pw_uid; + g1 = pwd->pw_gid; + +/* +* Keep a copy of needed contents as it is a static +* memory area and subsequent calls will overwrite +* what's in. +* However getpwnam() returns NULL if cannot find +* user in passwd. +*/ +setpwent (); + pwd2 =getpwnam (user2); +if (pwd2) { + u2 = pwd2->pw_uid; + g2 = pwd2->pw_gid; + } + + test[0 ].skip = !pwd; + test[0 ].u[P_GDB ] = u1; + test[0 ].g[P_GDB ] = g1; + test[0 ].ret = -EACCES ; + test[0 ].desc ="User GDB to Root App" ; + + test[1 ].skip = !pwd; + test[1 ].u[P_APP ] = u1; + test[1 ].g[P_APP ] = g1; + test[1 ].u[P_GDB ] = u1; + test[1 ].g[P_GDB ] = g1; + test[1 ].ret =0 ; + test[1 ].desc ="User GDB to User App" ; + + test[2 ].skip = !pwd; + test[2 ].u[P_APP ] = u1; + test[2 ].g[P_APP ] = g1; + test[2 ].ret =0 ; + test[2 ].desc ="Root GDB to User App" ; + + test[3 ].skip = !pwd2; + test[3 ].u[P_APP ] = u1; + test[3 ].g[P_APP ] = g1; + test[3 ].u[P_GDB ] = u2; + test[3 ].g[P_GDB ] = g2; + test[3 ].ret = -EACCES ; + test[3 ].desc ="User GDB to Other User App" ; + +if (!pwd2) +igt_warn ("User %s not available in the system. Skipping subtests: %s.\n" , + user2, test[3 ].desc); + +for (i =0 ; i <NUM_USER_TESTS ; i++) { +if (test[i].skip) { +igt_debug ("Subtest %s skipped\n" , test[i].desc); +continue ; + } +igt_debug ("Executing connection: %s\n" , test[i].desc); + igt_fork(child, 2) { +if (!child) { +if (test[i].u[P_APP ]) +switch_user (test[i].u[P_APP ], test[i].g[P_APP ]); + + pid =getpid (); +/* Signal the PID */ +igt_assert (write (p1[1 ], &pid,sizeof (pid)) ==sizeof (pid)); +/* wait with exit */ +igt_assert (read (p2[0 ], &pid,sizeof (pid)) ==sizeof (pid)); + }else { +if (test[i].u[P_GDB ]) +switch_user (test[i].u[P_GDB ], test[i].g[P_GDB ]); + +igt_assert (read (p1[0 ], &pid,sizeof (pid)) ==sizeof (pid)); + param.pid = pid; + + newfd =drm_open_driver (DRIVER_XE ); + ret =__debug_connect (newfd, &debugfd, ¶m); + +/* Release the app first */ +igt_assert (write (p2[1 ], &pid,sizeof (pid)) ==sizeof (pid)); + +igt_assert_eq (ret, test[i].ret); +if (!ret) +close (debugfd); + } + } +igt_waitchildren (); + } +close (p1[0 ]); +close (p1[1 ]); +close (p2[0 ]); +close (p2[1 ]); +#undef NUM_USER_TESTS +#undef P_APP +#undef P_GDB +} +/** * SUBTEST: basic-close * Description:
@@ -1534,6 +1695,9 @@ igt_main igt_subtest("basic-connect")test_connect (fd); + igt_subtest("connect-user") +test_connect_user (fd); + igt_subtest("basic-close")test_close (fd);
Signature · 1 line
2.34.1
PATCH v2 30/66 tests/xe_eudebug: Add discovery-race-vmbind subtest
In reply to Christoph ManszewskiFrom: Karolina Stolarek <[email protected]>
Extend discovery-race test case with BO creation and vm_bind operation to verify that all vm_bind_op events are properly registered and replayed.
--- tests/intel/xe_eudebug.c | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-)
tests/intel/xe_eudebug.c +29 -2
@@ -917,11 +917,13 @@ static void test_basic_discovery(int fd, unsigned int flags, bool match_opposite#define PRIMARY_THREAD (1 << 0)#define DISCOVERY_CLOSE_CLIENT (1 << 1)#define DISCOVERY_DESTROY_RESOURCES (1 << 2) +#define DISCOVERY_VM_BIND (1 << 3)static void run_discovery_client (struct xe_eudebug_client *c) {struct drm_xe_engine_class_instance *hwe =NULL ;int fd[RESOURCE_COUNT ], i;bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES |DISCOVERY_CLOSE_CLIENT ); +uint64_t addr =0x1a0000 ;srand (getpid ());
@@ -950,18 +952,29 @@ static void run_discovery_client(struct xe_eudebug_client *c)sleep (1 );for (int j =0 ; j <RESOURCE_COUNT ; j++) { +uint32_t vm =xe_eudebug_client_vm_create (c, fd[i],0 ,0 );struct drm_xe_exec_queue_create create = { .width =1 , .num_placements =1 , - .vm_id =xe_eudebug_client_vm_create (c, fd[i],0 ,0 ), + .vm_id = vm, .instances =to_user_pointer (hwe) }; +const unsigned int bo_size =max_t (bo_size, +xe_get_default_alignment (fd[i]), +MIN_BO_SIZE ); +uint32_t bo =xe_bo_create (fd[i],0 , bo_size,system_memory (fd[i]),0 );xe_eudebug_client_exec_queue_create (c, fd[i], &create); +if (c->flags &DISCOVERY_VM_BIND ) { +xe_eudebug_client_vm_bind (c, fd[i], vm, bo,0 , addr, bo_size); + addr +=0x100000 ; + } +if (c->flags &DISCOVERY_DESTROY_RESOURCES ) {xe_eudebug_client_exec_queue_destroy (c, fd[i], &create);xe_eudebug_client_vm_destroy (c, fd[i], create.vm_id); +gem_close (fd[i], bo); } }
@@ -978,6 +991,7 @@ static void run_discovery_client(struct xe_eudebug_client *c)* arg[1]: * * @race: resources creation +* @race-vmbind: vm-bind operations * @empty: resources destruction * @empty-clients: client closure */
@@ -987,6 +1001,7 @@ static void *discovery_race_thread(void *data)uint64_t client_handle;int vm_count;int exec_queue_count; +int vm_bind_op_count; } clients[RESOURCE_COUNT ];struct xe_eudebug_session *s = data;int expected =RESOURCE_COUNT * (1 +2 *RESOURCE_COUNT );
@@ -1024,12 +1039,17 @@ static void *discovery_race_thread(void *data)igt_assert_eq (clients[i].exec_queue_count,RESOURCE_COUNT ); + +if (s->c->flags &DISCOVERY_VM_BIND ) +igt_assert_eq (clients[i].vm_bind_op_count, +RESOURCE_COUNT ); }igt_assert (++i <RESOURCE_COUNT ); clients[i].client_handle = eo->client_handle; clients[i].vm_count =0 ; clients[i].exec_queue_count =0 ; + clients[i].vm_bind_op_count =0 ; }if (e->type ==DRM_XE_EUDEBUG_EVENT_VM )
@@ -1037,6 +1057,9 @@ static void *discovery_race_thread(void *data)if (e->type ==DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE ) clients[i].exec_queue_count++; + +if (e->type ==DRM_XE_EUDEBUG_EVENT_VM_BIND_OP ) + clients[i].vm_bind_op_count++; };igt_assert_lte (0 , i);
@@ -1116,7 +1139,8 @@ static void test_race_discovery(int fd, unsigned int flags, int clients)igt_assert_eq (sessions[i].c->seqno-1 , sessions[i].d->event_count);xe_eudebug_event_log_compare (sessions[0 ].d->log, - sessions[i].d->log,0 ); + sessions[i].d->log, +XE_EUDEBUG_FILTER_EVENT_VM_BIND );xe_eudebug_client_destroy (sessions[i].c); }
@@ -1755,6 +1779,9 @@ igt_main igt_subtest("discovery-race")test_race_discovery (fd,0 ,4 ); + igt_subtest("discovery-race-vmbind") +test_race_discovery (fd,DISCOVERY_VM_BIND ,4 ); + igt_subtest("discovery-empty")test_empty_discovery (fd,DISCOVERY_CLOSE_CLIENT ,16 );
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 30/66] tests/xe_eudebug: Add discovery-race-vmbind subtest
Quoted 167 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 30/66] tests/xe_eudebug: Add discovery-race- vmbind subtestFrom: Karolina Stolarek <[email protected]>
Extend discovery-race test case with BO creation and
vm_bindoperation to verify that allvm_bind_opevents are properly registered and replayed.Signed-off-by Karolina Stolarek <[email protected]>Cc Dominik Grzegorzek <[email protected]>Cc Dominik Karol Piątkowski <[email protected]>--- tests/intel/xe_eudebug.c | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-)tests/intel/xe_eudebug.c index renamed from tests/intel/xe_eudebug.c +0
-0
8c21cffc7..c368e30e7100644tests/intel/xe_eudebug.c +0
-0@@ -917,11 +917,13 @@ static void test_basic_discovery(int fd, unsigned intflags, bool
match_opposite
#definePRIMARY_THREAD(1 << 0)
#defineDISCOVERY_CLOSE_CLIENT(1 << 1)
#defineDISCOVERY_DESTROY_RESOURCES(1 << 2)tests/intel/xe_eudebug.c +1
-0+#define DISCOVERY_VM_BIND (1 << 3)static void run_discovery_client (struct xe_eudebug_client *c) {struct drm_xe_engine_class_instance *hwe =NULL ;int fd[RESOURCE_COUNT ], i; bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES |
DISCOVERY_CLOSE_CLIENT);tests/intel/xe_eudebug.c +10
-1+uint64_t addr =0x1a0000 ;srand (getpid ());@@ -950,18 +952,29 @@ static void run_discovery_client(struct xe_eudebug_client *c) sleep(1);for (int j =0 ; j <RESOURCE_COUNT ; j++) { +uint32_t vm =xe_eudebug_client_vm_create (c, fd[i],0 ,0 );struct drm_xe_exec_queue_create create = { .width =1 , .num_placements =1 , - .vm_id =xe_eudebug_client_vm_create (c, fd[i], 0, 0), + .vm_id = vm, .instances =to_user_pointer (hwe) }; +const unsigned int bo_size =max_t (bo_size, +xe_get_default_alignment (fd[i]), +MIN_BO_SIZE ); +uint32_t bo =xe_bo_create (fd[i],0 , bo_size,system_memory (fd[i]), +0 );xe_eudebug_client_exec_queue_create (c, fd[i], &create); +if (c->flags &DISCOVERY_VM_BIND ) { + xe_eudebug_client_vm_bind(c, fd[i], vm, bo,0, addr,
bo_size);tests/intel/xe_eudebug.c +3
-0+ addr +=0x100000 ; + } +if (c->flags &DISCOVERY_DESTROY_RESOURCES ) { xe_eudebug_client_exec_queue_destroy(c,fd[i], &create);
xe_eudebug_client_vm_destroy(c, fd[i],
create.vm_id);tests/intel/xe_eudebug.c +2
-0+gem_close (fd[i], bo); } }@@ -978,6 +991,7 @@ static void run_discovery_client(struct xe_eudebug_client *c) * arg[1]: * * @race: resources creation + * @race-vmbind: vm-bind operations * @empty: resources destruction * @empty-clients: client closure*/
tests/intel/xe_eudebug.c +1
-1@@ -987,6 +1001,7 @@ static void *discovery_race_thread(void *data)uint64_t client_handle;int vm_count;int exec_queue_count; +int vm_bind_op_count; } clients[RESOURCE_COUNT ];struct xe_eudebug_session *s = data; int expected = RESOURCE_COUNT * (1 + 2 * RESOURCE_COUNT); @@ -1024,12 +1039,17 @@ static void *discovery_race_thread(void *data)igt_assert_eq(clients[i].exec_queue_count,
RESOURCE_COUNT);tests/intel/xe_eudebug.c +2
-0+ + if (s->c->flags &
DISCOVERY_VM_BIND)
+
igt_assert_eq(clients[i].vm_bind_op_count,
+RESOURCE_COUNT);tests/intel/xe_eudebug.c +0
-0}igt_assert (++i <RESOURCE_COUNT ); clients[i].client_handle = eo-Quoted 1 line
client_handle;tests/intel/xe_eudebug.c +1
-0clients[i].vm_count =0 ; clients[i].exec_queue_count =0 ; + clients[i].vm_bind_op_count =0 ; } if (e->type ==
DRM_XE_EUDEBUG_EVENT_VM) @@ -1037,6 +1057,9 @@ static void *discovery_race_thread(void *data)if (
e->type==DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE)tests/intel/xe_eudebug.c +2
-0clients[i].exec_queue_count++; + + if (e->type ==
DRM_XE_EUDEBUG_EVENT_VM_BIND_OP)tests/intel/xe_eudebug.c +3
-1+ clients[i].vm_bind_op_count++; };igt_assert_lte (0 , i);@@ -1116,7 +1139,8 @@ static void test_race_discovery(int fd, unsigned int flags, int clients)igt_assert_eq (sessions[i].c->seqno-1 , sessions[i].d- >event_count);xe_eudebug_event_log_compare (sessions[0 ].d->log, - sessions[i].d->log,0 ); + sessions[i].d->log, +XE_EUDEBUG_FILTER_EVENT_VM_BIND );tests/intel/xe_eudebug.c +3
-1xe_eudebug_client_destroy (sessions[i].c); }@@ -1755,6 +1779,9 @@ igt_main igt_subtest("discovery-race")test_race_discovery (fd,0 ,4 ); + igt_subtest("discovery-race-vmbind") +test_race_discovery (fd,DISCOVERY_VM_BIND ,4 ); + igt_subtest("discovery-empty")test_empty_discovery (fd,DISCOVERY_CLOSE_CLIENT ,16 ); --2.34.1
PATCH v2 31/66 tests/xe_eudebug: Add userptr variant of basic-vm-access test
In reply to Christoph ManszewskiFrom: Andrzej Hajda <[email protected]>
The variant uses DRM_XE_VM_BIND_OP_MAP_USERPTR to bind memory from userspace.
--- tests/intel/xe_eudebug.c | 103 ++++++++++++++++++++++++++++++--------- 1 file changed, 80 insertions(+), 23 deletions(-)
tests/intel/xe_eudebug.c +80 -23
@@ -60,6 +60,7 @@ static void test_sysfs_toggle(int fd)#define VM_BIND_EXTENDED (1 << 4)#define VM_METADATA (1 << 5)#define VM_BIND_METADATA (1 << 6) +#define VM_BIND_OP_MAP_USERPTR (1 << 7)#define TEST_DISCOVERY (1 << 31)#define PAGE_SIZE 4096
@@ -166,54 +167,82 @@ static void basic_vm_bind_vm_destroy_client(int fd, struct xe_eudebug_client *c)#define BO_ITEMS 4096#define MIN_BO_SIZE (BO_ITEMS * sizeof(uint64_t)) +union buf_id { +uint32_t fd; +void *userptr; +}; +struct bind_list {int fd;uint32_t vm; -uint32_t *bo; +union buf_id *bo;struct drm_xe_vm_bind_op *bind_ops;unsigned int n; }; -static void bo_prime (int fd,uint32_t bo,const uint64_t addr,const uint64_t size) +static void *bo_get_ptr (int fd,struct drm_xe_vm_bind_op *o) +{ +void *ptr; + +if (o->op !=DRM_XE_VM_BIND_OP_MAP_USERPTR ) + ptr =xe_bo_map (fd, o->obj, o->range); +else + ptr = (void *)(uintptr_t )o->userptr; + +igt_assert (ptr); + +return ptr; +} + +static void bo_put_ptr (int fd,struct drm_xe_vm_bind_op *o,void *ptr) +{ +if (o->op !=DRM_XE_VM_BIND_OP_MAP_USERPTR ) +munmap (ptr, o->range); +} + +static void bo_prime (int fd,struct drm_xe_vm_bind_op *o) {uint64_t *d;uint64_t i; - d =xe_bo_map (fd, bo, size); -igt_assert (d); + d =bo_get_ptr (fd, o); -for (i =0 ; i < size/sizeof (*d); i++) - d[i] = addr + i; +for (i =0 ; i < o->range /sizeof (*d); i++) + d[i] = o->addr + i; -munmap (d, size); +bo_put_ptr (fd, o, d); } -static void bo_check (int fd,uint32_t bo,const uint64_t addr,const uint64_t size) +static void bo_check (int fd,struct drm_xe_vm_bind_op *o) {uint64_t *d;uint64_t i; - d =xe_bo_map (fd, bo, size); -igt_assert (d); + d =bo_get_ptr (fd, o); -for (i =0 ; i < size/sizeof (*d); i++) -igt_assert_eq (d[i], addr + i +1 ); +for (i =0 ; i < o->range /sizeof (*d); i++) +igt_assert_eq (d[i], o->addr + i +1 ); -munmap (d, size); +bo_put_ptr (fd, o, d); } -static uint32_t *vm_create_objects (int fd,uint32_t bo_placement,uint32_t vm,unsigned int size, +static union buf_id *vm_create_objects (int fd,uint32_t bo_placement,uint32_t vm,unsigned int size,unsigned int n) { -uint32_t *bo; +union buf_id *bo;unsigned int i; bo =calloc (n,sizeof (*bo));igt_assert (bo);for (i =0 ; i < n; i++) { - bo[i] =xe_bo_create (fd, vm, size, bo_placement,0 ); -igt_assert (bo[i]); +if (bo_placement) { + bo[i].fd =xe_bo_create (fd, vm, size, bo_placement,0 ); +igt_assert (bo[i].fd); + }else { + bo[i].userptr =aligned_alloc (PAGE_SIZE , size); +igt_assert (bo[i].userptr); + } }return bo;
@@ -223,6 +252,7 @@ static struct bind_list *create_bind_list(int fd, uint32_t bo_placement, uint32_t vm, unsigned int n) {const unsigned int bo_size =max_t (bo_size,xe_get_default_alignment (fd),MIN_BO_SIZE ); +bool is_userptr = !bo_placement;struct bind_list *bl;unsigned int i;
@@ -237,6 +267,16 @@ static struct bind_list *create_bind_list(int fd, uint32_t bo_placement,for (i =0 ; i < n; i++) {struct drm_xe_vm_bind_op *o = &bl->bind_ops[i]; +if (is_userptr) { + o->obj =0 ; + o->userptr = (uintptr_t )bl->bo[i].userptr; + o->op =DRM_XE_VM_BIND_OP_MAP_USERPTR ; + }else { + o->obj = bl->bo[i].fd; + o->obj_offset =0 ; + o->op =DRM_XE_VM_BIND_OP_MAP ; + } + o->range = bo_size; o->addr =BO_ADDR +2 * i * bo_size; o->flags =0 ;
@@ -250,7 +290,7 @@ static struct bind_list *create_bind_list(int fd, uint32_t bo_placement,struct drm_xe_vm_bind_op *o = &bl->bind_ops[i];igt_debug ("bo %d: addr 0x%llx, range 0x%llx\n" , i, o->addr, o->range); -bo_prime (fd, bl->bo[i], o->addr, o->range); +bo_prime (fd, o); }return bl;
@@ -277,16 +317,21 @@ static void do_bind_list(struct xe_eudebug_client *c,igt_assert (syncobj_wait (bl->fd, &sync->handle,1 ,INT64_MAX ,0 ,NULL )); } -static void check_bind_list (struct bind_list *bl) +static void free_bind_list (struct bind_list *bl) {unsigned int i;for (i =0 ; i < bl->n; i++) {igt_debug ("%d: checking 0x%llx (%lld)\n" , i, bl->bind_ops[i].addr, bl->bind_ops[i].addr); -bo_check (bl->fd, bl->bo[i], bl->bind_ops[i].addr, - bl->bind_ops[i].range); +bo_check (bl->fd, &bl->bind_ops[i]); +if (bl->bind_ops[i].op ==DRM_XE_VM_BIND_OP_MAP_USERPTR ) +free (bl->bo[i].userptr); } + +free (bl->bind_ops); +free (bl->bo); +free (bl); }static void vm_bind_client (int fd,struct xe_eudebug_client *c)
@@ -1321,6 +1366,7 @@ static void vm_access_client(struct xe_eudebug_client *c)struct drm_xe_sync sync = { .flags =DRM_XE_SYNC_TYPE_SYNCOBJ |DRM_XE_SYNC_FLAG_SIGNAL , };struct drm_xe_engine_class_instance *hwe = c->ptr; +uint32_t bo_placement;struct bind_list *bl;uint32_t vm;int fd, i;
@@ -1332,7 +1378,11 @@ static void vm_access_client(struct xe_eudebug_client *c) vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); - bl =create_bind_list (fd,vram_if_possible (fd, hwe->gt_id), vm,4 ); +if (c->flags &VM_BIND_OP_MAP_USERPTR ) + bo_placement =0 ; +else + bo_placement =vram_if_possible (fd, hwe->gt_id); + bl =create_bind_list (fd, bo_placement, vm,4 ); sync.handle =syncobj_create (bl->fd,0 );do_bind_list (c, bl, &sync);syncobj_destroy (bl->fd, sync.handle);
@@ -1340,7 +1390,7 @@ static void vm_access_client(struct xe_eudebug_client *c)for (i =0 ; i < bl->n; i++)xe_eudebug_client_wait_stage (c, bl->bind_ops[i].addr); -check_bind_list (bl); +free_bind_list (bl);xe_eudebug_client_vm_destroy (c, fd, vm);
@@ -1414,6 +1464,10 @@ static void vm_trigger(struct xe_eudebug_debugger *d,* SUBTEST: basic-vm-access * Description: * Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the vm fd +* +* SUBTEST: basic-vm-access-userptr +* Description: +* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the vm fd, but backed by userptr */ static void test_vm_access (int fd,unsigned int flags,int num_clients) {
@@ -1737,6 +1791,9 @@ igt_main igt_subtest("basic-vm-access")test_vm_access (fd,0 ,1 ); + igt_subtest("basic-vm-access-userptr") +test_vm_access (fd,VM_BIND_OP_MAP_USERPTR ,1 ); + igt_subtest("basic-vm-access-parameters")test_vm_access_parameters (fd,0 ,1 );
Signature · 1 line
2.34.1
PATCH v2 32/66 tests/xe_eudebug: Add basic-vm-bind-ufence
In reply to Christoph ManszewskiAdd a basic test to check if ufence will be blocked and released by debugger ack.
--- tests/intel/xe_eudebug.c | 214 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 214 insertions(+)
tests/intel/xe_eudebug.c +214 -0
@@ -1757,6 +1757,217 @@ static void test_metadata_attach(int fd, unsigned int flags, int num_clients) NULL, true, 0); } +#define STAGE_CLIENT_WAIT_ON_UFENCE_DONE 1337 + +#define UFENCE_EVENT_COUNT_EXPECTED 4 +#define UFENCE_EVENT_COUNT_MAX 100 + +struct ufence_bind { +struct drm_xe_sync f; +uint64_t addr; +uint64_t range; +uint64_t value; +struct { +uint64_t vm_sync; + } *fence_data; +}; + +static void basic_ufence_client (struct xe_eudebug_client *c) +{ +const int64_t default_fence_timeout_ns =MS_TO_NS (500 ); +const unsigned int n =UFENCE_EVENT_COUNT_EXPECTED ; +int fd =xe_eudebug_client_open_driver (c); +uint32_t vm =xe_eudebug_client_vm_create (c, fd,0 ,0 ); +size_t bo_size = n *xe_get_default_alignment (fd); +uint32_t bo =xe_bo_create (fd,0 , bo_size, +system_memory (fd),0 ); +struct ufence_bind *binds; +int64_t timeout_ns; +int err; + + binds =calloc (n,sizeof (*binds)); +igt_assert (binds); + +for (int i =0 ; i < n; i++) { +struct ufence_bind *b = &binds[i]; + + b->range =0x1000 ; + b->addr =0x100000 + b->range * i; + b->fence_data =aligned_alloc (xe_get_default_alignment (fd), +sizeof (*b->fence_data)); +igt_assert (b->fence_data); +memset (b->fence_data,0 ,sizeof (*b->fence_data)); + + b->f.type =DRM_XE_SYNC_TYPE_USER_FENCE ; + b->f.flags =DRM_XE_SYNC_FLAG_SIGNAL ; + b->f.addr =to_user_pointer (&b->fence_data->vm_sync); + b->f.timeline_value =UFENCE_EVENT_COUNT_EXPECTED + i; + } + +for (int i =0 ; i < n; i++) { +struct ufence_bind *b = &binds[i]; + +xe_eudebug_client_vm_bind_flags (c, fd, vm, bo,0 , b->addr, b->range,0 , + &b->f,1 ,0 ); + } + +/* Ensure that wait on unacked ufence times out */ +for (int i =0 ; i < n; i++) { +struct ufence_bind *b = &binds[i]; + + timeout_ns = default_fence_timeout_ns; + err =__xe_wait_ufence (fd, &b->fence_data->vm_sync, b->f.timeline_value, +0 , &timeout_ns); +igt_assert_eq (err, -ETIME ); +igt_assert_neq (b->fence_data->vm_sync, b->f.timeline_value); +igt_debug ("wait #%d blocked on ack\n" , i); + } + +/* Wait on fence timed out, now tell the debugger to ack */ +xe_eudebug_client_signal_stage (c,STAGE_CLIENT_WAIT_ON_UFENCE_DONE ); + +/* Check that ack unblocks ufence */ +for (int i =0 ; i < n; i++) { +struct ufence_bind *b = &binds[i]; + + timeout_ns =MS_TO_NS (XE_EUDEBUG_DEFAULT_TIMEOUT_MS ); + err =__xe_wait_ufence (fd, &b->fence_data->vm_sync, b->f.timeline_value, +0 , &timeout_ns); +igt_assert_eq (err,0 ); +igt_assert_eq (b->fence_data->vm_sync, b->f.timeline_value); +igt_debug ("wait #%d completed\n" , i); + } + +for (int i =0 ; i < n; i++) { +struct ufence_bind *b = &binds[i]; + +xe_eudebug_client_vm_unbind (c, fd, vm,0 , b->addr, b->range); + } + +free (binds); +gem_close (fd, bo); +xe_eudebug_client_vm_destroy (c, fd, vm); +xe_eudebug_client_close_driver (c, fd); +} + +struct ufence_priv { +struct drm_xe_eudebug_event_vm_bind_ufence ufence_events[UFENCE_EVENT_COUNT_MAX ]; +unsigned int ufence_event_count; +pthread_mutex_t mutex; +}; + +static struct ufence_priv *ufence_priv_create (void ) +{ +struct ufence_priv *priv; + + priv =mmap (0 ,ALIGN (sizeof (*priv),PAGE_SIZE ), +PROT_WRITE ,MAP_SHARED |MAP_ANON ,-1 ,0 ); +igt_assert (priv); +memset (priv,0 ,sizeof (*priv)); +pthread_mutex_init (&priv->mutex,NULL ); + +return priv; +} + +static void ufence_priv_destroy (struct ufence_priv *priv) +{ +munmap (priv,ALIGN (sizeof (*priv),PAGE_SIZE )); +} + +static void ack_fences (struct xe_eudebug_debugger *d) +{ +struct ufence_priv *priv = d->ptr; + +for (int i =0 ; i < priv->ufence_event_count; i++) +xe_eudebug_ack_ufence (d->fd, &priv->ufence_events[i]); +} + +static void basic_ufence_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; +struct ufence_priv *priv = d->ptr; + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +char event_str[XE_EUDEBUG_EVENT_STRING_MAX_LEN ]; +struct drm_xe_eudebug_event_vm_bind *eb; + +xe_eudebug_event_to_str (e, event_str,XE_EUDEBUG_EVENT_STRING_MAX_LEN ); +igt_debug ("ufence event received: %s\n" , event_str); + +xe_eudebug_assert_f (d, priv->ufence_event_count <UFENCE_EVENT_COUNT_EXPECTED , +"surplus ufence event received: %s\n" , event_str); +xe_eudebug_assert (d, ef->vm_bind_ref_seqno); + +memcpy (&priv->ufence_events[priv->ufence_event_count++], ef,sizeof (*ef)); + + eb = (struct drm_xe_eudebug_event_vm_bind *) +xe_eudebug_event_log_find_seqno (d->log, ef->vm_bind_ref_seqno); +xe_eudebug_assert_f (d, eb,"vm bind event with seqno (%lld) not found\n" , + ef->vm_bind_ref_seqno); + } +} + +static int wait_for_ufence_events (struct ufence_priv *priv,int timeout_ms) +{ +int ret = -ETIMEDOUT ; + +igt_for_milliseconds (timeout_ms) { +pthread_mutex_lock (&priv->mutex); +if (priv->ufence_event_count ==UFENCE_EVENT_COUNT_EXPECTED ) + ret =0 ; +pthread_mutex_unlock (&priv->mutex); + +if (!ret) +break ; +usleep (1000 ); + } + +return ret; +} + +/** +* SUBTEST: basic-vm-bind-ufence +* Description: +* Give user fence in application and check if ufence ack works +*/ +static void test_basic_ufence (int fd,unsigned int flags) +{ +struct xe_eudebug_debugger *d; +struct xe_eudebug_session *s; +struct xe_eudebug_client *c; +struct ufence_priv *priv; + + priv =ufence_priv_create (); + s =xe_eudebug_session_create (fd, basic_ufence_client, flags, priv); + c = s->c; + d = s->d; + +xe_eudebug_debugger_add_trigger (d, +DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE , + basic_ufence_trigger); + +igt_assert_eq (xe_eudebug_debugger_attach (d, c),0 ); +xe_eudebug_debugger_start_worker (d); +xe_eudebug_client_start (c); + +xe_eudebug_debugger_wait_stage (s,STAGE_CLIENT_WAIT_ON_UFENCE_DONE ); +xe_eudebug_assert_f (d,wait_for_ufence_events (priv,XE_EUDEBUG_DEFAULT_TIMEOUT_MS ) ==0 , +"missing ufence events\n" ); +ack_fences (d); + +xe_eudebug_client_wait_done (c); +xe_eudebug_debugger_stop_worker (d,1 ); + +xe_eudebug_event_log_print (d->log, true); +xe_eudebug_event_log_print (c->log, true); + +xe_eudebug_session_check (s, true,XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE ); + +xe_eudebug_session_destroy (s); +ufence_priv_destroy (priv); +} + igt_main {bool was_enabled;
@@ -1809,6 +2020,9 @@ igt_main igt_subtest("basic-vm-bind")test_basic_sessions (fd,VM_BIND ,1 , true); + igt_subtest("basic-vm-bind-ufence") +test_basic_ufence (fd,0 ); + igt_subtest("basic-vm-bind-discovery")test_basic_discovery (fd,VM_BIND , true);
Signature · 1 line
2.34.1
PATCH v2 33/66 tests/xe_eudebug: Add multigpu scenarios
In reply to Christoph ManszewskiFrom: Dominik Karol Piątkowski <[email protected]>
Add multigpu-basic-client and multigpu-basic-client-many tests, extending basic-client and multiple-session tests.
--- tests/intel/xe_eudebug.c | 62 +++++++++++++++++++++++++++++++++++++++- 1 file changed, 61 insertions(+), 1 deletion(-)
tests/intel/xe_eudebug.c +61 -1
@@ -875,6 +875,15 @@ static void test_read_event(int fd)* Attach the debugger to a process that performs bind, bind array, rebind, * partial unbind, unbind and unbind all operations. * +* SUBTEST: multigpu-basic-client +* Description: +* Attach the debugger to process which opens and closes xe drm client on all Xe devices. +* +* SUBTEST: multigpu-basic-client-many +* Description: +* Simultaneously attach many debuggers to many processes on all Xe devices. +* Each process opens and closes xe drm client and creates few resources. +* * arg[1]: * * @vms: vms
@@ -1971,7 +1980,8 @@ static void test_basic_ufence(int fd, unsigned int flags) igt_main {bool was_enabled; -int fd; +bool *multigpu_was_enabled; +int fd, gpu_count; igt_fixture { fd =drm_open_driver (DRIVER_XE );
@@ -2063,4 +2073,54 @@ igt_mainxe_eudebug_enable (fd, was_enabled);drm_close_driver (fd); } + + igt_subtest_group { + igt_fixture { + gpu_count =drm_prepare_filtered_multigpu (DRIVER_XE ); +igt_require (gpu_count >=2 ); + + multigpu_was_enabled =malloc (gpu_count *sizeof (bool )); +igt_assert (multigpu_was_enabled); +for (int i =0 ; i < gpu_count; i++) { + fd =drm_open_filtered_card (i); + multigpu_was_enabled[i] =xe_eudebug_enable (fd, true); +close (fd); + } + } + + igt_subtest("multigpu-basic-client") { + igt_multi_fork(child, gpu_count) { + fd =drm_open_filtered_card (child); +igt_assert_f (fd >0 ,"cannot open gpu-%d, errno=%d\n" , + child, errno); +igt_assert (is_xe_device (fd)); + +test_basic_sessions (fd,0 ,1 , true); +close (fd); + } +igt_waitchildren (); + } + + igt_subtest("multigpu-basic-client-many") { + igt_multi_fork(child, gpu_count) { + fd =drm_open_filtered_card (child); +igt_assert_f (fd >0 ,"cannot open gpu-%d, errno=%d\n" , + child, errno); +igt_assert (is_xe_device (fd)); + +test_basic_sessions (fd,0 ,4 , true); +close (fd); + } +igt_waitchildren (); + } + + igt_fixture { +for (int i =0 ; i < gpu_count; i++) { + fd =drm_open_filtered_card (i); +xe_eudebug_enable (fd, multigpu_was_enabled[i]); +close (fd); + } +free (multigpu_was_enabled); + } + } }
Signature · 1 line
2.34.1
PATCH v2 34/66 tests/xe_eudebug: Add vm-bind-clear test
In reply to Christoph ManszewskiPort i915_debugger sanity check that fresh buffers we vm_bind into the ppGTT are always clear.
--- tests/intel/xe_eudebug.c | 276 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 276 insertions(+)
tests/intel/xe_eudebug.c +276 -0
@@ -1977,6 +1977,279 @@ static void test_basic_ufence(int fd, unsigned int flags)ufence_priv_destroy (priv); } +struct vm_bind_clear_thread_priv { +struct drm_xe_engine_class_instance *hwe; +struct xe_eudebug_client *c; +pthread_t thread; +uint64_t region; +unsigned long sum; +}; + +struct vm_bind_clear_priv { +unsigned long unbind_count; +unsigned long bind_count; +unsigned long sum; +}; + +static struct vm_bind_clear_priv *vm_bind_clear_priv_create (void ) +{ +struct vm_bind_clear_priv *priv; + + priv =mmap (0 ,ALIGN (sizeof (*priv),PAGE_SIZE ), +PROT_WRITE ,MAP_SHARED |MAP_ANON ,-1 ,0 ); +igt_assert (priv); +memset (priv,0 ,sizeof (*priv)); + +return priv; +} + +static void vm_bind_clear_priv_destroy (struct vm_bind_clear_priv *priv) +{ +munmap (priv,ALIGN (sizeof (*priv),PAGE_SIZE )); +} + +static void *vm_bind_clear_thread (void *data) +{ +const uint32_t CS_GPR0 =0x600 ; +const size_t batch_size =16 ; +struct drm_xe_sync uf_sync = { + .type =DRM_XE_SYNC_TYPE_USER_FENCE , .flags =DRM_XE_SYNC_FLAG_SIGNAL , + }; +struct vm_bind_clear_thread_priv *priv = data; +int fd =xe_eudebug_client_open_driver (priv->c); +uint32_t gtt_size =1ull <<min_t (uint32_t,xe_va_bits (fd),48 ); +uint32_t vm =xe_eudebug_client_vm_create (priv->c, fd,0 ,0 ); +size_t bo_size =xe_bb_size (fd, batch_size); +unsigned long count =0 ; +uint64_t *fence_data; + +/* init uf_sync */ + fence_data =aligned_alloc (xe_get_default_alignment (fd),sizeof (*fence_data)); +igt_assert (fence_data); + uf_sync.timeline_value =1337 ; + uf_sync.addr =to_user_pointer (fence_data); + +igt_debug ("Run on: %s%u\n" ,xe_engine_class_string (priv->hwe->engine_class), + priv->hwe->engine_instance); + + igt_until_timeout(5) { +struct drm_xe_exec_queue_create eq_create = {0 }; +uint32_t clean_bo =0 ; +uint32_t batch_bo =0 ; +uint64_t clean_offset, batch_offset; +uint32_t exec_queue; +uint32_t *map, *cs; +uint64_t delta; + +/* calculate offsets (vma addresses) */ + batch_offset = (random () *SZ_2M ) & (gtt_size -1 ); +/* XXX: for some platforms/memory regions batch offset '0' can be problematic */ +if (batch_offset ==0 ) + batch_offset =SZ_2M ; + +do { + clean_offset = (random () *SZ_2M ) & (gtt_size -1 ); +if (clean_offset ==0 ) + clean_offset =SZ_2M ; + }while (clean_offset == batch_offset); + + batch_offset +=random () %SZ_2M & -bo_size; + clean_offset +=random () %SZ_2M & -bo_size; + + delta = (random () % bo_size) &-4 ; + +/* prepare clean bo */ + clean_bo =xe_bo_create (fd, vm, bo_size, priv->region, +DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM ); +memset (fence_data,0 ,sizeof (*fence_data)); +xe_eudebug_client_vm_bind_flags (priv->c, fd, vm, clean_bo,0 , clean_offset, bo_size, +0 , &uf_sync,1 ,0 ); +xe_wait_ufence (fd, fence_data, uf_sync.timeline_value,0 , +MS_TO_NS (XE_EUDEBUG_DEFAULT_TIMEOUT_MS )); + +/* prepare batch bo */ + batch_bo =xe_bo_create (fd, vm, bo_size, priv->region, +DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM ); +memset (fence_data,0 ,sizeof (*fence_data)); +xe_eudebug_client_vm_bind_flags (priv->c, fd, vm, batch_bo,0 , batch_offset, bo_size, +0 , &uf_sync,1 ,0 ); +xe_wait_ufence (fd, fence_data, uf_sync.timeline_value,0 , +MS_TO_NS (XE_EUDEBUG_DEFAULT_TIMEOUT_MS )); + + map =xe_bo_map (fd, batch_bo, bo_size); + + cs = map; + *cs++ =MI_NOOP |0xc5a3 ; + *cs++ =MI_LOAD_REGISTER_MEM_CMD |MI_LRI_LRM_CS_MMIO |2 ; + *cs++ =CS_GPR0 ; + *cs++ = clean_offset + delta; + *cs++ = (clean_offset + delta) >>32 ; + *cs++ =MI_STORE_REGISTER_MEM_CMD |MI_LRI_LRM_CS_MMIO |2 ; + *cs++ =CS_GPR0 ; + *cs++ = batch_offset; + *cs++ = batch_offset >>32 ; + *cs++ =MI_BATCH_BUFFER_END ; + +/* execute batch */ + eq_create.width =1 ; + eq_create.num_placements =1 ; + eq_create.vm_id = vm; + eq_create.instances =to_user_pointer (priv->hwe); + exec_queue =xe_eudebug_client_exec_queue_create (priv->c, fd, &eq_create); +xe_exec_wait (fd, exec_queue, batch_offset); + +igt_assert_eq (*map,0 ); + +/* cleanup */ +xe_eudebug_client_exec_queue_destroy (priv->c, fd, &eq_create); +munmap (map, bo_size); + +xe_eudebug_client_vm_unbind (priv->c, fd, vm,0 , batch_offset, bo_size); +gem_close (fd, batch_bo); + +xe_eudebug_client_vm_unbind (priv->c, fd, vm,0 , clean_offset, bo_size); +gem_close (fd, clean_bo); + + count++; + } + + priv->sum = count; + +free (fence_data); +xe_eudebug_client_close_driver (priv->c, fd); +return NULL ; +} + +static void vm_bind_clear_client (struct xe_eudebug_client *c) +{ +int fd =xe_eudebug_client_open_driver (c); +struct xe_device *xe_dev =xe_device_get (fd); +int count =xe_number_engines (fd) * xe_dev->mem_regions->num_mem_regions; +uint64_t memreg =all_memory_regions (fd); +struct vm_bind_clear_priv *priv = c->ptr; +int current =0 ; +struct drm_xe_engine_class_instance *engine; +struct vm_bind_clear_thread_priv *threads; +uint64_t region; + + threads =calloc (count,sizeof (*threads)); +igt_assert (threads); + priv->sum =0 ; + +xe_for_each_mem_region (fd, memreg, region) { +xe_for_each_engine (fd, engine) { + threads[current].c = c; + threads[current].hwe = engine; + threads[current].region = region; + +pthread_create (&threads[current].thread,NULL , + vm_bind_clear_thread, &threads[current]); + current++; + } + } + +for (current =0 ; current < count; current++) +pthread_join (threads[current].thread,NULL ); + +xe_for_each_mem_region (fd, memreg, region) { +unsigned long sum =0 ; + +for (current =0 ; current < count; current++) +if (threads[current].region == region) + sum += threads[current].sum; + +igt_info ("%s sampled %lu objects\n" ,xe_region_name (region), sum); + priv->sum += sum; + } + +free (threads); +xe_device_put (fd); +xe_eudebug_client_close_driver (c, fd); +} + +static void vm_bind_clear_test_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_vm_bind_op *eo = (void *)e; +struct vm_bind_clear_priv *priv = d->ptr; + +if (e->flags &DRM_XE_EUDEBUG_EVENT_CREATE ) { +if (random () &1 ) { +struct drm_xe_eudebug_vm_open vo = {0 , }; +uint32_t v =0xc1c1c1c1 ; + +struct drm_xe_eudebug_event_vm_bind *eb; +int fd, delta, r; + +igt_debug ("vm bind op event received with ref %lld, addr 0x%llx, range 0x%llx\n" , + eo->vm_bind_ref_seqno, + eo->addr, + eo->range); + + eb = (struct drm_xe_eudebug_event_vm_bind *) +xe_eudebug_event_log_find_seqno (d->log, eo->vm_bind_ref_seqno); +igt_assert (eb); + + vo.client_handle = eb->client_handle; + vo.vm_handle = eb->vm_handle; + + fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo); +igt_assert_lte (0 , fd); + + delta = (random () % eo->range) &-4 ; + r =pread (fd, &v,sizeof (v), eo->addr + delta); +igt_assert_eq (r,sizeof (v)); +igt_assert_eq_u32 (v,0 ); + +close (fd); + } + priv->bind_count++; + } + +if (e->flags &DRM_XE_EUDEBUG_EVENT_DESTROY ) + priv->unbind_count++; +} + +static void vm_bind_clear_ack_trigger (struct xe_eudebug_debugger *d, +struct drm_xe_eudebug_event *e) +{ +struct drm_xe_eudebug_event_vm_bind_ufence *ef = (void *)e; + +xe_eudebug_ack_ufence (d->fd, ef); +} + +/** +* SUBTEST: vm-bind-clear +* Description: +* Check that fresh buffers we vm_bind into the ppGTT are always clear. +*/ +static void test_vm_bind_clear (int fd) +{ +struct vm_bind_clear_priv *priv; +struct xe_eudebug_session *s; + + priv =vm_bind_clear_priv_create (); + s =xe_eudebug_session_create (fd, vm_bind_clear_client,0 , priv); + +xe_eudebug_debugger_add_trigger (s->d,DRM_XE_EUDEBUG_EVENT_VM_BIND_OP , + vm_bind_clear_test_trigger); +xe_eudebug_debugger_add_trigger (s->d,DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE , + vm_bind_clear_ack_trigger); + +igt_assert_eq (xe_eudebug_debugger_attach (s->d, s->c),0 ); +xe_eudebug_debugger_start_worker (s->d); +xe_eudebug_client_start (s->c); + +xe_eudebug_client_wait_done (s->c); +xe_eudebug_debugger_stop_worker (s->d,1 ); + +igt_assert_eq (priv->bind_count, priv->unbind_count); +igt_assert_eq (priv->sum *2 , priv->bind_count); + +xe_eudebug_session_destroy (s); +vm_bind_clear_priv_destroy (priv); +} + igt_main {bool was_enabled;
@@ -2033,6 +2306,9 @@ igt_main igt_subtest("basic-vm-bind-ufence")test_basic_ufence (fd,0 ); + igt_subtest("vm-bind-clear") +test_vm_bind_clear (fd); + igt_subtest("basic-vm-bind-discovery")test_basic_discovery (fd,VM_BIND , true);
Signature · 1 line
2.34.1
PATCH v2 35/66 tests/xe_eudebug: Exercise lseek
In reply to Christoph ManszewskiFrom: Jonathan Cavitt <[email protected]>
Add an additional check in debugger_test_vma that simultaneously exercises lseek support and also that pwrite successfully wrote the new buffer contents to the vma via pwrite.
--- tests/intel/xe_eudebug.c | 26 ++++++++++++++++++-------- 1 file changed, 18 insertions(+), 8 deletions(-)
tests/intel/xe_eudebug.c +18 -8
@@ -1414,13 +1414,15 @@ static void debugger_test_vma(struct xe_eudebug_debugger *d, uint64_t va_length) {struct drm_xe_eudebug_vm_open vo = {0 , }; -uint64_t *v; +uint64_t *v1, *v2;uint64_t items = va_length /sizeof (uint64_t );int fd;int r, i; - v =malloc (va_length); -igt_assert (v); + v1 =malloc (va_length); +igt_assert (v1); + v2 =malloc (va_length); +igt_assert (v2); vo.client_handle = client_handle; vo.vm_handle = vm_handle;
@@ -1428,22 +1430,30 @@ static void debugger_test_vma(struct xe_eudebug_debugger *d, fd =igt_ioctl (d->fd,DRM_XE_EUDEBUG_IOCTL_VM_OPEN , &vo);igt_assert_lte (0 , fd); - r =pread (fd, v, va_length, va_start); + r =pread (fd, v1, va_length, va_start);igt_assert_eq (r, va_length);for (i =0 ; i < items; i++) -igt_assert_eq (v[i], va_start + i); +igt_assert_eq (v1[i], va_start + i);for (i =0 ; i < items; i++) - v[i] = va_start + i +1 ; + v1[i] = va_start + i +1 ; - r =pwrite (fd, v, va_length, va_start); + r =pwrite (fd, v1, va_length, va_start); +igt_assert_eq (r, va_length); + +lseek (fd, va_start,SEEK_SET ); + r =read (fd, v2, va_length);igt_assert_eq (r, va_length); +for (i =0 ; i < items; i++) +igt_assert_eq (v1[i], v2[i]); +fsync (fd);close (fd); -free (v); +free (v1); +free (v2); } static void vm_trigger(struct xe_eudebug_debugger *d,
Signature · 1 line
2.34.1
PATCH v2 36/66 tests/xe_eudebug: Test multiple bo sizes
In reply to Christoph ManszewskiFrom: Jonathan Cavitt <[email protected]>
Extend the basic vm access tests to allow for specifying the target bo size per bo in the bind list. The size still has to be at least the minimum, but can be overwritten to be larger.
Make sure that the vm is unbound during bind list destroy, to avoid overlapping vmas.
--- tests/intel/xe_eudebug.c | 45 ++++++++++++++++++++++++++-------------- 1 file changed, 29 insertions(+), 16 deletions(-)
tests/intel/xe_eudebug.c +29 -16
@@ -249,12 +249,13 @@ static union buf_id *vm_create_objects(int fd, uint32_t bo_placement, uint32_t v }static struct bind_list *create_bind_list (int fd,uint32_t bo_placement, -uint32_t vm,unsigned int n) +uint32_t vm,unsigned int n, +unsigned int target_size) { -const unsigned int bo_size =max_t (bo_size,xe_get_default_alignment (fd),MIN_BO_SIZE ); +unsigned int i = target_size ?:MIN_BO_SIZE ; +const unsigned int bo_size =max_t (bo_size,xe_get_default_alignment (fd), i);bool is_userptr = !bo_placement;struct bind_list *bl; -unsigned int i; bl =malloc (sizeof (*bl)); bl->fd = fd;
@@ -317,7 +318,7 @@ static void do_bind_list(struct xe_eudebug_client *c,igt_assert (syncobj_wait (bl->fd, &sync->handle,1 ,INT64_MAX ,0 ,NULL )); } -static void free_bind_list (struct bind_list *bl) +static void free_bind_list (struct xe_eudebug_client *c,struct bind_list *bl) {unsigned int i;
@@ -327,6 +328,9 @@ static void free_bind_list(struct bind_list *bl)bo_check (bl->fd, &bl->bind_ops[i]);if (bl->bind_ops[i].op ==DRM_XE_VM_BIND_OP_MAP_USERPTR )free (bl->bo[i].userptr); +xe_eudebug_client_vm_unbind (c, bl->fd, bl->vm,0 , + bl->bind_ops[i].addr, + bl->bind_ops[i].range); }free (bl->bind_ops);
@@ -359,7 +363,7 @@ static void vm_bind_client(int fd, struct xe_eudebug_client *c)xe_vm_bind_async (fd, vm,0 , bo[1 ], rebind_bo_offset, addr[1 ], size,NULL ,0 ); - bl =create_bind_list (fd,system_memory (fd), vm,4 ); + bl =create_bind_list (fd,system_memory (fd), vm,4 ,0 );xe_vm_bind_array (bl->fd, bl->vm,0 , bl->bind_ops, bl->n,NULL ,0 );xe_vm_unbind_all_async (fd, vm,0 , bo[0 ],NULL ,0 );
@@ -387,7 +391,7 @@ static void vm_bind_client(int fd, struct xe_eudebug_client *c)xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ],0 , addr[1 ], bo_size);xe_eudebug_client_vm_bind (c, fd, vm, bo[1 ], rebind_bo_offset, addr[1 ], size); - bl =create_bind_list (fd,system_memory (fd), vm,4 ); + bl =create_bind_list (fd,system_memory (fd), vm,4 ,0 );do_bind_list (c, bl,NULL ); }
@@ -1378,7 +1382,7 @@ static void vm_access_client(struct xe_eudebug_client *c)uint32_t bo_placement;struct bind_list *bl;uint32_t vm; -int fd, i; +int fd, i, j;igt_debug ("Using %s\n" ,xe_engine_class_string (hwe->engine_class));
@@ -1391,16 +1395,20 @@ static void vm_access_client(struct xe_eudebug_client *c) bo_placement =0 ; else bo_placement =vram_if_possible (fd, hwe->gt_id); - bl =create_bind_list (fd, bo_placement, vm,4 ); - sync.handle =syncobj_create (bl->fd,0 ); -do_bind_list (c, bl, &sync); -syncobj_destroy (bl->fd, sync.handle); -for (i =0 ; i < bl->n; i++) -xe_eudebug_client_wait_stage (c, bl->bind_ops[i].addr); +for (j =0 ; j <5 ; j++) { +unsigned int target_size =MIN_BO_SIZE * (1 << j); -free_bind_list (bl); + bl =create_bind_list (fd, bo_placement, vm,4 , target_size); + sync.handle =syncobj_create (bl->fd,0 ); +do_bind_list (c, bl, &sync); +syncobj_destroy (bl->fd, sync.handle); +for (i =0 ; i < bl->n; i++) +xe_eudebug_client_wait_stage (c, bl->bind_ops[i].addr); + +free_bind_list (c, bl); + }xe_eudebug_client_vm_destroy (c, fd, vm);xe_device_put (fd);
@@ -1482,11 +1490,16 @@ static void vm_trigger(struct xe_eudebug_debugger *d,/** * SUBTEST: basic-vm-access * Description: -* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the vm fd +* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the +* vm fd, concerning many different offsets inside the vm, +* and many virtual addresses of the vm_bound object. * * SUBTEST: basic-vm-access-userptr * Description: -* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the vm fd, but backed by userptr +* Exercise XE_EUDEBG_VM_OPEN with pread and pwrite into the +* vm fd, concerning many different offsets inside the vm, +* and many virtual addresses of the vm_bound object, but backed +* by userptr. */ static void test_vm_access (int fd,unsigned int flags,int num_clients) {
Signature · 1 line
2.34.1
PATCH v2 37/66 lib/gpgpu_shader: Extend shader building library
In reply to Christoph ManszewskiAdd shader building functions and iga64 code used by eudebug subtests.
--- lib/gpgpu_shader.c | 386 +++++++++++++++++++++++++++++++++++- lib/gpgpu_shader.h | 24 ++- lib/iga64_generated_codes.c | 321 +++++++++++++++++++++++++++++- 3 files changed, 727 insertions(+), 4 deletions(-)
lib/gpgpu_shader.c +385 -1
@@ -7,10 +7,16 @@#include <i915_drm.h> +#include "igt_map.h" #include "ioctl_wrappers.h" #include "gpgpu_shader.h" #include "gpu_cmds.h" +struct label_entry { +uint32_t id; +uint32_t offset; +}; +#define IGA64_ARG0 0xc0ded000#define IGA64_ARG_MASK 0xffffff00
@@ -32,7 +38,7 @@ static void gpgpu_shader_extend(struct gpgpu_shader *shdr)igt_assert (shdr->code); } -void +uint32_t __emit_iga64_code (struct gpgpu_shader *shdr,struct iga64_template const *tpls,int argc,uint32_t *argv) {
@@ -60,6 +66,8 @@ __emit_iga64_code(struct gpgpu_shader *shdr, struct iga64_template const *tpls, } shdr->size += tpls->size; + +return tpls->size; } static uint32_t fill_sip(struct intel_bb *ibb,
@@ -235,6 +243,7 @@ struct gpgpu_shader *gpgpu_shader_create(int fd) shdr->gen_ver =100 * info->graphics_ver + info->graphics_rel; shdr->max_size =16 *4 ; shdr->code =malloc (4 * shdr->max_size); + shdr->labels =igt_map_create (igt_map_hash_32, igt_map_equal_32);igt_assert (shdr->code);return shdr; }
@@ -251,6 +260,70 @@ void gpgpu_shader_destroy(struct gpgpu_shader *shdr)free (shdr); } +/** +* gpgpu_shader_dump: +* @shdr: shader to be printed +* +* Print shader instructions from @shdr in hex. +*/ +void gpgpu_shader_dump (struct gpgpu_shader *shdr) +{ +for (int i =0 ; i < shdr->size /4 ; i++) +igt_info ("0x%08x 0x%08x 0x%08x 0x%08x\n" , + shdr->instr[i][0 ], shdr->instr[i][1 ], + shdr->instr[i][2 ], shdr->instr[i][3 ]); +} + +/** +* gpgpu_shader__breakpoint_on: +* @shdr: shader to create breakpoint in +* @cmd_no: index of the instruction to break on +* +* Insert a breakpoint on the @cmd_no'th instruction within @shdr. +*/ +void gpgpu_shader__breakpoint_on (struct gpgpu_shader *shdr,uint32_t cmd_no) +{ + shdr->instr[cmd_no][0 ] |=1 <<30 ; +} + +/** +* gpgpu_shader__breakpoint: +* @shdr: shader to create breakpoint in +* +* Insert a breakpoint on the last instruction in @shdr. +*/ +void gpgpu_shader__breakpoint (struct gpgpu_shader *shdr) +{ +gpgpu_shader__breakpoint_on (shdr, shdr->size /4 -1 ); +} + +/** +* gpgpu_shader__wait: +* @shdr: shader to be modified +* +* Append wait instruction to @shader. This instruction raises attention +* and stops execution. +*/ +void gpgpu_shader__wait (struct gpgpu_shader *shdr) +{ +emit_iga64_code (shdr, sync_host," \n\ +(W) sync.host null \n\ +" ); +} + +/** +* gpgpu_shader__nop: +* @shdr: shader to be modified +* +* Append a no-op instruction to @shdr. +*/ +void gpgpu_shader__nop (struct gpgpu_shader *shdr) +{ +emit_iga64_code (shdr, nop," \n\ +(W) nop \n\ +" ); +} +/** * gpgpu_shader__eot: * @shdr: shader to be modified
@@ -269,6 +342,247 @@ void gpgpu_shader__eot(struct gpgpu_shader *shdr) "); } +/** +* gpgpu_shader__label: +* @shdr: shader to be modified +* @label_id: id of the label to be created +* +* Create a label for the last instruction within @shdr. +*/ +void gpgpu_shader__label (struct gpgpu_shader *shdr,int label_id) +{ +struct label_entry *l =malloc (sizeof (*l)); + + l->id = label_id; + l->offset = shdr->size; +igt_map_insert (shdr->labels, &l->id, l); +} + +#define OPCODE (x) (x & 0x7f) +#define OPCODE_JUMP_INDEXED 0x20 +static void __patch_indexed_jump (struct gpgpu_shader *shdr,int label_id, +uint32_t jump_iga64_size) +{ +struct label_entry *l; +uint32_t *start, *end, *label; +int32_t relative; + + l =igt_map_search (shdr->labels, &label_id); +igt_assert (l); + +igt_assert (jump_iga64_size %4 ==0 ); + + label = shdr->code + l->offset; + end = shdr->code + shdr->size; + start = end - jump_iga64_size; + +for (; start < end; start +=4 ) +if (OPCODE (*start) ==OPCODE_JUMP_INDEXED ) { + relative = (label - start) *4 ; + *(start +3 ) = relative; +break ; + } +} + +/** +* gpgpu_shader__jump: +* @shdr: shader to be modified +* @label_id: label to jump to +* +* Append jump instruction to @shdr. Jump to instruction with label @label_id. +*/ +void gpgpu_shader__jump (struct gpgpu_shader *shdr,int label_id) +{ +size_t shader_size; + + shader_size =emit_iga64_code (shdr, jump," \n\ +L0: \n\ +(W) jmpi L0 \n\ +" ); + +__patch_indexed_jump (shdr, label_id, shader_size); +} + +/** +* gpgpu_shader__jump_neq: +* @shdr: shader to be modified +* @label_id: label to jump to +* @y_offset: offset within target buffer in rows +* @value: expected value +* +* Append jump instruction to @shdr. Jump to instruction with label @label_id +* when @value is not equal to dword stored at @dw_offset within the surface. +* +* Note: @dw_offset has to be aligned to 4 +*/ +void gpgpu_shader__jump_neq (struct gpgpu_shader *shdr,int label_id, +uint32_t y_offset,uint32_t value) +{ +uint32_t size; + + size =emit_iga64_code (shdr, jump_dw_neq," \n\ +L0: \n\ +(W) mov (16|M0) r30.0<1>:ud 0x0:ud \n\ +#if GEN_VER < 2000 // Media Block Write \n\ +// Y offset of the block in rows := thread group id Y \n\ +(W) mov (1|M0) r30.1<1>:ud ARG(0):ud \n\ +// block width [0,63] representing 1 to 64 bytes, we want dword \n\ +(W) mov (1|M0) r30.2<1>:ud 0x3:ud \n\ +// FFTID := FFTID from R0 header \n\ +(W) mov (1|M0) r30.4<1>:ud r0.5<0;1,0>:ud \n\ +(W) send.dc1 (16|M0) r31 r30 null 0x0 0x2190000 \n\ +#else // Typed 2D Block Store \n\ +// Store X and Y block start (160:191 and 192:223) \n\ +(W) mov (2|M0) r30.6<1>:ud ARG(0):ud \n\ +// Store X and Y block size (224:231 and 232:239) \n\ +(W) mov (1|M0) r30.7<1>:ud 0x3:ud \n\ +(W) send.tgm (16|M0) r31 r30 null:0 0x0 0x62100003 \n\ +#endif \n\ +// clear the flag register \n\ +(W) mov (1|M0) f0.0<1>:ud 0x0:ud \n\ +(W) cmp (1|M0) (ne)f0.0 null<1>:ud r31.0<0;1,0>:ud ARG(1):ud \n\ +(W&f0.0) jmpi L0 \n\ +" , y_offset, value); + +__patch_indexed_jump (shdr, label_id, size); +} + +/** +* gpgpu_shader__loop_begin: +* @shdr: shader to be modified +* @label_id: id of the label to be created +* +* Begin a counting loop in @shdr. All subsequent instructions will constitute +* the loop body up until 'gpgpu_shader__loop_end' gets called. The first +* instruction of the loop will be at label @label_id. +*/ +void gpgpu_shader__loop_begin (struct gpgpu_shader *shdr,int label_id) +{ +emit_iga64_code (shdr, clear_r40," \n\ +L0: \n\ +(W) mov (1|M0) r40:ud 0x0:ud \n\ +" ); + +gpgpu_shader__label (shdr, label_id); +} + +/** +* gpgpu_shader__loop_end: +* @shdr: shader to be modified +* @label_id: label id passed to 'gpgpu_shader__loop_begin' +* @iter: iteration count +* +* End loop body in @shdr. +*/ +void gpgpu_shader__loop_end (struct gpgpu_shader *shdr,int label_id,uint32_t iter) +{ +uint32_t size; + + size =emit_iga64_code (shdr, inc_r40_jump_neq," \n\ +L0: \n\ +(W) add (1|M0) r40:ud r40.0<0;1,0>:ud 0x1:ud \n\ +(W) mov (1|M0) f0.0<1>:ud 0x0:ud \n\ +(W) cmp (1|M0) (ne)f0.0 null<1>:ud r40.0<0;1,0>:ud ARG(0):ud \n\ +(W&f0.0) jmpi L0 \n\ +" , iter); + +__patch_indexed_jump (shdr, label_id, size); +} + +/** +* gpgpu_shader__common_target_write: +* @shdr: shader to be modified +* @y_offset: write target offset within target buffer in rows +* @value: oword to be written +* +* Write the oword stored in @value to the target buffer at @y_offset. +*/ +void gpgpu_shader__common_target_write (struct gpgpu_shader *shdr, +uint32_t y_offset,const uint32_t value[4 ]) +{ +emit_iga64_code (shdr, common_target_write," \n\ +(W) mov (16|M0) r31.0<1>:ud 0x0:ud \n\ +(W) mov (1|M0) r31.0<1>:ud ARG(1):ud \n\ +(W) mov (1|M0) r31.1<1>:ud ARG(2):ud \n\ +(W) mov (1|M0) r31.2<1>:ud ARG(3):ud \n\ +(W) mov (1|M0) r31.3<1>:ud ARG(4):ud \n\ +(W) mov (16|M0) r30.0<1>:ud 0x0:ud \n\ +#if GEN_VER < 2000 // Media Block Write \n\ +// Y offset of the block in rows \n\ +(W) mov (1|M0) r30.1<1>:ud ARG(0):ud \n\ +// block width [0,63] representing 1 to 64 bytes \n\ +(W) mov (1|M0) r30.2<1>:ud 0xf:ud \n\ +// FFTID := FFTID from R0 header \n\ +(W) mov (1|M0) r30.4<1>:ud r0.5<0;1,0>:ud \n\ +// written value \n\ +(W) send.dc1 (16|M0) null r30 src1_null 0x0 0x40A8000 \n\ +#else // Typed 2D Block Store \n\ +// Store X and Y block start (160:191 and 192:223) \n\ +(W) mov (2|M0) r30.6<1>:ud ARG(0):ud \n\ +// Store X and Y block size (224:231 and 232:239) \n\ +(W) mov (1|M0) r30.7<1>:ud 0xf:ud \n\ +(W) send.tgm (16|M0) null r30 null:0 0x0 0x64000007 \n\ +#endif \n\ +" , y_offset, value[0 ], value[1 ], value[2 ], value[3 ]); +} + +/** +* gpgpu_shader__common_target_write_u32: +* @shdr: shader to be modified +* @y_offset: write target offset within target buffer in rows +* @value: dword to be written +* +* Fill oword at @y_offset with dword stored in @value. +*/ +void gpgpu_shader__common_target_write_u32 (struct gpgpu_shader *shdr, +uint32_t y_offset,uint32_t value) +{ +const uint32_t owblock[4 ] = { + value, value, value, value + }; +gpgpu_shader__common_target_write (shdr, y_offset, owblock); +} + +/** +* gpgpu_shader__write_aip: +* @shdr: shader to be modified +* @y_offset: write target offset within the surface in rows +* +* Write address instruction pointer to row tg_id_y + @y_offset. +*/ +void gpgpu_shader__write_aip (struct gpgpu_shader *shdr,uint32_t y_offset) +{ +emit_iga64_code (shdr, media_block_write_aip," \n\ +// Payload \n\ +(W) mov (1|M0) r5.0<1>:ud cr0.2:ud \n\ +#if GEN_VER < 2000 // Media Block Write \n\ +// X offset of the block in bytes := (thread group id X << ARG(0)) \n\ +(W) shl (1|M0) r4.0<1>:ud r0.1<0;1,0>:ud 0x2:ud \n\ +// Y offset of the block in rows := thread group id Y \n\ +(W) mov (1|M0) r4.1<1>:ud r0.6<0;1,0>:ud \n\ +(W) add (1|M0) r4.1<1>:ud r4.1<0;1,0>:ud ARG(0):ud \n\ +// block width [0,63] representing 1 to 64 bytes \n\ +(W) mov (1|M0) r4.2<1>:ud 0x3:ud \n\ +// FFTID := FFTID from R0 header \n\ +(W) mov (1|M0) r4.4<1>:ud r0.5<0;1,0>:ud \n\ +(W) send.dc1 (16|M0) null r4 src1_null 0 0x40A8000 \n\ +#else // Typed 2D Block Store \n\ +// Load r2.0-3 with tg id X << ARG(0) \n\ +(W) shl (1|M0) r2.0<1>:ud r0.1<0;1,0>:ud 0x2:ud \n\ +// Load r2.4-7 with tg id Y + ARG(1):ud \n\ +(W) mov (1|M0) r2.1<1>:ud r0.6<0;1,0>:ud \n\ +(W) add (1|M0) r2.1<1>:ud r2.1<0;1,0>:ud ARG(0):ud \n\ +// payload setup \n\ +(W) mov (16|M0) r4.0<1>:ud 0x0:ud \n\ +// Store X and Y block start (160:191 and 192:223) \n\ +(W) mov (2|M0) r4.5<1>:ud r2.0<2;2,1>:ud \n\ +// Store X and Y block max_size (224:231 and 232:239) \n\ +(W) mov (1|M0) r4.7<1>:ud 0x3:ud \n\ +(W) send.tgm (16|M0) null r4 null:0 0 0x64000007 \n\ +#endif \n\ +" , y_offset); +} +/** * gpgpu_shader__write_dword: * @shdr: shader to be modified
@@ -313,3 +627,73 @@ void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value, #endif \n\ ", 2, y_offset, 3, value, value, value, value); } + +/** +* gpgpu_shader__end_system_routine: +* @shdr: shader to be modified +* @breakpoint_suppress: breakpoint suppress flag +* +* Return from system routine. To prevent infinite jumping to the system +* routine on a breakpoint, @breakpoint_suppres flag has to be set. +*/ +void gpgpu_shader__end_system_routine (struct gpgpu_shader *shdr, +bool breakpoint_suppress) +{ +/* +* set breakpoint suppress bit to avoid an endless loop +* when sip was invoked by a breakpoint +*/ +if (breakpoint_suppress) +emit_iga64_code (shdr, breakpoint_suppress," \n\ +(W) or (1|M0) cr0.0<1>:ud cr0.0<0;1,0>:ud 0x8000:ud \n\ +" ); + +emit_iga64_code (shdr, end_system_routine," \n\ +(W) and (1|M0) cr0.1<1>:ud cr0.1<0;1,0>:ud ARG(0):ud \n\ +// return to an application \n\ +(W) and (1|M0) cr0.0<1>:ud cr0.0<0;1,0>:ud 0x7FFFFFFD:ud \n\ +" ,0x7fffff | (1 <<26 ));/* clear all exceptions, except read only bit */ +} + +/** +* gpgpu_shader__end_system_routine_step_if_eq: +* @shdr: shader to be modified +* @y_offset: offset within target buffer in rows +* @value: expected value for single stepping execution +* +* Return from system routine. Don't clear breakpoint exception when @value +* is equal to value stored at @dw_offset. This triggers the system routine +* after the subsequent instruction, resulting in single stepping execution. +*/ +void gpgpu_shader__end_system_routine_step_if_eq (struct gpgpu_shader *shdr, +uint32_t y_offset, +uint32_t value) +{ +emit_iga64_code (shdr, end_system_routine_step_if_eq," \n\ +(W) or (1|M0) cr0.0<1>:ud cr0.0<0;1,0>:ud 0x8000:ud \n\ +(W) and (1|M0) cr0.1<1>:ud cr0.1<0;1,0>:ud ARG(0):ud \n\ +(W) mov (16|M0) r30.0<1>:ud 0x0:ud \n\ +#if GEN_VER < 2000 // Media Block Write \n\ +// Y offset of the block in rows := thread group id Y \n\ +(W) mov (1|M0) r30.1<1>:ud ARG(1):ud \n\ +// block width [0,63] representing 1 to 64 bytes, we want dword \n\ +(W) mov (1|M0) r30.2<1>:ud 0x3:ud \n\ +// FFTID := FFTID from R0 header \n\ +(W) mov (1|M0) r30.4<1>:ud r0.5<0;1,0>:ud \n\ +(W) send.dc1 (16|M0) r31 r30 null 0x0 0x2190000 \n\ +#else // Typed 2D Block Store \n\ +// Store X and Y block start (160:191 and 192:223) \n\ +(W) mov (2|M0) r30.6<1>:ud ARG(1):ud \n\ +// Store X and Y block size (224:231 and 232:239) \n\ +(W) mov (1|M0) r30.7<1>:ud 0x3:ud \n\ +(W) send.tgm (16|M0) r31 r30 null:0 0x0 0x62100003 \n\ +#endif \n\ +// clear the flag register \n\ +(W) mov (1|M0) f0.0<1>:ud 0x0:ud \n\ +(W) cmp (1|M0) (ne)f0.0 null<1>:ud r31.0<0;1,0>:ud ARG(2):ud \n\ +(W&f0.0) and (1|M0) cr0.1<1>:ud cr0.1<0;1,0>:ud ARG(3):ud \n\ +// return to an application \n\ +(W) and (1|M0) cr0.0<1>:ud cr0.0<0;1,0>:ud 0x7FFFFFFD:ud \n\ +" ,0x807fffff ,/* leave breakpoint exception */ + y_offset, value,0x7fffff /* clear all exceptions */ ); +}
lib/gpgpu_shader.h +22 -2
@@ -21,6 +21,7 @@ struct gpgpu_shader {uint32_t *code;uint32_t (*instr)[4 ]; }; +struct igt_map *labels; };struct iga64_template {
@@ -31,7 +32,7 @@ struct iga64_template {#pragma GCC diagnostic ignored "-Wnested-externs" -void +uint32_t __emit_iga64_code (struct gpgpu_shader *shdr,const struct iga64_template *tpls,int argc,uint32_t *argv);
@@ -56,8 +57,27 @@ void gpgpu_shader_exec(struct intel_bb *ibb,struct gpgpu_shader *sip, uint64_t ring, bool explicit_engine); +void gpgpu_shader__wait (struct gpgpu_shader *shdr); +void gpgpu_shader__breakpoint_on (struct gpgpu_shader *shdr,uint32_t cmd_no); +void gpgpu_shader__breakpoint (struct gpgpu_shader *shdr); +void gpgpu_shader__nop (struct gpgpu_shader *shdr);void gpgpu_shader__eot (struct gpgpu_shader *shdr); +void gpgpu_shader__common_target_write (struct gpgpu_shader *shdr, +uint32_t y_offset,const uint32_t value[4 ]); +void gpgpu_shader__common_target_write_u32 (struct gpgpu_shader *shdr, +uint32_t y_offset,uint32_t value); +void gpgpu_shader__end_system_routine (struct gpgpu_shader *shdr, +bool breakpoint_suppress); +void gpgpu_shader__end_system_routine_step_if_eq (struct gpgpu_shader *shdr, +uint32_t dw_offset, +uint32_t value); +void gpgpu_shader__write_aip (struct gpgpu_shader *shdr,uint32_t y_offset);void gpgpu_shader__write_dword (struct gpgpu_shader *shdr,uint32_t value,uint32_t y_offset); - +void gpgpu_shader__label (struct gpgpu_shader *shdr,int label_id); +void gpgpu_shader__jump (struct gpgpu_shader *shdr,int label_id); +void gpgpu_shader__jump_neq (struct gpgpu_shader *shdr,int label_id, +uint32_t dw_offset,uint32_t value); +void gpgpu_shader__loop_begin (struct gpgpu_shader *shdr,int label_id); +void gpgpu_shader__loop_end (struct gpgpu_shader *shdr,int label_id,uint32_t iter);#endif /* GPGPU_SHADER_H */
lib/iga64_generated_codes.c +320 -1
336 lines not on this page · raw message
Signature · 1 line
2.34.1
PATCH v2 38/66 tests/xe_exec_sip: Port tests for shaders and sip
In reply to Christoph ManszewskiSIP is a System Instruction Pointer, which the hardware will except/jump into when some defined event occurs, debug mode is enabled and pipeline setup has included sip program.
Events like illegal instruction or breakpoint hit will jump into SIP directly. Driver can also except into sip during hang resolution and SIP can do, for example, eu thread state snapshot before the hang resolution ends up in a hardware state reset.
--- tests/intel/xe_exec_sip.c | 129 ++++++++++++++++++++++++++++++++++---- 1 file changed, 116 insertions(+), 13 deletions(-)
tests/intel/xe_exec_sip.c +116 -13
@@ -21,6 +21,7 @@#include "gpgpu_shader.h" #include "igt.h" #include "igt_sysfs.h" +#include "xe/xe_eudebug.h" #include "xe/xe_ioctl.h" #include "xe/xe_query.h"
@@ -30,9 +31,16 @@#define COLOR_C4 0xc4#define SHADER_CANARY 0x01010101 +#define SIP_CANARY 0x02020202#define NSEC_PER_MSEC (1000 * 1000ull) +#define SHADER_BREAKPOINT 0 +#define SHADER_WRITE 1 +#define SHADER_WAIT 2 +#define SIP_WRITE 3 +#define SIP_NULL 4 +static struct intel_buf *create_fill_buf (int fd,int width,int height,uint8_t color) {
@@ -52,27 +60,78 @@ create_fill_buf(int fd, int width, int height, uint8_t color)return buf; } -static struct gpgpu_shader *get_shader (int fd) +static struct gpgpu_shader *get_shader (int fd,const int shadertype) {static struct gpgpu_shader *shader; shader =gpgpu_shader_create (fd);gpgpu_shader__write_dword (shader,SHADER_CANARY ,0 ); + +switch (shadertype) { +case SHADER_WAIT : +gpgpu_shader__wait (shader); +break ; +case SHADER_WRITE : +break ; +case SHADER_BREAKPOINT : +gpgpu_shader__nop (shader); +gpgpu_shader__breakpoint (shader); +break ; + } +gpgpu_shader__eot (shader);return shader; } -static uint32_t gpgpu_shader (int fd,struct intel_bb *ibb,unsigned int threads, -unsigned int width,unsigned int height) +static struct gpgpu_shader *get_sip (int fd,const int siptype, +const int shadertype,unsigned int y_offset) +{ +static struct gpgpu_shader *sip; + +if (siptype ==SIP_NULL ) +return NULL ; + + sip =gpgpu_shader_create (fd); +gpgpu_shader__write_dword (sip,SIP_CANARY , y_offset); + +switch (siptype) { +case SIP_WRITE : +break ; +/* TODO: Add alternative SIP instructions here */ + } + +gpgpu_shader__end_system_routine (sip, shadertype ==SHADER_BREAKPOINT ); +return sip; +} + +static uint32_t gpgpu_shader (int fd,struct intel_bb *ibb,const int shadertype,const int siptype, +unsigned int threads,unsigned int width,unsigned int height) {struct intel_buf *buf =create_fill_buf (fd, width, height,COLOR_C4 ); -struct gpgpu_shader *shader =get_shader (fd); +struct gpgpu_shader *sip =get_sip (fd, siptype, shadertype, height /2 ); +struct gpgpu_shader *shader =get_shader (fd, shadertype); + +gpgpu_shader_exec (ibb, buf,1 , threads, shader, sip,0 ,0 ); -gpgpu_shader_exec (ibb, buf,1 , threads, shader,NULL ,0 ,0 ); +if (sip) +gpgpu_shader_destroy (sip);gpgpu_shader_destroy (shader); +return buf->handle; } +static bool has_debugger (int fd) +{ +struct drm_xe_eudebug_connect param = { .pid =getpid () }; +int debugfd; + + debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , ¶m); +if (debugfd >=0 ) +close (debugfd); + +return debugfd >=0 ; +} +static void check_fill_buf (uint8_t *ptr,const int width,const int x,const int y,const uint8_t color) {
@@ -84,10 +143,10 @@ static void check_fill_buf(uint8_t *ptr, const int width, const int x, }static void check_buf (int fd,uint32_t handle,int width,int height, -uint8_t poison_c) +int siptype,uint8_t poison_c) {unsigned int sz =ALIGN (width * height,4096 ); -int thread_count =0 ; +int thread_count =0 , sip_count =0 ;uint32_t *ptr;int i, j;
@@ -105,7 +164,25 @@ static void check_buf(int fd, uint32_t handle, int width, int height, i =0 ; } +for (i =0 , j = height /2 ; j < height; ++j) { +if (ptr[j * width /4 ] ==SIP_CANARY ) { + ++sip_count; + i =4 ; + } + +for (; i < width; i++) +check_fill_buf ((uint8_t *)ptr, width, i, j, poison_c); + + i =0 ; + } +igt_assert (thread_count); +if (siptype !=SIP_NULL &&has_debugger (fd)) +igt_assert_f (thread_count == sip_count, +"Thread and SIP count mismatch, %d != %d\n" , + thread_count, sip_count); +else +igt_assert (sip_count ==0 );munmap (ptr, sz); }
@@ -128,16 +205,22 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* Description: check basic shader with write operation * Run type: BAT * +* SUBTEST: wait-writesip-nodebug +* Description: verify that we don't enter SIP after wait with debugging disabled. +* +* SUBTEST: breakpoint-writesip +* Description: Test that we enter SIP after hitting breakpoint in shader. +* */ -static void test_sip (struct drm_xe_engine_class_instance *eci,uint32_t flags) +static void test_sip (int shader,int sip,struct drm_xe_engine_class_instance *eci) {unsigned int threads =512 ;unsigned int height =max_t (threads,HEIGHT , threads *2 ); -uint32_t exec_queue_id, handle, vm_id;unsigned int width =WIDTH ;struct timespec ts = { }; -uint64_t timeout; +uint32_t exec_queue_id, handle, vm_id;struct intel_bb *ibb; +uint64_t timeout;int fd;igt_debug ("Using %s\n" ,xe_engine_class_string (eci->engine_class));
@@ -156,12 +239,12 @@ static void test_sip(struct drm_xe_engine_class_instance *eci, uint32_t flags) ibb =intel_bb_create_with_context (fd, exec_queue_id, vm_id,NULL ,4096 );igt_nsec_elapsed (&ts); - handle =gpgpu_shader (fd, ibb, threads, width, height); + handle =gpgpu_shader (fd, ibb, shader, sip, threads, width, height);intel_bb_sync (ibb);igt_assert_lt_u64 (igt_nsec_elapsed (&ts), timeout); -check_buf (fd, handle, width, height,COLOR_C4 ); +check_buf (fd, handle, width, height, sip,COLOR_C4 );gem_close (fd, handle);intel_bb_destroy (ibb);
@@ -189,7 +272,27 @@ igt_main fd =drm_open_driver (DRIVER_XE ); test_render_and_compute("sanity", fd, eci) -test_sip (eci,0 ); +test_sip (SHADER_WRITE ,SIP_NULL , eci); + +/* Debugger disabled (TD_CTL not set) */ + igt_subtest_group { + igt_fixture { +igt_require (!has_debugger (fd)); + } + + test_render_and_compute("wait-writesip-nodebug", fd, eci) +test_sip (SHADER_WAIT ,SIP_WRITE , eci); + } + +/* Debugger enabled (TD_CTL set) */ + igt_subtest_group { + igt_fixture { +igt_require (has_debugger (fd)); + } + + test_render_and_compute("breakpoint-writesip", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci); + }igt_fixture drm_close_driver (fd );
Signature · 1 line
2.34.1
PATCH v2 39/66 tests/xe_exec_sip: Check if we reset due to unhandled attention
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Add breakpoint-waitsip test which checks whether we reset upon unhandled attention.
--- tests/intel/xe_exec_sip.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-)
tests/intel/xe_exec_sip.c +19 -2
@@ -40,6 +40,7 @@#define SHADER_WAIT 2#define SIP_WRITE 3#define SIP_NULL 4 +#define SIP_WAIT 5static struct intel_buf *create_fill_buf (int fd,int width,int height,uint8_t color)
@@ -97,7 +98,9 @@ static struct gpgpu_shader *get_sip(int fd, const int siptype,switch (siptype) {case SIP_WRITE :break ; -/* TODO: Add alternative SIP instructions here */ +case SIP_WAIT : +gpgpu_shader__wait (sip); +break ; }gpgpu_shader__end_system_routine (sip, shadertype ==SHADER_BREAKPOINT );
@@ -211,12 +214,20 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* SUBTEST: breakpoint-writesip * Description: Test that we enter SIP after hitting breakpoint in shader. * +* SUBTEST: breakpoint-waitsip +* Description: Test that we reset after seeing the attention without the debugger. +* */ static void test_sip (int shader,int sip,struct drm_xe_engine_class_instance *eci) {unsigned int threads =512 ;unsigned int height =max_t (threads,HEIGHT , threads *2 );unsigned int width =WIDTH ; +struct drm_xe_ext_set_property ext = { + .base.name =DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY , + .property =DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG , + .value =DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE , + };struct timespec ts = { };uint32_t exec_queue_id, handle, vm_id;struct intel_bb *ibb;
@@ -228,6 +239,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e fd =drm_open_driver (DRIVER_XE );xe_device_get (fd); + vm_id =xe_vm_create (fd,0 ,0 );/* Get timeout for job, and add 4s to ensure timeout processes in subtest. */
@@ -235,7 +247,9 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e timeout *=NSEC_PER_MSEC ; timeout *=igt_run_in_simulation () ?10 :1 ; - exec_queue_id =xe_exec_queue_create (fd, vm_id, eci,0 ); + exec_queue_id =xe_exec_queue_create (fd, vm_id, eci, +has_debugger (fd) ? +to_user_pointer (&ext) :0 ); ibb =intel_bb_create_with_context (fd, exec_queue_id, vm_id,NULL ,4096 );igt_nsec_elapsed (&ts);
@@ -292,6 +306,9 @@ igt_main test_render_and_compute("breakpoint-writesip", fd, eci)test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci); + + test_render_and_compute("breakpoint-waitsip", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci); } igt_fixture
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 39/66] tests/xe_exec_sip: Check if we reset due to unhandled attention
Quoted 110 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 39/66] tests/xe_exec_sip: Check if we reset due to unhandled attentionFrom: Dominik Grzegorzek <[email protected]>
Add breakpoint-waitsip test which checks whether we reset upon unhandled attention.
Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_exec_sip.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-)tests/intel/xe_exec_sip.c index renamed from tests/intel/xe_exec_sip.c +0
-0
e52889818..1b0accb3b100644tests/intel/xe_exec_sip.c +1
-0@@ -40,6 +40,7 @@#define SHADER_WAIT 2#define SIP_WRITE 3#define SIP_NULL 4 +#define SIP_WAIT 5static struct intel_buf * create_fill_buf(int fd, int width, int height, uint8_t color) @@ -97,7 +98,9@@ static struct
gpgpu_shader*get_sip(int fd, const int siptype,tests/intel/xe_exec_sip.c +3
-1switch (siptype) {case SIP_WRITE :break ; -/* TODO: Add alternative SIP instructions here */ +case SIP_WAIT : +gpgpu_shader__wait (sip); +break ; } gpgpu_shader__end_system_routine(sip, shadertype ==
SHADER_BREAKPOINT); @@ -211,12 +214,20 @@xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)
* SUBTEST: breakpoint-writesip
* Description: Test that we enter SIP after hitting breakpoint in shader. *
+ * SUBTEST: breakpoint-waitsip
+ * Description: Test that we reset after seeing the attention without the debugger.
+ *
*/
static void test_sip(int shader, int sip, structdrm_xe_engine_class_instance
*eci) {tests/intel/xe_exec_sip.c +2
-0unsigned int threads =512 ;unsigned int height =max_t (threads,HEIGHT , threads *2 );unsigned int width =WIDTH ; + struct drm_xe_ext_set_property ext = { + .base.name =
DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY,tests/intel/xe_exec_sip.c +1
-0+ .property =
DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG,tests/intel/xe_exec_sip.c +2
-0+ .value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, + };struct timespec ts = { };uint32_t exec_queue_id, handle, vm_id;struct intel_bb *ibb;@@ -228,6 +239,7 @@ static void test_sip(int shader, int sip, struct
drm_xe_engine_class_instance*etests/intel/xe_exec_sip.c +1
-0fd =drm_open_driver (DRIVER_XE );xe_device_get (fd); + vm_id =xe_vm_create (fd,0 ,0 );/* Get timeout for job, and add 4s to ensure timeout processes in subtest. */ @@ -235,7 +247,9 @@ static void test_sip(int shader, int sip, struct
drm_xe_engine_class_instance*etests/intel/xe_exec_sip.c +3
-1timeout *=NSEC_PER_MSEC ; timeout *=igt_run_in_simulation () ?10 :1 ; - exec_queue_id =xe_exec_queue_create (fd, vm_id, eci,0 ); + exec_queue_id =xe_exec_queue_create (fd, vm_id, eci, +has_debugger (fd) ? +to_user_pointer (&ext) :0 ); ibb = intel_bb_create_with_context(fd, exec_queue_id, vm_id, NULL,4096);
tests/intel/xe_exec_sip.c +3
-1igt_nsec_elapsed (&ts);@@ -292,6 +306,9 @@ igt_main test_render_and_compute("breakpoint-writesip", fd, eci)test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci); + + test_render_and_compute("breakpoint-waitsip", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci); } igt_fixture --2.34.1
Re: [PATCH i-g-t v2 39/66] tests/xe_exec_sip: Check if we reset due to unhandled attention
In reply to Christoph ManszewskiQuoted 56 lines · Christoph Manszewski
From: Dominik Grzegorzek <[email protected]>
Add breakpoint-waitsip test which checks whether we reset upon unhandled attention.
Signed-off-by Dominik Grzegorzek <[email protected]>Cc Christoph Manszewski <[email protected]>--- tests/intel/xe_exec_sip.c | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-)tests/intel/xe_exec_sip.c +12
-1@@ -40,6 +40,7 @@#define SHADER_WAIT 2#define SIP_WRITE 3#define SIP_NULL 4 +#define SIP_WAIT 5static struct intel_buf *create_fill_buf (int fd,int width,int height,uint8_t color)@@ -97,7 +98,9 @@ static struct gpgpu_shader *get_sip(int fd, const int siptype,switch (siptype) {case SIP_WRITE :break ; -/* TODO: Add alternative SIP instructions here */ +case SIP_WAIT : +gpgpu_shader__wait (sip); +break ; }gpgpu_shader__end_system_routine (sip, shadertype ==SHADER_BREAKPOINT );@@ -211,12 +214,20 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* SUBTEST: breakpoint-writesip * Description: Test that we enter SIP after hitting breakpoint in shader. * +* SUBTEST: breakpoint-waitsip +* Description: Test that we reset after seeing the attention without the debugger. +* */ static void test_sip (int shader,int sip,struct drm_xe_engine_class_instance *eci) {unsigned int threads =512 ;unsigned int height =max_t (threads,HEIGHT , threads *2 );unsigned int width =WIDTH ; +struct drm_xe_ext_set_property ext = { + .base.name =DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY , + .property =DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG , + .value =DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE , + };struct timespec ts = { };uint32_t exec_queue_id, handle, vm_id;struct intel_bb *ibb;
tests/intel/xe_exec_sip.c static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e · line 242
Quoted 4 lines
tests/intel/xe_exec_sip.c +1
-0@@ -228,6 +239,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e fd =drm_open_driver (DRIVER_XE );xe_device_get (fd); +
Extra new line.
Regards,
Dominik
Quoted 24 lines
tests/intel/xe_exec_sip.c +6
-1vm_id =xe_vm_create (fd,0 ,0 );/* Get timeout for job, and add 4s to ensure timeout processes in subtest. */ @@ -235,7 +247,9 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e timeout *=NSEC_PER_MSEC ; timeout *=igt_run_in_simulation () ?10 :1 ; - exec_queue_id =xe_exec_queue_create (fd, vm_id, eci,0 ); + exec_queue_id =xe_exec_queue_create (fd, vm_id, eci, +has_debugger (fd) ? +to_user_pointer (&ext) :0 ); ibb =intel_bb_create_with_context (fd, exec_queue_id, vm_id,NULL ,4096 );igt_nsec_elapsed (&ts);@@ -292,6 +306,9 @@ igt_main test_render_and_compute("breakpoint-writesip", fd, eci)test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci); + + test_render_and_compute("breakpoint-waitsip", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci); } igt_fixture
PATCH v2 40/66 tests/xe_exec_sip: Check usercoredump for attentions
In reply to Christoph ManszewskiFrom: Dominik Grzegorzek <[email protected]>
Check for attentions within usercoredump in tests that raise attentions.
--- tests/intel/xe_exec_sip.c | 64 +++++++++++++++++++++++++++++++++++++-- 1 file changed, 61 insertions(+), 3 deletions(-)
tests/intel/xe_exec_sip.c +61 -3
@@ -145,7 +145,7 @@ static void check_fill_buf(uint8_t *ptr, const int width, const int x, color, val, x, y); } -static void check_buf (int fd,uint32_t handle,int width,int height, +static int check_buf (int fd,uint32_t handle,int width,int height,int siptype,uint8_t poison_c) {unsigned int sz =ALIGN (width * height,4096 );
@@ -188,6 +188,63 @@ static void check_buf(int fd, uint32_t handle, int width, int height,igt_assert (sip_count ==0 );munmap (ptr, sz); + +return sip_count; +} + +#define USERCOREDUMP_FORMAT "usercoredumps/%d/%d" +static char *get_latest_usercoredump (int dir) +{ +char tmp[256 ]; +int i =1 ; + +do { +snprintf (tmp,sizeof (tmp),USERCOREDUMP_FORMAT ,getpid (), i++); + }while (igt_sysfs_has_attr (dir, tmp)); + +snprintf (tmp,sizeof (tmp),USERCOREDUMP_FORMAT ,getpid (), i-2 ); +return igt_sysfs_get (dir, tmp); +} + +static void check_usercoredump (int fd,int sip,int dispatched) +{ +int dir =igt_debugfs_dir (fd); +char *usercoredump, *str; +unsigned int before, after; +char match[256 ]; + +if (sip !=SIP_WAIT ) +return ; + +/* XXX reinstate when offline coredumps are implemented */ +#ifndef XXX_ATTENTIONS_THROUGH_COREDUMPS +return ; +#endif + usercoredump =get_latest_usercoredump (dir); +igt_assert (usercoredump); +igt_debug ("%s\n" , usercoredump); + +snprintf (match,sizeof (match),"PID: %d" ,getpid ()); + str =strstr (usercoredump, match); +igt_assert (str); + +snprintf (match,sizeof (match),"Comm: %s" ,igt_test_name ()); + str =strstr (str, match); +igt_assert (str); + + str =strstr (str,"TD_ATT" ); +igt_assert (str); +igt_assert_eq (sscanf (str,"TD_ATT before (%d):" , &before),1 ); + str =strstr (str +1 ,"TD_ATT" ); +igt_assert_eq (sscanf (str,"TD_ATT after (%d):" , &after),1 ); + +igt_info ("attentions %d before, %d after\n" , before, after); + +igt_assert_eq (before, dispatched); +igt_assert_eq (after, dispatched); + +free (usercoredump); +close (dir); } static uint64_t
@@ -232,7 +289,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *euint32_t exec_queue_id, handle, vm_id;struct intel_bb *ibb;uint64_t timeout; -int fd; +int dispatched, fd;igt_debug ("Using %s\n" ,xe_engine_class_string (eci->engine_class));
@@ -258,7 +315,8 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *eintel_bb_sync (ibb);igt_assert_lt_u64 (igt_nsec_elapsed (&ts), timeout); -check_buf (fd, handle, width, height, sip,COLOR_C4 ); + dispatched =check_buf (fd, handle, width, height, sip,COLOR_C4 ); +check_usercoredump (fd, sip, dispatched);gem_close (fd, handle);intel_bb_destroy (ibb);
Signature · 1 line
2.34.1
PATCH v2 41/66 tests/xe_exec_sip: Add support for dynamic debugger sysfs toggle
In reply to Christoph ManszewskiFrom now on the debugger is disabled by default so it is required to enable the debugger before using it. This change addresses that fact by calling necessary library functions within test fixtures.
--- tests/intel/xe_exec_sip.c | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-)
tests/intel/xe_exec_sip.c +12 -16
@@ -123,18 +123,6 @@ static uint32_t gpgpu_shader(int fd, struct intel_bb *ibb, const int shadertype,return buf->handle; } -static bool has_debugger (int fd) -{ -struct drm_xe_eudebug_connect param = { .pid =getpid () }; -int debugfd; - - debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , ¶m); -if (debugfd >=0 ) -close (debugfd); - -return debugfd >=0 ; -} -static void check_fill_buf (uint8_t *ptr,const int width,const int x,const int y,const uint8_t color) {
@@ -180,7 +168,7 @@ static int check_buf(int fd, uint32_t handle, int width, int height, }igt_assert (thread_count); -if (siptype !=SIP_NULL &&has_debugger (fd)) +if (siptype !=SIP_NULL &&xe_eudebug_debugger_available (fd))igt_assert_f (thread_count == sip_count,"Thread and SIP count mismatch, %d != %d\n" , thread_count, sip_count);
@@ -305,7 +293,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e timeout *=igt_run_in_simulation () ?10 :1 ; exec_queue_id =xe_exec_queue_create (fd, vm_id, eci, -has_debugger (fd) ? +xe_eudebug_debugger_available (fd) ?to_user_pointer (&ext) :0 ); ibb =intel_bb_create_with_context (fd, exec_queue_id, vm_id,NULL ,4096 );
@@ -338,6 +326,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e igt_main {struct drm_xe_engine_class_instance *eci; +bool was_enabled;int fd; igt_fixture
@@ -349,17 +338,21 @@ igt_main/* Debugger disabled (TD_CTL not set) */ igt_subtest_group { igt_fixture { -igt_require (!has_debugger (fd)); + was_enabled =xe_eudebug_enable (fd, false); +igt_require (!xe_eudebug_debugger_available (fd)); } test_render_and_compute("wait-writesip-nodebug", fd, eci)test_sip (SHADER_WAIT ,SIP_WRITE , eci); + +igt_fixture +xe_eudebug_enable (fd ,was_enabled ); }/* Debugger enabled (TD_CTL set) */ igt_subtest_group { igt_fixture { -igt_require (has_debugger (fd)); + was_enabled =xe_eudebug_enable (fd, true); }test_render_and_compute ("breakpoint-writesip" , fd, eci)
@@ -367,6 +360,9 @@ igt_main test_render_and_compute("breakpoint-waitsip", fd, eci)test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci); + +igt_fixture +xe_eudebug_enable (fd ,was_enabled ); } igt_fixture
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 41/66] tests/xe_exec_sip: Add support for dynamic debugger sysfs toggle
Quoted 115 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 41/66] tests/xe_exec_sip: Add support for dynamic debugger sysfs toggleFrom now on the debugger is disabled by default so it is required to enable the debugger before using it. This change addresses that fact by calling necessary library functions within test fixtures.
Signed-off-by Mika Kuoppala <[email protected]>Signed-off-by Christoph Manszewski <[email protected]>Cc Dominik Grzegorzek <[email protected]>--- tests/intel/xe_exec_sip.c | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-)tests/intel/xe_exec_sip.c index renamed from tests/intel/xe_exec_sip.c +0
-0
a315bd3a9..832c26bac100644tests/intel/xe_exec_sip.c +0
-12@@ -123,18 +123,6 @@ static uint32_t gpgpu_shader(int fd, struct intel_bb *ibb, const int shadertype, return buf->handle; } -static bool has_debugger (int fd) -{ -struct drm_xe_eudebug_connect param = { .pid =getpid () }; -int debugfd; - - debugfd =igt_ioctl (fd,DRM_IOCTL_XE_EUDEBUG_CONNECT , ¶m); -if (debugfd >=0 ) -close (debugfd); - -return debugfd >=0 ; -} - static void check_fill_buf(uint8_t *ptr, const int width, const int x,const int y, const
uint8_tcolor) { @@ -180,7 +168,7
@@ static int check_buf(int fd,uint32_thandle, int width, int height,tests/intel/xe_exec_sip.c +1
-1}igt_assert (thread_count); -if (siptype !=SIP_NULL &&has_debugger (fd)) +if (siptype !=SIP_NULL &&xe_eudebug_debugger_available (fd))igt_assert_f (thread_count == sip_count,"Thread and SIP count mismatch, %d != %d\n" , thread_count, sip_count);@@ -305,7 +293,7 @@ static void test_sip(int shader, int sip, struct
drm_xe_engine_class_instance*etests/intel/xe_exec_sip.c +1
-1timeout *=igt_run_in_simulation () ?10 :1 ; exec_queue_id = xe_exec_queue_create(fd, vm_id, eci, - has_debugger(fd) ? +
xe_eudebug_debugger_available(fd)?tests/intel/xe_exec_sip.c +0
-0to_user_pointer(&ext) : 0); ibb = intel_bb_create_with_context(fd, exec_queue_id, vm_id, NULL,4096);
tests/intel/xe_exec_sip.c +10
-4@@ -338,6 +326,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e igt_main {struct drm_xe_engine_class_instance *eci; +bool was_enabled;int fd; igt_fixture@@ -349,17 +338,21 @@ igt_main/* Debugger disabled (TD_CTL not set) */ igt_subtest_group { igt_fixture { -igt_require (!has_debugger (fd)); + was_enabled =xe_eudebug_enable (fd, false); +igt_require (!xe_eudebug_debugger_available (fd)); } test_render_and_compute("wait-writesip-nodebug", fd, eci)test_sip (SHADER_WAIT ,SIP_WRITE , eci); + +igt_fixture +xe_eudebug_enable (fd ,was_enabled ); }/* Debugger enabled (TD_CTL set) */ igt_subtest_group { igt_fixture { -igt_require (has_debugger (fd)); + was_enabled =xe_eudebug_enable (fd, true); } test_render_and_compute("breakpoint-writesip", fd, eci) @@ -367,6 +360,9 @@ igt_main test_render_and_compute("breakpoint-waitsip", fd, eci)test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci); + +igt_fixture +xe_eudebug_enable (fd ,was_enabled ); } igt_fixture --2.34.1
PATCH v2 42/66 tests/xe_exec_sip: Add breakpoint-writesip-twice test
In reply to Christoph ManszewskiFrom: Dominik Karol Piątkowski <[email protected]>
Add breakpoint-writesip-twice test that checks twice if we enter SIP after hitting breakpoint in shader.
--- tests/intel/xe_exec_sip.c | 40 ++++++++++++++++++++++++--------------- 1 file changed, 25 insertions(+), 15 deletions(-)
tests/intel/xe_exec_sip.c +25 -15
@@ -42,6 +42,8 @@#define SIP_NULL 4#define SIP_WAIT 5 +#define F_SUBMIT_TWICE (1 << 0) +static struct intel_buf *create_fill_buf (int fd,int width,int height,uint8_t color) {
@@ -259,11 +261,14 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* SUBTEST: breakpoint-writesip * Description: Test that we enter SIP after hitting breakpoint in shader. * +* SUBTEST: breakpoint-writesip-twice +* Description: Test twice that we enter SIP after hitting breakpoint in shader. +* * SUBTEST: breakpoint-waitsip * Description: Test that we reset after seeing the attention without the debugger. * */ -static void test_sip (int shader,int sip,struct drm_xe_engine_class_instance *eci) +static void test_sip (int shader,int sip,struct drm_xe_engine_class_instance *eci,uint32_t flags) {unsigned int threads =512 ;unsigned int height =max_t (threads,HEIGHT , threads *2 );
@@ -274,6 +279,7 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e .value = DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE, };struct timespec ts = { }; +int done =0 ;uint32_t exec_queue_id, handle, vm_id;struct intel_bb *ibb;uint64_t timeout;
@@ -284,7 +290,6 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e fd =drm_open_driver (DRIVER_XE );xe_device_get (fd); - vm_id =xe_vm_create (fd,0 ,0 );/* Get timeout for job, and add 4s to ensure timeout processes in subtest. */
@@ -295,19 +300,21 @@ static void test_sip(int shader, int sip, struct drm_xe_engine_class_instance *e exec_queue_id =xe_exec_queue_create (fd, vm_id, eci,xe_eudebug_debugger_available (fd) ?to_user_pointer (&ext) :0 ); - ibb =intel_bb_create_with_context (fd, exec_queue_id, vm_id,NULL ,4096 ); +do { + ibb =intel_bb_create_with_context (fd, exec_queue_id, vm_id,NULL ,4096 ); -igt_nsec_elapsed (&ts); - handle =gpgpu_shader (fd, ibb, shader, sip, threads, width, height); +igt_nsec_elapsed (&ts); + handle =gpgpu_shader (fd, ibb, shader, sip, threads, width, height); -intel_bb_sync (ibb); -igt_assert_lt_u64 (igt_nsec_elapsed (&ts), timeout); +intel_bb_sync (ibb); +igt_assert_lt_u64 (igt_nsec_elapsed (&ts), timeout); - dispatched =check_buf (fd, handle, width, height, sip,COLOR_C4 ); -check_usercoredump (fd, sip, dispatched); + dispatched =check_buf (fd, handle, width, height, sip,COLOR_C4 ); +check_usercoredump (fd, sip, dispatched); -gem_close (fd, handle); -intel_bb_destroy (ibb); +gem_close (fd, handle); +intel_bb_destroy (ibb); + }while (!done++ && (flags &F_SUBMIT_TWICE ));xe_exec_queue_destroy (fd, exec_queue_id);xe_vm_destroy (fd, vm_id);
@@ -333,7 +340,7 @@ igt_main fd =drm_open_driver (DRIVER_XE ); test_render_and_compute("sanity", fd, eci) -test_sip (SHADER_WRITE ,SIP_NULL , eci); +test_sip (SHADER_WRITE ,SIP_NULL , eci,0 );/* Debugger disabled (TD_CTL not set) */ igt_subtest_group {
@@ -343,7 +350,7 @@ igt_main } test_render_and_compute("wait-writesip-nodebug", fd, eci) -test_sip (SHADER_WAIT ,SIP_WRITE , eci); +test_sip (SHADER_WAIT ,SIP_WRITE , eci,0 );igt_fixture xe_eudebug_enable (fd ,was_enabled );
@@ -356,10 +363,13 @@ igt_main } test_render_and_compute("breakpoint-writesip", fd, eci) -test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci); +test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci,0 ); + + test_render_and_compute("breakpoint-writesip-twice", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci,F_SUBMIT_TWICE ); test_render_and_compute("breakpoint-waitsip", fd, eci) -test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci); +test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci,0 );igt_fixture xe_eudebug_enable (fd ,was_enabled );
Signature · 1 line
2.34.1
PATCH v2 43/66 tests/xe_exec_sip: Add sanity-after-timeout test
In reply to Christoph ManszewskiFrom: Karolina Stolarek <[email protected]>
Introduce sanity-after-timeout test to check if the shader gets executed after a hang.
--- tests/intel/xe_exec_sip.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-)
tests/intel/xe_exec_sip.c +21 -3
@@ -38,9 +38,10 @@#define SHADER_BREAKPOINT 0#define SHADER_WRITE 1#define SHADER_WAIT 2 -#define SIP_WRITE 3 -#define SIP_NULL 4 -#define SIP_WAIT 5 +#define SHADER_HANG 3 +#define SIP_WRITE 4 +#define SIP_NULL 5 +#define SIP_WAIT 6#define F_SUBMIT_TWICE (1 << 0)
@@ -71,6 +72,11 @@ static struct gpgpu_shader *get_shader(int fd, const int shadertype)gpgpu_shader__write_dword (shader,SHADER_CANARY ,0 );switch (shadertype) { +case SHADER_HANG : +gpgpu_shader__label (shader,0 ); +gpgpu_shader__nop (shader); +gpgpu_shader__jump (shader,0 ); +break ;case SHADER_WAIT :gpgpu_shader__wait (shader);break ;
@@ -255,6 +261,9 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* Description: check basic shader with write operation * Run type: BAT * +* SUBTEST: sanity-after-timeout +* Description: check basic shader execution after job timeout +* * SUBTEST: wait-writesip-nodebug * Description: verify that we don't enter SIP after wait with debugging disabled. *
@@ -342,6 +351,15 @@ igt_main test_render_and_compute("sanity", fd, eci)test_sip (SHADER_WRITE ,SIP_NULL , eci,0 ); + test_render_and_compute("sanity-after-timeout", fd, eci) { +test_sip (SHADER_HANG ,SIP_NULL , eci,0 ); + +xe_for_each_engine (fd, eci) +if (eci->engine_class ==DRM_XE_ENGINE_CLASS_RENDER || + eci->engine_class ==DRM_XE_ENGINE_CLASS_COMPUTE ) +test_sip (SHADER_WRITE ,SIP_NULL , eci,0 ); + } +/* Debugger disabled (TD_CTL not set) */ igt_subtest_group { igt_fixture {
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 43/66] tests/xe_exec_sip: Add sanity-after-timeout test
Quoted 91 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 43/66] tests/xe_exec_sip: Add sanity-after-timeout testFrom: Karolina Stolarek <[email protected]>
Introduce sanity-after-timeout test to check if the shader gets executed after a hang.
Signed-off-by Karolina Stolarek <[email protected]>Cc Christoph Manszewski <[email protected]>Cc Dominik Karol Piątkowski <[email protected]>--- tests/intel/xe_exec_sip.c | 24 +++++++++++++++++++++--- 1 file changed, 21 insertions(+), 3 deletions(-)tests/intel/xe_exec_sip.c index renamed from tests/intel/xe_exec_sip.c +0
-0
7b4305576..92da8f14d100644tests/intel/xe_exec_sip.c +9
-3@@ -38,9 +38,10 @@#define SHADER_BREAKPOINT 0#define SHADER_WRITE 1#define SHADER_WAIT 2 -#define SIP_WRITE 3 -#define SIP_NULL 4 -#define SIP_WAIT 5 +#define SHADER_HANG 3 +#define SIP_WRITE 4 +#define SIP_NULL 5 +#define SIP_WAIT 6#define F_SUBMIT_TWICE (1 << 0)@@ -71,6 +72,11 @@ static struct gpgpu_shader *get_shader(int fd, const int shadertype) gpgpu_shader__write_dword(shader, SHADER_CANARY, 0); switch (shadertype) { +case SHADER_HANG : +gpgpu_shader__label (shader,0 ); +gpgpu_shader__nop (shader); +gpgpu_shader__jump (shader,0 ); +break ;case SHADER_WAIT :gpgpu_shader__wait (shader);tests/intel/xe_exec_sip.c +3
-0break ;@@ -255,6 +261,9 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci) * Description: check basic shader with write operation * Run type: BAT * + * SUBTEST: sanity-after-timeout + * Description: check basic shader execution after job timeout + * * SUBTEST: wait-writesip-nodebug * Description: verify that we don't enter SIP after wait with debuggingdisabled.
*tests/intel/xe_exec_sip.c +5
-0@@ -342,6 +351,15 @@ igt_main test_render_and_compute("sanity", fd, eci)test_sip (SHADER_WRITE ,SIP_NULL , eci,0 ); + test_render_and_compute("sanity-after-timeout", fd, eci) { +test_sip (SHADER_HANG ,SIP_NULL , eci,0 ); + +xe_for_each_engine (fd, eci) + if (eci->engine_class ==
DRM_XE_ENGINE_CLASS_RENDER||tests/intel/xe_exec_sip.c +1
-0+ eci->engine_class ==
DRM_XE_ENGINE_CLASS_COMPUTE)tests/intel/xe_exec_sip.c +3
-1+test_sip (SHADER_WRITE ,SIP_NULL , eci,0 ); + } +/* Debugger disabled (TD_CTL not set) */ igt_subtest_group { igt_fixture { --2.34.1
PATCH v2 44/66 tests/xe_exec_sip: Add breakpoint-waitsip-heavy test
In reply to Christoph ManszewskiFrom: Dominik Karol Piątkowski <[email protected]>
Add breakpoint-waitsip-heavy test that walks checks if we reset after seeing the attention from heavy SIP without the debugger.
--- tests/intel/xe_exec_sip.c | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-)
tests/intel/xe_exec_sip.c +26 -1
@@ -42,6 +42,7 @@#define SIP_WRITE 4#define SIP_NULL 5#define SIP_WAIT 6 +#define SIP_HEAVY 7#define F_SUBMIT_TWICE (1 << 0)
@@ -107,6 +108,23 @@ static struct gpgpu_shader *get_sip(int fd, const int siptype,case SIP_WRITE :break ;case SIP_WAIT : +gpgpu_shader__wait (sip); +break ; +case SIP_HEAVY : +/* Depending on the generation, the production sip +* executes between 145 to 157 instructions. +* It performs at most 45 data port writes and 5 data port reads. +* Make sure our heavy sip is at least twice heavy as production one. +*/ +gpgpu_shader__loop_begin (sip,0 ); +gpgpu_shader__write_dword (sip,0xdeadbeef , y_offset); +gpgpu_shader__write_dword (sip,SIP_CANARY , y_offset); +gpgpu_shader__loop_end (sip,0 ,45 ); + +gpgpu_shader__loop_begin (sip,1 ); +gpgpu_shader__jump_neq (sip,1 , y_offset,SIP_CANARY ); +gpgpu_shader__loop_end (sip,1 ,10 ); +gpgpu_shader__wait (sip);break ; }
@@ -209,7 +227,7 @@ static void check_usercoredump(int fd, int sip, int dispatched)unsigned int before, after;char match[256 ]; -if (sip !=SIP_WAIT ) +if (sip !=SIP_WAIT && sip !=SIP_HEAVY )return ;/* XXX reinstate when offline coredumps are implemented */
@@ -276,6 +294,10 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* SUBTEST: breakpoint-waitsip * Description: Test that we reset after seeing the attention without the debugger. * +* SUBTEST: breakpoint-waitsip-heavy +* Description: +* Test that we reset after seeing the attention from heavy SIP, that resembles +* the production one, without the debugger. */ static void test_sip (int shader,int sip,struct drm_xe_engine_class_instance *eci,uint32_t flags) {
@@ -389,6 +411,9 @@ igt_main test_render_and_compute("breakpoint-waitsip", fd, eci)test_sip (SHADER_BREAKPOINT ,SIP_WAIT , eci,0 ); + test_render_and_compute("breakpoint-waitsip-heavy", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_HEAVY , eci,0 ); +igt_fixture xe_eudebug_enable (fd ,was_enabled ); }
Signature · 1 line
2.34.1
PATCH v2 45/66 tests/xe_exec_sip: Add nodebug test cases
In reply to Christoph ManszewskiFrom: Karolina Stolarek <[email protected]>
Introduce tests that make sure we don't enter SIP when debugging is disabled.
--- tests/intel/xe_exec_sip.c | 7 +++++++ 1 file changed, 7 insertions(+)
tests/intel/xe_exec_sip.c +7 -0
@@ -285,6 +285,10 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci)* SUBTEST: wait-writesip-nodebug * Description: verify that we don't enter SIP after wait with debugging disabled. * +* SUBTEST: breakpoint-writesip-nodebug +* Description: verify that we don't enter SIP after hitting breakpoint in shader +* when debugging is disabled. +* * SUBTEST: breakpoint-writesip * Description: Test that we enter SIP after hitting breakpoint in shader. *
@@ -392,6 +396,9 @@ igt_main test_render_and_compute("wait-writesip-nodebug", fd, eci)test_sip (SHADER_WAIT ,SIP_WRITE , eci,0 ); + test_render_and_compute("breakpoint-writesip-nodebug", fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci,0 ); +igt_fixture xe_eudebug_enable (fd ,was_enabled ); }
Signature · 1 line
2.34.1
RE: [PATCH i-g-t v2 45/66] tests/xe_exec_sip: Add nodebug test cases
Quoted 55 lines
-----Original Message-----
From: Manszewski, Christoph <[email protected]>
Sent: Tuesday, July 30, 2024 1:45 PM
To: [email protected]
Cc: Kempczynski, Zbigniew <[email protected]>; Kamil Konieczny <[email protected]>; Grzegorzek, Dominik <[email protected]>; Patelczyk, Maciej <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Sikora, Pawel <[email protected]>; Hajda, Andrzej <[email protected]>; Kolanupaka Naveena <[email protected]>; Kuoppala, Mika <[email protected]>; Mun, Gwan-gyeong <gwan- [email protected]>
Subject: [PATCH i-g-t v2 45/66] tests/xe_exec_sip: Add nodebug test casesFrom: Karolina Stolarek <[email protected]>
Introduce tests that make sure we don't enter SIP when debugging is disabled.
Signed-off-by Karolina Stolarek <[email protected]>Cc Dominik Karol Piątkowski <[email protected]>--- tests/intel/xe_exec_sip.c | 7 +++++++ 1 file changed, 7 insertions(+)tests/intel/xe_exec_sip.c index renamed from tests/intel/xe_exec_sip.c +0
-0
a27d3cba6..35d65bcc4100644tests/intel/xe_exec_sip.c +0
-0@@ -285,6 +285,10 @@ xe_sysfs_get_job_timeout_ms(int fd, struct drm_xe_engine_class_instance *eci) * SUBTEST: wait-writesip-nodebug * Description: verify that we don't enter SIP after wait with debuggingdisabled.
*
+ * SUBTEST: breakpoint-writesip-nodebug
+ * Description: verify that we don't enter SIP after hitting breakpoint in shader
+ * when debugging is disabled.
+ *
* SUBTEST: breakpoint-writesip
* Description: Test that we enter SIP after hitting breakpoint in shader. *tests/intel/xe_exec_sip.c +3
-0@@ -392,6 +396,9 @@ igt_main test_render_and_compute("wait-writesip-nodebug", fd, eci)test_sip (SHADER_WAIT ,SIP_WRITE , eci,0 ); +test_render_and_compute ("breakpoint-writesip-nodebug" , fd, eci) +test_sip (SHADER_BREAKPOINT ,SIP_WRITE , eci,0 ); +igt_fixture xe_eudebug_enable (fd ,was_enabled );}
--
2.34.1
PATCH v2 46/66 lib/gpgpu_shader: Add write_on_exception template
In reply to Christoph ManszewskiFrom: Andrzej Hajda <[email protected]>
Writing specific value to memory location on unexpected value in exception register allows to report errors from inside shader or siplet.
--- lib/gpgpu_shader.c | 56 ++++++++++++++++++++++++++ lib/gpgpu_shader.h | 2 + lib/iga64_generated_codes.c | 79 ++++++++++++++++++++++++++++++++++++- 3 files changed, 136 insertions(+), 1 deletion(-)
lib/gpgpu_shader.c +56 -0
@@ -628,6 +628,62 @@ void gpgpu_shader__write_dword(struct gpgpu_shader *shdr, uint32_t value, ", 2, y_offset, 3, value, value, value, value); } +/** +* gpgpu_shader__write_on_exception: +* @shdr: shader to be modified +* @value: dword to be written +* @y_offset: write target offset within the surface in rows +* @mask: mask to be applied on exception register +* @expected: expected value of exception register with @mask applied +* +* Check if bits specified by @mask in exception register(cr0.1) are equal +* to provided ones: cr0.1 & @mask == @expected, +* if yes fill dword in (row, column/dword) == (tg_id_y + @y_offset, tg_id_x). +*/ +void gpgpu_shader__write_on_exception (struct gpgpu_shader *shdr,uint32_t value, +uint32_t y_offset,uint32_t mask,uint32_t expected) +{ +emit_iga64_code (shdr, write_on_exception," \n\ +// Payload \n\ +(W) mov (1|M0) r5.0<1>:ud ARG(3):ud \n\ +(W) mov (1|M0) r5.1<1>:ud ARG(4):ud \n\ +(W) mov (1|M0) r5.2<1>:ud ARG(5):ud \n\ +(W) mov (1|M0) r5.3<1>:ud ARG(6):ud \n\ +#if GEN_VER < 2000 // prepare Media Block Write \n\ +// X offset of the block in bytes := (thread group id X << ARG(0)) \n\ +(W) shl (1|M0) r4.0<1>:ud r0.1<0;1,0>:ud ARG(0):ud \n\ +// Y offset of the block in rows := thread group id Y \n\ +(W) mov (1|M0) r4.1<1>:ud r0.6<0;1,0>:ud \n\ +(W) add (1|M0) r4.1<1>:ud r4.1<0;1,0>:ud ARG(1):ud \n\ +// block width [0,63] representing 1 to 64 bytes \n\ +(W) mov (1|M0) r4.2<1>:ud ARG(2):ud \n\ +// FFTID := FFTID from R0 header \n\ +(W) mov (1|M0) r4.4<1>:ud r0.5<0;1,0>:ud \n\ +#else // prepare Typed 2D Block Store \n\ +// Load r2.0-3 with tg id X << ARG(0) \n\ +(W) shl (1|M0) r2.0<1>:ud r0.1<0;1,0>:ud ARG(0):ud \n\ +// Load r2.4-7 with tg id Y + ARG(1):ud \n\ +(W) mov (1|M0) r2.1<1>:ud r0.6<0;1,0>:ud \n\ +(W) add (1|M0) r2.1<1>:ud r2.1<0;1,0>:ud ARG(1):ud \n\ +// payload setup \n\ +(W) mov (16|M0) r4.0<1>:ud 0x0:ud \n\ +// Store X and Y block start (160:191 and 192:223) \n\ +(W) mov (2|M0) r4.5<1>:ud r2.0<2;2,1>:ud \n\ +// Store X and Y block max_size (224:231 and 232:239) \n\ +(W) mov (1|M0) r4.7<1>:ud ARG(2):ud \n\ +#endif \n\ +// Check if masked exception is equal to provided value and write conditionally \n\ +(W) and (1|M0) r3.0<1>:ud cr0.1<0;1,0>:ud ARG(7):ud \n\ +(W) mov (1|M0) f0.0<1>:ud 0x0:ud \n\ +(W) cmp (1|M0) (eq)f0.0 null:ud r3.0<0;1,0>:ud ARG(8):ud \n\ +#if GEN_VER < 2000 // Media Block Write \n\ +(W&f0.0) send.dc1 (16|M0) null r4 src1_null 0 0x40A8000 \n\ +#else // Typed 2D Block Store \n\ +(W&f0.0) send.tgm (16|M0) null r4 null:0 0 0x64000007 \n\ +#endif \n\ +" ,2 , y_offset,3 , value, value, value, value, mask, expected); +} +/** * gpgpu_shader__end_system_routine: * @shdr: shader to be modified
lib/gpgpu_shader.h +2 -0
@@ -74,6 +74,8 @@ void gpgpu_shader__end_system_routine_step_if_eq(struct gpgpu_shader *shdr,void gpgpu_shader__write_aip (struct gpgpu_shader *shdr,uint32_t y_offset);void gpgpu_shader__write_dword (struct gpgpu_shader *shdr,uint32_t value,uint32_t y_offset); +void gpgpu_shader__write_on_exception (struct gpgpu_shader *shdr,uint32_t dw, +uint32_t y_offset,uint32_t mask,uint32_t value);void gpgpu_shader__label (struct gpgpu_shader *shdr,int label_id);void gpgpu_shader__jump (struct gpgpu_shader *shdr,int label_id); void gpgpu_shader__jump_neq(struct gpgpu_shader *shdr, int label_id,
lib/iga64_generated_codes.c +78 -1
91 lines not on this page · raw message
Signature · 1 line
2.34.1