intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-30 01:35:20 +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

12
level_zero/tools/test/unit_tests/sources/debug/debug_session_helper.cpp
View File

@@ -1,10 +1,18 @@
/*
* Copyright (C) 2021-2023 Intel Corporation
* Copyright (C) 2021-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#ifdef _WIN32
namespace NEO {
class EuDebugInterface {};
} // namespace NEO
#else
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h"
#endif
#include "level_zero/tools/test/unit_tests/sources/debug/mock_debug_session.h"
#include <level_zero/ze_api.h>
@@ -21,7 +29,7 @@ DebugSession *createDebugSessionHelper(const zet_debug_config_t &config, Device
return new L0::ult::DebugSessionMock(config, device);
}
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) {
if (L0::ult::createDebugSessionFuncXe) {
return L0::ult::createDebugSessionFuncXe(config, device, debugFd, params);
}

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

@@ -6,6 +6,7 @@
*/
#include "shared/source/os_interface/linux/drm_debug.h"
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h"
#include "shared/source/os_interface/os_interface.h"
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/gtest_helpers.h"
@@ -200,7 +201,7 @@ struct MockDebugSessionLinuxXe : public L0::DebugSessionLinuxXe {
using L0::DebugSessionLinuxXe::threadControl;
using L0::DebugSessionLinuxXe::ThreadControlCmd;
MockDebugSessionLinuxXe(const zet_debug_config_t &config, L0::Device *device, int debugFd, void *params) : DebugSessionLinuxXe(config, device, debugFd, params) {
MockDebugSessionLinuxXe(const zet_debug_config_t &config, L0::Device *device, int debugFd, void *params) : DebugSessionLinuxXe(config, device, debugFd, std::make_unique<MockEuDebugInterface>(), params) {
clientHandleToConnection[mockClientHandle].reset(new ClientConnectionXe);
clientHandle = mockClientHandle;
createEuThreads();

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

@@ -755,8 +755,9 @@ TEST_F(DebugApiLinuxTestXe, GivenEuDebugExecQueueEventWithEventDestroyFlagWhenHa
client1.clientHandle = 0x123456789;
session->handleEvent(reinterpret_cast<NEO::EuDebugEvent *>(&client1));
uint64_t execQueueData[sizeof(NEO::EuDebugEventExecQueue) / sizeof(uint64_t) + 3 * sizeof(typeOfLrcHandle)];
auto *lrcHandle = reinterpret_cast<typeOfLrcHandle *>(ptrOffset(execQueueData, sizeof(NEO::EuDebugEventExecQueue)));
NEO::EuDebugEventExecQueue *execQueue = static_cast<NEO::EuDebugEventExecQueue *>(malloc(sizeof(NEO::EuDebugEventExecQueue) + 3 * sizeof(typeOfLrcHandle)));
auto &lrcHandle = execQueue->lrcHandle;
typeOfLrcHandle lrcHandleTemp[3];
const uint64_t lrcHandle0 = 2;
const uint64_t lrcHandle1 = 3;
@@ -766,7 +767,6 @@ TEST_F(DebugApiLinuxTestXe, GivenEuDebugExecQueueEventWithEventDestroyFlagWhenHa
lrcHandleTemp[2] = static_cast<typeOfLrcHandle>(lrcHandle2);
// ExecQueue create event handle
NEO::EuDebugEventExecQueue *execQueue = reinterpret_cast<NEO::EuDebugEventExecQueue *>(&execQueueData);
execQueue->base.type = static_cast<uint16_t>(NEO::EuDebugParam::eventTypeExecQueue);
execQueue->base.flags = static_cast<uint16_t>(NEO::shiftLeftBy(static_cast<uint16_t>(NEO::EuDebugParam::eventBitCreate)));
execQueue->clientHandle = client1.clientHandle;
@@ -797,6 +797,8 @@ TEST_F(DebugApiLinuxTestXe, GivenEuDebugExecQueueEventWithEventDestroyFlagWhenHa
session->handleEvent(&execQueue->base);
EXPECT_TRUE(session->clientHandleToConnection[execQueue->clientHandle]->execQueues.empty());
EXPECT_TRUE(session->clientHandleToConnection[execQueue->clientHandle]->lrcHandleToVmHandle.empty());
free(execQueue);
}
TEST_F(DebugApiLinuxTestXe, GivenExecQueueWhenGetVmHandleFromClientAndlrcHandleThenProperVmHandleReturned) {
@@ -2994,7 +2996,7 @@ TEST(DebugSessionLinuxXeTest, GivenRootDebugSessionWhenCreateTileSessionCalledTh
using DebugSessionLinuxXe::createTileSession;
using DebugSessionLinuxXe::DebugSessionLinuxXe;
};
auto session = std::make_unique<DebugSession>(zet_debug_config_t{0x1234}, &deviceImp, 10, nullptr);
auto session = std::make_unique<DebugSession>(zet_debug_config_t{0x1234}, &deviceImp, 10, nullptr, nullptr);
ASSERT_NE(nullptr, session);
std::unique_ptr<DebugSessionImp> tileSession = std::unique_ptr<DebugSessionImp>{session->createTileSession(zet_debug_config_t{0x1234}, &deviceImp, nullptr)};

19
shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h
View File

@@ -18,6 +18,25 @@ class EuDebugInterface {
virtual uint32_t getParamValue(EuDebugParam param) const = 0;
virtual bool isExecQueuePageFaultEnableSupported() { return false; };
virtual ~EuDebugInterface() = default;
virtual std::unique_ptr<EuDebugEventEuAttention> toEuDebugEventEuAttention(const void *drmType) = 0;
virtual EuDebugEventClient toEuDebugEventClient(const void *drmType) = 0;
virtual EuDebugEventVm toEuDebugEventVm(const void *drmType) = 0;
virtual std::unique_ptr<EuDebugEventExecQueue> toEuDebugEventExecQueue(const void *drmType) = 0;
virtual std::unique_ptr<EuDebugEventExecQueuePlacements> toEuDebugEventExecQueuePlacements(const void *drmType) = 0;
virtual EuDebugEventMetadata toEuDebugEventMetadata(const void *drmType) = 0;
virtual EuDebugEventVmBind toEuDebugEventVmBind(const void *drmType) = 0;
virtual EuDebugEventVmBindOp toEuDebugEventVmBindOp(const void *drmType) = 0;
virtual EuDebugEventVmBindOpMetadata toEuDebugEventVmBindOpMetadata(const void *drmType) = 0;
virtual EuDebugEventVmBindUfence toEuDebugEventVmBindUfence(const void *drmType) = 0;
virtual std::unique_ptr<EuDebugEventPageFault> toEuDebugEventPageFault(const void *drmType) = 0;
virtual EuDebugEuControl toEuDebugEuControl(const void *drmType) = 0;
virtual EuDebugConnect toEuDebugConnect(const void *drmType) = 0;
virtual std::unique_ptr<void, void (*)(void *)> toDrmEuDebugConnect(const EuDebugConnect &connect) = 0;
virtual std::unique_ptr<void, void (*)(void *)> toDrmEuDebugEuControl(const EuDebugEuControl &euControl) = 0;
virtual std::unique_ptr<void, void (*)(void *)> toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) = 0;
virtual std::unique_ptr<void, void (*)(void *)> toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) = 0;
};
enum class EuDebugInterfaceType : uint32_t {

379
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.cpp
View File

@@ -9,6 +9,8 @@
#include "shared/source/os_interface/linux/xe/xedrm_prelim.h"
#include <string.h>
namespace NEO {
uint32_t EuDebugInterfacePrelim::getParamValue(EuDebugParam param) const {
switch (param) {
@@ -90,11 +92,288 @@ uint32_t EuDebugInterfacePrelim::getParamValue(EuDebugParam param) const {
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));
std::unique_ptr<EuDebugEventEuAttention> EuDebugInterfacePrelim::toEuDebugEventEuAttention(const void *drmType) {
const prelim_drm_xe_eudebug_event_eu_attention *event = static_cast<const prelim_drm_xe_eudebug_event_eu_attention *>(drmType);
EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t)));
pEuAttentionEvent->base.len = event->base.len;
pEuAttentionEvent->base.type = event->base.type;
pEuAttentionEvent->base.flags = event->base.flags;
pEuAttentionEvent->base.seqno = event->base.seqno;
pEuAttentionEvent->base.reserved = event->base.reserved;
memcpy(pEuAttentionEvent->bitmask, event->bitmask, event->bitmask_size);
pEuAttentionEvent->bitmaskSize = event->bitmask_size;
pEuAttentionEvent->flags = event->flags;
pEuAttentionEvent->lrcHandle = event->lrc_handle;
pEuAttentionEvent->execQueueHandle = event->exec_queue_handle;
pEuAttentionEvent->clientHandle = event->client_handle;
return std::unique_ptr<EuDebugEventEuAttention>(pEuAttentionEvent);
}
EuDebugEventClient EuDebugInterfacePrelim::toEuDebugEventClient(const void *drmType) {
const prelim_drm_xe_eudebug_event_client *event = static_cast<const prelim_drm_xe_eudebug_event_client *>(drmType);
EuDebugEventClient euClientEvent = {};
euClientEvent.base.len = event->base.len;
euClientEvent.base.type = event->base.type;
euClientEvent.base.flags = event->base.flags;
euClientEvent.base.seqno = event->base.seqno;
euClientEvent.base.reserved = event->base.reserved;
euClientEvent.clientHandle = event->client_handle;
return euClientEvent;
}
EuDebugEventVm EuDebugInterfacePrelim::toEuDebugEventVm(const void *drmType) {
const prelim_drm_xe_eudebug_event_vm *event = static_cast<const prelim_drm_xe_eudebug_event_vm *>(drmType);
EuDebugEventVm euVmEvent = {};
euVmEvent.base.len = event->base.len;
euVmEvent.base.type = event->base.type;
euVmEvent.base.flags = event->base.flags;
euVmEvent.base.seqno = event->base.seqno;
euVmEvent.base.reserved = event->base.reserved;
euVmEvent.clientHandle = event->client_handle;
euVmEvent.vmHandle = event->vm_handle;
return euVmEvent;
}
std::unique_ptr<EuDebugEventExecQueue> EuDebugInterfacePrelim::toEuDebugEventExecQueue(const void *drmType) {
const prelim_drm_xe_eudebug_event_exec_queue *event = static_cast<const prelim_drm_xe_eudebug_event_exec_queue *>(drmType);
EuDebugEventExecQueue *pExecQueueEvent = static_cast<EuDebugEventExecQueue *>(malloc(sizeof(EuDebugEventExecQueue) + event->width * sizeof(uint64_t)));
pExecQueueEvent->base.len = event->base.len;
pExecQueueEvent->base.type = event->base.type;
pExecQueueEvent->base.flags = event->base.flags;
pExecQueueEvent->base.seqno = event->base.seqno;
pExecQueueEvent->base.reserved = event->base.reserved;
pExecQueueEvent->execQueueHandle = event->exec_queue_handle;
pExecQueueEvent->engineClass = event->engine_class;
pExecQueueEvent->width = event->width;
pExecQueueEvent->vmHandle = event->vm_handle;
pExecQueueEvent->clientHandle = event->client_handle;
memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t));
return std::unique_ptr<EuDebugEventExecQueue>(pExecQueueEvent);
}
std::unique_ptr<EuDebugEventExecQueuePlacements> EuDebugInterfacePrelim::toEuDebugEventExecQueuePlacements(const void *drmType) {
const prelim_drm_xe_eudebug_event_exec_queue_placements *event = static_cast<const prelim_drm_xe_eudebug_event_exec_queue_placements *>(drmType);
EuDebugEventExecQueuePlacements *euExecQueuePlacementsEvent = static_cast<EuDebugEventExecQueuePlacements *>(malloc(sizeof(EuDebugEventExecQueuePlacements) + event->num_placements * sizeof(uint64_t)));
euExecQueuePlacementsEvent->base.len = event->base.len;
euExecQueuePlacementsEvent->base.type = event->base.type;
euExecQueuePlacementsEvent->base.flags = event->base.flags;
euExecQueuePlacementsEvent->base.seqno = event->base.seqno;
euExecQueuePlacementsEvent->base.reserved = event->base.reserved;
euExecQueuePlacementsEvent->clientHandle = event->client_handle;
euExecQueuePlacementsEvent->execQueueHandle = event->exec_queue_handle;
euExecQueuePlacementsEvent->lrcHandle = event->lrc_handle;
euExecQueuePlacementsEvent->numPlacements = event->num_placements;
euExecQueuePlacementsEvent->vmHandle = event->vm_handle;
memcpy(euExecQueuePlacementsEvent->instances, event->instances, event->num_placements * sizeof(uint64_t));
return std::unique_ptr<EuDebugEventExecQueuePlacements>(euExecQueuePlacementsEvent);
}
EuDebugEventMetadata EuDebugInterfacePrelim::toEuDebugEventMetadata(const void *drmType) {
const prelim_drm_xe_eudebug_event_metadata *event = static_cast<const prelim_drm_xe_eudebug_event_metadata *>(drmType);
EuDebugEventMetadata metadataEvent = {};
metadataEvent.base.len = event->base.len;
metadataEvent.base.type = event->base.type;
metadataEvent.base.flags = event->base.flags;
metadataEvent.base.seqno = event->base.seqno;
metadataEvent.base.reserved = event->base.reserved;
metadataEvent.clientHandle = event->client_handle;
metadataEvent.len = event->len;
metadataEvent.metadataHandle = event->metadata_handle;
metadataEvent.type = event->type;
return metadataEvent;
}
EuDebugEventVmBind EuDebugInterfacePrelim::toEuDebugEventVmBind(const void *drmType) {
const prelim_drm_xe_eudebug_event_vm_bind *event = static_cast<const prelim_drm_xe_eudebug_event_vm_bind *>(drmType);
EuDebugEventVmBind vmBindEvent = {};
vmBindEvent.base.len = event->base.len;
vmBindEvent.base.type = event->base.type;
vmBindEvent.base.flags = event->base.flags;
vmBindEvent.base.seqno = event->base.seqno;
vmBindEvent.base.reserved = event->base.reserved;
vmBindEvent.clientHandle = event->client_handle;
vmBindEvent.flags = event->flags;
vmBindEvent.numBinds = event->num_binds;
vmBindEvent.vmHandle = event->vm_handle;
return vmBindEvent;
}
NEO::EuDebugEventVmBindOp EuDebugInterfacePrelim::toEuDebugEventVmBindOp(const void *drmType) {
const prelim_drm_xe_eudebug_event_vm_bind_op *event = static_cast<const prelim_drm_xe_eudebug_event_vm_bind_op *>(drmType);
EuDebugEventVmBindOp vmBindOpEvent = {};
vmBindOpEvent.base.len = event->base.len;
vmBindOpEvent.base.type = event->base.type;
vmBindOpEvent.base.flags = event->base.flags;
vmBindOpEvent.base.seqno = event->base.seqno;
vmBindOpEvent.base.reserved = event->base.reserved;
vmBindOpEvent.vmBindRefSeqno = event->vm_bind_ref_seqno;
vmBindOpEvent.numExtensions = event->num_extensions;
vmBindOpEvent.addr = event->addr;
vmBindOpEvent.range = event->range;
return vmBindOpEvent;
}
EuDebugEventVmBindOpMetadata EuDebugInterfacePrelim::toEuDebugEventVmBindOpMetadata(const void *drmType) {
const prelim_drm_xe_eudebug_event_vm_bind_op_metadata *event = static_cast<const prelim_drm_xe_eudebug_event_vm_bind_op_metadata *>(drmType);
EuDebugEventVmBindOpMetadata vmBindOpMetadataEvent = {};
vmBindOpMetadataEvent.base.len = event->base.len;
vmBindOpMetadataEvent.base.type = event->base.type;
vmBindOpMetadataEvent.base.flags = event->base.flags;
vmBindOpMetadataEvent.base.seqno = event->base.seqno;
vmBindOpMetadataEvent.base.reserved = event->base.reserved;
vmBindOpMetadataEvent.vmBindOpRefSeqno = event->vm_bind_op_ref_seqno;
vmBindOpMetadataEvent.metadataHandle = event->metadata_handle;
vmBindOpMetadataEvent.metadataCookie = event->metadata_cookie;
return vmBindOpMetadataEvent;
}
EuDebugEventVmBindUfence EuDebugInterfacePrelim::toEuDebugEventVmBindUfence(const void *drmType) {
const prelim_drm_xe_eudebug_event_vm_bind_ufence *event = static_cast<const prelim_drm_xe_eudebug_event_vm_bind_ufence *>(drmType);
EuDebugEventVmBindUfence vmBindUfenceEvent = {};
vmBindUfenceEvent.base.len = event->base.len;
vmBindUfenceEvent.base.type = event->base.type;
vmBindUfenceEvent.base.flags = event->base.flags;
vmBindUfenceEvent.base.seqno = event->base.seqno;
vmBindUfenceEvent.base.reserved = event->base.reserved;
vmBindUfenceEvent.vmBindRefSeqno = event->vm_bind_ref_seqno;
return vmBindUfenceEvent;
}
std::unique_ptr<EuDebugEventPageFault> EuDebugInterfacePrelim::toEuDebugEventPageFault(const void *drmType) {
const prelim_drm_xe_eudebug_event_pagefault *event = static_cast<const prelim_drm_xe_eudebug_event_pagefault *>(drmType);
EuDebugEventPageFault *pPageFaultEvent = static_cast<EuDebugEventPageFault *>(malloc(sizeof(EuDebugEventPageFault) + event->bitmask_size * sizeof(uint8_t)));
pPageFaultEvent->base.len = event->base.len;
pPageFaultEvent->base.type = event->base.type;
pPageFaultEvent->base.flags = event->base.flags;
pPageFaultEvent->base.seqno = event->base.seqno;
pPageFaultEvent->base.reserved = event->base.reserved;
memcpy(pPageFaultEvent->bitmask, event->bitmask, event->bitmask_size);
pPageFaultEvent->bitmaskSize = event->bitmask_size;
pPageFaultEvent->clientHandle = event->client_handle;
pPageFaultEvent->flags = event->flags;
pPageFaultEvent->execQueueHandle = event->exec_queue_handle;
pPageFaultEvent->lrcHandle = event->lrc_handle;
pPageFaultEvent->pagefaultAddress = event->pagefault_address;
return std::unique_ptr<EuDebugEventPageFault>(pPageFaultEvent);
}
EuDebugEuControl EuDebugInterfacePrelim::toEuDebugEuControl(const void *drmType) {
const prelim_drm_xe_eudebug_eu_control *euControl = static_cast<const prelim_drm_xe_eudebug_eu_control *>(drmType);
EuDebugEuControl control = {};
control.bitmaskPtr = euControl->bitmask_ptr;
control.bitmaskSize = euControl->bitmask_size;
control.clientHandle = euControl->client_handle;
control.cmd = euControl->cmd;
control.flags = euControl->flags;
control.execQueueHandle = euControl->exec_queue_handle;
control.lrcHandle = euControl->lrc_handle;
control.seqno = euControl->seqno;
return control;
}
EuDebugConnect EuDebugInterfacePrelim::toEuDebugConnect(const void *drmType) {
const prelim_drm_xe_eudebug_connect *event = static_cast<const prelim_drm_xe_eudebug_connect *>(drmType);
EuDebugConnect connectEvent = {};
connectEvent.extensions = event->extensions;
connectEvent.flags = event->flags;
connectEvent.pid = event->pid;
connectEvent.version = event->version;
return connectEvent;
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfacePrelim::toDrmEuDebugConnect(const EuDebugConnect &connect) {
struct prelim_drm_xe_eudebug_connect *pDrmConnect = new prelim_drm_xe_eudebug_connect();
pDrmConnect->extensions = connect.extensions;
pDrmConnect->pid = connect.pid;
pDrmConnect->flags = connect.flags;
pDrmConnect->version = connect.version;
auto deleter = [](void *ptr) { delete static_cast<prelim_drm_xe_eudebug_connect *>(ptr); };
return std::unique_ptr<void, void (*)(void *)>(pDrmConnect, deleter);
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfacePrelim::toDrmEuDebugEuControl(const EuDebugEuControl &euControl) {
struct prelim_drm_xe_eudebug_eu_control *pDrmEuControl = new prelim_drm_xe_eudebug_eu_control();
auto bitmaskData = new uint8_t[euControl.bitmaskSize];
memcpy(bitmaskData, reinterpret_cast<uint8_t *>(euControl.bitmaskPtr), euControl.bitmaskSize * sizeof(uint8_t));
pDrmEuControl->bitmask_ptr = reinterpret_cast<uintptr_t>(bitmaskData);
pDrmEuControl->bitmask_size = euControl.bitmaskSize;
pDrmEuControl->client_handle = euControl.clientHandle;
pDrmEuControl->cmd = euControl.cmd;
pDrmEuControl->flags = euControl.flags;
pDrmEuControl->exec_queue_handle = euControl.execQueueHandle;
pDrmEuControl->lrc_handle = euControl.lrcHandle;
pDrmEuControl->seqno = euControl.seqno;
auto deleter = [](void *ptr) {
delete[] reinterpret_cast<uint8_t *>(static_cast<prelim_drm_xe_eudebug_eu_control *>(ptr)->bitmask_ptr);
delete static_cast<prelim_drm_xe_eudebug_eu_control *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmEuControl, deleter);
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfacePrelim::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct prelim_drm_xe_eudebug_vm_open *pDrmVmOpen = new prelim_drm_xe_eudebug_vm_open();
pDrmVmOpen->client_handle = vmOpen.clientHandle;
pDrmVmOpen->extensions = vmOpen.extensions;
pDrmVmOpen->flags = vmOpen.flags;
pDrmVmOpen->timeout_ns = vmOpen.timeoutNs;
pDrmVmOpen->vm_handle = vmOpen.vmHandle;
auto deleter = [](void *ptr) { delete static_cast<prelim_drm_xe_eudebug_vm_open *>(ptr); };
return std::unique_ptr<void, void (*)(void *)>(pDrmVmOpen, deleter);
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfacePrelim::toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) {
struct prelim_drm_xe_eudebug_ack_event *pDrmAckEvent = new prelim_drm_xe_eudebug_ack_event();
pDrmAckEvent->type = ackEvent.type;
pDrmAckEvent->flags = ackEvent.flags;
pDrmAckEvent->seqno = ackEvent.seqno;
auto deleter = [](void *ptr) { delete static_cast<prelim_drm_xe_eudebug_ack_event *>(ptr); };
return std::unique_ptr<void, void (*)(void *)>(pDrmAckEvent, deleter);
}
static_assert(sizeof(EuDebugEvent) == sizeof(prelim_drm_xe_eudebug_event));
static_assert(offsetof(EuDebugEvent, len) == offsetof(prelim_drm_xe_eudebug_event, len));
@@ -103,73 +382,6 @@ static_assert(offsetof(EuDebugEvent, flags) == offsetof(prelim_drm_xe_eudebug_ev
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(EuDebugEventPageFault) == sizeof(prelim_drm_xe_eudebug_event_pagefault));
static_assert(offsetof(EuDebugEventPageFault, clientHandle) == offsetof(prelim_drm_xe_eudebug_event_pagefault, client_handle));
static_assert(offsetof(EuDebugEventPageFault, execQueueHandle) == offsetof(prelim_drm_xe_eudebug_event_pagefault, exec_queue_handle));
static_assert(offsetof(EuDebugEventPageFault, lrcHandle) == offsetof(prelim_drm_xe_eudebug_event_pagefault, lrc_handle));
static_assert(offsetof(EuDebugEventPageFault, flags) == offsetof(prelim_drm_xe_eudebug_event_pagefault, flags));
static_assert(offsetof(EuDebugEventPageFault, bitmaskSize) == offsetof(prelim_drm_xe_eudebug_event_pagefault, bitmask_size));
static_assert(offsetof(EuDebugEventPageFault, pagefaultAddress) == offsetof(prelim_drm_xe_eudebug_event_pagefault, pagefault_address));
static_assert(offsetof(EuDebugEventPageFault, bitmask) == offsetof(prelim_drm_xe_eudebug_event_pagefault, bitmask));
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));
@@ -178,29 +390,6 @@ static_assert(offsetof(EuDebugReadMetadata, reserved) == offsetof(prelim_drm_xe_
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));

19
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h
View File

@@ -14,5 +14,24 @@ class EuDebugInterfacePrelim : public EuDebugInterface {
uint32_t getParamValue(EuDebugParam param) const override;
bool isExecQueuePageFaultEnableSupported() override;
uint32_t getAdditionalParamValue(EuDebugParam param) const;
std::unique_ptr<EuDebugEventEuAttention> toEuDebugEventEuAttention(const void *drmType) override;
EuDebugEventClient toEuDebugEventClient(const void *drmType) override;
EuDebugEventVm toEuDebugEventVm(const void *drmType) override;
std::unique_ptr<EuDebugEventExecQueue> toEuDebugEventExecQueue(const void *drmType) override;
std::unique_ptr<EuDebugEventExecQueuePlacements> toEuDebugEventExecQueuePlacements(const void *drmType) override;
EuDebugEventMetadata toEuDebugEventMetadata(const void *drmType) override;
EuDebugEventVmBind toEuDebugEventVmBind(const void *drmType) override;
EuDebugEventVmBindOp toEuDebugEventVmBindOp(const void *drmType) override;
EuDebugEventVmBindOpMetadata toEuDebugEventVmBindOpMetadata(const void *drmType) override;
EuDebugEventVmBindUfence toEuDebugEventVmBindUfence(const void *drmType) override;
std::unique_ptr<EuDebugEventPageFault> toEuDebugEventPageFault(const void *drmType) override;
EuDebugEuControl toEuDebugEuControl(const void *drmType) override;
EuDebugConnect toEuDebugConnect(const void *drmType) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugConnect(const EuDebugConnect &connect) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugEuControl(const EuDebugEuControl &euControl) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) override;
};
} // namespace NEO

371
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.cpp
View File

@@ -8,6 +8,8 @@
#include "shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h"
#include "third_party/uapi-eudebug/drm/xe_drm.h"
#include <string.h>
namespace NEO {
uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
switch (param) {
@@ -89,86 +91,285 @@ uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
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));
std::unique_ptr<EuDebugEventEuAttention> EuDebugInterfaceUpstream::toEuDebugEventEuAttention(const void *drmType) {
const drm_xe_eudebug_event_eu_attention *event = static_cast<const drm_xe_eudebug_event_eu_attention *>(drmType);
EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t)));
pEuAttentionEvent->base.len = event->base.len;
pEuAttentionEvent->base.type = event->base.type;
pEuAttentionEvent->base.flags = event->base.flags;
pEuAttentionEvent->base.seqno = event->base.seqno;
pEuAttentionEvent->base.reserved = event->base.reserved;
memcpy(pEuAttentionEvent->bitmask, event->bitmask, event->bitmask_size * sizeof(uint8_t));
pEuAttentionEvent->bitmaskSize = event->bitmask_size;
pEuAttentionEvent->flags = event->flags;
pEuAttentionEvent->lrcHandle = event->lrc_handle;
pEuAttentionEvent->execQueueHandle = event->exec_queue_handle;
pEuAttentionEvent->clientHandle = event->client_handle;
return std::unique_ptr<EuDebugEventEuAttention>(pEuAttentionEvent);
}
EuDebugEventClient EuDebugInterfaceUpstream::toEuDebugEventClient(const void *drmType) {
const drm_xe_eudebug_event_client *event = static_cast<const drm_xe_eudebug_event_client *>(drmType);
EuDebugEventClient euClientEvent = {};
euClientEvent.base.len = event->base.len;
euClientEvent.base.type = event->base.type;
euClientEvent.base.flags = event->base.flags;
euClientEvent.base.seqno = event->base.seqno;
euClientEvent.base.reserved = event->base.reserved;
euClientEvent.clientHandle = event->client_handle;
return euClientEvent;
}
EuDebugEventVm EuDebugInterfaceUpstream::toEuDebugEventVm(const void *drmType) {
const drm_xe_eudebug_event_vm *event = static_cast<const drm_xe_eudebug_event_vm *>(drmType);
EuDebugEventVm euVmEvent = {};
euVmEvent.base.len = event->base.len;
euVmEvent.base.type = event->base.type;
euVmEvent.base.flags = event->base.flags;
euVmEvent.base.seqno = event->base.seqno;
euVmEvent.base.reserved = event->base.reserved;
euVmEvent.clientHandle = event->client_handle;
euVmEvent.vmHandle = event->vm_handle;
return euVmEvent;
}
std::unique_ptr<EuDebugEventExecQueue> EuDebugInterfaceUpstream::toEuDebugEventExecQueue(const void *drmType) {
const drm_xe_eudebug_event_exec_queue *event = static_cast<const drm_xe_eudebug_event_exec_queue *>(drmType);
EuDebugEventExecQueue *pExecQueueEvent = static_cast<EuDebugEventExecQueue *>(malloc(sizeof(EuDebugEventExecQueue) + event->width * sizeof(uint64_t)));
pExecQueueEvent->base.len = event->base.len;
pExecQueueEvent->base.type = event->base.type;
pExecQueueEvent->base.flags = event->base.flags;
pExecQueueEvent->base.seqno = event->base.seqno;
pExecQueueEvent->base.reserved = event->base.reserved;
pExecQueueEvent->execQueueHandle = event->exec_queue_handle;
pExecQueueEvent->engineClass = event->engine_class;
pExecQueueEvent->width = event->width;
pExecQueueEvent->vmHandle = event->vm_handle;
pExecQueueEvent->clientHandle = event->client_handle;
memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t));
return std::unique_ptr<EuDebugEventExecQueue>(pExecQueueEvent);
}
std::unique_ptr<EuDebugEventExecQueuePlacements> EuDebugInterfaceUpstream::toEuDebugEventExecQueuePlacements(const void *drmType) {
return {};
}
EuDebugEventMetadata EuDebugInterfaceUpstream::toEuDebugEventMetadata(const void *drmType) {
const drm_xe_eudebug_event_metadata *event = static_cast<const drm_xe_eudebug_event_metadata *>(drmType);
EuDebugEventMetadata metadataEvent = {};
metadataEvent.base.len = event->base.len;
metadataEvent.base.type = event->base.type;
metadataEvent.base.flags = event->base.flags;
metadataEvent.base.seqno = event->base.seqno;
metadataEvent.base.reserved = event->base.reserved;
metadataEvent.clientHandle = event->client_handle;
metadataEvent.len = event->len;
metadataEvent.metadataHandle = event->metadata_handle;
metadataEvent.type = event->type;
return metadataEvent;
}
EuDebugEventVmBind EuDebugInterfaceUpstream::toEuDebugEventVmBind(const void *drmType) {
const drm_xe_eudebug_event_vm_bind *event = static_cast<const drm_xe_eudebug_event_vm_bind *>(drmType);
EuDebugEventVmBind vmBindEvent = {};
vmBindEvent.base.len = event->base.len;
vmBindEvent.base.type = event->base.type;
vmBindEvent.base.flags = event->base.flags;
vmBindEvent.base.seqno = event->base.seqno;
vmBindEvent.base.reserved = event->base.reserved;
vmBindEvent.clientHandle = event->client_handle;
vmBindEvent.flags = event->flags;
vmBindEvent.numBinds = event->num_binds;
vmBindEvent.vmHandle = event->vm_handle;
return vmBindEvent;
}
NEO::EuDebugEventVmBindOp EuDebugInterfaceUpstream::toEuDebugEventVmBindOp(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op *event = static_cast<const drm_xe_eudebug_event_vm_bind_op *>(drmType);
EuDebugEventVmBindOp vmBindOpEvent = {};
vmBindOpEvent.base.len = event->base.len;
vmBindOpEvent.base.type = event->base.type;
vmBindOpEvent.base.flags = event->base.flags;
vmBindOpEvent.base.seqno = event->base.seqno;
vmBindOpEvent.base.reserved = event->base.reserved;
vmBindOpEvent.vmBindRefSeqno = event->vm_bind_ref_seqno;
vmBindOpEvent.numExtensions = event->num_extensions;
vmBindOpEvent.addr = event->addr;
vmBindOpEvent.range = event->range;
return vmBindOpEvent;
}
EuDebugEventVmBindOpMetadata EuDebugInterfaceUpstream::toEuDebugEventVmBindOpMetadata(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op_metadata *event = static_cast<const drm_xe_eudebug_event_vm_bind_op_metadata *>(drmType);
EuDebugEventVmBindOpMetadata vmBindOpMetadataEvent = {};
vmBindOpMetadataEvent.base.len = event->base.len;
vmBindOpMetadataEvent.base.type = event->base.type;
vmBindOpMetadataEvent.base.flags = event->base.flags;
vmBindOpMetadataEvent.base.seqno = event->base.seqno;
vmBindOpMetadataEvent.base.reserved = event->base.reserved;
vmBindOpMetadataEvent.vmBindOpRefSeqno = event->vm_bind_op_ref_seqno;
vmBindOpMetadataEvent.metadataHandle = event->metadata_handle;
vmBindOpMetadataEvent.metadataCookie = event->metadata_cookie;
return vmBindOpMetadataEvent;
}
EuDebugEventVmBindUfence EuDebugInterfaceUpstream::toEuDebugEventVmBindUfence(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_ufence *event = static_cast<const drm_xe_eudebug_event_vm_bind_ufence *>(drmType);
EuDebugEventVmBindUfence vmBindUfenceEvent = {};
vmBindUfenceEvent.base.len = event->base.len;
vmBindUfenceEvent.base.type = event->base.type;
vmBindUfenceEvent.base.flags = event->base.flags;
vmBindUfenceEvent.base.seqno = event->base.seqno;
vmBindUfenceEvent.base.reserved = event->base.reserved;
vmBindUfenceEvent.vmBindRefSeqno = event->vm_bind_ref_seqno;
return vmBindUfenceEvent;
}
std::unique_ptr<EuDebugEventPageFault> EuDebugInterfaceUpstream::toEuDebugEventPageFault(const void *drmType) {
const drm_xe_eudebug_event_pagefault *event = static_cast<const drm_xe_eudebug_event_pagefault *>(drmType);
EuDebugEventPageFault *pPageFaultEvent = static_cast<EuDebugEventPageFault *>(malloc(sizeof(EuDebugEventPageFault) + event->bitmask_size * sizeof(uint8_t)));
pPageFaultEvent->base.len = event->base.len;
pPageFaultEvent->base.type = event->base.type;
pPageFaultEvent->base.flags = event->base.flags;
pPageFaultEvent->base.seqno = event->base.seqno;
pPageFaultEvent->base.reserved = event->base.reserved;
memcpy(pPageFaultEvent->bitmask, event->bitmask, event->bitmask_size * sizeof(uint8_t));
pPageFaultEvent->bitmaskSize = event->bitmask_size;
pPageFaultEvent->clientHandle = event->client_handle;
pPageFaultEvent->flags = event->flags;
pPageFaultEvent->execQueueHandle = event->exec_queue_handle;
pPageFaultEvent->lrcHandle = event->lrc_handle;
pPageFaultEvent->pagefaultAddress = event->pagefault_address;
return std::unique_ptr<EuDebugEventPageFault>(pPageFaultEvent);
}
EuDebugEuControl EuDebugInterfaceUpstream::toEuDebugEuControl(const void *drmType) {
const drm_xe_eudebug_eu_control *euControl = static_cast<const drm_xe_eudebug_eu_control *>(drmType);
EuDebugEuControl control = {};
control.bitmaskPtr = euControl->bitmask_ptr;
control.bitmaskSize = euControl->bitmask_size;
control.clientHandle = euControl->client_handle;
control.cmd = euControl->cmd;
control.flags = euControl->flags;
control.execQueueHandle = euControl->exec_queue_handle;
control.lrcHandle = euControl->lrc_handle;
control.seqno = euControl->seqno;
return control;
}
EuDebugConnect EuDebugInterfaceUpstream::toEuDebugConnect(const void *drmType) {
const drm_xe_eudebug_connect *event = static_cast<const drm_xe_eudebug_connect *>(drmType);
EuDebugConnect connectEvent = {};
connectEvent.extensions = event->extensions;
connectEvent.flags = event->flags;
connectEvent.pid = event->pid;
connectEvent.version = event->version;
return connectEvent;
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugConnect(const EuDebugConnect &connect) {
struct drm_xe_eudebug_connect *pDrmConnect = new drm_xe_eudebug_connect();
pDrmConnect->extensions = connect.extensions;
pDrmConnect->pid = connect.pid;
pDrmConnect->flags = connect.flags;
pDrmConnect->version = connect.version;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_connect *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmConnect, deleter);
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugEuControl(const EuDebugEuControl &euControl) {
struct drm_xe_eudebug_eu_control *pDrmEuControl = new drm_xe_eudebug_eu_control();
auto bitmaskData = new uint8_t[euControl.bitmaskSize];
memcpy(bitmaskData, reinterpret_cast<uint8_t *>(euControl.bitmaskPtr), euControl.bitmaskSize * sizeof(uint8_t));
pDrmEuControl->bitmask_ptr = reinterpret_cast<uintptr_t>(bitmaskData);
pDrmEuControl->bitmask_size = euControl.bitmaskSize;
pDrmEuControl->client_handle = euControl.clientHandle;
pDrmEuControl->cmd = euControl.cmd;
pDrmEuControl->flags = euControl.flags;
pDrmEuControl->exec_queue_handle = euControl.execQueueHandle;
pDrmEuControl->lrc_handle = euControl.lrcHandle;
pDrmEuControl->seqno = euControl.seqno;
auto deleter = [](void *ptr) {
delete[] reinterpret_cast<uint8_t *>(static_cast<drm_xe_eudebug_eu_control *>(ptr)->bitmask_ptr);
delete static_cast<drm_xe_eudebug_eu_control *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmEuControl, deleter);
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct drm_xe_eudebug_vm_open *pDrmVmOpen = new drm_xe_eudebug_vm_open();
pDrmVmOpen->client_handle = vmOpen.clientHandle;
pDrmVmOpen->extensions = vmOpen.extensions;
pDrmVmOpen->flags = vmOpen.flags;
pDrmVmOpen->timeout_ns = vmOpen.timeoutNs;
pDrmVmOpen->vm_handle = vmOpen.vmHandle;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_vm_open *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmVmOpen, deleter);
}
std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) {
struct drm_xe_eudebug_ack_event *pDrmAckEvent = new drm_xe_eudebug_ack_event();
pDrmAckEvent->type = ackEvent.type;
pDrmAckEvent->flags = ackEvent.flags;
pDrmAckEvent->seqno = ackEvent.seqno;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_ack_event *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmAckEvent, deleter);
}
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(EuDebugEventPageFault) == sizeof(drm_xe_eudebug_event_pagefault));
static_assert(offsetof(EuDebugEventPageFault, clientHandle) == offsetof(drm_xe_eudebug_event_pagefault, client_handle));
static_assert(offsetof(EuDebugEventPageFault, execQueueHandle) == offsetof(drm_xe_eudebug_event_pagefault, exec_queue_handle));
static_assert(offsetof(EuDebugEventPageFault, lrcHandle) == offsetof(drm_xe_eudebug_event_pagefault, lrc_handle));
static_assert(offsetof(EuDebugEventPageFault, flags) == offsetof(drm_xe_eudebug_event_pagefault, flags));
static_assert(offsetof(EuDebugEventPageFault, bitmaskSize) == offsetof(drm_xe_eudebug_event_pagefault, bitmask_size));
static_assert(offsetof(EuDebugEventPageFault, pagefaultAddress) == offsetof(drm_xe_eudebug_event_pagefault, pagefault_address));
static_assert(offsetof(EuDebugEventPageFault, bitmask) == offsetof(drm_xe_eudebug_event_pagefault, bitmask));
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));
@@ -177,29 +378,6 @@ static_assert(offsetof(EuDebugReadMetadata, reserved) == offsetof(drm_xe_eudebug
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));
@@ -222,4 +400,5 @@ static_assert(offsetof(VmBindOpExtAttachDebug, metadataId) == offsetof(drm_xe_vm
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

22
shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2024 Intel Corporation
* Copyright (C) 2024-2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -14,6 +14,24 @@ class EuDebugInterfaceUpstream : public EuDebugInterface {
static constexpr const char *sysFsXeEuDebugFile = "/device/enable_eudebug";
uint32_t getParamValue(EuDebugParam param) const override;
};
std::unique_ptr<EuDebugEventEuAttention> toEuDebugEventEuAttention(const void *drmType) override;
EuDebugEventClient toEuDebugEventClient(const void *drmType) override;
EuDebugEventVm toEuDebugEventVm(const void *drmType) override;
std::unique_ptr<EuDebugEventExecQueue> toEuDebugEventExecQueue(const void *drmType) override;
std::unique_ptr<EuDebugEventExecQueuePlacements> toEuDebugEventExecQueuePlacements(const void *drmType) override;
EuDebugEventMetadata toEuDebugEventMetadata(const void *drmType) override;
EuDebugEventVmBind toEuDebugEventVmBind(const void *drmType) override;
EuDebugEventVmBindOp toEuDebugEventVmBindOp(const void *drmType) override;
EuDebugEventVmBindOpMetadata toEuDebugEventVmBindOpMetadata(const void *drmType) override;
EuDebugEventVmBindUfence toEuDebugEventVmBindUfence(const void *drmType) override;
std::unique_ptr<EuDebugEventPageFault> toEuDebugEventPageFault(const void *drmType) override;
EuDebugEuControl toEuDebugEuControl(const void *drmType) override;
EuDebugConnect toEuDebugConnect(const void *drmType) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugConnect(const EuDebugConnect &connect) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugEuControl(const EuDebugEuControl &euControl) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) override;
};
} // namespace NEO

172
shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.cpp
View File

@@ -7,6 +7,13 @@
#include "shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h"
// clang-format off
#include "third_party/uapi-eudebug/drm/xe_drm.h"
#include "third_party/uapi/drm-uapi-helper/xe/xe_drm_prelim.h"
// clang-format on
#include <string.h>
#define RETURN_AS_IS(X) \
case X: \
return static_cast<uint32_t>(X)
@@ -58,6 +65,171 @@ uint32_t MockEuDebugInterface::getParamValue(EuDebugParam param) const {
return 0;
}
std::unique_ptr<EuDebugEventEuAttention> MockEuDebugInterface::toEuDebugEventEuAttention(const void *drmType) {
const drm_xe_eudebug_event_eu_attention *event = static_cast<const drm_xe_eudebug_event_eu_attention *>(drmType);
EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t)));
pEuAttentionEvent->base.len = event->base.len;
pEuAttentionEvent->base.type = event->base.type;
pEuAttentionEvent->base.flags = event->base.flags;
pEuAttentionEvent->base.seqno = event->base.seqno;
pEuAttentionEvent->base.reserved = event->base.reserved;
memcpy(pEuAttentionEvent->bitmask, event->bitmask, event->bitmask_size * sizeof(uint8_t));
pEuAttentionEvent->bitmaskSize = event->bitmask_size;
pEuAttentionEvent->flags = event->flags;
pEuAttentionEvent->lrcHandle = event->lrc_handle;
pEuAttentionEvent->execQueueHandle = event->exec_queue_handle;
pEuAttentionEvent->clientHandle = event->client_handle;
return std::unique_ptr<EuDebugEventEuAttention>(pEuAttentionEvent);
}
EuDebugEventClient MockEuDebugInterface::toEuDebugEventClient(const void *drmType) {
return *static_cast<const EuDebugEventClient *>(drmType);
}
EuDebugEventVm MockEuDebugInterface::toEuDebugEventVm(const void *drmType) {
return *static_cast<const EuDebugEventVm *>(drmType);
}
std::unique_ptr<EuDebugEventExecQueue> MockEuDebugInterface::toEuDebugEventExecQueue(const void *drmType) {
const drm_xe_eudebug_event_exec_queue *event = static_cast<const drm_xe_eudebug_event_exec_queue *>(drmType);
EuDebugEventExecQueue *pExecQueueEvent = static_cast<EuDebugEventExecQueue *>(malloc(sizeof(EuDebugEventExecQueue) + event->width * sizeof(uint64_t)));
pExecQueueEvent->base.len = event->base.len;
pExecQueueEvent->base.type = event->base.type;
pExecQueueEvent->base.flags = event->base.flags;
pExecQueueEvent->base.seqno = event->base.seqno;
pExecQueueEvent->base.reserved = event->base.reserved;
pExecQueueEvent->execQueueHandle = event->exec_queue_handle;
pExecQueueEvent->engineClass = event->engine_class;
pExecQueueEvent->width = event->width;
pExecQueueEvent->vmHandle = event->vm_handle;
pExecQueueEvent->clientHandle = event->client_handle;
memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t));
return std::unique_ptr<EuDebugEventExecQueue>(pExecQueueEvent);
}
std::unique_ptr<EuDebugEventExecQueuePlacements> MockEuDebugInterface::toEuDebugEventExecQueuePlacements(const void *drmType) {
const prelim_drm_xe_eudebug_event_exec_queue_placements *event = static_cast<const prelim_drm_xe_eudebug_event_exec_queue_placements *>(drmType);
EuDebugEventExecQueuePlacements *euExecQueuePlacementsEvent = static_cast<EuDebugEventExecQueuePlacements *>(malloc(sizeof(EuDebugEventExecQueuePlacements) + event->num_placements * sizeof(uint64_t)));
euExecQueuePlacementsEvent->base.len = event->base.len;
euExecQueuePlacementsEvent->base.type = event->base.type;
euExecQueuePlacementsEvent->base.flags = event->base.flags;
euExecQueuePlacementsEvent->base.seqno = event->base.seqno;
euExecQueuePlacementsEvent->base.reserved = event->base.reserved;
euExecQueuePlacementsEvent->clientHandle = event->client_handle;
euExecQueuePlacementsEvent->execQueueHandle = event->exec_queue_handle;
euExecQueuePlacementsEvent->lrcHandle = event->lrc_handle;
euExecQueuePlacementsEvent->numPlacements = event->num_placements;
euExecQueuePlacementsEvent->vmHandle = event->vm_handle;
memcpy(euExecQueuePlacementsEvent->instances, event->instances, event->num_placements * sizeof(uint64_t));
return std::unique_ptr<EuDebugEventExecQueuePlacements>(euExecQueuePlacementsEvent);
}
EuDebugEventMetadata MockEuDebugInterface::toEuDebugEventMetadata(const void *drmType) {
return *static_cast<const EuDebugEventMetadata *>(drmType);
}
EuDebugEventVmBind MockEuDebugInterface::toEuDebugEventVmBind(const void *drmType) {
return *static_cast<const EuDebugEventVmBind *>(drmType);
}
EuDebugEventVmBindOp MockEuDebugInterface::toEuDebugEventVmBindOp(const void *drmType) {
return *static_cast<const EuDebugEventVmBindOp *>(drmType);
}
EuDebugEventVmBindOpMetadata MockEuDebugInterface::toEuDebugEventVmBindOpMetadata(const void *drmType) {
return *static_cast<const EuDebugEventVmBindOpMetadata *>(drmType);
}
EuDebugEventVmBindUfence MockEuDebugInterface::toEuDebugEventVmBindUfence(const void *drmType) {
return *static_cast<const EuDebugEventVmBindUfence *>(drmType);
}
std::unique_ptr<EuDebugEventPageFault> MockEuDebugInterface::toEuDebugEventPageFault(const void *drmType) {
const drm_xe_eudebug_event_pagefault *event = static_cast<const drm_xe_eudebug_event_pagefault *>(drmType);
EuDebugEventPageFault *pPageFaultEvent = static_cast<EuDebugEventPageFault *>(malloc(sizeof(EuDebugEventPageFault) + event->bitmask_size * sizeof(uint8_t)));
pPageFaultEvent->base.len = event->base.len;
pPageFaultEvent->base.type = event->base.type;
pPageFaultEvent->base.flags = event->base.flags;
pPageFaultEvent->base.seqno = event->base.seqno;
pPageFaultEvent->base.reserved = event->base.reserved;
memcpy(pPageFaultEvent->bitmask, event->bitmask, event->bitmask_size * sizeof(uint8_t));
pPageFaultEvent->bitmaskSize = event->bitmask_size;
pPageFaultEvent->clientHandle = event->client_handle;
pPageFaultEvent->flags = event->flags;
pPageFaultEvent->execQueueHandle = event->exec_queue_handle;
pPageFaultEvent->lrcHandle = event->lrc_handle;
pPageFaultEvent->pagefaultAddress = event->pagefault_address;
return std::unique_ptr<EuDebugEventPageFault>(pPageFaultEvent);
}
EuDebugEuControl MockEuDebugInterface::toEuDebugEuControl(const void *drmType) {
return *static_cast<const EuDebugEuControl *>(drmType);
}
EuDebugConnect MockEuDebugInterface::toEuDebugConnect(const void *drmType) {
return *static_cast<const EuDebugConnect *>(drmType);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugConnect(const EuDebugConnect &connect) {
struct drm_xe_eudebug_connect *pDrmConnect = new drm_xe_eudebug_connect();
pDrmConnect->extensions = connect.extensions;
pDrmConnect->pid = connect.pid;
pDrmConnect->flags = connect.flags;
pDrmConnect->version = connect.version;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_connect *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmConnect, deleter);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugEuControl(const EuDebugEuControl &euControl) {
struct drm_xe_eudebug_eu_control *pDrmEuControl = new drm_xe_eudebug_eu_control();
pDrmEuControl->bitmask_ptr = euControl.bitmaskPtr;
pDrmEuControl->bitmask_size = euControl.bitmaskSize;
pDrmEuControl->client_handle = euControl.clientHandle;
pDrmEuControl->cmd = euControl.cmd;
pDrmEuControl->flags = euControl.flags;
pDrmEuControl->exec_queue_handle = euControl.execQueueHandle;
pDrmEuControl->lrc_handle = euControl.lrcHandle;
pDrmEuControl->seqno = euControl.seqno;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_eu_control *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmEuControl, deleter);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct drm_xe_eudebug_vm_open *pDrmVmOpen = new drm_xe_eudebug_vm_open();
pDrmVmOpen->client_handle = vmOpen.clientHandle;
pDrmVmOpen->extensions = vmOpen.extensions;
pDrmVmOpen->flags = vmOpen.flags;
pDrmVmOpen->timeout_ns = vmOpen.timeoutNs;
pDrmVmOpen->vm_handle = vmOpen.vmHandle;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_vm_open *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmVmOpen, deleter);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) {
struct drm_xe_eudebug_ack_event *pDrmAckEvent = new drm_xe_eudebug_ack_event();
pDrmAckEvent->type = ackEvent.type;
pDrmAckEvent->flags = ackEvent.flags;
pDrmAckEvent->seqno = ackEvent.seqno;
auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_ack_event *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmAckEvent, deleter);
}
char MockEuDebugInterface::sysFsContent = '1';
[[maybe_unused]] static EnableEuDebugInterface enableMockEuDebug(MockEuDebugInterface::euDebugInterfaceType, MockEuDebugInterface::sysFsXeEuDebugFile, []() -> std::unique_ptr<EuDebugInterface> { return std::make_unique<MockEuDebugInterface>(); });
} // namespace NEO

19
shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h
View File

@@ -18,6 +18,25 @@ class MockEuDebugInterface : public EuDebugInterface {
bool isExecQueuePageFaultEnableSupported() override { return pageFaultEnableSupported; };
uint32_t getParamValue(EuDebugParam param) const override;
std::unique_ptr<EuDebugEventEuAttention> toEuDebugEventEuAttention(const void *drmType) override;
EuDebugEventClient toEuDebugEventClient(const void *drmType) override;
EuDebugEventVm toEuDebugEventVm(const void *drmType) override;
std::unique_ptr<EuDebugEventExecQueue> toEuDebugEventExecQueue(const void *drmType) override;
std::unique_ptr<EuDebugEventExecQueuePlacements> toEuDebugEventExecQueuePlacements(const void *drmType) override;
EuDebugEventMetadata toEuDebugEventMetadata(const void *drmType) override;
EuDebugEventVmBind toEuDebugEventVmBind(const void *drmType) override;
EuDebugEventVmBindOp toEuDebugEventVmBindOp(const void *drmType) override;
EuDebugEventVmBindOpMetadata toEuDebugEventVmBindOpMetadata(const void *drmType) override;
EuDebugEventVmBindUfence toEuDebugEventVmBindUfence(const void *drmType) override;
std::unique_ptr<EuDebugEventPageFault> toEuDebugEventPageFault(const void *drmType) override;
EuDebugEuControl toEuDebugEuControl(const void *drmType) override;
EuDebugConnect toEuDebugConnect(const void *drmType) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugConnect(const EuDebugConnect &connect) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugEuControl(const EuDebugEuControl &euControl) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) override;
std::unique_ptr<void, void (*)(void *)> toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) override;
bool pageFaultEnableSupported = false;
};

328
shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_prelim_tests.cpp
View File

@@ -50,3 +50,331 @@ TEST(EuDebugInterfacePrelimTest, whenGettingParamValueThenCorrectValueIsReturned
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));
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmEuAttentionWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_eu_attention *drmEuAttention = (prelim_drm_xe_eudebug_event_eu_attention *)malloc(sizeof(prelim_drm_xe_eudebug_event_eu_attention) + 4 * sizeof(uint8_t));
drmEuAttention->client_handle = 0x32;
drmEuAttention->exec_queue_handle = 0x64;
drmEuAttention->lrc_handle = 0x128;
drmEuAttention->flags = 0x0F;
drmEuAttention->bitmask_size = 4;
drmEuAttention->bitmask[0] = 0x1;
drmEuAttention->bitmask[1] = 0x2;
drmEuAttention->bitmask[2] = 0x3;
drmEuAttention->bitmask[3] = 0x4;
auto event = euDebugInterface.toEuDebugEventEuAttention(drmEuAttention);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x128u, event->lrcHandle);
EXPECT_EQ(0x0Fu, event->flags);
EXPECT_EQ(4u, event->bitmaskSize);
EXPECT_EQ(0x1u, event->bitmask[0]);
EXPECT_EQ(0x2u, event->bitmask[1]);
EXPECT_EQ(0x3u, event->bitmask[2]);
EXPECT_EQ(0x4u, event->bitmask[3]);
free(drmEuAttention);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmClientWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_client drmClient = {};
drmClient.client_handle = 0x32;
auto event = euDebugInterface.toEuDebugEventClient(&drmClient);
EXPECT_EQ(0x32u, event.clientHandle);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmVmWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_vm drmVm = {};
drmVm.client_handle = 0x32;
drmVm.vm_handle = 0x64;
auto event = euDebugInterface.toEuDebugEventVm(&drmVm);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.vmHandle);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmExecQueueWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_exec_queue *drmExecQueue = (prelim_drm_xe_eudebug_event_exec_queue *)malloc(sizeof(prelim_drm_xe_eudebug_event_exec_queue) + 3 * sizeof(uint64_t));
drmExecQueue->client_handle = 0x32;
drmExecQueue->vm_handle = 0x64;
drmExecQueue->exec_queue_handle = 0x128;
drmExecQueue->engine_class = 0x256;
drmExecQueue->width = 0x03;
drmExecQueue->lrc_handle[0] = 0x1;
drmExecQueue->lrc_handle[1] = 0x2;
drmExecQueue->lrc_handle[2] = 0x3;
auto event = euDebugInterface.toEuDebugEventExecQueue(drmExecQueue);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->vmHandle);
EXPECT_EQ(0x128u, event->execQueueHandle);
EXPECT_EQ(0x256u, event->engineClass);
EXPECT_EQ(0x3u, event->width);
EXPECT_EQ(0x1u, event->lrcHandle[0]);
EXPECT_EQ(0x2u, event->lrcHandle[1]);
EXPECT_EQ(0x3u, event->lrcHandle[2]);
free(drmExecQueue);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmExecQueuePlacementsWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_exec_queue_placements *drmExecQueuePlacements = (prelim_drm_xe_eudebug_event_exec_queue_placements *)malloc(sizeof(prelim_drm_xe_eudebug_event_exec_queue_placements) + 3 * sizeof(uint64_t));
drmExecQueuePlacements->client_handle = 0x32;
drmExecQueuePlacements->exec_queue_handle = 0x64;
drmExecQueuePlacements->lrc_handle = 0x128;
drmExecQueuePlacements->num_placements = 3;
drmExecQueuePlacements->vm_handle = 0x256;
drmExecQueuePlacements->instances[0] = 0x1;
drmExecQueuePlacements->instances[1] = 0x2;
drmExecQueuePlacements->instances[2] = 0x3;
auto event = euDebugInterface.toEuDebugEventExecQueuePlacements(drmExecQueuePlacements);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x128u, event->lrcHandle);
EXPECT_EQ(3u, event->numPlacements);
EXPECT_EQ(0x256u, event->vmHandle);
EXPECT_EQ(0x1u, event->instances[0]);
EXPECT_EQ(0x2u, event->instances[1]);
EXPECT_EQ(0x3u, event->instances[2]);
free(drmExecQueuePlacements);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmMetadataWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_metadata drmMetadata = {};
drmMetadata.client_handle = 0x32;
drmMetadata.metadata_handle = 0x64;
drmMetadata.type = 0x128;
drmMetadata.len = 0x256;
auto event = euDebugInterface.toEuDebugEventMetadata(&drmMetadata);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.metadataHandle);
EXPECT_EQ(0x128u, event.type);
EXPECT_EQ(0x256u, event.len);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmVmBindWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_vm_bind drmVmBind = {};
drmVmBind.client_handle = 0x32;
drmVmBind.vm_handle = 0x64;
drmVmBind.flags = 0x0F;
drmVmBind.num_binds = 0x128;
auto event = euDebugInterface.toEuDebugEventVmBind(&drmVmBind);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.vmHandle);
EXPECT_EQ(0x0Fu, event.flags);
EXPECT_EQ(0x128u, event.numBinds);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmVmBindOpWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_vm_bind_op drmVmBindOp = {};
drmVmBindOp.vm_bind_ref_seqno = 0x32;
drmVmBindOp.addr = 0x64;
drmVmBindOp.range = 0x128;
drmVmBindOp.num_extensions = 0x0F;
auto event = euDebugInterface.toEuDebugEventVmBindOp(&drmVmBindOp);
EXPECT_EQ(0x32u, event.vmBindRefSeqno);
EXPECT_EQ(0x64u, event.addr);
EXPECT_EQ(0x128u, event.range);
EXPECT_EQ(0x0Fu, event.numExtensions);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmVmBindOpMetadataWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_vm_bind_op_metadata drmVmBindOpMetadata = {};
drmVmBindOpMetadata.vm_bind_op_ref_seqno = 0x32;
drmVmBindOpMetadata.metadata_handle = 0x64;
drmVmBindOpMetadata.metadata_cookie = 0x128;
auto event = euDebugInterface.toEuDebugEventVmBindOpMetadata(&drmVmBindOpMetadata);
EXPECT_EQ(0x32u, event.vmBindOpRefSeqno);
EXPECT_EQ(0x64u, event.metadataHandle);
EXPECT_EQ(0x128u, event.metadataCookie);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmVmBindUfenceWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_vm_bind_ufence drmVmBindUfence = {};
drmVmBindUfence.vm_bind_ref_seqno = 0x32;
auto event = euDebugInterface.toEuDebugEventVmBindUfence(&drmVmBindUfence);
EXPECT_EQ(0x32u, event.vmBindRefSeqno);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmPageFaultWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_event_pagefault *drmPageFault = (prelim_drm_xe_eudebug_event_pagefault *)malloc(sizeof(prelim_drm_xe_eudebug_event_pagefault) + 4 * sizeof(uint8_t));
drmPageFault->client_handle = 0x32;
drmPageFault->exec_queue_handle = 0x64;
drmPageFault->flags = 0x0F;
drmPageFault->lrc_handle = 0x4096;
drmPageFault->pagefault_address = 0x128;
drmPageFault->bitmask_size = 4;
drmPageFault->bitmask[0] = 0x1;
drmPageFault->bitmask[1] = 0x2;
drmPageFault->bitmask[2] = 0x3;
drmPageFault->bitmask[3] = 0x4;
auto event = euDebugInterface.toEuDebugEventPageFault(drmPageFault);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x0Fu, event->flags);
EXPECT_EQ(0x4096u, event->lrcHandle);
EXPECT_EQ(0x128u, event->pagefaultAddress);
EXPECT_EQ(4u, event->bitmaskSize);
EXPECT_EQ(0x1u, event->bitmask[0]);
EXPECT_EQ(0x2u, event->bitmask[1]);
EXPECT_EQ(0x3u, event->bitmask[2]);
EXPECT_EQ(0x4u, event->bitmask[3]);
free(drmPageFault);
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmEuControlWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_eu_control drmEuControl = {};
drmEuControl.cmd = 1;
drmEuControl.flags = 2;
drmEuControl.seqno = 3;
drmEuControl.exec_queue_handle = 4;
drmEuControl.lrc_handle = 5;
drmEuControl.bitmask_size = 6;
auto bitmask = std::make_unique<uint8_t[]>(drmEuControl.bitmask_size);
for (uint32_t i = 0; i < drmEuControl.bitmask_size; i++) {
bitmask[i] = static_cast<uint8_t>(i + 1);
}
drmEuControl.bitmask_ptr = reinterpret_cast<uintptr_t>(bitmask.get());
auto event = euDebugInterface.toEuDebugEuControl(&drmEuControl);
EXPECT_EQ(1u, event.cmd);
EXPECT_EQ(2u, event.flags);
EXPECT_EQ(3u, event.seqno);
EXPECT_EQ(4u, event.execQueueHandle);
EXPECT_EQ(5u, event.lrcHandle);
EXPECT_EQ(6u, event.bitmaskSize);
for (uint32_t i = 0; i < drmEuControl.bitmask_size; i++) {
EXPECT_EQ(static_cast<uint8_t>(i + 1), reinterpret_cast<uint8_t *>(event.bitmaskPtr)[i]);
}
}
TEST(EuDebugInterfacePrelimTest, givenValidDrmConnectwhenConvertingToInterfaceTypesThenFieldsAreCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
prelim_drm_xe_eudebug_connect drmConnect = {};
drmConnect.extensions = 1;
drmConnect.pid = 2;
drmConnect.flags = 3;
drmConnect.version = 4;
auto connect = euDebugInterface.toEuDebugConnect(&drmConnect);
EXPECT_EQ(1u, connect.extensions);
EXPECT_EQ(2u, connect.pid);
EXPECT_EQ(3u, connect.flags);
EXPECT_EQ(4u, connect.version);
}
TEST(EuDebugInterfacePrelimTest, givenInterfaceConnectWhenConvertingToDrmConnectThenDrmTypeIsCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
EuDebugConnect connect = {};
connect.extensions = 1;
auto wrappedDrmConnect = euDebugInterface.toDrmEuDebugConnect(connect);
auto drmConnect = static_cast<prelim_drm_xe_eudebug_connect *>(wrappedDrmConnect.get());
EXPECT_EQ(1u, drmConnect->extensions);
}
TEST(EuDebugInterfacePrelimTest, givenInterfaceControlWhenConvertingToDrmEuControlThenDrmTypeIsCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
EuDebugEuControl euControl = {};
euControl.cmd = 2;
euControl.flags = 3;
euControl.seqno = 4;
euControl.execQueueHandle = 5;
euControl.lrcHandle = 6;
euControl.bitmaskSize = 7;
auto bitmask = std::make_unique<uint8_t[]>(euControl.bitmaskSize);
for (uint32_t i = 0; i < euControl.bitmaskSize; i++) {
bitmask[i] = static_cast<uint8_t>(i + 1);
}
euControl.bitmaskPtr = reinterpret_cast<uintptr_t>(bitmask.get());
auto wrappedDrmEuControl = euDebugInterface.toDrmEuDebugEuControl(euControl);
auto drmEuControl = static_cast<prelim_drm_xe_eudebug_eu_control *>(wrappedDrmEuControl.get());
EXPECT_EQ(2u, drmEuControl->cmd);
EXPECT_EQ(3u, drmEuControl->flags);
EXPECT_EQ(4u, drmEuControl->seqno);
EXPECT_EQ(5u, drmEuControl->exec_queue_handle);
EXPECT_EQ(6u, drmEuControl->lrc_handle);
EXPECT_EQ(7u, drmEuControl->bitmask_size);
for (uint32_t i = 0; i < euControl.bitmaskSize; i++) {
EXPECT_EQ(static_cast<uint8_t>(i + 1), reinterpret_cast<uint8_t *>(drmEuControl->bitmask_ptr)[i]);
}
}
TEST(EuDebugInterfacePrelimTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpenThenDrmTypeIsCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
EuDebugVmOpen vmOpen = {};
vmOpen.extensions = 1;
vmOpen.clientHandle = 2;
vmOpen.vmHandle = 3;
vmOpen.flags = 4;
vmOpen.timeoutNs = 5;
auto wrappedDrmVmOpen = euDebugInterface.toDrmEuDebugVmOpen(vmOpen);
auto drmVmOpen = static_cast<prelim_drm_xe_eudebug_vm_open *>(wrappedDrmVmOpen.get());
EXPECT_EQ(1u, drmVmOpen->extensions);
EXPECT_EQ(2u, drmVmOpen->client_handle);
EXPECT_EQ(3u, drmVmOpen->vm_handle);
EXPECT_EQ(4u, drmVmOpen->flags);
EXPECT_EQ(5u, drmVmOpen->timeout_ns);
}
TEST(EuDebugInterfacePrelimTest, givenInterfaceAckEventWhenConvertingToDrmAckEventThenDrmTypeIsCorrect) {
EuDebugInterfacePrelim euDebugInterface{};
EuDebugAckEvent ackEvent = {};
ackEvent.type = 1;
ackEvent.flags = 2;
ackEvent.seqno = 3;
auto wrappedDrmAckEvent = euDebugInterface.toDrmEuDebugAckEvent(ackEvent);
auto drmAckEvent = static_cast<prelim_drm_xe_eudebug_ack_event *>(wrappedDrmAckEvent.get());
EXPECT_EQ(1u, drmAckEvent->type);
EXPECT_EQ(2u, drmAckEvent->flags);
EXPECT_EQ(3u, drmAckEvent->seqno);
}

303
shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_upstream_tests.cpp
View File

@@ -51,3 +51,306 @@ TEST(EuDebugInterfaceUpstreamTest, whenGettingParamValueThenCorrectValueIsReturn
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));
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_eu_attention *drmEuAttention = (drm_xe_eudebug_event_eu_attention *)malloc(sizeof(drm_xe_eudebug_event_eu_attention) + 4 * sizeof(uint8_t));
drmEuAttention->client_handle = 0x32;
drmEuAttention->exec_queue_handle = 0x64;
drmEuAttention->lrc_handle = 0x128;
drmEuAttention->flags = 0x0F;
drmEuAttention->bitmask_size = 4;
drmEuAttention->bitmask[0] = 0x1;
drmEuAttention->bitmask[1] = 0x2;
drmEuAttention->bitmask[2] = 0x3;
drmEuAttention->bitmask[3] = 0x4;
auto event = euDebugInterface.toEuDebugEventEuAttention(drmEuAttention);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x128u, event->lrcHandle);
EXPECT_EQ(0x0Fu, event->flags);
EXPECT_EQ(4u, event->bitmaskSize);
EXPECT_EQ(0x1u, event->bitmask[0]);
EXPECT_EQ(0x2u, event->bitmask[1]);
EXPECT_EQ(0x3u, event->bitmask[2]);
EXPECT_EQ(0x4u, event->bitmask[3]);
free(drmEuAttention);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmClientWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_client drmClient = {};
drmClient.client_handle = 0x32;
auto event = euDebugInterface.toEuDebugEventClient(&drmClient);
EXPECT_EQ(0x32u, event.clientHandle);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm drmVm = {};
drmVm.client_handle = 0x32;
drmVm.vm_handle = 0x64;
auto event = euDebugInterface.toEuDebugEventVm(&drmVm);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.vmHandle);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_exec_queue *drmExecQueue = (drm_xe_eudebug_event_exec_queue *)malloc(sizeof(drm_xe_eudebug_event_exec_queue) + 3 * sizeof(uint64_t));
drmExecQueue->client_handle = 0x32;
drmExecQueue->vm_handle = 0x64;
drmExecQueue->exec_queue_handle = 0x128;
drmExecQueue->engine_class = 0x256;
drmExecQueue->width = 0x03;
drmExecQueue->lrc_handle[0] = 0x1;
drmExecQueue->lrc_handle[1] = 0x2;
drmExecQueue->lrc_handle[2] = 0x3;
auto event = euDebugInterface.toEuDebugEventExecQueue(drmExecQueue);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->vmHandle);
EXPECT_EQ(0x128u, event->execQueueHandle);
EXPECT_EQ(0x256u, event->engineClass);
EXPECT_EQ(0x3u, event->width);
EXPECT_EQ(0x1u, event->lrcHandle[0]);
EXPECT_EQ(0x2u, event->lrcHandle[1]);
EXPECT_EQ(0x3u, event->lrcHandle[2]);
free(drmExecQueue);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmMetadataWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_metadata drmMetadata = {};
drmMetadata.client_handle = 0x32;
drmMetadata.metadata_handle = 0x64;
drmMetadata.type = 0x128;
drmMetadata.len = 0x256;
auto event = euDebugInterface.toEuDebugEventMetadata(&drmMetadata);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.metadataHandle);
EXPECT_EQ(0x128u, event.type);
EXPECT_EQ(0x256u, event.len);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmBindWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm_bind drmVmBind = {};
drmVmBind.client_handle = 0x32;
drmVmBind.vm_handle = 0x64;
drmVmBind.flags = 0x0F;
drmVmBind.num_binds = 0x128;
auto event = euDebugInterface.toEuDebugEventVmBind(&drmVmBind);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.vmHandle);
EXPECT_EQ(0x0Fu, event.flags);
EXPECT_EQ(0x128u, event.numBinds);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmBindOpWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm_bind_op drmVmBindOp = {};
drmVmBindOp.vm_bind_ref_seqno = 0x32;
drmVmBindOp.addr = 0x64;
drmVmBindOp.range = 0x128;
drmVmBindOp.num_extensions = 0x0F;
auto event = euDebugInterface.toEuDebugEventVmBindOp(&drmVmBindOp);
EXPECT_EQ(0x32u, event.vmBindRefSeqno);
EXPECT_EQ(0x64u, event.addr);
EXPECT_EQ(0x128u, event.range);
EXPECT_EQ(0x0Fu, event.numExtensions);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmBindOpMetadataWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm_bind_op_metadata drmVmBindOpMetadata = {};
drmVmBindOpMetadata.vm_bind_op_ref_seqno = 0x32;
drmVmBindOpMetadata.metadata_handle = 0x64;
drmVmBindOpMetadata.metadata_cookie = 0x128;
auto event = euDebugInterface.toEuDebugEventVmBindOpMetadata(&drmVmBindOpMetadata);
EXPECT_EQ(0x32u, event.vmBindOpRefSeqno);
EXPECT_EQ(0x64u, event.metadataHandle);
EXPECT_EQ(0x128u, event.metadataCookie);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmBindUfenceWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm_bind_ufence drmVmBindUfence = {};
drmVmBindUfence.vm_bind_ref_seqno = 0x32;
auto event = euDebugInterface.toEuDebugEventVmBindUfence(&drmVmBindUfence);
EXPECT_EQ(0x32u, event.vmBindRefSeqno);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmPageFaultWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_pagefault *drmPageFault = (drm_xe_eudebug_event_pagefault *)malloc(sizeof(drm_xe_eudebug_event_pagefault) + 4 * sizeof(uint8_t));
drmPageFault->client_handle = 0x32;
drmPageFault->exec_queue_handle = 0x64;
drmPageFault->flags = 0x0F;
drmPageFault->lrc_handle = 0x4096;
drmPageFault->pagefault_address = 0x128;
drmPageFault->bitmask_size = 4;
drmPageFault->bitmask[0] = 0x1;
drmPageFault->bitmask[1] = 0x2;
drmPageFault->bitmask[2] = 0x3;
drmPageFault->bitmask[3] = 0x4;
auto event = euDebugInterface.toEuDebugEventPageFault(drmPageFault);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x0Fu, event->flags);
EXPECT_EQ(0x4096u, event->lrcHandle);
EXPECT_EQ(0x128u, event->pagefaultAddress);
EXPECT_EQ(4u, event->bitmaskSize);
EXPECT_EQ(0x1u, event->bitmask[0]);
EXPECT_EQ(0x2u, event->bitmask[1]);
EXPECT_EQ(0x3u, event->bitmask[2]);
EXPECT_EQ(0x4u, event->bitmask[3]);
free(drmPageFault);
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuControlWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_eu_control drmEuControl = {};
drmEuControl.cmd = 1;
drmEuControl.flags = 2;
drmEuControl.seqno = 3;
drmEuControl.exec_queue_handle = 4;
drmEuControl.lrc_handle = 5;
drmEuControl.bitmask_size = 6;
auto bitmask = std::make_unique<uint8_t[]>(drmEuControl.bitmask_size);
for (uint32_t i = 0; i < drmEuControl.bitmask_size; i++) {
bitmask[i] = static_cast<uint8_t>(i + 1);
}
drmEuControl.bitmask_ptr = reinterpret_cast<uintptr_t>(bitmask.get());
auto event = euDebugInterface.toEuDebugEuControl(&drmEuControl);
EXPECT_EQ(1u, event.cmd);
EXPECT_EQ(2u, event.flags);
EXPECT_EQ(3u, event.seqno);
EXPECT_EQ(4u, event.execQueueHandle);
EXPECT_EQ(5u, event.lrcHandle);
EXPECT_EQ(6u, event.bitmaskSize);
for (uint32_t i = 0; i < drmEuControl.bitmask_size; i++) {
EXPECT_EQ(static_cast<uint8_t>(i + 1), reinterpret_cast<uint8_t *>(event.bitmaskPtr)[i]);
}
}
TEST(EuDebugInterfaceUpstreamTest, givenValidDrmConnectwhenConvertingToInterfaceTypesThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_connect drmConnect = {};
drmConnect.extensions = 1;
drmConnect.pid = 2;
drmConnect.flags = 3;
drmConnect.version = 4;
auto connect = euDebugInterface.toEuDebugConnect(&drmConnect);
EXPECT_EQ(1u, connect.extensions);
EXPECT_EQ(2u, connect.pid);
EXPECT_EQ(3u, connect.flags);
EXPECT_EQ(4u, connect.version);
}
TEST(EuDebugInterfaceUpstreamTest, givenInterfaceConnectWhenConvertingToDrmConnectThenDrmTypeIsCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
EuDebugConnect connect = {};
connect.extensions = 1;
auto wrappedDrmConnect = euDebugInterface.toDrmEuDebugConnect(connect);
auto drmConnect = static_cast<drm_xe_eudebug_connect *>(wrappedDrmConnect.get());
EXPECT_EQ(1u, drmConnect->extensions);
}
TEST(EuDebugInterfaceUpstreamTest, givenInterfaceControlWhenConvertingToDrmEuControlThenDrmTypeIsCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
EuDebugEuControl euControl = {};
euControl.cmd = 2;
euControl.flags = 3;
euControl.seqno = 4;
euControl.execQueueHandle = 5;
euControl.lrcHandle = 6;
euControl.bitmaskSize = 7;
auto bitmask = std::make_unique<uint8_t[]>(euControl.bitmaskSize);
for (uint32_t i = 0; i < euControl.bitmaskSize; i++) {
bitmask[i] = static_cast<uint8_t>(i + 1);
}
euControl.bitmaskPtr = reinterpret_cast<uintptr_t>(bitmask.get());
auto wrappedDrmEuControl = euDebugInterface.toDrmEuDebugEuControl(euControl);
auto drmEuControl = static_cast<drm_xe_eudebug_eu_control *>(wrappedDrmEuControl.get());
EXPECT_EQ(2u, drmEuControl->cmd);
EXPECT_EQ(3u, drmEuControl->flags);
EXPECT_EQ(4u, drmEuControl->seqno);
EXPECT_EQ(5u, drmEuControl->exec_queue_handle);
EXPECT_EQ(6u, drmEuControl->lrc_handle);
EXPECT_EQ(7u, drmEuControl->bitmask_size);
for (uint32_t i = 0; i < euControl.bitmaskSize; i++) {
EXPECT_EQ(static_cast<uint8_t>(i + 1), reinterpret_cast<uint8_t *>(drmEuControl->bitmask_ptr)[i]);
}
}
TEST(EuDebugInterfaceUpstreamTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpenThenDrmTypeIsCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
EuDebugVmOpen vmOpen = {};
vmOpen.extensions = 1;
vmOpen.clientHandle = 2;
vmOpen.vmHandle = 3;
vmOpen.flags = 4;
vmOpen.timeoutNs = 5;
auto wrappedDrmVmOpen = euDebugInterface.toDrmEuDebugVmOpen(vmOpen);
auto drmVmOpen = static_cast<drm_xe_eudebug_vm_open *>(wrappedDrmVmOpen.get());
EXPECT_EQ(1u, drmVmOpen->extensions);
EXPECT_EQ(2u, drmVmOpen->client_handle);
EXPECT_EQ(3u, drmVmOpen->vm_handle);
EXPECT_EQ(4u, drmVmOpen->flags);
EXPECT_EQ(5u, drmVmOpen->timeout_ns);
}
TEST(EuDebugInterfaceUpstreamTest, givenInterfaceAckEventWhenConvertingToDrmAckEventThenDrmTypeIsCorrect) {
EuDebugInterfaceUpstream euDebugInterface{};
EuDebugAckEvent ackEvent = {};
ackEvent.type = 1;
ackEvent.flags = 2;
ackEvent.seqno = 3;
auto wrappedDrmAckEvent = euDebugInterface.toDrmEuDebugAckEvent(ackEvent);
auto drmAckEvent = static_cast<drm_xe_eudebug_ack_event *>(wrappedDrmAckEvent.get());
EXPECT_EQ(1u, drmAckEvent->type);
EXPECT_EQ(2u, drmAckEvent->flags);
EXPECT_EQ(3u, drmAckEvent->seqno);
}