ARM架构Linux多线程程序正常退出时如何获取全线程回溯？

一、在程序代码中主动注入回溯逻辑 #

这是不受GDB架构限制的可靠方案，直接在代码层面实现退出时的回溯收集：

• 注册全局退出回调：用atexit()或on_exit()注册退出处理函数，触发全线程回溯收集。注意atexit默认仅在主线程执行，需手动枚举所有线程。
• 枚举线程并触发回溯：
  1. 遍历/proc/self/task/目录下的子目录（每个子目录对应一个线程ID），获取所有线程的TID。
  2. 通过pthread_kill()给每个线程发送SIGUSR1信号，在信号处理函数中调用backtrace()生成当前线程的回溯地址。
  3. 由于backtrace_symbols()不是异步信号安全函数，先将回溯地址存入全局缓冲区，待所有线程完成回溯后，在主线程的退出回调中统一转换为可读符号。

示例代码片段：

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <pthread.h>
#include <unistd.h>
#include <execinfo.h>
#include <dirent.h>

#define MAX_BACKTRACE_FRAMES 32
#define MAX_THREADS 64

typedef struct {
    pthread_t tid;
    void* frames[MAX_BACKTRACE_FRAMES];
    int frame_count;
} ThreadBacktrace;

ThreadBacktrace thread_traces[MAX_THREADS];
int trace_count = 0;
pthread_mutex_t trace_mutex = PTHREAD_MUTEX_INITIALIZER;

void sigusr1_handler(int sig) {
    ThreadBacktrace* trace = NULL;
    pthread_t self = pthread_self();

    pthread_mutex_lock(&trace_mutex);
    for (int i = 0; i < trace_count; i++) {
        if (pthread_equal(thread_traces[i].tid, self)) {
            trace = &thread_traces[i];
            break;
        }
    }
    pthread_mutex_unlock(&trace_mutex);

    if (trace) {
        trace->frame_count = backtrace(trace->frames, MAX_BACKTRACE_FRAMES);
    }
}

void collect_all_thread_backtraces() {
    struct sigaction sa;
    sa.sa_handler = sigusr1_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    sigaction(SIGUSR1, &sa, NULL);

    DIR* dir = opendir("/proc/self/task");
    if (!dir) return;

    struct dirent* entry;
    pthread_mutex_lock(&trace_mutex);
    trace_count = 0;

    while ((entry = readdir(dir)) != NULL && trace_count < MAX_THREADS) {
        if (entry->d_type == DT_DIR && atoi(entry->d_name) > 0) {
            thread_traces[trace_count].tid = (pthread_t)atoi(entry->d_name);
            thread_traces[trace_count].frame_count = 0;
            trace_count++;
        }
    }
    pthread_mutex_unlock(&trace_mutex);
    closedir(dir);

    for (int i = 0; i < trace_count; i++) {
        pthread_kill(thread_traces[i].tid, SIGUSR1);
    }

    usleep(100000);

    pthread_mutex_lock(&trace_mutex);
    for (int i = 0; i < trace_count; i++) {
        printf("Thread %lu backtrace:\n", (unsigned long)thread_traces[i].tid);
        char** symbols = backtrace_symbols(thread_traces[i].frames, thread_traces[i].frame_count);
        if (symbols) {
            for (int j = 0; j < thread_traces[i].frame_count; j++) {
                printf("  %s\n", symbols[j]);
            }
            free(symbols);
        }
    }
    pthread_mutex_unlock(&trace_mutex);
}

void exit_handler() {
    collect_all_thread_backtraces();
}

int main() {
    atexit(exit_handler);

    // 此处添加你的多线程业务逻辑

    return 0;
}

编译时需添加参数保留符号表：
gcc -o app app.c -rdynamic -pthread

二、优化GDB断点设置方案 #

你之前设置exit/_exit断点失败，可尝试以下调整：

• 针对动态链接的程序，直接断点glibc的退出处理入口函数__run_exit_handlers，这个函数会在所有退出处理逻辑执行前触发：

  (gdb) b __run_exit_handlers
  

• 断点命中后，用GDB命令自动遍历所有线程打印回溯：

  (gdb) thread apply all bt
  

• 也可编写GDB脚本自动化操作，保存为bt_on_exit.gdb：

  set pagination off
  b __run_exit_handlers
  command
    thread apply all bt
    continue
  end
  

  启动程序时加载脚本：
  gdb --command=bt_on_exit.gdb ./app

三、系统工具组合方案 #

用strace监控多线程程序退出时必调用的exit_group系统调用，捕获到后立即用GDB附加进程获取回溯：

# 后台启动strace监控目标进程
strace -e exit_group -p <进程PID> &
# 当strace输出exit_group调用时，立即执行GDB命令
gdb -p <进程PID> -ex "thread apply all bt" -ex "quit"

可编写shell脚本自动化这个流程，监控strace的输出日志，一旦检测到exit_group就自动触发GDB命令。

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