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

refactor: Update eudebug header

Browse Source 
Resolves: NEO-16069

Signed-off-by: Jemale Lockett <jemale.lockett@intel.com>
This commit is contained in:
Jemale Lockett
2025-11-05 16:32:30 +00:00
committed by Compute-Runtime-Automation
parent 3d8a19cc13
commit 5677d4b9ab
15 changed files with 5453 additions and 5104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -72,6 +72,15 @@ DebugSession *DebugSessionLinuxXe::createLinuxSession(const zet_debug_config_t &
return nullptr; return nullptr;
} }
ze_result_t DebugSessionLinuxXe::initialize() {
if (euDebugInterface->getInterfaceType() == NEO::EuDebugInterfaceType::upstream) {
clientHandleToConnection[euDebugInterface->getDefaultClientHandle()].reset(new ClientConnectionXe);
clientHandleToConnection[euDebugInterface->getDefaultClientHandle()]->client = NEO::EuDebugEventClient{};
clientHandleToConnection[euDebugInterface->getDefaultClientHandle()]->client.clientHandle = euDebugInterface->getDefaultClientHandle();
}
return DebugSessionLinux::initialize();
}
bool DebugSessionLinuxXe::handleInternalEvent() { bool DebugSessionLinuxXe::handleInternalEvent() {
auto eventMemory = getInternalEvent(); auto eventMemory = getInternalEvent();
if (eventMemory == nullptr) { if (eventMemory == nullptr) {

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

@@ -26,6 +26,8 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, std::unique_ptr<NEO::EuDebugInterface> debugInterface, void *params); DebugSessionLinuxXe(const zet_debug_config_t &config, Device *device, int debugFd, std::unique_ptr<NEO::EuDebugInterface> debugInterface, void *params);
static DebugSession *createLinuxSession(const zet_debug_config_t &config, Device *device, ze_result_t &result, bool isRootAttach); static DebugSession *createLinuxSession(const zet_debug_config_t &config, Device *device, ze_result_t &result, bool isRootAttach);
ze_result_t initialize() override;
struct IoctlHandlerXe : DebugSessionLinux::IoctlHandler { struct IoctlHandlerXe : DebugSessionLinux::IoctlHandler {
IoctlHandlerXe(const NEO::EuDebugInterface &euDebugInterface) : euDebugInterface(euDebugInterface){}; IoctlHandlerXe(const NEO::EuDebugInterface &euDebugInterface) : euDebugInterface(euDebugInterface){};
int ioctl(int fd, unsigned long request, void *arg) override { int ioctl(int fd, unsigned long request, void *arg) override {

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

@@ -181,6 +181,7 @@ struct MockDebugSessionLinuxXe : public L0::DebugSessionLinuxXe {
using L0::DebugSessionLinuxXe::clientHandleToConnection; using L0::DebugSessionLinuxXe::clientHandleToConnection;
using L0::DebugSessionLinuxXe::debugArea; using L0::DebugSessionLinuxXe::debugArea;
using L0::DebugSessionLinuxXe::euControlInterruptSeqno; using L0::DebugSessionLinuxXe::euControlInterruptSeqno;
using L0::DebugSessionLinuxXe::euDebugInterface;
using L0::DebugSessionLinuxXe::eventTypeIsAttention; using L0::DebugSessionLinuxXe::eventTypeIsAttention;
using L0::DebugSessionLinuxXe::getEuControlCmdUnlock; using L0::DebugSessionLinuxXe::getEuControlCmdUnlock;
using L0::DebugSessionLinuxXe::getThreadStateMutexForTileSession; using L0::DebugSessionLinuxXe::getThreadStateMutexForTileSession;

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

@@ -364,6 +364,23 @@ TEST_F(DebugApiLinuxTestXe, GivenDebugSessionWhenPollReturnsZeroThenNotReadyIsRe
EXPECT_EQ(ZE_RESULT_NOT_READY, result); EXPECT_EQ(ZE_RESULT_NOT_READY, result);
} }
TEST_F(DebugApiLinuxTestXe, GivenDebugSessionWhenInterfaceIsUpstreamThenDefaultClientHandleConnectionCreated) {
zet_debug_config_t config = {};
config.pid = 0x1234;
auto session = std::make_unique<MockDebugSessionLinuxXe>(config, device, 10);
ASSERT_NE(nullptr, session);
auto handler = new MockIoctlHandlerXe;
session->ioctlHandler.reset(handler);
session->clientHandleToConnection.clear();
session->initialize();
EXPECT_EQ(1u, session->clientHandleToConnection.size());
EXPECT_NE(session->clientHandleToConnection.end(), session->clientHandleToConnection.find(EuDebugInterfaceUpstream::defaultClientHandle));
}
TEST_F(DebugApiLinuxTestXe, GivenDebugSessionInitializationWhenNoValidEventsAreReadThenResultNotReadyIsReturned) { TEST_F(DebugApiLinuxTestXe, GivenDebugSessionInitializationWhenNoValidEventsAreReadThenResultNotReadyIsReturned) {
zet_debug_config_t config = {}; zet_debug_config_t config = {};
config.pid = 0x1234; config.pid = 0x1234;

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

@@ -22,6 +22,7 @@ class EuDebugInterface {
static std::unique_ptr<EuDebugInterface> create(const std::string &sysFsPciPath); static std::unique_ptr<EuDebugInterface> create(const std::string &sysFsPciPath);
virtual uint32_t getParamValue(EuDebugParam param) const = 0; virtual uint32_t getParamValue(EuDebugParam param) const = 0;
virtual bool isExecQueuePageFaultEnableSupported() { return false; }; virtual bool isExecQueuePageFaultEnableSupported() { return false; };
virtual uint64_t getDefaultClientHandle() const { return 0; }
virtual EuDebugInterfaceType getInterfaceType() const = 0; virtual EuDebugInterfaceType getInterfaceType() const = 0;
virtual ~EuDebugInterface() = default; virtual ~EuDebugInterface() = default;

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

@@ -38,9 +38,9 @@ uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
case EuDebugParam::eventTypeExecQueuePlacements: case EuDebugParam::eventTypeExecQueuePlacements:
return 0; return 0;
case EuDebugParam::eventTypeMetadata: case EuDebugParam::eventTypeMetadata:
return DRM_XE_EUDEBUG_EVENT_METADATA; return 0;
case EuDebugParam::eventTypeOpen: case EuDebugParam::eventTypeOpen:
return DRM_XE_EUDEBUG_EVENT_OPEN; return 0;
case EuDebugParam::eventTypePagefault: case EuDebugParam::eventTypePagefault:
return DRM_XE_EUDEBUG_EVENT_PAGEFAULT; return DRM_XE_EUDEBUG_EVENT_PAGEFAULT;
case EuDebugParam::eventTypeRead: case EuDebugParam::eventTypeRead:
@@ -50,9 +50,9 @@ uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
case EuDebugParam::eventTypeVmBind: case EuDebugParam::eventTypeVmBind:
return DRM_XE_EUDEBUG_EVENT_VM_BIND; return DRM_XE_EUDEBUG_EVENT_VM_BIND;
case EuDebugParam::eventTypeVmBindOp: case EuDebugParam::eventTypeVmBindOp:
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP; return 0;
case EuDebugParam::eventTypeVmBindOpMetadata: case EuDebugParam::eventTypeVmBindOpMetadata:
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA; return 0;
case EuDebugParam::eventTypeVmBindUfence: case EuDebugParam::eventTypeVmBindUfence:
return DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE; return DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE;
case EuDebugParam::eventVmBindFlagUfence: case EuDebugParam::eventVmBindFlagUfence:
@@ -70,25 +70,25 @@ uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
case EuDebugParam::ioctlReadEvent: case EuDebugParam::ioctlReadEvent:
return DRM_XE_EUDEBUG_IOCTL_READ_EVENT; return DRM_XE_EUDEBUG_IOCTL_READ_EVENT;
case EuDebugParam::ioctlReadMetadata: case EuDebugParam::ioctlReadMetadata:
return DRM_XE_EUDEBUG_IOCTL_READ_METADATA; return 0;
case EuDebugParam::ioctlVmOpen: case EuDebugParam::ioctlVmOpen:
return DRM_XE_EUDEBUG_IOCTL_VM_OPEN; return DRM_XE_EUDEBUG_IOCTL_VM_OPEN;
case EuDebugParam::metadataCreate: case EuDebugParam::metadataCreate:
return DRM_IOCTL_XE_DEBUG_METADATA_CREATE; return 0;
case EuDebugParam::metadataDestroy: case EuDebugParam::metadataDestroy:
return DRM_IOCTL_XE_DEBUG_METADATA_DESTROY; return 0;
case EuDebugParam::metadataElfBinary: case EuDebugParam::metadataElfBinary:
return DRM_XE_DEBUG_METADATA_ELF_BINARY; return 0;
case EuDebugParam::metadataModuleArea: case EuDebugParam::metadataModuleArea:
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA; return 0;
case EuDebugParam::metadataProgramModule: case EuDebugParam::metadataProgramModule:
return DRM_XE_DEBUG_METADATA_PROGRAM_MODULE; return 0;
case EuDebugParam::metadataSbaArea: case EuDebugParam::metadataSbaArea:
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA; return 0;
case EuDebugParam::metadataSipArea: case EuDebugParam::metadataSipArea:
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA; return 0;
case EuDebugParam::vmBindOpExtensionsAttachDebug: case EuDebugParam::vmBindOpExtensionsAttachDebug:
return XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG; return 0;
} }
return 0; return 0;
} }
@@ -97,6 +97,10 @@ EuDebugInterfaceType EuDebugInterfaceUpstream::getInterfaceType() const {
return EuDebugInterfaceType::upstream; return EuDebugInterfaceType::upstream;
} }
uint64_t EuDebugInterfaceUpstream::getDefaultClientHandle() const {
return defaultClientHandle;
}
std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> EuDebugInterfaceUpstream::toEuDebugEventEuAttention(const void *drmType) { std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> EuDebugInterfaceUpstream::toEuDebugEventEuAttention(const void *drmType) {
const drm_xe_eudebug_event_eu_attention *event = static_cast<const drm_xe_eudebug_event_eu_attention *>(drmType); const drm_xe_eudebug_event_eu_attention *event = static_cast<const drm_xe_eudebug_event_eu_attention *>(drmType);
EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t))); EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t)));
@@ -112,7 +116,7 @@ std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> Eu
pEuAttentionEvent->flags = event->flags; pEuAttentionEvent->flags = event->flags;
pEuAttentionEvent->lrcHandle = event->lrc_handle; pEuAttentionEvent->lrcHandle = event->lrc_handle;
pEuAttentionEvent->execQueueHandle = event->exec_queue_handle; pEuAttentionEvent->execQueueHandle = event->exec_queue_handle;
pEuAttentionEvent->clientHandle = event->client_handle; pEuAttentionEvent->clientHandle = defaultClientHandle;
auto deleter = [](EuDebugEventEuAttention *ptr) { auto deleter = [](EuDebugEventEuAttention *ptr) {
free(ptr); free(ptr);
@@ -122,18 +126,8 @@ std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> Eu
} }
EuDebugEventClient EuDebugInterfaceUpstream::toEuDebugEventClient(const void *drmType) { EuDebugEventClient EuDebugInterfaceUpstream::toEuDebugEventClient(const void *drmType) {
const drm_xe_eudebug_event_client *event = static_cast<const drm_xe_eudebug_event_client *>(drmType); UNRECOVERABLE_IF(true);
EuDebugEventClient euClientEvent = {}; return {};
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) { EuDebugEventVm EuDebugInterfaceUpstream::toEuDebugEventVm(const void *drmType) {
@@ -145,9 +139,8 @@ EuDebugEventVm EuDebugInterfaceUpstream::toEuDebugEventVm(const void *drmType) {
euVmEvent.base.flags = event->base.flags; euVmEvent.base.flags = event->base.flags;
euVmEvent.base.seqno = event->base.seqno; euVmEvent.base.seqno = event->base.seqno;
euVmEvent.base.reserved = event->base.reserved; euVmEvent.base.reserved = event->base.reserved;
euVmEvent.clientHandle = event->client_handle;
euVmEvent.vmHandle = event->vm_handle; euVmEvent.vmHandle = event->vm_handle;
euVmEvent.clientHandle = defaultClientHandle;
return euVmEvent; return euVmEvent;
} }
@@ -166,7 +159,7 @@ std::unique_ptr<EuDebugEventExecQueue, void (*)(EuDebugEventExecQueue *)> EuDebu
pExecQueueEvent->engineClass = event->engine_class; pExecQueueEvent->engineClass = event->engine_class;
pExecQueueEvent->width = event->width; pExecQueueEvent->width = event->width;
pExecQueueEvent->vmHandle = event->vm_handle; pExecQueueEvent->vmHandle = event->vm_handle;
pExecQueueEvent->clientHandle = event->client_handle; pExecQueueEvent->clientHandle = defaultClientHandle;
memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t)); memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t));
auto deleter = [](EuDebugEventExecQueue *ptr) { auto deleter = [](EuDebugEventExecQueue *ptr) {
@@ -183,21 +176,9 @@ std::unique_ptr<EuDebugEventExecQueuePlacements, void (*)(EuDebugEventExecQueueP
} }
EuDebugEventMetadata EuDebugInterfaceUpstream::toEuDebugEventMetadata(const void *drmType) { EuDebugEventMetadata EuDebugInterfaceUpstream::toEuDebugEventMetadata(const void *drmType) {
const drm_xe_eudebug_event_metadata *event = static_cast<const drm_xe_eudebug_event_metadata *>(drmType);
EuDebugEventMetadata metadataEvent = {};
metadataEvent.base.len = event->base.len; UNRECOVERABLE_IF(true);
metadataEvent.base.type = event->base.type; return {};
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) { EuDebugEventVmBind EuDebugInterfaceUpstream::toEuDebugEventVmBind(const void *drmType) {
@@ -209,48 +190,24 @@ EuDebugEventVmBind EuDebugInterfaceUpstream::toEuDebugEventVmBind(const void *dr
vmBindEvent.base.flags = event->base.flags; vmBindEvent.base.flags = event->base.flags;
vmBindEvent.base.seqno = event->base.seqno; vmBindEvent.base.seqno = event->base.seqno;
vmBindEvent.base.reserved = event->base.reserved; vmBindEvent.base.reserved = event->base.reserved;
vmBindEvent.clientHandle = event->client_handle;
vmBindEvent.flags = event->flags; vmBindEvent.flags = event->flags;
vmBindEvent.numBinds = event->num_binds; vmBindEvent.numBinds = event->num_binds;
vmBindEvent.vmHandle = event->vm_handle; vmBindEvent.vmHandle = event->vm_handle;
vmBindEvent.clientHandle = defaultClientHandle;
return vmBindEvent; return vmBindEvent;
} }
NEO::EuDebugEventVmBindOp EuDebugInterfaceUpstream::toEuDebugEventVmBindOp(const void *drmType) { NEO::EuDebugEventVmBindOp EuDebugInterfaceUpstream::toEuDebugEventVmBindOp(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op *event = static_cast<const drm_xe_eudebug_event_vm_bind_op *>(drmType);
EuDebugEventVmBindOp vmBindOpEvent = {};
vmBindOpEvent.base.len = event->base.len; UNRECOVERABLE_IF(true);
vmBindOpEvent.base.type = event->base.type; return {};
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) { EuDebugEventVmBindOpMetadata EuDebugInterfaceUpstream::toEuDebugEventVmBindOpMetadata(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op_metadata *event = static_cast<const drm_xe_eudebug_event_vm_bind_op_metadata *>(drmType);
EuDebugEventVmBindOpMetadata vmBindOpMetadataEvent = {};
vmBindOpMetadataEvent.base.len = event->base.len; UNRECOVERABLE_IF(true);
vmBindOpMetadataEvent.base.type = event->base.type; return {};
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) { EuDebugEventVmBindUfence EuDebugInterfaceUpstream::toEuDebugEventVmBindUfence(const void *drmType) {
@@ -280,11 +237,11 @@ std::unique_ptr<EuDebugEventPageFault, void (*)(EuDebugEventPageFault *)> EuDebu
memcpy(pPageFaultEvent->bitmask, event->bitmask, event->bitmask_size * sizeof(uint8_t)); memcpy(pPageFaultEvent->bitmask, event->bitmask, event->bitmask_size * sizeof(uint8_t));
pPageFaultEvent->bitmaskSize = event->bitmask_size; pPageFaultEvent->bitmaskSize = event->bitmask_size;
pPageFaultEvent->clientHandle = event->client_handle;
pPageFaultEvent->flags = event->flags; pPageFaultEvent->flags = event->flags;
pPageFaultEvent->execQueueHandle = event->exec_queue_handle; pPageFaultEvent->execQueueHandle = event->exec_queue_handle;
pPageFaultEvent->lrcHandle = event->lrc_handle; pPageFaultEvent->lrcHandle = event->lrc_handle;
pPageFaultEvent->pagefaultAddress = event->pagefault_address; pPageFaultEvent->pagefaultAddress = event->pagefault_address;
pPageFaultEvent->clientHandle = defaultClientHandle;
auto deleter = [](EuDebugEventPageFault *ptr) { auto deleter = [](EuDebugEventPageFault *ptr) {
free(ptr); free(ptr);
@@ -299,12 +256,12 @@ EuDebugEuControl EuDebugInterfaceUpstream::toEuDebugEuControl(const void *drmTyp
control.bitmaskPtr = euControl->bitmask_ptr; control.bitmaskPtr = euControl->bitmask_ptr;
control.bitmaskSize = euControl->bitmask_size; control.bitmaskSize = euControl->bitmask_size;
control.clientHandle = euControl->client_handle;
control.cmd = euControl->cmd; control.cmd = euControl->cmd;
control.flags = euControl->flags; control.flags = euControl->flags;
control.execQueueHandle = euControl->exec_queue_handle; control.execQueueHandle = euControl->exec_queue_handle;
control.lrcHandle = euControl->lrc_handle; control.lrcHandle = euControl->lrc_handle;
control.seqno = euControl->seqno; control.seqno = euControl->seqno;
control.clientHandle = defaultClientHandle;
return control; return control;
} }
@@ -315,7 +272,6 @@ EuDebugConnect EuDebugInterfaceUpstream::toEuDebugConnect(const void *drmType) {
connectEvent.extensions = event->extensions; connectEvent.extensions = event->extensions;
connectEvent.flags = event->flags; connectEvent.flags = event->flags;
connectEvent.pid = event->pid;
connectEvent.version = event->version; connectEvent.version = event->version;
return connectEvent; return connectEvent;
@@ -325,7 +281,6 @@ std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugCo
struct drm_xe_eudebug_connect *pDrmConnect = new drm_xe_eudebug_connect(); struct drm_xe_eudebug_connect *pDrmConnect = new drm_xe_eudebug_connect();
pDrmConnect->extensions = connect.extensions; pDrmConnect->extensions = connect.extensions;
pDrmConnect->pid = connect.pid;
pDrmConnect->flags = connect.flags; pDrmConnect->flags = connect.flags;
pDrmConnect->version = connect.version; pDrmConnect->version = connect.version;
@@ -340,7 +295,6 @@ std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugEu
pDrmEuControl->bitmask_ptr = euControl.bitmaskPtr; pDrmEuControl->bitmask_ptr = euControl.bitmaskPtr;
pDrmEuControl->bitmask_size = euControl.bitmaskSize; pDrmEuControl->bitmask_size = euControl.bitmaskSize;
pDrmEuControl->client_handle = euControl.clientHandle;
pDrmEuControl->cmd = euControl.cmd; pDrmEuControl->cmd = euControl.cmd;
pDrmEuControl->flags = euControl.flags; pDrmEuControl->flags = euControl.flags;
pDrmEuControl->exec_queue_handle = euControl.execQueueHandle; pDrmEuControl->exec_queue_handle = euControl.execQueueHandle;
@@ -356,7 +310,6 @@ std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugEu
std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) { std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct drm_xe_eudebug_vm_open *pDrmVmOpen = new drm_xe_eudebug_vm_open(); struct drm_xe_eudebug_vm_open *pDrmVmOpen = new drm_xe_eudebug_vm_open();
pDrmVmOpen->client_handle = vmOpen.clientHandle;
pDrmVmOpen->extensions = vmOpen.extensions; pDrmVmOpen->extensions = vmOpen.extensions;
pDrmVmOpen->flags = vmOpen.flags; pDrmVmOpen->flags = vmOpen.flags;
pDrmVmOpen->timeout_ns = vmOpen.timeoutNs; pDrmVmOpen->timeout_ns = vmOpen.timeoutNs;
@@ -387,35 +340,9 @@ static_assert(offsetof(EuDebugEvent, flags) == offsetof(drm_xe_eudebug_event, fl
static_assert(offsetof(EuDebugEvent, seqno) == offsetof(drm_xe_eudebug_event, seqno)); static_assert(offsetof(EuDebugEvent, seqno) == offsetof(drm_xe_eudebug_event, seqno));
static_assert(offsetof(EuDebugEvent, reserved) == offsetof(drm_xe_eudebug_event, reserved)); static_assert(offsetof(EuDebugEvent, reserved) == offsetof(drm_xe_eudebug_event, reserved));
static_assert(sizeof(EuDebugReadMetadata) == sizeof(drm_xe_eudebug_read_metadata));
static_assert(offsetof(EuDebugReadMetadata, clientHandle) == offsetof(drm_xe_eudebug_read_metadata, client_handle));
static_assert(offsetof(EuDebugReadMetadata, metadataHandle) == offsetof(drm_xe_eudebug_read_metadata, metadata_handle));
static_assert(offsetof(EuDebugReadMetadata, flags) == offsetof(drm_xe_eudebug_read_metadata, flags));
static_assert(offsetof(EuDebugReadMetadata, reserved) == offsetof(drm_xe_eudebug_read_metadata, reserved));
static_assert(offsetof(EuDebugReadMetadata, ptr) == offsetof(drm_xe_eudebug_read_metadata, ptr));
static_assert(offsetof(EuDebugReadMetadata, size) == offsetof(drm_xe_eudebug_read_metadata, size));
static_assert(sizeof(DebugMetadataCreate) == sizeof(drm_xe_debug_metadata_create));
static_assert(offsetof(DebugMetadataCreate, extensions) == offsetof(drm_xe_debug_metadata_create, extensions));
static_assert(offsetof(DebugMetadataCreate, type) == offsetof(drm_xe_debug_metadata_create, type));
static_assert(offsetof(DebugMetadataCreate, userAddr) == offsetof(drm_xe_debug_metadata_create, user_addr));
static_assert(offsetof(DebugMetadataCreate, len) == offsetof(drm_xe_debug_metadata_create, len));
static_assert(offsetof(DebugMetadataCreate, metadataId) == offsetof(drm_xe_debug_metadata_create, metadata_id));
static_assert(sizeof(DebugMetadataDestroy) == sizeof(drm_xe_debug_metadata_destroy));
static_assert(offsetof(DebugMetadataDestroy, extensions) == offsetof(drm_xe_debug_metadata_destroy, extensions));
static_assert(offsetof(DebugMetadataDestroy, metadataId) == offsetof(drm_xe_debug_metadata_destroy, metadata_id));
static_assert(sizeof(XeUserExtension) == sizeof(drm_xe_user_extension)); static_assert(sizeof(XeUserExtension) == sizeof(drm_xe_user_extension));
static_assert(offsetof(XeUserExtension, nextExtension) == offsetof(drm_xe_user_extension, next_extension)); static_assert(offsetof(XeUserExtension, nextExtension) == offsetof(drm_xe_user_extension, next_extension));
static_assert(offsetof(XeUserExtension, name) == offsetof(drm_xe_user_extension, name)); static_assert(offsetof(XeUserExtension, name) == offsetof(drm_xe_user_extension, name));
static_assert(offsetof(XeUserExtension, pad) == offsetof(drm_xe_user_extension, pad)); static_assert(offsetof(XeUserExtension, pad) == offsetof(drm_xe_user_extension, pad));
static_assert(sizeof(VmBindOpExtAttachDebug) == sizeof(drm_xe_vm_bind_op_ext_attach_debug));
static_assert(offsetof(VmBindOpExtAttachDebug, base) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, base));
static_assert(offsetof(VmBindOpExtAttachDebug, metadataId) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, metadata_id));
static_assert(offsetof(VmBindOpExtAttachDebug, flags) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, flags));
static_assert(offsetof(VmBindOpExtAttachDebug, cookie) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, cookie));
static_assert(offsetof(VmBindOpExtAttachDebug, reserved) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, reserved));
} // namespace NEO } // namespace NEO

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

@@ -12,9 +12,11 @@ namespace NEO {
class EuDebugInterfaceUpstream : public EuDebugInterface { class EuDebugInterfaceUpstream : public EuDebugInterface {
public: public:
static constexpr const char *sysFsXeEuDebugFile = "/device/enable_eudebug"; static constexpr const char *sysFsXeEuDebugFile = "/device/enable_eudebug";
static constexpr uint64_t defaultClientHandle = 1;
uint32_t getParamValue(EuDebugParam param) const override; uint32_t getParamValue(EuDebugParam param) const override;
EuDebugInterfaceType getInterfaceType() const override; EuDebugInterfaceType getInterfaceType() const override;
uint64_t getDefaultClientHandle() const override;
std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> toEuDebugEventEuAttention(const void *drmType) override; std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> toEuDebugEventEuAttention(const void *drmType) override;
EuDebugEventClient toEuDebugEventClient(const void *drmType) override; EuDebugEventClient toEuDebugEventClient(const void *drmType) override;

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

@@ -67,7 +67,7 @@ uint32_t MockEuDebugInterface::getParamValue(EuDebugParam param) const {
std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> MockEuDebugInterface::toEuDebugEventEuAttention(const void *drmType) { std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> MockEuDebugInterface::toEuDebugEventEuAttention(const void *drmType) {
const drm_xe_eudebug_event_eu_attention *event = static_cast<const drm_xe_eudebug_event_eu_attention *>(drmType); const prelim_drm_xe_eudebug_event_eu_attention *event = static_cast<const prelim_drm_xe_eudebug_event_eu_attention *>(drmType);
EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t))); EuDebugEventEuAttention *pEuAttentionEvent = static_cast<EuDebugEventEuAttention *>(malloc(sizeof(EuDebugEventEuAttention) + event->bitmask_size * sizeof(uint8_t)));
pEuAttentionEvent->base.len = event->base.len; pEuAttentionEvent->base.len = event->base.len;
@@ -94,7 +94,7 @@ EuDebugEventVm MockEuDebugInterface::toEuDebugEventVm(const void *drmType) {
return *static_cast<const EuDebugEventVm *>(drmType); return *static_cast<const EuDebugEventVm *>(drmType);
} }
std::unique_ptr<EuDebugEventExecQueue, void (*)(EuDebugEventExecQueue *)> MockEuDebugInterface::toEuDebugEventExecQueue(const void *drmType) { std::unique_ptr<EuDebugEventExecQueue, void (*)(EuDebugEventExecQueue *)> MockEuDebugInterface::toEuDebugEventExecQueue(const void *drmType) {
const drm_xe_eudebug_event_exec_queue *event = static_cast<const drm_xe_eudebug_event_exec_queue *>(drmType); const prelim_drm_xe_eudebug_event_exec_queue *event = static_cast<const prelim_drm_xe_eudebug_event_exec_queue *>(drmType);
EuDebugEventExecQueue *pExecQueueEvent = static_cast<EuDebugEventExecQueue *>(malloc(sizeof(EuDebugEventExecQueue) + event->width * sizeof(uint64_t))); EuDebugEventExecQueue *pExecQueueEvent = static_cast<EuDebugEventExecQueue *>(malloc(sizeof(EuDebugEventExecQueue) + event->width * sizeof(uint64_t)));
pExecQueueEvent->base.len = event->base.len; pExecQueueEvent->base.len = event->base.len;
@@ -153,7 +153,7 @@ EuDebugEventVmBindUfence MockEuDebugInterface::toEuDebugEventVmBindUfence(const
return *static_cast<const EuDebugEventVmBindUfence *>(drmType); return *static_cast<const EuDebugEventVmBindUfence *>(drmType);
} }
std::unique_ptr<EuDebugEventPageFault, void (*)(EuDebugEventPageFault *)> MockEuDebugInterface::toEuDebugEventPageFault(const void *drmType) { std::unique_ptr<EuDebugEventPageFault, void (*)(EuDebugEventPageFault *)> MockEuDebugInterface::toEuDebugEventPageFault(const void *drmType) {
const drm_xe_eudebug_event_pagefault *event = static_cast<const drm_xe_eudebug_event_pagefault *>(drmType); const prelim_drm_xe_eudebug_event_pagefault *event = static_cast<const prelim_drm_xe_eudebug_event_pagefault *>(drmType);
EuDebugEventPageFault *pPageFaultEvent = static_cast<EuDebugEventPageFault *>(malloc(sizeof(EuDebugEventPageFault) + event->bitmask_size * sizeof(uint8_t))); EuDebugEventPageFault *pPageFaultEvent = static_cast<EuDebugEventPageFault *>(malloc(sizeof(EuDebugEventPageFault) + event->bitmask_size * sizeof(uint8_t)));
pPageFaultEvent->base.len = event->base.len; pPageFaultEvent->base.len = event->base.len;
@@ -186,7 +186,7 @@ EuDebugConnect MockEuDebugInterface::toEuDebugConnect(const void *drmType) {
} }
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugConnect(const EuDebugConnect &connect) { std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugConnect(const EuDebugConnect &connect) {
struct drm_xe_eudebug_connect *pDrmConnect = new drm_xe_eudebug_connect(); struct prelim_drm_xe_eudebug_connect *pDrmConnect = new prelim_drm_xe_eudebug_connect();
pDrmConnect->extensions = connect.extensions; pDrmConnect->extensions = connect.extensions;
pDrmConnect->pid = connect.pid; pDrmConnect->pid = connect.pid;
@@ -194,12 +194,12 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugConnec
pDrmConnect->version = connect.version; pDrmConnect->version = connect.version;
auto deleter = [](void *ptr) { auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_connect *>(ptr); delete static_cast<prelim_drm_xe_eudebug_connect *>(ptr);
}; };
return std::unique_ptr<void, void (*)(void *)>(pDrmConnect, deleter); return std::unique_ptr<void, void (*)(void *)>(pDrmConnect, deleter);
} }
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugEuControl(const EuDebugEuControl &euControl) { std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugEuControl(const EuDebugEuControl &euControl) {
struct drm_xe_eudebug_eu_control *pDrmEuControl = new drm_xe_eudebug_eu_control(); struct prelim_drm_xe_eudebug_eu_control *pDrmEuControl = new prelim_drm_xe_eudebug_eu_control();
pDrmEuControl->bitmask_ptr = euControl.bitmaskPtr; pDrmEuControl->bitmask_ptr = euControl.bitmaskPtr;
pDrmEuControl->bitmask_size = euControl.bitmaskSize; pDrmEuControl->bitmask_size = euControl.bitmaskSize;
@@ -211,12 +211,12 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugEuCont
pDrmEuControl->seqno = euControl.seqno; pDrmEuControl->seqno = euControl.seqno;
auto deleter = [](void *ptr) { auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_eu_control *>(ptr); delete static_cast<prelim_drm_xe_eudebug_eu_control *>(ptr);
}; };
return std::unique_ptr<void, void (*)(void *)>(pDrmEuControl, deleter); return std::unique_ptr<void, void (*)(void *)>(pDrmEuControl, deleter);
} }
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) { std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct drm_xe_eudebug_vm_open *pDrmVmOpen = new drm_xe_eudebug_vm_open(); struct prelim_drm_xe_eudebug_vm_open *pDrmVmOpen = new prelim_drm_xe_eudebug_vm_open();
pDrmVmOpen->client_handle = vmOpen.clientHandle; pDrmVmOpen->client_handle = vmOpen.clientHandle;
pDrmVmOpen->extensions = vmOpen.extensions; pDrmVmOpen->extensions = vmOpen.extensions;
@@ -225,19 +225,19 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen
pDrmVmOpen->vm_handle = vmOpen.vmHandle; pDrmVmOpen->vm_handle = vmOpen.vmHandle;
auto deleter = [](void *ptr) { auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_vm_open *>(ptr); delete static_cast<prelim_drm_xe_eudebug_vm_open *>(ptr);
}; };
return std::unique_ptr<void, void (*)(void *)>(pDrmVmOpen, deleter); return std::unique_ptr<void, void (*)(void *)>(pDrmVmOpen, deleter);
} }
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) { std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) {
struct drm_xe_eudebug_ack_event *pDrmAckEvent = new drm_xe_eudebug_ack_event(); struct prelim_drm_xe_eudebug_ack_event *pDrmAckEvent = new prelim_drm_xe_eudebug_ack_event();
pDrmAckEvent->type = ackEvent.type; pDrmAckEvent->type = ackEvent.type;
pDrmAckEvent->flags = ackEvent.flags; pDrmAckEvent->flags = ackEvent.flags;
pDrmAckEvent->seqno = ackEvent.seqno; pDrmAckEvent->seqno = ackEvent.seqno;
auto deleter = [](void *ptr) { auto deleter = [](void *ptr) {
delete static_cast<drm_xe_eudebug_ack_event *>(ptr); delete static_cast<prelim_drm_xe_eudebug_ack_event *>(ptr);
}; };
return std::unique_ptr<void, void (*)(void *)>(pDrmAckEvent, deleter); return std::unique_ptr<void, void (*)(void *)>(pDrmAckEvent, deleter);
} }

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

@@ -18,6 +18,9 @@ class MockEuDebugInterface : public EuDebugInterface {
bool isExecQueuePageFaultEnableSupported() override { return pageFaultEnableSupported; }; bool isExecQueuePageFaultEnableSupported() override { return pageFaultEnableSupported; };
uint32_t getParamValue(EuDebugParam param) const override; uint32_t getParamValue(EuDebugParam param) const override;
EuDebugInterfaceType getInterfaceType() const override { return euDebugInterfaceType; }; EuDebugInterfaceType getInterfaceType() const override { return euDebugInterfaceType; };
uint64_t getDefaultClientHandle() const override {
return 1; // EuDebugInterfaceUpstream::defaultClientHandle
};
std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> toEuDebugEventEuAttention(const void *drmType) override; std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> toEuDebugEventEuAttention(const void *drmType) override;
EuDebugEventClient toEuDebugEventClient(const void *drmType) override; EuDebugEventClient toEuDebugEventClient(const void *drmType) override;

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

@@ -25,14 +25,14 @@ TEST(EuDebugInterfaceUpstreamTest, whenGettingParamValueThenCorrectValueIsReturn
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_EU_ATTENTION), euDebugInterface.getParamValue(EuDebugParam::eventTypeEuAttention)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_EU_ATTENTION), euDebugInterface.getParamValue(EuDebugParam::eventTypeEuAttention));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueue)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueue));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueuePlacements)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueuePlacements));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeMetadata)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_OPEN), euDebugInterface.getParamValue(EuDebugParam::eventTypeOpen)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeOpen));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_PAGEFAULT), euDebugInterface.getParamValue(EuDebugParam::eventTypePagefault)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_PAGEFAULT), euDebugInterface.getParamValue(EuDebugParam::eventTypePagefault));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_READ), euDebugInterface.getParamValue(EuDebugParam::eventTypeRead)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_READ), euDebugInterface.getParamValue(EuDebugParam::eventTypeRead));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM), euDebugInterface.getParamValue(EuDebugParam::eventTypeVm)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM), euDebugInterface.getParamValue(EuDebugParam::eventTypeVm));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBind)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBind));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOp)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOp));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOpMetadata)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOpMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindUfence)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindUfence));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventVmBindFlagUfence)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventVmBindFlagUfence));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG), euDebugInterface.getParamValue(EuDebugParam::execQueueSetPropertyEuDebug)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG), euDebugInterface.getParamValue(EuDebugParam::execQueueSetPropertyEuDebug));
@@ -40,16 +40,16 @@ TEST(EuDebugInterfaceUpstreamTest, whenGettingParamValueThenCorrectValueIsReturn
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_ACK_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlAckEvent)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_ACK_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlAckEvent));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_EU_CONTROL), euDebugInterface.getParamValue(EuDebugParam::ioctlEuControl)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_EU_CONTROL), euDebugInterface.getParamValue(EuDebugParam::ioctlEuControl));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlReadEvent)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlReadEvent));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_METADATA), euDebugInterface.getParamValue(EuDebugParam::ioctlReadMetadata)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::ioctlReadMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_VM_OPEN), euDebugInterface.getParamValue(EuDebugParam::ioctlVmOpen)); EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_VM_OPEN), euDebugInterface.getParamValue(EuDebugParam::ioctlVmOpen));
EXPECT_EQ(static_cast<uint32_t>(DRM_IOCTL_XE_DEBUG_METADATA_CREATE), euDebugInterface.getParamValue(EuDebugParam::metadataCreate)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataCreate));
EXPECT_EQ(static_cast<uint32_t>(DRM_IOCTL_XE_DEBUG_METADATA_DESTROY), euDebugInterface.getParamValue(EuDebugParam::metadataDestroy)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataDestroy));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_DEBUG_METADATA_ELF_BINARY), euDebugInterface.getParamValue(EuDebugParam::metadataElfBinary)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataElfBinary));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataModuleArea)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataModuleArea));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_DEBUG_METADATA_PROGRAM_MODULE), euDebugInterface.getParamValue(EuDebugParam::metadataProgramModule)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataProgramModule));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSbaArea)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataSbaArea));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea));
EXPECT_EQ(static_cast<uint32_t>(XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG), euDebugInterface.getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug)); EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug));
} }
TEST(EuDebugInterfaceUpstreamTest, whenGettingInterfaceTypeThenUpstreamIsReturned) { TEST(EuDebugInterfaceUpstreamTest, whenGettingInterfaceTypeThenUpstreamIsReturned) {
@@ -62,7 +62,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInter
EuDebugInterfaceUpstream euDebugInterface{}; 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)); 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->exec_queue_handle = 0x64;
drmEuAttention->lrc_handle = 0x128; drmEuAttention->lrc_handle = 0x128;
drmEuAttention->flags = 0x0F; drmEuAttention->flags = 0x0F;
@@ -73,7 +72,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInter
drmEuAttention->bitmask[3] = 0x4; drmEuAttention->bitmask[3] = 0x4;
auto event = euDebugInterface.toEuDebugEventEuAttention(drmEuAttention); auto event = euDebugInterface.toEuDebugEventEuAttention(drmEuAttention);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle); EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x128u, event->lrcHandle); EXPECT_EQ(0x128u, event->lrcHandle);
EXPECT_EQ(0x0Fu, event->flags); EXPECT_EQ(0x0Fu, event->flags);
@@ -86,25 +84,13 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInter
free(drmEuAttention); 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) { TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{}; EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm drmVm = {}; drm_xe_eudebug_event_vm drmVm = {};
drmVm.client_handle = 0x32;
drmVm.vm_handle = 0x64; drmVm.vm_handle = 0x64;
auto event = euDebugInterface.toEuDebugEventVm(&drmVm); auto event = euDebugInterface.toEuDebugEventVm(&drmVm);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.vmHandle); EXPECT_EQ(0x64u, event.vmHandle);
} }
@@ -112,7 +98,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfa
EuDebugInterfaceUpstream euDebugInterface{}; 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)); 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->vm_handle = 0x64;
drmExecQueue->exec_queue_handle = 0x128; drmExecQueue->exec_queue_handle = 0x128;
drmExecQueue->engine_class = 0x256; drmExecQueue->engine_class = 0x256;
@@ -122,7 +107,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfa
drmExecQueue->lrc_handle[2] = 0x3; drmExecQueue->lrc_handle[2] = 0x3;
auto event = euDebugInterface.toEuDebugEventExecQueue(drmExecQueue); auto event = euDebugInterface.toEuDebugEventExecQueue(drmExecQueue);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->vmHandle); EXPECT_EQ(0x64u, event->vmHandle);
EXPECT_EQ(0x128u, event->execQueueHandle); EXPECT_EQ(0x128u, event->execQueueHandle);
EXPECT_EQ(0x256u, event->engineClass); EXPECT_EQ(0x256u, event->engineClass);
@@ -134,68 +118,20 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfa
free(drmExecQueue); 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) { TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmBindWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{}; EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_vm_bind drmVmBind = {}; drm_xe_eudebug_event_vm_bind drmVmBind = {};
drmVmBind.client_handle = 0x32;
drmVmBind.vm_handle = 0x64; drmVmBind.vm_handle = 0x64;
drmVmBind.flags = 0x0F; drmVmBind.flags = 0x0F;
drmVmBind.num_binds = 0x128; drmVmBind.num_binds = 0x128;
auto event = euDebugInterface.toEuDebugEventVmBind(&drmVmBind); auto event = euDebugInterface.toEuDebugEventVmBind(&drmVmBind);
EXPECT_EQ(0x32u, event.clientHandle);
EXPECT_EQ(0x64u, event.vmHandle); EXPECT_EQ(0x64u, event.vmHandle);
EXPECT_EQ(0x0Fu, event.flags); EXPECT_EQ(0x0Fu, event.flags);
EXPECT_EQ(0x128u, event.numBinds); 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) { TEST(EuDebugInterfaceUpstreamTest, givenValidDrmVmBindUfenceWhenConvertingToInterfaceTypeThenFieldsAreCorrect) {
EuDebugInterfaceUpstream euDebugInterface{}; EuDebugInterfaceUpstream euDebugInterface{};
@@ -210,7 +146,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmPageFaultWhenConvertingToInterfa
EuDebugInterfaceUpstream euDebugInterface{}; EuDebugInterfaceUpstream euDebugInterface{};
drm_xe_eudebug_event_pagefault *drmPageFault = (drm_xe_eudebug_event_pagefault *)malloc(sizeof(drm_xe_eudebug_event_pagefault) + 4 * sizeof(uint8_t)); 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->exec_queue_handle = 0x64;
drmPageFault->flags = 0x0F; drmPageFault->flags = 0x0F;
drmPageFault->lrc_handle = 0x4096; drmPageFault->lrc_handle = 0x4096;
@@ -222,7 +157,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmPageFaultWhenConvertingToInterfa
drmPageFault->bitmask[3] = 0x4; drmPageFault->bitmask[3] = 0x4;
auto event = euDebugInterface.toEuDebugEventPageFault(drmPageFault); auto event = euDebugInterface.toEuDebugEventPageFault(drmPageFault);
EXPECT_EQ(0x32u, event->clientHandle);
EXPECT_EQ(0x64u, event->execQueueHandle); EXPECT_EQ(0x64u, event->execQueueHandle);
EXPECT_EQ(0x0Fu, event->flags); EXPECT_EQ(0x0Fu, event->flags);
EXPECT_EQ(0x4096u, event->lrcHandle); EXPECT_EQ(0x4096u, event->lrcHandle);
@@ -270,14 +204,12 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmConnectwhenConvertingToInterface
drm_xe_eudebug_connect drmConnect = {}; drm_xe_eudebug_connect drmConnect = {};
drmConnect.extensions = 1; drmConnect.extensions = 1;
drmConnect.pid = 2;
drmConnect.flags = 3; drmConnect.flags = 3;
drmConnect.version = 4; drmConnect.version = 4;
auto connect = euDebugInterface.toEuDebugConnect(&drmConnect); auto connect = euDebugInterface.toEuDebugConnect(&drmConnect);
EXPECT_EQ(1u, connect.extensions); EXPECT_EQ(1u, connect.extensions);
EXPECT_EQ(2u, connect.pid);
EXPECT_EQ(3u, connect.flags); EXPECT_EQ(3u, connect.flags);
EXPECT_EQ(4u, connect.version); EXPECT_EQ(4u, connect.version);
} }
@@ -330,7 +262,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpen
EuDebugVmOpen vmOpen = {}; EuDebugVmOpen vmOpen = {};
vmOpen.extensions = 1; vmOpen.extensions = 1;
vmOpen.clientHandle = 2;
vmOpen.vmHandle = 3; vmOpen.vmHandle = 3;
vmOpen.flags = 4; vmOpen.flags = 4;
vmOpen.timeoutNs = 5; vmOpen.timeoutNs = 5;
@@ -339,7 +270,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpen
auto drmVmOpen = static_cast<drm_xe_eudebug_vm_open *>(wrappedDrmVmOpen.get()); auto drmVmOpen = static_cast<drm_xe_eudebug_vm_open *>(wrappedDrmVmOpen.get());
EXPECT_EQ(1u, drmVmOpen->extensions); EXPECT_EQ(1u, drmVmOpen->extensions);
EXPECT_EQ(2u, drmVmOpen->client_handle);
EXPECT_EQ(3u, drmVmOpen->vm_handle); EXPECT_EQ(3u, drmVmOpen->vm_handle);
EXPECT_EQ(4u, drmVmOpen->flags); EXPECT_EQ(4u, drmVmOpen->flags);
EXPECT_EQ(5u, drmVmOpen->timeout_ns); EXPECT_EQ(5u, drmVmOpen->timeout_ns);

4
third_party/uapi-eudebug/drm/.version vendored
View File

@@ -1,3 +1,3 @@
git_url: https://gitlab.freedesktop.org/miku/kernel/-/tree/eudebug-dev git_url: https://gitlab.freedesktop.org/miku/kernel/-/tree/eudebug-v5
git_revision: 446269b9ea8d6d08a35437b0b4bc85f64e070ebd git_revision: 9d410b9d29c8ca09a621ca988260bd30999b6915

2826
third_party/uapi-eudebug/drm/drm.h vendored
View File

File diff suppressed because it is too large Load Diff

2725
third_party/uapi-eudebug/drm/drm_mode.h vendored
View File

File diff suppressed because it is too large Load Diff

4255
third_party/uapi-eudebug/drm/xe_drm.h vendored
View File

File diff suppressed because it is too large Load Diff

459
third_party/uapi-eudebug/drm/xe_drm_eudebug.h vendored
View File

@@ -3,238 +3,227 @@
* Copyright © 2023 Intel Corporation * Copyright © 2023 Intel Corporation
*/ */
#ifndef _XE_DRM_EUDEBUG_H_ #ifndef _XE_DRM_EUDEBUG_H_
#define _XE_DRM_EUDEBUG_H_ #define _XE_DRM_EUDEBUG_H_
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif #endif
/** /**
* Do a eudebug event read for a debugger connection. * Do a eudebug event read for a debugger connection.
* *
* This ioctl is available in debug version 1. * This ioctl is available in debug version 1.
*/ */
#define DRM_XE_EUDEBUG_IOCTL_READ_EVENT _IO('j', 0x0) #define DRM_XE_EUDEBUG_IOCTL_READ_EVENT _IO('j', 0x0)
#define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL _IOWR('j', 0x2, struct drm_xe_eudebug_eu_control) #define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT _IOW('j', 0x1, struct drm_xe_eudebug_ack_event)
#define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT _IOW('j', 0x4, struct drm_xe_eudebug_ack_event) #define DRM_XE_EUDEBUG_IOCTL_VM_OPEN _IOW('j', 0x2, struct drm_xe_eudebug_vm_open)
#define DRM_XE_EUDEBUG_IOCTL_VM_OPEN _IOW('j', 0x1, struct drm_xe_eudebug_vm_open) #define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL _IOWR('j', 0x3, struct drm_xe_eudebug_eu_control)
#define DRM_XE_EUDEBUG_IOCTL_READ_METADATA _IOWR('j', 0x3, struct drm_xe_eudebug_read_metadata)
/**
/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */ * struct drm_xe_eudebug_event - Base type of event delivered by xe_eudebug.
struct drm_xe_eudebug_event { * @len: Length of event, including the base, of event.
__u32 len; * @type: Event type
* @flags: Flags for the event
__u16 type; * @seqno: Sequence number
#define DRM_XE_EUDEBUG_EVENT_NONE 0 * @reserved: MBZ
#define DRM_XE_EUDEBUG_EVENT_READ 1 *
#define DRM_XE_EUDEBUG_EVENT_OPEN 2 * Base event for xe_eudebug interface. To initiate a read, type
#define DRM_XE_EUDEBUG_EVENT_VM 3 * needs to be set to DRM_XE_EUDEBUG_EVENT_READ and length
#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 4 * need to be set by userspace to what has been allocated as max.
#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 5 * On successful return the event len will be deliver or -EMSGSIZE
#define DRM_XE_EUDEBUG_EVENT_VM_BIND 6 * if it does not fit. Seqno can be used to form a timeline
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP 7 * as event delivery order does not guarantee event creation
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 8 * order.
#define DRM_XE_EUDEBUG_EVENT_METADATA 9 *
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10 * flags will indicate if resource was created, destroyed
#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT 11 * or its state changed.
*
__u16 flags; * if DRM_XE_EUDEBUG_EVENT_NEED_ACK is set, the xe_eudebug
#define DRM_XE_EUDEBUG_EVENT_CREATE (1 << 0) * will held the said resource until it is acked by userspace
#define DRM_XE_EUDEBUG_EVENT_DESTROY (1 << 1) * using another acking ioctl with the seqno of said event.
#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE (1 << 2) *
#define DRM_XE_EUDEBUG_EVENT_NEED_ACK (1 << 3) */
struct drm_xe_eudebug_event {
__u64 seqno; __u32 len;
__u64 reserved;
}; __u16 type;
#define DRM_XE_EUDEBUG_EVENT_NONE 0
struct drm_xe_eudebug_event_client { #define DRM_XE_EUDEBUG_EVENT_READ 1
struct drm_xe_eudebug_event base; #define DRM_XE_EUDEBUG_EVENT_VM 2
#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE 3
__u64 client_handle; /* This is unique per debug connection */ #define DRM_XE_EUDEBUG_EVENT_VM_BIND 4
}; #define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA 5
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE 6
struct drm_xe_eudebug_event_vm { #define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION 7
struct drm_xe_eudebug_event base; #define DRM_XE_EUDEBUG_EVENT_PAGEFAULT 8
__u64 client_handle; __u16 flags;
__u64 vm_handle; #define DRM_XE_EUDEBUG_EVENT_CREATE (1 << 0)
}; #define DRM_XE_EUDEBUG_EVENT_DESTROY (1 << 1)
#define DRM_XE_EUDEBUG_EVENT_STATE_CHANGE (1 << 2)
struct drm_xe_eudebug_event_exec_queue { #define DRM_XE_EUDEBUG_EVENT_NEED_ACK (1 << 3)
struct drm_xe_eudebug_event base;
__u64 seqno;
__u64 client_handle; __u64 reserved;
__u64 vm_handle; };
__u64 exec_queue_handle;
__u32 engine_class; /**
__u32 width; * struct drm_xe_eudebug_event_vm - VM resource event
__u64 lrc_handle[]; * @vm_handle: Handle of a vm that was created/destroyed
}; *
* Resource creation/destruction event for a VM.
struct drm_xe_eudebug_event_eu_attention { */
struct drm_xe_eudebug_event base; struct drm_xe_eudebug_event_vm {
struct drm_xe_eudebug_event base;
__u64 client_handle;
__u64 exec_queue_handle; __u64 vm_handle;
__u64 lrc_handle; };
__u32 flags;
__u32 bitmask_size; struct drm_xe_eudebug_event_exec_queue {
__u8 bitmask[]; struct drm_xe_eudebug_event base;
};
__u64 vm_handle;
struct drm_xe_eudebug_eu_control { __u64 exec_queue_handle;
__u64 client_handle; __u32 engine_class;
__u32 width;
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL 0 __u64 lrc_handle[];
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED 1 };
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME 2
__u32 cmd; /*
__u32 flags; * When the client (debuggee) calls the vm_bind_ioctl with the
* DRM_XE_VM_BIND_OP_[ADD|REMOVE]_DEBUG_DATA operation, the following event
__u64 seqno; * sequence will be created (for the debugger):
*
__u64 exec_queue_handle; * ┌───────────────────────┐
__u64 lrc_handle; * │ EVENT_VM_BIND ├──────────────────┬─┬┄┐
__u32 reserved; * └───────────────────────┘ │ │ ┊
__u32 bitmask_size; * ┌──────────────────────────────────┐ │ │ ┊
__u64 bitmask_ptr; * │ EVENT_VM_BIND_OP_DEBUG_DATA #1 ├───┘ │ ┊
}; * └──────────────────────────────────┘ │ ┊
* ... │ ┊
/* * ┌──────────────────────────────────┐ │ ┊
* When client (debuggee) does vm_bind_ioctl() following event * │ EVENT_VM_BIND_OP_DEBUG_DATA #n ├─────┘ ┊
* sequence will be created (for the debugger): * └──────────────────────────────────┘ ┊
* * ┊
* ┌───────────────────────┐ * ┌┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┐ ┊
* │ EVENT_VM_BIND ├───────┬─┬─┐ * ┊ EVENT_UFENCE ├┄┄┄┄┄┄┄┘
* └───────────────────────┘ │ │ │ * └┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┘
* ┌───────────────────────┐ │ │ │ *
* │ EVENT_VM_BIND_OP #1 ├───┘ │ │ * All the events below VM_BIND will reference the VM_BIND
* └───────────────────────┘ │ │ * they associate with, by field .vm_bind_ref_seqno.
* ... │ │ * EVENT_UFENCE will only be included if the client did
* ┌───────────────────────┐ │ │ * attach sync of type UFENCE into its vm_bind_ioctl().
* │ EVENT_VM_BIND_OP #n ├─────┘ │ *
* └───────────────────────┘ │ * When EVENT_UFENCE is sent by the driver, all the OPs of
* │ * the original VM_BIND are completed and the [addr,range]
* ┌───────────────────────┐ │ * contained in them are present and modifiable through the
* │ EVENT_UFENCE ├───────┘ * vm accessors. Accessing [addr, range] before related ufence
* └───────────────────────┘ * event will lead to undefined results as the actual bind
* * operations are async and the backing storage might not
* All the events below VM_BIND will reference the VM_BIND * be there on a moment of receiving the event.
* they associate with, by field .vm_bind_ref_seqno. *
* event_ufence will only be included if the client did * Client's UFENCE sync will be held by the driver: client's
* attach sync of type UFENCE into its vm_bind_ioctl(). * drm_xe_wait_ufence will not complete and the value of the ufence
* * won't appear until ufence is acked by the debugger process calling
* When EVENT_UFENCE is sent by the driver, all the OPs of * DRM_XE_EUDEBUG_IOCTL_ACK_EVENT with the event_ufence.base.seqno.
* the original VM_BIND are completed and the [addr,range] * This will signal the fence, .value will update and the wait will
* contained in them are present and modifiable through the * complete allowing the client to continue.
* vm accessors. Accessing [addr, range] before related ufence *
* event will lead to undefined results as the actual bind */
* operations are async and the backing storage might not
* be there on a moment of receiving the event. struct drm_xe_eudebug_event_vm_bind {
* struct drm_xe_eudebug_event base;
* Client's UFENCE sync will be held by the driver: client's
* drm_xe_wait_ufence will not complete and the value of the ufence __u64 vm_handle;
* won't appear until ufence is acked by the debugger process calling
* DRM_XE_EUDEBUG_IOCTL_ACK_EVENT with the event_ufence.base.seqno. __u32 flags;
* This will signal the fence, .value will update and the wait will #define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0)
* complete allowing the client to continue.
* __u32 num_binds;
*/ };
struct drm_xe_eudebug_event_vm_bind { struct drm_xe_eudebug_event_vm_bind_op_debug_data {
struct drm_xe_eudebug_event base; struct drm_xe_eudebug_event base;
__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
__u64 client_handle; __u64 num_extensions;
__u64 vm_handle;
__u64 addr;
__u32 flags; __u64 range;
#define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0) __u64 flags;
__u32 offset;
__u32 num_binds; __u32 reserved;
}; union {
__u64 pseudopath;
struct drm_xe_eudebug_event_vm_bind_op { char pathname[PATH_MAX];
struct drm_xe_eudebug_event base; };
__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */ };
__u64 num_extensions;
struct drm_xe_eudebug_event_vm_bind_ufence {
__u64 addr; /* XXX: Zero for unmap all? */ struct drm_xe_eudebug_event base;
__u64 range; /* XXX: Zero for unmap all? */ __u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
}; };
struct drm_xe_eudebug_event_vm_bind_ufence { struct drm_xe_eudebug_ack_event {
struct drm_xe_eudebug_event base; __u32 type;
__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */ __u32 flags; /* MBZ */
}; __u64 seqno;
};
struct drm_xe_eudebug_ack_event {
__u32 type; struct drm_xe_eudebug_vm_open {
__u32 flags; /* MBZ */ /** @extensions: Pointer to the first extension struct, if any */
__u64 seqno; __u64 extensions;
};
/** @vm_handle: id of vm */
struct drm_xe_eudebug_vm_open { __u64 vm_handle;
/** @extensions: Pointer to the first extension struct, if any */
__u64 extensions; /** @flags: flags */
__u64 flags;
/** @client_handle: id of client */
__u64 client_handle; /** @timeout_ns: Timeout value in nanoseconds operations (fsync) */
__u64 timeout_ns;
/** @vm_handle: id of vm */ };
__u64 vm_handle;
struct drm_xe_eudebug_eu_control {
/** @flags: flags */
__u64 flags; #define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL 0
#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED 1
#define DRM_XE_EUDEBUG_VM_SYNC_MAX_TIMEOUT_NSECS (10ULL * NSEC_PER_SEC) #define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME 2
/** @timeout_ns: Timeout value in nanoseconds operations (fsync) */ __u32 cmd;
__u64 timeout_ns; __u32 flags;
};
__u64 seqno;
struct drm_xe_eudebug_read_metadata {
__u64 client_handle; __u64 exec_queue_handle;
__u64 metadata_handle; __u64 lrc_handle;
__u32 flags; __u32 reserved;
__u32 reserved; __u32 bitmask_size;
__u64 ptr; __u64 bitmask_ptr;
__u64 size; };
};
struct drm_xe_eudebug_event_eu_attention {
struct drm_xe_eudebug_event_metadata { struct drm_xe_eudebug_event base;
struct drm_xe_eudebug_event base;
__u64 exec_queue_handle;
__u64 client_handle; __u64 lrc_handle;
__u64 metadata_handle; __u32 flags;
/* XXX: Refer to xe_drm.h for fields */ __u32 bitmask_size;
__u64 type; __u8 bitmask[];
__u64 len; };
};
struct drm_xe_eudebug_event_pagefault {
struct drm_xe_eudebug_event_vm_bind_op_metadata { struct drm_xe_eudebug_event base;
struct drm_xe_eudebug_event base;
__u64 vm_bind_op_ref_seqno; /* *_event_vm_bind_op.base.seqno */ __u64 exec_queue_handle;
__u64 lrc_handle;
__u64 metadata_handle; __u32 flags;
__u64 metadata_cookie; __u32 bitmask_size;
}; __u64 pagefault_address;
__u8 bitmask[];
struct drm_xe_eudebug_event_pagefault { };
struct drm_xe_eudebug_event base;
#if defined(__cplusplus)
__u64 client_handle; }
__u64 exec_queue_handle; #endif
__u64 lrc_handle;
__u32 flags; #endif /* _XE_DRM_EUDEBUG_H_ */
__u32 bitmask_size;
__u64 pagefault_address;
__u8 bitmask[];
};
#if defined(__cplusplus)
}
#endif
#endif /* _XE_DRM_EUDEBUG_H_ */