Fixed teardown race condition w/static loader

Signed-off-by: Russell McGuire <russell.w.mcguire@intel.com>

Author: rwmcguir

source/layers/validation/ze_validation_layer.cpp

@@ -25,16 +25,11 @@ namespace validation_layer
         enableThreadingValidation = getenv_tobool( "ZE_ENABLE_THREADING_VALIDATION" );
         verboseLogging = getenv_tobool( "ZEL_LOADER_LOGGING_ENABLE_SUCCESS_PRINT" );
 
-        // Initialize logger to a no-op sentinel (level=off, no file/console I/O, no banner).
-        // This is purely crash protection: in normal operation the loader calls
-        // zelLoaderSetLogger() immediately after dlopen — before the DDI tables
-        // go live — so no real log call ever hits this sentinel.
-        //
-        // Thread-safety note: zelLoaderSetLogger() writes this field once, on the
-        // init thread, before zeDdiTable.exchange() makes the validation layer
-        // reachable from other threads.  The non-atomic shared_ptr assignment is
-        // therefore safe in practice; no mutex is needed here.
-        logger = std::shared_ptr<loader::ZeLogger>(new loader::ZeLogger()); // no-op sentinel: no sink, no mutex, no syscalls
+        // Point at the process-lifetime no-op logger until the loader calls
+        // zelLoaderSetLogger().  This is never null, so call sites need no null check.
+        // Thread-safety: zelLoaderSetLogger() writes this field exactly once on the
+        // init thread before zeDdiTable.exchange() makes the layer reachable.
+        logger = loader::noopLogger();
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -64,13 +59,13 @@ zelLoaderGetVersion(zel_component_version_t *version)
 }
 
 /// @brief Called by the loader immediately after dlopen to share its logger.
-///        Replaces the fallback logger created in the constructor so that
-///        validation-layer messages flow through the same sink as the loader.
+///        Replaces the no-op default so that validation-layer messages flow
+///        through the same sink as the loader.
 ZE_DLLEXPORT void ZE_APICALL
-zelLoaderSetLogger(std::shared_ptr<loader::ZeLogger> *loaderLogger)
+zelLoaderSetLogger(loader::ZeLogger *loaderLogger)
 {
-    if (loaderLogger && *loaderLogger) {
-        validation_layer::context_t::getInstance().logger = *loaderLogger;
+    if (loaderLogger) {
+        validation_layer::context_t::getInstance().logger = loaderLogger;
     }
 }
 

source/layers/validation/ze_validation_layer.h

@@ -57,7 +57,12 @@ namespace validation_layer
         std::vector<validationChecker *> validationHandlers;
         std::unique_ptr<HandleLifetimeValidation> handleLifetime;
 
-        std::shared_ptr<loader::ZeLogger> logger;
+        // Raw pointer — the loader owns the ZeLogger and guarantees it outlives
+        // the validation layer during normal operation (dlclose happens before
+        // zel_logger is destroyed in context_t::~context_t()).  Using a raw pointer
+        // (rather than shared_ptr) avoids _Sp_counted_base::_M_release() being
+        // called during _dl_call_fini after the control block has been freed.
+        loader::ZeLogger *logger;
 
         static context_t& getInstance() {
             static context_t instance;

source/loader/ze_loader.cpp

@@ -780,11 +780,11 @@ namespace loader
                 }
                 // Inject this loader instance's logger into the validation layer
                 // so both share a single file handle and mutex.
-                using SetLoggerFn = void (*)(std::shared_ptr<loader::ZeLogger> *);
+                using SetLoggerFn = void (*)(loader::ZeLogger *);
                 auto setLogger = reinterpret_cast<SetLoggerFn>(
                     GET_FUNCTION_PTR(validationLayer, "zelLoaderSetLogger"));
                 if (setLogger) {
-                    setLogger(&zel_logger);
+                    setLogger(zel_logger.get());
                 }
 
                 auto getVersion = reinterpret_cast<getVersion_t>(

source/utils/ze_logger.cpp

@@ -600,4 +600,13 @@ std::shared_ptr<ZeLogger> createLogger(const std::string &caller) {
     return logger;
 }
 
+// Returns a pointer to a process-lifetime no-op ZeLogger.
+// Using a function-local static here gives STB_LOCAL linkage (non-inline, non-template .cpp
+// function), avoiding STB_GNU_UNIQUE.  The instance is never destroyed, which is intentional:
+// components holding a raw pointer to this object are safe regardless of shutdown order.
+ZeLogger *noopLogger() {
+    static ZeLogger instance; // default constructor: level=off, _sink=nullptr
+    return &instance;
+}
+
 } // namespace loader

source/utils/ze_logger.h

@@ -95,6 +95,12 @@ std::string to_string(ze_result_t result);
 // Factory: reads ZEL_* env vars and constructs an appropriately configured logger.
 std::shared_ptr<ZeLogger> createLogger(const std::string &caller = "Loader");
 
+// A permanently-alive no-op logger instance suitable for use as a raw-pointer
+// default in components (e.g. the validation layer) that must never hold a
+// shared_ptr across dlclose/process-exit boundaries.
+// Level=off, no sink, no I/O.  Safe to call from any thread at any time.
+ZeLogger *noopLogger();
+
 } // namespace loader
 
 #endif // ZE_LOGGER_H