Reintroduce prelim DRM debug support

It was verified that the issue existed before the failing commit. Signed-off-by: Daniel Chabrowski daniel.chabrowski@intel.com Related-To: NEO-6591
2026-01-05 09:09:04 +08:00 · 2022-02-28 13:56:41 +00:00
parent 8aa2e76173
commit ca7d47598a
16 changed files with 665 additions and 31 deletions
--- a/shared/source/os_interface/linux/CMakeLists.txt
+++ b/shared/source/os_interface/linux/CMakeLists.txt
@@ -24,7 +24,8 @@ set(NEO_CORE_OS_INTERFACE_LINUX
    ${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream.h
    ${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream.inl
    ${CMAKE_CURRENT_SOURCE_DIR}/drm_command_stream_bdw_and_later.inl
-    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}drm_debug.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/drm_debug.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/drm_debug.h
    ${CMAKE_CURRENT_SOURCE_DIR}/drm_gem_close_worker.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/drm_gem_close_worker.h
    ${CMAKE_CURRENT_SOURCE_DIR}/drm_memory_manager.cpp
--- a/shared/source/os_interface/linux/drm_debug.cpp
+++ b/shared/source/os_interface/linux/drm_debug.cpp
@@ -5,23 +5,68 @@
 *
 */

-#include "drm_neo.h"
+#include "shared/source/os_interface/linux/drm_debug.h"
+
+#include "shared/source/helpers/string.h"
+#include "shared/source/os_interface/linux/drm_neo.h"
+
+#include <string>
+#include <utility>

 namespace NEO {

 bool Drm::registerResourceClasses() {
-    return false;
+    for (auto classNameUUID : classNamesToUuid) {
+        auto className = classNameUUID.first;
+        auto uuid = classNameUUID.second;
+
+        const auto result = ioctlHelper->registerStringClassUuid(this, uuid, (uintptr_t)className, strnlen_s(className, 100));
+        if (result.retVal != 0) {
+            return false;
+        }
+
+        classHandles.push_back(result.handle);
+    }
+    return true;
 }

 uint32_t Drm::registerResource(ResourceClass classType, const void *data, size_t size) {
-    return 0;
+    if (classHandles.size() < static_cast<uint32_t>(classType)) {
+        return 0;
+    }
+
+    std::string uuid;
+    if (classType == NEO::Drm::ResourceClass::Elf) {
+        uuid = generateElfUUID(data);
+    } else {
+        uuid = generateUUID();
+    }
+
+    const auto uuidClass = classHandles[static_cast<uint32_t>(classType)];
+    const auto ptr = size > 0 ? (uintptr_t)data : 0;
+    const auto result = ioctlHelper->registerUuid(this, uuid, uuidClass, ptr, size);
+
+    PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_UUID_REGISTER: classType = %d, uuid = %s, data = %p, handle = %lu, ret = %d\n", (int)classType, std::string(uuid, 36).c_str(), ptr, result.handle, result.retVal);
+    DEBUG_BREAK_IF(result.retVal != 0);
+
+    return result.handle;
 }

 uint32_t Drm::registerIsaCookie(uint32_t isaHandle) {
-    return 0;
+    auto uuid = generateUUID();
+
+    const auto result = ioctlHelper->registerUuid(this, uuid, isaHandle, 0, 0);
+
+    PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_UUID_REGISTER: isa handle = %lu, uuid = %s, data = %p, handle = %lu, ret = %d\n", isaHandle, std::string(uuid, 36).c_str(), 0, result.handle, result.retVal);
+    DEBUG_BREAK_IF(result.retVal != 0);
+
+    return result.handle;
 }

 void Drm::unregisterResource(uint32_t handle) {
+    PRINT_DEBUGGER_INFO_LOG("PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER: handle = %lu\n", handle);
+    [[maybe_unused]] const auto ret = ioctlHelper->unregisterUuid(this, handle);
+    DEBUG_BREAK_IF(ret != 0);
 }

 std::string Drm::generateUUID() {
@@ -40,12 +85,37 @@ std::string Drm::generateUUID() {
 }

 std::string Drm::generateElfUUID(const void *data) {
-    return generateUUID();
+    std::string elf_class_uuid = classNamesToUuid[static_cast<uint32_t>(Drm::ResourceClass::Elf)].second;
+    std::string UUID1st = elf_class_uuid.substr(0, 18);
+
+    const char uuidString[] = "%s-%04" SCNx64 "-%012" SCNx64;
+    char buffer[36 + 1] = "00000000-0000-0000-0000-000000000000";
+
+    uint64_t parts[2] = {0, 0};
+    parts[0] = reinterpret_cast<uintptr_t>(data) & 0xFFFFFFFFFFFF;
+    parts[1] = (reinterpret_cast<uintptr_t>(data) & 0xFFFF000000000000) >> 48;
+    snprintf(buffer, sizeof(buffer), uuidString, UUID1st.c_str(), parts[1], parts[0]);
+
+    return std::string(buffer, 36);
 }

-void Drm::checkContextDebugSupport() {}
-void Drm::setContextDebugFlag(uint32_t drmContextId) {}
-uint32_t Drm::notifyFirstCommandQueueCreated() { return 0; }
-void Drm::notifyLastCommandQueueDestroyed(uint32_t handle) {}
+void Drm::checkContextDebugSupport() {
+    contextDebugSupported = ioctlHelper->isContextDebugSupported(this);
+}
+
+void Drm::setContextDebugFlag(uint32_t drmContextId) {
+    [[maybe_unused]] const auto retVal = ioctlHelper->setContextDebugFlag(this, drmContextId);
+    DEBUG_BREAK_IF(retVal != 0 && contextDebugSupported);
+}
+
+uint32_t Drm::notifyFirstCommandQueueCreated() {
+    const auto result = ioctlHelper->registerStringClassUuid(this, uuidL0CommandQueueHash, (uintptr_t)uuidL0CommandQueueName, strnlen_s(uuidL0CommandQueueName, 100));
+    DEBUG_BREAK_IF(result.retVal);
+    return result.handle;
+}
+
+void Drm::notifyLastCommandQueueDestroyed(uint32_t handle) {
+    unregisterResource(handle);
+}

 } // namespace NEO
--- a/shared/source/os_interface/linux/drm_debug.h
+++ b/shared/source/os_interface/linux/drm_debug.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/os_interface/linux/drm_neo.h"
+
+#include <string>
+#include <utility>
+
+namespace NEO {
+
+/*
+
+UUIDs: Deterministic generation
+
+$ python -q # Version 3.x
+>>> import uuid
+>>>
+>>> I915_UUID_NAMESPACE = uuid.UUID(bytes = b'i915' * 4);
+>>> I915_UUID_NAMESPACE
+UUID('69393135-6939-3135-6939-313569393135')
+>>>
+>>>
+>>> I915_UUID = lambda x: uuid.uuid5(I915_UUID_NAMESPACE, x)
+>>> I915_UUID('I915_UUID_CLASS_CUSTOM')
+UUID('74644f12-6a2c-59e6-ac92-ea7f2ef530eb')
+>>>
+>>>
+>>> L0_UUID_NAMESPACE = uuid.UUID(bytes = b'L0' * 8);
+>>> L0_UUID_NAMESPACE
+UUID('4c304c30-4c30-4c30-4c30-4c304c304c30')
+>>>
+>>>
+>>> L0_UUID = lambda x: uuid.uuid5(L0_UUID_NAMESPACE, x)
+>>> L0_UUID('L0_ZEBIN_MODULE')
+UUID('88d347c1-c79b-530a-b68f-e0db7d575e04')
+>>>
+>>>
+>>> L0_UUID('L0_COMMAND_QUEUE')
+UUID('285208b2-c5e0-5fcb-90bb-7576ed7a9697')
+
+*/
+
+using ClassNamesArray = std::array<std::pair<const char *, const std::string>, size_t(Drm::ResourceClass::MaxSize)>;
+const ClassNamesArray classNamesToUuid = {std::make_pair("I915_UUID_CLASS_ELF_BINARY", "31203221-8069-5a0a-9d43-94a4d3395ee1"),
+                                          std::make_pair("I915_UUID_CLASS_ISA_BYTECODE", "53baed0a-12c3-5d19-aa69-ab9c51aa1039"),
+                                          std::make_pair("I915_UUID_L0_MODULE_AREA", "a411e82e-16c9-58b7-bfb5-b209b8601d5f"),
+                                          std::make_pair("I915_UUID_L0_SIP_AREA", "21fd6baf-f918-53cc-ba74-f09aaaea2dc0"),
+                                          std::make_pair("I915_UUID_L0_SBA_AREA", "ec45189d-97d3-58e2-80d1-ab52c72fdcc1"),
+                                          std::make_pair("L0_ZEBIN_MODULE", "88d347c1-c79b-530a-b68f-e0db7d575e04")};
+
+constexpr auto uuidL0CommandQueueName = "L0_COMMAND_QUEUE";
+constexpr auto uuidL0CommandQueueHash = "285208b2-c5e0-5fcb-90bb-7576ed7a9697"; // L0_UUID('L0_COMMAND_QUEUE')
+
+struct DrmUuid {
+    static bool getClassUuidIndex(std::string uuid, uint32_t &index) {
+        for (uint32_t i = 0; i < uint32_t(Drm::ResourceClass::MaxSize); i++) {
+            if (uuid == classNamesToUuid[i].second) {
+                index = i;
+                return true;
+            }
+        }
+        return false;
+    }
+};
+} // namespace NEO
--- a/shared/source/os_interface/linux/ioctl_helper.h
+++ b/shared/source/os_interface/linux/ioctl_helper.h
@@ -66,6 +66,11 @@ struct VmBindParams {
    uint64_t extensions;
 };

+struct UuidRegisterResult {
+    uint32_t retVal;
+    uint32_t handle;
+};
+
 using MemRegionsVec = StackVec<MemoryClassInstance, 5>;

 class IoctlHelper {
@@ -114,6 +119,11 @@ class IoctlHelper {
    virtual int vmUnbind(Drm *drm, const VmBindParams &vmBindParams) = 0;
    virtual bool getEuStallProperties(std::array<uint64_t, 10u> &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance) = 0;
    virtual uint32_t getEuStallFdParameter() = 0;
+    virtual UuidRegisterResult registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) = 0;
+    virtual UuidRegisterResult registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) = 0;
+    virtual int unregisterUuid(Drm *drm, uint32_t handle) = 0;
+    virtual bool isContextDebugSupported(Drm *drm) = 0;
+    virtual int setContextDebugFlag(Drm *drm, uint32_t drmContextId) = 0;
 };

 class IoctlHelperUpstream : public IoctlHelper {
@@ -159,6 +169,11 @@ class IoctlHelperUpstream : public IoctlHelper {
    int vmUnbind(Drm *drm, const VmBindParams &vmBindParams) override;
    bool getEuStallProperties(std::array<uint64_t, 10u> &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance) override;
    uint32_t getEuStallFdParameter() override;
+    UuidRegisterResult registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) override;
+    UuidRegisterResult registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) override;
+    int unregisterUuid(Drm *drm, uint32_t handle) override;
+    bool isContextDebugSupported(Drm *drm) override;
+    int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
 };

 template <PRODUCT_FAMILY gfxProduct>
@@ -217,6 +232,11 @@ class IoctlHelperPrelim20 : public IoctlHelper {
    int vmUnbind(Drm *drm, const VmBindParams &vmBindParams) override;
    bool getEuStallProperties(std::array<uint64_t, 10u> &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance) override;
    uint32_t getEuStallFdParameter() override;
+    UuidRegisterResult registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) override;
+    UuidRegisterResult registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) override;
+    int unregisterUuid(Drm *drm, uint32_t handle) override;
+    bool isContextDebugSupported(Drm *drm) override;
+    int setContextDebugFlag(Drm *drm, uint32_t drmContextId) override;
 };

 } // namespace NEO
--- a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp
+++ b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp
@@ -10,6 +10,7 @@
 #include "shared/source/helpers/hw_helper.h"
 #include "shared/source/helpers/hw_info.h"
 #include "shared/source/helpers/ptr_math.h"
+#include "shared/source/helpers/string.h"
 #include "shared/source/os_interface/linux/cache_info.h"
 #include "shared/source/os_interface/linux/ioctl_helper.h"

@@ -319,6 +320,7 @@ int32_t IoctlHelperPrelim20::getComputeEngineClass() {
 std::optional<int> IoctlHelperPrelim20::getHasPageFaultParamId() {
    return PRELIM_I915_PARAM_HAS_PAGE_FAULT;
 };
+
 bool IoctlHelperPrelim20::getEuStallProperties(std::array<uint64_t, 10u> &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance) {
    properties[0] = PRELIM_DRM_I915_EU_STALL_PROP_BUF_SZ;
    properties[1] = dssBufferSize;
@@ -472,4 +474,52 @@ int IoctlHelperPrelim20::vmUnbind(Drm *drm, const VmBindParams &vmBindParams) {
    auto prelimVmBind = translateVmBindParamsToPrelimStruct(vmBindParams);
    return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_GEM_VM_UNBIND, &prelimVmBind);
 }
+
+UuidRegisterResult IoctlHelperPrelim20::registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
+    prelim_drm_i915_uuid_control uuidControl = {};
+    memcpy_s(uuidControl.uuid, sizeof(uuidControl.uuid), uuid.c_str(), uuid.size());
+    uuidControl.uuid_class = uuidClass;
+    uuidControl.ptr = ptr;
+    uuidControl.size = size;
+
+    const auto retVal = IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_UUID_REGISTER, &uuidControl);
+
+    return {
+        retVal,
+        uuidControl.handle,
+    };
+}
+
+UuidRegisterResult IoctlHelperPrelim20::registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) {
+    return registerUuid(drm, uuid, PRELIM_I915_UUID_CLASS_STRING, ptr, size);
+}
+
+int IoctlHelperPrelim20::unregisterUuid(Drm *drm, uint32_t handle) {
+    prelim_drm_i915_uuid_control uuidControl = {};
+    uuidControl.handle = handle;
+
+    return IoctlHelper::ioctl(drm, PRELIM_DRM_IOCTL_I915_UUID_UNREGISTER, &uuidControl);
+}
+
+bool IoctlHelperPrelim20::isContextDebugSupported(Drm *drm) {
+    drm_i915_gem_context_param ctxParam = {};
+    ctxParam.size = 0;
+    ctxParam.param = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS;
+    ctxParam.ctx_id = 0;
+    ctxParam.value = 0;
+
+    const auto retVal = IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM, &ctxParam);
+    return retVal == 0 && ctxParam.value == (PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32);
+}
+
+int IoctlHelperPrelim20::setContextDebugFlag(Drm *drm, uint32_t drmContextId) {
+    drm_i915_gem_context_param ctxParam = {};
+    ctxParam.size = 0;
+    ctxParam.param = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAGS;
+    ctxParam.ctx_id = drmContextId;
+    ctxParam.value = PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP << 32 | PRELIM_I915_CONTEXT_PARAM_DEBUG_FLAG_SIP;
+
+    return IoctlHelper::ioctl(drm, DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM, &ctxParam);
+}
+
 } // namespace NEO
--- a/shared/source/os_interface/linux/ioctl_helper_upstream.cpp
+++ b/shared/source/os_interface/linux/ioctl_helper_upstream.cpp
@@ -120,6 +120,7 @@ uint32_t IoctlHelperUpstream::getComputeSlicesIoctlVal() {
 std::unique_ptr<uint8_t[]> IoctlHelperUpstream::prepareVmBindExt(const StackVec<uint32_t, 2> &bindExtHandles) {
    return {};
 }
+
 uint64_t IoctlHelperUpstream::getFlagsForVmBind(bool bindCapture, bool bindImmediate, bool bindMakeResident) {
    return 0u;
 }
@@ -151,7 +152,7 @@ int32_t IoctlHelperUpstream::getComputeEngineClass() {

 uint16_t IoctlHelperUpstream::getWaitUserFenceSoftFlag() {
    return 0;
-};
+}

 int IoctlHelperUpstream::execBuffer(Drm *drm, drm_i915_gem_execbuffer2 *execBuffer, uint64_t completionGpuAddress, uint32_t counterValue) {
    return ioctl(drm, DRM_IOCTL_I915_GEM_EXECBUFFER2, execBuffer);
@@ -164,6 +165,7 @@ bool IoctlHelperUpstream::completionFenceExtensionSupported(const HardwareInfo &
 std::optional<int> IoctlHelperUpstream::getHasPageFaultParamId() {
    return std::nullopt;
 };
+
 bool IoctlHelperUpstream::getEuStallProperties(std::array<uint64_t, 10u> &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance) {
    return false;
 }
@@ -183,17 +185,21 @@ uint32_t IoctlHelperUpstream::getFlagsForVmCreate(bool disableScratch, bool enab
 uint32_t IoctlHelperUpstream::createContextWithAccessCounters(Drm *drm, drm_i915_gem_context_create_ext &gcc) {
    return EINVAL;
 }
+
 uint32_t IoctlHelperUpstream::createCooperativeContext(Drm *drm, drm_i915_gem_context_create_ext &gcc) {
    return EINVAL;
 }

 std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSetPat() {
    return {};
-};
+}
+
 void IoctlHelperUpstream::fillVmBindExtSetPat(const std::unique_ptr<uint8_t[]> &vmBindExtSetPat, uint64_t patIndex, uint64_t nextExtension) {}
+
 std::unique_ptr<uint8_t[]> IoctlHelperUpstream::createVmBindExtSyncFence() {
    return {};
 }
+
 void IoctlHelperUpstream::fillVmBindExtSyncFence(const std::unique_ptr<uint8_t[]> &vmBindExtSyncFence, uint64_t fenceAddress, uint64_t fenceValue, uint64_t nextExtension) {}

 std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturatePCIECapability() {
@@ -207,7 +213,29 @@ std::optional<uint64_t> IoctlHelperUpstream::getCopyClassSaturateLinkCapability(
 int IoctlHelperUpstream::vmBind(Drm *drm, const VmBindParams &vmBindParams) {
    return 0;
 }
+
 int IoctlHelperUpstream::vmUnbind(Drm *drm, const VmBindParams &vmBindParams) {
    return 0;
 }
+
+UuidRegisterResult IoctlHelperUpstream::registerUuid(Drm *drm, const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) {
+    return {0, 0};
+}
+
+UuidRegisterResult IoctlHelperUpstream::registerStringClassUuid(Drm *drm, const std::string &uuid, uint64_t ptr, uint64_t size) {
+    return {0, 0};
+}
+
+int IoctlHelperUpstream::unregisterUuid(Drm *drm, uint32_t handle) {
+    return 0;
+}
+
+bool IoctlHelperUpstream::isContextDebugSupported(Drm *drm) {
+    return false;
+}
+
+int IoctlHelperUpstream::setContextDebugFlag(Drm *drm, uint32_t drmContextId) {
+    return 0;
+}
+
 } // namespace NEO