GDB对Linux信号的处理方式

前言

在软件开发过程中，调试工具是程序员不可或缺的助手。GDB（GNU Debugger）作为一个强大的调试器，广泛应用于Linux系统中的C/C++程序调试。然而，信号处理机制的复杂性常常给调试带来挑战。特别是在处理异步和同步信号时，不同的信号处理方式对程序执行流和调试工具的行为会产生显著影响。

本文旨在深入探讨GDB如何处理Linux信号，以及不同信号处理方式对调试的影响。通过具体示例和代码演示，我们将解析GDB处理信号的机制，探讨如何在信号处理函数中有效地进行调试，并提出在同步信号处理方式下使GDB能够捕获信号的解决方案。希望通过本文的学习，读者能更好地理解和掌握在实际开发中如何使用GDB调试带有复杂信号处理的程序，提高调试效率。

GDB中的信号处理方式

GDB（GNU Debugger）是一个功能强大的调试工具，能够捕获和处理被调试的程序收到的信号。当信号发送到正在被调试的程序时，GDB 可以选择不同的处理方式。

查看信号处理方式

通过在 GDB 中运行命令： info handle，可以查看 GDB 对各个信号的处理方式。例如：

(gdb) info handle
Signal        Stop      Print   Pass to program Description

SIGHUP        Yes       Yes     Yes             Hangup
SIGINT        Yes       Yes     No              Interrupt
SIGQUIT       Yes       Yes     Yes             Quit
SIGILL        Yes       Yes     Yes             Illegal instruction
SIGTRAP       Yes       Yes     No              Trace/breakpoint trap
SIGABRT       Yes       Yes     Yes             Aborted
SIGEMT        Yes       Yes     Yes             Emulation trap
SIGFPE        Yes       Yes     Yes             Arithmetic exception
SIGKILL       Yes       Yes     Yes             Killed
SIGBUS        Yes       Yes     Yes             Bus error
SIGSEGV       Yes       Yes     Yes             Segmentation fault
...省略

信号处理分析

通过info handle的结果可以看到，GDB 对信号的处理方式有三种：

（1）Stop: 暂停程序执行

（2）Print: 打印信号信息

（3）Pass to program: 传递给被调试的程序

以SIGINT（通常由 Ctrl+C 触发）为例，当收到这个信号后，GDB 会暂停程序执行并打印信号信息，但不会将 SIGINT 信号传递给程序的信号处理函数。但有特殊场景会使信号直接传给被调试程序，不被GDB截获，详见下文。

应用程序中捕获信号的方式

在应用程序中，可以通过多种方式捕获信号，包括Linux系统调用signal、sigaction、sigwait和signalfd相关系统调用。这些方法可以分为异步信号处理和同步信号处理。

异步信号处理

通过Linux系统调用signal 和 sigaction可以注册信号的处理函数，这种方式属于异步信号处理。

特点

（1）即时处理：当一个信号被发送到进程时，如果该信号没有被屏蔽，内核会很快调用相应的信号处理函数。这个过程不需要等待进程中的某个同步点或特定的代码段；

（2）不可预测性：信号处理函数可以在程序的任意位置被调用，程序无法预见信号何时会到来。

示例代码

#include <iostream>
#include <csignal>
#include <unistd.h>
void handle_signal(int sig) {
    std::cout << "Received signal " << sig << std::endl;
}
int main() {
    signal(SIGINT, handle_signal);
    while (true) {
        std::cout << "Running..." << std::endl;
        sleep(1);
    }
    return 0;
}

......省略
(gdb) r
Starting program: /root/work_dir/test_programs/test_signal/test
Running...
Running...
Running...
^C
  Program received signal SIGINT, Interrupt.
0x00007ffff71d0068 in nanosleep () from /lib64/libc.so.6
Missing separate debuginfos, use: yum debuginfo-install glibc-2.28-251.el8.x86_64 libgcc-8.5.0-21.el8.x86_64 libstdc++-8.5.0-21.el8.x86_64
(gdb) bt
#0  0x00007ffff71d0068 in nanosleep () from /lib64/libc.so.6
#1  0x00007ffff71cff9e in sleep () from /lib64/libc.so.6
#2  0x0000000000400989 in main () at test.cpp:13

在这个例子中，使用signal 捕获 SIGINT 信号。GDB先捕获到了这个信号，没有调用用户注册的信号处理函数。这时程序也没有退出，可以进行查看堆栈、打断点等调试操作，非常方便。

信号处理函数的调用时机

信号处理函数的调用时机，总结为以下几个要点：

（1）当一个信号（如 SIGINT）被发送到进程时，进程并不会立刻中断当前的执行，而是继续执行当前的指令；

（2）当进程因为系统调用、硬件中断或者其他原因进入内核态，并处理完内核态逻辑返回用户态之前，内核会检查是否有待处理的信号。检测到待处理的信号后，会查找该信号对应的处理函数，并将其上下文准备好；

（3）内核返回用户态时，执行用户注册的信号处理函数。在信号处理函数执行完毕后，进程恢复到之前的状态，继续执行被中断的代码。

当收到一个信号（如 SIGINT），处理流程示意图如下：

同步信号处理

sigwait 和 signalfd相关系统调用对信号的处理方式是同步的。

sigwait: 线程阻塞等待指定信号到达。
signalfd: 使用文件描述符同步接收信号。

特点

同步信号处理的特点主要体现在信号的处理机制和程序的控制流上。与异步信号处理不同，同步信号处理在程序的特定点等待和处理信号。以下是同步信号处理的主要特点：

1. 明确的等待和处理信号的点
   在同步信号处理机制中，程序明确地调用函数来等待和处理信号。这些函数会阻塞执行，直到指定的信号到达。这使得信号处理更可控，程序可以在预定的、安全的地方处理信号。
2. 避免了异步信号处理的不可预测性
   同步信号处理避免了异步信号处理的不确定性。异步信号处理函数可能在程序的任何位置被调用，可能会中断关键代码段。而同步信号处理只有在程序显式等待信号时才会进行处理，这减少了对程序流的干扰。
3. 更好的线程和进程控制
   同步信号处理特别适用于多线程程序。线程可以独立地等待和处理信号，不会影响其他业务线程的执行。

示例代码

#include <iostream>
#include <csignal>
#include <pthread.h>
#include <unistd.h>

void* signal_handler(void* arg) {
    sigset_t* set = (sigset_t*)arg;
    int sig;
    while (true) {
        sigwait(set, &sig);
        std::cout << "Received signal " << sig << std::endl;
    }
    return nullptr;
}

int main() {
    sigset_t set;
    pthread_t thread;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    pthread_sigmask(SIG_BLOCK, &set, nullptr);
    pthread_create(&thread, nullptr, signal_handler, (void*)&set);
    while (true) {
        sleep(1);
    }
    return 0;
}

......省略
(gdb) r
Starting program: /root/work_dir/test_programs/test_signal/test1
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib64/libthread_db.so.1".
[New Thread 0x7ffff6ea7700 (LWP 4072812)]
^CReceived signal 2
^CReceived signal 2
^CReceived signal 2

在这个例子中，使用 sigwait 捕获 SIGINT 信号。GDB 无法捕获同步信号处理中的信号，信号直接被用户代码捕获处理了，这会导致无法通过 Ctrl+C 暂停程序执行，增加调试困难。

信号捕获分析

异步信号处理：GDB 能捕获信号，调试方便。

同步信号处理：GDB 不能捕获信号，调试不便，无法通过 Ctrl+C 暂停程序。

解决同步阻塞信号处理的调试问题

由于 GDB 无法捕获同步阻塞的信号，我们可以在信号处理函数中显式调用 INT 3 汇编指令，并检查当前是否被 GDB 追踪。如果被追踪，则暂停程序，否则执行程序本身的信号处理逻辑。

示例代码

#include <iostream>
#include <fstream>
#include <csignal>
#include <pthread.h>
#include <unistd.h>
#include <sys/ptrace.h>

bool is_debugged() {
    std::ifstream status_file("/proc/self/status");
    std::string line;
    while (std::getline(status_file, line)) {
        if (line.find("TracerPid:") == 0) {
            int tracer_pid = std::stoi(line.substr(10));
            return tracer_pid != 0;
        }
    }
    return false;
}

void* signal_handler(void* arg) {
    int sig;
    while (true) {
        sigwait((sigset_t*)arg, &sig);
        if (is_debugged()) {
            asm("int $0x3"); // 如果被GDB追踪，触发断点
        } else {
            std::cout << "Received signal " << sig << std::endl;
        }
    }
    return nullptr;
}

int main() {
    sigset_t set;
    pthread_t thread;
    sigemptyset(&set);
    sigaddset(&set, SIGINT);
    pthread_sigmask(SIG_BLOCK, &set, nullptr);
    pthread_create(&thread, nullptr, signal_handler, (void*)&set);
    while (true) {
        sleep(1);
    }
    return 0;
}

代码中的is_debugged函数通过读取 /proc/self/status 文件，可以检测当前进程的 TracerPid 值。如果 TracerPid 不为零，则说明当前进程正在被调试。测试结果如下图所示：
可见，这次使用gdb进行调试时按 Ctrl+C后，程序停在了asm("int $0x3");这一行，此时就可以进行查看堆栈、打断点等调试操作了，问题得到解决。

结束语

本文详细介绍了GDB对Linux信号的处理方式，比较了异步和同步信号处理的机制，并提供了解决同步信号处理调试问题的方法。通过使用显式的 INT 3 指令，可以在调试同步信号处理的程序时使GDB能够捕获并暂停程序，提供更高效的调试体验。理解这些机制和技巧，可以显著提高程序开发和调试的效率。