intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-13 10:14:36 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Add type conversion handling methods for EuDebugInterface

Browse Source 
Resolves: NEO-16068

Signed-off-by: Jemale Lockett <jemale.lockett@intel.com>
This commit is contained in:
Jemale Lockett
2025-10-13 16:48:00 +00:00
committed by Compute-Runtime-Automation
parent a2503a2e14
commit 765af92aca
16 changed files with 1552 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/tools/source/debug/linux/debug_session_factory.h
View File

@@ -1,10 +1,12 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
#include "level_zero/tools/source/debug/debug_session.h"
namespace L0 {

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

@@ -21,12 +21,11 @@ namespace L0 {
static DebugSessionLinuxPopulateFactory<DEBUG_SESSION_LINUX_TYPE_XE, DebugSessionLinuxXe>
populateXeDebugger;
DebugSession *createDebugSessionHelperXe(const zet_debug_config_t &config, Device *device, int debugFd, void *params);
DebugSession *createDebugSessionHelperXe(const zet_debug_config_t &config, Device *device, int debugFd, std::unique_ptr<NEO::EuDebugInterface> debugInterface, void *params);
DebugSessionLinuxXe::DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, void *params) : DebugSessionLinux(config, device, debugFd) {
auto sysFsPciPath = DrmHelper::getSysFsPciPath(device);
euDebugInterface = NEO::EuDebugInterface::create(sysFsPciPath);
if (euDebugInterface) {
DebugSessionLinuxXe::DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, std::unique_ptr<NEO::EuDebugInterface> debugInterface, void *params) : DebugSessionLinux(config, device, debugFd) {
if (debugInterface) {
euDebugInterface = std::move(debugInterface);
ioctlHandler.reset(new IoctlHandlerXe(*euDebugInterface));
if (params) {
this->xeDebuggerVersion = reinterpret_cast<NEO::EuDebugConnect *>(params)->version;
@@ -47,12 +46,23 @@ DebugSession *DebugSessionLinuxXe::createLinuxSession(const zet_debug_config_t &
.pid = config.pid,
.flags = 0,
.version = 0};
auto debugFd = DrmHelper::ioctl(device, NEO::DrmIoctl::debuggerOpen, &open);
auto debugInterface = NEO::EuDebugInterface::create(DrmHelper::getSysFsPciPath(device));
int debugFd = 0;
if (debugInterface == nullptr) {
PRINT_DEBUGGER_ERROR_LOG("Failed to create EuDebugInterface for drm_xe_eu_debug_connect\n", "");
debugFd = DrmHelper::ioctl(device, NEO::DrmIoctl::debuggerOpen, &open);
} else {
auto drmOpen = debugInterface->toDrmEuDebugConnect(open);
debugFd = DrmHelper::ioctl(device, NEO::DrmIoctl::debuggerOpen, drmOpen.get());
open = debugInterface->toEuDebugConnect(drmOpen.get());
}
if (debugFd >= 0) {
PRINT_DEBUGGER_INFO_LOG("drm_xe_eudebug_connect: open.pid: %d, debugFd: %d\n",
open.pid, debugFd);
return createDebugSessionHelperXe(config, device, debugFd, &open);
return createDebugSessionHelperXe(config, device, debugFd, std::move(debugInterface), &open);
} else {
auto reason = DrmHelper::getErrno(device);
PRINT_DEBUGGER_ERROR_LOG("drm_xe_eudebug_connect failed: open.pid: %d, retCode: %d, errno: %d\n",
@@ -184,38 +194,37 @@ void DebugSessionLinuxXe::handleEvent(NEO::EuDebugEvent *event) {
(uint16_t)event->type, (uint16_t)event->flags, (uint64_t)event->seqno, (uint32_t)event->len);
if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeOpen)) {
auto clientEvent = reinterpret_cast<NEO::EuDebugEventClient *>(event);
auto clientEvent = euDebugInterface->toEuDebugEventClient(event);
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;
DEBUG_BREAK_IF(clientHandleToConnection.find(clientEvent.clientHandle) != clientHandleToConnection.end());
clientHandleToConnection[clientEvent.clientHandle].reset(new ClientConnectionXe);
clientHandleToConnection[clientEvent.clientHandle]->client = clientEvent;
}
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitDestroy)) {
clientHandleClosed = clientEvent->clientHandle;
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->clientHandle);
(uint64_t)clientEvent.clientHandle);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVm)) {
NEO::EuDebugEventVm *vm = reinterpret_cast<NEO::EuDebugEventVm *>(event);
NEO::EuDebugEventVm vm = euDebugInterface->toEuDebugEventVm(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->clientHandle, (uint64_t)vm->vmHandle);
(uint64_t)vm.clientHandle, (uint64_t)vm.vmHandle);
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));
UNRECOVERABLE_IF(clientHandleToConnection.find(vm.clientHandle) == clientHandleToConnection.end());
clientHandleToConnection[vm.clientHandle]->vmIds.emplace(static_cast<uint64_t>(vm.vmHandle));
}
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));
UNRECOVERABLE_IF(clientHandleToConnection.find(vm.clientHandle) == clientHandleToConnection.end());
clientHandleToConnection[vm.clientHandle]->vmIds.erase(static_cast<uint64_t>(vm.vmHandle));
}
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeExecQueue)) {
NEO::EuDebugEventExecQueue *execQueue = reinterpret_cast<NEO::EuDebugEventExecQueue *>(event);
auto execQueue = euDebugInterface->toEuDebugEventExecQueue(event);
if (event->flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventBitCreate)) {
UNRECOVERABLE_IF(clientHandleToConnection.find(execQueue->clientHandle) == clientHandleToConnection.end());
@@ -265,7 +274,7 @@ void DebugSessionLinuxXe::handleEvent(NEO::EuDebugEvent *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);
auto attention = euDebugInterface->toEuDebugEventEuAttention(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->clientHandle, (uint64_t)attention->flags,
@@ -273,80 +282,77 @@ void DebugSessionLinuxXe::handleEvent(NEO::EuDebugEvent *event) {
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);
handleAttentionEvent(attention.get());
}
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBind)) {
NEO::EuDebugEventVmBind *vmBind = reinterpret_cast<NEO::EuDebugEventVmBind *>(event);
UNRECOVERABLE_IF(clientHandleToConnection.find(vmBind->clientHandle) == clientHandleToConnection.end());
NEO::EuDebugEventVmBind vmBind = euDebugInterface->toEuDebugEventVmBind(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->clientHandle), static_cast<uint64_t>(vmBind->vmHandle),
static_cast<uint64_t>(vmBind->numBinds), 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->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->numBinds;
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.numBinds;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBindOp)) {
NEO::EuDebugEventVmBindOp *vmBindOp = reinterpret_cast<NEO::EuDebugEventVmBindOp *>(event);
NEO::EuDebugEventVmBindOp vmBindOp = euDebugInterface->toEuDebugEventVmBindOp(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->vmBindRefSeqno), static_cast<uint64_t>(vmBindOp->numExtensions),
static_cast<uint64_t>(vmBindOp->addr), static_cast<uint64_t>(vmBindOp->range));
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->vmBindRefSeqno) == vmBindMap.end());
auto &vmBindData = vmBindMap[vmBindOp->vmBindRefSeqno];
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->numExtensions;
vmBindOpData.vmBindOp = *vmBindOp;
auto &vmBindOpData = vmBindData.vmBindOpMap[vmBindOp.base.seqno];
vmBindOpData.pendingNumExtensions = vmBindOp.numExtensions;
vmBindOpData.vmBindOp = vmBindOp;
vmBindData.pendingNumBinds--;
clientHandleToConnection[clientHandle]->vmBindIdentifierMap[vmBindOp->base.seqno] = vmBindOp->vmBindRefSeqno;
clientHandleToConnection[clientHandle]->vmBindIdentifierMap[vmBindOp.base.seqno] = vmBindOp.vmBindRefSeqno;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBindUfence)) {
NEO::EuDebugEventVmBindUfence *vmBindUfence = reinterpret_cast<NEO::EuDebugEventVmBindUfence *>(event);
NEO::EuDebugEventVmBindUfence vmBindUfence = euDebugInterface->toEuDebugEventVmBindUfence(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->vmBindRefSeqno));
static_cast<uint64_t>(vmBindUfence.vmBindRefSeqno));
auto &vmBindMap = clientHandleToConnection[clientHandle]->vmBindMap;
UNRECOVERABLE_IF(vmBindMap.find(vmBindUfence->vmBindRefSeqno) == vmBindMap.end());
uint32_t uFenceRequired = vmBindMap[vmBindUfence->vmBindRefSeqno].vmBind.flags & euDebugInterface->getParamValue(NEO::EuDebugParam::eventVmBindFlagUfence);
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->vmBindRefSeqno].uFenceReceived); // Dont expect multiple UFENCE for same vm_bind
vmBindMap[vmBindUfence->vmBindRefSeqno].uFenceReceived = true;
vmBindMap[vmBindUfence->vmBindRefSeqno].vmBindUfence = *vmBindUfence;
UNRECOVERABLE_IF(vmBindMap[vmBindUfence.vmBindRefSeqno].uFenceReceived); // Dont expect multiple UFENCE for same vm_bind
vmBindMap[vmBindUfence.vmBindRefSeqno].uFenceReceived = true;
vmBindMap[vmBindUfence.vmBindRefSeqno].vmBindUfence = vmBindUfence;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeMetadata)) {
NEO::EuDebugEventMetadata *metaData = reinterpret_cast<NEO::EuDebugEventMetadata *>(event);
NEO::EuDebugEventMetadata metaData = euDebugInterface->toEuDebugEventMetadata(event);
if (clientHandle == invalidClientHandle) {
clientHandle = metaData->clientHandle;
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->clientHandle, (uint64_t)metaData->metadataHandle, (uint64_t)metaData->type, (uint64_t)metaData->len);
handleMetadataEvent(metaData);
(uint64_t)metaData.clientHandle, (uint64_t)metaData.metadataHandle, (uint64_t)metaData.type, (uint64_t)metaData.len);
handleMetadataEvent(&metaData);
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeVmBindOpMetadata)) {
NEO::EuDebugEventVmBindOpMetadata *vmBindOpMetadata = reinterpret_cast<NEO::EuDebugEventVmBindOpMetadata *>(event);
NEO::EuDebugEventVmBindOpMetadata vmBindOpMetadata = euDebugInterface->toEuDebugEventVmBindOpMetadata(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->vmBindOpRefSeqno), static_cast<uint64_t>(vmBindOpMetadata->metadataHandle),
static_cast<uint64_t>(vmBindOpMetadata->metadataCookie));
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->vmBindOpRefSeqno) == vmBindIdentifierMap.end());
VmBindSeqNo vmBindSeqNo = vmBindIdentifierMap[vmBindOpMetadata->vmBindOpRefSeqno];
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->vmBindOpRefSeqno];
auto &vmBindOpData = vmBindMap[vmBindSeqNo].vmBindOpMap[vmBindOpMetadata.vmBindOpRefSeqno];
UNRECOVERABLE_IF(!vmBindOpData.pendingNumExtensions);
vmBindOpData.vmBindOpMetadataVec.push_back(*vmBindOpMetadata);
vmBindOpData.vmBindOpMetadataVec.push_back(vmBindOpMetadata);
vmBindOpData.pendingNumExtensions--;
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeExecQueuePlacements)) {
NEO::EuDebugEventExecQueuePlacements *execQueuePlacements = reinterpret_cast<NEO::EuDebugEventExecQueuePlacements *>(event);
auto execQueuePlacements = euDebugInterface->toEuDebugEventExecQueuePlacements(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: PRELIM_DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS client_handle = %" SCNx64
" vm_handle = %" SCNx64
@@ -377,7 +383,7 @@ void DebugSessionLinuxXe::handleEvent(NEO::EuDebugEvent *event) {
static_cast<uint64_t>(execQueuePlacements->clientHandle), static_cast<uint64_t>(execQueuePlacements->vmHandle), tileIndex);
}
} else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypePagefault)) {
NEO::EuDebugEventPageFault *pf = reinterpret_cast<NEO::EuDebugEventPageFault *>(event);
auto pf = euDebugInterface->toEuDebugEventPageFault(event);
PRINT_DEBUGGER_INFO_LOG("DRM_XE_EUDEBUG_IOCTL_READ_EVENT type: DRM_XE_EUDEBUG_EVENT_PAGEFAULT flags = %d, address = %llu seqno = %d, length = %llu"
" client_handle = %llu pf_flags = %llu bitmask_size = %lu exec_queue_handle = %llu\n",
@@ -711,7 +717,8 @@ int DebugSessionLinuxXe::openVmFd(uint64_t vmHandle, [[maybe_unused]] bool readO
.flags = 0,
.timeoutNs = 5000000000u};
return ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlVmOpen), &vmOpen);
auto drmVmOpen = euDebugInterface->toDrmEuDebugVmOpen(vmOpen);
return ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlVmOpen), drmVmOpen.get());
}
int DebugSessionLinuxXe::flushVmCache(int vmfd) {
@@ -779,11 +786,14 @@ int DebugSessionLinuxXe::threadControlInterruptAll() {
euControl.execQueueHandle = execQueue.first;
for (const auto &lrcHandle : execQueue.second.lrcHandles) {
euControl.lrcHandle = lrcHandle;
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), &euControl);
auto drmEuControl = euDebugInterface->toDrmEuDebugEuControl(euControl);
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), drmEuControl.get());
euControl = euDebugInterface->toEuDebugEuControl(drmEuControl.get());
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.execQueueHandle),
static_cast<uint64_t>(euControl.lrcHandle));
} else {
DEBUG_BREAK_IF(euControlInterruptSeqno >= euControl.seqno);
euControlInterruptSeqno = euControl.seqno;
@@ -816,7 +826,9 @@ int DebugSessionLinuxXe::threadControlStopped(std::unique_ptr<uint8_t[]> &bitmas
euControl.execQueueHandle = execQueue.first;
for (const auto &lrcHandle : execQueue.second.lrcHandles) {
euControl.lrcHandle = lrcHandle;
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), &euControl);
auto drmEuControl = euDebugInterface->toDrmEuDebugEuControl(euControl);
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), drmEuControl.get());
euControl = euDebugInterface->toEuDebugEuControl(drmEuControl.get());
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.execQueueHandle),
@@ -838,8 +850,10 @@ int DebugSessionLinuxXe::threadControlStopped(std::unique_ptr<uint8_t[]> &bitmas
}
}
printBitmask(bitmask.get(), bitmaskSize);
bitmaskOut = std::move(bitmask);
auto temp = std::make_unique<uint8_t[]>(euControl.bitmaskSize);
memcpy_s(temp.get(), euControl.bitmaskSize, reinterpret_cast<void *>(euControl.bitmaskPtr), euControl.bitmaskSize);
printBitmask(temp.get(), euControl.bitmaskSize);
bitmaskOut = std::move(temp);
UNRECOVERABLE_IF(bitmaskOut.get() == nullptr);
bitmaskSizeOut = euControl.bitmaskSize;
return euControlRetVal;
@@ -869,7 +883,8 @@ int DebugSessionLinuxXe::threadControlResume(const std::vector<EuThread::ThreadI
auto invokeIoctl = [&](int cmd) {
euControl.cmd = cmd;
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), &euControl);
auto drmEuControl = euDebugInterface->toDrmEuDebugEuControl(euControl);
euControlRetVal = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlEuControl), drmEuControl.get());
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.execQueueHandle),
@@ -914,7 +929,9 @@ int DebugSessionLinuxXe::eventAckIoctl(EventToAck &event) {
eventToAck.type = event.type;
eventToAck.seqno = event.seqno;
eventToAck.flags = 0;
auto ret = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlAckEvent), &eventToAck);
auto drmEventToAck = euDebugInterface->toDrmEuDebugAckEvent(eventToAck);
auto ret = ioctl(euDebugInterface->getParamValue(NEO::EuDebugParam::ioctlAckEvent), drmEventToAck.get());
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;
}

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

@@ -23,7 +23,7 @@ struct Device;
struct DebugSessionLinuxXe : DebugSessionLinux {
~DebugSessionLinuxXe() override;
DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, void *params);
DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, std::unique_ptr<NEO::EuDebugInterface> debugInterface, void *params);
static DebugSession *createLinuxSession(const zet_debug_config_t &config, Device *device, ze_result_t &result, bool isRootAttach);
struct IoctlHandlerXe : DebugSessionLinux::IoctlHandler {

4
level_zero/tools/source/debug/linux/xe/debug_session_xe_helper.cpp
View File

@@ -9,8 +9,8 @@
namespace L0 {
DebugSession *createDebugSessionHelperXe(const zet_debug_config_t &config, Device *device, int debugFd, void *params) {
return new DebugSessionLinuxXe(config, device, debugFd, params);
DebugSession *createDebugSessionHelperXe(const zet_debug_config_t &config, Device *device, int debugFd, std::unique_ptr<NEO::EuDebugInterface> debugInterface, void *params) {
return new DebugSessionLinuxXe(config, device, debugFd, std::move(debugInterface), params);
}
} // namespace L0