fix: segfaults in zer DDI intercepts

scripts/templates/ldrddi_driver_ddi.cpp.mako

@@ -109,7 +109,7 @@ namespace loader_driver_ddi
             return ${failure_return};
             %endif
         }
-        auto dditable = reinterpret_cast<ze_handle_t*>( loader::context->defaultZerDriverHandle )->pRuntime;
+        auto dditable = reinterpret_cast<ze_handle_t*>( *loader::context->defaultZerDriverHandle )->pRuntime;
         if (dditable->isValidFlag == 0) {
             %if ret_type == 'ze_result_t':
             return ${X}_RESULT_ERROR_UNINITIALIZED;

source/drivers/null/ze_null.cpp

@@ -487,17 +487,32 @@ namespace driver
         {
             if( nullptr != pExtensionProperties )
             {
-                ze_driver_extension_properties_t driverExtensionProperties = {};
+                ze_driver_extension_properties_t tracingExtension = {};
 #if defined(_WIN32)
-                strcpy_s( driverExtensionProperties.name, ZET_API_TRACING_EXP_NAME );
+                strcpy_s( tracingExtension.name, ZET_API_TRACING_EXP_NAME );
 #else
-                strcpy( driverExtensionProperties.name, ZET_API_TRACING_EXP_NAME );
+                strcpy( tracingExtension.name, ZET_API_TRACING_EXP_NAME );
+#endif
+                tracingExtension.version = ZET_API_TRACING_EXP_VERSION_1_0;
+                pExtensionProperties[0] = tracingExtension;
+
+                ze_driver_extension_properties_t ddiHandlesExtension = {};
+#if defined(_WIN32)
+                strcpy_s( ddiHandlesExtension.name, ZE_DRIVER_DDI_HANDLES_EXT_NAME );
+#else
+                strcpy( ddiHandlesExtension.name, ZE_DRIVER_DDI_HANDLES_EXT_NAME );
 #endif
-                driverExtensionProperties.version = ZET_API_TRACING_EXP_VERSION_1_0;
 
-                *pExtensionProperties = driverExtensionProperties;
+                auto ddi_version_env = getenv("ZEL_TEST_DDI_HANDLES_EXT_VERSION");
+                if (ddi_version_env && strcmp(ddi_version_env, "1_0") == 0) {
+                    ddiHandlesExtension.version = ZE_DRIVER_DDI_HANDLES_EXT_VERSION_1_0;
+                } else {
+                    ddiHandlesExtension.version = ZE_DRIVER_DDI_HANDLES_EXT_VERSION_1_1;
+                }
+
+                pExtensionProperties[1] = ddiHandlesExtension;
             }
-            *pCount = 1;
+            *pCount = 2;
 
             return ZE_RESULT_SUCCESS;
         };
@@ -629,6 +644,16 @@ namespace driver
         pSysman.Driver = &zesDdiTable.Driver;
         pSysman.isValidFlag = 1;
         pSysman.version = ZE_API_VERSION_CURRENT;
+
+        static zer_global_dditable_t runtimeDdiTable;
+        runtimeDdiTable.pfnGetLastErrorDescription = driver::zerGetLastErrorDescription;
+        runtimeDdiTable.pfnTranslateDeviceHandleToIdentifier = driver::zerTranslateDeviceHandleToIdentifier;
+        runtimeDdiTable.pfnTranslateIdentifierToDeviceHandle = driver::zerTranslateIdentifierToDeviceHandle;
+        runtimeDdiTable.pfnGetDefaultContext = driver::zerGetDefaultContext;
+
+        pRuntime.Global = &runtimeDdiTable;
+        pRuntime.isValidFlag = 1;
+        pRuntime.version = ZE_API_VERSION_CURRENT;
     }
 
     char *context_t::setenv_var_with_driver_id(const std::string &key, uint32_t driverId)

source/drivers/null/ze_null.h

@@ -64,6 +64,11 @@ namespace driver
 	char *setenv_var_with_driver_id(const std::string &key, uint32_t driverId);
     };
 
+    ze_result_t ZE_APICALL zerGetLastErrorDescription(const char **ppString);
+    uint32_t ZE_APICALL zerTranslateDeviceHandleToIdentifier(ze_device_handle_t hDevice);
+    ze_device_handle_t ZE_APICALL zerTranslateIdentifierToDeviceHandle(uint32_t identifier);
+    ze_context_handle_t ZE_APICALL zerGetDefaultContext(void);
+
     extern context_t context;
 } // namespace driver
 

source/loader/zer_ldrddi_driver_ddi.cpp

@@ -31,7 +31,7 @@ namespace loader_driver_ddi
         if (loader::context->defaultZerDriverHandle == nullptr) {
             return ZE_RESULT_ERROR_UNINITIALIZED;
         }
-        auto dditable = reinterpret_cast<ze_handle_t*>( loader::context->defaultZerDriverHandle )->pRuntime;
+        auto dditable = reinterpret_cast<ze_handle_t*>( *loader::context->defaultZerDriverHandle )->pRuntime;
         if (dditable->isValidFlag == 0) {
             return ZE_RESULT_ERROR_UNINITIALIZED;
         }
@@ -66,7 +66,7 @@ namespace loader_driver_ddi
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return UINT32_MAX;
         }
-        auto dditable = reinterpret_cast<ze_handle_t*>( loader::context->defaultZerDriverHandle )->pRuntime;
+        auto dditable = reinterpret_cast<ze_handle_t*>( *loader::context->defaultZerDriverHandle )->pRuntime;
         if (dditable->isValidFlag == 0) {
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return UINT32_MAX;
@@ -105,7 +105,7 @@ namespace loader_driver_ddi
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return nullptr;
         }
-        auto dditable = reinterpret_cast<ze_handle_t*>( loader::context->defaultZerDriverHandle )->pRuntime;
+        auto dditable = reinterpret_cast<ze_handle_t*>( *loader::context->defaultZerDriverHandle )->pRuntime;
         if (dditable->isValidFlag == 0) {
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return nullptr;
@@ -144,7 +144,7 @@ namespace loader_driver_ddi
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return nullptr;
         }
-        auto dditable = reinterpret_cast<ze_handle_t*>( loader::context->defaultZerDriverHandle )->pRuntime;
+        auto dditable = reinterpret_cast<ze_handle_t*>( *loader::context->defaultZerDriverHandle )->pRuntime;
         if (dditable->isValidFlag == 0) {
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return nullptr;

test/CMakeLists.txt

@@ -596,7 +596,25 @@ set_property(TEST driver_ordering_trim_function PROPERTY ENVIRONMENT "ZE_ENABLE_
 add_test(NAME driver_ordering_parse_driver_order COMMAND tests --gtest_filter=DriverOrderingHelperFunctionsTest.ParseDriverOrder_*)
 set_property(TEST driver_ordering_parse_driver_order PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
 
+add_test(NAME tests_sigle_driver_runtime_api_ddi_ext_v1_1 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
+set_property(TEST tests_sigle_driver_runtime_api_ddi_ext_v1_1 PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
 
+add_test(NAME tests_multi_driver_runtime_api_ddi_ext_v1_1 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
+if (MSVC)
+  set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_1 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
+else()
+  set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_1 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
+endif()
+
+# add_test(NAME tests_sigle_driver_runtime_api_ddi_ext_v1_0 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWithVersion1_0WhenCallingRuntimeApisThenExpectErrorUninitialized)
+# set_property(TEST tests_sigle_driver_runtime_api_ddi_ext_v1_0 PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
+
+# add_test(NAME tests_multi_driver_runtime_api_ddi_ext_v1_0 COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWithVersion1_0WhenCallingRuntimeApisThenExpectErrorUninitialized)
+# if (MSVC)
+#   set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_0 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
+# else()
+#   set_property(TEST tests_multi_driver_runtime_api_ddi_ext_v1_0 APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DRIVER_DDI_PATH=1;ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
+# endif()
 
 # These tests are currently not supported on Windows. The reason is that the std::cerr is not being redirected to a pipe in Windows to be then checked against the expected output.
 if(NOT MSVC)

test/loader_api.cpp

@@ -11,6 +11,7 @@
 #include "loader/ze_loader.h"
 #include "ze_api.h"
 #include "zes_api.h"
+#include "zer_api.h"
 
 #include <fstream>
 
@@ -2287,4 +2288,88 @@ TEST_F(DriverOrderingTest,
     }
 }
 
+  TEST(
+      RuntimeApiLoaderDriverInteraction,
+      GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisThenExpectNullDriverIsReachedSuccessfully)
+  {
+    uint32_t pInitDriversCount = 0;
+    ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
+    desc.flags = UINT32_MAX;
+    desc.pNext = nullptr;
+    putenv_safe(const_cast<char *>("ZE_ENABLE_LOADER_INTERCEPT=1"));
+    putenv_safe(const_cast<char *>("ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT=0"));
+    std::vector<ze_driver_handle_t> drivers;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, nullptr, &desc));
+    drivers.resize(pInitDriversCount);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, drivers.data(), &desc));
+    EXPECT_GT(pInitDriversCount, 0);
+
+    const char *errorString = nullptr;
+    uint32_t deviceId = 0;
+
+    ze_result_t result = zerGetLastErrorDescription(&errorString);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_TRUE(compare_env("zerGetLastErrorDescription", "1"));
+
+    deviceId = zerTranslateDeviceHandleToIdentifier(nullptr);
+    EXPECT_TRUE(compare_env("zerTranslateDeviceHandleToIdentifier", "1"));
+
+    ze_device_handle_t translatedDevice = zerTranslateIdentifierToDeviceHandle(deviceId);
+    EXPECT_TRUE(compare_env("zerTranslateIdentifierToDeviceHandle", "1"));
+    (void)translatedDevice;
+
+    ze_context_handle_t defaultContext = zerGetDefaultContext();
+    EXPECT_TRUE(compare_env("zerGetDefaultContext", "1"));
+    (void)defaultContext;
+  }
+
+  /*
+  TEST(
+      RuntimeApiLoaderDriverInteraction,
+      GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWithVersion1_0WhenCallingRuntimeApisThenExpectErrorUninitialized)
+  {
+    uint32_t pInitDriversCount = 0;
+    ze_init_driver_type_desc_t desc = {ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC};
+    desc.flags = UINT32_MAX;
+    desc.pNext = nullptr;
+    putenv_safe(const_cast<char *>("ZE_ENABLE_LOADER_INTERCEPT=1"));
+    putenv_safe(const_cast<char *>("ZEL_TEST_NULL_DRIVER_DISABLE_DDI_EXT=0"));
+    putenv_safe(const_cast<char *>("ZEL_TEST_DDI_HANDLES_EXT_VERSION=1_0"));
+    std::vector<ze_driver_handle_t> drivers;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, nullptr, &desc));
+    drivers.resize(pInitDriversCount);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeInitDrivers(&pInitDriversCount, drivers.data(), &desc));
+    EXPECT_GT(pInitDriversCount, 0);
+
+    uint32_t deviceId = 0;
+
+    const char *errorDesc = nullptr;
+    ze_result_t errorDescResult{};
+
+    deviceId = zerTranslateDeviceHandleToIdentifier(nullptr);
+    EXPECT_EQ(UINT32_MAX, deviceId);
+
+    errorDescResult = zerGetLastErrorDescription(&errorDesc);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, errorDescResult);
+    EXPECT_NE(errorDesc, nullptr);
+    EXPECT_EQ(0, strcmp(errorDesc, "ERROR UNINITIALIZED"));
+
+    ze_device_handle_t translatedDevice = zerTranslateIdentifierToDeviceHandle(deviceId);
+    EXPECT_EQ(nullptr, translatedDevice);
+
+    errorDescResult = zerGetLastErrorDescription(&errorDesc);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, errorDescResult);
+    EXPECT_NE(errorDesc, nullptr);
+    EXPECT_EQ(0, strcmp(errorDesc, "ERROR UNINITIALIZED"));
+
+    ze_context_handle_t defaultContext = zerGetDefaultContext();
+    EXPECT_EQ(nullptr, defaultContext);
+
+    errorDescResult = zerGetLastErrorDescription(&errorDesc);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, errorDescResult);
+    EXPECT_NE(errorDesc, nullptr);
+    EXPECT_EQ(0, strcmp(errorDesc, "ERROR UNINITIALIZED"));
+  }
+  */
+
 } // namespace