diff --git a/level_zero/tools/source/debug/linux/debug_session_factory.h b/level_zero/tools/source/debug/linux/debug_session_factory.h index 2a288d1e76..fc7b05b3cc 100644 --- a/level_zero/tools/source/debug/linux/debug_session_factory.h +++ b/level_zero/tools/source/debug/linux/debug_session_factory.h @@ -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 { diff --git a/level_zero/tools/source/debug/linux/xe/debug_session.cpp b/level_zero/tools/source/debug/linux/xe/debug_session.cpp index 396c3c50f6..144abc0282 100644 --- a/level_zero/tools/source/debug/linux/xe/debug_session.cpp +++ b/level_zero/tools/source/debug/linux/xe/debug_session.cpp @@ -21,12 +21,11 @@ namespace L0 { static DebugSessionLinuxPopulateFactory 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 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 debugInterface, void *params) : DebugSessionLinux(config, device, debugFd) { + if (debugInterface) { + euDebugInterface = std::move(debugInterface); ioctlHandler.reset(new IoctlHandlerXe(*euDebugInterface)); if (params) { this->xeDebuggerVersion = reinterpret_cast(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(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(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(vm->vmHandle)); + UNRECOVERABLE_IF(clientHandleToConnection.find(vm.clientHandle) == clientHandleToConnection.end()); + clientHandleToConnection[vm.clientHandle]->vmIds.emplace(static_cast(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(vm->vmHandle)); + UNRECOVERABLE_IF(clientHandleToConnection.find(vm.clientHandle) == clientHandleToConnection.end()); + clientHandleToConnection[vm.clientHandle]->vmIds.erase(static_cast(vm.vmHandle)); } } else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypeExecQueue)) { - NEO::EuDebugEventExecQueue *execQueue = reinterpret_cast(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(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(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(vmBind->clientHandle), static_cast(vmBind->vmHandle), - static_cast(vmBind->numBinds), static_cast(vmBind->flags)); + static_cast(vmBind.clientHandle), static_cast(vmBind.vmHandle), + static_cast(vmBind.numBinds), static_cast(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(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(vmBindOp->vmBindRefSeqno), static_cast(vmBindOp->numExtensions), - static_cast(vmBindOp->addr), static_cast(vmBindOp->range)); - + static_cast(vmBindOp.vmBindRefSeqno), static_cast(vmBindOp.numExtensions), + static_cast(vmBindOp.addr), static_cast(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(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(vmBindUfence->vmBindRefSeqno)); + static_cast(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(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(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(vmBindOpMetadata->vmBindOpRefSeqno), static_cast(vmBindOpMetadata->metadataHandle), - static_cast(vmBindOpMetadata->metadataCookie)); + static_cast(vmBindOpMetadata.vmBindOpRefSeqno), static_cast(vmBindOpMetadata.metadataHandle), + static_cast(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(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(execQueuePlacements->clientHandle), static_cast(execQueuePlacements->vmHandle), tileIndex); } } else if (type == euDebugInterface->getParamValue(NEO::EuDebugParam::eventTypePagefault)) { - NEO::EuDebugEventPageFault *pf = reinterpret_cast(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(euControl.cmd), static_cast(euControl.execQueueHandle), static_cast(euControl.lrcHandle)); + } else { DEBUG_BREAK_IF(euControlInterruptSeqno >= euControl.seqno); euControlInterruptSeqno = euControl.seqno; @@ -816,7 +826,9 @@ int DebugSessionLinuxXe::threadControlStopped(std::unique_ptr &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(euControl.cmd), static_cast(euControl.execQueueHandle), @@ -838,8 +850,10 @@ int DebugSessionLinuxXe::threadControlStopped(std::unique_ptr &bitmas } } - printBitmask(bitmask.get(), bitmaskSize); - bitmaskOut = std::move(bitmask); + auto temp = std::make_unique(euControl.bitmaskSize); + memcpy_s(temp.get(), euControl.bitmaskSize, reinterpret_cast(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::vectorgetParamValue(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(euControl.cmd), static_cast(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(eventToAck.seqno), ret, ret != 0 ? errno : 0); return ret; } diff --git a/level_zero/tools/source/debug/linux/xe/debug_session.h b/level_zero/tools/source/debug/linux/xe/debug_session.h index e55bf4330e..af2503c0c0 100644 --- a/level_zero/tools/source/debug/linux/xe/debug_session.h +++ b/level_zero/tools/source/debug/linux/xe/debug_session.h @@ -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 debugInterface, void *params); static DebugSession *createLinuxSession(const zet_debug_config_t &config, Device *device, ze_result_t &result, bool isRootAttach); struct IoctlHandlerXe : DebugSessionLinux::IoctlHandler { diff --git a/level_zero/tools/source/debug/linux/xe/debug_session_xe_helper.cpp b/level_zero/tools/source/debug/linux/xe/debug_session_xe_helper.cpp index 5870eb64f7..6371d1d96d 100644 --- a/level_zero/tools/source/debug/linux/xe/debug_session_xe_helper.cpp +++ b/level_zero/tools/source/debug/linux/xe/debug_session_xe_helper.cpp @@ -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 debugInterface, void *params) { + return new DebugSessionLinuxXe(config, device, debugFd, std::move(debugInterface), params); } } // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/debug/debug_session_helper.cpp b/level_zero/tools/test/unit_tests/sources/debug/debug_session_helper.cpp index 965b3f384f..3d7dc0329c 100644 --- a/level_zero/tools/test/unit_tests/sources/debug/debug_session_helper.cpp +++ b/level_zero/tools/test/unit_tests/sources/debug/debug_session_helper.cpp @@ -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 @@ -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 debugInterface, void *params) { if (L0::ult::createDebugSessionFuncXe) { return L0::ult::createDebugSessionFuncXe(config, device, debugFd, params); } diff --git a/level_zero/tools/test/unit_tests/sources/debug/linux/xe/debug_session_fixtures_linux_xe.h b/level_zero/tools/test/unit_tests/sources/debug/linux/xe/debug_session_fixtures_linux_xe.h index a93e40153a..cad52d735d 100644 --- a/level_zero/tools/test/unit_tests/sources/debug/linux/xe/debug_session_fixtures_linux_xe.h +++ b/level_zero/tools/test/unit_tests/sources/debug/linux/xe/debug_session_fixtures_linux_xe.h @@ -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(), params) { clientHandleToConnection[mockClientHandle].reset(new ClientConnectionXe); clientHandle = mockClientHandle; createEuThreads(); diff --git a/level_zero/tools/test/unit_tests/sources/debug/linux/xe/test_debug_api_linux_xe.cpp b/level_zero/tools/test/unit_tests/sources/debug/linux/xe/test_debug_api_linux_xe.cpp index 66a4140961..8b6b736908 100644 --- a/level_zero/tools/test/unit_tests/sources/debug/linux/xe/test_debug_api_linux_xe.cpp +++ b/level_zero/tools/test/unit_tests/sources/debug/linux/xe/test_debug_api_linux_xe.cpp @@ -755,8 +755,9 @@ TEST_F(DebugApiLinuxTestXe, GivenEuDebugExecQueueEventWithEventDestroyFlagWhenHa client1.clientHandle = 0x123456789; session->handleEvent(reinterpret_cast(&client1)); - uint64_t execQueueData[sizeof(NEO::EuDebugEventExecQueue) / sizeof(uint64_t) + 3 * sizeof(typeOfLrcHandle)]; - auto *lrcHandle = reinterpret_cast(ptrOffset(execQueueData, sizeof(NEO::EuDebugEventExecQueue))); + NEO::EuDebugEventExecQueue *execQueue = static_cast(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(lrcHandle2); // ExecQueue create event handle - NEO::EuDebugEventExecQueue *execQueue = reinterpret_cast(&execQueueData); execQueue->base.type = static_cast(NEO::EuDebugParam::eventTypeExecQueue); execQueue->base.flags = static_cast(NEO::shiftLeftBy(static_cast(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(zet_debug_config_t{0x1234}, &deviceImp, 10, nullptr); + auto session = std::make_unique(zet_debug_config_t{0x1234}, &deviceImp, 10, nullptr, nullptr); ASSERT_NE(nullptr, session); std::unique_ptr tileSession = std::unique_ptr{session->createTileSession(zet_debug_config_t{0x1234}, &deviceImp, nullptr)}; diff --git a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h index 06d9e7b9a2..15faf0cbe1 100644 --- a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h +++ b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface.h @@ -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 toEuDebugEventEuAttention(const void *drmType) = 0; + virtual EuDebugEventClient toEuDebugEventClient(const void *drmType) = 0; + virtual EuDebugEventVm toEuDebugEventVm(const void *drmType) = 0; + virtual std::unique_ptr toEuDebugEventExecQueue(const void *drmType) = 0; + virtual std::unique_ptr 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 toEuDebugEventPageFault(const void *drmType) = 0; + virtual EuDebugEuControl toEuDebugEuControl(const void *drmType) = 0; + virtual EuDebugConnect toEuDebugConnect(const void *drmType) = 0; + + virtual std::unique_ptr toDrmEuDebugConnect(const EuDebugConnect &connect) = 0; + virtual std::unique_ptr toDrmEuDebugEuControl(const EuDebugEuControl &euControl) = 0; + virtual std::unique_ptr toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) = 0; + virtual std::unique_ptr toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) = 0; }; enum class EuDebugInterfaceType : uint32_t { diff --git a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.cpp b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.cpp index fedf9d0082..c943315ed8 100644 --- a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.cpp +++ b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.cpp @@ -9,6 +9,8 @@ #include "shared/source/os_interface/linux/xe/xedrm_prelim.h" +#include + 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 EuDebugInterfacePrelim::toEuDebugEventEuAttention(const void *drmType) { + const prelim_drm_xe_eudebug_event_eu_attention *event = static_cast(drmType); + EuDebugEventEuAttention *pEuAttentionEvent = static_cast(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(pEuAttentionEvent); +} + +EuDebugEventClient EuDebugInterfacePrelim::toEuDebugEventClient(const void *drmType) { + const prelim_drm_xe_eudebug_event_client *event = static_cast(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(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 EuDebugInterfacePrelim::toEuDebugEventExecQueue(const void *drmType) { + const prelim_drm_xe_eudebug_event_exec_queue *event = static_cast(drmType); + EuDebugEventExecQueue *pExecQueueEvent = static_cast(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(pExecQueueEvent); +} + +std::unique_ptr EuDebugInterfacePrelim::toEuDebugEventExecQueuePlacements(const void *drmType) { + const prelim_drm_xe_eudebug_event_exec_queue_placements *event = static_cast(drmType); + EuDebugEventExecQueuePlacements *euExecQueuePlacementsEvent = static_cast(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(euExecQueuePlacementsEvent); +} + +EuDebugEventMetadata EuDebugInterfacePrelim::toEuDebugEventMetadata(const void *drmType) { + const prelim_drm_xe_eudebug_event_metadata *event = static_cast(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(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(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(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(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 EuDebugInterfacePrelim::toEuDebugEventPageFault(const void *drmType) { + const prelim_drm_xe_eudebug_event_pagefault *event = static_cast(drmType); + EuDebugEventPageFault *pPageFaultEvent = static_cast(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(pPageFaultEvent); +} + +EuDebugEuControl EuDebugInterfacePrelim::toEuDebugEuControl(const void *drmType) { + const prelim_drm_xe_eudebug_eu_control *euControl = static_cast(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(drmType); + EuDebugConnect connectEvent = {}; + + connectEvent.extensions = event->extensions; + connectEvent.flags = event->flags; + connectEvent.pid = event->pid; + connectEvent.version = event->version; + + return connectEvent; +} + +std::unique_ptr 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(ptr); }; + return std::unique_ptr(pDrmConnect, deleter); +} + +std::unique_ptr 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(euControl.bitmaskPtr), euControl.bitmaskSize * sizeof(uint8_t)); + pDrmEuControl->bitmask_ptr = reinterpret_cast(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(static_cast(ptr)->bitmask_ptr); + delete static_cast(ptr); + }; + return std::unique_ptr(pDrmEuControl, deleter); +} + +std::unique_ptr 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(ptr); }; + return std::unique_ptr(pDrmVmOpen, deleter); +} + +std::unique_ptr 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(ptr); }; + return std::unique_ptr(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)); diff --git a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h index 567e354755..fec96f1256 100644 --- a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h +++ b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_prelim.h @@ -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 toEuDebugEventEuAttention(const void *drmType) override; + EuDebugEventClient toEuDebugEventClient(const void *drmType) override; + EuDebugEventVm toEuDebugEventVm(const void *drmType) override; + std::unique_ptr toEuDebugEventExecQueue(const void *drmType) override; + std::unique_ptr 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 toEuDebugEventPageFault(const void *drmType) override; + EuDebugEuControl toEuDebugEuControl(const void *drmType) override; + EuDebugConnect toEuDebugConnect(const void *drmType) override; + + std::unique_ptr toDrmEuDebugConnect(const EuDebugConnect &connect) override; + std::unique_ptr toDrmEuDebugEuControl(const EuDebugEuControl &euControl) override; + std::unique_ptr toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) override; + std::unique_ptr toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) override; }; } // namespace NEO diff --git a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.cpp b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.cpp index 24638ee9bd..7a5421c011 100644 --- a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.cpp +++ b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.cpp @@ -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 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 EuDebugInterfaceUpstream::toEuDebugEventEuAttention(const void *drmType) { + const drm_xe_eudebug_event_eu_attention *event = static_cast(drmType); + EuDebugEventEuAttention *pEuAttentionEvent = static_cast(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(pEuAttentionEvent); +} + +EuDebugEventClient EuDebugInterfaceUpstream::toEuDebugEventClient(const void *drmType) { + const drm_xe_eudebug_event_client *event = static_cast(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(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 EuDebugInterfaceUpstream::toEuDebugEventExecQueue(const void *drmType) { + const drm_xe_eudebug_event_exec_queue *event = static_cast(drmType); + EuDebugEventExecQueue *pExecQueueEvent = static_cast(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(pExecQueueEvent); +} + +std::unique_ptr EuDebugInterfaceUpstream::toEuDebugEventExecQueuePlacements(const void *drmType) { + return {}; +} + +EuDebugEventMetadata EuDebugInterfaceUpstream::toEuDebugEventMetadata(const void *drmType) { + const drm_xe_eudebug_event_metadata *event = static_cast(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(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(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(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(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 EuDebugInterfaceUpstream::toEuDebugEventPageFault(const void *drmType) { + const drm_xe_eudebug_event_pagefault *event = static_cast(drmType); + EuDebugEventPageFault *pPageFaultEvent = static_cast(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(pPageFaultEvent); +} + +EuDebugEuControl EuDebugInterfaceUpstream::toEuDebugEuControl(const void *drmType) { + const drm_xe_eudebug_eu_control *euControl = static_cast(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(drmType); + EuDebugConnect connectEvent = {}; + + connectEvent.extensions = event->extensions; + connectEvent.flags = event->flags; + connectEvent.pid = event->pid; + connectEvent.version = event->version; + + return connectEvent; +} + +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(pDrmConnect, deleter); +} + +std::unique_ptr 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(euControl.bitmaskPtr), euControl.bitmaskSize * sizeof(uint8_t)); + pDrmEuControl->bitmask_ptr = reinterpret_cast(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(static_cast(ptr)->bitmask_ptr); + delete static_cast(ptr); + }; + return std::unique_ptr(pDrmEuControl, deleter); +} + +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(pDrmVmOpen, deleter); +} + +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(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 diff --git a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h index 9cdc203f21..25b4893f08 100644 --- a/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h +++ b/shared/source/os_interface/linux/xe/eudebug/eudebug_interface_upstream.h @@ -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 toEuDebugEventEuAttention(const void *drmType) override; + EuDebugEventClient toEuDebugEventClient(const void *drmType) override; + EuDebugEventVm toEuDebugEventVm(const void *drmType) override; + std::unique_ptr toEuDebugEventExecQueue(const void *drmType) override; + std::unique_ptr 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 toEuDebugEventPageFault(const void *drmType) override; + EuDebugEuControl toEuDebugEuControl(const void *drmType) override; + EuDebugConnect toEuDebugConnect(const void *drmType) override; + + std::unique_ptr toDrmEuDebugConnect(const EuDebugConnect &connect) override; + std::unique_ptr toDrmEuDebugEuControl(const EuDebugEuControl &euControl) override; + std::unique_ptr toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) override; + std::unique_ptr toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) override; +}; } // namespace NEO diff --git a/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.cpp b/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.cpp index 97d6a977a6..d1d9b9b772 100644 --- a/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.cpp +++ b/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.cpp @@ -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 + #define RETURN_AS_IS(X) \ case X: \ return static_cast(X) @@ -58,6 +65,171 @@ uint32_t MockEuDebugInterface::getParamValue(EuDebugParam param) const { return 0; } +std::unique_ptr MockEuDebugInterface::toEuDebugEventEuAttention(const void *drmType) { + + const drm_xe_eudebug_event_eu_attention *event = static_cast(drmType); + EuDebugEventEuAttention *pEuAttentionEvent = static_cast(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(pEuAttentionEvent); +} +EuDebugEventClient MockEuDebugInterface::toEuDebugEventClient(const void *drmType) { + return *static_cast(drmType); +} +EuDebugEventVm MockEuDebugInterface::toEuDebugEventVm(const void *drmType) { + return *static_cast(drmType); +} +std::unique_ptr MockEuDebugInterface::toEuDebugEventExecQueue(const void *drmType) { + const drm_xe_eudebug_event_exec_queue *event = static_cast(drmType); + EuDebugEventExecQueue *pExecQueueEvent = static_cast(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(pExecQueueEvent); +} +std::unique_ptr MockEuDebugInterface::toEuDebugEventExecQueuePlacements(const void *drmType) { + const prelim_drm_xe_eudebug_event_exec_queue_placements *event = static_cast(drmType); + EuDebugEventExecQueuePlacements *euExecQueuePlacementsEvent = static_cast(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(euExecQueuePlacementsEvent); +} +EuDebugEventMetadata MockEuDebugInterface::toEuDebugEventMetadata(const void *drmType) { + return *static_cast(drmType); +} +EuDebugEventVmBind MockEuDebugInterface::toEuDebugEventVmBind(const void *drmType) { + return *static_cast(drmType); +} +EuDebugEventVmBindOp MockEuDebugInterface::toEuDebugEventVmBindOp(const void *drmType) { + return *static_cast(drmType); +} +EuDebugEventVmBindOpMetadata MockEuDebugInterface::toEuDebugEventVmBindOpMetadata(const void *drmType) { + return *static_cast(drmType); +} +EuDebugEventVmBindUfence MockEuDebugInterface::toEuDebugEventVmBindUfence(const void *drmType) { + return *static_cast(drmType); +} +std::unique_ptr MockEuDebugInterface::toEuDebugEventPageFault(const void *drmType) { + const drm_xe_eudebug_event_pagefault *event = static_cast(drmType); + EuDebugEventPageFault *pPageFaultEvent = static_cast(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(pPageFaultEvent); +} + +EuDebugEuControl MockEuDebugInterface::toEuDebugEuControl(const void *drmType) { + return *static_cast(drmType); +} + +EuDebugConnect MockEuDebugInterface::toEuDebugConnect(const void *drmType) { + return *static_cast(drmType); +} + +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(pDrmConnect, deleter); +} +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(pDrmEuControl, deleter); +} +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(pDrmVmOpen, deleter); +} +std::unique_ptr 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(ptr); + }; + return std::unique_ptr(pDrmAckEvent, deleter); +} + char MockEuDebugInterface::sysFsContent = '1'; [[maybe_unused]] static EnableEuDebugInterface enableMockEuDebug(MockEuDebugInterface::euDebugInterfaceType, MockEuDebugInterface::sysFsXeEuDebugFile, []() -> std::unique_ptr { return std::make_unique(); }); } // namespace NEO diff --git a/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h b/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h index 1e14a197a5..eb106f9399 100644 --- a/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h +++ b/shared/test/common/os_interface/linux/xe/eudebug/mock_eudebug_interface.h @@ -18,6 +18,25 @@ class MockEuDebugInterface : public EuDebugInterface { bool isExecQueuePageFaultEnableSupported() override { return pageFaultEnableSupported; }; uint32_t getParamValue(EuDebugParam param) const override; + std::unique_ptr toEuDebugEventEuAttention(const void *drmType) override; + EuDebugEventClient toEuDebugEventClient(const void *drmType) override; + EuDebugEventVm toEuDebugEventVm(const void *drmType) override; + std::unique_ptr toEuDebugEventExecQueue(const void *drmType) override; + std::unique_ptr 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 toEuDebugEventPageFault(const void *drmType) override; + EuDebugEuControl toEuDebugEuControl(const void *drmType) override; + EuDebugConnect toEuDebugConnect(const void *drmType) override; + + std::unique_ptr toDrmEuDebugConnect(const EuDebugConnect &connect) override; + std::unique_ptr toDrmEuDebugEuControl(const EuDebugEuControl &euControl) override; + std::unique_ptr toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) override; + std::unique_ptr toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) override; + bool pageFaultEnableSupported = false; }; diff --git a/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_prelim_tests.cpp b/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_prelim_tests.cpp index dcba8325c5..6b40a9e1eb 100644 --- a/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_prelim_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_prelim_tests.cpp @@ -50,3 +50,331 @@ TEST(EuDebugInterfacePrelimTest, whenGettingParamValueThenCorrectValueIsReturned EXPECT_EQ(static_cast(PRELIM_WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea)); EXPECT_EQ(static_cast(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(drmEuControl.bitmask_size); + for (uint32_t i = 0; i < drmEuControl.bitmask_size; i++) { + bitmask[i] = static_cast(i + 1); + } + drmEuControl.bitmask_ptr = reinterpret_cast(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(i + 1), reinterpret_cast(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(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(euControl.bitmaskSize); + for (uint32_t i = 0; i < euControl.bitmaskSize; i++) { + bitmask[i] = static_cast(i + 1); + } + euControl.bitmaskPtr = reinterpret_cast(bitmask.get()); + + auto wrappedDrmEuControl = euDebugInterface.toDrmEuDebugEuControl(euControl); + auto drmEuControl = static_cast(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(i + 1), reinterpret_cast(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(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(wrappedDrmAckEvent.get()); + + EXPECT_EQ(1u, drmAckEvent->type); + EXPECT_EQ(2u, drmAckEvent->flags); + EXPECT_EQ(3u, drmAckEvent->seqno); +} \ No newline at end of file diff --git a/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_upstream_tests.cpp b/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_upstream_tests.cpp index c828b29b96..386f312565 100644 --- a/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_upstream_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/xe/eudebug/eudebug_interface_upstream_tests.cpp @@ -51,3 +51,306 @@ TEST(EuDebugInterfaceUpstreamTest, whenGettingParamValueThenCorrectValueIsReturn EXPECT_EQ(static_cast(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea)); EXPECT_EQ(static_cast(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(drmEuControl.bitmask_size); + for (uint32_t i = 0; i < drmEuControl.bitmask_size; i++) { + bitmask[i] = static_cast(i + 1); + } + drmEuControl.bitmask_ptr = reinterpret_cast(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(i + 1), reinterpret_cast(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(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(euControl.bitmaskSize); + + for (uint32_t i = 0; i < euControl.bitmaskSize; i++) { + bitmask[i] = static_cast(i + 1); + } + euControl.bitmaskPtr = reinterpret_cast(bitmask.get()); + + auto wrappedDrmEuControl = euDebugInterface.toDrmEuDebugEuControl(euControl); + auto drmEuControl = static_cast(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(i + 1), reinterpret_cast(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(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(wrappedDrmAckEvent.get()); + + EXPECT_EQ(1u, drmAckEvent->type); + EXPECT_EQ(2u, drmAckEvent->flags); + EXPECT_EQ(3u, drmAckEvent->seqno); +} \ No newline at end of file