Implement ExceptionHandling.SetFatalErrorHandler

src/coreclr/nativeaot/System.Private.CoreLib/src/System/RuntimeExceptionHelpers.cs

@@ -5,7 +5,9 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime;
 using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Threading;
 
 using Internal.Reflection.Augments;
@@ -26,6 +28,80 @@ internal static void Initialize()
 
     internal static class RuntimeExceptionHelpers
     {
+        // Matches the FatalErrorInfo struct defined in src/native/public/FatalErrorHandling.h.
+        // The layout must be kept in sync with the native header.
+        [StructLayout(LayoutKind.Sequential)]
+        internal unsafe struct FatalErrorInfo
+        {
+            internal nuint Size;
+            internal void* Address;
+            internal void* Info;
+            internal void* Context;
+            internal delegate* unmanaged<FatalErrorInfo*, delegate* unmanaged<byte*, void*, void>, void*, void> PfnGetFatalErrorLog;
+        }
+
+        // Pre-allocated buffer for crash log text (UTF-8). Only one thread should
+        // be in the crash path at a time (guarded by s_crashingThreadId).
+        private const int CrashLogBufferSize = 8192;
+        private static readonly byte[] s_crashLogBuffer = new byte[CrashLogBufferSize];
+        private static int s_crashLogLength;
+
+        /// <summary>
+        /// Appends a string to the crash log buffer as UTF-8. If the buffer is full,
+        /// the remaining text is silently truncated.
+        /// </summary>
+        private static void AppendToCrashLog(string? text)
+        {
+            if (string.IsNullOrEmpty(text))
+                return;
+
+            try
+            {
+                int remaining = CrashLogBufferSize - s_crashLogLength;
+                if (remaining <= 0)
+                    return;
+
+                ReadOnlySpan<char> source = text.AsSpan();
+                Span<byte> destination = s_crashLogBuffer.AsSpan(s_crashLogLength, remaining);
+
+                int bytesUsed = Encoding.UTF8.GetBytes(source, destination);
+                s_crashLogLength += bytesUsed;
+            }
+            catch
+            {
+                // Never fail on the crash path.
+            }
+        }
+
+        private static void AppendNewlineToCrashLog()
+        {
+            if (s_crashLogLength < CrashLogBufferSize)
+            {
+                s_crashLogBuffer[s_crashLogLength++] = (byte)'\n';
+            }
+        }
+
+        [UnmanagedCallersOnly]
+        private static unsafe void GetFatalErrorLog(
+            FatalErrorInfo* errorData,
+            delegate* unmanaged<byte*, void*, void> pfnLogAction,
+            void* userContext)
+        {
+            if (s_crashLogLength == 0 || pfnLogAction == null)
+                return;
+
+            // Null-terminate the buffer for the callback.
+            if (s_crashLogLength < CrashLogBufferSize)
+                s_crashLogBuffer[s_crashLogLength] = 0;
+            else
+                s_crashLogBuffer[CrashLogBufferSize - 1] = 0;
+
+            fixed (byte* pBuffer = s_crashLogBuffer)
+            {
+                pfnLogAction(pBuffer, userContext);
+            }
+        }
+
         //------------------------------------------------------------------------------------------------------------
         // @TODO: this function is related to throwing exceptions out of Rtm. If we did not have to throw
         // out of Rtm, then we would note have to have the code below to get a classlib exception object given
@@ -249,55 +325,72 @@ internal static unsafe void FailFast(string? message = null, Exception? exceptio
                     // report that OOM is the reason for the crash.
                     try
                     {
-                        // Try to print the same short message CoreCLR prints.
                         Internal.Console.Error.Write("Out of memory.");
                         Internal.Console.Error.WriteLine();
+                        AppendToCrashLog("Out of memory.\n");
                     }
                     catch { }
                 }
                 else
                 {
-                    Internal.Console.Error.Write(((exception == null) || (reason is RhFailFastReason.EnvironmentFailFast or RhFailFastReason.AssertionFailure)) ?
-                        "Process terminated. " : "Unhandled exception. ");
+                    string header = ((exception == null) || (reason is RhFailFastReason.EnvironmentFailFast or RhFailFastReason.AssertionFailure)) ?
+                        "Process terminated. " : "Unhandled exception. ";
+                    Internal.Console.Error.Write(header);
+                    AppendToCrashLog(header);
 
                     if (errorSource != null)
                     {
                         Internal.Console.Error.Write(errorSource);
                         Internal.Console.Error.WriteLine();
+                        AppendToCrashLog(errorSource);
+                        AppendNewlineToCrashLog();
                     }
 
                     if (message != null)
                     {
                         Internal.Console.Error.Write(message);
                         Internal.Console.Error.WriteLine();
+                        AppendToCrashLog(message);
+                        AppendNewlineToCrashLog();
                     }
 
                     if (errorSource == null && message == null && (exception == null || reason is RhFailFastReason.EnvironmentFailFast))
                     {
-                        Internal.Console.Error.Write(GetStringForFailFastReason(reason));
+                        string reasonText = GetStringForFailFastReason(reason);
+                        Internal.Console.Error.Write(reasonText);
                         Internal.Console.Error.WriteLine();
+                        AppendToCrashLog(reasonText);
+                        AppendNewlineToCrashLog();
                     }
 
                     if (reason is RhFailFastReason.EnvironmentFailFast)
                     {
-                        Internal.Console.Error.Write(new StackTrace().ToString());
+                        string stackTrace = new StackTrace().ToString();
+                        Internal.Console.Error.Write(stackTrace);
+                        AppendToCrashLog(stackTrace);
                     }
 
                     if ((exception != null) && (reason is not RhFailFastReason.AssertionFailure))
                     {
                         try
                         {
-                            Internal.Console.Error.Write(exception.ToString());
+                            string exText = exception.ToString();
+                            Internal.Console.Error.Write(exText);
                             Internal.Console.Error.WriteLine();
+                            AppendToCrashLog(exText);
+                            AppendNewlineToCrashLog();
                         }
                         catch
                         {
                             // If ToString() fails (for example, due to OOM), fall back to a simpler message.
                             try
                             {
                                 // Use an allocation-free MethodTable comparison.
-                                Internal.Console.Error.Write(exception.GetMethodTable() == Internal.Runtime.MethodTable.Of<OutOfMemoryException>() ? "Out of memory." : exception.GetType().FullName);
+                                string? typeName = exception.GetMethodTable() == Internal.Runtime.MethodTable.Of<OutOfMemoryException>() ? "Out of memory." : exception.GetType().FullName;
+                                Internal.Console.Error.Write(typeName);
                                 Internal.Console.Error.WriteLine();
+                                AppendToCrashLog(typeName);
+                                AppendNewlineToCrashLog();
                             }
                             catch { }
                         }
@@ -352,6 +445,29 @@ internal static unsafe void FailFast(string? message = null, Exception? exceptio
                 }
             }
 
+            // Invoke the user's fatal error handler, if one was registered.
+            IntPtr fatalHandler = ExceptionHandling.s_fatalErrorHandler;
+            if (fatalHandler != IntPtr.Zero)
+            {
+                FatalErrorInfo errorInfo;
+                errorInfo.Size = (nuint)sizeof(FatalErrorInfo);
+                errorInfo.Address = (void*)pExAddress;
+                errorInfo.Info = null;
+                errorInfo.Context = (void*)pExContext;
+                errorInfo.PfnGetFatalErrorLog = &GetFatalErrorLog;
+
+                int handlerResult = ((delegate* unmanaged<int, void*, int>)fatalHandler)(errorCode, &errorInfo);
+                if (handlerResult == 1)
+                {
+                    // SkipDefaultHandler — terminate without crash dump.
+#if TARGET_WINDOWS
+                    Interop.Kernel32.ExitProcess(errorCode);
+#else
+                    Interop.Sys.Exit(errorCode);
+#endif
+                }
+            }
+
             EXCEPTION_RECORD exceptionRecord;
             // STATUS_STACK_BUFFER_OVERRUN is a "transport" exception code required by Watson to trigger the proper analyzer/provider for bucketing
             exceptionRecord.ExceptionCode = STATUS_STACK_BUFFER_OVERRUN;

src/coreclr/vm/corelib.h

@@ -1008,6 +1008,9 @@ DEFINE_CLASS(EXCEPTION_DISPATCH_INFO, ExceptionServices,      ExceptionDispatchI
 DEFINE_METHOD(EXCEPTION_DISPATCH_INFO, CAPTURE, Capture, NoSig)
 DEFINE_METHOD(EXCEPTION_DISPATCH_INFO, THROW, Throw, IM_RetVoid)
 
+DEFINE_CLASS(EXCEPTION_HANDLING, ExceptionServices,         ExceptionHandling)
+DEFINE_FIELD(EXCEPTION_HANDLING, FATAL_ERROR_HANDLER,       s_fatalErrorHandler)
+
 DEFINE_CLASS_U(Loader,             AssemblyLoadContext,           AssemblyLoadContextBaseObject)
 DEFINE_FIELD_U(_unloadLock,                 AssemblyLoadContextBaseObject, _unloadLock)
 DEFINE_FIELD_U(_resolvingUnmanagedDll,      AssemblyLoadContextBaseObject, _resolvingUnmanagedDll)

src/coreclr/vm/eepolicy.cpp

@@ -668,6 +668,72 @@ void EEPolicy::LogFatalError(UINT exitCode, UINT_PTR address, LPCWSTR pszMessage
     }
 }
 
+//
+// Fatal error handler invocation support.
+// Uses the public FatalErrorHandling.h header for shared type definitions.
+//
+
+#include <public/FatalErrorHandling.h>
+
+using FatalErrorHandlerFunc = int (DOTNET_CALLCONV *)(int hresult, void* errorData);
+
+static void DOTNET_CALLCONV GetFatalErrorLogCallback(FatalErrorInfo* errorData, FatalErrorLogAction pfnLogAction, void* userContext)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    size_t length = 0;
+    char* buffer = GetCrashLogBuffer(&length);
+    if (length > 0 && pfnLogAction != nullptr)
+        pfnLogAction(buffer, userContext);
+}
+
+// Invokes the user-registered fatal error handler if one has been set.
+// Returns true if the handler indicated that default handling should be skipped.
+static bool InvokeFatalErrorHandler(UINT exitCode, UINT_PTR address, PEXCEPTION_POINTERS pExceptionInfo)
+{
+    WRAPPER_NO_CONTRACT;
+
+    // We are in a fatal error path — suppress all contract enforcement.
+    CONTRACT_VIOLATION(GCViolation | ModeViolation | FaultNotFatal | TakesLockViolation);
+
+    bool skipDefault = false;
+
+    EX_TRY
+    {
+        FatalErrorHandlerFunc pfnHandler;
+        {
+            // CoreLibBinder::GetField requires GC_TRIGGERS and
+            // GetCurrentStaticAddress requires MODE_COOPERATIVE.
+            GCX_COOP();
+            FieldDesc* pFD = CoreLibBinder::GetField(FIELD__EXCEPTION_HANDLING__FATAL_ERROR_HANDLER);
+            pfnHandler = reinterpret_cast<FatalErrorHandlerFunc>(pFD->GetStaticValuePtr());
+        }
+        if (pfnHandler != NULL)
+        {
+            GCX_PREEMP();
+            FatalErrorInfo errorInfo{};
+            errorInfo.size = sizeof(FatalErrorInfo);
+            errorInfo.address = reinterpret_cast<void*>(address);
+            if (pExceptionInfo != NULL)
+            {
+                errorInfo.info = pExceptionInfo->ExceptionRecord;
+                errorInfo.context = pExceptionInfo->ContextRecord;
+            }
+            errorInfo.pfnGetFatalErrorLog = GetFatalErrorLogCallback;
+
+            // Call user-defined fatal error handler.
+            int result = pfnHandler(static_cast<int>(exitCode), &errorInfo);
+            skipDefault = (result == SkipDefaultHandler);
+        }
+    }
+    EX_CATCH
+    {
+    }
+    EX_END_CATCH
+
+    return skipDefault;
+}
+
 void DisplayStackOverflowException()
 {
     LIMITED_METHOD_CONTRACT;
@@ -698,6 +764,8 @@ void DECLSPEC_NORETURN EEPolicy::HandleFatalStackOverflow(EXCEPTION_POINTERS *pE
 
     STRESS_LOG0(LF_EH, LL_INFO100, "In EEPolicy::HandleFatalStackOverflow\n");
 
+    EnableCrashLogCapture();
+
     FaultingExceptionFrame fef;
     if (pExceptionInfo->ContextRecord)
     {
@@ -845,6 +913,13 @@ void DECLSPEC_NORETURN EEPolicy::HandleFatalStackOverflow(EXCEPTION_POINTERS *pE
     if (g_LogStackOverflowExit)
         PrintToStdErrA("@Terminating the process.\n");
 #endif
+
+    UINT_PTR soAddress = pExceptionInfo->ContextRecord ? GetIP(pExceptionInfo->ContextRecord) : 0;
+    if (InvokeFatalErrorHandler(COR_E_STACKOVERFLOW, soAddress, pExceptionInfo))
+    {
+        _exit(COR_E_STACKOVERFLOW);
+    }
+
     CrashDumpAndTerminateProcess(COR_E_STACKOVERFLOW);
     UNREACHABLE();
 }
@@ -927,8 +1002,16 @@ int NOINLINE EEPolicy::HandleFatalError(UINT exitCode, UINT_PTR address, LPCWSTR
 
         g_fFastExitProcess = 2;
 
+        EnableCrashLogCapture();
+
         STRESS_LOG0(LF_CORDB,LL_INFO100, "D::HFE: About to call LogFatalError\n");
         LogFatalError(exitCode, address, pszMessage, pExceptionInfo, errorSource, argExceptionString);
+
+        if (InvokeFatalErrorHandler(exitCode, address, pExceptionInfo))
+        {
+            _exit(exitCode);
+        }
+
         SafeExitProcess(exitCode, SCA_TerminateProcessWhenShutdownComplete);
     }
 

src/coreclr/vm/util.cpp

@@ -120,6 +120,30 @@ LPVOID CQuickHeap::Alloc(UINT sz)
 // Output functions that avoid the crt's.
 //----------------------------------------------------------------------------
 
+static char s_crashLogBuffer[8192];
+static size_t s_crashLogPos = 0;
+static bool s_crashLogActive = false;
+
+void EnableCrashLogCapture()
+{
+    LIMITED_METHOD_CONTRACT;
+    s_crashLogActive = true;
+}
+
+char* GetCrashLogBuffer(size_t* pLength)
+{
+    LIMITED_METHOD_CONTRACT;
+
+    // Ensure null termination when requested.
+    size_t nullTerminatorPos = (s_crashLogPos < ARRAY_SIZE(s_crashLogBuffer))
+        ? s_crashLogPos
+        : ARRAY_SIZE(s_crashLogBuffer) - 1;
+    s_crashLogBuffer[nullTerminatorPos] = '\0';
+
+    *pLength = s_crashLogPos;
+    return s_crashLogBuffer;
+}
+
 void PrintToStdErrA(const char *pszString)
 {
     CONTRACTL
@@ -131,6 +155,19 @@ void PrintToStdErrA(const char *pszString)
     CONTRACTL_END
 
     minipal_log_write_error(pszString);
+
+    if (s_crashLogActive)
+    {
+        size_t len = strlen(pszString);
+        size_t remaining = ARRAY_SIZE(s_crashLogBuffer) - s_crashLogPos;
+        if (len > remaining)
+            len = remaining;
+        if (len > 0)
+        {
+            memcpy(s_crashLogBuffer + s_crashLogPos, pszString, len);
+            s_crashLogPos += len;
+        }
+    }
 }
 
 void PrintToStdErrW(const WCHAR *pwzString)

src/coreclr/vm/util.hpp

@@ -188,6 +188,9 @@ class CQuickHeap
 void PrintToStdErrA(const char *pszString);
 void PrintToStdErrW(const WCHAR *pwzString);
 
+void EnableCrashLogCapture();
+char* GetCrashLogBuffer(size_t* pLength);
+
 #include "nativevaraccessors.h"
 
 // --------------------------------------------------------------------------------

src/libraries/System.Private.CoreLib/src/Resources/Strings.resx

@@ -2611,6 +2611,9 @@
   <data name="InvalidOperation_CannotRegisterSecondHandler" xml:space="preserve">
     <value>A handler for unhandled exceptions is already set.</value>
   </data>
+  <data name="InvalidOperation_CannotRegisterSecondFatalErrorHandler" xml:space="preserve">
+    <value>A handler for fatal errors is already set.</value>
+  </data>
   <data name="InvalidOperation_CannotRestoreUnsuppressedFlow" xml:space="preserve">
     <value>Cannot restore context flow when it is not suppressed.</value>
   </data>