linux系统编程之信号

1 信号的概念

信号在我们的生活中随处可见， 如：古代战争中摔杯为号；现代战争中的信号弹；体育比赛中使用的信号枪......

它们都有共性： 1. 简单 2. 不能携带大量信息 3. 满足某个特设条件才发送。

信号是信息的载体， Linux/UNIX 环境下，古老、经典的通信方式， 现下依然是主要的通信手段。
Unix 早期版本就提供了信号机制，但不可靠，信号可能丢失。 Berkeley 和 AT&T 都对信号模型做了更改，增加了可靠信号机制。但彼此不兼容。 POSIX.1 对可靠信号例程进行了标准化。

2 信号的机制

A 给 B 发送信号， B 收到信号之前执行自己的代码，收到信号后，不管执行到程序的什么位置，都要暂停运行，去处理信号，处理完毕再继续执行。与硬件中断类似——异步模式。但信号是软件层面上实现的中断，早期常被称为“软中断”。

信号的特质：由于信号是通过软件方法实现，其实现手段导致信号有很强的延时性。但对于用户来说，这个延迟时间非常短，不易察觉。

每个进程收到的所有信号，都是由内核负责发送的，内核处理。

3 与信号相关的事件和状态

产生信号:

1 按键产生，如： Ctrl+c、 Ctrl+z、 Ctrl+\
2 系统调用产生，如： kill、 raise、 abort
3 软件条件产生，如：定时器 alarm
4 硬件异常产生，如：非法访问内存(段错误)、除 0(浮点数例外)、内存对齐出错(总线错误)
5 命令产生，如： kill 命令

递达：递送并且到达进程。
未决：产生和递达之间的状态。主要由于阻塞(屏蔽)导致该状态。

信号的处理方式:

1 执行默认动作
2 忽略(丢弃)
3 捕捉(调用户处理函数)

Linux 内核的进程控制块 PCB 是一个结构体， task_struct, 除了包含进程 id，状态，工作目录，用户id，组 id，文件描述符表，还包含了信号相关的信息，主要指阻塞信号集和未决信号集。

阻塞信号集(信号屏蔽字)： 将某些信号加入集合，对他们设置屏蔽，当屏蔽 x 信号后，再收到该信号，该信号的处理将推后(解除屏蔽后) 。

未决信号集:

1 信号产生，未决信号集中描述该信号的位立刻翻转为 1，表信号处于未决状态。当信号被处理对应位翻转回为 0。这一时刻往往非常短暂。

2 信号产生后由于某些原因(主要是阻塞)不能抵达。这类信号的集合称之为未决信号集。在屏蔽解除前，信号一直处于未决状态。

未决信号集：本质：位图。用来记录信号的处理状态。该信号集中的信号，表示，已经产生，但尚未被处理。

4 信号四要素

kill -l     #查看当前系统中常规信号

1-31:常规信号；34-64：实时信号。

信号使用之前，应先确定其4要素，而后再用！！！

（1）编号
（2）名称
（3）信号对应事件
（4）信号默认处理动作。

1. Term：终止进程；
2. Ign： 忽略信号 (默认即时对该种信号忽略操作)；
3. Core：终止进程，生成 Core 文件。(查验进程死亡原因， 用于 gdb 调试)；
4. Stop：停止（暂停）进程；
5. Cont：继续运行进程。

5 linux常规信号汇总

1、SIGHUP: 当用户退出 shell 时，由该 shell 启动的所有进程将收到这个信号，默认动作为终止进程；
2、SIGINT：当用户按下了组合键时，用户终端向正在运行中的由该终端启动的程序发出此信号。默认动作为终止进程；
3、SIGQUIT：当用户按下组合键时产生该信号，用户终端向正在运行中的由该终端启动的程序发出些信号。默认动作为终止进程;

4、SIGILL：CPU 检测到某进程执行了非法指令。默认动作为终止进程并产生 core 文件;
5、SIGTRAP：该信号由断点指令或其他 trap 指令产生。默认动作为终止里程 并产生 core 文件;
6、SIGABRT: 调用 abort 函数时产生该信号。默认动作为终止进程并产生 core 文件;
7、SIGBUS：非法访问内存地址，包括内存对齐出错，默认动作为终止进程并产生 core 文件;
8、SIGFPE：在发生致命的运算错误时发出。不仅包括浮点运算错误，还包括溢出及除数为 0 等所有的算法错误。默认动作为终止进程并产生 core 文件;
9、SIGKILL：无条件终止进程。本信号不能被忽略，处理和阻塞。默认动作为终止进程。它向系统管理员提供了可以杀死任何进程的方法;
10、SIGUSE1：用户定义 的信号。即程序员可以在程序中定义并使用该信号。默认动作为终止进程;
11、SIGSEGV：指示进程进行了无效内存访问。默认动作为终止进程并产生 core 文件;
12、SIGUSR2：另外一个用户自定义信号，程序员可以在程序中定义并使用该信号。默认动作为终止进程;
13、SIGPIPE：Broken pipe 向一个没有读端的管道写数据。默认动作为终止进程;
14、SIGALRM: 定时器超时，超时的时间 由系统调用 alarm 设置。默认动作为终止进程;
15、SIGTERM：程序结束信号，与 SIGKILL 不同的是，该信号可以被阻塞和终止。通常用来要示程序正常退出;执行 shell 命令 Kill 时，缺省产生这个信号。默认动作为终止进程;
16、SIGSTKFLT：Linux 早期版本出现的信号，现仍保留向后兼容。默认动作为终止进程;
17、SIGCHLD：子进程状态发生变化时，父进程会收到这个信号。默认动作为忽略这个信号;
18、SIGCONT：如果进程已停止，则使其继续运行。默认动作为继续/忽略;
19、SIGSTOP：停止进程的执行。信号不能被忽略，处理和阻塞。默认动作为暂停进程;
20、SIGTSTP：停止终端交互进程的运行。按下组合键时发出这个信号。默认动作为暂停进程;
21、SIGTTIN：后台进程读终端控制台。默认动作为暂停进程;
22、SIGTTOU: 该信号类似于 SIGTTIN，在后台进程要向终端输出数据时发生。默认动作为暂停进程;
23、SIGURG：套接字上有紧急数据时，向当前正在运行的进程发出些信号，报告有紧急数据到达。如网络带外数据到达，默认动作为忽略该信号;
24、SIGXCPU：进程执行时间超过了分配给该进程的 CPU 时间 ，系统产生该信号并发送给该进程。默认动作为终止进程;
25、SIGXFSZ：超过文件的最大长度设置。默认动作为终止进程;
26、SIGVTALRM：虚拟时钟超时时产生该信号。类似于 SIGALRM，但是该信号只计算该进程占用 CPU的使用时间。默认动作为终止进程;
27、SGIPROF：类似于 SIGVTALRM，它不公包括该进程占用 CPU 时间还包括执行系统调用时间。默认动作为终止进程;
28、SIGWINCH：窗口变化大小时发出。默认动作为忽略该信号;
29、SIGIO：此信号向进程指示发出了一个异步 IO 事件。默认动作为忽略;
30、SIGPWR：关机。默认动作为终止进程;
31、SIGSYS：无效的系统调用。默认动作为终止进程并产生 core 文件;
32、SIGRTMIN ～ (64) SIGRTMAX：LINUX 的实时信号，它们没有固定的含义（可以由用户自定义）。所有的实时信号的默认动作都为终止进程。

6 信号的产生

6.1 终端按键产生信号

1. Ctrl + c → 2) SIGINT（终止/中断） “INT” ----Interrupt
2. Ctrl + z → 20) SIGTSTP（暂停/停止） “T” ----Terminal 终端。
3. Ctrl + \ → 3) SIGQUIT（退出）

6.2 硬件异常产生信号

1. 除 0 操作 → 8) SIGFPE (浮点数例外) “F” -----float 浮点数。
2. 非法访问内存 → 11) SIGSEGV (段错误)。总线错误 → 7) SIGBUS

6.3 kill 函数/命令产生信号

函数原型

int kill(pid_t pid, int sig);
// 成功：0；失败：-1 (ID 非法，信号非法，普通用户杀 init 进程等权级问题)，设置errno

// pid > 0: 发送信号给指定的进程。
// pid = 0: 发送信号给 与调用 kill 函数进程属于同一进程组的所有进程。
// pid < 0: 取|pid|发给对应进程组。
// pid = -1：发送给进程有权限发送的系统中所有进程。
// sig：不推荐直接使用数字，应使用宏名，因为不同操作系统信号编号可能不同，但名称一致

子进程kill父进程

#include 
#include 
#include 
#include 
#include 
#include 

int main(int argc, char *argv[])
{
    pid_t pid = fork();
    if (pid > 0)
    {
        // 父进程
        printf("parent, pid = %d\n", getpid());
        while (1) ;
    }
    else if (pid == 0)
    {
        // 子进程
        printf("child, pid = %d, ppid = %d\n", getpid(), getppid());
        kill(getppid(), SIGKILL);
        // kill(getppid(), SIGSEGV);
    }
    else
    {
        perror("fork error\n");
    }

    return 0;
}

执行

kill 命令

kill -SIGKILL pid       # kill 命令产生信号
kill -9 -groupname      # 杀一个进程组

6.4 软件条件产生信号

6.4.1 alarm函数原型

设置定时器(闹钟)。在指定 seconds 后，内核会给当前进程发送 14）SIGALRM 信号。进程收到该信号，默认动作终止。

每个进程都有且只有唯一个定时器

unsigned int alarm(unsigned int seconds); 
// 返回 0 或剩余的秒数，无失败。
// 常用：取消定时器 alarm(0)，返回旧闹钟余下秒数。

time 命令 ： 查看程序执行时间。

实际时间 = 用户时间 + 内核时间 + 等待时间。 --》 优化瓶颈 IO

#include 
#include 
#include 
#include 
#include 
#include 

int main(int argc, char *argv[])
{
    int i;
    alarm(1);
    for (i = 0;; i++)
    {
        printf("%d\n", i);
    }
    
    return 0;
}

执行

 即计算机1s钟可以数多少个数。

6.4.2 使用 time 命令查看程序执行的时间（优化）

执行

time ./a.out 

结果

 将结果重定向到out中

time ./a.out > out

执行

输出out的内容

结论：程序运行的瓶颈在于 IO，优化程序，首选优化 IO。

6.4.3 setitimer函数原型

函数原型

setitimer函数

int setitimer(int which, 
              const struct itimerval *new_value,
              struct itimerval *old_value);
// 返回值：
// 成功： 0
// 失败： -1 errno

 参数1：which

which： 
ITIMER_REAL：      // 采用自然计时。 ——> SIGALRM
ITIMER_VIRTUAL:    // 采用用户空间计时（进程占CPU时间） ---> SIGVTALRM
ITIMER_PROF:       // 采用内核+用户空间计时 ---> SIGPROF

参数2：new_value：结构体设置间隔时间和单次时间

new_value： 
// 定时秒数
// 类型：

struct itimerval {
    struct timeval {
        time_t tv_sec; /* seconds */
        suseconds_t tv_usec; /* microseconds */
    }it_interval; // 周期定时秒数

    struct timeval {
        time_t tv_sec;
        suseconds_t tv_usec;
        }it_value; // 第一次定时秒数
};

参数3：old_value：传出参数，上次定时剩余时间。

e.g.:

struct itimerval new_t;
struct itimerval old_t;
new_t.it_interval.tv_sec = 0;
new_t.it_interval.tv_usec = 0;
new_t.it_value.tv_sec = 1;
new_t.it_value.tv_usec = 0;
int ret = setitimer(&new_t, &old_t);  // 定时1秒

使用setitimer定时，向屏幕打印信息：

第一次信息打印是两秒间隔，之后都是5秒间隔打印一次。可以理解为第一次是有个定时器，什么时候触发打印，之后就是间隔时间。

实现alarm

#include 
#include 
#include 
#include 
#include 
#include 
#include 

unsigned int myAlarm(unsigned int sec)
{
    struct itimerval it, oldit;
    it.it_value.tv_sec = sec;
    it.it_value.tv_usec = 0;
    it.it_interval.tv_sec = 0;
    it.it_interval.tv_usec = 0;
    if (setitimer(ITIMER_REAL, &it, &oldit) == -1)
    {
        perror("setitimer error\n");
        exit(1);
    }
    return oldit.it_value.tv_sec;
}

int main(int argc, char *argv[])
{
    myAlarm(1);
    int i;
    for (i = 0;; i++)
    {

        printf("%d\n", i);
    }
    
    return 0;
}

 执行

7 信号集操作函数+原理（重）

控制原理：内核通过读取未决信号集来判断信号是否应被处理。信号屏蔽字 mask 可以影响未决信号集。

而我们可以在应用程序中自定义 set 来改变 mask。已达到屏蔽指定信号的目的。（重点）

阻塞信号集、未决信号集默认0

信号集操作函数：

sigset_t set; 
// 自定义信号集。typedef unsignedlong sigset_t;

sigemptyset(sigset_t *set); 
// 将某个信号集清 0 成功：0；失败：-1

sigfillset(sigset_t *set); 
// 将某个信号集置 1 成功：0；失败：-1

sigaddset(sigset_t *set, int signum); 
// 将某个信号加入信号集 成功：0；失败：-1

sigdelset(sigset_t *set, int signum); 
// 将某个信号清出信号集 成功：0；失败：-1

sigismember(const sigset_t *set，int signum); 
// 判断某个信号是否在信号集中 返回值：在集合：1；不在：0；出错：-1

7.1 sigprocmask 函数

用来屏蔽信号、解除屏蔽也使用该函数。其本质，读取或修改进程的信号屏蔽字(PCB 中)

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
// how: SIG_BLOCK: 设置阻塞
//      SIG_UNBLOCK: 取消阻塞
//      SIG_SETMASK: 用自定义set替换mask。
// set： 自定义set
// oldset：旧有的 mask。

7.2 sigpending 函数

查看未决信号集

int sigpending(sigset_t *set);
// set： 传出的 未决信号集。

7.3 信号操作函数使用原理分析

上来全部是0。
自己写的set
信号屏蔽字mask

用到的函数

sigset_t set, mySet;
sigemptyset(&set);
sigaddset(&set, SIGINT)
sigprocmask(SIG_BLOCK, &set);
sigpending(&mySet);

信号列表：

其中9号和19号信号比较特殊，只能执行默认动作，不能忽略捕捉，不能设置阻塞。

下面这个小例子，利用自定义集合，来设置信号阻塞，我们输入被设置阻塞的信号，可以看到未决信号集发生变化：

#include 
#include 
#include 
#include 
#include 
#include 
void printSet(sigset_t *set)
{
    int i;
    for (i = 1; i < 32; i++)
    {
        if (sigismember(set, i))
        {
            putchar('1');
        }
        else
        {
            putchar('0');
        }
    }
    printf("\n");
}

int main(int argc, char *argv[])
{
    // 自定义信号集
    sigset_t set, oldSet, pedSet;
    int res = 0;
    sigemptyset(&set);        // 清空信号集
    sigaddset(&set, SIGINT);  // ctrl + c
    sigaddset(&set, SIGQUIT); // ctrl + /
    sigaddset(&set, SIGBUS);
    sigaddset(&set, SIGKILL);                    // kill只能默认
    res = sigprocmask(SIG_BLOCK, &set, &oldSet); // 设置到阻塞信号集里
    if (res == -1)
    {
        perror("sigprocmask error\n");
    }

    while (1)
    {
        // 查看未决信号集
        res = sigpending(&pedSet);
        if (res == -1)
        {
            perror("sigpending error\n");
        }
        printSet(&pedSet);
        sleep(1);
    }

    return 0;
}

执行

 可以看到，在输入Ctrl+C之后，进程捕捉到信号，但由于设置阻塞，没有处理，未决信号集对应位置变为1.

其中9号和19号信号比较特殊，只能执行默认动作，不能忽略捕捉，不能设置阻塞。

8 信号捕捉

8.1 signal 函数

作用：注册一个信号捕捉函数（注册而非创建）

原型：

sighandler_t signal(int signum, sighandler_t handler);
// signum ：待捕捉信号
// handler：捕捉信号后的操纵函数

typedef void (*sighandler_t)(int);
// 函数指针类型 需要注意的就是需要传入一个整形参数 不管用不用

 返回值：

信号捕捉特性：

1 捕捉函数执行期间，信号屏蔽字 由 mask --> sa_mask , 捕捉函数执行结束。 恢复回mask
2 捕捉函数执行期间，本信号自动被屏蔽(sa_flgs = 0).
3 捕捉函数执行期间，被屏蔽信号多次发送，解除屏蔽后只处理一次！

一个信号捕捉的小例子

#include 
#include 
#include 
#include 
#include 
#include 

void signalCatch(int signum)
{
    printf("catch you %d\n", signum);
}

int main(int argc, char *argv[])
{
    // 注册信号捕捉函数, 当信号SIGINT触发时，调用signalCatch
    signal(SIGINT, signalCatch);
    while (1)
        ;
    return 0;
}

执行

8.2 sigaction实现信号捕捉

sigaction也是注册一个信号捕捉函数

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

结构体：

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

返回值

下面的小例子，使用sigaction捕捉两个信号：

#include 
#include 
#include 
#include 
#include 
#include 

// 捕捉函数，回调函数【内核调】
void signalCatch(int signum)
{
    if (signum == SIGINT)
    {
        printf("catch you %d\n", signum);
        sleep(10);
    }
    else if (signum == SIGQUIT)
    {
        printf("--------catch you %d---------\n", signum);
    }
}

int main(int argc, char *argv[])
{
    struct sigaction act, oldact;
    act.sa_handler = signalCatch; // 设置回调函数
    sigemptyset(&act.sa_mask);    // 设置屏蔽字，只在signalCatch工作时有效，清空sa_mask屏蔽字
    act.sa_flags = 0; // 默认值
    // 注册信号捕捉函数, 当信号SIGINT触发时，调用signalCatch
    int res = sigaction(SIGINT, &act, &oldact);
    if (res == -1)
    {
        perror("sigaction error\n");
    }

    res = sigaction(SIGQUIT, &act, &oldact);
    if (res == -1)
    {
        perror("sigaction error\n");
    }

    while (1);
    return 0;
}

 执行

 如图，两个信号都捕捉到了，并且输出了对应字符串。

8.3 信号捕捉的特性

特性

捕捉函数执行期间，信号屏蔽字 由 mask --> sa_mask , 捕捉函数执行结束。 恢复回mask
捕捉函数执行期间，本信号自动被屏蔽(sa_flgs = 0).
捕捉函数执行期间，被屏蔽信号多次发送，解除屏蔽后只处理一次！

8.4 内核实现信号捕捉简析

值得说明的是第四步到达第五步，因为函数处理完需要返回（类似于返回值的感觉），在函数处理之前我们实在内核空间，所以还要返回一次。

9 SIGCHLD信号（面试常问）

9.1 SIGCHLD的产生条件

SIGCHLD的产生条件：

子进程终止时
子进程接收到SIGSTOP
子进程处于停止态，接收到SIGCONT后唤醒时

9.2 借助 SIGCHLD 信号回收子进程(重)

子进程结束运行，其父进程会收到 SIGCHLD 信号。该信号的默认处理动作是忽略。
可以捕捉该信号，在捕捉函数中完成子进程状态的回收。

注意

有几个代码中需要注意的问题 [ 重要]
（1）开始设置的信号阻塞，是为了防止子进程结束了，父进程还没有走到注册捕获信号函数。这样就会导致子进程结束信号还是会执行默认的事件–忽略。所以多个了阻塞和解除阻塞。
（2）自定义事件do_sig_child中的while是为了防止，同一时间多个子进程同时结束，同时发送信号，就会导致性质二【XXX 信号捕捉函数执行期间，XXX 信号自动被屏蔽。】。最多两个信号事件执行，多个子进程信号被忽略了。
（3）父进程结束的时候我们要加个循环，防止父进程先与子进程结束，导致捕捉信号执行自定义函数的功能失效。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
// 信号捕捉函数
void catchchild(int num)
{
    pid_t wpid;
    while ((wpid = wait(NULL)) != -1)
    {
        printf("--------catch child,id = %d\n", wpid);
    }
    return;
}
int main(int argc, char *argv[])
{
    pid_t pid;
    int i;
    // 创建5个子进程
    for (i = 0; i < 5; i++)
    {
        if ((pid = fork()) == 0)
        {
            break;
        }
    }
    // 父进程回收子进程 
    if (i == 5)
    {
        struct sigaction act, oldact;
        act.sa_handler = catchchild; // 信号捕捉函数
        sigemptyset(&act.sa_mask);   // 设置捕捉函数执行期间屏蔽字
        act.sa_flags = 0;            // 设置默认属性, 本信号自动屏蔽
        // 父进程注册信号捕捉函数，回收子进程
        sigaction(SIGCHLD, &act, &oldact);
        printf("I'm parent, pid = %d \n", getpid());
        while (1)
            ;
    }
    else
    {
        printf("I‘m child ,pid = %d \n", getpid());
    }
    
    return 0;
}

执行

不清楚这里为什么会出现段错误。

还有一个问题需要注意，这里有可能父进程还没注册完捕捉函数，子进程就死亡了，解决这个问题的方法，首先是让子进程sleep，但这个不太科学。在fork之前注册也行，但这个也不是很科学。最科学的方法是在int i之前设置屏蔽，等父进程注册完捕捉函数再解除屏蔽。这样即使子进程先死亡了，信号也因为被屏蔽而无法到达父进程。解除屏蔽过后，父进程就能处理累积起来的信号了。

10 中断系统调用

系统调用可分为两类：慢速系统调用和其他系统调用

• 慢速系统调用：可能会使进程永远阻塞的一类。如果在阻塞期间收到一个信号，该系统调用就被中断,不再继续执行(早期)；也可以设定系统调用是否重启。如， read、 write、 pause、 wait...
• 其他系统调用： getpid、 getppid、 fork...

结合 pause，回顾慢速系统调用：
慢速系统调用被中断的相关行为，实际上就是 pause 的行为： 如， read
① 想中断 pause，信号不能被屏蔽。
② 信号的处理方式必须是捕捉 (默认、忽略都不可以)
③ 中断后返回-1， 设置 errno 为 EINTR(表“被信号中断” )
可修改 sa_flags 参数来设置被信号中断后系统调用是否重启。 SA_INTERRURT 不重启。 SA_RESTART重启。sa_flags 还有很多可选参数， 适用于不同情况。 如：捕捉到信号后，在执行捕捉函数期间，不希望自动阻塞该信号，可将 sa_flags 设置为 SA_NODEFER，除非 sa_mask 中包含该信号。