BmnCoreDumpGuard.cxx

Go to the documentation of this file.

#include "BmnCoreDumpGuard.h"
 
#include <csignal>
#include <cstdlib>
#include <cstring>
 
#ifdef __linux__
#include <pthread.h>
#include <sys/prctl.h>
#endif
 
// signals whose default action is to terminate the process and to write a core dump.
// In practice BmnRoot dies from SIGABRT: abort() is called by glibc when the heap is corrupted
// ("double free or corruption"), by a failed assert() and by std::terminate() for an uncaught exception.
// SIGSEGV and the others are intercepted by ROOT itself (see 'Root.ErrorHandlers' in system.rootrc), which prints the
// stack trace and exits without dumping the core
static const int gFatalSignals[] = {SIGABRT, SIGSEGV, SIGBUS, SIGFPE, SIGILL};
static const int gFatalSignalCount = sizeof(gFatalSignals) / sizeof(gFatalSignals[0]);
 
// actions replaced by Install(), they are called by the guard and restored by Uninstall()
static struct sigaction gPreviousActions[gFatalSignalCount];
static bool gIsSignalGuarded[gFatalSignalCount];
// whether the guard is already processing a fatal signal (the previous handler may raise the signal once again)
static volatile sig_atomic_t gIsHandlingSignal = 0;
 
// get index of the signal in the gFatalSignals array; return -1 if not found
static int GetFatalSignalIndex(int signalNumber)
{
    for (int i = 0; i < gFatalSignalCount; i++)
        if (gFatalSignals[i] == signalNumber)
            return i;
 
    return -1;
}
 
static void BmnFatalSignalHandler(int signalNumber, siginfo_t* signalInfo, void* signalContext)
{
#ifdef __linux__
    // the kernel does not dump a process marked as non-dumpable. In contrast to 'ulimit -c 0' this works also when
    // /proc/sys/kernel/core_pattern pipes the dump to a helper program (apport on Ubuntu, abrt-hook-ccpp on CentOS 7
    // and AlmaLinux 9): for a pipe pattern the kernel ignores the RLIMIT_CORE limit and calls the helper anyway
    prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
#endif
 
    // let the replaced handler do its job (it can print the stack trace and terminate the process by itself),
    // but only once, otherwise a handler raising the same signal again would call the guard recursively
    int signalIndex = GetFatalSignalIndex(signalNumber);
    if ((signalIndex >= 0) && (gIsHandlingSignal == 0)) {
        gIsHandlingSignal = 1;
 
        const struct sigaction& previousAction = gPreviousActions[signalIndex];
        if (((previousAction.sa_flags & SA_SIGINFO) != 0) && (previousAction.sa_sigaction != nullptr))
            previousAction.sa_sigaction(signalNumber, signalInfo, signalContext);
        else if ((previousAction.sa_handler != SIG_DFL) && (previousAction.sa_handler != SIG_IGN)
                 && (previousAction.sa_handler != nullptr))
            previousAction.sa_handler(signalNumber);
    }
 
    // the previous handler has returned or there was none: die from the original signal, so that the shell and the
    // batch system still get the correct termination status, but without the core dump disabled above
    struct sigaction defaultAction;
    memset(&defaultAction, 0, sizeof(defaultAction));
    defaultAction.sa_handler = SIG_DFL;
    sigemptyset(&defaultAction.sa_mask);
    sigaction(signalNumber, &defaultAction, nullptr);
 
    // the signal is blocked while its handler is running, unblock it to be killed by the raise() below
    sigset_t signalMask;
    sigemptyset(&signalMask);
    sigaddset(&signalMask, signalNumber);
    pthread_sigmask(SIG_UNBLOCK, &signalMask, nullptr);
 
    raise(signalNumber);
}
 
ClassImp(BmnCoreDumpGuard);
 
bool BmnCoreDumpGuard::fgIsInstalled = false;
 
bool BmnCoreDumpGuard::Install()
{
    if (fgIsInstalled)
        return true;
 
    // ENABLE_CORE_DUMP=1 keeps the core dumps enabled, e.g. to investigate a crash with gdb
    const char* isCoreDumpRequested = getenv("ENABLE_CORE_DUMP");
    if ((isCoreDumpRequested != nullptr) && (isCoreDumpRequested[0] != '\0') && (strcmp(isCoreDumpRequested, "0") != 0))
        return false;
 
    struct sigaction guardAction;
    memset(&guardAction, 0, sizeof(guardAction));
    guardAction.sa_sigaction = BmnFatalSignalHandler;
    sigemptyset(&guardAction.sa_mask);
    guardAction.sa_flags = SA_SIGINFO;
 
    for (int i = 0; i < gFatalSignalCount; i++) {
        struct sigaction currentAction;
        if (sigaction(gFatalSignals[i], nullptr, &currentAction) != 0)
            continue;
 
        // SIGABRT is guarded in any case: it is the signal the core dumps come from, and no handler prints a stack
        // trace for it. The other signals are guarded only if nobody processes them yet, in order not to replace the
        // ROOT handler printing the stack trace
        bool isSignalProcessed = ((currentAction.sa_flags & SA_SIGINFO) != 0) || (currentAction.sa_handler != SIG_DFL);
        if ((gFatalSignals[i] != SIGABRT) && isSignalProcessed)
            continue;
 
        gPreviousActions[i] = currentAction;
        if (sigaction(gFatalSignals[i], &guardAction, nullptr) == 0) {
            gIsSignalGuarded[i] = true;
            fgIsInstalled = true;
        }
    }
 
    return fgIsInstalled;
}
 
bool BmnCoreDumpGuard::Uninstall()
{
    if (!fgIsInstalled)
        return false;
 
    for (int i = 0; i < gFatalSignalCount; i++) {
        if (!gIsSignalGuarded[i])
            continue;
 
        // restore the action which was replaced by Install()
        if (sigaction(gFatalSignals[i], &gPreviousActions[i], nullptr) == 0)
            gIsSignalGuarded[i] = false;
    }
 
    fgIsInstalled = false;
    return true;
}
 
namespace
{
// install the guard as soon as the library is loaded to cover every macro and program using BmnRoot
struct BmnCoreDumpGuardInstaller
{
    BmnCoreDumpGuardInstaller() { BmnCoreDumpGuard::Install(); }
} gBmnCoreDumpGuardInstaller;
}   // namespace