fix: segfaults in Validation Layer for Zer API's (#392)

vishnu-khanth · web-flow · commit 919e9daf056f · 2025-10-30T12:26:19.000-07:00
Signed-off-by: Vishnu Khanth &lt;vishnu.khanth.b@intel.com&gt;
diff --git a/scripts/templates/validation/param.cpp.mako b/scripts/templates/validation/param.cpp.mako
@@ -32,9 +32,11 @@ namespace validation_layer
             ZEParameterValidation *zeChecker = new ZEParameterValidation;
             ZESParameterValidation *zesChecker = new ZESParameterValidation;
             ZETParameterValidation *zetChecker = new ZETParameterValidation;
+            ZERParameterValidation *zerChecker = new ZERParameterValidation;
             parameterChecker.zeValidation = zeChecker;
             parameterChecker.zetValidation = zetChecker;
             parameterChecker.zesValidation = zesChecker;
+            parameterChecker.zerValidation = zerChecker;
             validation_layer::context.getInstance().validationHandlers.push_back(&parameterChecker);
         }
     }
@@ -44,6 +46,7 @@ namespace validation_layer
             delete parameterChecker.zeValidation;
             delete parameterChecker.zetValidation;
             delete parameterChecker.zesValidation;
+            delete parameterChecker.zerValidation;
         }
     }
     %endif
diff --git a/source/layers/validation/checkers/basic_leak/zel_basic_leak_checker.cpp b/source/layers/validation/checkers/basic_leak/zel_basic_leak_checker.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -23,9 +23,11 @@ namespace validation_layer
             basic_leakChecker::ZEbasic_leakChecker *zeChecker = new basic_leakChecker::ZEbasic_leakChecker;
             basic_leakChecker::ZESbasic_leakChecker *zesChecker = new basic_leakChecker::ZESbasic_leakChecker;
             basic_leakChecker::ZETbasic_leakChecker *zetChecker = new basic_leakChecker::ZETbasic_leakChecker;
+            basic_leakChecker::ZERbasic_leakChecker *zerChecker = new basic_leakChecker::ZERbasic_leakChecker;
             basic_leak_checker.zeValidation = zeChecker;
             basic_leak_checker.zetValidation = zetChecker;
             basic_leak_checker.zesValidation = zesChecker;
+            basic_leak_checker.zerValidation = zerChecker;
             validation_layer::context.getInstance().validationHandlers.push_back(&basic_leak_checker);
         }
     }
@@ -35,6 +37,7 @@ namespace validation_layer
             delete basic_leak_checker.zeValidation;
             delete basic_leak_checker.zetValidation;
             delete basic_leak_checker.zesValidation;
+            delete basic_leak_checker.zerValidation;
         }
     }
 
diff --git a/source/layers/validation/checkers/certification/zel_certification_checker.cpp b/source/layers/validation/checkers/certification/zel_certification_checker.cpp
@@ -22,6 +22,8 @@ certificationChecker::certificationChecker() {
         new certificationChecker::ZEScertificationChecker;
     certificationChecker::ZETcertificationChecker *zetChecker =
         new certificationChecker::ZETcertificationChecker;
+    certificationChecker::ZERcertificationChecker *zerChecker =
+        new certificationChecker::ZERcertificationChecker;
     ze_api_version_t certification_version = ZE_API_VERSION_CURRENT;
     const auto certification_version_string =
         getenv_string("ZEL_CERTIFICATION_CHECKER_VERSION");
@@ -38,6 +40,7 @@ certificationChecker::certificationChecker() {
     certification_checker.zeValidation = zeChecker;
     certification_checker.zetValidation = zetChecker;
     certification_checker.zesValidation = zesChecker;
+    certification_checker.zerValidation = zerChecker;
     validation_layer::context.getInstance().validationHandlers.push_back(
         &certification_checker);
   }
@@ -48,6 +51,7 @@ certificationChecker::~certificationChecker() {
     delete certification_checker.zeValidation;
     delete certification_checker.zetValidation;
     delete certification_checker.zesValidation;
+    delete certification_checker.zerValidation;
   }
 }
 
diff --git a/source/layers/validation/checkers/events_checker/zel_events_checker.cpp b/source/layers/validation/checkers/events_checker/zel_events_checker.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -21,9 +21,11 @@ eventsChecker::eventsChecker() {
         eventsChecker::ZEeventsChecker *zeChecker = new eventsChecker::ZEeventsChecker;
         eventsChecker::ZESeventsChecker *zesChecker = new eventsChecker::ZESeventsChecker;
         eventsChecker::ZETeventsChecker *zetChecker = new eventsChecker::ZETeventsChecker;
+        eventsChecker::ZEReventsChecker *zerChecker = new eventsChecker::ZEReventsChecker;
         events_checker.zeValidation = zeChecker;
         events_checker.zesValidation = zesChecker;
         events_checker.zetValidation = zetChecker;
+        events_checker.zerValidation = zerChecker;
 
         validation_layer::context.getInstance().validationHandlers.push_back(&events_checker);
     }
@@ -34,6 +36,7 @@ eventsChecker::~eventsChecker() {
         delete events_checker.zeValidation;
         delete events_checker.zesValidation;
         delete events_checker.zetValidation;
+        delete events_checker.zerValidation;
     }
 }
 
diff --git a/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.cpp b/source/layers/validation/checkers/parameter_validation/ze_parameter_validation.cpp
@@ -22,9 +22,11 @@ namespace validation_layer
             ZEParameterValidation *zeChecker = new ZEParameterValidation;
             ZESParameterValidation *zesChecker = new ZESParameterValidation;
             ZETParameterValidation *zetChecker = new ZETParameterValidation;
+            ZERParameterValidation *zerChecker = new ZERParameterValidation;
             parameterChecker.zeValidation = zeChecker;
             parameterChecker.zetValidation = zetChecker;
             parameterChecker.zesValidation = zesChecker;
+            parameterChecker.zerValidation = zerChecker;
             validation_layer::context.getInstance().validationHandlers.push_back(&parameterChecker);
         }
     }
@@ -34,6 +36,7 @@ namespace validation_layer
             delete parameterChecker.zeValidation;
             delete parameterChecker.zetValidation;
             delete parameterChecker.zesValidation;
+            delete parameterChecker.zerValidation;
         }
     }
 
diff --git a/source/layers/validation/checkers/template/zel_template_checker.cpp b/source/layers/validation/checkers/template/zel_template_checker.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,9 +18,11 @@ namespace validation_layer
             validationCheckerTemplate::ZEvalidationCheckerTemplate *zeChecker = new validationCheckerTemplate::ZEvalidationCheckerTemplate;
             validationCheckerTemplate::ZESvalidationCheckerTemplate *zesChecker = new validationCheckerTemplate::ZESvalidationCheckerTemplate;
             validationCheckerTemplate::ZETvalidationCheckerTemplate *zetChecker = new validationCheckerTemplate::ZETvalidationCheckerTemplate;
+            validationCheckerTemplate::ZERvalidationCheckerTemplate *zerChecker = new validationCheckerTemplate::ZERvalidationCheckerTemplate;
             templateChecker.zeValidation = zeChecker;
             templateChecker.zetValidation = zetChecker;
             templateChecker.zesValidation = zesChecker;
+            templateChecker.zerValidation = zerChecker;
             validation_layer::context.getInstance().validationHandlers.push_back(&templateChecker);
         }
     }
@@ -30,6 +32,7 @@ namespace validation_layer
             delete templateChecker.zeValidation;
             delete templateChecker.zetValidation;
             delete templateChecker.zesValidation;
+            delete templateChecker.zerValidation;
         }
     }
 
diff --git a/source/layers/validation/checkers/template/zel_template_checker.h b/source/layers/validation/checkers/template/zel_template_checker.h
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,6 +33,9 @@ namespace validation_layer
             public:
                 ze_result_t zetModuleGetDebugInfoPrologue( zet_module_handle_t hModule, zet_module_debug_info_format_t format, size_t* pSize, uint8_t* pDebugInfo ) override;
             };
+            class ZERvalidationCheckerTemplate : public ZERValidationEntryPoints {
+            public:
+            };
         bool enableValidationCheckerTemplate = false;
     };
     extern class validationCheckerTemplate templateChecker;
diff --git a/source/lib/error_state.cpp b/source/lib/error_state.cpp
@@ -28,6 +28,8 @@ namespace error_state
         {
             errorDescs[threadId] = std::string();
         }
-        *ppString = errorDescs[threadId].c_str();
+        if(ppString != nullptr) {
+            *ppString = errorDescs[threadId].c_str();
+        }
     }
 }
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -701,4 +701,11 @@ add_test(NAME test_ze_and_zer_tracing_dynamic COMMAND tests --gtest_filter=*Trac
 set_property(TEST test_ze_and_zer_tracing_dynamic PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
 
 add_test(NAME test_zer_unsupported_and_ze_tracing_dynamic COMMAND tests --gtest_filter=*TracingParameterizedTest*GivenLoaderWithDynamicTracingEnabledAndZerApisUnsupportedAndBothZeAndZerCallbacksRegisteredWhenCallingBothApisThenTracingWorksForZeOnly*)
-set_property(TEST test_zer_unsupported_and_ze_tracing_dynamic PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
+set_property(TEST test_zer_unsupported_and_ze_tracing_dynamic PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
+
+# ZER API Validation Layer Tests
+add_test(NAME test_zer_validation_layer_positive_case COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWithLoaderInterceptEnabledAndDdiExtSupportedWhenCallingRuntimeApisAfterZeInitDriversThenExpectNullDriverIsReachedSuccessfully)
+set_property(TEST test_zer_validation_layer_positive_case PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;ZE_ENABLE_VALIDATION_LAYER=1;ZE_ENABLE_PARAMETER_VALIDATION=1;ZE_ENABLE_HANDLE_LIFETIME=0;ZEL_ENABLE_EVENTS_CHECKER=1;ZEL_ENABLE_BASIC_LEAK_CHECKER=1;ZEL_ENABLE_CERTIFICATION_CHECKER=1")
+
+add_test(NAME test_zer_parameter_validation_layer_negative_case COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingZerApiWithParameterValidationEnabledThenExpectValidationsAreTriggered)
+set_property(TEST test_zer_parameter_validation_layer_negative_case PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;ZE_ENABLE_VALIDATION_LAYER=1;ZE_ENABLE_PARAMETER_VALIDATION=1;ZE_ENABLE_HANDLE_LIFETIME=1;ZEL_ENABLE_EVENTS_CHECKER=1;ZEL_ENABLE_BASIC_LEAK_CHECKER=1;ZEL_ENABLE_CERTIFICATION_CHECKER=1")
diff --git a/test/loader_api.cpp b/test/loader_api.cpp
@@ -2311,7 +2311,11 @@ TEST_F(DriverOrderingTest,
     EXPECT_EQ(ZE_RESULT_SUCCESS, result);
     EXPECT_TRUE(compare_env("zerGetLastErrorDescription", "1"));
 
-    deviceId = zerTranslateDeviceHandleToIdentifier(nullptr);
+    uint32_t device_count = 1;
+    std::vector<ze_device_handle_t> devices(device_count);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zeDeviceGet(drivers[0], &device_count, devices.data()));
+
+    deviceId = zerTranslateDeviceHandleToIdentifier(devices[0]);
     EXPECT_TRUE(compare_env("zerTranslateDeviceHandleToIdentifier", "1"));
 
     ze_device_handle_t translatedDevice = zerTranslateIdentifierToDeviceHandle(deviceId);
diff --git a/test/loader_validation_layer.cpp b/test/loader_validation_layer.cpp
@@ -9,6 +9,7 @@
 #include "gtest/gtest.h"
 #include "loader/ze_loader.h"
 #include "ze_api.h"
+#include "zer_api.h"
 
 #if defined(_WIN32)
 #define putenv_safe _putenv
@@ -581,3 +582,23 @@ TEST(
     status = zeContextDestroy(context);
     EXPECT_EQ(ZE_RESULT_SUCCESS, status);
 }
+
+  TEST(
+      RuntimeApiParameterValidation,
+      GivenLevelZeroLoaderPresentWhenCallingZerApiWithParameterValidationEnabledThenExpectValidationsAreTriggered)
+  {
+    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);
+
+    ze_result_t result = zerGetLastErrorDescription(nullptr);
+    EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_POINTER, result);
+  }

Original file line number	Diff line number	Diff line change
`@@ -32,9 +32,11 @@ namespace validation_layer`
`32`	`32`	`ZEParameterValidation *zeChecker = new ZEParameterValidation;`
`33`	`33`	`ZESParameterValidation *zesChecker = new ZESParameterValidation;`
`34`	`34`	`ZETParameterValidation *zetChecker = new ZETParameterValidation;`
	`35`	`+ ZERParameterValidation *zerChecker = new ZERParameterValidation;`
`35`	`36`	`parameterChecker.zeValidation = zeChecker;`
`36`	`37`	`parameterChecker.zetValidation = zetChecker;`
`37`	`38`	`parameterChecker.zesValidation = zesChecker;`
	`39`	`+ parameterChecker.zerValidation = zerChecker;`
`38`	`40`	`validation_layer::context.getInstance().validationHandlers.push_back(&parameterChecker);`
`39`	`41`	`}`
`40`	`42`	`}`
`@@ -44,6 +46,7 @@ namespace validation_layer`
`44`	`46`	`delete parameterChecker.zeValidation;`
`45`	`47`	`delete parameterChecker.zetValidation;`
`46`	`48`	`delete parameterChecker.zesValidation;`
	`49`	`+ delete parameterChecker.zerValidation;`
`47`	`50`	`}`
`48`	`51`	`}`
`49`	`52`	`%endif`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`/*`
`2`		`- * Copyright (C) 2024 Intel Corporation`
	`2`	`+ * Copyright (C) 2024-2025 Intel Corporation`
`3`	`3`	`*`
`4`	`4`	`* SPDX-License-Identifier: MIT`
`5`	`5`	`*`
`@@ -23,9 +23,11 @@ namespace validation_layer`
`23`	`23`	`basic_leakChecker::ZEbasic_leakChecker *zeChecker = new basic_leakChecker::ZEbasic_leakChecker;`
`24`	`24`	`basic_leakChecker::ZESbasic_leakChecker *zesChecker = new basic_leakChecker::ZESbasic_leakChecker;`
`25`	`25`	`basic_leakChecker::ZETbasic_leakChecker *zetChecker = new basic_leakChecker::ZETbasic_leakChecker;`
	`26`	`+ basic_leakChecker::ZERbasic_leakChecker *zerChecker = new basic_leakChecker::ZERbasic_leakChecker;`
`26`	`27`	`basic_leak_checker.zeValidation = zeChecker;`
`27`	`28`	`basic_leak_checker.zetValidation = zetChecker;`
`28`	`29`	`basic_leak_checker.zesValidation = zesChecker;`
	`30`	`+ basic_leak_checker.zerValidation = zerChecker;`
`29`	`31`	`validation_layer::context.getInstance().validationHandlers.push_back(&basic_leak_checker);`
`30`	`32`	`}`
`31`	`33`	`}`
`@@ -35,6 +37,7 @@ namespace validation_layer`
`35`	`37`	`delete basic_leak_checker.zeValidation;`
`36`	`38`	`delete basic_leak_checker.zetValidation;`
`37`	`39`	`delete basic_leak_checker.zesValidation;`
	`40`	`+ delete basic_leak_checker.zerValidation;`
`38`	`41`	`}`
`39`	`42`	`}`
`40`	`43`
Original file line number	Diff line number	Diff line change
`@@ -22,9 +22,11 @@ namespace validation_layer`
`22`	`22`	`ZEParameterValidation *zeChecker = new ZEParameterValidation;`
`23`	`23`	`ZESParameterValidation *zesChecker = new ZESParameterValidation;`
`24`	`24`	`ZETParameterValidation *zetChecker = new ZETParameterValidation;`
	`25`	`+ ZERParameterValidation *zerChecker = new ZERParameterValidation;`
`25`	`26`	`parameterChecker.zeValidation = zeChecker;`
`26`	`27`	`parameterChecker.zetValidation = zetChecker;`
`27`	`28`	`parameterChecker.zesValidation = zesChecker;`
	`29`	`+ parameterChecker.zerValidation = zerChecker;`
`28`	`30`	`validation_layer::context.getInstance().validationHandlers.push_back(&parameterChecker);`
`29`	`31`	`}`
`30`	`32`	`}`
`@@ -34,6 +36,7 @@ namespace validation_layer`
`34`	`36`	`delete parameterChecker.zeValidation;`
`35`	`37`	`delete parameterChecker.zetValidation;`
`36`	`38`	`delete parameterChecker.zesValidation;`
	`39`	`+ delete parameterChecker.zerValidation;`
`37`	`40`	`}`
`38`	`41`	`}`
`39`	`42`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`/*`
`2`	`2`	`*`
`3`		`- * Copyright (C) 2024 Intel Corporation`
	`3`	`+ * Copyright (C) 2024-2025 Intel Corporation`
`4`	`4`	`*`
`5`	`5`	`* SPDX-License-Identifier: MIT`
`6`	`6`	`*`
`@@ -33,6 +33,9 @@ namespace validation_layer`
`33`	`33`	`public:`
`34`	`34`	`ze_result_t zetModuleGetDebugInfoPrologue( zet_module_handle_t hModule, zet_module_debug_info_format_t format, size_t* pSize, uint8_t* pDebugInfo ) override;`
`35`	`35`	`};`
	`36`	`+ class ZERvalidationCheckerTemplate : public ZERValidationEntryPoints {`
	`37`	`+ public:`
	`38`	`+ };`
`36`	`39`	`bool enableValidationCheckerTemplate = false;`
`37`	`40`	`};`
`38`	`41`	`extern class validationCheckerTemplate templateChecker;`
Original file line number	Diff line number	Diff line change
`@@ -28,6 +28,8 @@ namespace error_state`
`28`	`28`	`{`
`29`	`29`	`errorDescs[threadId] = std::string();`
`30`	`30`	`}`
`31`		`- *ppString = errorDescs[threadId].c_str();`
	`31`	`+ if(ppString != nullptr) {`
	`32`	`+ *ppString = errorDescs[threadId].c_str();`
	`33`	`+ }`
`32`	`34`	`}`
`33`	`35`	`}`