threaddump.c

#include <signal.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include "threaddump_shared.h"
#include "threaddump.h"

#define THREADDUMP_HANDLER_THREAD_NAME "threaddump_handler_thread"

pthread_t signal_handler_thread;

static void threaddump_run_gdb_backtrace() {
    // hacky but works
    char pidbuf[32] = {0};
    pid_t parent_pid = getppid();
    snprintf(pidbuf, 32, "%d", parent_pid);
    pidbuf[31] = 0;
    const char* argv[] = {
        THREADDUMP_GDB_ATTACH(pidbuf),
        THREADDUMP_GDB_EXEC("set logging redirect on"),
        THREADDUMP_GDB_EXEC("set logging debugredirect on"),
        THREADDUMP_GDB_EXEC("set logging file td.log"),
        THREADDUMP_GDB_EXEC("set logging enabled on"),
        THREADDUMP_GDB_EXEC("thread apply all bt"),
        THREADDUMP_GDB_EXEC("quit"),
        NULL
    };
    int execv_ret = 0;
#ifdef __cplusplus
    // this ugly const_cast is needed to bypass C's old non const api
    // and to make gcc/g++ shut up
    // don't blame me
    execv_ret = execve(argv[0], const_cast<char**> (&argv[0]), NULL);
#else
    execv_ret = execve(argv[0], (char* const*) &argv[0], NULL);
#endif
    // if we return from execve, the call failed
    THREADDUMP_ERROR_ABORT("execve() failed, aborting.", execv_ret);
}

static void* threaddump_wait_and_backtrace(void* arg) {
    int sig, r;
    while (1) {
        r = sigwait((const sigset_t *) arg, &sig);
        if (r < 0) {
            THREADDUMP_ERROR_ABORT("Failed waiting on signal handler, aborting", -1);
        }
        break;
    }
    free(arg);
    pid_t pid = fork();
    if (pid == -1) {
        THREADDUMP_ERROR_ABORT("Failed forking process", pid);
    }
    if (pid == 0) {
        threaddump_run_gdb_backtrace();
    }
    wait(&pid);
    exit(sig);
}


static THREADDUMP_INIT threaddump_init(void) {
    THREADDUMP_LOG("THREADDUMP INIT\n");
    sigset_t* set = (sigset_t*) malloc(sizeof(*set));
    if (set == NULL) {
        THREADDUMP_ERROR_ABORT("Failed to malloc signal mask\n", -1);
    }

    // initialize and add SIGINT to the set of signals to handle by the signal_handler_thread
    sigemptyset(set);
    sigaddset(set, SIGINT);
    sigaddset(set, SIGTERM);

    int r = pthread_sigmask(SIG_BLOCK, set, NULL);
    if (r < 0) {
        free(set);
        THREADDUMP_ERROR_ABORT("Failed to set sigmask", -1);
    }

    r = pthread_create(&signal_handler_thread, NULL, &threaddump_wait_and_backtrace, set);
    if (r < 0) {
        free(set);
        THREADDUMP_ERROR_ABORT("Failed to create signal handling thread", -1);
    }
    THREADDUMP_LOG("CREATED SIGNAL HANDLING THREAD\n");
}

static THREADDUMP_DESTROY threaddump_destroy(void) {
    THREADDUMP_LOG("THREADDUMP DESTROY\n");
    int r = pthread_join(signal_handler_thread, NULL);
    if (r < 0) {
        THREADDUMP_ERROR_ABORT("Failed joining signal handling thread", -1);
    }
    THREADDUMP_LOG("JOINED THREAD WITH CODE %d\n", r);
}