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

Revert "refactor: Update eudebug header"

Browse Source 
This reverts commit c410b54866.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2025-11-07 10:22:37 +01:00
committed by Compute-Runtime-Automation
parent 7b1c8e10ba
commit 156e7fd9f0
15 changed files with 5105 additions and 5454 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,15 +72,6 @@ DebugSession *DebugSessionLinuxXe::createLinuxSession(const zet_debug_config_t &
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() {
auto eventMemory = getInternalEvent();
if (eventMemory == nullptr) {

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

@@ -26,8 +26,6 @@ struct DebugSessionLinuxXe : DebugSessionLinux {
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);
ze_result_t initialize() override;
struct IoctlHandlerXe : DebugSessionLinux::IoctlHandler {
IoctlHandlerXe(const NEO::EuDebugInterface &euDebugInterface) : euDebugInterface(euDebugInterface){};
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,7 +181,6 @@ struct MockDebugSessionLinuxXe : public L0::DebugSessionLinuxXe {
using L0::DebugSessionLinuxXe::clientHandleToConnection;
using L0::DebugSessionLinuxXe::debugArea;
using L0::DebugSessionLinuxXe::euControlInterruptSeqno;
using L0::DebugSessionLinuxXe::euDebugInterface;
using L0::DebugSessionLinuxXe::eventTypeIsAttention;
using L0::DebugSessionLinuxXe::getEuControlCmdUnlock;
using L0::DebugSessionLinuxXe::getThreadStateMutexForTileSession;

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

@@ -364,23 +364,6 @@ TEST_F(DebugApiLinuxTestXe, GivenDebugSessionWhenPollReturnsZeroThenNotReadyIsRe
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) {
zet_debug_config_t config = {};
config.pid = 0x1234;

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

@@ -22,7 +22,6 @@ 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 0;
return DRM_XE_EUDEBUG_EVENT_METADATA;
case EuDebugParam::eventTypeOpen:
return 0;
return DRM_XE_EUDEBUG_EVENT_OPEN;
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 0;
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP;
case EuDebugParam::eventTypeVmBindOpMetadata:
return 0;
return DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA;
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 0;
return DRM_XE_EUDEBUG_IOCTL_READ_METADATA;
case EuDebugParam::ioctlVmOpen:
return DRM_XE_EUDEBUG_IOCTL_VM_OPEN;
case EuDebugParam::metadataCreate:
return 0;
return DRM_IOCTL_XE_DEBUG_METADATA_CREATE;
case EuDebugParam::metadataDestroy:
return 0;
return DRM_IOCTL_XE_DEBUG_METADATA_DESTROY;
case EuDebugParam::metadataElfBinary:
return 0;
return DRM_XE_DEBUG_METADATA_ELF_BINARY;
case EuDebugParam::metadataModuleArea:
return 0;
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA;
case EuDebugParam::metadataProgramModule:
return 0;
return DRM_XE_DEBUG_METADATA_PROGRAM_MODULE;
case EuDebugParam::metadataSbaArea:
return 0;
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA;
case EuDebugParam::metadataSipArea:
return 0;
return WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA;
case EuDebugParam::vmBindOpExtensionsAttachDebug:
return 0;
return XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG;
}
return 0;
}
@@ -97,10 +97,6 @@ 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)));
@@ -116,7 +112,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 = defaultClientHandle;
pEuAttentionEvent->clientHandle = event->client_handle;
auto deleter = [](EuDebugEventEuAttention *ptr) {
free(ptr);
@@ -126,8 +122,18 @@ std::unique_ptr<EuDebugEventEuAttention, void (*)(EuDebugEventEuAttention *)> Eu
}
EuDebugEventClient EuDebugInterfaceUpstream::toEuDebugEventClient(const void *drmType) {
UNRECOVERABLE_IF(true);
return {};
const drm_xe_eudebug_event_client *event = static_cast<const drm_xe_eudebug_event_client *>(drmType);
EuDebugEventClient euClientEvent = {};
euClientEvent.base.len = event->base.len;
euClientEvent.base.type = event->base.type;
euClientEvent.base.flags = event->base.flags;
euClientEvent.base.seqno = event->base.seqno;
euClientEvent.base.reserved = event->base.reserved;
euClientEvent.clientHandle = event->client_handle;
return euClientEvent;
}
EuDebugEventVm EuDebugInterfaceUpstream::toEuDebugEventVm(const void *drmType) {
@@ -139,8 +145,9 @@ 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;
}
@@ -159,7 +166,7 @@ std::unique_ptr<EuDebugEventExecQueue, void (*)(EuDebugEventExecQueue *)> EuDebu
pExecQueueEvent->engineClass = event->engine_class;
pExecQueueEvent->width = event->width;
pExecQueueEvent->vmHandle = event->vm_handle;
pExecQueueEvent->clientHandle = defaultClientHandle;
pExecQueueEvent->clientHandle = event->client_handle;
memcpy(pExecQueueEvent->lrcHandle, event->lrc_handle, event->width * sizeof(uint64_t));
auto deleter = [](EuDebugEventExecQueue *ptr) {
@@ -176,9 +183,21 @@ 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 = {};
UNRECOVERABLE_IF(true);
return {};
metadataEvent.base.len = event->base.len;
metadataEvent.base.type = event->base.type;
metadataEvent.base.flags = event->base.flags;
metadataEvent.base.seqno = event->base.seqno;
metadataEvent.base.reserved = event->base.reserved;
metadataEvent.clientHandle = event->client_handle;
metadataEvent.len = event->len;
metadataEvent.metadataHandle = event->metadata_handle;
metadataEvent.type = event->type;
return metadataEvent;
}
EuDebugEventVmBind EuDebugInterfaceUpstream::toEuDebugEventVmBind(const void *drmType) {
@@ -190,24 +209,48 @@ 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 = {};
UNRECOVERABLE_IF(true);
return {};
vmBindOpEvent.base.len = event->base.len;
vmBindOpEvent.base.type = event->base.type;
vmBindOpEvent.base.flags = event->base.flags;
vmBindOpEvent.base.seqno = event->base.seqno;
vmBindOpEvent.base.reserved = event->base.reserved;
vmBindOpEvent.vmBindRefSeqno = event->vm_bind_ref_seqno;
vmBindOpEvent.numExtensions = event->num_extensions;
vmBindOpEvent.addr = event->addr;
vmBindOpEvent.range = event->range;
return vmBindOpEvent;
}
EuDebugEventVmBindOpMetadata EuDebugInterfaceUpstream::toEuDebugEventVmBindOpMetadata(const void *drmType) {
const drm_xe_eudebug_event_vm_bind_op_metadata *event = static_cast<const drm_xe_eudebug_event_vm_bind_op_metadata *>(drmType);
EuDebugEventVmBindOpMetadata vmBindOpMetadataEvent = {};
UNRECOVERABLE_IF(true);
return {};
vmBindOpMetadataEvent.base.len = event->base.len;
vmBindOpMetadataEvent.base.type = event->base.type;
vmBindOpMetadataEvent.base.flags = event->base.flags;
vmBindOpMetadataEvent.base.seqno = event->base.seqno;
vmBindOpMetadataEvent.base.reserved = event->base.reserved;
vmBindOpMetadataEvent.vmBindOpRefSeqno = event->vm_bind_op_ref_seqno;
vmBindOpMetadataEvent.metadataHandle = event->metadata_handle;
vmBindOpMetadataEvent.metadataCookie = event->metadata_cookie;
return vmBindOpMetadataEvent;
}
EuDebugEventVmBindUfence EuDebugInterfaceUpstream::toEuDebugEventVmBindUfence(const void *drmType) {
@@ -237,11 +280,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);
@@ -256,12 +299,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;
}
@@ -272,6 +315,7 @@ EuDebugConnect EuDebugInterfaceUpstream::toEuDebugConnect(const void *drmType) {
connectEvent.extensions = event->extensions;
connectEvent.flags = event->flags;
connectEvent.pid = event->pid;
connectEvent.version = event->version;
return connectEvent;
@@ -281,6 +325,7 @@ 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;
@@ -295,6 +340,7 @@ 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;
@@ -310,6 +356,7 @@ 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;
@@ -340,9 +387,35 @@ 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,11 +12,9 @@ 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 prelim_drm_xe_eudebug_event_eu_attention *event = static_cast<const prelim_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)));
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 prelim_drm_xe_eudebug_event_exec_queue *event = static_cast<const prelim_drm_xe_eudebug_event_exec_queue *>(drmType);
const drm_xe_eudebug_event_exec_queue *event = static_cast<const drm_xe_eudebug_event_exec_queue *>(drmType);
EuDebugEventExecQueue *pExecQueueEvent = static_cast<EuDebugEventExecQueue *>(malloc(sizeof(EuDebugEventExecQueue) + event->width * sizeof(uint64_t)));
pExecQueueEvent->base.len = event->base.len;
@@ -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 prelim_drm_xe_eudebug_event_pagefault *event = static_cast<const prelim_drm_xe_eudebug_event_pagefault *>(drmType);
const drm_xe_eudebug_event_pagefault *event = static_cast<const drm_xe_eudebug_event_pagefault *>(drmType);
EuDebugEventPageFault *pPageFaultEvent = static_cast<EuDebugEventPageFault *>(malloc(sizeof(EuDebugEventPageFault) + event->bitmask_size * sizeof(uint8_t)));
pPageFaultEvent->base.len = event->base.len;
@@ -186,7 +186,7 @@ EuDebugConnect MockEuDebugInterface::toEuDebugConnect(const void *drmType) {
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugConnect(const EuDebugConnect &connect) {
struct prelim_drm_xe_eudebug_connect *pDrmConnect = new prelim_drm_xe_eudebug_connect();
struct drm_xe_eudebug_connect *pDrmConnect = new 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<prelim_drm_xe_eudebug_connect *>(ptr);
delete static_cast<drm_xe_eudebug_connect *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmConnect, deleter);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugEuControl(const EuDebugEuControl &euControl) {
struct prelim_drm_xe_eudebug_eu_control *pDrmEuControl = new prelim_drm_xe_eudebug_eu_control();
struct drm_xe_eudebug_eu_control *pDrmEuControl = new 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<prelim_drm_xe_eudebug_eu_control *>(ptr);
delete static_cast<drm_xe_eudebug_eu_control *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmEuControl, deleter);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen(const EuDebugVmOpen &vmOpen) {
struct prelim_drm_xe_eudebug_vm_open *pDrmVmOpen = new prelim_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;
@@ -225,19 +225,19 @@ std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugVmOpen
pDrmVmOpen->vm_handle = vmOpen.vmHandle;
auto deleter = [](void *ptr) {
delete static_cast<prelim_drm_xe_eudebug_vm_open *>(ptr);
delete static_cast<drm_xe_eudebug_vm_open *>(ptr);
};
return std::unique_ptr<void, void (*)(void *)>(pDrmVmOpen, deleter);
}
std::unique_ptr<void, void (*)(void *)> MockEuDebugInterface::toDrmEuDebugAckEvent(const EuDebugAckEvent &ackEvent) {
struct prelim_drm_xe_eudebug_ack_event *pDrmAckEvent = new prelim_drm_xe_eudebug_ack_event();
struct drm_xe_eudebug_ack_event *pDrmAckEvent = new drm_xe_eudebug_ack_event();
pDrmAckEvent->type = ackEvent.type;
pDrmAckEvent->flags = ackEvent.flags;
pDrmAckEvent->seqno = ackEvent.seqno;
auto deleter = [](void *ptr) {
delete static_cast<prelim_drm_xe_eudebug_ack_event *>(ptr);
delete static_cast<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,9 +18,6 @@ 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>(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_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>(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>(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_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>(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>(0), euDebugInterface.getParamValue(EuDebugParam::ioctlReadMetadata));
EXPECT_EQ(static_cast<uint32_t>(DRM_XE_EUDEBUG_IOCTL_READ_METADATA), 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>(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));
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));
}
TEST(EuDebugInterfaceUpstreamTest, whenGettingInterfaceTypeThenUpstreamIsReturned) {
@@ -62,6 +62,7 @@ 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;
@@ -72,6 +73,7 @@ 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);
@@ -84,13 +86,25 @@ 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);
}
@@ -98,6 +112,7 @@ 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;
@@ -107,6 +122,7 @@ 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);
@@ -118,20 +134,68 @@ 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{};
@@ -146,6 +210,7 @@ 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;
@@ -157,6 +222,7 @@ 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);
@@ -204,12 +270,14 @@ 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);
}
@@ -262,6 +330,7 @@ TEST(EuDebugInterfaceUpstreamTest, givenInterfaceVmOpenWhenConvertingToDrmVmOpen
EuDebugVmOpen vmOpen = {};
vmOpen.extensions = 1;
vmOpen.clientHandle = 2;
vmOpen.vmHandle = 3;
vmOpen.flags = 4;
vmOpen.timeoutNs = 5;
@@ -270,6 +339,7 @@ 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);

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

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

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

File diff suppressed because it is too large Load Diff

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