kill -l

在UNIX或类UNIX系统中，信号可以通过多种方式产生，其中之一是通过终端按键。用户在终端上按下特定的键盘组合时，会生成相应的信号，通常用于与正在运行的程序进行交互或控制。

下面是一些常见的通过终端按键产生的信号：

1. Ctrl+C (SIGINT)：

   • 产生原因：用户按下Ctrl+C组合键。
   • 默认行为：中断（Interrupt）当前运行的程序。
   • 通常用途：允许用户通过终端中断正在运行的程序。

2. Ctrl+Z (SIGTSTP)：

   • 产生原因：用户按下Ctrl+Z组合键。
   • 默认行为：挂起（Suspend）当前运行的程序，将其放到后台。
   • 通常用途：将一个正在前台运行的程序放到后台，暂停其执行。

3. Ctrl+\ (SIGQUIT)：

   • 产生原因：用户按下Ctrl+\组合键。
   • 默认行为：类似于Ctrl+C，但可能会生成core dump文件，用于调试。
   • 通常用途：在出现问题时，用户可以使用该信号强制终止程序，并生成core dump以供调试。

17.3.2 调用系统函数产生信号

在UNIX或类UNIX系统中，信号还可以通过系统函数的调用而产生。这种方式通常是由进程主动调用系统函数，而不是依赖于外部的用户或终端输入。以下是一些产生信号的常见系统函数：

1. kill函数：

   • 函数原型：int kill(pid_t pid, int sig);
   • 作用：向指定进程发送特定信号。
   • 例子：kill(pid, SIGTERM); 将向进程ID为pid的进程发送SIGTERM信号，请求它正常终止。

2. raise函数：

   • 函数原型：int raise(int sig);
   • 作用：使当前进程给自己发送指定信号。
   • 例子：raise(SIGALRM); 将使当前进程收到SIGALRM信号。

3. alarm函数：

   • 函数原型：unsigned int alarm(unsigned int seconds);
   • 作用：设置一个定时器，经过指定秒数后发送SIGALRM信号给调用进程。
   • 例子：alarm(5); 将在5秒后给当前进程发送SIGALRM信号。

4. abort函数：

   • 函数原型：void abort(void);
   • 作用：使当前进程接收到SIGABRT信号，导致进程异常终止。
   • 例子：abort(); 调用该函数将导致当前进程异常终止，可能生成包含堆栈跟踪的核心转储文件。

17.3.3 软件条件产生信号

SIGPIPE信号实际上就是一种由软件条件产生的信号

我们之前在讲到进程间通信当进程在使用管道进行通信时，读端进程将读端关闭，而写端进程还在一直向管道写入数据，那么此时写端进程就会收到SIGPIPE信号进而被操作系统终止。

例如，下面代码当中，创建匿名管道进行父子进程之间的通信，其中父进程是读端进程，子进程是写端进程，但是一开始通信父进程就将读端关闭了，那么此时子进程在向管道写入数据时就会收到SIGPIPE信号，进而被终止。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
int main()
{
	int fd[2] = { 0 };
	if (pipe(fd) < 0){ //使用pipe创建匿名管道
		perror("pipe");
		return 1;
	}
	pid_t id = fork(); //使用fork创建子进程
	if (id == 0){
		//child
		close(fd[0]); //子进程关闭读端
		//子进程向管道写入数据
		const char* msg = "hello father, I am child...";
		int count = 10;
		while (count--){
			write(fd[1], msg, strlen(msg));
			sleep(1);
		}
		close(fd[1]); //子进程写入完毕，关闭文件
		exit(0);
	}
	//father
	close(fd[1]); //父进程关闭写端
	close(fd[0]); //父进程直接关闭读端（导致子进程被操作系统杀掉）
	int status = 0;
	waitpid(id, &status, 0);
	printf("child get signal:%d\n", status & 0x7F); //打印子进程收到的信号
	return 0;
}

17.3.4 硬件异常产生信号

在操作系统中，硬件异常通常指的是由 CPU 探测到的一些错误或异常情况。当这些异常发生时，CPU 会向操作系统发出信号，操作系统会相应地采取措施，例如发送相应的信号给受影响的进程。

以下是一些常见的硬件异常，以及它们在信号中的映射：

1. 除零异常（Division by Zero）：

   • 当程序试图执行除以零的操作时，CPU 探测到除零异常。
   • 操作系统通常会将这个异常映射为 SIGFPE 信号（浮点异常）。

2. 非法指令异常（Illegal Instruction）：

   • 当程序尝试执行一条非法的机器指令时，CPU 探测到非法指令异常。
   • 操作系统通常会将这个异常映射为 SIGILL 信号。

3. 非法地址访问异常（Illegal Address Access）：

   • 当程序尝试访问未映射到其地址空间的内存区域时，CPU 探测到非法地址访问异常。
   • 操作系统通常会将这个异常映射为 SIGSEGV 信号（段错误）。

4. 浮点溢出异常（Floating-Point Overflow）：

   • 当程序中进行的浮点运算结果过大，无法表示时，CPU 探测到浮点溢出异常。
   • 操作系统通常会将这个异常映射为 SIGFPE 信号。

这些硬件异常产生信号的方式是由操作系统内核管理的，操作系统负责捕获硬件异常并向受影响的进程发送相应的信号。

---

这里我们就常见的除零错误，野指针或越界来分解一下从硬件到软件的信号处理

除零错误：

1. 硬件层面： 当 CPU 进行除法运算时，如果除数为零，就会导致除零错误。这是硬件级别的异常，通常由硬件内部的控制逻辑进行检测。

2. 状态标志： CPU 内部有状态标志位，例如溢出标志。如果发生除零错误，会设置相应的状态标志。操作系统会定期检查这些标志，如果发现异常状态，就会采取相应的措施。

3. 信号处理： 操作系统可以通过发送信号的方式通知进程。在除零错误的情况下，通常会发送 SIGFPE（浮点异常）信号给进程。

4. 进程退出： 默认情况下，操作系统可能会终止发生除零错误的进程。但这并非绝对，操作系统的具体行为可能受到进程对信号的处理方式的影响。

5. 死循环： 如果除零错误引发了异常而进程没有适当处理，可能导致程序陷入死循环。这是因为异常没有得到解决，寄存器中的异常标志一直保持未解决状态。

野指针或越界：

1. 虚拟地址和物理地址： 计算机程序中使用的地址是虚拟地址，需要通过页表和内存管理单元（MMU）将其转化为物理地址。MMU 是硬件的一部分，负责地址转换。

2. 异常检测： 当程序尝试访问非法地址（野指针、越界等），MMU 会检测到这一异常，触发硬件异常。

3. 页表： 操作系统通过页表管理虚拟地址到物理地址的映射。非法地址访问可能导致页表中的相应条目不存在，从而引发异常。

4. 操作系统处理： 操作系统可以通过信号通知进程发生了非法地址访问。常见的是 SIGSEGV（段错误）信号。

5. 死循环： 类似于除零错误，如果异常没有被适当处理，程序可能会进入死循环，导致无法正常执行。

总的来说，硬件和操作系统协同工作，通过硬件异常检测和操作系统的信号处理，确保程序在发生错误时能够得到适当的通知，从而采取相应的措施。

对于异常，进程不一定会立即退出，具体行为可能受到信号处理的影响。但是，即使我们不退出，基本上也做不了什么，因为寄存器上中的异常还没有解决，程序会陷入死循环。

17.3.5 【补充】核心转储 Core Dump

Core Dump（核心转储）是在进程发生异常终止时，将进程的内存数据保存到磁盘上的文件。

一般情况下，当进程遇到致命错误（如段错误）时，操作系统会生成一个 Core Dump 文件。这个文件可以被调试器用于事后调试，帮助开发人员定位程序崩溃的原因。通常，Core Dump 文件保存在进程当前工作目录中，文件名为 "core"。

在Linux和类Unix系统上，通过ulimit命令可以控制 Core Dump 文件的生成大小。默认情况下，操作系统可能会禁止生成 Core Dump 文件，因为它们可能包含敏感信息。

在云服务器中，核心转储是默认被关掉的，我们可以通过使用ulimit -a命令查看当前资源限制的设定。

ulimit -a

在开发和调试阶段，开发人员可以使用ulimit命令来调整 Core Dump 文件的大小限制。例如：

ulimit -c 1024

core文件的大小设置完毕后，就相当于将核心转储功能打开了。

此时如果我们再使用Ctrl+\对进程进行终止，就会发现终止进程后会显示core dumped。

并且会在当前路径下生成一个core文件，该文件以一串数字为后缀，而这一串数字实际上就是发生这一次核心转储的进程的PID。

这里我们写一个除0错误的代码进一步演示：

使用gdb对当前可执行程序进行调试，然后直接使用core-file core文件命令加载core文件，即可判断出该程序在终止时收到了8号信号

---

还记得进程等待函数waitpid函数的第二个参数吗：

pid_t waitpid(pid_t pid, int *status, int options);

core dump标志实际上就是用于表示程序崩溃的时候是否进行了核心转储。如果该位是1，则进行了核心转储；0，则没有进行了核心转储

说明一下： 

ulimit命令是用来设置用户级资源限制的命令，它会影响当前Shell进程及其子进程。在Unix-like系统中，每个进程都有与之相关的资源限制，这些限制定义了进程在运行时可以消耗的资源的上限。

ulimit命令改变的是Shell进程的Resource Limit，但myproc进程的PCB是由Shell进程复制而来的，所以也具有和Shell进程相同的Resource Limit值。

        17.4 信号的阻塞

17.4.1 信号相关常见概念补充

• 信号递达（Signal Delivery）：

  • 信号递达指的是实际执行信号处理动作的过程。一旦信号递达，进程就会执行与该信号关联的处理函数或默认动作。

• 信号未决（Signal Pending）：

  • 信号从产生到递达之间的状态称为信号未决。即，信号已经产生，但尚未被进程处理。在信号未决状态下，信号可以被阻塞，也可以等待进程处理。

• 信号阻塞（Signal Blocking）：

  • 进程可以选择阻塞某个信号，使得被阻塞的信号在进程解除对其阻塞之前，不会递达。这种机制允许进程对特定信号进行控制，以便在某些时候忽略或推迟对该信号的处理。

• 阻塞状态下的信号保持未决状态：

  • 当一个信号被阻塞时，即使信号已经产生，它会一直保持在信号未决状态。直到进程解除对该信号的阻塞，信号才能递达并触发相应的处理动作。

• 阻塞与忽略的区别：

  • 阻塞和忽略是两个不同的概念。当信号被阻塞时，它会保持在未决状态，直到解除阻塞；而当信号被忽略时，它在递达时不会触发任何处理动作。忽略是一种处理信号的方式，而阻塞是一种控制信号递达的方式。

17.4.2 信号在内核的表示

在内核中，每个进程的内核控制块（PCB）中会包含阻塞位图、未决位图以及处理动作表，用于跟踪和管理该进程的信号状态

• 阻塞位图（Block Bitmap）：

  • 阻塞位图是一个比特位图，每个比特位表示一个特定的信号。如果某个信号的阻塞位被设置为 1，说明该信号被阻塞；如果为 0，说明该信号没有被阻塞。

• 未决位图（Pending Bitmap）：

  • 未决位图也是一个比特位图，每个比特位表示一个特定的信号。如果某个信号的未决位被设置为 1，说明该信号在进程中是未决状态；如果为 0，说明该信号没有产生或已经被处理。

• 处理动作表（Handler Table）：

  • 处理动作表是一个函数指针数组，每个数组元素对应一个特定的信号。函数指针指向信号递达时要执行的处理动作，可能是默认动作、忽略动作或用户自定义函数。

• 在上图的例子中,SIGHUP信号未阻塞也未产生过,当它递达时执行默认处理动作。
• SIGINT信号产生过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。
• SIGQUIT信号未产生过,一旦产生SIGQUIT信号将被阻塞,它的处理动作是用户自定义函数sighandler。 

如果在进程解除对某信号的阻塞之前这种信号产生过多次,将如何处理?

POSIX.1允许系统递送该信号一次或多次。Linux是这样实现的:常规信号在递达之前产生多次只计一次,而实时信号在递达之前产生多次可以依次放在一个队列里。本章不讨论实时信号。

17.4.3 信号集

信号集（Signal Set）是一个用于表示一组信号状态的数据结构。在 POSIX 操作系统中，通常使用 sigset_t 数据类型来表示信号集。每个信号集包含了系统所支持的所有信号，并使用比特位图的形式表示每个信号的状态。

在信号集中，每个比特位（bit）代表一个特定的信号。如果某个比特位的值为 1，表示该信号在信号集中是有效的（被包含），如果为 0，则表示该信号是无效的（未包含）。

---

sigset_t：

sigset_t 是一个数据类型，用于表示信号集。信号集是一个集合，其中每个元素对应一个可能的信号。从上面阻塞位图（Block Bitmap）和 未决位图（Pending Bitmap）来看,每个信号只有一个bit的未决标志,非0即1,不记录该信号产生了多少次,阻塞标志也是这样表示的。 因此,未决和阻塞标志可以用相同的数据类型sigset_t来存储。

---

信号集操作函数：

#include <signal.h>

int sigemptyset(sigset_t *set);

int sigfillset(sigset_t *set);

int sigaddset(sigset_t *set, int signum);

int sigdelset(sigset_t *set, int signum);

int sigismember(const sigset_t *set, int signum);  

1. 初始化信号集：

   • sigemptyset：将信号集中的所有比特位都清零，表示该信号集不包含任何信号。
   • sigfillset：将信号集中的所有比特位都设置为 1，表示该信号集包含所有系统支持的信号。

2. 添加和删除信号：

   • sigaddset：将指定信号的比特位设置为 1，将该信号添加到信号集中。
   • sigdelset：将指定信号的比特位清零，将该信号从信号集中删除。

3. 查询信号是否包含在信号集中：

   • sigismember：用于判断指定信号是否包含在信号集中，返回 1 表示包含，返回 0 表示不包含。

 函数可以读取或更改进程的信号屏蔽字（阻塞信号集）。

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

参数说明：

• 如果oset是非空指针，则读取进程当前的信号屏蔽字通过oset参数传出。
• 如果set是非空指针，则更改进程的信号屏蔽字，参数how指示如何更改。
• 如果oset和set都是非空指针，则先将原来的信号屏蔽字备份到oset里，然后根据set和how参数更改信号屏蔽字。

---

sigpending：

该函数用于读取当前进程的未决信号集

int sigpending(sigset_t *set);

sigpending函数读取当前进程的未决信号集，并通过 set 参数传出。该函数调用成功返回0，出错返回-1

17.4.4 代码测试

首先我们编写一段程序 signal ，阻塞1~31号信号，并不断的打印pending位图

#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void printPending(sigset_t *pending)
{
	int i = 1;
	for (i = 1; i <= 31; i++){
		if (sigismember(pending, i)){
			printf("1 ");
		}
		else{
			printf("0 ");
		}
	}
	printf("\n");
}
void handler(int signo)
{
	printf("handler signo:%d\n", signo);
}
int main()
{
	signal(2, handler);
	sigset_t set, oset;
	sigemptyset(&set);
	sigemptyset(&oset);
    for(int i=1;i<=31;i++)
    {
	    sigaddset(&set, i); //SIGINT
    }
	sigprocmask(SIG_SETMASK, &set, &oset); 
	sigset_t pending;
	sigemptyset(&pending);
	int count = 0;
	while (1){
		sigpending(&pending); //获取pending
		printPending(&pending); //打印pending位图（1表示未决）
		sleep(1);
		count++;
	}
	return 0;
}

再编写一个shell脚本，来向运行后的程序 signal 发送1~31 号信号（这里我们避开9号与19号，原因后面会将）

#!/bin/bash

i=1
id=$(pidof signal)
while [ $i -le 31 ]
do 
    if [ $i -eq 9 ];then 
        let i++
        continue
    fi
    if [ $i -eq 19 ];then      
        let i++
        continue
    fi 
    kill -$i $id 
    echo "kill -$i $id"
    let i++
    sleep 1
done 

程序运行后的效果如下

#include <signal.h>

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

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

// 信号处理函数
void signal_handler(int signum) {
    printf("Received signal %d\n", signum);
}

int main() {
    // 注册信号处理函数
    if (signal(SIGINT, signal_handler) == SIG_ERR) {
        perror("Error setting up signal handler");
        return 1;
    }

    printf("Press Ctrl+C to send a SIGINT signal\n");

    // 进入一个无限循环
    while (1) {
        sleep(1);
    }

    return 0;
}

#include <signal.h>

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

struct sigaction {
    void (*sa_handler)(int);          // 信号处理函数，类似于 signal 函数的第一个参数
    void (*sa_sigaction)(int, siginfo_t *, void *);  // 实时信号的处理函数
    sigset_t sa_mask;                 // 用于屏蔽的信号集合
    int sa_flags;                     // 一些标志位
    void (*sa_restorer)(void);        // 未使用
};

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

// 信号处理函数
void signal_handler(int signum) {
    printf("Received signal %d\n", signum);
}

int main() {
    struct sigaction sa;
    
    // 设置信号处理函数
    sa.sa_handler = signal_handler;
    sa.sa_flags = 0;

    // 注册信号处理函数
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("Error setting up sigaction");
        return 1;
    }

    printf("Press Ctrl+C to send a SIGINT signal\n");

    // 进入一个无限循环
    while (1);

    return 0;
}

进程一章讲过用 wait 和 waitpid 函数清理僵尸进程 , 父进程可以阻塞等待子进程结束 , 也可以非阻 塞地查询是否有子进 程结束等待清理( 也就是轮询的方式 ) 。采用第一种方式 , 父进程阻塞了就不 能处理自己的工作了 ; 采用第二种方式 , 父 进程在处理自己的工作的同时还要记得时不时地轮询一 下, 程序实现复杂。

其实 , 子进程在终止时会给父进程发 SIGCHLD 信号 , 该信号的默认处理动作是忽略 , 父进程可以自 定义 SIGCHLD 信号的处理函数, 这样父进程只需专心处理自己的工作 , 不必关心子进程了 , 子进程 终止时会通知父进程 , 父进程在信号处理 函数中调用wait 清理子进程即可。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/wait.h>
#include <unistd.h>

void handler(int sig) {
    pid_t id;
    while ((id = waitpid(-1, NULL, WNOHANG)) > 0) {
        printf("等待子进程成功：%d\n", id);
    }
    printf("子进程退出：%d\n", getpid());
}

int main() {
    signal(SIGCHLD, handler);

    pid_t cid;
    if ((cid = fork()) == 0) { // 子进程
        printf("子进程：%d\n", getpid());
        sleep(3);
        exit(1);
    }

    while (1) {
        printf("父进程正在执行一些操作！\n");
        sleep(1);
    }

    return 0;
}

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

int main()
{
	signal(SIGCHLD, SIG_IGN);
	if (fork() == 0){
		//child
		printf("child is running, child dead: %d\n", getpid());
		sleep(3);
		exit(1);
	}
	//father
	while (1);
	return 0;
}