Question

我有一个大型程序需要尽可能具有弹性，并且拥有大量线程。我需要捕获所有信号SIGBUS SIGSEGV，并在必要时重新初始化问题线程，或禁用线程以继续减少功能。

我的第一个想法是做一个setjump，然后设置信号处理程序，可以记录问题，然后执行longjump回到线程中的恢复点。有一个问题是信号处理程序需要确定信号来自哪个线程，使用适当的跳转缓冲区作为跳回到错误的线程将是无用的。

有没有人知道如何确定信号处理程序中的违规线程？

Answer 1

我将假设您已经考虑过这一点，并且有充分的理由相信您的程序会因为在SIGSEGV之后重试而更多更具弹性 - 请记住，段错误突出了悬挂指针和其他滥用行为的问题，这些行为也可能破坏流程地址空间中不可预测的位置，而不会产生分裂。

由于您已经非常仔细地考虑了这一点，并且您已经（以某种方式）确定应用程序段错误的特定方式无法掩盖用于取消和重新启动线程的记帐数据的损坏，以及你对这些线程有完美的取消逻辑（也非常罕见），让我们继续解决这个问题。

Linux上的SIGSEGV处理程序在失败指令（man 7信号）的线程中执行。我们无法调用pthread_self（），因为它不是异步信号安全，但互联网似乎同意syscall（man 2系统调用）是安全的，所以我们可以通过syscall SYS_gettid获取线程ID。因此，我们要保持pthread_t（pthread_self）到pid＆＃39; s（gettid（））的映射。由于write（）也是安全的，我们可以捕获SEGV，将当前线程ID写入管道，然后暂停直到pthread_cancel终止我们。

我们还需要一个监视器线程，以便在事物变成梨形时留意。监视器线程监视管道的读取端以获取有关已终止线程的信息，并可以重新启动它。

因为我认为假装处理SIGSEGV是愚蠢的，所以我打算调用这里的结构daft_thread_t等等，someone_please_fix_me代表你破坏的代码。监视器线程是main（）。当线程发生段错误时，它被信号处理程序捕获，将其ID写入管道;监视器读取管道，使用pthread_cancel和pthread_join取消线程，然后重新启动它。

#include <assert.h>
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/syscall.h>

#define MAX_DAFT_THREADS (1024) // arbitrary

#define CHECK_OSCALL(call, onfail) { \
    if ((call) == -1) { \
        char buf[512]; \
        strerror_r(errno, buf, sizeof(buf)); \
        fprintf(stderr, "%s@%d failed: %s\n", __FILE__, __LINE__, buf); \
        onfail; \
    } \
}

/*********************** daft thread accounting *****************/
typedef void* (*threadproc_t)(void* arg);

struct daft_thread_t {
    threadproc_t start_routine;
    void* start_routine_arg;
    pthread_t pthread;
    pid_t tid;
};

struct daft_thread_accounting_info_t {
    int monitor_pipe[2];
    pthread_mutex_t info_lock;
    size_t daft_thread_count;
    struct daft_thread_t daft_threads[MAX_DAFT_THREADS];
};

static struct daft_thread_accounting_info_t g_thread_accounting;

void daft_thread_accounting_info_init(struct daft_thread_accounting_info_t* inf)
{
    memset(inf, 0, sizeof(*inf));
    pthread_mutex_init(&inf->info_lock, NULL);
    CHECK_OSCALL(pipe(inf->monitor_pipe), abort());
}

struct daft_thread_wrapper_data_t {
    struct daft_thread_t* thread_info;
};

static void* daft_thread_wrapper(void* arg)
{
    struct daft_thread_t* wrapper = arg;
    wrapper->tid = gettid();
    return (*wrapper->start_routine)(wrapper->start_routine_arg);
}

static void start_daft_thread(threadproc_t proc, void* arg)
{
    struct daft_thread_t*  info;
    pthread_mutex_lock(&g_thread_accounting.info_lock);
    assert (g_thread_accounting.daft_thread_count < MAX_DAFT_THREADS);
    info = &g_thread_accounting.daft_threads[g_thread_accounting.daft_thread_count++];
    pthread_mutex_unlock(&g_thread_accounting.info_lock);
    info->start_routine = proc;
    info->start_routine_arg = arg;
    CHECK_OSCALL(pthread_create(&info->pthread, NULL, daft_thread_wrapper, info), abort());
}

static struct daft_thread_t* find_thread_by_tid(pid_t thread_id)
{
    int k;
    struct daft_thread_t* info = NULL;
    pthread_mutex_lock(&g_thread_accounting.info_lock);
    for (k = 0; k < g_thread_accounting.daft_thread_count; ++k) {
        if (g_thread_accounting.daft_threads[k].tid == thread_id) {
            info = &g_thread_accounting.daft_threads[k];
            break;
        }
    }
    pthread_mutex_unlock(&g_thread_accounting.info_lock);
    return info;
}

static void restart_daft_thread(struct daft_thread_t* info)
{
    void* unused;
    CHECK_OSCALL(pthread_cancel(info->pthread), abort());
    CHECK_OSCALL(pthread_join(info->pthread, &unused), abort());
    info->tid = 0;
    CHECK_OSCALL(pthread_create(&info->pthread, NULL, daft_thread_wrapper, info), abort());
}

/************* signal handling stuff **************/
struct sigdeath_notify_info {
    int signum;
    pid_t tid;
};

static void sigdeath_handler(int signum, siginfo_t* info, void* ctx)
{
    int z;
    struct sigdeath_notify_info inf = {
        .signum = signum,
        .tid = gettid()
    };
    z = write(g_thread_accounting.monitor_pipe[1], &inf, sizeof(inf));
    assert (z == sizeof(inf)); // or else SIGABRT. Are we handling that too? Hope     not.
    pause(); // returning doesn't do us any good.
}

static void register_signal_handlers()
{
    struct sigaction sa = {};
    sa.sa_sigaction = sigdeath_handler;
    sa.sa_flags = SA_SIGINFO;
    CHECK_OSCALL(sigaction(SIGSEGV, &sa, NULL), abort());
    CHECK_OSCALL(sigaction(SIGBUS, &sa, NULL), abort());
}

pid_t gettid() { return (pid_t) syscall(SYS_gettid); }

/** This is the code that segfaults randomly. Kwality with a 'k'. */
static void* someone_please_fix_me(void* arg)
{
    char* i_think_this_address_looks_nice = (char*) 42;
    sleep(1 + rand() % 200);
    i_think_this_address_looks_nice[0] = 'q'; // ugh
    return NULL;
}

// main() will serve as the monitor thread here
int main()
{
    int k;
    struct sigdeath_notify_info death;
    daft_thread_accounting_info_init(&g_thread_accounting);
    register_signal_handlers();
    for (k = 0; k < 200; ++k) {
        start_daft_thread(someone_please_fix_me, (void*) k);
    }
    while (read(g_thread_accounting.monitor_pipe[0], &death, sizeof(death)) == sizeof(death)) {
        struct daft_thread_t* info = find_thread_by_tid(death.tid);
        if (info == NULL) {
            fprintf(stderr, "*** thread_id %u not found\n", death.tid);
            continue;
        }
        fprintf(stderr, "Thread %u (%d) died of %d, restarting.\n",
            death.tid, (int) info->start_routine_arg, death.signum);
        restart_daft_thread(info);
    }
    fprintf(stderr, "Shouldn't get here.\n");
    return 0;
}

如果你没有想过：试图从SIGSEGV中恢复是非常危险的 - 我强烈反对它。线程共享一个地址空间。 segfaulted的线程也可能损坏了其他线程数据或全局会计数据，例如malloc（）的会计。一种更安全的方法 - 假设失败的代码无法修复但必须使用 - 是隔离进程边界后面的失败代码，例如在调用损坏的代码之前通过fork（）。然后，您必须陷入SIGCLD并处理崩溃或正常终止的过程，以及其他一些陷阱，但至少您不必担心随机损坏。当然，最好的选择是修复血腥代码，这样你就不会观察到段错误了。

Answer 2

在我的Linux机上使用syscall(SYS_gettid)对我有用：gcc pt.c -lpthread -Wall -Wextra

//pt.c
#define _GNU_SOURCE
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <setjmp.h>
#include <signal.h>
#include <string.h>
#include <ucontext.h>
#include <stdlib.h>

static sigjmp_buf jmpbuf[65536];

static void handler(int sig, siginfo_t *siginfo, void *context)
{
    //ucontext_t *ucontext = context;
    pid_t tid = syscall(SYS_gettid);

    printf("Thread %d in handler, signal %d\n", tid, sig);
    siglongjmp(jmpbuf[tid], 1);
}

static void *threadfunc(void *data)
{
    int index, segvindex = *(int *)data;
    pid_t tid = syscall(SYS_gettid);

    for(index = 0; index < 500; index++) {
        if (sigsetjmp(jmpbuf[tid], 1) == 1) {
            printf("Recovery of thread %d\n", tid); 
            continue;
        }
        printf("Thread %d, index %d\n", tid, index);
        if (index % 5 == segvindex) {
            printf("%zu\n", strlen((char *)2)); // SIGSEGV
        }
        pthread_yield();
    }
    return NULL;
}

int main(void)
{
    pthread_t thread1, thread2, thread3;
    int segvindex1 = rand() % 5;
    int segvindex2 = rand() % 5;
    int segvindex3 = rand() % 5;
    struct sigaction sact;

    memset(&sact, 0, sizeof sact);
    sact.sa_sigaction = handler;
    sact.sa_flags = SA_SIGINFO;
    if (sigaction(SIGSEGV, &sact, NULL) < 0) {
        perror("sigaction");
        return 1;
    }
    pthread_create(&thread1, NULL, &threadfunc, (void *) &segvindex1);
    pthread_create(&thread2, NULL, &threadfunc, (void *) &segvindex2);
    pthread_create(&thread3, NULL, &threadfunc, (void *) &segvindex3);
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    pthread_join(thread3, NULL);
    return 0;
}

可以使用更加便携pthread_self。它是异步信号安全的。

但获得SIGSEGV的线程应该通过异步信号安全方式启动一个新线程，不应该执行siglongjmp因为它可能导致调用非异步信号 - 安全功能。

Answer 3

根据我的经验，当一个线程程序接收到一个同步信号时 - 即一个由程序执行的操作产生的信号，例如解除引用错误的指针 - 导致该问题的线程接收到该信号。

我使用了一个明确保证这种行为的系统，但我不知道它是否一般。当然，如果有问题的线程阻塞了信号，就像在一个线程处理所有信号的范例中那样，可能它将进入信号处理线程。

在多线程环境中捕获信号

3 个答案: