Also restore terminal state on SIGBUS and SIGPIPE

Author: magiblot

README.md

@@ -306,7 +306,7 @@ There are a few environment variables that affect the behaviour of all Turbo Vis
     * Support for Conpty's [`win32-input-mode`](https://github.com/microsoft/terminal/blob/37b0cfd32ba0aa54e0fe50bb158154d906472a89/doc/specs/%234999%20-%20Improved%20keyboard%20handling%20in%20Conpty.md) (available in WSL).
     * Support for [far2l](https://github.com/elfmz/far2l)'s terminal extensions.
     * Support for key modifiers (via `TIOCLINUX`) and mouse (via GPM) in the Linux console.
-* Custom signal handler that restores the terminal state before the program crashes.
+* Custom signal handler that restores the terminal state before the program gets terminated or suspended by these signals: `SIGINT`, `SIGQUIT`, `SIGILL`, `SIGABRT`, `SIGBUS`, `SIGFPE`, `SIGSEGV`, `SIGPIPE`, `SIGTERM`, `SIGTSTP`.
 * When `stderr` is a tty, messages written to it are redirected to a buffer to prevent them from messing up the display and are eventually printed to the console when exiting or suspending the application.
     * The buffer used for this purpose has a limited size, so writes to `stderr` will fail once the buffer is full. If you wish to preserve all of `stderr`, just redirect it into a file from the command line with `2>`.
 

include/tvision/internal/sighandl.h

@@ -21,8 +21,8 @@ class SignalHandler
 
     enum HandledSignals
     {
-        SigInt, SigQuit, SigIll, SigAbrt, SigFpe, SigSegv, SigTerm, SigTstp,
-        HandledSignalCount
+        SigInt, SigQuit, SigIll, SigAbrt, SigBus, SigFpe, SigSegv, SigPipe,
+        SigTerm, SigTstp, HandledSignalCount
     };
 
 public:

source/platform/sighandl.cpp

@@ -9,7 +9,7 @@ namespace tvision
 
 std::atomic<SignalHandlerCallback *> SignalHandler::callback {nullptr};
 const int SignalHandler::handledSignals[HandledSignalCount] =
-    { SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGFPE, SIGSEGV, SIGTERM, SIGTSTP };
+    { SIGINT, SIGQUIT, SIGILL, SIGABRT, SIGBUS, SIGFPE, SIGSEGV, SIGPIPE, SIGTERM, SIGTSTP };
 
 static bool operator==(const struct sigaction &a, const struct sigaction &b) noexcept
 {
@@ -59,8 +59,10 @@ SignalHandler::HandlerInfo &SignalHandler::getHandlerInfo(int signo) noexcept
         case SIGQUIT:   return infos[SigQuit];
         case SIGILL:    return infos[SigIll];
         case SIGABRT:   return infos[SigAbrt];
+        case SIGBUS:    return infos[SigBus];
         case SIGFPE:    return infos[SigFpe];
         case SIGSEGV:   return infos[SigSegv];
+        case SIGPIPE:   return infos[SigPipe];
         case SIGTERM:   return infos[SigTerm];
         case SIGTSTP:   return infos[SigTstp];
         default:        abort();
@@ -78,22 +80,34 @@ void SignalHandler::handleSignal(int signo, siginfo_t *info, void *context)
     if ((callback = SignalHandler::callback) && handlerInfo.running.exchange(true) == false)
     {
         struct sigaction nextAction = handlerInfo.action;
+        // Uninstall the current action, just in case this signal gets raised
+        // again while invoking the callback.
         sigaction(signo, nullptr, &currentAction);
+        // Invoke the callback, which should be signal-safe in theory.
         callback(true);
+        // Install and invoke the action that was in place when we installed
+        // our handler.
         sigaction(signo, &nextAction, nullptr);
         if (invokeHandlerOrDefault(signo, nextAction, info, context))
+            // In some cases it is necessary to exit this handler.
             return;
+        // If the process didn't get killed, get ready to resume normal process
+        // execution.
         callback(false);
+        // Reinstall the action that was in place when this handler was invoked.
         sigaction(signo, &currentAction, nullptr);
         handlerInfo.running = false;
     }
     else
     {
-        // Just invoke the default handler.
+        // In the unexpected case where our handler was invoked even though
+        // it is already running or no callback was specified, just invoke the
+        // default handler.
         struct sigaction sa = makeDefaultAction();
         sigaction(signo, &sa, &currentAction);
         if (invokeDefault(signo, info))
             return;
+        // Reinstall the action that was in place when this handler was invoked.
         sigaction(signo, &currentAction, nullptr);
     }
 }
@@ -121,15 +135,19 @@ bool SignalHandler::invokeHandlerOrDefault( int signo, const struct sigaction &a
 
 bool SignalHandler::invokeDefault(int signo, siginfo_t *info) noexcept
 {
-    // In some cases the signal will be raised again after leaving the handler.
-    if ((signo == SIGILL || signo == SIGFPE || signo == SIGSEGV) && info->si_code > 0)
+    // Allow synchronous signals sent by the kernel to be raised again by exiting
+    // the handler. This will preserve the original stack trace, si_addr, etc.
+    if ( (signo == SIGILL || signo == SIGBUS || signo == SIGFPE || signo == SIGSEGV)
+         && info->si_code > 0 )
         return true;
     // Otherwise, raise the signal manually.
     sigset_t mask, oldMask;
     sigemptyset(&mask);
+    // Unblock this signal.
     sigaddset(&mask, signo);
     sigprocmask(SIG_UNBLOCK, &mask, &oldMask);
     raise(signo);
+    // If the process didn't get killed, restore the original mask.
     sigprocmask(SIG_SETMASK, &oldMask, nullptr);
     return false;
 }