intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-25 22:34:15 +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

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);
virtual uint32_t getParamValue(EuDebugParam param) const = 0;
virtual bool isExecQueuePageFaultEnableSupported() { return false; };
virtual uint64_t getDefaultClientHandle() const { return 0; }
virtual EuDebugInterfaceType getInterfaceType() const = 0;
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:
return 0;
case EuDebugParam::eventTypeMetadata:
return DRM_XE_EUDEBUG_EVENT_METADATA;
return 0;
case EuDebugParam::eventTypeOpen:
return DRM_XE_EUDEBUG_EVENT_OPEN;
return 0;
case EuDebugParam::eventTypePagefault:
return DRM_XE_EUDEBUG_EVENT_PAGEFAULT;
case EuDebugParam::eventTypeRead:
@@ -50,9 +50,9 @@ uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
case EuDebugParam::eventTypeVmBind:
return DRM_XE_EUDEBUG_EVENT_VM_BIND;
case EuDebugParam::eventTypeVmBindOp:
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP;
return 0;
case EuDebugParam::eventTypeVmBindOpMetadata:
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA;
return 0;
case EuDebugParam::eventTypeVmBindUfence:
return DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE;
case EuDebugParam::eventVmBindFlagUfence:
@@ -70,25 +70,25 @@ uint32_t EuDebugInterfaceUpstream::getParamValue(EuDebugParam param) const {
case EuDebugParam::ioctlReadEvent:
return DRM_XE_EUDEBUG_IOCTL_READ_EVENT;
case EuDebugParam::ioctlReadMetadata:
return DRM_XE_EUDEBUG_IOCTL_READ_METADATA;
return 0;
case EuDebugParam::ioctlVmOpen:
return DRM_XE_EUDEBUG_IOCTL_VM_OPEN;
case EuDebugParam::metadataCreate:
return DRM_IOCTL_XE_DEBUG_METADATA_CREATE;
return 0;
case EuDebugParam::metadataDestroy:
return DRM_IOCTL_XE_DEBUG_METADATA_DESTROY;
return 0;
case EuDebugParam::metadataElfBinary:
return DRM_XE_DEBUG_METADATA_ELF_BINARY;
return 0;
case EuDebugParam::metadataModuleArea:
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA;
return 0;
case EuDebugParam::metadataProgramModule:
return DRM_XE_DEBUG_METADATA_PROGRAM_MODULE;
return 0;
case EuDebugParam::metadataSbaArea:
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA;
return 0;
case EuDebugParam::metadataSipArea:
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA;
return 0;
case EuDebugParam::vmBindOpExtensionsAttachDebug:
return XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
return 0;
}
return 0;
}
@@ -97,6 +97,10 @@ EuDebugInterfaceType EuDebugInterfaceUpstream::getInterfaceType() const {
return EuDebugInterfaceType::upstream;
}
uint64_t EuDebugInterfaceUpstream::getDefaultClientHandle() const {
return defaultClientHandle;
}
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);
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->lrcHandle = event->lrc_handle;
pEuAttentionEvent->execQueueHandle = event->exec_queue_handle;
pEuAttentionEvent->clientHandle = event->client_handle;
pEuAttentionEvent->clientHandle = defaultClientHandle;
auto deleter = [](EuDebugEventEuAttention *ptr) {
free(ptr);
@@ -122,18 +126,8 @@ std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> Eu
}
EuDebugEventClient EuDebugInterfaceUpstream::toEuDebugEventClient(const void *drmType) {
const drm_xe_eudebug_event_client *event = static_cast<const drm_xe_eudebug_event_client *>(drmType);
EuDebugEventClient euClientEvent = {};
euClientEvent.base.len = event->base.len;
euClientEvent.base.type = event->base.type;
euClientEvent.base.flags = event->base.flags;
euClientEvent.base.seqno = event->base.seqno;
euClientEvent.base.reserved = event->base.reserved;
euClientEvent.clientHandle = event->client_handle;
return euClientEvent;
UNRECOVERABLE_IF(true);
return {};
}
EuDebugEventVm EuDebugInterfaceUpstream::toEuDebugEventVm(const void *drmType) {
@@ -145,9 +139,8 @@ EuDebugEventVm EuDebugInterfaceUpstream::toEuDebugEventVm(const void *drmType) {
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;
euVmEvent.clientHandle = defaultClientHandle;
return euVmEvent;
}
@@ -166,7 +159,7 @@ std::unique_ptr<EuDebugEventExecQueue, void (*)(EuDebugEventExecQueue *)> EuDebu
pExecQueueEvent->engineClass = event->engine_class;
pExecQueueEvent->width = event->width;
pExecQueueEvent->vmHandle = event->vm_handle;
pExecQueueEvent->clientHandle = event->client_handle;
pExecQueueEvent->clientHandle = defaultClientHandle;
memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t));
auto deleter = [](EuDebugEventExecQueue *ptr) {
@@ -183,21 +176,9 @@ std::unique_ptr<EuDebugEventExecQueuePlacements, void (*)(EuDebugEventExecQueueP
}
EuDebugEventMetadata EuDebugInterfaceUpstream::toEuDebugEventMetadata(const void *drmType) {
const drm_xe_eudebug_event_metadata *event = static_cast<const drm_xe_eudebug_event_metadata *>(drmType);
EuDebugEventMetadata metadataEvent = {};
metadataEvent.base.len = event->base.len;
metadataEvent.base.type = event->base.type;
metadataEvent.base.flags = event->base.flags;
metadataEvent.base.seqno = event->base.seqno;
metadataEvent.base.reserved = event->base.reserved;
metadataEvent.clientHandle = event->client_handle;
metadataEvent.len = event->len;
metadataEvent.metadataHandle = event->metadata_handle;
metadataEvent.type = event->type;
return metadataEvent;
UNRECOVERABLE_IF(true);
return {};
}
EuDebugEventVmBind EuDebugInterfaceUpstream::toEuDebugEventVmBind(const void *drmType) {
@@ -209,48 +190,24 @@ EuDebugEventVmBind EuDebugInterfaceUpstream::toEuDebugEventVmBind(const void *dr
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;
vmBindEvent.clientHandle = defaultClientHandle;
return vmBindEvent;
}
NEO::EuDebugEventVmBindOp EuDebugInterfaceUpstream::toEuDebugEventVmBindOp(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op *event = static_cast<const drm_xe_eudebug_event_vm_bind_op *>(drmType);
EuDebugEventVmBindOp vmBindOpEvent = {};
vmBindOpEvent.base.len = event->base.len;
vmBindOpEvent.base.type = event->base.type;
vmBindOpEvent.base.flags = event->base.flags;
vmBindOpEvent.base.seqno = event->base.seqno;
vmBindOpEvent.base.reserved = event->base.reserved;
vmBindOpEvent.vmBindRefSeqno = event->vm_bind_ref_seqno;
vmBindOpEvent.numExtensions = event->num_extensions;
vmBindOpEvent.addr = event->addr;
vmBindOpEvent.range = event->range;
return vmBindOpEvent;
UNRECOVERABLE_IF(true);
return {};
}
EuDebugEventVmBindOpMetadata EuDebugInterfaceUpstream::toEuDebugEventVmBindOpMetadata(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op_metadata *event = static_cast<const drm_xe_eudebug_event_vm_bind_op_metadata *>(drmType);
EuDebugEventVmBindOpMetadata vmBindOpMetadataEvent = {};
vmBindOpMetadataEvent.base.len = event->base.len;
vmBindOpMetadataEvent.base.type = event->base.type;
vmBindOpMetadataEvent.base.flags = event->base.flags;
vmBindOpMetadataEvent.base.seqno = event->base.seqno;
vmBindOpMetadataEvent.base.reserved = event->base.reserved;
vmBindOpMetadataEvent.vmBindOpRefSeqno = event->vm_bind_op_ref_seqno;
vmBindOpMetadataEvent.metadataHandle = event->metadata_handle;
vmBindOpMetadataEvent.metadataCookie = event->metadata_cookie;
return vmBindOpMetadataEvent;
UNRECOVERABLE_IF(true);
return {};
}
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));
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;
pPageFaultEvent->clientHandle = defaultClientHandle;
auto deleter = [](EuDebugEventPageFault *ptr) {
free(ptr);
@@ -299,12 +256,12 @@ EuDebugEuControl EuDebugInterfaceUpstream::toEuDebugEuControl(const void *drmTyp
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;
control.clientHandle = defaultClientHandle;
return control;
}
@@ -315,7 +272,6 @@ EuDebugConnect EuDebugInterfaceUpstream::toEuDebugConnect(const void *drmType) {
connectEvent.extensions = event->extensions;
connectEvent.flags = event->flags;
connectEvent.pid = event->pid;
connectEvent.version = event->version;
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();
pDrmConnect->extensions = connect.extensions;
pDrmConnect->pid = connect.pid;
pDrmConnect->flags = connect.flags;
pDrmConnect->version = connect.version;
@@ -340,7 +295,6 @@ std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugEu
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;
@@ -356,7 +310,6 @@ std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugEu
std::unique_ptr<void, void (*)(void *)> EuDebugInterfaceUpstream::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct drm_xe_eudebug_vm_open *pDrmVmOpen = new drm_xe_eudebug_vm_open();
pDrmVmOpen->client_handle = vmOpen.clientHandle;
pDrmVmOpen->extensions = vmOpen.extensions;
pDrmVmOpen->flags = vmOpen.flags;
pDrmVmOpen->timeout_ns = vmOpen.timeoutNs;
@@ -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, 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(offsetof(XeUserExtension, nextExtension) == offsetof(drm_xe_user_extension, next_extension));
static_assert(offsetof(XeUserExtension, name) == offsetof(drm_xe_user_extension, name));
static_assert(offsetof(XeUserExtension, pad) == offsetof(drm_xe_user_extension, pad));
static_assert(sizeof(VmBindOpExtAttachDebug) == sizeof(drm_xe_vm_bind_op_ext_attach_debug));
static_assert(offsetof(VmBindOpExtAttachDebug, base) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, base));
static_assert(offsetof(VmBindOpExtAttachDebug, metadataId) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, metadata_id));
static_assert(offsetof(VmBindOpExtAttachDebug, flags) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, flags));
static_assert(offsetof(VmBindOpExtAttachDebug, cookie) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, cookie));
static_assert(offsetof(VmBindOpExtAttachDebug, reserved) == offsetof(drm_xe_vm_bind_op_ext_attach_debug, reserved));
} // namespace NEO

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

@@ -12,9 +12,11 @@ namespace NEO {
class EuDebugInterfaceUpstream : public EuDebugInterface {
public:
static constexpr const char *sysFsXeEuDebugFile = "/device/enable_eudebug";
static constexpr uint64_t defaultClientHandle = 1;
uint32_t getParamValue(EuDebugParam param) const override;
EuDebugInterfaceType getInterfaceType() const override;
uint64_t getDefaultClientHandle() const override;
std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> toEuDebugEventEuAttention(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) {
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)));
pEuAttentionEvent->base.len = event->base.len;
@@ -94,7 +94,7 @@ EuDebugEventVm MockEuDebugInterface::toEuDebugEventVm(const void *drmType) {
return *static_cast<const EuDebugEventVm *>(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)));
pExecQueueEvent->base.len = event->base.len;
@@ -153,7 +153,7 @@ EuDebugEventVmBindUfence MockEuDebugInterface::toEuDebugEventVmBindUfence(const
return *static_cast<const EuDebugEventVmBindUfence *>(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)));
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) {
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->pid = connect.pid;
@@ -194,12 +194,12 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugConnec
pDrmConnect->version = connect.version;
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);
}
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_size = euControl.bitmaskSize;
@@ -211,12 +211,12 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugEuCont
pDrmEuControl->seqno = euControl.seqno;
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);
}
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->extensions = vmOpen.extensions;
@@ -225,19 +225,19 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen
pDrmVmOpen->vm_handle = vmOpen.vmHandle;
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);
}
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->flags = ackEvent.flags;
pDrmAckEvent->seqno = ackEvent.seqno;
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);
}

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; };
uint32_t getParamValue(EuDebugParam param) const override;
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;
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_EXEC_QUEUE), euDebugInterface.getParamValue(EuDebugParam::eventTypeExecQueue));
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>(DRM_XE_EUDEBUG_EVENT_OPEN), euDebugInterface.getParamValue(EuDebugParam::eventTypeOpen));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeMetadata));
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_READ), euDebugInterface.getParamValue(EuDebugParam::eventTypeRead));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM), euDebugInterface.getParamValue(EuDebugParam::eventTypeVm));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBind));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOp));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOpMetadata));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::eventTypeVmBindOp));
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_FLAG_UFENCE), euDebugInterface.getParamValue(EuDebugParam::eventVmBindFlagUfence));
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_EU_CONTROL), euDebugInterface.getParamValue(EuDebugParam::ioctlEuControl));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_EVENT), euDebugInterface.getParamValue(EuDebugParam::ioctlReadEvent));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_METADATA), euDebugInterface.getParamValue(EuDebugParam::ioctlReadMetadata));
EXPECT_EQ(static_cast<uint32_t>(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_IOCTL_XE_DEBUG_METADATA_CREATE), euDebugInterface.getParamValue(EuDebugParam::metadataCreate));
EXPECT_EQ(static_cast<uint32_t>(DRM_IOCTL_XE_DEBUG_METADATA_DESTROY), euDebugInterface.getParamValue(EuDebugParam::metadataDestroy));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_DEBUG_METADATA_ELF_BINARY), euDebugInterface.getParamValue(EuDebugParam::metadataElfBinary));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataModuleArea));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_DEBUG_METADATA_PROGRAM_MODULE), euDebugInterface.getParamValue(EuDebugParam::metadataProgramModule));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSbaArea));
EXPECT_EQ(static_cast<uint32_t>(WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea));
EXPECT_EQ(static_cast<uint32_t>(XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG), euDebugInterface.getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataCreate));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataDestroy));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataElfBinary));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataModuleArea));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataProgramModule));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataSbaArea));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::metadataSipArea));
EXPECT_EQ(static_cast<uint32_t>(0), euDebugInterface.getParamValue(EuDebugParam::vmBindOpExtensionsAttachDebug));
}
TEST(EuDebugInterfaceUpstreamTest, whenGettingInterfaceTypeThenUpstreamIsReturned) {
@@ -62,7 +62,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInter
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;
@@ -73,7 +72,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInter
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);
@@ -86,25 +84,13 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmEuAttentionWhenConvertingToInter
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);
}
@@ -112,7 +98,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfa
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;
@@ -122,7 +107,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfa
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);
@@ -134,68 +118,20 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmExecQueueWhenConvertingToInterfa
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{};
@@ -210,7 +146,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmPageFaultWhenConvertingToInterfa
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;
@@ -222,7 +157,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmPageFaultWhenConvertingToInterfa
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);
@@ -270,14 +204,12 @@ TEST(EuDebugInterfaceUpstreamTest, givenValidDrmConnectwhenConvertingToInterface
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);
}
@@ -330,7 +262,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpen
EuDebugVmOpen vmOpen = {};
vmOpen.extensions = 1;
vmOpen.clientHandle = 2;
vmOpen.vmHandle = 3;
vmOpen.flags = 4;
vmOpen.timeoutNs = 5;
@@ -339,7 +270,6 @@ TEST(EuDebugInterfaceUpstreamTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpen
auto drmVmOpen = static_cast<drm_xe_eudebug_vm_open *>(wrappedDrmVmOpen.get());
EXPECT_EQ(1u, drmVmOpen->extensions);
EXPECT_EQ(2u, drmVmOpen->client_handle);
EXPECT_EQ(3u, drmVmOpen->vm_handle);
EXPECT_EQ(4u, drmVmOpen->flags);
EXPECT_EQ(5u, drmVmOpen->timeout_ns);