程序捕获信号时偶发冻结，求安全生成回溯的可行方案

我来帮你拆解问题根源，再给出安全生成回溯的可行方案：

问题背景 #

你实现的信号捕获逻辑多数情况正常，但偶尔会在内存分配步骤（比如char **message = backtrace_symbols(stack, size);）冻结，无法输出回溯，且不同信号类型都可能触发。你的信号处理代码如下：

static void signal_handled(int s) {
#ifdef _OPENMP
#pragma omp single
#endif
{
    g_printf("Error, signal %d:\n", s);
    const gchar *visit = _("Please report this bug to: " PACKAGE_BUGREPORT);
    switch (s) {
        case SIGSEGV:
        case SIGFPE:
        case SIGABRT:
        case SIGILL:
            g_printf(ANSI_COLOR_RED"%s\n"ANSI_COLOR_RESET, visit);
    }
#if (!defined _WIN32 && defined HAVE_EXECINFO_H)
    int i;
    void *stack[STACK_DEPTH];
    size_t size = backtrace(stack, sizeof(stack) / sizeof(void*));
    char **message = backtrace_symbols(stack, size);
    if (message != NULL && message[0] != NULL) {
        for (i = 0; i < size && message != NULL; ++i) {
            g_printf("[#%i] in %s\n", i, message[i]);
        }
        free(message);
    }
#else
    unsigned int i;
    void *stack[STACK_DEPTH];
    unsigned short size;
    SYMBOL_INFO *symbol;
    HANDLE process;
    process = GetCurrentProcess();
    SymInitialize(process, NULL, TRUE);
    size = CaptureStackBackTrace(0, sizeof(stack) / sizeof(void*), stack, NULL);
    symbol = (SYMBOL_INFO*) calloc(sizeof(SYMBOL_INFO) + 256 * sizeof(char), 1);
    symbol->MaxNameLen = 255;
    symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
    for (i = 0; i < size; i++) {
        SymFromAddr(process, (DWORD64)(stack[i]), 0, symbol);
        g_printf("[#%i]: in %s\n", i, symbol->Name);
    }
    free(symbol);
#endif
}
undo_flush();
exit(EXIT_FAILURE);
}

void signals_init() {
#ifndef _WIN32
    signal(SIGHUP, signal_handled);
    signal(SIGQUIT, signal_handled);
    signal(SIGBUS, signal_handled);
    signal(SIGINT, signal_handled);
    signal(SIGTRAP, signal_handled);
#endif
    signal(SIGABRT, signal_handled);
    signal(SIGFPE, signal_handled);
    signal(SIGSEGV, signal_handled);
    signal(SIGTERM, signal_handled);
    signal(SIGILL, signal_handled);
}

冻结的核心原因 #

问题出在信号处理函数的异步安全约束上：

信号是异步触发的，可能在程序执行的任意时刻打断正常线程，包括当正常线程正在执行malloc/free这类持有内部锁的操作时。而你的代码中调用的backtrace_symbols、calloc、甚至g_printf都不属于异步信号安全函数：

1. 内存分配死锁：当正常线程持有内存分配器的锁时，信号处理函数调用backtrace_symbols（内部会调用malloc）或calloc，会尝试再次获取同一把锁，直接导致死锁、程序冻结。
2. IO操作竞争：g_printf依赖stdio缓冲区，如果正常线程正在执行IO操作，信号处理中再次调用printf类函数会引发缓冲区竞争，导致异常或死锁。
3. OpenMP指令风险：信号处理函数中的#pragma omp single完全不符合信号安全要求，OpenMP运行时不支持异步信号场景，会引入未知竞争问题。

安全生成回溯的解决方案 #

方案1：将回溯逻辑移到正常线程上下文（最稳妥） #

信号处理函数只做最小化操作：设置全局标志，让主程序的正常流程检测标志并生成回溯。这样完全避开了异步信号的安全限制。

示例代码：

#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define STACK_DEPTH 64

static volatile sig_atomic_t crash_detected = 0;
static int crash_signal = 0;

// 异步安全的信号处理函数
static void signal_handled(int s) {
    crash_detected = 1;
    crash_signal = s;
    // 用异步安全的write输出简单提示
    const char msg_prefix[] = "Crash triggered by signal ";
    char msg_num[4];
    snprintf(msg_num, sizeof(msg_num), "%d\n", s);
    write(STDERR_FILENO, msg_prefix, sizeof(msg_prefix)-1);
    write(STDERR_FILENO, msg_num, strlen(msg_num));
}

// 在正常线程上下文生成回溯
static void generate_backtrace(int s) {
    const char *visit = "Please report this bug to: " PACKAGE_BUGREPORT;
    fprintf(stderr, "Error, signal %d:\n", s);
    switch (s) {
        case SIGSEGV:
        case SIGFPE:
        case SIGABRT:
        case SIGILL:
            fprintf(stderr, ANSI_COLOR_RED"%s\n"ANSI_COLOR_RESET, visit);
            break;
    }

#if (!defined _WIN32 && defined HAVE_EXECINFO_H)
    int i;
    void *stack[STACK_DEPTH];
    size_t size = backtrace(stack, sizeof(stack)/sizeof(void*));
    // 用backtrace_symbols_fd直接输出，避免内存分配
    backtrace_symbols_fd(stack, size, STDERR_FILENO);
#else
    unsigned int i;
    void *stack[STACK_DEPTH];
    unsigned short size;
    SYMBOL_INFO symbol_buf; // 用栈上内存替代calloc
    HANDLE process = GetCurrentProcess();
    
    // 初始化符号表（建议在程序启动时就执行一次）
    SymInitialize(process, NULL, TRUE);
    size = CaptureStackBackTrace(0, sizeof(stack)/sizeof(void*), stack, NULL);
    
    symbol_buf.MaxNameLen = 255;
    symbol_buf.SizeOfStruct = sizeof(SYMBOL_INFO);
    for (i = 0; i < size; i++) {
        SymFromAddr(process, (DWORD64)(stack[i]), 0, &symbol_buf);
        fprintf(stderr, "[#%i]: in %s\n", i, symbol_buf.Name);
    }
#endif
    undo_flush();
}

void signals_init() {
#ifndef _WIN32
    signal(SIGHUP, signal_handled);
    signal(SIGQUIT, signal_handled);
    signal(SIGBUS, signal_handled);
    signal(SIGINT, signal_handled);
    signal(SIGTRAP, signal_handled);
#endif
    signal(SIGABRT, signal_handled);
    signal(SIGFPE, signal_handled);
    signal(SIGSEGV, signal_handled);
    signal(SIGTERM, signal_handled);
    signal(SIGILL, signal_handled);
}

int main() {
    signals_init();
    
    // 主循环示例（根据你的程序结构调整）
    while (1) {
        if (crash_detected) {
            generate_backtrace(crash_signal);
            exit(EXIT_FAILURE);
        }
        // 你的正常业务逻辑
        sleep(1);
    }
}

方案2：全程使用异步信号安全函数（仅限简单场景） #

如果必须在信号处理中生成回溯，要严格遵循异步安全要求：

• Linux下：用backtrace_symbols_fd替代backtrace_symbols，直接将回溯写入文件描述符，无需内存分配。
• Windows下：预先在程序启动时调用SymInitialize，并使用栈上的SYMBOL_INFO结构替代calloc分配。
• 所有IO操作改用write（Linux）或WriteFile（Windows）这类异步安全的函数。

关键注意事项 #

• 永远不要在信号处理函数中调用malloc/free、printf/fprintf、线程同步函数等非异步安全函数。
• 移除信号处理函数中的OpenMP指令，OpenMP运行时不支持异步信号场景。
• 对于Windows平台，SymInitialize建议在程序启动时就执行一次，避免在信号处理中调用。

内容的提问来源于stack exchange，提问作者lock