intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-18 05:52:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature: add eudebug interface class

Browse Source 
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
2024-12-12 13:26:54 +00:00
committed by Compute-Runtime-Automation
parent 49c028858a
commit 8f7bacdd95
42 changed files with 2134 additions and 1144 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
BUILD.md
View File

@@ -72,7 +72,7 @@ NEO Driver has build options to enable support for EU Debugging with XeKMD. Kern
To build NEO with support for this feature follow above steps with these additional cmake options added to step 6.
` -DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=1 -DNEO_ENABLE_XE_PRELIM_DETECTION=0 `
` -DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=1 -DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=1`
___(*) Other names and brands may be claimed as property of others.___

20
CMakeLists.txt
View File

@@ -564,7 +564,7 @@ if(WIN32 OR NOT DISABLE_WDDM_LINUX)
endif()
if(UNIX)
# prelim headers detection
# i915 prelim detection
if(NOT ("${BRANCH_TYPE}" STREQUAL ""))
set(NEO_ENABLE_I915_PRELIM_DETECTION TRUE)
elseif(NOT DEFINED NEO_ENABLE_I915_PRELIM_DETECTION)
@@ -572,6 +572,7 @@ if(UNIX)
endif()
message(STATUS "i915 prelim headers detection: ${NEO_ENABLE_I915_PRELIM_DETECTION}")
# xe prelim detection
if(NOT ("${BRANCH_TYPE}" STREQUAL ""))
set(NEO_ENABLE_XE_PRELIM_DETECTION TRUE)
elseif(NOT DEFINED NEO_ENABLE_XE_PRELIM_DETECTION)
@@ -579,7 +580,7 @@ if(UNIX)
endif()
message(STATUS "xe prelim headers detection: ${NEO_ENABLE_XE_PRELIM_DETECTION}")
# drm-xe support
# xe eudebug support
if(NOT ("${BRANCH_TYPE}" STREQUAL ""))
set(NEO_ENABLE_XE_EU_DEBUG_SUPPORT TRUE)
elseif(NOT DEFINED NEO_ENABLE_XE_EU_DEBUG_SUPPORT)
@@ -587,13 +588,16 @@ if(UNIX)
endif()
message(STATUS "Xe EU Debug support: ${NEO_ENABLE_XE_EU_DEBUG_SUPPORT}")
if((NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM OR NOT NEO_ENABLE_XE_PRELIM_DETECTION) AND ("${BRANCH_TYPE}" STREQUAL ""))
get_filename_component(XE_DEBUG_INCLUDE_DIR "${NEO_SOURCE_DIR}/shared/source/debugger/linux/" ABSOLUTE)
else()
get_filename_component(XE_DEBUG_INCLUDE_DIR "${NEO_SOURCE_DIR}/shared/source/debugger/linux/prelim" ABSOLUTE)
if(NEO_ENABLE_XE_EU_DEBUG_SUPPORT)
# xe eudebug exp upstream support
if(NOT ("${BRANCH_TYPE}" STREQUAL ""))
set(NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM TRUE)
elseif(NOT DEFINED NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM)
set(NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM FALSE)
endif()
message(STATUS "Xe EU Debug support for upstream: ${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM}")
message(STATUS "Xe EU Debug support for prelim: ${NEO_ENABLE_XE_PRELIM_DETECTION}")
endif()
include_directories(BEFORE ${XE_DEBUG_INCLUDE_DIR})
endif()
include(cmake${BRANCH_DIR_SUFFIX}/find_drm.cmake)

13
level_zero/core/source/dll/linux/CMakeLists.txt
View File

@@ -11,6 +11,19 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${NEO_SOURCE_DIR}/level_zero/tools/source/debug/linux/xe/debug_session_xe_helper.cpp
)
if(NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM)
target_sources(${TARGET_NAME_L0}
PRIVATE
${NEO_SOURCE_DIR}/shared/source/os_interface/linux/xe/eudebug/enable_eudebug_interface_upstream.cpp
)
endif()
if(NEO_ENABLE_XE_PRELIM_DETECTION)
target_sources(${TARGET_NAME_L0}
PRIVATE
${NEO_SOURCE_DIR}/shared/source/os_interface/linux/xe/eudebug/enable_eudebug_interface_prelim.cpp
)
endif()
endif()
if(NEO_ENABLE_I915_PRELIM_DETECTION)

7
level_zero/tools/source/debug/linux/drm_helper.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -20,6 +20,11 @@ int DrmHelper::ioctl(Device *device, NEO::DrmIoctl request, void *arg) {
return drm->getIoctlHelper()->ioctl(request, arg);
}
std::string DrmHelper::getSysFsPciPath(Device *device) {
auto drm = device->getOsInterface().getDriverModel()->as<NEO::Drm>();
return drm->getSysFsPciPath();
}
int DrmHelper::getErrno(Device *device) {
auto drm = device->getOsInterface().getDriverModel()->as<NEO::Drm>();
return drm->getErrno();

6
level_zero/tools/source/debug/linux/drm_helper.h
View File

@@ -1,14 +1,15 @@
/*
* Copyright (C) 2022-2023 Intel Corporation
* Copyright (C) 2022-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/helpers/topology_map.h"
#include <string>
namespace NEO {
struct EngineClassInstance;
enum class DrmIoctl;
@@ -21,6 +22,7 @@ namespace L0 {
struct Device;
struct DrmHelper {
static int ioctl(Device *device, NEO::DrmIoctl request, void *arg);
static std::string getSysFsPciPath(Device *device);
static int getErrno(Device *device);
static uint32_t getEngineTileIndex(Device *device, const NEO::EngineClassInstance &engine);
static const NEO::EngineClassInstance *getEngineInstance(Device *device, uint32_t tile, aub_stream::EngineType engineType);

404
level_zero/tools/source/debug/linux/xe/debug_session.cpp
View File

@@ -27,10 +27,13 @@ static DebugSessionLinuxPopulateFactory<DEBUG_SESSION_LINUX_TYPE_XE, DebugSessio
DebugSession *createDebugSessionHelperXe(const zet_debug_config_t &config, Device *device, int debugFd, void *params);
DebugSessionLinuxXe::DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, void *params) : DebugSessionLinux(config, device, debugFd) {
ioctlHandler.reset(new IoctlHandlerXe);
if (params) {
this->xeDebuggerVersion = reinterpret_cast<drm_xe_eudebug_connect *>(params)->version;
auto sysFsPciPath = DrmHelper::getSysFsPciPath(device);
euDebugInterface = NEO::EuDebugInterface::create(sysFsPciPath);
if (euDebugInterface) {
ioctlHandler.reset(new IoctlHandlerXe(*euDebugInterface));
if (params) {
this->xeDebuggerVersion = reinterpret_cast<NEO::EuDebugConnect *>(params)->version;
}
}
};
DebugSessionLinuxXe::~DebugSessionLinuxXe() {
@@ -42,7 +45,7 @@ DebugSessionLinuxXe::~DebugSessionLinuxXe() {
DebugSession *DebugSessionLinuxXe::createLinuxSession(const zet_debug_config_t &config, Device *device, ze_result_t &result, bool isRootAttach) {
drm_xe_eudebug_connect open = {
NEO::EuDebugConnect open = {
.extensions = 0,
.pid = config.pid,
.flags = 0,
@@ -68,7 +71,7 @@ bool DebugSessionLinuxXe::handleInternalEvent() {
return false;
}
auto debugEvent = reinterpret_cast<drm_xe_eudebug_event *>(eventMemory.get());
auto debugEvent = reinterpret_cast<NEO::EuDebugEvent *>(eventMemory.get());
handleEvent(debugEvent);
return true;
}
@@ -127,10 +130,10 @@ void DebugSessionLinuxXe::readInternalEventsAsync() {
ze_result_t result = ZE_RESULT_SUCCESS;
uint8_t maxEventBuffer[sizeof(drm_xe_eudebug_event) + maxEventSize];
auto event = reinterpret_cast<drm_xe_eudebug_event *>(maxEventBuffer);
uint8_t maxEventBuffer[sizeof(NEO::EuDebugEvent) + maxEventSize];
auto event = reinterpret_cast<NEO::EuDebugEvent *>(maxEventBuffer);
event->len = maxEventSize;
event->type = DRM_XE_EUDEBUG_EVENT_READ;
event->type = euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeRead);
event->flags = 0;
result = readEventImp(event);
@@ -154,65 +157,64 @@ int DebugSessionLinuxXe::ioctl(unsigned long request, void *arg) {
return ioctlHandler->ioctl(fd, request, arg);
}
ze_result_t DebugSessionLinuxXe::readEventImp(drm_xe_eudebug_event *drmDebugEvent) {
auto ret = ioctl(DRM_XE_EUDEBUG_IOCTL_READ_EVENT, drmDebugEvent);
ze_result_t DebugSessionLinuxXe::readEventImp(NEO::EuDebugEvent *drmDebugEvent) {
auto ret = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlReadEvent), drmDebugEvent);
if (ret != 0) {
PRINT_DEBUGGER_ERROR_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT failed: retCode: %d errno = %d\n", ret, errno);
return ZE_RESULT_NOT_READY;
} else if (drmDebugEvent->flags & ~static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_CREATE | DRM_XE_EUDEBUG_EVENT_DESTROY | DRM_XE_EUDEBUG_EVENT_STATE_CHANGE | DRM_XE_EUDEBUG_EVENT_NEED_ACK)) {
} else if (drmDebugEvent->flags & ~static_cast<uint32_t>(
euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate) |
euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy) |
euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitStateChange) |
euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitNeedAck))) {
PRINT_DEBUGGER_ERROR_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT unsupported flag = %d\n", (int)drmDebugEvent->flags);
return ZE_RESULT_ERROR_UNKNOWN;
}
return ZE_RESULT_SUCCESS;
}
void DebugSessionLinuxXe::handleEvent(drm_xe_eudebug_event *event) {
void DebugSessionLinuxXe::handleEvent(NEO::EuDebugEvent *event) {
auto type = event->type;
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type = %u flags = %u seqno = %llu len = %lu",
(uint16_t)event->type, (uint16_t)event->flags, (uint64_t)event->seqno, (uint32_t)event->len);
switch (type) {
case DRM_XE_EUDEBUG_EVENT_OPEN: {
auto clientEvent = reinterpret_cast<drm_xe_eudebug_event_client *>(event);
if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeOpen)) {
auto clientEvent = reinterpret_cast<NEO::EuDebugEventClient *>(event);
if (event->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
DEBUG_BREAK_IF(clientHandleToConnection.find(clientEvent->client_handle) != clientHandleToConnection.end());
clientHandleToConnection[clientEvent->client_handle].reset(new ClientConnectionXe);
clientHandleToConnection[clientEvent->client_handle]->client = *clientEvent;
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate)) {
DEBUG_BREAK_IF(clientHandleToConnection.find(clientEvent->clientHandle) != clientHandleToConnection.end());
clientHandleToConnection[clientEvent->clientHandle].reset(new ClientConnectionXe);
clientHandleToConnection[clientEvent->clientHandle]->client = *clientEvent;
}
if (event->flags & DRM_XE_EUDEBUG_EVENT_DESTROY) {
clientHandleClosed = clientEvent->client_handle;
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy)) {
clientHandleClosed = clientEvent->clientHandle;
}
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_OPEN client.handle = %llu\n",
(uint64_t)clientEvent->client_handle);
(uint64_t)clientEvent->clientHandle);
} break;
case DRM_XE_EUDEBUG_EVENT_VM: {
drm_xe_eudebug_event_vm *vm = reinterpret_cast<drm_xe_eudebug_event_vm *>(event);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVm)) {
NEO::EuDebugEventVm *vm = reinterpret_cast<NEO::EuDebugEventVm *>(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_VM client_handle = %llu vm_handle = %llu\n",
(uint64_t)vm->client_handle, (uint64_t)vm->vm_handle);
(uint64_t)vm->clientHandle, (uint64_t)vm->vmHandle);
if (event->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
UNRECOVERABLE_IF(clientHandleToConnection.find(vm->client_handle) == clientHandleToConnection.end());
clientHandleToConnection[vm->client_handle]->vmIds.emplace(static_cast<uint64_t>(vm->vm_handle));
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate)) {
UNRECOVERABLE_IF(clientHandleToConnection.find(vm->clientHandle) == clientHandleToConnection.end());
clientHandleToConnection[vm->clientHandle]->vmIds.emplace(static_cast<uint64_t>(vm->vmHandle));
}
if (event->flags & DRM_XE_EUDEBUG_EVENT_DESTROY) {
UNRECOVERABLE_IF(clientHandleToConnection.find(vm->client_handle) == clientHandleToConnection.end());
clientHandleToConnection[vm->client_handle]->vmIds.erase(static_cast<uint64_t>(vm->vm_handle));
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy)) {
UNRECOVERABLE_IF(clientHandleToConnection.find(vm->clientHandle) == clientHandleToConnection.end());
clientHandleToConnection[vm->clientHandle]->vmIds.erase(static_cast<uint64_t>(vm->vmHandle));
}
} break;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeExecQueue)) {
NEO::EuDebugEventExecQueue *execQueue = reinterpret_cast<NEO::EuDebugEventExecQueue *>(event);
case DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE: {
drm_xe_eudebug_event_exec_queue *execQueue = reinterpret_cast<drm_xe_eudebug_event_exec_queue *>(event);
if (event->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
UNRECOVERABLE_IF(clientHandleToConnection.find(execQueue->client_handle) == clientHandleToConnection.end());
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate)) {
UNRECOVERABLE_IF(clientHandleToConnection.find(execQueue->clientHandle) == clientHandleToConnection.end());
if (!processEntryEventGenerated) {
zet_debug_event_t debugEvent = {};
@@ -221,22 +223,22 @@ void DebugSessionLinuxXe::handleEvent(drm_xe_eudebug_event *event) {
processEntryEventGenerated = true;
}
std::lock_guard<std::mutex> lock(asyncThreadMutex);
clientHandleToConnection[execQueue->client_handle]->execQueues[execQueue->exec_queue_handle].vmHandle = execQueue->vm_handle;
clientHandleToConnection[execQueue->client_handle]->execQueues[execQueue->exec_queue_handle].engineClass = execQueue->engine_class;
clientHandleToConnection[execQueue->clientHandle]->execQueues[execQueue->execQueueHandle].vmHandle = execQueue->vmHandle;
clientHandleToConnection[execQueue->clientHandle]->execQueues[execQueue->execQueueHandle].engineClass = execQueue->engineClass;
for (uint16_t idx = 0; idx < execQueue->width; idx++) {
uint64_t lrcHandle = execQueue->lrc_handle[idx];
clientHandleToConnection[execQueue->client_handle]->execQueues[execQueue->exec_queue_handle].lrcHandles.push_back(lrcHandle);
clientHandleToConnection[execQueue->client_handle]->lrcHandleToVmHandle[lrcHandle] = execQueue->vm_handle;
uint64_t lrcHandle = execQueue->lrcHandle[idx];
clientHandleToConnection[execQueue->clientHandle]->execQueues[execQueue->execQueueHandle].lrcHandles.push_back(lrcHandle);
clientHandleToConnection[execQueue->clientHandle]->lrcHandleToVmHandle[lrcHandle] = execQueue->vmHandle;
}
}
if (event->flags & DRM_XE_EUDEBUG_EVENT_DESTROY) {
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy)) {
{
std::lock_guard<std::mutex> lock(asyncThreadMutex);
for (uint16_t idx = 0; idx < execQueue->width; idx++) {
clientHandleToConnection[execQueue->client_handle]->lrcHandleToVmHandle.erase(execQueue->lrc_handle[idx]);
clientHandleToConnection[execQueue->clientHandle]->lrcHandleToVmHandle.erase(execQueue->lrcHandle[idx]);
}
clientHandleToConnection[execQueue->client_handle]->execQueues.erase(execQueue->exec_queue_handle);
clientHandleToConnection[execQueue->clientHandle]->execQueues.erase(execQueue->execQueueHandle);
}
{
bool lastExecQueue = true;
@@ -256,108 +258,96 @@ void DebugSessionLinuxXe::handleEvent(drm_xe_eudebug_event *event) {
}
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE client_handle = %llu vm_handle = %llu exec_queue_handle = %llu engine_class = %u\n",
(uint64_t)execQueue->client_handle, (uint64_t)execQueue->vm_handle,
(uint64_t)execQueue->exec_queue_handle, (uint16_t)execQueue->engine_class);
} break;
case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION: {
drm_xe_eudebug_event_eu_attention *attention = reinterpret_cast<drm_xe_eudebug_event_eu_attention *>(event);
(uint64_t)execQueue->clientHandle, (uint64_t)execQueue->vmHandle,
(uint64_t)execQueue->execQueueHandle, (uint16_t)execQueue->engineClass);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeEuAttention)) {
NEO::EuDebugEventEuAttention *attention = reinterpret_cast<NEO::EuDebugEventEuAttention *>(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_EU_ATTENTION client_handle = %llu flags = %llu bitmask_size = %lu exec_queue_handle = %llu lrc_handle = %llu\n",
(uint64_t)attention->client_handle, (uint64_t)attention->flags,
(uint32_t)attention->bitmask_size, uint64_t(attention->exec_queue_handle), uint64_t(attention->lrc_handle));
(uint64_t)attention->clientHandle, (uint64_t)attention->flags,
(uint32_t)attention->bitmaskSize, uint64_t(attention->execQueueHandle), uint64_t(attention->lrcHandle));
if (attention->base.seqno < newestAttSeqNo.load()) {
PRINT_DEBUGGER_INFO_LOG("Dropping stale ATT event seqno=%llu\n", (uint64_t)attention->base.seqno);
} else {
handleAttentionEvent(attention);
}
} break;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBind)) {
case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
drm_xe_eudebug_event_vm_bind *vmBind = reinterpret_cast<drm_xe_eudebug_event_vm_bind *>(event);
UNRECOVERABLE_IF(clientHandleToConnection.find(vmBind->client_handle) == clientHandleToConnection.end());
NEO::EuDebugEventVmBind *vmBind = reinterpret_cast<NEO::EuDebugEventVmBind *>(event);
UNRECOVERABLE_IF(clientHandleToConnection.find(vmBind->clientHandle) == clientHandleToConnection.end());
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_VM_BIND client_handle = %llu vm_handle = %llu num_binds = %llu vmBindflag=%lu\n",
static_cast<uint64_t>(vmBind->client_handle), static_cast<uint64_t>(vmBind->vm_handle),
static_cast<uint64_t>(vmBind->num_binds), static_cast<uint32_t>(vmBind->flags));
static_cast<uint64_t>(vmBind->clientHandle), static_cast<uint64_t>(vmBind->vmHandle),
static_cast<uint64_t>(vmBind->numBinds), static_cast<uint32_t>(vmBind->flags));
auto &connection = clientHandleToConnection[vmBind->client_handle];
auto &connection = clientHandleToConnection[vmBind->clientHandle];
UNRECOVERABLE_IF(connection->vmBindMap.find(vmBind->base.seqno) != connection->vmBindMap.end());
auto &vmBindData = connection->vmBindMap[vmBind->base.seqno];
vmBindData.vmBind = *vmBind;
vmBindData.pendingNumBinds = vmBind->num_binds;
} break;
case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
drm_xe_eudebug_event_vm_bind_op *vmBindOp = reinterpret_cast<drm_xe_eudebug_event_vm_bind_op *>(event);
vmBindData.pendingNumBinds = vmBind->numBinds;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBindOp)) {
NEO::EuDebugEventVmBindOp *vmBindOp = reinterpret_cast<NEO::EuDebugEventVmBindOp *>(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: drm_xe_eudebug_event_vm_bind_op vm_bind_ref_seqno = %llu num_extensions = %llu addr = 0x%llx range = %llu\n",
static_cast<uint64_t>(vmBindOp->vm_bind_ref_seqno), static_cast<uint64_t>(vmBindOp->num_extensions),
static_cast<uint64_t>(vmBindOp->vmBindRefSeqno), static_cast<uint64_t>(vmBindOp->numExtensions),
static_cast<uint64_t>(vmBindOp->addr), static_cast<uint64_t>(vmBindOp->range));
auto &vmBindMap = clientHandleToConnection[clientHandle]->vmBindMap;
UNRECOVERABLE_IF(vmBindMap.find(vmBindOp->vm_bind_ref_seqno) == vmBindMap.end());
auto &vmBindData = vmBindMap[vmBindOp->vm_bind_ref_seqno];
UNRECOVERABLE_IF(vmBindMap.find(vmBindOp->vmBindRefSeqno) == vmBindMap.end());
auto &vmBindData = vmBindMap[vmBindOp->vmBindRefSeqno];
UNRECOVERABLE_IF(!vmBindData.pendingNumBinds);
auto &vmBindOpData = vmBindData.vmBindOpMap[vmBindOp->base.seqno];
vmBindOpData.pendingNumExtensions = vmBindOp->num_extensions;
vmBindOpData.pendingNumExtensions = vmBindOp->numExtensions;
vmBindOpData.vmBindOp = *vmBindOp;
vmBindData.pendingNumBinds--;
clientHandleToConnection[clientHandle]->vmBindIdentifierMap[vmBindOp->base.seqno] = vmBindOp->vm_bind_ref_seqno;
clientHandleToConnection[clientHandle]->vmBindIdentifierMap[vmBindOp->base.seqno] = vmBindOp->vmBindRefSeqno;
handleVmBind(vmBindData);
} break;
case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE: {
drm_xe_eudebug_event_vm_bind_ufence *vmBindUfence = reinterpret_cast<drm_xe_eudebug_event_vm_bind_ufence *>(event);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBindUfence)) {
NEO::EuDebugEventVmBindUfence *vmBindUfence = reinterpret_cast<NEO::EuDebugEventVmBindUfence *>(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE vm_bind_ref_seqno = %llu\n",
static_cast<uint64_t>(vmBindUfence->vm_bind_ref_seqno));
static_cast<uint64_t>(vmBindUfence->vmBindRefSeqno));
auto &vmBindMap = clientHandleToConnection[clientHandle]->vmBindMap;
UNRECOVERABLE_IF(vmBindMap.find(vmBindUfence->vm_bind_ref_seqno) == vmBindMap.end());
uint32_t uFenceRequired = vmBindMap[vmBindUfence->vm_bind_ref_seqno].vmBind.flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE;
UNRECOVERABLE_IF(vmBindMap.find(vmBindUfence->vmBindRefSeqno) == vmBindMap.end());
uint32_t uFenceRequired = vmBindMap[vmBindUfence->vmBindRefSeqno].vmBind.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventVmBindFlagUfence);
UNRECOVERABLE_IF(!uFenceRequired);
UNRECOVERABLE_IF(vmBindMap[vmBindUfence->vm_bind_ref_seqno].uFenceReceived); // Dont expect multiple UFENCE for same vm_bind
vmBindMap[vmBindUfence->vm_bind_ref_seqno].uFenceReceived = true;
vmBindMap[vmBindUfence->vm_bind_ref_seqno].vmBindUfence = *vmBindUfence;
handleVmBind(vmBindMap[vmBindUfence->vm_bind_ref_seqno]);
} break;
case DRM_XE_EUDEBUG_EVENT_METADATA: {
drm_xe_eudebug_event_metadata *metaData = reinterpret_cast<drm_xe_eudebug_event_metadata *>(event);
UNRECOVERABLE_IF(vmBindMap[vmBindUfence->vmBindRefSeqno].uFenceReceived); // Dont expect multiple UFENCE for same vm_bind
vmBindMap[vmBindUfence->vmBindRefSeqno].uFenceReceived = true;
vmBindMap[vmBindUfence->vmBindRefSeqno].vmBindUfence = *vmBindUfence;
handleVmBind(vmBindMap[vmBindUfence->vmBindRefSeqno]);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeMetadata)) {
NEO::EuDebugEventMetadata *metaData = reinterpret_cast<NEO::EuDebugEventMetadata *>(event);
if (clientHandle == invalidClientHandle) {
clientHandle = metaData->client_handle;
clientHandle = metaData->clientHandle;
}
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_METADATA client_handle = %llu metadata_handle = %llu type = %llu len = %llu\n",
(uint64_t)metaData->client_handle, (uint64_t)metaData->metadata_handle, (uint64_t)metaData->type, (uint64_t)metaData->len);
(uint64_t)metaData->clientHandle, (uint64_t)metaData->metadataHandle, (uint64_t)metaData->type, (uint64_t)metaData->len);
handleMetadataEvent(metaData);
} break;
case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA: {
drm_xe_eudebug_event_vm_bind_op_metadata *vmBindOpMetadata = reinterpret_cast<drm_xe_eudebug_event_vm_bind_op_metadata *>(event);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBindOpMetadata)) {
NEO::EuDebugEventVmBindOpMetadata *vmBindOpMetadata = reinterpret_cast<NEO::EuDebugEventVmBindOpMetadata *>(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA vm_bind_op_ref_seqno = %llu metadata_handle = %llu metadata_cookie = %llu\n",
static_cast<uint64_t>(vmBindOpMetadata->vm_bind_op_ref_seqno), static_cast<uint64_t>(vmBindOpMetadata->metadata_handle),
static_cast<uint64_t>(vmBindOpMetadata->metadata_cookie));
static_cast<uint64_t>(vmBindOpMetadata->vmBindOpRefSeqno), static_cast<uint64_t>(vmBindOpMetadata->metadataHandle),
static_cast<uint64_t>(vmBindOpMetadata->metadataCookie));
auto &vmBindMap = clientHandleToConnection[clientHandle]->vmBindMap;
auto &vmBindIdentifierMap = clientHandleToConnection[clientHandle]->vmBindIdentifierMap;
UNRECOVERABLE_IF(vmBindIdentifierMap.find(vmBindOpMetadata->vm_bind_op_ref_seqno) == vmBindIdentifierMap.end());
VmBindSeqNo vmBindSeqNo = vmBindIdentifierMap[vmBindOpMetadata->vm_bind_op_ref_seqno];
UNRECOVERABLE_IF(vmBindIdentifierMap.find(vmBindOpMetadata->vmBindOpRefSeqno) == vmBindIdentifierMap.end());
VmBindSeqNo vmBindSeqNo = vmBindIdentifierMap[vmBindOpMetadata->vmBindOpRefSeqno];
UNRECOVERABLE_IF(vmBindMap.find(vmBindSeqNo) == vmBindMap.end());
auto &vmBindOpData = vmBindMap[vmBindSeqNo].vmBindOpMap[vmBindOpMetadata->vm_bind_op_ref_seqno];
auto &vmBindOpData = vmBindMap[vmBindSeqNo].vmBindOpMap[vmBindOpMetadata->vmBindOpRefSeqno];
UNRECOVERABLE_IF(!vmBindOpData.pendingNumExtensions);
vmBindOpData.vmBindOpMetadataVec.push_back(*vmBindOpMetadata);
vmBindOpData.pendingNumExtensions--;
handleVmBind(vmBindMap[vmBindSeqNo]);
} break;
default:
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypePagefault)) {
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: UNHANDLED %u flags = %u len = %lu\n", type, event->flags, event->len);
} else {
additionalEvents(event);
break;
}
}
@@ -370,7 +360,7 @@ bool DebugSessionLinuxXe::canHandleVmBind(VmBindData &vmBindData) const {
return false;
}
}
uint32_t uFenceRequired = vmBindData.vmBind.flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE;
uint32_t uFenceRequired = vmBindData.vmBind.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventVmBindFlagUfence);
if (uFenceRequired) {
if (!vmBindData.uFenceReceived) {
return false;
@@ -384,7 +374,7 @@ void DebugSessionLinuxXe::handleVmBind(VmBindData &vmBindData) {
if (!canHandleVmBind(vmBindData)) {
return;
}
bool shouldAckEvent = vmBindData.vmBind.flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE;
bool shouldAckEvent = vmBindData.vmBind.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventVmBindFlagUfence);
auto connection = clientHandleToConnection[clientHandle].get();
auto elfHandleInVmBind = invalidHandle;
@@ -395,30 +385,30 @@ void DebugSessionLinuxXe::handleVmBind(VmBindData &vmBindData) {
for (auto &vmBindOpData : vmBindData.vmBindOpMap) {
auto &vmBindOp = vmBindOpData.second.vmBindOp;
for (const auto &vmBindOpMetadata : vmBindOpData.second.vmBindOpMetadataVec) {
auto &metaDataEntry = connection->metaDataMap[vmBindOpMetadata.metadata_handle];
if (vmBindOp.base.flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
auto &metaDataEntry = connection->metaDataMap[vmBindOpMetadata.metadataHandle];
if (vmBindOp.base.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate)) {
{
std::lock_guard<std::mutex> lock(asyncThreadMutex);
if (metaDataEntry.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA) {
connection->vmToStateBaseAreaBindInfo[vmBindData.vmBind.vm_handle] = {vmBindOp.addr, vmBindOp.range};
if (metaDataEntry.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataSbaArea)) {
connection->vmToStateBaseAreaBindInfo[vmBindData.vmBind.vmHandle] = {vmBindOp.addr, vmBindOp.range};
}
if (metaDataEntry.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA) {
connection->vmToContextStateSaveAreaBindInfo[vmBindData.vmBind.vm_handle] = {vmBindOp.addr, vmBindOp.range};
if (metaDataEntry.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataSipArea)) {
connection->vmToContextStateSaveAreaBindInfo[vmBindData.vmBind.vmHandle] = {vmBindOp.addr, vmBindOp.range};
}
if (metaDataEntry.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA) {
if (metaDataEntry.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataModuleArea)) {
isaAddr = vmBindOp.addr;
if (connection->isaMap[0].find(vmBindOp.addr) == connection->isaMap[0].end()) {
auto &isaMap = connection->isaMap[0];
auto isa = std::make_unique<IsaAllocation>();
isa->bindInfo = {vmBindOp.addr, vmBindOp.range};
isa->vmHandle = vmBindData.vmBind.vm_handle;
isa->vmHandle = vmBindData.vmBind.vmHandle;
isa->elfHandle = invalidHandle;
isa->moduleBegin = 0;
isa->moduleEnd = 0;
isa->tileInstanced = !(this->debugArea.isShared);
isa->validVMs.insert(vmBindData.vmBind.vm_handle);
isa->validVMs.insert(vmBindData.vmBind.vmHandle);
uint32_t deviceBitfield = 0;
auto &debugModule = connection->metaDataToModule[vmBindOpMetadata.metadata_handle];
auto &debugModule = connection->metaDataToModule[vmBindOpMetadata.metadataHandle];
memcpy_s(&deviceBitfield, sizeof(uint32_t),
&debugModule.deviceBitfield,
sizeof(debugModule.deviceBitfield));
@@ -427,41 +417,41 @@ void DebugSessionLinuxXe::handleVmBind(VmBindData &vmBindData) {
isa->perKernelModule = false;
isaMap[vmBindOp.addr] = std::move(isa);
}
connection->vmToModuleDebugAreaBindInfo[vmBindData.vmBind.vm_handle] = {vmBindOp.addr, vmBindOp.range};
connection->vmToModuleDebugAreaBindInfo[vmBindData.vmBind.vmHandle] = {vmBindOp.addr, vmBindOp.range};
}
}
if (metaDataEntry.metadata.type == DRM_XE_DEBUG_METADATA_ELF_BINARY) {
if (metaDataEntry.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataElfBinary)) {
isaAddr = vmBindOp.addr;
if (connection->isaMap[0].find(vmBindOp.addr) == connection->isaMap[0].end()) {
auto &isaMap = connection->isaMap[0];
auto &elfMap = connection->elfMap;
auto isa = std::make_unique<IsaAllocation>();
isa->bindInfo = {vmBindOp.addr, vmBindOp.range};
isa->vmHandle = vmBindData.vmBind.vm_handle;
isa->elfHandle = vmBindOpMetadata.metadata_handle;
isa->vmHandle = vmBindData.vmBind.vmHandle;
isa->elfHandle = vmBindOpMetadata.metadataHandle;
isa->moduleBegin = reinterpret_cast<uint64_t>(metaDataEntry.data.get());
isa->moduleEnd = isa->moduleBegin + metaDataEntry.metadata.len;
isa->tileInstanced = false;
isa->validVMs.insert(vmBindData.vmBind.vm_handle);
isa->validVMs.insert(vmBindData.vmBind.vmHandle);
isa->perKernelModule = false;
elfMap[isa->moduleBegin] = isa->elfHandle;
isaMap[vmBindOp.addr] = std::move(isa);
isaMap[vmBindOp.addr]->moduleLoadEventAck = true;
elfHandleInVmBind = vmBindOpMetadata.metadata_handle;
elfHandleInVmBind = vmBindOpMetadata.metadataHandle;
} else {
auto &isa = connection->isaMap[0][vmBindOp.addr];
isa->validVMs.insert(vmBindData.vmBind.vm_handle);
isa->validVMs.insert(vmBindData.vmBind.vmHandle);
}
}
if (metaDataEntry.metadata.type == DRM_XE_DEBUG_METADATA_PROGRAM_MODULE) {
auto &module = connection->metaDataToModule[vmBindOpMetadata.metadata_handle];
if (metaDataEntry.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataProgramModule)) {
auto &module = connection->metaDataToModule[vmBindOpMetadata.metadataHandle];
module.segmentVmBindCounter[0]++;
DEBUG_BREAK_IF(module.loadAddresses[0].size() > module.segmentCount);
bool canTriggerEvent = module.loadAddresses[0].size() == (module.segmentCount - 1);
module.loadAddresses[0].insert(vmBindOp.addr);
moduleHandle = vmBindOpMetadata.metadata_handle;
moduleHandle = vmBindOpMetadata.metadataHandle;
if (canTriggerEvent && module.loadAddresses[0].size() == module.segmentCount) {
triggerModuleLoadEvent = true;
}
@@ -469,10 +459,10 @@ void DebugSessionLinuxXe::handleVmBind(VmBindData &vmBindData) {
}
}
if (vmBindOp.base.flags & DRM_XE_EUDEBUG_EVENT_DESTROY) {
if (vmBindOp.base.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy)) {
if (connection->isaMap[0].count(vmBindOp.addr)) {
auto &isa = connection->isaMap[0][vmBindOp.addr];
if (isa->validVMs.count(vmBindData.vmBind.vm_handle)) {
if (isa->validVMs.count(vmBindData.vmBind.vmHandle)) {
auto &module = connection->metaDataToModule[isa->moduleHandle];
module.segmentVmBindCounter[0]--;
if (module.segmentVmBindCounter[0] == 0) {
@@ -486,11 +476,11 @@ void DebugSessionLinuxXe::handleVmBind(VmBindData &vmBindData) {
auto &elfMetadata = connection->metaDataMap[isa->elfHandle];
debugEvent.info.module.moduleBegin = reinterpret_cast<uint64_t>(elfMetadata.data.get());
debugEvent.info.module.moduleEnd = reinterpret_cast<uint64_t>(elfMetadata.data.get()) + elfMetadata.metadata.len;
pushApiEvent(debugEvent, metaDataEntry.metadata.metadata_handle);
pushApiEvent(debugEvent, metaDataEntry.metadata.metadataHandle);
module.loadAddresses[0].clear();
module.moduleLoadEventAcked[0] = false;
}
isa->validVMs.erase(vmBindData.vmBind.vm_handle);
isa->validVMs.erase(vmBindData.vmBind.vmHandle);
}
}
}
@@ -520,60 +510,60 @@ void DebugSessionLinuxXe::handleVmBind(VmBindData &vmBindData) {
{
std::lock_guard<std::mutex> lock(asyncThreadMutex);
if (vmBindData.vmBind.flags & DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE) {
if (vmBindData.vmBindUfence.base.flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK) {
if (vmBindData.vmBind.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventVmBindFlagUfence)) {
if (vmBindData.vmBindUfence.base.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitNeedAck)) {
EventToAck ackEvent(vmBindData.vmBindUfence.base.seqno, vmBindData.vmBindUfence.base.type);
module.ackEvents[0].push_back(ackEvent);
shouldAckEvent = false;
}
}
}
pushApiEvent(debugEvent, metaDataEntry.metadata.metadata_handle);
pushApiEvent(debugEvent, metaDataEntry.metadata.metadataHandle);
}
if (shouldAckEvent && (vmBindData.vmBindUfence.base.flags & DRM_XE_EUDEBUG_EVENT_NEED_ACK)) {
if (shouldAckEvent && (vmBindData.vmBindUfence.base.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitNeedAck))) {
EventToAck ackEvent(vmBindData.vmBindUfence.base.seqno, vmBindData.vmBindUfence.base.type);
eventAckIoctl(ackEvent);
}
}
void DebugSessionLinuxXe::handleMetadataEvent(drm_xe_eudebug_event_metadata *metaData) {
bool destroy = metaData->base.flags & DRM_XE_EUDEBUG_EVENT_DESTROY;
bool create = metaData->base.flags & DRM_XE_EUDEBUG_EVENT_CREATE;
void DebugSessionLinuxXe::handleMetadataEvent(NEO::EuDebugEventMetadata *metaData) {
bool destroy = metaData->base.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy);
bool create = metaData->base.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate);
UNRECOVERABLE_IF(clientHandleToConnection.find(metaData->client_handle) == clientHandleToConnection.end());
const auto &connection = clientHandleToConnection[metaData->client_handle];
UNRECOVERABLE_IF(clientHandleToConnection.find(metaData->clientHandle) == clientHandleToConnection.end());
const auto &connection = clientHandleToConnection[metaData->clientHandle];
if (destroy && connection->metaDataMap[metaData->metadata_handle].metadata.type == DRM_XE_DEBUG_METADATA_PROGRAM_MODULE) {
DEBUG_BREAK_IF(connection->metaDataToModule[metaData->metadata_handle].segmentVmBindCounter[0] != 0 ||
connection->metaDataToModule[metaData->metadata_handle].loadAddresses[0].size() > 0);
if (destroy && connection->metaDataMap[metaData->metadataHandle].metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataProgramModule)) {
DEBUG_BREAK_IF(connection->metaDataToModule[metaData->metadataHandle].segmentVmBindCounter[0] != 0 ||
connection->metaDataToModule[metaData->metadataHandle].loadAddresses[0].size() > 0);
connection->metaDataToModule.erase(metaData->metadata_handle);
connection->metaDataToModule.erase(metaData->metadataHandle);
}
if (create) {
if (!metaData->len) {
connection->metaDataMap[metaData->metadata_handle].metadata = *metaData;
connection->metaDataMap[metaData->metadataHandle].metadata = *metaData;
return;
}
drm_xe_eudebug_read_metadata readMetadata{};
NEO::EuDebugReadMetadata readMetadata{};
auto ptr = std::make_unique<char[]>(metaData->len);
readMetadata.client_handle = metaData->client_handle;
readMetadata.metadata_handle = static_cast<decltype(readMetadata.metadata_handle)>(metaData->metadata_handle);
readMetadata.clientHandle = metaData->clientHandle;
readMetadata.metadataHandle = static_cast<decltype(readMetadata.metadataHandle)>(metaData->metadataHandle);
readMetadata.ptr = reinterpret_cast<uint64_t>(ptr.get());
readMetadata.size = metaData->len;
auto ret = ioctl(DRM_XE_EUDEBUG_IOCTL_READ_METADATA, &readMetadata);
auto ret = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlReadMetadata), &readMetadata);
if (ret != 0) {
PRINT_DEBUGGER_ERROR_LOG("DRM_XE_EUDEBUG_IOCTL_READ_METADATA ret = %d errno = %d\n", ret, errno);
return;
}
connection->metaDataMap[metaData->metadata_handle].metadata = *metaData;
connection->metaDataMap[metaData->metadata_handle].data = std::move(ptr);
connection->metaDataMap[metaData->metadataHandle].metadata = *metaData;
connection->metaDataMap[metaData->metadataHandle].data = std::move(ptr);
if (metaData->type == DRM_XE_DEBUG_METADATA_PROGRAM_MODULE) {
auto handle = metaData->metadata_handle;
if (metaData->type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataProgramModule)) {
auto handle = metaData->metadataHandle;
auto &newModule = connection->metaDataToModule[handle];
newModule.segmentCount = 0;
newModule.moduleHandle = handle;
@@ -583,48 +573,48 @@ void DebugSessionLinuxXe::handleMetadataEvent(drm_xe_eudebug_event_metadata *met
newModule.moduleLoadEventAcked[i] = false;
}
}
extractMetaData(metaData->client_handle, connection->metaDataMap[metaData->metadata_handle]);
extractMetaData(metaData->clientHandle, connection->metaDataMap[metaData->metadataHandle]);
}
}
void DebugSessionLinuxXe::extractMetaData(uint64_t client, const MetaData &metaData) {
if (metaData.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA ||
metaData.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA ||
metaData.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA) {
if (metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataSbaArea) ||
metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataModuleArea) ||
metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataSipArea)) {
UNRECOVERABLE_IF(metaData.metadata.len != 8);
uint64_t *data = (uint64_t *)metaData.data.get();
if (metaData.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA) {
if (metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataSbaArea)) {
clientHandleToConnection[client]->stateBaseAreaGpuVa = *data;
PRINT_DEBUGGER_INFO_LOG("SbaTrackingBuffer GPU VA = %p", (void *)clientHandleToConnection[clientHandle]->stateBaseAreaGpuVa);
}
if (metaData.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA) {
if (metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataModuleArea)) {
clientHandleToConnection[client]->moduleDebugAreaGpuVa = *data;
PRINT_DEBUGGER_INFO_LOG("ModuleHeapDebugArea GPU VA = %p", (void *)clientHandleToConnection[clientHandle]->moduleDebugAreaGpuVa);
}
if (metaData.metadata.type == WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA) {
if (metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataSipArea)) {
clientHandleToConnection[client]->contextStateSaveAreaGpuVa = *data;
PRINT_DEBUGGER_INFO_LOG("ContextSaveArea GPU VA = %p", (void *)clientHandleToConnection[clientHandle]->contextStateSaveAreaGpuVa);
}
}
if (metaData.metadata.type == DRM_XE_DEBUG_METADATA_PROGRAM_MODULE) {
if (metaData.metadata.type == euDebugInterface->getParamValue(NEO::EuDebugParam::metadataProgramModule)) {
uint32_t segmentCount = 0;
memcpy_s(&segmentCount, sizeof(uint32_t), metaData.data.get(), metaData.metadata.len);
clientHandleToConnection[client]->metaDataToModule[metaData.metadata.metadata_handle].segmentCount = segmentCount;
PRINT_DEBUGGER_INFO_LOG("Zebin module = %ull, segment count = %ul", metaData.metadata.metadata_handle, segmentCount);
clientHandleToConnection[client]->metaDataToModule[metaData.metadata.metadataHandle].segmentCount = segmentCount;
PRINT_DEBUGGER_INFO_LOG("Zebin module = %ull, segment count = %ul", metaData.metadata.metadataHandle, segmentCount);
}
}
int DebugSessionLinuxXe::openVmFd(uint64_t vmHandle, [[maybe_unused]] bool readOnly) {
drm_xe_eudebug_vm_open vmOpen = {
NEO::EuDebugVmOpen vmOpen = {
.extensions = 0,
.client_handle = clientHandle,
.vm_handle = vmHandle,
.clientHandle = clientHandle,
.vmHandle = vmHandle,
.flags = 0,
.timeout_ns = 5000000000u};
.timeoutNs = 5000000000u};
return ioctl(DRM_XE_EUDEBUG_IOCTL_VM_OPEN, &vmOpen);
return ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlVmOpen), &vmOpen);
}
int DebugSessionLinuxXe::flushVmCache(int vmfd) {
@@ -649,7 +639,7 @@ uint64_t DebugSessionLinuxXe::getVmHandleFromClientAndlrcHandle(uint64_t clientH
return clientConnection->lrcHandleToVmHandle[lrcHandle];
}
void DebugSessionLinuxXe::handleAttentionEvent(drm_xe_eudebug_event_eu_attention *attention) {
void DebugSessionLinuxXe::handleAttentionEvent(NEO::EuDebugEventEuAttention *attention) {
if (interruptSent) {
if (attention->base.seqno <= euControlInterruptSeqno) {
PRINT_DEBUGGER_INFO_LOG("Discarding EU ATTENTION event for interrupt request. Event seqno == %llu <= %llu == interrupt seqno\n",
@@ -662,33 +652,33 @@ void DebugSessionLinuxXe::handleAttentionEvent(drm_xe_eudebug_event_eu_attention
std::vector<EuThread::ThreadId> threadsWithAttention;
AttentionEventFields attentionEventFields;
attentionEventFields.bitmask = attention->bitmask;
attentionEventFields.bitmaskSize = attention->bitmask_size;
attentionEventFields.clientHandle = attention->client_handle;
attentionEventFields.contextHandle = attention->exec_queue_handle;
attentionEventFields.lrcHandle = attention->lrc_handle;
attentionEventFields.bitmaskSize = attention->bitmaskSize;
attentionEventFields.clientHandle = attention->clientHandle;
attentionEventFields.contextHandle = attention->execQueueHandle;
attentionEventFields.lrcHandle = attention->lrcHandle;
return updateStoppedThreadsAndCheckTriggerEvents(attentionEventFields, 0, threadsWithAttention);
}
int DebugSessionLinuxXe::threadControlInterruptAll() {
int euControlRetVal = -1;
drm_xe_eudebug_eu_control euControl = {};
euControl.client_handle = clientHandle;
euControl.cmd = DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL;
euControl.bitmask_size = 0;
euControl.bitmask_ptr = 0;
NEO::EuDebugEuControl euControl = {};
euControl.clientHandle = clientHandle;
euControl.cmd = euDebugInterface->getParamValue(NEO::EuDebugParam::euControlCmdInterruptAll);
euControl.bitmaskSize = 0;
euControl.bitmaskPtr = 0;
DEBUG_BREAK_IF(clientHandleToConnection.find(clientHandle) == clientHandleToConnection.end());
std::lock_guard<std::mutex> lock(asyncThreadMutex);
for (const auto &execQueue : clientHandleToConnection[clientHandle]->execQueues) {
euControl.exec_queue_handle = execQueue.first;
euControl.execQueueHandle = execQueue.first;
for (const auto &lrcHandle : execQueue.second.lrcHandles) {
euControl.lrc_handle = lrcHandle;
euControlRetVal = ioctl(DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &euControl);
euControl.lrcHandle = lrcHandle;
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), &euControl);
if (euControlRetVal != 0) {
PRINT_DEBUGGER_ERROR_LOG("DRM_XE_EUDEBUG_IOCTL_EU_CONTROL failed: retCode: %d errno = %d command = %d, execQueueHandle = %llu lrcHandle = %llu\n",
euControlRetVal, errno, static_cast<uint32_t>(euControl.cmd), static_cast<uint64_t>(euControl.exec_queue_handle),
static_cast<uint64_t>(euControl.lrc_handle));
euControlRetVal, errno, static_cast<uint32_t>(euControl.cmd), static_cast<uint64_t>(euControl.execQueueHandle),
static_cast<uint64_t>(euControl.lrcHandle));
} else {
DEBUG_BREAK_IF(euControlInterruptSeqno >= euControl.seqno);
euControlInterruptSeqno = euControl.seqno;
@@ -705,27 +695,27 @@ int DebugSessionLinuxXe::threadControlStopped(std::unique_ptr<uint8_t[]> &bitmas
int euControlRetVal = -1;
auto hwInfo = connectedDevice->getHwInfo();
auto &l0GfxCoreHelper = connectedDevice->getL0GfxCoreHelper();
drm_xe_eudebug_eu_control euControl = {};
euControl.client_handle = clientHandle;
euControl.cmd = DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED;
NEO::EuDebugEuControl euControl = {};
euControl.clientHandle = clientHandle;
euControl.cmd = euDebugInterface->getParamValue(NEO::EuDebugParam::euControlCmdStopped);
std::unique_ptr<uint8_t[]> bitmask;
size_t bitmaskSize = 0;
l0GfxCoreHelper.getAttentionBitmaskForSingleThreads({}, hwInfo, bitmask, bitmaskSize);
euControl.bitmask_size = static_cast<uint32_t>(bitmaskSize);
euControl.bitmask_ptr = reinterpret_cast<uint64_t>(bitmask.get());
euControl.bitmaskSize = static_cast<uint32_t>(bitmaskSize);
euControl.bitmaskPtr = reinterpret_cast<uint64_t>(bitmask.get());
DEBUG_BREAK_IF(clientHandleToConnection.find(clientHandle) == clientHandleToConnection.end());
std::lock_guard<std::mutex> lock(asyncThreadMutex);
for (const auto &execQueue : clientHandleToConnection[clientHandle]->execQueues) {
euControl.exec_queue_handle = execQueue.first;
euControl.execQueueHandle = execQueue.first;
for (const auto &lrcHandle : execQueue.second.lrcHandles) {
euControl.lrc_handle = lrcHandle;
euControlRetVal = ioctl(DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &euControl);
euControl.lrcHandle = lrcHandle;
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), &euControl);
if (euControlRetVal != 0) {
PRINT_DEBUGGER_ERROR_LOG("DRM_XE_EUDEBUG_IOCTL_EU_CONTROL failed: retCode: %d errno = %d command = %d, execQueueHandle = %llu lrcHandle = %llu\n",
euControlRetVal, errno, static_cast<uint32_t>(euControl.cmd), static_cast<uint64_t>(euControl.exec_queue_handle),
static_cast<uint64_t>(euControl.lrc_handle));
euControlRetVal, errno, static_cast<uint32_t>(euControl.cmd), static_cast<uint64_t>(euControl.execQueueHandle),
static_cast<uint64_t>(euControl.lrcHandle));
} else {
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_EU_CONTROL: seqno = %llu command = %u\n", static_cast<uint64_t>(euControl.seqno),
static_cast<uint32_t>(euControl.cmd));
@@ -740,7 +730,7 @@ int DebugSessionLinuxXe::threadControlStopped(std::unique_ptr<uint8_t[]> &bitmas
printBitmask(bitmask.get(), bitmaskSize);
bitmaskOut = std::move(bitmask);
UNRECOVERABLE_IF(bitmaskOut.get() == nullptr);
bitmaskSizeOut = euControl.bitmask_size;
bitmaskSizeOut = euControl.bitmaskSize;
return euControlRetVal;
}
@@ -748,31 +738,31 @@ int DebugSessionLinuxXe::threadControlResume(const std::vector<EuThread::ThreadI
int euControlRetVal = -1;
auto hwInfo = connectedDevice->getHwInfo();
auto &l0GfxCoreHelper = connectedDevice->getL0GfxCoreHelper();
drm_xe_eudebug_eu_control euControl = {};
euControl.client_handle = clientHandle;
euControl.bitmask_size = 0;
euControl.bitmask_ptr = 0;
NEO::EuDebugEuControl euControl = {};
euControl.clientHandle = clientHandle;
euControl.bitmaskSize = 0;
euControl.bitmaskPtr = 0;
std::unique_ptr<uint8_t[]> bitmask;
size_t bitmaskSize = 0;
l0GfxCoreHelper.getAttentionBitmaskForSingleThreads(threads, hwInfo, bitmask, bitmaskSize);
euControl.bitmask_size = static_cast<uint32_t>(bitmaskSize);
euControl.bitmask_ptr = reinterpret_cast<uint64_t>(bitmask.get());
euControl.bitmaskSize = static_cast<uint32_t>(bitmaskSize);
euControl.bitmaskPtr = reinterpret_cast<uint64_t>(bitmask.get());
printBitmask(bitmask.get(), bitmaskSize);
uint64_t execQueueHandle{0};
uint64_t lrcHandle{0};
allThreads[threads[0]]->getContextHandle(execQueueHandle);
allThreads[threads[0]]->getLrcHandle(lrcHandle);
euControl.exec_queue_handle = execQueueHandle;
euControl.lrc_handle = lrcHandle;
euControl.execQueueHandle = execQueueHandle;
euControl.lrcHandle = lrcHandle;
auto invokeIoctl = [&](int cmd) {
euControl.cmd = cmd;
euControlRetVal = ioctl(DRM_XE_EUDEBUG_IOCTL_EU_CONTROL, &euControl);
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), &euControl);
if (euControlRetVal != 0) {
PRINT_DEBUGGER_ERROR_LOG("DRM_XE_EUDEBUG_IOCTL_EU_CONTROL failed: retCode: %d errno = %d command = %d, execQueueHandle = %llu lrcHandle = %llu\n",
euControlRetVal, errno, static_cast<uint32_t>(euControl.cmd), static_cast<uint64_t>(euControl.exec_queue_handle),
static_cast<uint64_t>(euControl.lrc_handle));
euControlRetVal, errno, static_cast<uint32_t>(euControl.cmd), static_cast<uint64_t>(euControl.execQueueHandle),
static_cast<uint64_t>(euControl.lrcHandle));
} else {
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_EU_CONTROL: seqno = %llu command = %u\n", static_cast<uint64_t>(euControl.seqno), static_cast<uint32_t>(euControl.cmd));
}
@@ -782,7 +772,7 @@ int DebugSessionLinuxXe::threadControlResume(const std::vector<EuThread::ThreadI
invokeIoctl(getEuControlCmdUnlock());
}
invokeIoctl(DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME);
invokeIoctl(euDebugInterface->getParamValue(NEO::EuDebugParam::euControlCmdResume));
return euControlRetVal;
}
@@ -809,13 +799,13 @@ void DebugSessionLinuxXe::updateContextAndLrcHandlesForThreadsWithAttention(EuTh
}
int DebugSessionLinuxXe::eventAckIoctl(EventToAck &event) {
drm_xe_eudebug_ack_event eventToAck = {};
NEO::EuDebugAckEvent eventToAck = {};
eventToAck.type = event.type;
eventToAck.seqno = event.seqno;
eventToAck.flags = 0;
auto ret = ioctl(DRM_XE_EUDEBUG_IOCTL_ACK_EVENT, &eventToAck);
auto ret = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlAckEvent), &eventToAck);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_ACK_EVENT seqno = %llu ret = %d errno = %d\n", static_cast<uint64_t>(eventToAck.seqno), ret, ret != 0 ? errno : 0);
return ret;
}
} // namespace L0
} // namespace L0

32
level_zero/tools/source/debug/linux/xe/debug_session.h
View File

@@ -8,14 +8,13 @@
#pragma once
#include "shared/source/os_interface/linux/drm_debug.h"
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
#include "level_zero/tools/source/debug/debug_session.h"
#include "level_zero/tools/source/debug/debug_session_imp.h"
#include "level_zero/tools/source/debug/linux/debug_session.h"
#include "level_zero/tools/source/debug/linux/debug_session_factory.h"
#include "debug_xe_includes.h"
namespace L0 {
struct DebugSessionLinuxXe : DebugSessionLinux {
@@ -25,6 +24,7 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
static DebugSession *createLinuxSession(const zet_debug_config_t &config, Device *device, ze_result_t &result, bool isRootAttach);
struct IoctlHandlerXe : DebugSessionLinux::IoctlHandler {
IoctlHandlerXe(const NEO::EuDebugInterface &euDebugInterface) : euDebugInterface(euDebugInterface){};
int ioctl(int fd, unsigned long request, void *arg) override {
int ret = 0;
int error = 0;
@@ -37,13 +37,14 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
if (ret == -1) {
shouldRetryIoctl = (error == EINTR || error == EAGAIN || error == EBUSY);
if (request == DRM_XE_EUDEBUG_IOCTL_EU_CONTROL) {
if (request == euDebugInterface.getParamValue(NEO::EuDebugParam::ioctlEuControl)) {
shouldRetryIoctl = (error == EINTR || error == EAGAIN);
}
}
} while (shouldRetryIoctl);
return ret;
}
const NEO::EuDebugInterface &euDebugInterface;
};
using ExecQueueHandle = uint64_t;
@@ -66,9 +67,9 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
int threadControlInterruptAll();
int threadControlResume(const std::vector<EuThread::ThreadId> &threads);
int threadControlStopped(std::unique_ptr<uint8_t[]> &bitmaskOut, size_t &bitmaskSizeOut);
MOCKABLE_VIRTUAL void handleAttentionEvent(drm_xe_eudebug_event_eu_attention *attention);
void handleMetadataEvent(drm_xe_eudebug_event_metadata *pMetaData);
bool handleMetadataOpEvent(drm_xe_eudebug_event_vm_bind_op_metadata *vmBindOpMetadata);
MOCKABLE_VIRTUAL void handleAttentionEvent(NEO::EuDebugEventEuAttention *attention);
void handleMetadataEvent(NEO::EuDebugEventMetadata *pMetaData);
bool handleMetadataOpEvent(NEO::EuDebugEventVmBindOpMetadata *vmBindOpMetadata);
void updateContextAndLrcHandlesForThreadsWithAttention(EuThread::ThreadId threadId, const AttentionEventFields &attention) override;
int eventAckIoctl(EventToAck &event) override;
MOCKABLE_VIRTUAL int getEuControlCmdUnlock() const;
@@ -96,7 +97,7 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
}
struct MetaData {
drm_xe_eudebug_event_metadata metadata;
NEO::EuDebugEventMetadata metadata;
std::unique_ptr<char[]> data;
};
@@ -104,20 +105,20 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
using VmBindSeqNo = uint64_t;
struct VmBindOpData {
uint64_t pendingNumExtensions = 0;
drm_xe_eudebug_event_vm_bind_op vmBindOp;
std::vector<drm_xe_eudebug_event_vm_bind_op_metadata> vmBindOpMetadataVec;
NEO::EuDebugEventVmBindOp vmBindOp;
std::vector<NEO::EuDebugEventVmBindOpMetadata> vmBindOpMetadataVec;
};
struct VmBindData {
uint64_t pendingNumBinds = 0;
drm_xe_eudebug_event_vm_bind vmBind;
NEO::EuDebugEventVmBind vmBind;
bool uFenceReceived = false;
drm_xe_eudebug_event_vm_bind_ufence vmBindUfence;
NEO::EuDebugEventVmBindUfence vmBindUfence;
std::unordered_map<VmBindOpSeqNo, VmBindOpData> vmBindOpMap;
};
struct ClientConnectionXe : public ClientConnection {
drm_xe_eudebug_event_client client = {};
NEO::EuDebugEventClient client = {};
size_t getElfSize(uint64_t elfHandle) override { return metaDataMap[elfHandle].metadata.len; };
char *getElfData(uint64_t elfHandle) override { return metaDataMap[elfHandle].data.get(); };
@@ -136,8 +137,8 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
void extractMetaData(uint64_t client, const MetaData &metaData);
std::vector<std::unique_ptr<uint64_t[]>> pendingVmBindEvents;
bool checkAllEventsCollected();
MOCKABLE_VIRTUAL void handleEvent(drm_xe_eudebug_event *event);
void additionalEvents(drm_xe_eudebug_event *event);
MOCKABLE_VIRTUAL void handleEvent(NEO::EuDebugEvent *event);
void additionalEvents(NEO::EuDebugEvent *event);
MOCKABLE_VIRTUAL bool eventTypeIsAttention(uint16_t eventType);
void readInternalEventsAsync() override;
std::atomic<bool> detached{false};
@@ -160,10 +161,11 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
uint64_t euControlInterruptSeqno = 0;
ze_result_t readEventImp(drm_xe_eudebug_event *drmDebugEvent);
ze_result_t readEventImp(NEO::EuDebugEvent *drmDebugEvent);
int ioctl(unsigned long request, void *arg);
std::atomic<bool> processEntryEventGenerated = false;
std::atomic<uint64_t> newestAttSeqNo = 0;
std::unique_ptr<NEO::EuDebugInterface> euDebugInterface;
};
} // namespace L0

6
level_zero/tools/source/debug/linux/xe/handle_event_helper.cpp
View File

@@ -11,16 +11,16 @@
namespace L0 {
void DebugSessionLinuxXe::additionalEvents(drm_xe_eudebug_event *event) {
void DebugSessionLinuxXe::additionalEvents(NEO::EuDebugEvent *event) {
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: UNHANDLED %u flags = %u len = %lu\n", (uint16_t)event->type, (uint16_t)event->flags, (uint32_t)event->len);
}
bool DebugSessionLinuxXe::eventTypeIsAttention(uint16_t eventType) {
return (eventType == DRM_XE_EUDEBUG_EVENT_EU_ATTENTION);
return (eventType == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeEuAttention));
}
int DebugSessionLinuxXe::getEuControlCmdUnlock() const {
return -1;
}
} // namespace L0
} // namespace L0

43
level_zero/tools/test/unit_tests/sources/debug/linux/xe/debug_session_fixtures_linux_xe.h
View File

@@ -23,7 +23,6 @@
#include "level_zero/tools/test/unit_tests/sources/debug/linux/debug_session_fixtures_linux.h"
#include "common/StateSaveAreaHeader.h"
#include "debug_xe_includes.h"
#include <atomic>
#include <queue>
@@ -32,7 +31,7 @@
namespace L0 {
namespace ult {
using typeOfLrcHandle = std::decay<decltype(drm_xe_eudebug_event_exec_queue::lrc_handle[0])>::type;
using typeOfLrcHandle = std::decay<decltype(NEO::EuDebugEventExecQueue::lrcHandle[0])>::type;
struct DebugApiLinuxXeFixture : public DeviceFixture {
void setUp() {
@@ -53,8 +52,8 @@ struct MockIoctlHandlerXe : public L0::ult::MockIoctlHandler {
int ioctl(int fd, unsigned long request, void *arg) override {
ioctlCalled++;
if ((request == DRM_XE_EUDEBUG_IOCTL_READ_EVENT) && (arg != nullptr)) {
auto debugEvent = reinterpret_cast<drm_xe_eudebug_event *>(arg);
if ((request == static_cast<uint64_t>(NEO::EuDebugParam::ioctlReadEvent)) && (arg != nullptr)) {
auto debugEvent = reinterpret_cast<NEO::EuDebugEvent *>(arg);
debugEventInput = *debugEvent;
if (!eventQueue.empty()) {
@@ -66,32 +65,32 @@ struct MockIoctlHandlerXe : public L0::ult::MockIoctlHandler {
debugEventRetVal = -1;
}
return debugEventRetVal;
} else if ((request == DRM_XE_EUDEBUG_IOCTL_VM_OPEN) && (arg != nullptr)) {
drm_xe_eudebug_vm_open *vmOpenIn = reinterpret_cast<drm_xe_eudebug_vm_open *>(arg);
} else if ((request == static_cast<uint64_t>(NEO::EuDebugParam::ioctlVmOpen)) && (arg != nullptr)) {
NEO::EuDebugVmOpen *vmOpenIn = reinterpret_cast<NEO::EuDebugVmOpen *>(arg);
vmOpen = *vmOpenIn;
return vmOpenRetVal;
} else if ((request == DRM_XE_EUDEBUG_IOCTL_EU_CONTROL) && (arg != nullptr)) {
drm_xe_eudebug_eu_control *euControlArg = reinterpret_cast<drm_xe_eudebug_eu_control *>(arg);
} else if ((request == static_cast<uint64_t>(NEO::EuDebugParam::ioctlEuControl)) && (arg != nullptr)) {
NEO::EuDebugEuControl *euControlArg = reinterpret_cast<NEO::EuDebugEuControl *>(arg);
EuControlArg arg;
arg.euControl = *euControlArg;
euControlArg->seqno = ++euControlOutputSeqno;
if (euControlArg->bitmask_size != 0) {
arg.euControlBitmaskSize = euControlArg->bitmask_size;
if (euControlArg->bitmaskSize != 0) {
arg.euControlBitmaskSize = euControlArg->bitmaskSize;
arg.euControlBitmask = std::make_unique<uint8_t[]>(arg.euControlBitmaskSize);
memcpy(arg.euControlBitmask.get(), reinterpret_cast<void *>(euControlArg->bitmask_ptr), arg.euControlBitmaskSize);
if (euControlArg->cmd == DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED && euControlArg->bitmask_ptr && outputBitmask.get()) {
memcpy_s(reinterpret_cast<uint64_t *>(euControlArg->bitmask_ptr), euControlArg->bitmask_size, outputBitmask.get(), outputBitmaskSize);
memcpy(arg.euControlBitmask.get(), reinterpret_cast<void *>(euControlArg->bitmaskPtr), arg.euControlBitmaskSize);
if (euControlArg->cmd == static_cast<uint64_t>(NEO::EuDebugParam::euControlCmdStopped) && euControlArg->bitmaskPtr && outputBitmask.get()) {
memcpy_s(reinterpret_cast<uint64_t *>(euControlArg->bitmaskPtr), euControlArg->bitmaskSize, outputBitmask.get(), outputBitmaskSize);
}
}
euControlArgs.push_back(std::move(arg));
} else if ((request == DRM_XE_EUDEBUG_IOCTL_READ_METADATA) && (arg != nullptr)) {
drm_xe_eudebug_read_metadata *readMetadata = reinterpret_cast<drm_xe_eudebug_read_metadata *>(arg);
} else if ((request == static_cast<uint64_t>(NEO::EuDebugParam::ioctlReadMetadata)) && (arg != nullptr)) {
NEO::EuDebugReadMetadata *readMetadata = reinterpret_cast<NEO::EuDebugReadMetadata *>(arg);
if (returnMetadata) {
readMetadata->client_handle = returnMetadata->client_handle;
readMetadata->metadata_handle = returnMetadata->metadata_handle;
readMetadata->clientHandle = returnMetadata->clientHandle;
readMetadata->metadataHandle = returnMetadata->metadataHandle;
readMetadata->flags = returnMetadata->flags;
int returnError = 0;
if (readMetadata->size >= returnMetadata->size) {
@@ -122,14 +121,14 @@ struct MockIoctlHandlerXe : public L0::ult::MockIoctlHandler {
memset(&euControl, 0, sizeof(euControl));
}
EuControlArg(EuControlArg &&in) : euControl(in.euControl), euControlBitmask(std::move(in.euControlBitmask)), euControlBitmaskSize(in.euControlBitmaskSize){};
drm_xe_eudebug_eu_control euControl = {};
NEO::EuDebugEuControl euControl = {};
std::unique_ptr<uint8_t[]> euControlBitmask;
size_t euControlBitmaskSize = 0;
};
drm_xe_eudebug_event debugEventInput = {};
drm_xe_eudebug_vm_open vmOpen = {};
drm_xe_eudebug_read_metadata *returnMetadata = nullptr;
NEO::EuDebugEvent debugEventInput = {};
NEO::EuDebugVmOpen vmOpen = {};
NEO::EuDebugReadMetadata *returnMetadata = nullptr;
int ioctlRetVal = 0;
int debugEventRetVal = 0;
@@ -209,7 +208,7 @@ struct MockDebugSessionLinuxXe : public L0::DebugSessionLinuxXe {
return DebugSessionLinuxXe::initialize();
}
void handleAttentionEvent(drm_xe_eudebug_event_eu_attention *attention) override {
void handleAttentionEvent(NEO::EuDebugEventEuAttention *attention) override {
handleAttentionEventCalled++;
return DebugSessionLinuxXe::handleAttentionEvent(attention);
}

1430
level_zero/tools/test/unit_tests/sources/debug/linux/xe/test_debug_api_linux_xe.cpp
View File

File diff suppressed because it is too large Load Diff

12
opencl/source/dll/CMakeLists.txt
View File

@@ -56,6 +56,18 @@ set(RUNTIME_SRCS_DLL_LINUX
${NEO_SHARED_DIRECTORY}/os_interface/linux/sys_calls_linux.cpp
${NEO_SOURCE_DIR}/opencl/source/os_interface/linux/platform_teardown_linux.cpp
)
if(NEO_ENABLE_XE_EU_DEBUG_SUPPORT)
if(NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM)
list(APPEND RUNTIME_SRCS_DLL_LINUX
${NEO_SOURCE_DIR}/shared/source/os_interface/linux/xe/eudebug/enable_eudebug_interface_upstream.cpp
)
endif()
if(NEO_ENABLE_XE_PRELIM_DETECTION)
list(APPEND RUNTIME_SRCS_DLL_LINUX
${NEO_SOURCE_DIR}/shared/source/os_interface/linux/xe/eudebug/enable_eudebug_interface_prelim.cpp
)
endif()
endif()
set(RUNTIME_SRCS_DLL_WINDOWS
${NEO_SHARED_DIRECTORY}/dll/windows/debugger_l0_windows.cpp

2
scripts/packaging/l0_gpu_driver/build_l0_gpu_driver_rpm.sh
View File

@@ -56,6 +56,7 @@ if [ "${BUILD_SRPM}" == "1" ]; then
NEO_ENABLE_I915_PRELIM_DETECTION="${NEO_ENABLE_I915_PRELIM_DETECTION:-FALSE}"
NEO_ENABLE_XE_PRELIM_DETECTION="${NEO_ENABLE_XE_PRELIM_DETECTION:-FALSE}"
NEO_ENABLE_XE_EU_DEBUG_SUPPORT="${NEO_ENABLE_XE_EU_DEBUG_SUPPORT:-FALSE}"
NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM="${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM:-FALSE}"
#setup rpm build tree
rm -rf $BUILD_DIR
@@ -82,6 +83,7 @@ if [ "${BUILD_SRPM}" == "1" ]; then
perl -pi -e "s/^%global NEO_ENABLE_I915_PRELIM_DETECTION .*/%global NEO_ENABLE_I915_PRELIM_DETECTION ${NEO_ENABLE_I915_PRELIM_DETECTION}/" $SPEC
perl -pi -e "s/^%global NEO_ENABLE_XE_PRELIM_DETECTION .*/%global NEO_ENABLE_XE_PRELIM_DETECTION ${NEO_ENABLE_XE_PRELIM_DETECTION}/" $SPEC
perl -pi -e "s/^%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT .*/%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT ${NEO_ENABLE_XE_EU_DEBUG_SUPPORT}/" $SPEC
perl -pi -e "s/^%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM .*/%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM ${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM}/" $SPEC
perl -pi -e "s/^%global build_id .*/%global build_id ${NEO_L0_VERSION_PATCH}/" $SPEC
rpmbuild --define "_topdir $BUILD_DIR" -bs $SPEC --define 'build_type ${CMAKE_BUILD_TYPE}' "${build_args[@]}"

2
scripts/packaging/l0_gpu_driver/rhel_8/SPECS/l0_gpu_driver.spec
View File

@@ -6,6 +6,7 @@
%global NEO_ENABLE_I915_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT FALSE
%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM FALSE
%global NEO_I915_PRELIM_HEADERS_DIR %{nil}
%define _source_payload w5T16.xzdio
@@ -70,6 +71,7 @@ cd build
-DNEO_ENABLE_I915_PRELIM_DETECTION=%{NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=%{NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=%{NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=%{NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DRELEASE_WITH_REGKEYS=%{NEO_RELEASE_WITH_REGKEYS} \
-DL0_INSTALL_UDEV_RULES=1 \
-DUDEV_RULES_DIR=/etc/udev/rules.d/ \

2
scripts/packaging/l0_gpu_driver/sles_15/SPECS/l0_gpu_driver.spec
View File

@@ -6,6 +6,7 @@
%global build_id xxx
%global NEO_RELEASE_WITH_REGKEYS FALSE
%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT FALSE
%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM FALSE
%global NEO_ENABLE_I915_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_PRELIM_DETECTION FALSE
%global NEO_I915_PRELIM_HEADERS_DIR %{nil}
@@ -80,6 +81,7 @@ Intel(R) Graphics Compute Runtime for oneAPI Level Zero - development headers
-DNEO_ENABLE_I915_PRELIM_DETECTION=%{NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=%{NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=%{NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=%{NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DRELEASE_WITH_REGKEYS=%{NEO_RELEASE_WITH_REGKEYS} \
-DL0_INSTALL_UDEV_RULES=1 \
-DUDEV_RULES_DIR=/etc/udev/rules.d/ \

2
scripts/packaging/l0_gpu_driver/ubuntu_20.04/debian/rules
View File

@@ -11,6 +11,7 @@ NEO_SKIP_UNIT_TESTS ?= FALSE
NEO_ENABLE_I915_PRELIM_DETECTION ?= FALSE
NEO_ENABLE_XE_PRELIM_DETECTION ?= FALSE
NEO_ENABLE_XE_EU_DEBUG_SUPPORT ?= FALSE
NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM ?= FALSE
NEO_FORCE_USE_AUB_STREAM ?= TRUE
NEO_LEGACY_PLATFORMS_SUPPORT ?= FALSE
NEO_CURRENT_PLATFORMS_SUPPORT ?= TRUE
@@ -25,6 +26,7 @@ override_dh_auto_configure:
-DNEO_ENABLE_I915_PRELIM_DETECTION=${NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=${NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=${NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DNEO_DISABLE_BUILTINS_COMPILATION=${NEO_DISABLE_BUILTINS_COMPILATION} \
-DNEO_LEGACY_PLATFORMS_SUPPORT=${NEO_LEGACY_PLATFORMS_SUPPORT} \
-DNEO_CURRENT_PLATFORMS_SUPPORT=${NEO_CURRENT_PLATFORMS_SUPPORT} \

2
scripts/packaging/opencl/build_opencl_rpm.sh
View File

@@ -56,6 +56,7 @@ if [ "${BUILD_SRPM}" == "1" ]; then
NEO_ENABLE_I915_PRELIM_DETECTION="${NEO_ENABLE_I915_PRELIM_DETECTION:-FALSE}"
NEO_ENABLE_XE_PRELIM_DETECTION="${NEO_ENABLE_XE_PRELIM_DETECTION:-FALSE}"
NEO_ENABLE_XE_EU_DEBUG_SUPPORT="${NEO_ENABLE_XE_EU_DEBUG_SUPPORT:-FALSE}"
NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM="${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM:-FALSE}"
#setup rpm build tree
rm -rf $BUILD_DIR
@@ -87,6 +88,7 @@ if [ "${BUILD_SRPM}" == "1" ]; then
perl -pi -e "s/^%global NEO_ENABLE_I915_PRELIM_DETECTION .*/%global NEO_ENABLE_I915_PRELIM_DETECTION ${NEO_ENABLE_I915_PRELIM_DETECTION}/" $SPEC
perl -pi -e "s/^%global NEO_ENABLE_XE_PRELIM_DETECTION .*/%global NEO_ENABLE_XE_PRELIM_DETECTION ${NEO_ENABLE_XE_PRELIM_DETECTION}/" $SPEC
perl -pi -e "s/^%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT .*/%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT ${NEO_ENABLE_XE_EU_DEBUG_SUPPORT}/" $SPEC
perl -pi -e "s/^%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM .*/%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM ${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM}/" $SPEC
perl -pi -e "s/^%global rel .*/%global rel ${RELEASE}/" $SPEC
perl -pi -e "s/^%global ver .*/%global ver ${VERSION}/" $SPEC

2
scripts/packaging/opencl/rhel_8/SPECS/opencl.spec
View File

@@ -8,6 +8,7 @@
%global NEO_ENABLE_I915_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT FALSE
%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM FALSE
%global NEO_I915_PRELIM_HEADERS_DIR %{nil}
%define _source_payload w5T16.xzdio
@@ -67,6 +68,7 @@ cd build
-DNEO_ENABLE_I915_PRELIM_DETECTION=%{NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=%{NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=%{NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=%{NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DRELEASE_WITH_REGKEYS=%{NEO_RELEASE_WITH_REGKEYS} \
-DCMAKE_VERBOSE_MAKEFILE=FALSE \
-DNEO_I915_PRELIM_HEADERS_DIR=$(realpath %{NEO_I915_PRELIM_HEADERS_DIR})

2
scripts/packaging/opencl/sles_15/SPECS/opencl.spec
View File

@@ -10,6 +10,7 @@
%global NEO_ENABLE_I915_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_PRELIM_DETECTION FALSE
%global NEO_ENABLE_XE_EU_DEBUG_SUPPORT FALSE
%global NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM FALSE
%global NEO_I915_PRELIM_HEADERS_DIR %{nil}
%global NEO_OCLOC_VERSION_MODE 1
@@ -76,6 +77,7 @@ Summary: ocloc package for opencl
-DNEO_ENABLE_I915_PRELIM_DETECTION=%{NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=%{NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=%{NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=%{NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DRELEASE_WITH_REGKEYS=%{NEO_RELEASE_WITH_REGKEYS} \
-DCMAKE_VERBOSE_MAKEFILE=FALSE \
-DNEO_I915_PRELIM_HEADERS_DIR=$(realpath %{NEO_I915_PRELIM_HEADERS_DIR})

2
scripts/packaging/opencl/ubuntu_20.04/debian/rules
View File

@@ -11,6 +11,7 @@ NEO_SKIP_AUB_TESTS_RUN ?= TRUE
NEO_ENABLE_I915_PRELIM_DETECTION ?= FALSE
NEO_ENABLE_XE_PRELIM_DETECTION ?= FALSE
NEO_ENABLE_XE_EU_DEBUG_SUPPORT ?= FALSE
NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM ?= FALSE
NEO_FORCE_USE_AUB_STREAM ?= TRUE
NEO_LEGACY_PLATFORMS_SUPPORT ?= FALSE
NEO_CURRENT_PLATFORMS_SUPPORT ?= TRUE
@@ -30,6 +31,7 @@ override_dh_auto_configure:
-DNEO_ENABLE_I915_PRELIM_DETECTION=${NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=${NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=${NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DNEO_DISABLE_BUILTINS_COMPILATION=${NEO_DISABLE_BUILTINS_COMPILATION} \
-DBUILD_WITH_L0=FALSE \
-DRELEASE_WITH_REGKEYS=${RELEASE_WITH_REGKEYS} \

2
scripts/packaging/ubuntu/debian/rules
View File

@@ -11,6 +11,7 @@ NEO_SKIP_AUB_TESTS_RUN ?= TRUE
NEO_ENABLE_I915_PRELIM_DETECTION ?= FALSE
NEO_ENABLE_XE_PRELIM_DETECTION ?= FALSE
NEO_ENABLE_XE_EU_DEBUG_SUPPORT ?= FALSE
NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM ?= FALSE
NEO_FORCE_USE_AUB_STREAM ?= TRUE
NEO_BUILD_WITH_L0 ?= TRUE
NEO_LEGACY_PLATFORMS_SUPPORT ?= FALSE
@@ -32,6 +33,7 @@ override_dh_auto_configure:
-DNEO_ENABLE_I915_PRELIM_DETECTION=${NEO_ENABLE_I915_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_PRELIM_DETECTION=${NEO_ENABLE_XE_PRELIM_DETECTION} \
-DNEO_ENABLE_XE_EU_DEBUG_SUPPORT=${NEO_ENABLE_XE_EU_DEBUG_SUPPORT} \
-DNEO_USE_XE_EU_DEBUG_EXP_UPSTREAM=${NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM} \
-DNEO_DISABLE_BUILTINS_COMPILATION=${NEO_DISABLE_BUILTINS_COMPILATION} \
-DRELEASE_WITH_REGKEYS=${RELEASE_WITH_REGKEYS} \
-DIGDRCL_FORCE_USE_LIBVA=${IGDRCL_FORCE_USE_LIBVA} \

12
shared/source/debugger/linux/debug_xe_includes.h
View File

@@ -1,12 +0,0 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "third_party/uapi-eudebug/drm/xe_drm.h"
constexpr const char *sysFsXeEuDebugFile = "/device/enable_eudebug";

89
shared/source/debugger/linux/prelim/debug_xe_includes.h
View File

@@ -1,89 +0,0 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/os_interface/linux/xe/xedrm_prelim.h"
constexpr const char *sysFsXeEuDebugFile = "/device/prelim_enable_eudebug";
#define DRM_IOCTL_XE_DEBUG_METADATA_DESTROY PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY
#define DRM_IOCTL_XE_DEBUG_METADATA_CREATE PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE
#define DRM_IOCTL_XE_EUDEBUG_CONNECT PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT
using drm_xe_vm_bind_op_ext_attach_debug = prelim_drm_xe_vm_bind_op_ext_attach_debug;
#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG
#define DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG
#define DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE
#define DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_PAGEFAULT_ENABLE PRELIM_DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_PAGEFAULT_ENABLE
using drm_xe_debug_metadata_create = prelim_drm_xe_debug_metadata_create;
#define DRM_XE_DEBUG_METADATA_ELF_BINARY PRELIM_DRM_XE_DEBUG_METADATA_ELF_BINARY
#define DRM_XE_DEBUG_METADATA_PROGRAM_MODULE PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE
#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA
#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA
#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA
#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM
using drm_xe_debug_metadata_destroy = prelim_drm_xe_debug_metadata_destroy;
#define DRM_XE_EUDEBUG_IOCTL_READ_EVENT PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_EVENT
#define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL PRELIM_DRM_XE_EUDEBUG_IOCTL_EU_CONTROL
#define DRM_XE_EUDEBUG_IOCTL_VM_OPEN PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN
#define DRM_XE_EUDEBUG_IOCTL_READ_METADATA PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_METADATA
#define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT PRELIM_DRM_XE_EUDEBUG_IOCTL_ACK_EVENT
using drm_xe_eudebug_event = prelim_drm_xe_eudebug_event;
#define DRM_XE_EUDEBUG_EVENT_NONE PRELIM_DRM_XE_EUDEBUG_EVENT_NONE
#define DRM_XE_EUDEBUG_EVENT_READ PRELIM_DRM_XE_EUDEBUG_EVENT_READ
#define DRM_XE_EUDEBUG_EVENT_OPEN PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN
#define DRM_XE_EUDEBUG_EVENT_VM PRELIM_DRM_XE_EUDEBUG_EVENT_VM
#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE
#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION
#define DRM_XE_EUDEBUG_EVENT_VM_BIND PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE
#define DRM_XE_EUDEBUG_EVENT_METADATA PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA
#define DRM_XE_EUDEBUG_EVENT_VM_SET_METADATA PRELIM_DRM_XE_EUDEBUG_EVENT_VM_SET_METADATA
#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT
#define DRM_XE_EUDEBUG_EVENT_CREATE PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE
#define DRM_XE_EUDEBUG_EVENT_DESTROY PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY
#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE PRELIM_DRM_XE_EUDEBUG_EVENT_STATE_CHANGE
#define DRM_XE_EUDEBUG_EVENT_NEED_ACK PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK
using drm_xe_eudebug_event_client = prelim_drm_xe_eudebug_event_client;
using drm_xe_eudebug_event_vm = prelim_drm_xe_eudebug_event_vm;
using drm_xe_eudebug_event_exec_queue = prelim_drm_xe_eudebug_event_exec_queue;
using drm_xe_eudebug_event_eu_attention = prelim_drm_xe_eudebug_event_eu_attention;
using drm_xe_eudebug_event_vm_bind = prelim_drm_xe_eudebug_event_vm_bind;
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE
using drm_xe_eudebug_event_vm_bind_op = prelim_drm_xe_eudebug_event_vm_bind_op;
using drm_xe_eudebug_event_vm_bind_ufence = prelim_drm_xe_eudebug_event_vm_bind_ufence;
using drm_xe_eudebug_event_metadata = prelim_drm_xe_eudebug_event_metadata;
using drm_xe_eudebug_event_vm_bind_op_metadata = prelim_drm_xe_eudebug_event_vm_bind_op_metadata;
#define DRM_XE_EUDEBUG_VERSION PRELIM_DRM_XE_EUDEBUG_VERSION
using drm_xe_eudebug_connect = prelim_drm_xe_eudebug_connect;
using drm_xe_eudebug_eu_control = prelim_drm_xe_eudebug_eu_control;
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_UNLOCK PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_UNLOCK
using drm_xe_eudebug_vm_open = prelim_drm_xe_eudebug_vm_open;
using drm_xe_eudebug_read_metadata = prelim_drm_xe_eudebug_read_metadata;
using drm_xe_eudebug_ack_event = prelim_drm_xe_eudebug_ack_event;

29
shared/source/os_interface/linux/xe/eudebug/CMakeLists.txt Normal file
View 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()

32
shared/source/os_interface/linux/xe/eudebug/create_eudebug_interface.cpp Normal file
View File

@@ -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

12
shared/source/os_interface/linux/xe/eudebug/enable_eudebug_interface_prelim.cpp Normal file
View File

@@ -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>(); });
}

12
shared/source/os_interface/linux/xe/eudebug/enable_eudebug_interface_upstream.cpp Normal file
View File

@@ -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>(); });
}

39
shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h Normal file
View File

@@ -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

211
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.cpp Normal file
View File

@@ -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

16
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h Normal file
View File

@@ -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

210
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.cpp Normal file
View File

@@ -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

19
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h Normal file
View File

@@ -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
View 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

2
shared/source/os_interface/linux/xe/ioctl_helper_xe.h
View File

@@ -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>

86
shared/source/os_interface/linux/xe/ioctl_helper_xe_debugger.cpp
View File

@@ -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

43
shared/test/common/mocks/linux/debug_mock_drm_xe.h
View File

@@ -14,17 +14,19 @@
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "shared/source/os_interface/linux/memory_info.h"
#include "shared/source/os_interface/linux/xe/ioctl_helper_xe.h"
#include "shared/source/os_interface/linux/xe/xedrm.h"
#include "shared/source/os_interface/product_helper.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/default_hw_info.h"
#include "shared/test/common/helpers/variable_backup.h"
#include "shared/test/common/libult/linux/drm_mock.h"
#include "shared/test/common/mocks/linux/mock_os_time_linux.h"
#include "shared/test/common/mocks/mock_execution_environment.h"
#include "shared/test/common/mocks/mock_io_functions.h"
#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
#include "shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h"
#include "shared/test/common/test_macros/test.h"
#include "debug_xe_includes.h"
using namespace NEO;
struct MockIoctlHelperXeDebug : IoctlHelperXe {
@@ -54,6 +56,7 @@ struct DrmMockXeDebug : public DrmMockCustom {
drm->reset();
drm->ioctlHelper = std::make_unique<IoctlHelperXe>(*drm);
EXPECT_EQ(1, drm->ioctlHelper->getEuDebugSysFsEnable());
auto xeQueryEngines = reinterpret_cast<drm_xe_query_engines *>(drm->queryEngines);
xeQueryEngines->num_engines = 11;
xeQueryEngines->engines[0] = {{DRM_XE_ENGINE_CLASS_RENDER, 0, 0}, {}};
@@ -122,7 +125,7 @@ struct DrmMockXeDebug : public DrmMockCustom {
ret = 0;
} break;
case DrmIoctl::debuggerOpen: {
auto debuggerOpen = reinterpret_cast<drm_xe_eudebug_connect *>(arg);
auto debuggerOpen = reinterpret_cast<EuDebugConnect *>(arg);
if (debuggerOpen->version != 0) {
return -1;
@@ -133,16 +136,16 @@ struct DrmMockXeDebug : public DrmMockCustom {
return debuggerOpenRetval;
} break;
case DrmIoctl::metadataCreate: {
auto metadata = reinterpret_cast<drm_xe_debug_metadata_create *>(arg);
metadataAddr = reinterpret_cast<void *>(metadata->user_addr);
auto metadata = reinterpret_cast<DebugMetadataCreate *>(arg);
metadataAddr = reinterpret_cast<void *>(metadata->userAddr);
metadataSize = metadata->len;
metadataType = metadata->type;
metadata->metadata_id = metadataID;
metadata->metadataId = metadataID;
return 0;
} break;
case DrmIoctl::metadataDestroy: {
auto metadata = reinterpret_cast<drm_xe_debug_metadata_destroy *>(arg);
metadataID = metadata->metadata_id;
auto metadata = reinterpret_cast<DebugMetadataDestroy *>(arg);
metadataID = metadata->metadataId;
return 0;
} break;
case DrmIoctl::gemWaitUserFence: {
@@ -182,6 +185,8 @@ struct DrmMockXeDebug : public DrmMockCustom {
}
return allowDebugAttach;
}
static constexpr const char *mockSysFsPciPath = "mock_sys_fs_pci_path";
std::string getSysFsPciPath() override { return mockSysFsPciPath; }
static_assert(sizeof(drm_xe_engine) == 4 * sizeof(uint64_t), "");
uint64_t queryEngines[45]{}; // 1 qword for num engines and 4 qwords per engine
@@ -204,6 +209,8 @@ struct DrmMockXeDebug : public DrmMockCustom {
std::vector<drm_xe_engine_class_instance> execQueueEngineInstances;
drm_xe_exec_queue_create execQueueCreateParams = {};
StackVec<drm_xe_wait_user_fence, 1> waitUserFenceInputs;
VariableBackup<decltype(NEO::IoFunctions::fopenPtr)> mockFopen{&NEO::IoFunctions::fopenPtr};
VariableBackup<size_t (*)(void *, size_t, size_t, FILE *)> mockFread{&NEO::IoFunctions::freadPtr};
// Debugger ioctls
int debuggerOpenRetval = 10; // debugFd
@@ -212,5 +219,23 @@ struct DrmMockXeDebug : public DrmMockCustom {
protected:
// Don't call directly, use the create() function
DrmMockXeDebug(RootDeviceEnvironment &rootDeviceEnvironment)
: DrmMockCustom(std::make_unique<HwDeviceIdDrm>(mockFd, mockPciPath), rootDeviceEnvironment) {}
: DrmMockCustom(std::make_unique<HwDeviceIdDrm>(mockFd, mockPciPath), rootDeviceEnvironment) {
NEO::IoFunctions::fopenPtr = [](const char *filename, const char *mode) -> FILE * {
std::string fsEntry(filename);
std::string expectedPath = std::string(DrmMockXeDebug::mockSysFsPciPath) + MockEuDebugInterface::sysFsXeEuDebugFile;
if (fsEntry == expectedPath) {
return reinterpret_cast<FILE *>(MockEuDebugInterface::sysFsFd);
}
return NEO::IoFunctions::mockFopen(filename, mode);
};
NEO::IoFunctions::freadPtr = [](void *ptr, size_t size, size_t count, FILE *stream) -> size_t {
if (stream == reinterpret_cast<FILE *>(MockEuDebugInterface::sysFsFd)) {
memcpy_s(ptr, size, &MockEuDebugInterface::sysFsContent, sizeof(MockEuDebugInterface::sysFsContent));
return sizeof(MockEuDebugInterface::sysFsContent);
}
return NEO::IoFunctions::mockFread(ptr, size, count, stream);
};
}
};

17
shared/test/common/os_interface/linux/xe/eudebug/CMakeLists.txt Normal file
View File

@@ -0,0 +1,17 @@
#
# Copyright (C) 2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(neo_libult_common_SRCS_LIB_ULT_LINUX_XE_EUDEBUG
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/mock_eudebug_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_eudebug_interface.cpp
)
if(UNIX)
target_sources(neo_libult_common PRIVATE ${neo_libult_common_SRCS_LIB_ULT_LINUX_XE_EUDEBUG})
endif()
set_property(GLOBAL APPEND PROPERTY neo_libult_common_SRCS_LIB_ULT_LINUX_XE_EUDEBUG ${neo_libult_common_SRCS_LIB_ULT_LINUX_XE_EUDEBUG})
add_subdirectories()

60
shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.cpp Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h"
#define RETURN_AS_IS(X) \
case X: \
return static_cast<uint32_t>(X)
#define RETURN_AS_BIT_UINT16(X) \
case X: \
static_assert(static_cast<uint32_t>(X) < 16u); \
return static_cast<uint32_t>(1 << static_cast<uint32_t>(X))
namespace NEO {
uint32_t MockEuDebugInterface::getParamValue(EuDebugParam param) const {
switch (param) {
RETURN_AS_BIT_UINT16(EuDebugParam::eventBitCreate);
RETURN_AS_BIT_UINT16(EuDebugParam::eventBitDestroy);
RETURN_AS_BIT_UINT16(EuDebugParam::eventBitStateChange);
RETURN_AS_BIT_UINT16(EuDebugParam::eventBitNeedAck);
RETURN_AS_IS(EuDebugParam::connect);
RETURN_AS_IS(EuDebugParam::euControlCmdInterruptAll);
RETURN_AS_IS(EuDebugParam::euControlCmdResume);
RETURN_AS_IS(EuDebugParam::euControlCmdStopped);
RETURN_AS_IS(EuDebugParam::execQueueSetPropertyEuDebug);
RETURN_AS_IS(EuDebugParam::eventTypeEuAttention);
RETURN_AS_IS(EuDebugParam::eventTypeExecQueue);
RETURN_AS_IS(EuDebugParam::eventTypeMetadata);
RETURN_AS_IS(EuDebugParam::eventTypeOpen);
RETURN_AS_IS(EuDebugParam::eventTypePagefault);
RETURN_AS_IS(EuDebugParam::eventTypeRead);
RETURN_AS_IS(EuDebugParam::eventTypeVm);
RETURN_AS_IS(EuDebugParam::eventTypeVmBind);
RETURN_AS_IS(EuDebugParam::eventTypeVmBindOp);
RETURN_AS_IS(EuDebugParam::eventTypeVmBindOpMetadata);
RETURN_AS_IS(EuDebugParam::eventTypeVmBindUfence);
RETURN_AS_IS(EuDebugParam::eventVmBindFlagUfence);
RETURN_AS_IS(EuDebugParam::ioctlAckEvent);
RETURN_AS_IS(EuDebugParam::ioctlEuControl);
RETURN_AS_IS(EuDebugParam::ioctlReadEvent);
RETURN_AS_IS(EuDebugParam::ioctlReadMetadata);
RETURN_AS_IS(EuDebugParam::ioctlVmOpen);
RETURN_AS_IS(EuDebugParam::metadataCreate);
RETURN_AS_IS(EuDebugParam::metadataDestroy);
RETURN_AS_IS(EuDebugParam::metadataElfBinary);
RETURN_AS_IS(EuDebugParam::metadataModuleArea);
RETURN_AS_IS(EuDebugParam::metadataProgramModule);
RETURN_AS_IS(EuDebugParam::metadataSbaArea);
RETURN_AS_IS(EuDebugParam::metadataSipArea);
RETURN_AS_IS(EuDebugParam::vmBindOpExtensionsAttachDebug);
}
return 0;
}
char MockEuDebugInterface::sysFsContent = '1';
[[maybe_unused]] static EnableEuDebugInterface enableMockEuDebug(MockEuDebugInterface::euDebugInterfaceType, MockEuDebugInterface::sysFsXeEuDebugFile, []() -> std::unique_ptr<EuDebugInterface> { return std::make_unique<MockEuDebugInterface>(); });
} // namespace NEO

21
shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h Normal file
View File

@@ -0,0 +1,21 @@
/*
* 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 MockEuDebugInterface : public EuDebugInterface {
public:
static char sysFsContent;
static constexpr const char *sysFsXeEuDebugFile = "/mock_eudebug";
static constexpr uintptr_t sysFsFd = 0xE0DEB0;
static constexpr EuDebugInterfaceType euDebugInterfaceType = EuDebugInterfaceType::upstream;
uint32_t getParamValue(EuDebugParam param) const override;
};
} // namespace NEO

29
shared/test/unit_test/os_interface/linux/xe/eudebug/CMakeLists.txt Normal file
View File

@@ -0,0 +1,29 @@
#
# Copyright (C) 2024 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
set(NEO_CORE_OS_INTERFACE_TESTS_LINUX_XE_EUDEBUG
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
)
if(NEO_ENABLE_XE_EU_DEBUG_SUPPORT)
if(NEO_USE_XE_EU_DEBUG_EXP_UPSTREAM)
list(APPEND NEO_CORE_OS_INTERFACE_TESTS_LINUX_XE_EUDEBUG
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface_upstream_tests.cpp
)
endif()
if(NEO_ENABLE_XE_PRELIM_DETECTION)
list(APPEND NEO_CORE_OS_INTERFACE_TESTS_LINUX_XE_EUDEBUG
${CMAKE_CURRENT_SOURCE_DIR}/eudebug_interface_prelim_tests.cpp
)
endif()
endif()
set_property(GLOBAL APPEND PROPERTY NEO_CORE_OS_INTERFACE_TESTS_LINUX ${NEO_CORE_OS_INTERFACE_TESTS_LINUX_XE_EUDEBUG})
if(UNIX)
target_sources(neo_shared_tests PRIVATE ${NEO_CORE_OS_INTERFACE_TESTS_LINUX_XE_EUDEBUG})
endif()
add_subdirectories()

50
shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_prelim_tests.cpp Normal file
View File

@@ -0,0 +1,50 @@
/*
* 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"
#include "shared/test/common/test_macros/test.h"
using namespace NEO;
TEST(EuDebugInterfacePrelimTest, whenGettingParamValueThenCorrectValueIsReturned) {
EuDebugInterfacePrelim euDebugInterface{};
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_IOCTL_XE_EUDEBUG_CONNECT), euDebugInterface.getParamValue(EuDebugParam::connect));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL), euDebugInterface.getParamValue(EuDebugParam::euControlCmdInterruptAll));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME), euDebugInterface.getParamValue(EuDebugParam::euControlCmdResume));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED), euDebugInterface.getParamValue(EuDebugParam::euControlCmdStopped));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_CREATE), euDebugInterface.getParamValue(EuDebugParam::eventBitCreate));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_DESTROY), euDebugInterface.getParamValue(EuDebugParam::eventBitDestroy));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_NEED_ACK), euDebugInterface.getParamValue(EuDebugParam::eventBitNeedAck));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_STATE_CHANGE), euDebugInterface.getParamValue(EuDebugParam::eventBitStateChange));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_EU_ATTENTION), euDebugInterface.getParamValue(EuDebugParam::eventTypeEuAttention));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueue));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeMetadata));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_OPEN), euDebugInterface.getParamValue(EuDebugParam::eventTypeOpen));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_PAGEFAULT), euDebugInterface.getParamValue(EuDebugParam::eventTypePagefault));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_READ), euDebugInterface.getParamValue(EuDebugParam::eventTypeRead));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_VM), euDebugInterface.getParamValue(EuDebugParam::eventTypeVm));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBind));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOp));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOpMetadata));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindUfence));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventVmBindFlagUfence));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG), euDebugInterface.getParamValue(EuDebugParam::execQueueSetPropertyEuDebug));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_IOCTL_ACK_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlAckEvent));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_IOCTL_EU_CONTROL), euDebugInterface.getParamValue(EuDebugParam::ioctlEuControl));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlReadEvent));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_IOCTL_READ_METADATA), euDebugInterface.getParamValue(EuDebugParam::ioctlReadMetadata));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_EUDEBUG_IOCTL_VM_OPEN), euDebugInterface.getParamValue(EuDebugParam::ioctlVmOpen));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_CREATE), euDebugInterface.getParamValue(EuDebugParam::metadataCreate));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_IOCTL_XE_DEBUG_METADATA_DESTROY), euDebugInterface.getParamValue(EuDebugParam::metadataDestroy));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_DEBUG_METADATA_ELF_BINARY), euDebugInterface.getParamValue(EuDebugParam::metadataElfBinary));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataModuleArea));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_DRM_XE_DEBUG_METADATA_PROGRAM_MODULE), euDebugInterface.getParamValue(EuDebugParam::metadataProgramModule));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSbaArea));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea));
EXPECT_EQ(static_cast<uint32_t>(PRELIM_XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG), euDebugInterface.getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug));
}

51
shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_upstream_tests.cpp Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright (C) 2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h"
#include "shared/test/common/test_macros/test.h"
#include "third_party/uapi-eudebug/drm/xe_drm.h"
using namespace NEO;
TEST(EuDebugInterfaceUpstreamTest, whenGettingParamValueThenCorrectValueIsReturned) {
EuDebugInterfaceUpstream euDebugInterface{};
EXPECT_EQ(static_cast<uint32_t>(DRM_IOCTL_XE_EUDEBUG_CONNECT), euDebugInterface.getParamValue(EuDebugParam::connect));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL), euDebugInterface.getParamValue(EuDebugParam::euControlCmdInterruptAll));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME), euDebugInterface.getParamValue(EuDebugParam::euControlCmdResume));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED), euDebugInterface.getParamValue(EuDebugParam::euControlCmdStopped));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_CREATE), euDebugInterface.getParamValue(EuDebugParam::eventBitCreate));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_DESTROY), euDebugInterface.getParamValue(EuDebugParam::eventBitDestroy));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_NEED_ACK), euDebugInterface.getParamValue(EuDebugParam::eventBitNeedAck));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_STATE_CHANGE), euDebugInterface.getParamValue(EuDebugParam::eventBitStateChange));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_EU_ATTENTION), euDebugInterface.getParamValue(EuDebugParam::eventTypeEuAttention));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueue));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_OPEN), euDebugInterface.getParamValue(EuDebugParam::eventTypeOpen));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_PAGEFAULT), euDebugInterface.getParamValue(EuDebugParam::eventTypePagefault));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_READ), euDebugInterface.getParamValue(EuDebugParam::eventTypeRead));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM), euDebugInterface.getParamValue(EuDebugParam::eventTypeVm));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBind));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOp));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOpMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindUfence));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventVmBindFlagUfence));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG), euDebugInterface.getParamValue(EuDebugParam::execQueueSetPropertyEuDebug));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_ACK_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlAckEvent));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_EU_CONTROL), euDebugInterface.getParamValue(EuDebugParam::ioctlEuControl));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlReadEvent));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_METADATA), euDebugInterface.getParamValue(EuDebugParam::ioctlReadMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_VM_OPEN), euDebugInterface.getParamValue(EuDebugParam::ioctlVmOpen));
EXPECT_EQ(static_cast<uint32_t>(DRM_IOCTL_XE_DEBUG_METADATA_CREATE), euDebugInterface.getParamValue(EuDebugParam::metadataCreate));
EXPECT_EQ(static_cast<uint32_t>(DRM_IOCTL_XE_DEBUG_METADATA_DESTROY), euDebugInterface.getParamValue(EuDebugParam::metadataDestroy));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_DEBUG_METADATA_ELF_BINARY), euDebugInterface.getParamValue(EuDebugParam::metadataElfBinary));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataModuleArea));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_DEBUG_METADATA_PROGRAM_MODULE), euDebugInterface.getParamValue(EuDebugParam::metadataProgramModule));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSbaArea));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea));
EXPECT_EQ(static_cast<uint32_t>(XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG), euDebugInterface.getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug));
}

54
shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_debugger_tests.cpp
View File

@@ -24,8 +24,6 @@
#include "shared/test/common/test_macros/hw_test.h"
#include "shared/test/common/test_macros/test.h"
#include "debug_xe_includes.h"
using namespace NEO;
TEST(IoctlHelperXeTest, whenCallingDebuggerOpenIoctlThenProperValueIsReturned) {
@@ -36,7 +34,7 @@ TEST(IoctlHelperXeTest, whenCallingDebuggerOpenIoctlThenProperValueIsReturned) {
auto mockXeIoctlHelper = drm->ioctlHelper.get();
drm->reset();
drm_xe_eudebug_connect test = {};
EuDebugConnect test = {};
ret = mockXeIoctlHelper->ioctl(DrmIoctl::debuggerOpen, &test);
EXPECT_EQ(ret, drm->debuggerOpenRetval);
@@ -44,8 +42,8 @@ TEST(IoctlHelperXeTest, whenCallingDebuggerOpenIoctlThenProperValueIsReturned) {
TEST(IoctlHelperXeTest, givenIoctlHelperXeWhenCallingGetIoctForDebuggerThenCorrectValueReturned) {
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]};
auto xeIoctlHelper = std::make_unique<IoctlHelperXe>(drm);
auto drm = DrmMockXeDebug::create(*executionEnvironment->rootDeviceEnvironments[0]);
auto xeIoctlHelper = drm->getIoctlHelper();
auto verifyIoctlRequestValue = [&xeIoctlHelper](auto value, DrmIoctl drmIoctl) {
EXPECT_EQ(xeIoctlHelper->getIoctlRequestValue(drmIoctl), static_cast<unsigned int>(value));
};
@@ -55,7 +53,7 @@ TEST(IoctlHelperXeTest, givenIoctlHelperXeWhenCallingGetIoctForDebuggerThenCorre
verifyIoctlString(DrmIoctl::debuggerOpen, "DRM_IOCTL_XE_EUDEBUG_CONNECT");
verifyIoctlRequestValue(DRM_IOCTL_XE_EUDEBUG_CONNECT, DrmIoctl::debuggerOpen);
verifyIoctlRequestValue(EuDebugParam::connect, DrmIoctl::debuggerOpen);
}
TEST(IoctlHelperXeTest, givenIoctlHelperXeWhenCallingGetEudebugExtPropertyThenCorrectValueReturned) {
@@ -63,7 +61,7 @@ TEST(IoctlHelperXeTest, givenIoctlHelperXeWhenCallingGetEudebugExtPropertyThenCo
executionEnvironment->setDebuggingMode(DebuggingMode::offline);
auto drm = DrmMockXeDebug::create(*executionEnvironment->rootDeviceEnvironments[0]);
auto xeIoctlHelper = static_cast<MockIoctlHelperXeDebug *>(drm->ioctlHelper.get());
EXPECT_EQ(xeIoctlHelper->getEudebugExtProperty(), DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG);
EXPECT_EQ(xeIoctlHelper->getEudebugExtProperty(), static_cast<int>(EuDebugParam::execQueueSetPropertyEuDebug));
}
using IoctlHelperXeTestFixture = ::testing::Test;
@@ -86,7 +84,7 @@ HWTEST_F(IoctlHelperXeTestFixture, GivenDebuggingDisabledWhenCreateDrmContextThe
xeIoctlHelper->createDrmContext(*drm, osContext, 0, deviceIndex, false);
auto ext = drm->receivedContextCreateSetParam;
EXPECT_NE(ext.property, static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG));
EXPECT_NE(ext.property, static_cast<uint32_t>(EuDebugParam::execQueueSetPropertyEuDebug));
}
HWTEST_F(IoctlHelperXeTestFixture, givenDeviceIndexWhenCreatingContextThenSetCorrectGtId) {
@@ -138,7 +136,7 @@ HWTEST_F(IoctlHelperXeTestFixture, GivenDebuggingEnabledWhenCreateDrmContextThen
auto ext = drm->receivedContextCreateSetParam;
EXPECT_EQ(ext.base.name, static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_EXTENSION_SET_PROPERTY));
EXPECT_EQ(ext.base.next_extension, 0ULL);
EXPECT_EQ(ext.property, static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG));
EXPECT_EQ(ext.property, static_cast<uint32_t>(EuDebugParam::execQueueSetPropertyEuDebug));
EXPECT_EQ(ext.value, 1ULL);
}
@@ -161,7 +159,7 @@ HWTEST_F(IoctlHelperXeTestFixture, GivenContextCreatedForCopyEngineWhenCreateDrm
xeIoctlHelper->createDrmContext(*drm, osContext, 0, 0, false);
auto ext = drm->receivedContextCreateSetParam;
EXPECT_NE(ext.property, static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG));
EXPECT_NE(ext.property, static_cast<uint32_t>(EuDebugParam::execQueueSetPropertyEuDebug));
}
TEST(IoctlHelperXeTest, GivenXeDriverThenDebugAttachReturnsTrue) {
@@ -173,34 +171,30 @@ TEST(IoctlHelperXeTest, GivenXeDriverThenDebugAttachReturnsTrue) {
TEST(IoctlHelperXeTest, givenXeEnableEuDebugThenReturnCorrectValue) {
VariableBackup<size_t> mockFreadReturnBackup(&IoFunctions::mockFreadReturn, 1);
std::unique_ptr<char[]> buffer = std::make_unique<char[]>(IoFunctions::mockFreadReturn);
VariableBackup<char *> mockFreadBufferBackup(&IoFunctions::mockFreadBuffer, buffer.get());
VariableBackup<char> euDebugAvailabilityBackup(&MockEuDebugInterface::sysFsContent);
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
auto drm = DrmMockXeDebug::create(*executionEnvironment->rootDeviceEnvironments[0]);
auto xeIoctlHelper = static_cast<MockIoctlHelperXeDebug *>(drm->ioctlHelper.get());
buffer[0] = '1';
MockEuDebugInterface::sysFsContent = '1';
int enableEuDebug = xeIoctlHelper->getEuDebugSysFsEnable();
EXPECT_EQ(1, enableEuDebug);
buffer[0] = '0';
MockEuDebugInterface::sysFsContent = '0';
enableEuDebug = xeIoctlHelper->getEuDebugSysFsEnable();
EXPECT_EQ(0, enableEuDebug);
}
TEST(IoctlHelperXeTest, givenXeEnableEuDebugWithInvalidPathThenReturnCorrectValue) {
VariableBackup<size_t> mockFreadReturnBackup(&IoFunctions::mockFreadReturn, 1);
std::unique_ptr<char[]> buffer = std::make_unique<char[]>(IoFunctions::mockFreadReturn);
VariableBackup<char *> mockFreadBufferBackup(&IoFunctions::mockFreadBuffer, buffer.get());
auto executionEnvironment = std::make_unique<MockExecutionEnvironment>();
auto drm = DrmMockXeDebug::create(*executionEnvironment->rootDeviceEnvironments[0]);
auto xeIoctlHelper = static_cast<MockIoctlHelperXeDebug *>(drm->ioctlHelper.get());
buffer[0] = '1';
VariableBackup<FILE *> mockFopenReturnBackup(&IoFunctions::mockFopenReturned, nullptr);
VariableBackup<size_t> mockFreadReturnBackup(&IoFunctions::mockFreadReturn, 0);
VariableBackup<const char *> eudebugSysFsEntryBackup(&eudebugSysfsEntry[static_cast<uint32_t>(MockEuDebugInterface::euDebugInterfaceType)], "invalidEntry");
int enableEuDebug = xeIoctlHelper->getEuDebugSysFsEnable();
EXPECT_EQ(0, enableEuDebug);
@@ -217,7 +211,7 @@ TEST(IoctlHelperXeTest, givenXeRegisterResourceThenCorrectIoctlCalled) {
EXPECT_EQ(drm->metadataID, id);
EXPECT_EQ(drm->metadataAddr, buffer);
EXPECT_EQ(drm->metadataSize, bufferSize);
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(DRM_XE_DEBUG_METADATA_ELF_BINARY));
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(EuDebugParam::metadataElfBinary));
drm->metadataID = 0;
drm->metadataAddr = nullptr;
@@ -226,7 +220,7 @@ TEST(IoctlHelperXeTest, givenXeRegisterResourceThenCorrectIoctlCalled) {
EXPECT_EQ(drm->metadataID, id);
EXPECT_EQ(drm->metadataAddr, buffer);
EXPECT_EQ(drm->metadataSize, bufferSize);
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(DRM_XE_DEBUG_METADATA_PROGRAM_MODULE));
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(EuDebugParam::metadataProgramModule));
drm->metadataID = 0;
drm->metadataAddr = nullptr;
@@ -235,7 +229,7 @@ TEST(IoctlHelperXeTest, givenXeRegisterResourceThenCorrectIoctlCalled) {
EXPECT_EQ(drm->metadataID, id);
EXPECT_EQ(drm->metadataAddr, buffer);
EXPECT_EQ(drm->metadataSize, bufferSize);
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA));
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(EuDebugParam::metadataSipArea));
drm->metadataID = 0;
drm->metadataAddr = nullptr;
@@ -244,7 +238,7 @@ TEST(IoctlHelperXeTest, givenXeRegisterResourceThenCorrectIoctlCalled) {
EXPECT_EQ(drm->metadataID, id);
EXPECT_EQ(drm->metadataAddr, buffer);
EXPECT_EQ(drm->metadataSize, bufferSize);
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA));
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(EuDebugParam::metadataSbaArea));
drm->metadataID = 0;
drm->metadataAddr = nullptr;
@@ -253,7 +247,7 @@ TEST(IoctlHelperXeTest, givenXeRegisterResourceThenCorrectIoctlCalled) {
EXPECT_EQ(drm->metadataID, id);
EXPECT_EQ(drm->metadataAddr, buffer);
EXPECT_EQ(drm->metadataSize, bufferSize);
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA));
EXPECT_EQ(drm->metadataType, static_cast<uint64_t>(EuDebugParam::metadataModuleArea));
}
TEST(IoctlHelperXeTest, givenXeunregisterResourceThenCorrectIoctlCalled) {
@@ -274,16 +268,16 @@ TEST(IoctlHelperXeTest, whenGettingVmBindExtFromHandlesThenProperStructsAreRetur
bindExtHandles.push_back(2u);
bindExtHandles.push_back(3u);
auto retVal = xeIoctlHelper->prepareVmBindExt(bindExtHandles);
auto vmBindExt = reinterpret_cast<drm_xe_vm_bind_op_ext_attach_debug *>(retVal.get());
auto vmBindExt = reinterpret_cast<VmBindOpExtAttachDebug *>(retVal.get());
for (size_t i = 0; i < bindExtHandles.size(); i++) {
EXPECT_EQ(bindExtHandles[i], vmBindExt[i].metadata_id);
EXPECT_EQ(static_cast<uint32_t>(XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG), vmBindExt[i].base.name);
EXPECT_EQ(bindExtHandles[i], vmBindExt[i].metadataId);
EXPECT_EQ(static_cast<uint32_t>(EuDebugParam::vmBindOpExtensionsAttachDebug), vmBindExt[i].base.name);
}
EXPECT_EQ(reinterpret_cast<uintptr_t>(&vmBindExt[1]), vmBindExt[0].base.next_extension);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&vmBindExt[2]), vmBindExt[1].base.next_extension);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&vmBindExt[1]), vmBindExt[0].base.nextExtension);
EXPECT_EQ(reinterpret_cast<uintptr_t>(&vmBindExt[2]), vmBindExt[1].base.nextExtension);
}
TEST(IoctlHelperXeTest, givenResourceRegistrationEnabledWhenAllocationTypeShouldBeRegisteredThenBoHasBindExtHandleAdded) {