improved crash handler (more verbose)

malytomas · malytomas · commit 4faf3f6925c5 · 2025-08-21T13:23:00.000+02:00
diff --git a/sources/libcore/concurrent/concurrent.cpp b/sources/libcore/concurrent/concurrent.cpp
@@ -1,7 +1,6 @@
 #include <atomic>
 #include <cerrno>
 #include <exception>
-#include <mutex>
 #include <thread>
 
 #ifdef CAGE_SYSTEM_WINDOWS
@@ -20,6 +19,7 @@
 	#include <semaphore.h>
 	#include <sys/types.h>
 	#include <unistd.h>
+	#include <mutex>
 #endif
 
 #ifdef CAGE_SYSTEM_LINUX
@@ -36,10 +36,6 @@
 
 namespace cage
 {
-#ifdef CAGE_SYSTEM_LINUX
-	void crashHandlerInstallAltStack();
-#endif
-
 	namespace
 	{
 		class MutexImpl : public Mutex
@@ -658,36 +654,19 @@ namespace cage
 		return systemMemory().createImpl<Thread, ThreadImpl>(func, threadName);
 	}
 
+	void crashHandlerThreadInit();
+
 	namespace
 	{
-#ifdef CAGE_SYSTEM_WINDOWS
-		void currentThreadStackGuardLimit()
-		{
-			ULONG v = 128 * 1024;
-			SetThreadStackGuarantee(&v);
-		}
-
-		struct SetupStackGuardLimit
-		{
-			SetupStackGuardLimit() { currentThreadStackGuardLimit(); }
-		} setupStackGuardLimit;
-#endif
-
 #ifdef CAGE_SYSTEM_WINDOWS
 		DWORD WINAPI threadFunctionImpl(LPVOID params)
 #else
 		void *threadFunctionImpl(void *params)
 #endif
 		{
 			ThreadImpl *impl = (ThreadImpl *)params;
-#ifdef CAGE_SYSTEM_WINDOWS
-			currentThreadStackGuardLimit();
-#endif
-#ifdef CAGE_SYSTEM_LINUX
-			crashHandlerInstallAltStack();
-#endif
-
 			currentThreadName(impl->threadName);
+			crashHandlerThreadInit();
 			try
 			{
 				impl->function();
diff --git a/sources/libcore/concurrent/process.cpp b/sources/libcore/concurrent/process.cpp
@@ -27,6 +27,15 @@ extern "C"
 {
 	CAGE_API_EXPORT DWORD WINAPI CageRemoteThreadEntryPointToRaiseSignalTerm(_In_ LPVOID)
 	{
+		try
+		{
+			using namespace cage;
+			CAGE_LOG(SeverityEnum::Warning, "process", "raising SIGTERM");
+		}
+		catch (...)
+		{
+			// nothing
+		}
 		raise(SIGTERM);
 		return 0;
 	}
diff --git a/sources/libcore/errors/crashHandlerLinux.cpp b/sources/libcore/errors/crashHandlerLinux.cpp
@@ -19,8 +19,10 @@ namespace cage
 
 	int crashHandlerLogFileFd = STDERR_FILENO;
 
-	void crashHandlerInstallAltStack()
+	void crashHandlerThreadInit()
 	{
+		// install alternative stack memory for handling signals
+
 		static constexpr size_t AltStackSize = 128 * 1024; // bigger than SIGSTKSZ for safety
 
 		{
@@ -43,18 +45,19 @@ namespace cage
 		if (sigaltstack(&ss, nullptr) != 0)
 		{
 			CAGE_LOG(SeverityEnum::Note, "crash-handler", strerror(errno));
-			CAGE_LOG(SeverityEnum::Warning, "crash-handler", "failed to install alt stack");
+			CAGE_LOG(SeverityEnum::Warning, "crash-handler", "failed to install thread alt stack");
+			// most signals can be handled on regular stack memory, so we continue
 		}
 	}
 
 	namespace
 	{
-		constexpr int OldHandlersCount = 16;
-		struct sigaction prevHandlers[OldHandlersCount] = {};
+		constexpr int PrevHandlersCount = 16;
+		struct sigaction prevHandlers[PrevHandlersCount] = {};
 
 		struct sigaction *prevHandler(int sig)
 		{
-			if (sig >= 0 && sig < OldHandlersCount)
+			if (sig >= 0 && sig < PrevHandlersCount)
 				return &prevHandlers[sig];
 			return nullptr;
 		}
@@ -77,6 +80,8 @@ namespace cage
 					return "SIGTRAP";
 				case SIGTERM:
 					return "SIGTERM";
+				case SIGINT:
+					return "SIGINT";
 				default:
 					return "UNKNOWN";
 			}
@@ -102,35 +107,20 @@ namespace cage
 			safeWrite("\n");
 		}
 
-		void crashHandler(int sig, siginfo_t *si, void *uctx)
+		void performPreviousHandler(int sig, siginfo_t *si, void *uctx)
 		{
-			safeWrite(Stringizer() + "signal handler: " + sigToStr(sig) + " (" + sig + ")\n");
-
-			if (si)
-				safeWrite(Stringizer() + "fault addr: " + (uintptr_t)si->si_addr + ", code: " + si->si_code + "\n");
-
-			safeWrite(Stringizer() + "in thread: " + currentThreadName() + "\n");
-			printStackTrace();
-
 			if (struct sigaction *prev = prevHandler(sig))
 			{
 				safeWrite("calling previous handler\n");
 				if (prev->sa_flags & SA_SIGINFO)
-				{
-					// previous handler expects 3 arguments
 					prev->sa_sigaction(sig, si, uctx);
-				}
 				else if (prev->sa_handler == SIG_DFL || prev->sa_handler == SIG_IGN)
 				{
-					// default or ignore: you can reset signal to default and raise
 					signal(sig, prev->sa_handler);
 					raise(sig);
 				}
 				else
-				{
-					// simple handler with 1 argument
 					prev->sa_handler(sig);
-				}
 			}
 			else
 			{
@@ -140,10 +130,27 @@ namespace cage
 			}
 		}
 
+		void crashHandler(int sig, siginfo_t *si, void *uctx)
+		{
+			safeWrite(Stringizer() + "signal handler: " + sigToStr(sig) + " (" + sig + ")\n");
+			if (si)
+				safeWrite(Stringizer() + "fault addr: " + (uintptr_t)si->si_addr + ", code: " + si->si_code + "\n");
+			safeWrite(Stringizer() + "in thread: " + currentThreadName() + "\n");
+			printStackTrace();
+			performPreviousHandler(sig, si, uctx);
+		}
+
+		void intHandler(int sig, siginfo_t *si, void *uctx)
+		{
+			safeWrite(Stringizer() + "signal handler: " + sigToStr(sig) + " (" + sig + ")\n");
+			performPreviousHandler(sig, si, uctx);
+		}
+
+		template<auto Handler>
 		void installHandler(int sig)
 		{
 			struct sigaction sa = {};
-			sa.sa_sigaction = &crashHandler;
+			sa.sa_sigaction = Handler;
 			sigemptyset(&sa.sa_mask);
 			sa.sa_flags = SA_SIGINFO | SA_ONSTACK;
 			if (sigaction(sig, &sa, prevHandler(sig)) != 0)
@@ -157,10 +164,11 @@ namespace cage
 		{
 			SetupHandlers()
 			{
-				crashHandlerInstallAltStack();
-				int signals[] = { SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, SIGTRAP };
-				for (int s : signals)
-					installHandler(s);
+				crashHandlerThreadInit();
+				for (int s : { SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, SIGTRAP })
+					installHandler<&crashHandler>(s);
+				for (int s : { SIGTERM, SIGINT })
+					installHandler<&intHandler>(s);
 			}
 		} setupHandlers;
 	}
diff --git a/sources/libcore/errors/crashHandlerMacos.cpp b/sources/libcore/errors/crashHandlerMacos.cpp
@@ -0,0 +1,21 @@
+#ifdef CAGE_SYSTEM_MAC
+
+	#include <cage-core/core.h>
+
+namespace cage
+{
+	void crashHandlerThreadInit()
+	{
+		// nothing for now
+	}
+
+	namespace
+	{
+		struct SetupHandlers
+		{
+			SetupHandlers() { crashHandlerThreadInit(); }
+		} setupHandlers;
+	}
+}
+
+#endif // CAGE_SYSTEM_MAC
diff --git a/sources/libcore/errors/crashHandlerWindows.cpp b/sources/libcore/errors/crashHandlerWindows.cpp
@@ -1,7 +1,6 @@
 #ifdef CAGE_SYSTEM_WINDOWS
 
-	#include <mutex>
-	#include "windowsMinimumInclude.h"
+	#include "../windowsMinimumInclude.h"
 	#include <DbgHelp.h>
 
 	#pragma comment(lib, "DbgHelp.lib")
@@ -10,9 +9,17 @@
 	#define EXCEPTION_RENAME_THREAD 0x406D1388
 
 	#include <cage-core/core.h>
+	#include <cage-core/concurrent.h>
 
 namespace cage
 {
+	void crashHandlerThreadInit()
+	{
+		// reserve safe memory on the stack for handling EXCEPTION_STACK_OVERFLOW
+		ULONG v = 128 * 1024;
+		SetThreadStackGuarantee(&v);
+	}
+
 	namespace
 	{
 		String exceptionCodeToString(uint64 code)
@@ -112,6 +119,25 @@ namespace cage
 			}
 		}
 
+		String consoleCodeToString(uint64 code)
+		{
+			switch (code)
+			{
+				case CTRL_C_EVENT:
+					return "CTRL_C_EVENT";
+				case CTRL_BREAK_EVENT:
+					return "CTRL_BREAK_EVENT";
+				case CTRL_CLOSE_EVENT:
+					return "CTRL_CLOSE_EVENT";
+				case CTRL_LOGOFF_EVENT:
+					return "CTRL_LOGOFF_EVENT";
+				case CTRL_SHUTDOWN_EVENT:
+					return "CTRL_SHUTDOWN_EVENT";
+				default:
+					return Stringizer() + "unknown console code: " + code;
+			}
+		}
+
 		bool ignoredExceptionCodes(uint64 code)
 		{
 			switch (code)
@@ -200,12 +226,17 @@ namespace cage
 			}
 		}
 
+		RecursiveMutex *handlerMutex()
+		{
+			static Holder<RecursiveMutex> *mut = new Holder<RecursiveMutex>(newRecursiveMutex()); // this leak is intentional
+			return +*mut;
+		}
+
 		void commonHandler(PEXCEPTION_POINTERS ex)
 		{
 			if (IsDebuggerPresent())
 				return;
-			static std::mutex mutex;
-			std::scoped_lock lock(mutex);
+			ScopeLock lock(handlerMutex());
 			CAGE_LOG(SeverityEnum::Error, "crash-handler", Stringizer() + "crash handler: " + exceptionCodeToString(ex->ExceptionRecord->ExceptionCode));
 			if (ex->ExceptionRecord->ExceptionCode == EXCEPTION_DOTNET)
 				return;
@@ -221,6 +252,7 @@ namespace cage
 				for (uint32 i = 0; i < ex->ExceptionRecord->NumberParameters; i++)
 					CAGE_LOG(SeverityEnum::Info, "crash-handler", Stringizer() + "parameter[" + i + "]: " + ex->ExceptionRecord->ExceptionInformation);
 			}
+			CAGE_LOG(SeverityEnum::Info, "crash-handler", Stringizer() + "in thread: " + currentThreadName());
 			printStackTrace(ex);
 		}
 
@@ -241,13 +273,25 @@ namespace cage
 			return EXCEPTION_CONTINUE_SEARCH;
 		}
 
+		BOOL WINAPI consoleHandler(DWORD code)
+		{
+			CAGE_LOG(SeverityEnum::Error, "crash-handler", Stringizer() + "crash handler: " + consoleCodeToString(code));
+			return FALSE; // let other handlers process it
+		}
+
 		struct SetupHandlers
 		{
 			SetupHandlers()
 			{
-				AddVectoredExceptionHandler(1, &vectoredHandler);
-				AddVectoredContinueHandler(1, &vectoredHandler);
+				handlerMutex(); // allocate the mutex upfront
+				crashHandlerThreadInit();
+				if (!AddVectoredExceptionHandler(1, &vectoredHandler))
+					CAGE_THROW_ERROR(SystemError, "AddVectoredExceptionHandler", GetLastError());
+				if (!AddVectoredContinueHandler(1, &vectoredHandler))
+					CAGE_THROW_ERROR(SystemError, "AddVectoredContinueHandler", GetLastError());
 				previous = SetUnhandledExceptionFilter(&unhandledHandler);
+				if (!SetConsoleCtrlHandler(&consoleHandler, TRUE))
+					CAGE_THROW_ERROR(SystemError, "SetConsoleCtrlHandler", GetLastError());
 			}
 		} setupHandlers;
 	}
diff --git a/sources/libcore/errors/debug.cpp b/sources/libcore/errors/debug.cpp
@@ -23,7 +23,7 @@ static_assert(CAGE_DEBUG_BOOL == false);
 #include <string> // std::getline
 
 #ifdef CAGE_SYSTEM_WINDOWS
-	#include "windowsMinimumInclude.h"
+	#include "../windowsMinimumInclude.h"
 	#include <intrin.h> // __debugbreak
 #endif
 
diff --git a/sources/libcore/errors/exception.cpp b/sources/libcore/errors/exception.cpp

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,15 @@ extern "C"`
`27`	`27`	`{`
`28`	`28`	`CAGE_API_EXPORT DWORD WINAPI CageRemoteThreadEntryPointToRaiseSignalTerm(_In_ LPVOID)`
`29`	`29`	`{`
	`30`	`+ try`
	`31`	`+ {`
	`32`	`+ using namespace cage;`
	`33`	`+ CAGE_LOG(SeverityEnum::Warning, "process", "raising SIGTERM");`
	`34`	`+ }`
	`35`	`+ catch (...)`
	`36`	`+ {`
	`37`	`+ // nothing`
	`38`	`+ }`
`30`	`39`	`raise(SIGTERM);`
`31`	`40`	`return 0;`
`32`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,8 +19,10 @@ namespace cage`
`19`	`19`
`20`	`20`	`int crashHandlerLogFileFd = STDERR_FILENO;`
`21`	`21`
`22`		`- void crashHandlerInstallAltStack()`
	`22`	`+ void crashHandlerThreadInit()`
`23`	`23`	`{`
	`24`	`+ // install alternative stack memory for handling signals`
	`25`	`+`
`24`	`26`	`static constexpr size_t AltStackSize = 128 * 1024; // bigger than SIGSTKSZ for safety`
`25`	`27`
`26`	`28`	`{`
`@@ -43,18 +45,19 @@ namespace cage`
`43`	`45`	`if (sigaltstack(&ss, nullptr) != 0)`
`44`	`46`	`{`
`45`	`47`	`CAGE_LOG(SeverityEnum::Note, "crash-handler", strerror(errno));`
`46`		`- CAGE_LOG(SeverityEnum::Warning, "crash-handler", "failed to install alt stack");`
	`48`	`+ CAGE_LOG(SeverityEnum::Warning, "crash-handler", "failed to install thread alt stack");`
	`49`	`+ // most signals can be handled on regular stack memory, so we continue`
`47`	`50`	`}`
`48`	`51`	`}`
`49`	`52`
`50`	`53`	`namespace`
`51`	`54`	`{`
`52`		`- constexpr int OldHandlersCount = 16;`
`53`		`- struct sigaction prevHandlers[OldHandlersCount] = {};`
	`55`	`+ constexpr int PrevHandlersCount = 16;`
	`56`	`+ struct sigaction prevHandlers[PrevHandlersCount] = {};`
`54`	`57`
`55`	`58`	`struct sigaction *prevHandler(int sig)`
`56`	`59`	`{`
`57`		`- if (sig >= 0 && sig < OldHandlersCount)`
	`60`	`+ if (sig >= 0 && sig < PrevHandlersCount)`
`58`	`61`	`return &prevHandlers[sig];`
`59`	`62`	`return nullptr;`
`60`	`63`	`}`
`@@ -77,6 +80,8 @@ namespace cage`
`77`	`80`	`return "SIGTRAP";`
`78`	`81`	`case SIGTERM:`
`79`	`82`	`return "SIGTERM";`
	`83`	`+ case SIGINT:`
	`84`	`+ return "SIGINT";`
`80`	`85`	`default:`
`81`	`86`	`return "UNKNOWN";`
`82`	`87`	`}`
`@@ -102,35 +107,20 @@ namespace cage`
`102`	`107`	`safeWrite("\n");`
`103`	`108`	`}`
`104`	`109`
`105`		`- void crashHandler(int sig, siginfo_t si, void uctx)`
	`110`	`+ void performPreviousHandler(int sig, siginfo_t si, void uctx)`
`106`	`111`	`{`
`107`		`- safeWrite(Stringizer() + "signal handler: " + sigToStr(sig) + " (" + sig + ")\n");`
`108`		`-`
`109`		`- if (si)`
`110`		`- safeWrite(Stringizer() + "fault addr: " + (uintptr_t)si->si_addr + ", code: " + si->si_code + "\n");`
`111`		`-`
`112`		`- safeWrite(Stringizer() + "in thread: " + currentThreadName() + "\n");`
`113`		`- printStackTrace();`
`114`		`-`
`115`	`112`	`if (struct sigaction *prev = prevHandler(sig))`
`116`	`113`	`{`
`117`	`114`	`safeWrite("calling previous handler\n");`
`118`	`115`	`if (prev->sa_flags & SA_SIGINFO)`
`119`		`- {`
`120`		`- // previous handler expects 3 arguments`
`121`	`116`	`prev->sa_sigaction(sig, si, uctx);`
`122`		`- }`
`123`	`117`	`else if (prev->sa_handler == SIG_DFL \|\| prev->sa_handler == SIG_IGN)`
`124`	`118`	`{`
`125`		`- // default or ignore: you can reset signal to default and raise`
`126`	`119`	`signal(sig, prev->sa_handler);`
`127`	`120`	`raise(sig);`
`128`	`121`	`}`
`129`	`122`	`else`
`130`		`- {`
`131`		`- // simple handler with 1 argument`
`132`	`123`	`prev->sa_handler(sig);`
`133`		`- }`
`134`	`124`	`}`
`135`	`125`	`else`
`136`	`126`	`{`
`@@ -140,10 +130,27 @@ namespace cage`
`140`	`130`	`}`
`141`	`131`	`}`
`142`	`132`
	`133`	`+ void crashHandler(int sig, siginfo_t si, void uctx)`
	`134`	`+ {`
	`135`	`+ safeWrite(Stringizer() + "signal handler: " + sigToStr(sig) + " (" + sig + ")\n");`
	`136`	`+ if (si)`
	`137`	`+ safeWrite(Stringizer() + "fault addr: " + (uintptr_t)si->si_addr + ", code: " + si->si_code + "\n");`
	`138`	`+ safeWrite(Stringizer() + "in thread: " + currentThreadName() + "\n");`
	`139`	`+ printStackTrace();`
	`140`	`+ performPreviousHandler(sig, si, uctx);`
	`141`	`+ }`
	`142`	`+`
	`143`	`+ void intHandler(int sig, siginfo_t si, void uctx)`
	`144`	`+ {`
	`145`	`+ safeWrite(Stringizer() + "signal handler: " + sigToStr(sig) + " (" + sig + ")\n");`
	`146`	`+ performPreviousHandler(sig, si, uctx);`
	`147`	`+ }`
	`148`	`+`
	`149`	`+ template<auto Handler>`
`143`	`150`	`void installHandler(int sig)`
`144`	`151`	`{`
`145`	`152`	`struct sigaction sa = {};`
`146`		`- sa.sa_sigaction = &crashHandler;`
	`153`	`+ sa.sa_sigaction = Handler;`
`147`	`154`	`sigemptyset(&sa.sa_mask);`
`148`	`155`	`sa.sa_flags = SA_SIGINFO \| SA_ONSTACK;`
`149`	`156`	`if (sigaction(sig, &sa, prevHandler(sig)) != 0)`
`@@ -157,10 +164,11 @@ namespace cage`
`157`	`164`	`{`
`158`	`165`	`SetupHandlers()`
`159`	`166`	`{`
`160`		`- crashHandlerInstallAltStack();`
`161`		`- int signals[] = { SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, SIGTRAP };`
`162`		`- for (int s : signals)`
`163`		`- installHandler(s);`
	`167`	`+ crashHandlerThreadInit();`
	`168`	`+ for (int s : { SIGSEGV, SIGABRT, SIGFPE, SIGILL, SIGBUS, SIGTRAP })`
	`169`	`+ installHandler<&crashHandler>(s);`
	`170`	`+ for (int s : { SIGTERM, SIGINT })`
	`171`	`+ installHandler<&intHandler>(s);`
`164`	`172`	`}`
`165`	`173`	`} setupHandlers;`
`166`	`174`	`}`