feat: crash handler implementation for windows

Author: JeanPhilippeKernel

Obelisk/EntryPoint.cpp

@@ -2,6 +2,7 @@
 #include <Tetragrama/Editor.h>
 #include <ZEngine/Applications/GameApplication.h>
 #include <ZEngine/Core/Memory/MemoryManager.h>
+#include <ZEngine/CrashHandlers/CrashHandler.h>
 #include <ZEngine/EngineConfiguration.h>
 #include <ZEngine/Helpers/ThreadPool.h>
 #include <ZEngine/Logging/Logger.h>
@@ -12,9 +13,12 @@ using namespace ZEngine;
 using namespace ZEngine::Logging;
 using namespace ZEngine::Core::Memory;
 using namespace ZEngine::Applications;
+using namespace ZEngine::CrashHandlers;
 
 int applicationEntryPoint(int argc, char* argv[])
 {
+    CrashHandler::Install("Obelisk", "1.0.0", "CrashDumps");
+
     MemoryManager       manager = {};
     MemoryConfiguration config  = {.BufferSize = ZGiga(3u)};
     manager.Initialize(config);
@@ -43,7 +47,10 @@ int applicationEntryPoint(int argc, char* argv[])
         app->EnableRenderOverlay = true;
     }
 
-    app->ConfigFile = config_file.c_str();
+    auto config_file_str_size = config_file.size() + 1;
+    auto config_file_str      = ZPushString(arena, config_file_str_size);
+    Helpers::secure_strncpy(config_file_str, config_file_str_size, config_file.c_str(), config_file.size());
+    app->ConfigFile = config_file_str;
 
     app->Initialize(arena);
     app->Run();
@@ -53,6 +60,7 @@ int applicationEntryPoint(int argc, char* argv[])
 
     manager.Shutdown();
 
+    CrashHandler::Uninstall();
     return 0;
 }
 

ZEngine/ZEngine/CMakeLists.txt

@@ -84,6 +84,9 @@ target_include_directories (zEngineLib
 		./Windows/Layers
 		./Managers
 		./Serializers
+		# Idealy we want to convert this to modules/extensions
+		#
+		./CrashHandlers
 )
 
 target_precompile_headers(zEngineLib PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/pch.h)

ZEngine/ZEngine/CrashHandlers/CrashHandler.h

@@ -0,0 +1,58 @@
+#pragma once
+
+namespace ZEngine::CrashHandlers
+{
+    struct CrashHandler
+    {
+        using PreCrashFn = void (*)(void* ctx);
+        using cstring    = const char*;
+
+        // Install the platform crash handler.
+        //   app_name      — e.g. "GameName"
+        //   version       — e.g. "1.0.0"
+        //   crash_log_dir — directory where crash logs and .dmp files are written.
+        //                   Created if it does not exist.
+        //
+        // Call once, before any engine subsystem is initialized.
+        // No-op if already installed.
+        static void              Install(cstring app_name, cstring version, cstring crash_log_dir);
+
+        // Remove the platform crash handler and restore default OS behavior.
+        // Call at engine shutdown. Safe to call if Install() was never called.
+        static void              Uninstall();
+
+        // Set a callback to be called just before the crash dump is written.
+        // This is useful for flushing logs, saving game state, etc.
+        //
+        // The callback must complete within a defined timeout (default 2 seconds) or the crash handler will proceed to write the dump anyway.
+        //      On Windows, a helper thread's timeout fires
+        //      On Linux, macOS SIGALRM is raised on the callback thread
+        //
+        // Only one callback can be set at a time. Setting a new callback replaces the previous one.
+        // It must not allocate memory on the ZEngine heap, or call ZENGINE_VALIDATE_ASSERT.
+        static void              SetPreCrashCallback(PreCrashFn fn, void* ctx = nullptr);
+
+        // Called by the platform handler (SEH filter on Windows, signal handler
+        // on POSIX) to perform the cross-platform crash response.
+        //   signal_or_exception — human-readable description, e.g.
+        //                         "Access Violation at 0x0000000000000000"
+        //   context             — platform-specific context:
+        //                         Windows: EXCEPTION_POINTERS*
+        //                         POSIX:   ucontext_t*
+        //
+        // This function does not return under normal conditions.
+        [[noreturn]] static void OnCrash(cstring signal_or_exception, void* ctx = nullptr);
+
+        // Called by ZENGINE_VALIDATE_ASSERT to produce a crash report for
+        // assertion failures in Release/RelWithDebInfo builds.
+        //   file    — __FILE__
+        //   line    — __LINE__
+        //   message — the assertion condition and user message string
+        [[noreturn]] static void OnAssertionFailure(cstring file, int line, cstring message);
+
+    private:
+        CrashHandler() = delete;
+
+        static void StoreMetadata(cstring app_name, cstring version, cstring crash_log_dir);
+    };
+} // namespace ZEngine::CrashHandlers

ZEngine/ZEngine/CrashHandlers/CrashHandlerInternal.h

@@ -0,0 +1,27 @@
+#pragma once
+#include <CrashHandlers/CrashHandler.h>
+
+namespace ZEngine::CrashHandlers
+{
+    namespace
+    {
+        constexpr size_t kMaxPathLen         = 512;
+        constexpr size_t kMaxTraceLen        = 8192;
+        constexpr size_t kMaxNameLen         = 128;
+        constexpr int    kCallbackTimeoutSec = 2;
+
+        struct CrashHandlerState
+        {
+            bool                     Installed                = false;
+            bool                     UserConsentUpload        = false;
+            char                     AppName[kMaxNameLen]     = {};
+            char                     Version[kMaxNameLen]     = {};
+            char                     CrashLogDir[kMaxPathLen] = {};
+
+            void*                    PreCrashCtx              = nullptr;
+            CrashHandler::PreCrashFn PreCrashFn               = nullptr;
+        };
+
+        static CrashHandlerState g_state;
+    } // namespace
+} // namespace ZEngine::CrashHandlers