mirror of
https://github.com/intel/compute-runtime.git
synced 2025-12-25 05:24:02 +08:00
feature: add eudebug interface class
eudebug interface is now hidden under EuDebugInterface class shared code uses generic object and param values layout of structs is guarded by static asserts eudebug support is guarded by cmake flags: - NEO_ENABLE_XE_EU_DEBUG_SUPPORT - enables eudebug in general - NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM - registers exp upstream uAPI support - NEO_ENABLE_XE_PRELIM_DETECTION - registers prelim uAPI support This way we can support two different xe-eudebug interfaces within single binary. In unit tests there is mock eudebug interface enabled (even if no eudebug support is enabled by cmake flag). Related-To: NEO-13472 Signed-off-by: Mateusz Jablonski <mateusz.jablonski@intel.com>
This commit is contained in:
Mateusz Jablonski
committed by
Compute-Runtime-Automation
Compute-Runtime-Automation
parent
49c028858a
commit
8f7bacdd95
29
shared/source/os_interface/linux/xe/eudebug/CMakeLists.txt
Normal file
29
shared/source/os_interface/linux/xe/eudebug/CMakeLists.txt
Normal file
@@ -0,0 +1,29 @@
|
||||
#
|
||||
# Copyright (C) 2024 Intel Corporation
|
||||
#
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
|
||||
set(NEO_CORE_OS_INTERFACE_LINUX_XE_EUDEBUG
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/create_eudebug_interface.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_wrappers.h
|
||||
)
|
||||
if(NEO_ENABLE_XE_EU_DEBUG_SUPPORT)
|
||||
if(NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM)
|
||||
list(APPEND NEO_CORE_OS_INTERFACE_LINUX_XE_EUDEBUG
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface_upstream.cpp
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface_upstream.h
|
||||
)
|
||||
endif()
|
||||
if(NEO_ENABLE_XE_PRELIM_DETECTION)
|
||||
list(APPEND NEO_CORE_OS_INTERFACE_LINUX_XE_EUDEBUG
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface_prelim.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface_prelim.cpp
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
set_property(GLOBAL APPEND PROPERTY NEO_CORE_OS_INTERFACE_LINUX ${NEO_CORE_OS_INTERFACE_LINUX_XE_EUDEBUG})
|
||||
add_subdirectories()
|
||||
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
|
||||
#include "shared/source/utilities/io_functions.h"
|
||||
namespace NEO {
|
||||
const char *eudebugSysfsEntry[static_cast<uint32_t>(EuDebugInterfaceType::maxValue)]{};
|
||||
EuDebugInterfaceCreateFunctionType eudebugInterfaceFactory[static_cast<uint32_t>(EuDebugInterfaceType::maxValue)]{};
|
||||
|
||||
std::unique_ptr<EuDebugInterface> EuDebugInterface::create(const std::string &sysFsPciPath) {
|
||||
char enabledEuDebug = '0';
|
||||
|
||||
for (auto i = 0u; i < static_cast<uint32_t>(EuDebugInterfaceType::maxValue); i++) {
|
||||
if (eudebugSysfsEntry[i]) {
|
||||
auto path = sysFsPciPath + eudebugSysfsEntry[i];
|
||||
FILE *fileDescriptor = IoFunctions::fopenPtr(path.c_str(), "r");
|
||||
if (fileDescriptor) {
|
||||
[[maybe_unused]] auto bytesRead = IoFunctions::freadPtr(&enabledEuDebug, 1, 1, fileDescriptor);
|
||||
IoFunctions::fclosePtr(fileDescriptor);
|
||||
if (enabledEuDebug == '1') {
|
||||
return eudebugInterfaceFactory[i]();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
} // namespace NEO
|
||||
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h"
|
||||
|
||||
namespace NEO {
|
||||
[[maybe_unused]] static EnableEuDebugInterface enableEuDebugPrelim(EuDebugInterfaceType::prelim, EuDebugInterfacePrelim::sysFsXeEuDebugFile, []() -> std::unique_ptr<EuDebugInterface> { return std::make_unique<EuDebugInterfacePrelim>(); });
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h"
|
||||
|
||||
namespace NEO {
|
||||
[[maybe_unused]] static EnableEuDebugInterface enableEuDebugUpstream(EuDebugInterfaceType::upstream, EuDebugInterfaceUpstream::sysFsXeEuDebugFile, []() -> std::unique_ptr<EuDebugInterface> { return std::make_unique<EuDebugInterfaceUpstream>(); });
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_wrappers.h"
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
namespace NEO {
|
||||
|
||||
class EuDebugInterface {
|
||||
public:
|
||||
static std::unique_ptr<EuDebugInterface> create(const std::string &sysFsPciPath);
|
||||
virtual uint32_t getParamValue(EuDebugParam param) const = 0;
|
||||
virtual ~EuDebugInterface() = default;
|
||||
};
|
||||
|
||||
enum class EuDebugInterfaceType : uint32_t {
|
||||
upstream,
|
||||
prelim,
|
||||
maxValue
|
||||
};
|
||||
|
||||
using EuDebugInterfaceCreateFunctionType = std::unique_ptr<EuDebugInterface> (*)();
|
||||
extern const char *eudebugSysfsEntry[static_cast<uint32_t>(EuDebugInterfaceType::maxValue)];
|
||||
extern EuDebugInterfaceCreateFunctionType eudebugInterfaceFactory[static_cast<uint32_t>(EuDebugInterfaceType::maxValue)];
|
||||
|
||||
class EnableEuDebugInterface {
|
||||
public:
|
||||
EnableEuDebugInterface(EuDebugInterfaceType eudebugInterfaceType, const char *sysfsEntry, EuDebugInterfaceCreateFunctionType createFunc) {
|
||||
eudebugSysfsEntry[static_cast<uint32_t>(eudebugInterfaceType)] = sysfsEntry;
|
||||
eudebugInterfaceFactory[static_cast<uint32_t>(eudebugInterfaceType)] = createFunc;
|
||||
}
|
||||
};
|
||||
} // namespace NEO
|
||||
@@ -0,0 +1,211 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h"
|
||||
|
||||
#include "shared/source/os_interface/linux/xe/xedrm_prelim.h"
|
||||
|
||||
namespace NEO {
|
||||
uint32_t EuDebugInterfacePrelim::getParamValue(EuDebugParam param) const {
|
||||
switch (param) {
|
||||
case EuDebugParam::connect:
|
||||
return PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT;
|
||||
case EuDebugParam::euControlCmdInterruptAll:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL;
|
||||
case EuDebugParam::euControlCmdResume:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME;
|
||||
case EuDebugParam::euControlCmdStopped:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED;
|
||||
case EuDebugParam::eventBitCreate:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE;
|
||||
case EuDebugParam::eventBitDestroy:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY;
|
||||
case EuDebugParam::eventBitNeedAck:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK;
|
||||
case EuDebugParam::eventBitStateChange:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_STATE_CHANGE;
|
||||
case EuDebugParam::eventTypeEuAttention:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION;
|
||||
case EuDebugParam::eventTypeExecQueue:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE;
|
||||
case EuDebugParam::eventTypeMetadata:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA;
|
||||
case EuDebugParam::eventTypeOpen:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN;
|
||||
case EuDebugParam::eventTypePagefault:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT;
|
||||
case EuDebugParam::eventTypeRead:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_READ;
|
||||
case EuDebugParam::eventTypeVm:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_VM;
|
||||
case EuDebugParam::eventTypeVmBind:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND;
|
||||
case EuDebugParam::eventTypeVmBindOp:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP;
|
||||
case EuDebugParam::eventTypeVmBindOpMetadata:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA;
|
||||
case EuDebugParam::eventTypeVmBindUfence:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE;
|
||||
case EuDebugParam::eventVmBindFlagUfence:
|
||||
return PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE;
|
||||
case EuDebugParam::execQueueSetPropertyEuDebug:
|
||||
return PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG;
|
||||
case EuDebugParam::ioctlAckEvent:
|
||||
return PRELIM_DRM_XE_EUDEBUG_IOCTL_ACK_EVENT;
|
||||
case EuDebugParam::ioctlEuControl:
|
||||
return PRELIM_DRM_XE_EUDEBUG_IOCTL_EU_CONTROL;
|
||||
case EuDebugParam::ioctlReadEvent:
|
||||
return PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_EVENT;
|
||||
case EuDebugParam::ioctlReadMetadata:
|
||||
return PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_METADATA;
|
||||
case EuDebugParam::ioctlVmOpen:
|
||||
return PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN;
|
||||
case EuDebugParam::metadataCreate:
|
||||
return PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE;
|
||||
case EuDebugParam::metadataDestroy:
|
||||
return PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY;
|
||||
case EuDebugParam::metadataElfBinary:
|
||||
return PRELIM_DRM_XE_DEBUG_METADATA_ELF_BINARY;
|
||||
case EuDebugParam::metadataModuleArea:
|
||||
return PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA;
|
||||
case EuDebugParam::metadataProgramModule:
|
||||
return PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE;
|
||||
case EuDebugParam::metadataSbaArea:
|
||||
return PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA;
|
||||
case EuDebugParam::metadataSipArea:
|
||||
return PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA;
|
||||
case EuDebugParam::vmBindOpExtensionsAttachDebug:
|
||||
return PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static_assert(sizeof(EuDebugConnect) == sizeof(prelim_drm_xe_eudebug_connect));
|
||||
static_assert(offsetof(EuDebugConnect, extensions) == offsetof(prelim_drm_xe_eudebug_connect, extensions));
|
||||
static_assert(offsetof(EuDebugConnect, pid) == offsetof(prelim_drm_xe_eudebug_connect, pid));
|
||||
static_assert(offsetof(EuDebugConnect, flags) == offsetof(prelim_drm_xe_eudebug_connect, flags));
|
||||
static_assert(offsetof(EuDebugConnect, version) == offsetof(prelim_drm_xe_eudebug_connect, version));
|
||||
|
||||
static_assert(sizeof(EuDebugEvent) == sizeof(prelim_drm_xe_eudebug_event));
|
||||
static_assert(offsetof(EuDebugEvent, len) == offsetof(prelim_drm_xe_eudebug_event, len));
|
||||
static_assert(offsetof(EuDebugEvent, type) == offsetof(prelim_drm_xe_eudebug_event, type));
|
||||
static_assert(offsetof(EuDebugEvent, flags) == offsetof(prelim_drm_xe_eudebug_event, flags));
|
||||
static_assert(offsetof(EuDebugEvent, seqno) == offsetof(prelim_drm_xe_eudebug_event, seqno));
|
||||
static_assert(offsetof(EuDebugEvent, reserved) == offsetof(prelim_drm_xe_eudebug_event, reserved));
|
||||
|
||||
static_assert(sizeof(EuDebugEventEuAttention) == sizeof(prelim_drm_xe_eudebug_event_eu_attention));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, base) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, base));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, client_handle));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, execQueueHandle) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, exec_queue_handle));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, lrcHandle) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, lrc_handle));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, flags) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, flags));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, bitmaskSize) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, bitmask_size));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, bitmask) == offsetof(prelim_drm_xe_eudebug_event_eu_attention, bitmask));
|
||||
|
||||
static_assert(sizeof(EuDebugEventClient) == sizeof(prelim_drm_xe_eudebug_event_client));
|
||||
static_assert(offsetof(EuDebugEventClient, base) == offsetof(prelim_drm_xe_eudebug_event_client, base));
|
||||
static_assert(offsetof(EuDebugEventClient, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_client, client_handle));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVm) == sizeof(prelim_drm_xe_eudebug_event_vm));
|
||||
static_assert(offsetof(EuDebugEventVm, base) == offsetof(prelim_drm_xe_eudebug_event_vm, base));
|
||||
static_assert(offsetof(EuDebugEventVm, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_vm, client_handle));
|
||||
static_assert(offsetof(EuDebugEventVm, vmHandle) == offsetof(prelim_drm_xe_eudebug_event_vm, vm_handle));
|
||||
|
||||
static_assert(sizeof(EuDebugEventExecQueue) == sizeof(prelim_drm_xe_eudebug_event_exec_queue));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, base) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, base));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, client_handle));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, vmHandle) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, vm_handle));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, execQueueHandle) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, exec_queue_handle));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, engineClass) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, engine_class));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, width) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, width));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, lrcHandle) == offsetof(prelim_drm_xe_eudebug_event_exec_queue, lrc_handle));
|
||||
|
||||
static_assert(sizeof(EuDebugEventMetadata) == sizeof(prelim_drm_xe_eudebug_event_metadata));
|
||||
static_assert(offsetof(EuDebugEventMetadata, base) == offsetof(prelim_drm_xe_eudebug_event_metadata, base));
|
||||
static_assert(offsetof(EuDebugEventMetadata, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_metadata, client_handle));
|
||||
static_assert(offsetof(EuDebugEventMetadata, metadataHandle) == offsetof(prelim_drm_xe_eudebug_event_metadata, metadata_handle));
|
||||
static_assert(offsetof(EuDebugEventMetadata, type) == offsetof(prelim_drm_xe_eudebug_event_metadata, type));
|
||||
static_assert(offsetof(EuDebugEventMetadata, len) == offsetof(prelim_drm_xe_eudebug_event_metadata, len));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBind) == sizeof(prelim_drm_xe_eudebug_event_vm_bind));
|
||||
static_assert(offsetof(EuDebugEventVmBind, base) == offsetof(prelim_drm_xe_eudebug_event_vm_bind, base));
|
||||
static_assert(offsetof(EuDebugEventVmBind, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_vm_bind, client_handle));
|
||||
static_assert(offsetof(EuDebugEventVmBind, vmHandle) == offsetof(prelim_drm_xe_eudebug_event_vm_bind, vm_handle));
|
||||
static_assert(offsetof(EuDebugEventVmBind, flags) == offsetof(prelim_drm_xe_eudebug_event_vm_bind, flags));
|
||||
static_assert(offsetof(EuDebugEventVmBind, numBinds) == offsetof(prelim_drm_xe_eudebug_event_vm_bind, num_binds));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBindOp) == sizeof(prelim_drm_xe_eudebug_event_vm_bind_op));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, base) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op, base));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, vmBindRefSeqno) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op, vm_bind_ref_seqno));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, numExtensions) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op, num_extensions));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, addr) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op, addr));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, range) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op, range));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBindOpMetadata) == sizeof(prelim_drm_xe_eudebug_event_vm_bind_op_metadata));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, base) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op_metadata, base));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, vmBindOpRefSeqno) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op_metadata, vm_bind_op_ref_seqno));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, metadataHandle) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op_metadata, metadata_handle));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, metadataCookie) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_op_metadata, metadata_cookie));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBindUfence) == sizeof(prelim_drm_xe_eudebug_event_vm_bind_ufence));
|
||||
static_assert(offsetof(EuDebugEventVmBindUfence, base) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_ufence, base));
|
||||
static_assert(offsetof(EuDebugEventVmBindUfence, vmBindRefSeqno) == offsetof(prelim_drm_xe_eudebug_event_vm_bind_ufence, vm_bind_ref_seqno));
|
||||
|
||||
static_assert(sizeof(EuDebugReadMetadata) == sizeof(prelim_drm_xe_eudebug_read_metadata));
|
||||
static_assert(offsetof(EuDebugReadMetadata, clientHandle) == offsetof(prelim_drm_xe_eudebug_read_metadata, client_handle));
|
||||
static_assert(offsetof(EuDebugReadMetadata, metadataHandle) == offsetof(prelim_drm_xe_eudebug_read_metadata, metadata_handle));
|
||||
static_assert(offsetof(EuDebugReadMetadata, flags) == offsetof(prelim_drm_xe_eudebug_read_metadata, flags));
|
||||
static_assert(offsetof(EuDebugReadMetadata, reserved) == offsetof(prelim_drm_xe_eudebug_read_metadata, reserved));
|
||||
static_assert(offsetof(EuDebugReadMetadata, ptr) == offsetof(prelim_drm_xe_eudebug_read_metadata, ptr));
|
||||
static_assert(offsetof(EuDebugReadMetadata, size) == offsetof(prelim_drm_xe_eudebug_read_metadata, size));
|
||||
|
||||
static_assert(sizeof(EuDebugEuControl) == sizeof(prelim_drm_xe_eudebug_eu_control));
|
||||
static_assert(offsetof(EuDebugEuControl, clientHandle) == offsetof(prelim_drm_xe_eudebug_eu_control, client_handle));
|
||||
static_assert(offsetof(EuDebugEuControl, cmd) == offsetof(prelim_drm_xe_eudebug_eu_control, cmd));
|
||||
static_assert(offsetof(EuDebugEuControl, flags) == offsetof(prelim_drm_xe_eudebug_eu_control, flags));
|
||||
static_assert(offsetof(EuDebugEuControl, seqno) == offsetof(prelim_drm_xe_eudebug_eu_control, seqno));
|
||||
static_assert(offsetof(EuDebugEuControl, execQueueHandle) == offsetof(prelim_drm_xe_eudebug_eu_control, exec_queue_handle));
|
||||
static_assert(offsetof(EuDebugEuControl, lrcHandle) == offsetof(prelim_drm_xe_eudebug_eu_control, lrc_handle));
|
||||
static_assert(offsetof(EuDebugEuControl, reserved) == offsetof(prelim_drm_xe_eudebug_eu_control, reserved));
|
||||
static_assert(offsetof(EuDebugEuControl, bitmaskSize) == offsetof(prelim_drm_xe_eudebug_eu_control, bitmask_size));
|
||||
static_assert(offsetof(EuDebugEuControl, bitmaskPtr) == offsetof(prelim_drm_xe_eudebug_eu_control, bitmask_ptr));
|
||||
|
||||
static_assert(sizeof(EuDebugVmOpen) == sizeof(prelim_drm_xe_eudebug_vm_open));
|
||||
static_assert(offsetof(EuDebugVmOpen, extensions) == offsetof(prelim_drm_xe_eudebug_vm_open, extensions));
|
||||
static_assert(offsetof(EuDebugVmOpen, clientHandle) == offsetof(prelim_drm_xe_eudebug_vm_open, client_handle));
|
||||
static_assert(offsetof(EuDebugVmOpen, vmHandle) == offsetof(prelim_drm_xe_eudebug_vm_open, vm_handle));
|
||||
static_assert(offsetof(EuDebugVmOpen, flags) == offsetof(prelim_drm_xe_eudebug_vm_open, flags));
|
||||
static_assert(offsetof(EuDebugVmOpen, timeoutNs) == offsetof(prelim_drm_xe_eudebug_vm_open, timeout_ns));
|
||||
|
||||
static_assert(sizeof(EuDebugAckEvent) == sizeof(prelim_drm_xe_eudebug_ack_event));
|
||||
static_assert(offsetof(EuDebugAckEvent, type) == offsetof(prelim_drm_xe_eudebug_ack_event, type));
|
||||
static_assert(offsetof(EuDebugAckEvent, flags) == offsetof(prelim_drm_xe_eudebug_ack_event, flags));
|
||||
static_assert(offsetof(EuDebugAckEvent, seqno) == offsetof(prelim_drm_xe_eudebug_ack_event, seqno));
|
||||
|
||||
static_assert(sizeof(DebugMetadataCreate) == sizeof(prelim_drm_xe_debug_metadata_create));
|
||||
static_assert(offsetof(DebugMetadataCreate, extensions) == offsetof(prelim_drm_xe_debug_metadata_create, extensions));
|
||||
static_assert(offsetof(DebugMetadataCreate, type) == offsetof(prelim_drm_xe_debug_metadata_create, type));
|
||||
static_assert(offsetof(DebugMetadataCreate, userAddr) == offsetof(prelim_drm_xe_debug_metadata_create, user_addr));
|
||||
static_assert(offsetof(DebugMetadataCreate, len) == offsetof(prelim_drm_xe_debug_metadata_create, len));
|
||||
static_assert(offsetof(DebugMetadataCreate, metadataId) == offsetof(prelim_drm_xe_debug_metadata_create, metadata_id));
|
||||
|
||||
static_assert(sizeof(DebugMetadataDestroy) == sizeof(prelim_drm_xe_debug_metadata_destroy));
|
||||
static_assert(offsetof(DebugMetadataDestroy, extensions) == offsetof(prelim_drm_xe_debug_metadata_destroy, extensions));
|
||||
static_assert(offsetof(DebugMetadataDestroy, metadataId) == offsetof(prelim_drm_xe_debug_metadata_destroy, metadata_id));
|
||||
|
||||
static_assert(sizeof(XeUserExtension) == sizeof(drm_xe_user_extension));
|
||||
static_assert(offsetof(XeUserExtension, nextExtension) == offsetof(drm_xe_user_extension, next_extension));
|
||||
static_assert(offsetof(XeUserExtension, name) == offsetof(drm_xe_user_extension, name));
|
||||
static_assert(offsetof(XeUserExtension, pad) == offsetof(drm_xe_user_extension, pad));
|
||||
|
||||
static_assert(sizeof(VmBindOpExtAttachDebug) == sizeof(prelim_drm_xe_vm_bind_op_ext_attach_debug));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, base) == offsetof(prelim_drm_xe_vm_bind_op_ext_attach_debug, base));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, metadataId) == offsetof(prelim_drm_xe_vm_bind_op_ext_attach_debug, metadata_id));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, flags) == offsetof(prelim_drm_xe_vm_bind_op_ext_attach_debug, flags));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, cookie) == offsetof(prelim_drm_xe_vm_bind_op_ext_attach_debug, cookie));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, reserved) == offsetof(prelim_drm_xe_vm_bind_op_ext_attach_debug, reserved));
|
||||
} // namespace NEO
|
||||
@@ -0,0 +1,16 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
|
||||
namespace NEO {
|
||||
class EuDebugInterfacePrelim : public EuDebugInterface {
|
||||
public:
|
||||
static constexpr const char *sysFsXeEuDebugFile = "/device/prelim_enable_eudebug";
|
||||
uint32_t getParamValue(EuDebugParam param) const override;
|
||||
};
|
||||
} // namespace NEO
|
||||
@@ -0,0 +1,210 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h"
|
||||
|
||||
#include "third_party/uapi-eudebug/drm/xe_drm.h"
|
||||
namespace NEO {
|
||||
uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
|
||||
switch (param) {
|
||||
case EuDebugParam::connect:
|
||||
return DRM_IOCTL_XE_EUDEBUG_CONNECT;
|
||||
case EuDebugParam::euControlCmdInterruptAll:
|
||||
return DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL;
|
||||
case EuDebugParam::euControlCmdResume:
|
||||
return DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME;
|
||||
case EuDebugParam::euControlCmdStopped:
|
||||
return DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED;
|
||||
case EuDebugParam::eventBitCreate:
|
||||
return DRM_XE_EUDEBUG_EVENT_CREATE;
|
||||
case EuDebugParam::eventBitDestroy:
|
||||
return DRM_XE_EUDEBUG_EVENT_DESTROY;
|
||||
case EuDebugParam::eventBitNeedAck:
|
||||
return DRM_XE_EUDEBUG_EVENT_NEED_ACK;
|
||||
case EuDebugParam::eventBitStateChange:
|
||||
return DRM_XE_EUDEBUG_EVENT_STATE_CHANGE;
|
||||
case EuDebugParam::eventTypeEuAttention:
|
||||
return DRM_XE_EUDEBUG_EVENT_EU_ATTENTION;
|
||||
case EuDebugParam::eventTypeExecQueue:
|
||||
return DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE;
|
||||
case EuDebugParam::eventTypeMetadata:
|
||||
return DRM_XE_EUDEBUG_EVENT_METADATA;
|
||||
case EuDebugParam::eventTypeOpen:
|
||||
return DRM_XE_EUDEBUG_EVENT_OPEN;
|
||||
case EuDebugParam::eventTypePagefault:
|
||||
return DRM_XE_EUDEBUG_EVENT_PAGEFAULT;
|
||||
case EuDebugParam::eventTypeRead:
|
||||
return DRM_XE_EUDEBUG_EVENT_READ;
|
||||
case EuDebugParam::eventTypeVm:
|
||||
return DRM_XE_EUDEBUG_EVENT_VM;
|
||||
case EuDebugParam::eventTypeVmBind:
|
||||
return DRM_XE_EUDEBUG_EVENT_VM_BIND;
|
||||
case EuDebugParam::eventTypeVmBindOp:
|
||||
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP;
|
||||
case EuDebugParam::eventTypeVmBindOpMetadata:
|
||||
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA;
|
||||
case EuDebugParam::eventTypeVmBindUfence:
|
||||
return DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE;
|
||||
case EuDebugParam::eventVmBindFlagUfence:
|
||||
return DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE;
|
||||
case EuDebugParam::execQueueSetPropertyEuDebug:
|
||||
return DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG;
|
||||
case EuDebugParam::ioctlAckEvent:
|
||||
return DRM_XE_EUDEBUG_IOCTL_ACK_EVENT;
|
||||
case EuDebugParam::ioctlEuControl:
|
||||
return DRM_XE_EUDEBUG_IOCTL_EU_CONTROL;
|
||||
case EuDebugParam::ioctlReadEvent:
|
||||
return DRM_XE_EUDEBUG_IOCTL_READ_EVENT;
|
||||
case EuDebugParam::ioctlReadMetadata:
|
||||
return DRM_XE_EUDEBUG_IOCTL_READ_METADATA;
|
||||
case EuDebugParam::ioctlVmOpen:
|
||||
return DRM_XE_EUDEBUG_IOCTL_VM_OPEN;
|
||||
case EuDebugParam::metadataCreate:
|
||||
return DRM_IOCTL_XE_DEBUG_METADATA_CREATE;
|
||||
case EuDebugParam::metadataDestroy:
|
||||
return DRM_IOCTL_XE_DEBUG_METADATA_DESTROY;
|
||||
case EuDebugParam::metadataElfBinary:
|
||||
return DRM_XE_DEBUG_METADATA_ELF_BINARY;
|
||||
case EuDebugParam::metadataModuleArea:
|
||||
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA;
|
||||
case EuDebugParam::metadataProgramModule:
|
||||
return DRM_XE_DEBUG_METADATA_PROGRAM_MODULE;
|
||||
case EuDebugParam::metadataSbaArea:
|
||||
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA;
|
||||
case EuDebugParam::metadataSipArea:
|
||||
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA;
|
||||
case EuDebugParam::vmBindOpExtensionsAttachDebug:
|
||||
return XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static_assert(sizeof(EuDebugConnect) == sizeof(drm_xe_eudebug_connect));
|
||||
static_assert(offsetof(EuDebugConnect, extensions) == offsetof(drm_xe_eudebug_connect, extensions));
|
||||
static_assert(offsetof(EuDebugConnect, pid) == offsetof(drm_xe_eudebug_connect, pid));
|
||||
static_assert(offsetof(EuDebugConnect, flags) == offsetof(drm_xe_eudebug_connect, flags));
|
||||
static_assert(offsetof(EuDebugConnect, version) == offsetof(drm_xe_eudebug_connect, version));
|
||||
|
||||
static_assert(sizeof(EuDebugEvent) == sizeof(drm_xe_eudebug_event));
|
||||
static_assert(offsetof(EuDebugEvent, len) == offsetof(drm_xe_eudebug_event, len));
|
||||
static_assert(offsetof(EuDebugEvent, type) == offsetof(drm_xe_eudebug_event, type));
|
||||
static_assert(offsetof(EuDebugEvent, flags) == offsetof(drm_xe_eudebug_event, flags));
|
||||
static_assert(offsetof(EuDebugEvent, seqno) == offsetof(drm_xe_eudebug_event, seqno));
|
||||
static_assert(offsetof(EuDebugEvent, reserved) == offsetof(drm_xe_eudebug_event, reserved));
|
||||
|
||||
static_assert(sizeof(EuDebugEventEuAttention) == sizeof(drm_xe_eudebug_event_eu_attention));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, base) == offsetof(drm_xe_eudebug_event_eu_attention, base));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, clientHandle) == offsetof(drm_xe_eudebug_event_eu_attention, client_handle));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, execQueueHandle) == offsetof(drm_xe_eudebug_event_eu_attention, exec_queue_handle));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, lrcHandle) == offsetof(drm_xe_eudebug_event_eu_attention, lrc_handle));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, flags) == offsetof(drm_xe_eudebug_event_eu_attention, flags));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, bitmaskSize) == offsetof(drm_xe_eudebug_event_eu_attention, bitmask_size));
|
||||
static_assert(offsetof(EuDebugEventEuAttention, bitmask) == offsetof(drm_xe_eudebug_event_eu_attention, bitmask));
|
||||
|
||||
static_assert(sizeof(EuDebugEventClient) == sizeof(drm_xe_eudebug_event_client));
|
||||
static_assert(offsetof(EuDebugEventClient, base) == offsetof(drm_xe_eudebug_event_client, base));
|
||||
static_assert(offsetof(EuDebugEventClient, clientHandle) == offsetof(drm_xe_eudebug_event_client, client_handle));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVm) == sizeof(drm_xe_eudebug_event_vm));
|
||||
static_assert(offsetof(EuDebugEventVm, base) == offsetof(drm_xe_eudebug_event_vm, base));
|
||||
static_assert(offsetof(EuDebugEventVm, clientHandle) == offsetof(drm_xe_eudebug_event_vm, client_handle));
|
||||
static_assert(offsetof(EuDebugEventVm, vmHandle) == offsetof(drm_xe_eudebug_event_vm, vm_handle));
|
||||
|
||||
static_assert(sizeof(EuDebugEventExecQueue) == sizeof(drm_xe_eudebug_event_exec_queue));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, base) == offsetof(drm_xe_eudebug_event_exec_queue, base));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, clientHandle) == offsetof(drm_xe_eudebug_event_exec_queue, client_handle));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, vmHandle) == offsetof(drm_xe_eudebug_event_exec_queue, vm_handle));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, execQueueHandle) == offsetof(drm_xe_eudebug_event_exec_queue, exec_queue_handle));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, engineClass) == offsetof(drm_xe_eudebug_event_exec_queue, engine_class));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, width) == offsetof(drm_xe_eudebug_event_exec_queue, width));
|
||||
static_assert(offsetof(EuDebugEventExecQueue, lrcHandle) == offsetof(drm_xe_eudebug_event_exec_queue, lrc_handle));
|
||||
|
||||
static_assert(sizeof(EuDebugEventMetadata) == sizeof(drm_xe_eudebug_event_metadata));
|
||||
static_assert(offsetof(EuDebugEventMetadata, base) == offsetof(drm_xe_eudebug_event_metadata, base));
|
||||
static_assert(offsetof(EuDebugEventMetadata, clientHandle) == offsetof(drm_xe_eudebug_event_metadata, client_handle));
|
||||
static_assert(offsetof(EuDebugEventMetadata, metadataHandle) == offsetof(drm_xe_eudebug_event_metadata, metadata_handle));
|
||||
static_assert(offsetof(EuDebugEventMetadata, type) == offsetof(drm_xe_eudebug_event_metadata, type));
|
||||
static_assert(offsetof(EuDebugEventMetadata, len) == offsetof(drm_xe_eudebug_event_metadata, len));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBind) == sizeof(drm_xe_eudebug_event_vm_bind));
|
||||
static_assert(offsetof(EuDebugEventVmBind, base) == offsetof(drm_xe_eudebug_event_vm_bind, base));
|
||||
static_assert(offsetof(EuDebugEventVmBind, clientHandle) == offsetof(drm_xe_eudebug_event_vm_bind, client_handle));
|
||||
static_assert(offsetof(EuDebugEventVmBind, vmHandle) == offsetof(drm_xe_eudebug_event_vm_bind, vm_handle));
|
||||
static_assert(offsetof(EuDebugEventVmBind, flags) == offsetof(drm_xe_eudebug_event_vm_bind, flags));
|
||||
static_assert(offsetof(EuDebugEventVmBind, numBinds) == offsetof(drm_xe_eudebug_event_vm_bind, num_binds));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBindOp) == sizeof(drm_xe_eudebug_event_vm_bind_op));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, base) == offsetof(drm_xe_eudebug_event_vm_bind_op, base));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, vmBindRefSeqno) == offsetof(drm_xe_eudebug_event_vm_bind_op, vm_bind_ref_seqno));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, numExtensions) == offsetof(drm_xe_eudebug_event_vm_bind_op, num_extensions));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, addr) == offsetof(drm_xe_eudebug_event_vm_bind_op, addr));
|
||||
static_assert(offsetof(EuDebugEventVmBindOp, range) == offsetof(drm_xe_eudebug_event_vm_bind_op, range));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBindOpMetadata) == sizeof(drm_xe_eudebug_event_vm_bind_op_metadata));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, base) == offsetof(drm_xe_eudebug_event_vm_bind_op_metadata, base));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, vmBindOpRefSeqno) == offsetof(drm_xe_eudebug_event_vm_bind_op_metadata, vm_bind_op_ref_seqno));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, metadataHandle) == offsetof(drm_xe_eudebug_event_vm_bind_op_metadata, metadata_handle));
|
||||
static_assert(offsetof(EuDebugEventVmBindOpMetadata, metadataCookie) == offsetof(drm_xe_eudebug_event_vm_bind_op_metadata, metadata_cookie));
|
||||
|
||||
static_assert(sizeof(EuDebugEventVmBindUfence) == sizeof(drm_xe_eudebug_event_vm_bind_ufence));
|
||||
static_assert(offsetof(EuDebugEventVmBindUfence, base) == offsetof(drm_xe_eudebug_event_vm_bind_ufence, base));
|
||||
static_assert(offsetof(EuDebugEventVmBindUfence, vmBindRefSeqno) == offsetof(drm_xe_eudebug_event_vm_bind_ufence, vm_bind_ref_seqno));
|
||||
|
||||
static_assert(sizeof(EuDebugReadMetadata) == sizeof(drm_xe_eudebug_read_metadata));
|
||||
static_assert(offsetof(EuDebugReadMetadata, clientHandle) == offsetof(drm_xe_eudebug_read_metadata, client_handle));
|
||||
static_assert(offsetof(EuDebugReadMetadata, metadataHandle) == offsetof(drm_xe_eudebug_read_metadata, metadata_handle));
|
||||
static_assert(offsetof(EuDebugReadMetadata, flags) == offsetof(drm_xe_eudebug_read_metadata, flags));
|
||||
static_assert(offsetof(EuDebugReadMetadata, reserved) == offsetof(drm_xe_eudebug_read_metadata, reserved));
|
||||
static_assert(offsetof(EuDebugReadMetadata, ptr) == offsetof(drm_xe_eudebug_read_metadata, ptr));
|
||||
static_assert(offsetof(EuDebugReadMetadata, size) == offsetof(drm_xe_eudebug_read_metadata, size));
|
||||
|
||||
static_assert(sizeof(EuDebugEuControl) == sizeof(drm_xe_eudebug_eu_control));
|
||||
static_assert(offsetof(EuDebugEuControl, clientHandle) == offsetof(drm_xe_eudebug_eu_control, client_handle));
|
||||
static_assert(offsetof(EuDebugEuControl, cmd) == offsetof(drm_xe_eudebug_eu_control, cmd));
|
||||
static_assert(offsetof(EuDebugEuControl, flags) == offsetof(drm_xe_eudebug_eu_control, flags));
|
||||
static_assert(offsetof(EuDebugEuControl, seqno) == offsetof(drm_xe_eudebug_eu_control, seqno));
|
||||
static_assert(offsetof(EuDebugEuControl, execQueueHandle) == offsetof(drm_xe_eudebug_eu_control, exec_queue_handle));
|
||||
static_assert(offsetof(EuDebugEuControl, lrcHandle) == offsetof(drm_xe_eudebug_eu_control, lrc_handle));
|
||||
static_assert(offsetof(EuDebugEuControl, reserved) == offsetof(drm_xe_eudebug_eu_control, reserved));
|
||||
static_assert(offsetof(EuDebugEuControl, bitmaskSize) == offsetof(drm_xe_eudebug_eu_control, bitmask_size));
|
||||
static_assert(offsetof(EuDebugEuControl, bitmaskPtr) == offsetof(drm_xe_eudebug_eu_control, bitmask_ptr));
|
||||
|
||||
static_assert(sizeof(EuDebugVmOpen) == sizeof(drm_xe_eudebug_vm_open));
|
||||
static_assert(offsetof(EuDebugVmOpen, extensions) == offsetof(drm_xe_eudebug_vm_open, extensions));
|
||||
static_assert(offsetof(EuDebugVmOpen, clientHandle) == offsetof(drm_xe_eudebug_vm_open, client_handle));
|
||||
static_assert(offsetof(EuDebugVmOpen, vmHandle) == offsetof(drm_xe_eudebug_vm_open, vm_handle));
|
||||
static_assert(offsetof(EuDebugVmOpen, flags) == offsetof(drm_xe_eudebug_vm_open, flags));
|
||||
static_assert(offsetof(EuDebugVmOpen, timeoutNs) == offsetof(drm_xe_eudebug_vm_open, timeout_ns));
|
||||
|
||||
static_assert(sizeof(EuDebugAckEvent) == sizeof(drm_xe_eudebug_ack_event));
|
||||
static_assert(offsetof(EuDebugAckEvent, type) == offsetof(drm_xe_eudebug_ack_event, type));
|
||||
static_assert(offsetof(EuDebugAckEvent, flags) == offsetof(drm_xe_eudebug_ack_event, flags));
|
||||
static_assert(offsetof(EuDebugAckEvent, seqno) == offsetof(drm_xe_eudebug_ack_event, seqno));
|
||||
|
||||
static_assert(sizeof(DebugMetadataCreate) == sizeof(drm_xe_debug_metadata_create));
|
||||
static_assert(offsetof(DebugMetadataCreate, extensions) == offsetof(drm_xe_debug_metadata_create, extensions));
|
||||
static_assert(offsetof(DebugMetadataCreate, type) == offsetof(drm_xe_debug_metadata_create, type));
|
||||
static_assert(offsetof(DebugMetadataCreate, userAddr) == offsetof(drm_xe_debug_metadata_create, user_addr));
|
||||
static_assert(offsetof(DebugMetadataCreate, len) == offsetof(drm_xe_debug_metadata_create, len));
|
||||
static_assert(offsetof(DebugMetadataCreate, metadataId) == offsetof(drm_xe_debug_metadata_create, metadata_id));
|
||||
|
||||
static_assert(sizeof(DebugMetadataDestroy) == sizeof(drm_xe_debug_metadata_destroy));
|
||||
static_assert(offsetof(DebugMetadataDestroy, extensions) == offsetof(drm_xe_debug_metadata_destroy, extensions));
|
||||
static_assert(offsetof(DebugMetadataDestroy, metadataId) == offsetof(drm_xe_debug_metadata_destroy, metadata_id));
|
||||
|
||||
static_assert(sizeof(XeUserExtension) == sizeof(drm_xe_user_extension));
|
||||
static_assert(offsetof(XeUserExtension, nextExtension) == offsetof(drm_xe_user_extension, next_extension));
|
||||
static_assert(offsetof(XeUserExtension, name) == offsetof(drm_xe_user_extension, name));
|
||||
static_assert(offsetof(XeUserExtension, pad) == offsetof(drm_xe_user_extension, pad));
|
||||
|
||||
static_assert(sizeof(VmBindOpExtAttachDebug) == sizeof(drm_xe_vm_bind_op_ext_attach_debug));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, base) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, base));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, metadataId) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, metadata_id));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, flags) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, flags));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, cookie) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, cookie));
|
||||
static_assert(offsetof(VmBindOpExtAttachDebug, reserved) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, reserved));
|
||||
} // namespace NEO
|
||||
@@ -0,0 +1,19 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
|
||||
|
||||
namespace NEO {
|
||||
class EuDebugInterfaceUpstream : public EuDebugInterface {
|
||||
public:
|
||||
static constexpr const char *sysFsXeEuDebugFile = "/device/enable_eudebug";
|
||||
|
||||
uint32_t getParamValue(EuDebugParam param) const override;
|
||||
};
|
||||
|
||||
} // namespace NEO
|
||||
191
shared/source/os_interface/linux/xe/eudebug/eudebug_wrappers.h
Normal file
191
shared/source/os_interface/linux/xe/eudebug/eudebug_wrappers.h
Normal file
@@ -0,0 +1,191 @@
|
||||
/*
|
||||
* Copyright (C) 2024 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstdint>
|
||||
namespace NEO {
|
||||
struct EuDebugConnect {
|
||||
uint64_t extensions;
|
||||
uint64_t pid;
|
||||
uint32_t flags;
|
||||
uint32_t version;
|
||||
};
|
||||
|
||||
struct EuDebugEvent {
|
||||
uint32_t len;
|
||||
uint16_t type;
|
||||
uint16_t flags;
|
||||
uint64_t seqno;
|
||||
uint64_t reserved;
|
||||
};
|
||||
|
||||
struct EuDebugEventEuAttention {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t clientHandle;
|
||||
uint64_t execQueueHandle;
|
||||
uint64_t lrcHandle;
|
||||
uint32_t flags;
|
||||
uint32_t bitmaskSize;
|
||||
uint8_t bitmask[];
|
||||
};
|
||||
|
||||
struct EuDebugEventClient {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t clientHandle;
|
||||
};
|
||||
|
||||
struct EuDebugEventVm {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t clientHandle;
|
||||
uint64_t vmHandle;
|
||||
};
|
||||
|
||||
struct EuDebugEventExecQueue {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t clientHandle;
|
||||
uint64_t vmHandle;
|
||||
uint64_t execQueueHandle;
|
||||
uint32_t engineClass;
|
||||
uint32_t width;
|
||||
uint64_t lrcHandle[];
|
||||
};
|
||||
|
||||
struct EuDebugEventMetadata {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t clientHandle;
|
||||
uint64_t metadataHandle;
|
||||
uint64_t type;
|
||||
uint64_t len;
|
||||
};
|
||||
|
||||
struct EuDebugEventVmBind {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t clientHandle;
|
||||
uint64_t vmHandle;
|
||||
uint32_t flags;
|
||||
uint32_t numBinds;
|
||||
};
|
||||
|
||||
struct EuDebugEventVmBindOp {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t vmBindRefSeqno;
|
||||
uint64_t numExtensions;
|
||||
uint64_t addr;
|
||||
uint64_t range;
|
||||
};
|
||||
|
||||
struct EuDebugEventVmBindOpMetadata {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t vmBindOpRefSeqno;
|
||||
uint64_t metadataHandle;
|
||||
uint64_t metadataCookie;
|
||||
};
|
||||
|
||||
struct EuDebugEventVmBindUfence {
|
||||
struct EuDebugEvent base;
|
||||
uint64_t vmBindRefSeqno;
|
||||
};
|
||||
|
||||
struct EuDebugReadMetadata {
|
||||
uint64_t clientHandle;
|
||||
uint64_t metadataHandle;
|
||||
uint32_t flags;
|
||||
uint32_t reserved;
|
||||
uint64_t ptr;
|
||||
uint64_t size;
|
||||
};
|
||||
|
||||
struct EuDebugEuControl {
|
||||
uint64_t clientHandle;
|
||||
uint32_t cmd;
|
||||
uint32_t flags;
|
||||
uint64_t seqno;
|
||||
uint64_t execQueueHandle;
|
||||
uint64_t lrcHandle;
|
||||
uint32_t reserved;
|
||||
uint32_t bitmaskSize;
|
||||
uint64_t bitmaskPtr;
|
||||
};
|
||||
|
||||
struct EuDebugVmOpen {
|
||||
uint64_t extensions;
|
||||
uint64_t clientHandle;
|
||||
uint64_t vmHandle;
|
||||
uint64_t flags;
|
||||
uint64_t timeoutNs;
|
||||
};
|
||||
|
||||
struct EuDebugAckEvent {
|
||||
uint32_t type;
|
||||
uint32_t flags;
|
||||
uint64_t seqno;
|
||||
};
|
||||
|
||||
struct DebugMetadataCreate {
|
||||
uint64_t extensions;
|
||||
uint64_t type;
|
||||
uint64_t userAddr;
|
||||
uint64_t len;
|
||||
uint32_t metadataId;
|
||||
};
|
||||
|
||||
struct DebugMetadataDestroy {
|
||||
uint64_t extensions;
|
||||
uint32_t metadataId;
|
||||
};
|
||||
|
||||
struct XeUserExtension {
|
||||
uint64_t nextExtension;
|
||||
uint32_t name;
|
||||
uint32_t pad;
|
||||
};
|
||||
|
||||
struct VmBindOpExtAttachDebug {
|
||||
struct XeUserExtension base;
|
||||
uint64_t metadataId;
|
||||
uint64_t flags;
|
||||
uint64_t cookie;
|
||||
uint64_t reserved;
|
||||
};
|
||||
|
||||
enum class EuDebugParam {
|
||||
connect,
|
||||
euControlCmdInterruptAll,
|
||||
euControlCmdResume,
|
||||
euControlCmdStopped,
|
||||
eventBitCreate,
|
||||
eventBitDestroy,
|
||||
eventBitNeedAck,
|
||||
eventBitStateChange,
|
||||
eventTypeEuAttention = 20,
|
||||
eventTypeExecQueue,
|
||||
eventTypeMetadata,
|
||||
eventTypeOpen,
|
||||
eventTypePagefault,
|
||||
eventTypeRead,
|
||||
eventTypeVm,
|
||||
eventTypeVmBind,
|
||||
eventTypeVmBindOp,
|
||||
eventTypeVmBindOpMetadata,
|
||||
eventTypeVmBindUfence,
|
||||
eventVmBindFlagUfence,
|
||||
execQueueSetPropertyEuDebug,
|
||||
ioctlAckEvent,
|
||||
ioctlEuControl,
|
||||
ioctlReadEvent,
|
||||
ioctlReadMetadata,
|
||||
ioctlVmOpen,
|
||||
metadataCreate,
|
||||
metadataDestroy,
|
||||
metadataElfBinary,
|
||||
metadataModuleArea,
|
||||
metadataProgramModule,
|
||||
metadataSbaArea,
|
||||
metadataSipArea,
|
||||
vmBindOpExtensionsAttachDebug,
|
||||
};
|
||||
} // namespace NEO
|
||||
@@ -11,6 +11,7 @@
|
||||
#include "shared/source/os_interface/linux/drm_debug.h"
|
||||
#include "shared/source/os_interface/linux/engine_info.h"
|
||||
#include "shared/source/os_interface/linux/ioctl_helper.h"
|
||||
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
|
||||
|
||||
#include <bitset>
|
||||
#include <mutex>
|
||||
@@ -219,6 +220,7 @@ class IoctlHelperXe : public IoctlHelper {
|
||||
static_assert(sizeof(SupportedFeatures::flags) == sizeof(SupportedFeatures::allFlags), "");
|
||||
|
||||
void querySupportedFeatures();
|
||||
std::unique_ptr<EuDebugInterface> euDebugInterface;
|
||||
};
|
||||
|
||||
template <typename... XeLogArgs>
|
||||
|
||||
@@ -8,8 +8,6 @@
|
||||
#include "shared/source/os_interface/linux/drm_neo.h"
|
||||
#include "shared/source/os_interface/linux/xe/ioctl_helper_xe.h"
|
||||
|
||||
#include "debug_xe_includes.h"
|
||||
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
|
||||
@@ -21,11 +19,11 @@ namespace NEO {
|
||||
unsigned int IoctlHelperXe::getIoctlRequestValueDebugger(DrmIoctl ioctlRequest) const {
|
||||
switch (ioctlRequest) {
|
||||
case DrmIoctl::debuggerOpen:
|
||||
RETURN_ME(DRM_IOCTL_XE_EUDEBUG_CONNECT);
|
||||
return euDebugInterface->getParamValue(EuDebugParam::connect);
|
||||
case DrmIoctl::metadataCreate:
|
||||
RETURN_ME(DRM_IOCTL_XE_DEBUG_METADATA_CREATE);
|
||||
return euDebugInterface->getParamValue(EuDebugParam::metadataCreate);
|
||||
case DrmIoctl::metadataDestroy:
|
||||
RETURN_ME(DRM_IOCTL_XE_DEBUG_METADATA_DESTROY);
|
||||
return euDebugInterface->getParamValue(EuDebugParam::metadataDestroy);
|
||||
|
||||
default:
|
||||
UNRECOVERABLE_IF(true);
|
||||
@@ -34,7 +32,7 @@ unsigned int IoctlHelperXe::getIoctlRequestValueDebugger(DrmIoctl ioctlRequest)
|
||||
}
|
||||
|
||||
int IoctlHelperXe::debuggerOpenIoctl(DrmIoctl request, void *arg) {
|
||||
drm_xe_eudebug_connect *connect = static_cast<drm_xe_eudebug_connect *>(arg);
|
||||
EuDebugConnect *connect = static_cast<EuDebugConnect *>(arg);
|
||||
auto ret = IoctlHelper::ioctl(request, arg);
|
||||
xeLog(" -> IoctlHelperXe::ioctl debuggerOpen pid=%llu r=%d\n",
|
||||
connect->pid, ret);
|
||||
@@ -42,103 +40,95 @@ int IoctlHelperXe::debuggerOpenIoctl(DrmIoctl request, void *arg) {
|
||||
}
|
||||
|
||||
int IoctlHelperXe::debuggerMetadataCreateIoctl(DrmIoctl request, void *arg) {
|
||||
drm_xe_debug_metadata_create *metadata = static_cast<drm_xe_debug_metadata_create *>(arg);
|
||||
DebugMetadataCreate *metadata = static_cast<DebugMetadataCreate *>(arg);
|
||||
auto ret = IoctlHelper::ioctl(request, arg);
|
||||
xeLog(" -> IoctlHelperXe::ioctl metadataCreate type=%llu user_addr=%uul len=%uul\n id=%uul ret=%d, errno=%d\n",
|
||||
metadata->type, metadata->user_addr, metadata->len, metadata->metadata_id, ret, errno);
|
||||
metadata->type, metadata->userAddr, metadata->len, metadata->metadataId, ret, errno);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int IoctlHelperXe::debuggerMetadataDestroyIoctl(DrmIoctl request, void *arg) {
|
||||
drm_xe_debug_metadata_destroy *metadata = static_cast<drm_xe_debug_metadata_destroy *>(arg);
|
||||
DebugMetadataDestroy *metadata = static_cast<DebugMetadataDestroy *>(arg);
|
||||
auto ret = IoctlHelper::ioctl(request, arg);
|
||||
xeLog(" -> IoctlHelperXe::ioctl metadataDestroy id=%llu r=%d\n",
|
||||
metadata->metadata_id, ret);
|
||||
metadata->metadataId, ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int IoctlHelperXe::getEudebugExtProperty() {
|
||||
return DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG;
|
||||
return euDebugInterface->getParamValue(EuDebugParam::execQueueSetPropertyEuDebug);
|
||||
}
|
||||
|
||||
int IoctlHelperXe::getEuDebugSysFsEnable() {
|
||||
char enabledEuDebug = '0';
|
||||
std::string sysFsPciPath = drm.getSysFsPciPath();
|
||||
std::string euDebugPath = sysFsPciPath + sysFsXeEuDebugFile;
|
||||
|
||||
FILE *fileDescriptor = IoFunctions::fopenPtr(euDebugPath.c_str(), "r");
|
||||
if (fileDescriptor) {
|
||||
[[maybe_unused]] auto bytesRead = IoFunctions::freadPtr(&enabledEuDebug, 1, 1, fileDescriptor);
|
||||
IoFunctions::fclosePtr(fileDescriptor);
|
||||
}
|
||||
|
||||
return enabledEuDebug - '0';
|
||||
euDebugInterface = EuDebugInterface::create(drm.getSysFsPciPath());
|
||||
return euDebugInterface != nullptr ? 1 : 0;
|
||||
}
|
||||
|
||||
uint32_t IoctlHelperXe::registerResource(DrmResourceClass classType, const void *data, size_t size) {
|
||||
drm_xe_debug_metadata_create metadata = {};
|
||||
DebugMetadataCreate metadata = {};
|
||||
if (classType == DrmResourceClass::elf) {
|
||||
metadata.type = DRM_XE_DEBUG_METADATA_ELF_BINARY;
|
||||
metadata.user_addr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.type = euDebugInterface->getParamValue(EuDebugParam::metadataElfBinary);
|
||||
metadata.userAddr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.len = size;
|
||||
} else if (classType == DrmResourceClass::l0ZebinModule) {
|
||||
metadata.type = DRM_XE_DEBUG_METADATA_PROGRAM_MODULE;
|
||||
metadata.user_addr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.type = euDebugInterface->getParamValue(EuDebugParam::metadataProgramModule);
|
||||
metadata.userAddr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.len = size;
|
||||
} else if (classType == DrmResourceClass::contextSaveArea) {
|
||||
metadata.type = WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA;
|
||||
metadata.user_addr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.type = euDebugInterface->getParamValue(EuDebugParam::metadataSipArea);
|
||||
metadata.userAddr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.len = size;
|
||||
} else if (classType == DrmResourceClass::sbaTrackingBuffer) {
|
||||
metadata.type = WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA;
|
||||
metadata.user_addr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.type = euDebugInterface->getParamValue(EuDebugParam::metadataSbaArea);
|
||||
metadata.userAddr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.len = size;
|
||||
} else if (classType == DrmResourceClass::moduleHeapDebugArea) {
|
||||
metadata.type = WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA;
|
||||
metadata.user_addr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.type = euDebugInterface->getParamValue(EuDebugParam::metadataModuleArea);
|
||||
metadata.userAddr = reinterpret_cast<uintptr_t>(data);
|
||||
metadata.len = size;
|
||||
} else {
|
||||
UNRECOVERABLE_IF(true);
|
||||
}
|
||||
[[maybe_unused]] auto retVal = IoctlHelperXe::ioctl(DrmIoctl::metadataCreate, &metadata);
|
||||
PRINT_DEBUGGER_INFO_LOG("DRM_XE_DEBUG_METADATA_CREATE: type=%llu user_addr=%llu len=%llu id=%llu\n",
|
||||
metadata.type, metadata.user_addr, metadata.len, metadata.metadata_id);
|
||||
metadata.type, metadata.userAddr, metadata.len, metadata.metadataId);
|
||||
DEBUG_BREAK_IF(retVal != 0);
|
||||
return metadata.metadata_id;
|
||||
return metadata.metadataId;
|
||||
}
|
||||
|
||||
void IoctlHelperXe::unregisterResource(uint32_t handle) {
|
||||
drm_xe_debug_metadata_destroy metadata = {};
|
||||
metadata.metadata_id = handle;
|
||||
DebugMetadataDestroy metadata = {};
|
||||
metadata.metadataId = handle;
|
||||
[[maybe_unused]] auto retVal = IoctlHelperXe::ioctl(DrmIoctl::metadataDestroy, &metadata);
|
||||
DEBUG_BREAK_IF(retVal != 0);
|
||||
PRINT_DEBUGGER_INFO_LOG("DRM_XE_DEBUG_METADATA_DESTROY: id=%llu\n", metadata.metadata_id);
|
||||
PRINT_DEBUGGER_INFO_LOG("DRM_XE_DEBUG_METADATA_DESTROY: id=%llu\n", metadata.metadataId);
|
||||
}
|
||||
|
||||
std::unique_ptr<uint8_t[]> IoctlHelperXe::prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) {
|
||||
|
||||
static_assert(std::is_trivially_destructible_v<drm_xe_vm_bind_op_ext_attach_debug>,
|
||||
static_assert(std::is_trivially_destructible_v<VmBindOpExtAttachDebug>,
|
||||
"Storage must be allowed to be reused without calling the destructor!");
|
||||
|
||||
static_assert(alignof(drm_xe_vm_bind_op_ext_attach_debug) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__,
|
||||
static_assert(alignof(VmBindOpExtAttachDebug) <= __STDCPP_DEFAULT_NEW_ALIGNMENT__,
|
||||
"Alignment of a buffer returned via new[] operator must allow storing the required type!");
|
||||
|
||||
xeLog(" -> IoctlHelperXe::%s\n", __FUNCTION__);
|
||||
const auto bufferSize{sizeof(drm_xe_vm_bind_op_ext_attach_debug) * bindExtHandles.size()};
|
||||
const auto bufferSize{sizeof(VmBindOpExtAttachDebug) * bindExtHandles.size()};
|
||||
std::unique_ptr<uint8_t[]> extensionsBuffer{new uint8_t[bufferSize]};
|
||||
|
||||
auto extensions = new (extensionsBuffer.get()) drm_xe_vm_bind_op_ext_attach_debug[bindExtHandles.size()];
|
||||
auto extensions = new (extensionsBuffer.get()) VmBindOpExtAttachDebug[bindExtHandles.size()];
|
||||
std::memset(extensionsBuffer.get(), 0, bufferSize);
|
||||
|
||||
extensions[0].metadata_id = bindExtHandles[0];
|
||||
extensions[0].base.name = XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
|
||||
extensions[0].metadataId = bindExtHandles[0];
|
||||
extensions[0].base.name = euDebugInterface->getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug);
|
||||
|
||||
for (size_t i = 1; i < bindExtHandles.size(); i++) {
|
||||
extensions[i - 1].base.next_extension = reinterpret_cast<uint64_t>(&extensions[i]);
|
||||
extensions[i].metadata_id = bindExtHandles[i];
|
||||
extensions[i].base.name = XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
|
||||
extensions[i - 1].base.nextExtension = reinterpret_cast<uint64_t>(&extensions[i]);
|
||||
extensions[i].metadataId = bindExtHandles[i];
|
||||
extensions[i].base.name = euDebugInterface->getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug);
|
||||
;
|
||||
}
|
||||
return extensionsBuffer;
|
||||
}
|
||||
|
||||
} // namespace NEO
|
||||
} // namespace NEO
|
||||
|
||||
Reference in New Issue
Block a user