Linux C语言信号处理函数的错误处理

Linux C 语言信号处理函数基础

在 Linux 环境下，C 语言提供了一系列用于信号处理的函数，这些函数允许程序对各种异步事件做出响应。信号是一种异步通知机制，用于在进程间传递特定的事件信息。常见的信号包括 SIGINT（通常由用户通过 Ctrl+C 产生）、SIGTERM（用于正常终止进程）等。

信号处理函数的基本概念

在 C 语言中，主要通过 signal 函数和 sigaction 函数来进行信号处理。signal 函数是一个较为简单的接口，其原型如下：

typedef void (*sighandler_t)(int);
sighandler_t signal(int signum, sighandler_t handler);

其中，signum 是要处理的信号编号，handler 可以是一个自定义的信号处理函数指针，也可以是 SIG_IGN（忽略该信号）或 SIG_DFL（恢复默认处理）。

而 sigaction 函数提供了更为灵活和强大的信号处理机制，其原型为：

int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);

signum 同样是信号编号，act 是一个指向 struct sigaction 结构体的指针，用于指定新的信号处理动作，oldact 则用于保存旧的信号处理动作（如果不为 NULL）。struct sigaction 结构体定义如下：

struct sigaction {
    void     (*sa_handler)(int);
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t   sa_mask;
    int        sa_flags;
    void     (*sa_restorer)(void);
};

sa_handler 是一个函数指针，用于指定信号处理函数，类似于 signal 函数中的 handler。sa_sigaction 用于处理带有附加信息的信号（当 sa_flags 中设置了 SA_SIGINFO 标志时使用）。sa_mask 是一个信号集，用于指定在信号处理函数执行期间需要阻塞的信号。sa_flags 则是一些标志位，用于指定信号处理的一些特性。

简单示例：使用 signal 函数处理 SIGINT

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

void sigint_handler(int signum) {
    printf("Received SIGINT. Exiting...\n");
    _exit(0);
}

int main() {
    if (signal(SIGINT, sigint_handler) == SIG_ERR) {
        perror("signal");
        return 1;
    }
    printf("Press Ctrl+C to exit...\n");
    while (1) {
        sleep(1);
    }
    return 0;
}

在这个示例中，我们使用 signal 函数将 SIGINT 信号的处理函数设置为 sigint_handler。当用户按下 Ctrl+C 时，程序会捕获到 SIGINT 信号并执行 sigint_handler 函数，然后退出程序。

信号处理函数中的错误处理

在实际应用中，信号处理函数的错误处理至关重要。因为信号可能在程序执行的任何时刻到达，错误处理不当可能导致程序出现不可预测的行为。

signal 函数的错误处理

signal 函数在调用失败时会返回 SIG_ERR，并设置 errno 来指示错误原因。常见的错误原因包括：

• 无效的信号编号：如果传递给 signal 函数的 signum 不是一个有效的信号编号，errno 会被设置为 EINVAL。例如：

if (signal(999, sigint_handler) == SIG_ERR) {
    if (errno == EINVAL) {
        perror("Invalid signal number");
    } else {
        perror("signal");
    }
    return 1;
}

• 权限问题：某些信号（如 SIGKILL 和 SIGSTOP）不能被捕获或忽略，尝试对这些信号调用 signal 函数会导致错误，errno 可能被设置为 EPERM。

sigaction 函数的错误处理

sigaction 函数调用失败时返回 -1，并设置 errno。常见的错误情况如下：

• 无效的信号编号：同 signal 函数，如果 signum 不是有效的信号编号，errno 被设置为 EINVAL。

struct sigaction act;
act.sa_handler = sigint_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if (sigaction(SIGINT, &act, NULL) == -1) {
    if (errno == EINVAL) {
        perror("Invalid signal number");
    } else {
        perror("sigaction");
    }
    return 1;
}

• 内存访问错误：如果 act 指针指向的内存区域无效，可能会导致 sigaction 调用失败，errno 可能被设置为 EFAULT。这通常发生在 act 是一个未初始化或已释放的指针时。

信号处理函数中的重入问题与错误处理

重入问题的概念

重入问题是指当一个函数正在执行时，该函数可能被再次调用的情况。在信号处理函数中，重入问题尤为重要，因为信号可能在程序执行的任何时刻到达。如果信号处理函数中调用了非可重入函数，可能会导致程序出现未定义行为。

可重入与非可重入函数

可重入函数是指可以被多次调用，且在多次调用之间不会相互干扰的函数。一般来说，满足以下条件的函数是可重入的：

• 不使用静态或全局变量：静态和全局变量在函数多次调用之间保持状态，如果多个调用同时修改这些变量，会导致数据竞争。
• 不调用非可重入函数：例如，printf 函数通常是非可重入的，因为它可能使用静态缓冲区来格式化输出。

非可重入函数则不满足上述条件。常见的非可重入函数包括使用静态数据结构的函数，如 asctime、gethostbyname 等。

处理重入问题的错误处理

在信号处理函数中调用非可重入函数时，应采取适当的错误处理措施。一种常见的方法是在信号处理函数中设置一个标志，然后在主程序中检查该标志并调用相应的可重入函数。例如：

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <string.h>
#include <sys/time.h>

volatile sig_atomic_t sigflag;

void sigalrm_handler(int signum) {
    sigflag = 1;
}

int main() {
    struct sigaction act;
    act.sa_handler = sigalrm_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    if (sigaction(SIGALRM, &act, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    struct itimerval itv;
    itv.it_value.tv_sec = 2;
    itv.it_value.tv_usec = 0;
    itv.it_interval.tv_sec = 2;
    itv.it_interval.tv_usec = 0;
    if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
        perror("setitimer");
        return 1;
    }

    char buf[26];
    while (1) {
        if (sigflag) {
            sigflag = 0;
            struct timeval now;
            if (gettimeofday(&now, NULL) == -1) {
                perror("gettimeofday");
                continue;
            }
            struct tm *tm_info = localtime(&now.tv_sec);
            if (tm_info == NULL) {
                perror("localtime");
                continue;
            }
            if (strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", tm_info) == 0) {
                perror("strftime");
                continue;
            }
            printf("Alarm: %s\n", buf);
        }
        sleep(1);
    }
    return 0;
}

在这个示例中，SIGALRM 信号处理函数 sigalrm_handler 只设置了一个标志 sigflag。主程序在检查到 sigflag 被设置后，调用可重入函数 gettimeofday 和 strftime 来获取并格式化时间。如果这些函数调用失败，通过 perror 进行错误处理并继续循环。

信号处理函数中的竞态条件与错误处理

竞态条件的概念

竞态条件是指当多个执行线程（在信号处理的情况下，信号处理函数和主程序可以看作不同的执行线程）访问和修改共享资源时，由于执行顺序的不确定性而导致程序出现不可预测的结果。

信号处理函数中的竞态条件示例

考虑以下代码：

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

int counter = 0;

void sigint_handler(int signum) {
    printf("Counter value: %d\n", counter);
}

int main() {
    if (signal(SIGINT, sigint_handler) == SIG_ERR) {
        perror("signal");
        return 1;
    }
    for (int i = 0; i < 1000000; i++) {
        counter++;
    }
    return 0;
}

在这个示例中，如果 SIGINT 信号在 counter++ 语句执行过程中到达，可能会导致 sigint_handler 函数打印出一个未完全更新的 counter 值，这就是一个竞态条件。

处理竞态条件的错误处理

为了避免竞态条件，可以使用信号掩码来阻塞信号。例如：

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

int counter = 0;

void sigint_handler(int signum) {
    printf("Counter value: %d\n", counter);
}

int main() {
    sigset_t block_mask, old_mask;
    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGINT);

    if (sigprocmask(SIG_BLOCK, &block_mask, &old_mask) == -1) {
        perror("sigprocmask");
        return 1;
    }

    if (signal(SIGINT, sigint_handler) == SIG_ERR) {
        perror("signal");
        return 1;
    }

    for (int i = 0; i < 1000000; i++) {
        if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {
            perror("sigprocmask");
            return 1;
        }
        counter++;
        if (sigprocmask(SIG_BLOCK, &block_mask, &old_mask) == -1) {
            perror("sigprocmask");
            return 1;
        }
    }

    if (sigprocmask(SIG_SETMASK, &old_mask, NULL) == -1) {
        perror("sigprocmask");
        return 1;
    }
    return 0;
}

在这个改进的代码中，我们使用 sigprocmask 函数在 counter++ 操作前后阻塞和解除阻塞 SIGINT 信号，从而避免了竞态条件。如果 sigprocmask 函数调用失败，通过 perror 进行错误处理。

信号处理函数与进程状态保存和恢复的错误处理

进程状态保存与恢复的重要性

当信号处理函数执行时，它会打断主程序的正常执行流程。在信号处理完成后，需要确保主程序能够正确恢复到之前的状态，包括寄存器值、内存状态等。否则，可能会导致程序出现错误。

保存和恢复进程状态的方法

一种常见的方法是使用 sigcontext 结构体（在某些系统上可用）来保存和恢复进程状态。在 sigaction 结构体的 sa_sigaction 函数中，可以获取到 sigcontext 结构体指针。例如：

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

void sigsegv_handler(int signum, siginfo_t *info, void *context) {
    printf("Received SIGSEGV\n");
    // 这里可以根据 context 结构体进行状态检查和恢复
    _exit(1);
}

int main() {
    struct sigaction act;
    act.sa_sigaction = sigsegv_handler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = SA_SIGINFO;
    if (sigaction(SIGSEGV, &act, NULL) == -1) {
        perror("sigaction");
        return 1;
    }

    int *ptr = NULL;
    *ptr = 10; // 触发 SIGSEGV
    return 0;
}

在这个示例中，SIGSEGV 信号处理函数 sigsegv_handler 通过 context 指针可以获取到进程在信号发生时的上下文信息，理论上可以用于检查和恢复进程状态。然而，实际操作较为复杂，并且不同系统的 sigcontext 结构体可能有所不同。

错误处理

在获取和操作 sigcontext 结构体时，可能会出现错误，例如结构体版本不兼容等。因此，在使用 sigcontext 相关功能时，应进行充分的错误检查。例如，在不同系统上，可能需要检查 sa_sigaction 函数指针是否有效，以及 context 指针是否为 NULL 等。如果出现错误，应通过适当的日志记录或错误提示来通知开发者。

信号处理函数在多线程环境下的错误处理

多线程环境下的信号处理特点

在多线程程序中，信号处理变得更加复杂。默认情况下，信号会发送到整个进程，但可以通过设置线程特定的信号掩码来控制哪个线程处理信号。此外，不同线程之间共享的数据在信号处理时也需要特别小心，以避免竞态条件。

线程特定的信号掩码

每个线程都可以设置自己的信号掩码，使用 pthread_sigmask 函数。其原型如下：

int pthread_sigmask(int how, const sigset_t *set, sigset_t *oldset);

how 表示操作类型，如 SIG_BLOCK（阻塞信号）、SIG_UNBLOCK（解除阻塞）等。set 是要设置的信号集，oldset 用于保存旧的信号集。

多线程信号处理的错误处理

在多线程环境下，调用 pthread_sigmask 等函数时可能会出现错误。例如，pthread_sigmask 调用失败时会返回错误码。常见的错误包括无效的 how 参数（EINVAL）、无效的信号集指针（EFAULT）等。

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

void *thread_func(void *arg) {
    sigset_t block_mask;
    sigemptyset(&block_mask);
    sigaddset(&block_mask, SIGINT);
    if (pthread_sigmask(SIG_BLOCK, &block_mask, NULL) == -1) {
        perror("pthread_sigmask");
        pthread_exit(NULL);
    }
    printf("Thread: SIGINT is blocked\n");
    while (1) {
        sleep(1);
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t tid;
    if (pthread_create(&tid, NULL, thread_func, NULL) != 0) {
        perror("pthread_create");
        return 1;
    }
    sleep(2);
    printf("Main: Sending SIGINT to the thread\n");
    if (pthread_kill(tid, SIGINT) != 0) {
        perror("pthread_kill");
        return 1;
    }
    pthread_join(tid, NULL);
    return 0;
}

在这个示例中，线程通过 pthread_sigmask 阻塞了 SIGINT 信号。如果 pthread_sigmask 调用失败，通过 perror 进行错误处理并退出线程。主程序尝试向线程发送 SIGINT 信号，如果 pthread_kill 调用失败，同样进行错误处理。

信号处理函数的调试与错误排查

调试工具与方法

在调试信号处理函数的错误时，可以使用一些工具和方法：

• GDB 调试器：GDB 可以设置断点在信号处理函数中，以便观察函数执行时的变量状态和调用栈。例如，可以使用 break <signal_handler_function> 命令设置断点在信号处理函数上。
• 日志记录：在信号处理函数中添加日志记录，例如使用 printf 或系统日志函数（如 syslog）记录关键信息，如信号编号、处理函数的进入和退出等。

常见错误排查思路

• 检查信号处理函数的注册：确保信号处理函数正确注册，检查 signal 或 sigaction 函数的返回值和 errno。
• 排查重入问题：检查信号处理函数中是否调用了非可重入函数，如果是，考虑替换为可重入函数或采用其他处理方式。
• 检查竞态条件：分析信号处理函数和主程序之间是否存在共享资源的竞争，通过添加信号掩码等方式解决。

通过合理使用调试工具和遵循排查思路，可以有效地定位和解决信号处理函数中的错误。

综上所述，在 Linux C 语言中处理信号时，深入理解并妥善处理错误是编写健壮程序的关键。从信号处理函数的基本错误处理，到重入问题、竞态条件、进程状态保存与恢复以及多线程环境下的错误处理，每个方面都需要仔细考虑。同时，掌握调试和排查错误的方法，能够帮助开发者更快地定位和修复问题，提高程序的稳定性和可靠性。