再读APUE——聊聊信号

// kill 命令 
kill -l                  # 列出所有信号名称和编号
kill -SIGNAME PID        # 发送指定信号（如 `SIGTERM`）
kill -s SIGNAME PID      # 同上（兼容性写法）
kill -9 PID              # 强制杀死进程（SIGKILL 不可捕获）

xm@hcss-ecs-4208:~$ man 7 signal
       Signal     Value     Action   Comment
       ──────────────────────────────────────────────────────────────────────
       SIGHUP        1       Term    Hangup detected on controlling terminal
                                     or death of controlling process
       SIGINT        2       Term    Interrupt from keyboard
       SIGQUIT       3       Core    Quit from keyboard
       SIGILL        4       Core    Illegal Instruction
       ...

       #include <signal.h>

       typedef void (*sighandler_t)(int);

       sighandler_t signal(int signum, sighandler_t handler);

        // 信号处理时阻塞 & 退出信号处理时解除阻塞
       *  If the disposition is set to a function, then first either the disposition is reset to SIG_DFL, or the signal is blocked (see Portability below), and then handler is  called with argument signum.  If invocation of the handler caused the signal to be blocked, then the signal is unblocked upon return from the handler.

int main() {
    // 原程序捕获 SIGINT
    signal(SIGINT, [](int) { puts("Ignored SIGINT"); });

    // 忽略 SIGTERM
    signal(SIGTERM, SIG_IGN);

    // exec 后：
    // - 如果原程序对某个信号设置了自定义处理函数（如 SIGINT），exec 后该信号的处理方式会恢复为默认行为（SIG_DFL）。
    // - 如果原程序显式忽略了某个信号（如 SIGTERM），exec 后该信号仍会被忽略（SIG_IGN 状态保留）。
    execl("/path/to/new_program", "new_program", NULL);
}

void sig_int(int), sig_quit(int);

// 检查 SIGINT 是否被忽略，若未被忽略则绑定 handler
if (signal(SIGINT, SIG_IGN) != SIG_IGN) { 
    signal(SIGINT, sig_int);
}

// 检查 SIGQUIT 是否被忽略，若未被忽略则绑定 handler
if (signal(SIGQUIT, SIG_IGN) != SIG_IGN) {
    signal(SIGQUIT, sig_quit);
}

// 1.再解释 信号处理的几种方式
信号处理的三种状态​​
每个信号都有三种可能的处理方式：

​​默认行为（SIG_DFL）​​
    由系统预定义（如 SIGINT 默认终止进程，SIGQUIT 默认终止并生成core文件）。
​​忽略信号（SIG_IGN）​​
    明确告诉系统："这个信号来了不要做任何事"。
​​自定义处理函数​​
    程序员自己写的函数，用于响应信号。

// 2.为什么不能直接覆盖？
假设有一个守护进程（daemon）启动时做了以下操作：
signal(SIGINT, SIG_IGN);  // 显式忽略SIGINT

然后你的程序这样写：
void handler(int sig) { /*...*/ }
signal(SIGINT, handler);  // 强行覆盖SIG_IGN

// 3. 会引发什么问题
破坏系统设计意图​​
    守护进程忽略 SIGINT 是有原因的（比如防止被误杀），你的覆盖会导致它失去保护。
​​违反最小惊讶原则​​
    其他程序员或工具可能默认认为 SIGINT 是被忽略的，你的修改会引入隐蔽的Bug。

// 4. 是否只针对 sigint & sigquit
    否 针对所有信号

pause() causes the calling process (or thread) to sleep until a signal is delivered that either terminates the process or causes the invocation of a signal-catching function.

// 这段代码并不准确 但是在大多数时候都能正常工作 发生问题难以排查
int sig_int_flag = 0;  // 标志位，信号发生时设为非零

void sig_int(int signo) {  // 信号处理函数
    sig_int_flag = 1;      // 设置标志位
    signal(SIGINT, sig_int);  // 重新绑定（应对某些系统的自动重置）
}

int main() {
    signal(SIGINT, sig_int);  // 注册信号处理函数

    while (sig_int_flag == 0) {  // 等待信号触发
        pause();  // 挂起进程，直到信号到达
    }

    // 信号发生后执行的逻辑
    printf("Signal received!\n");
    return 0;
}

// 若进程收到信号且该信号未被忽略，系统调用会被​​中断​​（interrupted），立即返回错误，并设置 errno 为 EINTR（Interrupted system call）。
n = read(fd, buf, sizeof(buf));
if (n == -1 && errno == EINTR) {
    // 系统调用被信号中断
}

// static 为什么不可重入？  再次调用会复用原来的 static 变量
// 不可重入函数示例
char *strtok(char *str, const char *delim) {
    static char *last; // ← 静态变量导致重入时状态被破坏
    /* ... */
}

// 非线程安全示例
void unsafe_counter() {
    static int count = 0;
    count++; // ← 多线程同时执行会导致计数错误
}

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

// 信号处理函数必须是可重入的（可能打断正在执行的相同函数）
void handler(int sig) {
    // 这里不能用printf（非可重入），只能用write
    write(STDOUT_FILENO, "Signal!\n", 8);
}

int main() {
    signal(SIGINT, handler);
    while(1); 
}

#include <pthread.h>

int counter = 0;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

// 线程安全但不可重入（用锁保护全局变量）
void increment() {
    pthread_mutex_lock(&lock);
    counter++; // 受保护的全局状态
    pthread_mutex_unlock(&lock);
}

一、什么是可重入函数
这个函数可以“被多次调用”而不会搞乱状态。

常见于：递归、多个线程同时调用。

只要你不给它共享数据，它就不会乱。

二、什么是异步信号
程序正跑着，突然被打断（比如来了个 SIGINT 信号）。

这时跳去执行信号处理函数。

异步信号安全指的是：就算被打断了，也能安全地调用这个函数。

// 查看那些函数是异步线程安全的
 man 7 signal-safety

       An  async-signal-safe  function is one that can be safely called from within a signal handler.  Many functions are not async-signal-safe.  In particular, nonreentrant functions
       are generally unsafe to call from a signal handler.

static void my_alarm(int signo)
{
    struct passwd *rootptr;
    printf("in signal handler\n");
    if ((rootptr = getpwnam("root")) == NULL)
        err_sys("getpwnam(root) error");
    alarm(1);
}

int main(void)
{
    struct passwd *ptr;
    signal(SIGALRM, my_alarm);
    alarm(1);
    
    for(;;) {
        if ((ptr = getpwnam("sar")) == NULL)
            err_sys("getpwnam error");
        if (strcmp(ptr->pw_name, "sar") != 0)
            printf("return value corrupted, pw_name=%s\n", ptr->pw_name);
    }
}

static void sig_cld(int);   // 声明信号处理程序

int main()
{
    pid_t pid;

    if (signal(SIGCLD, sig_cld) == SIG_ERR)   // 注册信号处理程序
        perror("signal error");

    if ((pid = fork()) < 0)    // 创建子进程
        perror("fork error");
    else if (pid == 0) {   /* child */
        sleep(2);    // 子进程等待
        _exit(0);    // 子进程退出
    }

    pause();    // 父进程暂停等待信号
    exit(0);    // 父进程退出
}

static void sig_cld(int signo)   /* 中断 pause() 的信号处理程序 */
{
    pid_t pid;
    int status;

    printf("SIGCLD received\n");

    if (signal(SIGCLD, sig_cld) == SIG_ERR)  // 重新设置信号处理程序
        perror("signal error");

    if ((pid = wait(&status)) < 0)   // 父进程回收子进程资源
        perror("wait error");

    printf("pid = %d\n", pid);
}

// 1. x86/ARM CPU​​ 会抛出 ​​#DE（Divide Error）异常​​（中断号 0）。
// 2. CPU 暂停当前进程的执行，切换到内核模式，由操作系统处理。
// 3. 内核向违规进程发送 ​​SIGFPE（Signal Floating-Point Exception）​​
// 4. 信号默认行为：​​终止进程（Terminate）​​ 并生成 Core Dump（如果启用）。

//在 Unix/Linux 系统中：

//​​用户态进程无法直接向另一个进程发送信号​​，必须通过​​系统调用​​（如 kill()）请求内核代为处理。
​//​内核是信号的中枢​​，负责：
//1. 验证发送者权限（如：是否有权向目标进程发送信号）。
//2. 将信号写入目标进程的​​信号队列​​。
//3. 在目标进程的上下文切换时，触发信号处理。
​
//​关键结论​​
​//​所有信号发送的最终执行者都是内核​​，用户进程只是发起请求。
//你三种分类（A→B、A→A、内核→A）是​​逻辑上的分类​​，用于描述信号的触发场景，但底层均依赖内核。

static void sig_alm(int signo) { /* 仅唤醒pause，不处理逻辑 */ }

unsigned int sleep(unsigned int seconds) {
    if (signal(SIGALRM, sig_alm) == SIG_ERR) 
        return seconds;          // 信号处理注册失败时直接返回
    
    alarm(seconds);              // 启动定时器
    pause();                     // 挂起进程，等待SIGALRM
    return alarm(0);             // 关闭定时器并返回剩余时间
}

static jmp_buf env_alrm;
static void sig_alrm(int signo) {
    longjmp(env_alrm, 1);
}

unsigned int sleep2(unsigned int seconds) {
    if (signal(SIGALRM, sig_alrm) == SIG_ERR)
        return seconds;
    if (setjmp(env_alrm) == 0) {
        alarm(seconds);  // 启动定时器
        pause();        // 挂起进程
    }
    return alarm(0);    // 返回剩余时间
}

static void sig_alm(int);

int main(void) {
    int n;
    char line[MAXLINE];

    if (signal(SIGALRM, sig_alm) == SIG_ERR)
        err_sys("signal(SIGALRM) error");

    alarm(10);
    if ((n = read(STDIN_FILENO, line, MAXLINE)) < 0)
        err_sys("read error");
    alarm(0);

    write(STDOUT_FILENO, line, n);
    exit(0);
}

static void sig_alm(int signo) {
    /* nothing to do, just return to interrupt the read */
}

static void sig_alrm(int);
static jmp_buf env_alrm;

int main(void)
{
    int n;
    char line[MAXLINE];
    
    if (signal(SIGALRM, sig_alrm) == SIG_ERR)
        err_sys("signal(SIGALRM) error");
    
    if (setjmp(env_alrm) != 0)
        err_quit("read timeout");
    
    alarm(10);
    if ((n = read(STDIN_FILENO, line, MAXLINE)) < 0)
        err_sys("read error");
    alarm(0);
    
    write(STDOUT_FILENO, line, n);
    exit(0);
}

static void sig_alrm(int signo)
{
    longjmp(env_alrm, 1);
}

#include <signal.h>

int sigemptyset(sigset_t *set);   // 清空信号集（不含任何信号）
int sigfillset(sigset_t *set);    // 填充所有信号到集合中
int sigaddset(sigset_t *set, int signum);  // 添加指定信号（如 SIGINT）
int sigdelset(sigset_t *set, int signum);  // 删除指定信号
int sigismember(const sigset_t *set, int signum); // 检查信号是否存在
/*
SIG_BLOCK：将 set 中的信号加入当前阻塞列表。
SIG_UNBLOCK：从阻塞列表中移除 set 中的信号。
SIG_SETMASK：直接设置阻塞列表为 set。
*/
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);// 阻塞信号
int sigpending(sigset_t *set); // 查看阻塞且未处理的信号（未决信号）
//sigaction 中指定处理信号时的阻塞行为 后续章节补充
struct sigaction sa;
sa.sa_mask = mask;  // 设置处理函数执行期间阻塞的信号集
sigaction(SIGINT, &sa, NULL);

#define sigemptyset(ptr) (*(ptr) = 0)               // 所有位清0
#define sigfillset(ptr)  (*(ptr) = ~(signed int)0)   // 所有位置1（注意逗号运算符返回0）

*set |= 1 << (signo - 1);  // 位或操作开启特定位

*set &= ~(1 << (signo - 1));  // 位与操作关闭特定位

void pr_mask(const char *str)
{
    sigset_t sigset;
    int errno_save;

    errno_save = errno;  /* we can be called by signal handlers */

    if (sigprocmask(0, NULL, &sigset) < 0) {
        err_sys("sigprocmask error");
    } else {
        printf("%s", str);
        if (sigismember(&sigset, SIGINT))
            printf(" SIGINT");
        if (sigismember(&sigset, SIGQUIT))
            printf(" SIGQUIT");
        if (sigismember(&sigset, SIGUSR1))
            printf(" SIGUSR1");
        if (sigismember(&sigset, SIGALRM))
            printf(" SIGALRM");
        /* remaining signals can go here */
        printf("\n");
    }

    errno = errno_save;  /* restore errno */
}

// 举例说明 演示信号处理的全生命周期管理
// ​​1. 设置自定义处理函数​​ → 2. ​​临时阻塞信号​​ → 3. ​​检查未决信号​​ → 4. ​​解除阻塞并处理信号​​ → 5. ​​恢复默认行为​​。
static void sig_quit(int);

int main(void) {
    sigset_t newmask, oldmask, pendmask;

    if (signal(SIGQUIT, sig_quit) == SIG_ERR)
        err_sys("can't catch SIGQUIT");

    /* Block SIGQUIT and save current signal mask */
    sigemptyset(&newmask);
    sigaddset(&newmask, SIGQUIT);
    if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)  // 阻塞 SIGQUIT，防止其立即中断程序。
        err_sys("SIG_BLOCK error");

    sleep(5);  /* SIGQUIT here will remain pending */

    if (sigpending(&pendmask) < 0)
        err_sys("sigpending error");
    if (sigismember(&pendmask, SIGQUIT))  // 验证在阻塞期间是否有 SIGQUIT 信号到达（如用户按下 Ctrl+\），但被暂存为未决状态。
        printf("\nSIGQUIT pending\n");

    /* Restore signal mask which unblocks SIGQUIT */
    if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)
        err_sys("SIG_SETMASK error");
    printf("SIGQUIT unblocked\n");

    sleep(5);  /* SIGQUIT here will terminate with core file */
    exit(0);
}

static void sig_quit(int signo) {
    printf("caught SIGQUIT\n");
    if (signal(SIGQUIT, SIG_DFL) == SIG_ERR)
        err_sys("can't reset SIGQUIT");
}

// 结果
$ ./a.out
^\                      # 第一次按Ctrl+\（阻塞期间，信号被暂存）
SIGQUIT pending         # 发现未决信号
caught SIGQUIT          # 解除阻塞后处理信号   // 关键行为​​：解除阻塞时，系统会检查是否有未决的 SIGQUIT 信号。如果有，则​​立即递送​​该信号给进程。
SIGQUIT unblocked
^\                      # 第二次按Ctrl+\（默认行为生效） // 因处理函数中已重置为默认行为（SIG_DFL），直接终止进程。
QUIT (coredump)         # 进程终止

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

// 使用sigsetjmp/siglongjmp替代常规版本
// 当savemask非零时，会保存和恢复信号屏蔽字

#include <setjmp.h>
#include <signal.h>

int sigsetjmp(sigjmp_buf env, int savemask);
void siglongjmp(sigjmp_buf env, int val);

// 这段代码展示了正确处理信号与非本地跳转交互的标准模式，是Unix系统编程中信号处理的经典范例。
// 不是很理解
static void sig_usr1(int);
static void sig_alrm(int);

static sigjmp_buf jmpbuf;
static volatile sig_atomic_t canjump;

int main(void)
{
    if (signal(SIGUSR1, sig_usr1) == SIG_ERR)
        err_sys("signal(SIGUSR1) error");
    if (signal(SIGALRM, sig_alrm) == SIG_ERR)
        err_sys("signal(SIGALRM) error");
    
    pr_mask("starting main: ");
    
    if (sigsetjmp(jmpbuf, 1)) {
        pr_mask("ending main: ");
        exit(0);
    }
    canjump = 1; /* now sigsetjmp() is OK */
    
    for (;;)
        pause();
}

static void sig_usr1(int signo)
{
    time_t starttime;
    
    if (canjump == 0)
        return; /* unexpected signal, ignore */
    
    pr_mask("starting sig_usr1: ");
    alarm(3); /* SIGALRM in 3 seconds */
    starttime = time(NULL);
    
    for (;;) { /* busy wait for 5 seconds */
        if (time(NULL) > starttime + 5)
            break;
    }
    
    pr_mask("finishing sig_usr1: ");
    canjump = 0;
    siglongjmp(jmpbuf, 1); /* jump back to main, don't return */
}

static void sig_alrm(int signo)
{
    pr_mask("in sig_alrm: ");
}