BSP Day53

信号集

许多信号相关的系统调用都需要能表示一组不同的信号，多个信号可使用一个称之为信号集的数据结构来表示，其系统数据类型为 sigset_t。

在 PCB 中有两个非常重要的信号集。一个称之为 “阻塞信号集” ，另一个称之为“未决信号集” 。这两个信号集都是内核使用位图机制来实现的。但操作系统不允许我们直接对这两个信号集进行位操作，而需自定义另外一个集合，借助信号集操作函数来对 PCB 中的这两个信号集进行修改。

信号的 “未决” 是一种状态，指的是从信号的产生到信号被处理前的这一段时间，信号的 “阻塞” 是一个开关动作，指的是阻止信号被处理，但不是阻止信号产生。

信号的阻塞就是让系统暂时保留信号留待以后发送。由于另外有办法让系统忽略信号，所以一般情况下信号的阻塞只是暂时的，只是为了防止信号打断敏感的操作。

内核通过读取未决信号集来判断信号是否应被处理。信号屏蔽字mask可以影响未决信号集。而我们可以在应用程序中自定义set来改变mask.已达到屏蔽指定信号的目的。

信号集工作过程

1. 用户通过键盘Ctrl + C, 产生2号信号 SIGINT (信号被创建)

2.信号产生但是没有被处理 （未决）

- 在内核中将所有的没有被处理的信号存储在一个集合中 （未决信号集）

- SIGINT信号状态被存储在第二个标志位上

- 这个标志位的值为0， 说明信号不是未决状态

- 这个标志位的值为1， 说明信号处于未决状态

 3.这个未决状态的信号，需要被处理，处理之前需要和另一个信号集（阻塞信号集），进行比较

 - 阻塞信号集默认不阻塞任何的信号

- 如果想要阻塞某些信号，需要用户调用系统的API

4.在处理的时候和阻塞信号集中的标志位进行查询，看是不是对该信号设置阻塞了

- 如果没有阻塞，这个信号就被处理

- 如果阻塞了，这个信号就继续处于未决状态，直到阻塞解除，这个信号就被处理

信号屏蔽字

无法决定信号什么时候来，但可通过信号屏蔽字决定什么时候可以被响应。
即：一个进程的信号屏蔽字规定了当前阻塞而不能递送给该进程的信号集。 

信号屏蔽字函数

sigprocmask()——检测或更改其信号屏蔽字

函数功能：检测或更改其信号屏蔽字或在一个步骤中同时执行这两个操作。

项目	说明
函数原型	int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);
头文件	signal.h
参数说明	how:做什么 SIG_BLOCK、SIG_UNBLOCK、SIG_SETMASK
	set:信号集
	oldset:之前信号机状态
返回值	成功返回0 失败返回-1
注意	①若oldset非空指针，则进程当前信号屏蔽字通过oldset返回 ②若set是非空指针，则参数how指示如何修改信号屏蔽字。 ③若set是空指针，则不改变该进程的信号屏蔽字，how值无意义。

how可选用的值： 

how	说明
SIG_BLOCK	该进程新的信号屏蔽字是其当前信号屏蔽字和set指向信号集的并集。set包含了我们希望阻塞的附加信号
SIG_UNBLOCK	该进程新的信号屏蔽字是其当前信号屏蔽字和set所指向信号集补集的交集。set包含了我们希望解除阻塞的信号
SIG_SETMASK	该进程新的信号屏蔽字将被set指向的信号集的值代替

 

 信号集的相关函数 ：

 sigaction函数

#include <signal.h>
int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

    - 功能：检查或者改变信号的处理，即信号捕捉
    - 参数：
        - signum : 需要捕捉的信号的编号或者宏值（信号的名称）
        - act ：捕捉到信号之后的处理动作
        - oldact : 上一次对信号捕捉相关的设置，一般不使用，传递NULL
    - 返回值：
        成功 0
        失败 -1

 struct sigaction {
    // 函数指针，指向的函数就是信号捕捉到之后的处理函数
    void     (*sa_handler)(int);
    // 同样是信号处理函数，有三个参数，可以获得关于信号更详细的信息
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    // 临时阻塞信号集，在信号捕捉函数执行过程中，临时阻塞某些信号。
    sigset_t   sa_mask;
    // 使用哪一个信号处理对捕捉到的信号进行处理
    int sa_flags;
    这个值可以是0，表示使用 sa_handler，也可以是 SA_SIGINFO 表示使用 sa_sigaction
    SA_RESTART，使被信号打断的系统调用自动重新发起
    SA_NOCLDSTOP，使父进程在它的子进程暂停或继续运行时不会收到 SIGCHLD 信号
    SA_NOCLDWAIT，使父进程在它的子进程退出时不会收到 SIGCHLD 信号，这时子进程如果退出也不会成为僵尸进程
    SA_NODEFER，使对信号的屏蔽无效，即在信号处理函数执行期间仍能发出这个信号
    SA_RESETHAND，信号处理之后重新设置为默认的处理方式
    SA_SIGINFO，使用 sa_sigaction 成员而不是 sa_handler 作为信号处理函数
    // 被废弃掉了
    void     (*sa_restorer)(void);
};

sigemptyset函数

int sigemptyset(sigset_t *set);

- 功能：清空信号集中的数据，将信号集中的所有的标志位置为0

- 参数：set：传出参数，需要操作的信号集

- 返回值：成功返回0， 失败返回-1 

sigfillset函数

int sigfillset(sigset_t *set);

- 功能：将信号集中的所有的标志位置为1

- 参数：set：传出参数，需要操作的信号集

- 返回值：成功返回0， 失败返回-1

sigaddset函数

int sigaddset(sigset_t *set, int signum);

 - 功能：设置信号集中的某一个信号对应的标志位为1，表示阻塞这个信号

 - 参数：
 - set：传出参数，需要操作的信号集
 - signum：需要设置阻塞的那个信号
 - 返回值：成功返回0， 失败返回-1

sigdelset函数

int sigdelset(sigset_t *set, int signum);
- 功能：设置信号集中的某一个信号对应的标志位为0，表示不阻塞这个信号
- 参数：

- set：传出参数，需要操作的信号集

- signum：需要设置不阻塞的那个信号

- 返回值：成功返回0， 失败返回-1

sigismember函数

int sigismember(const sigset_t *set, int signum);
 - 功能：判断某个信号是否阻塞
 - 参数：
 - set：需要操作的信号集
 - signum：需要判断的那个信号

 - 返回值：
  1 ： signum被阻

  0 ： signum不阻塞
 -1 ： 失败

 例程：

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

int main()
 {

    // 创建一个信号集
    sigset_t set;

    // 清空信号集的内容
    sigemptyset(&set);

    // 判断 SIGINT 是否在信号集 set 里
    int ret = sigismember(&set, SIGINT);
    if(ret == 0)
 {
        printf("SIGINT 不阻塞\n");
    } else if(ret == 1)
 {
        printf("SIGINT 阻塞\n");
    }

    // 添加几个信号到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 判断SIGINT是否在信号集中
    ret = sigismember(&set, SIGINT);
    if(ret == 0) 
{
        printf("SIGINT 不阻塞\n");
    } else if(ret == 1)
 {
        printf("SIGINT 阻塞\n");
    }

    // 判断SIGQUIT是否在信号集中
    ret = sigismember(&set, SIGQUIT);
    if(ret == 0) 
{
        printf("SIGQUIT 不阻塞\n");
    } else if(ret == 1)
 {
        printf("SIGQUIT 阻塞\n");
    }

    // 从信号集中删除一个信号
    sigdelset(&set, SIGQUIT);

    // 判断SIGQUIT是否在信号集中
    ret = sigismember(&set, SIGQUIT);
    if(ret == 0)
 {
        printf("SIGQUIT 不阻塞\n");
    } else if(ret == 1) 
{
        printf("SIGQUIT 阻塞\n");
    }

    return 0;
}

sigpending函数

int sigpending(sigset_t *set);

- 功能：获取内核中的未决信号集

- 参数：set：传出参数，保存的是内核中的未决信号集中的信息。

 

 例程：

// 编写一个程序，把所有的常规信号（1-31）的未决状态打印到屏幕
// 设置某些信号是阻塞的，通过键盘产生这些信号

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

int main() {

    // 设置2、3号信号阻塞
    sigset_t set;
    sigemptyset(&set);
    // 将2号和3号信号添加到信号集中
    sigaddset(&set, SIGINT);
    sigaddset(&set, SIGQUIT);

    // 修改内核中的阻塞信号集
    sigprocmask(SIG_BLOCK, &set, NULL);

    int num = 0;

    while(1) {
        num++;
        // 获取当前的未决信号集的数据
        sigset_t pendingset;
        sigemptyset(&pendingset);
        sigpending(&pendingset);

        // 遍历前32位
        for(int i = 1; i <= 31; i++) {
            if(sigismember(&pendingset, i) == 1) {
                printf("1");
            }else if(sigismember(&pendingset, i) == 0) {
                printf("0");
            }else {
                perror("sigismember");
                exit(0);
            }
        }

        printf("\n");
        sleep(1);
        if(num == 10)
       {
            // 解除阻塞
            sigprocmask(SIG_UNBLOCK, &set, NULL);
        }
    }
    return 0;
}

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>

void myalarm(int num) {
    printf("捕捉到了信号的编号是：%d\n", num);
    printf("xxxxxxx\n");
}

// 过3秒以后，每隔2秒钟定时一次
int main() {

    struct sigaction act;
    act.sa_flags = 0;
    act.sa_handler = myalarm;
    sigemptyset(&act.sa_mask);  // 清空临时阻塞信号集
   
    // 注册信号捕捉
    sigaction(SIGALRM, &act, NULL);

    struct itimerval new_value;

    // 设置间隔的时间
    new_value.it_interval.tv_sec = 2;
    new_value.it_interval.tv_usec = 0;

    // 设置延迟的时间,3秒之后开始第一次定时
    new_value.it_value.tv_sec = 3;
    new_value.it_value.tv_usec = 0;

    int ret = setitimer(ITIMER_REAL, &new_value, NULL); // 非阻塞的
    printf("定时器开始了...\n");

    if(ret == -1) {
        perror("setitimer");
        exit(0);
    }

    // getchar();
    while(1);

    return 0;
}

 内核实现信号捕捉的过程：

SIGCHLD 信号

SIGCHLD 信号产生的3个条件：

1. 子进程终止时（最常见）
2. 子进程接收到 SIGSTOP 信号停止时
3. 子进程处在停止态，接受到 SIGCONT 后唤醒时

以上三种条件都会给父进程发送 SIGCHLD 信号，父进程默认会忽略该信号。

使用 SIGCHLD 信号解决僵尸进程的问题：

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

void myFun(int num) {
    printf("捕捉到的信号 ：%d\n", num);
    // 回收子进程PCB的资源
    // while(1) {
    //     wait(NULL); 
    // }
    while(1) {
       int ret = waitpid(-1, NULL, WNOHANG);
       if(ret > 0) {
           printf("child die , pid = %d\n", ret);
       } else if(ret == 0) {
           // 说明还有子进程或者
           break;
       } else if(ret == -1) {
           // 没有子进程
           break;
       }
    }
}

int main() {

    // 提前设置好阻塞信号集，阻塞SIGCHLD，因为有可能子进程很快结束，父进程还没有注册完信号捕捉
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGCHLD);
    sigprocmask(SIG_BLOCK, &set, NULL);

    // 创建一些子进程
    pid_t pid;
    for(int i = 0; i < 20; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程

        // 捕捉子进程死亡时发送的SIGCHLD信号
        struct sigaction act;
        act.sa_flags = 0;
        act.sa_handler = myFun;
        sigemptyset(&act.sa_mask);
        sigaction(SIGCHLD, &act, NULL);

        // 注册完信号捕捉以后，解除阻塞
        sigprocmask(SIG_UNBLOCK, &set, NULL);

        while(1) {
            printf("parent process pid : %d\n", getpid());
            sleep(2);
        }
    } else if( pid == 0) {
        // 子进程
        printf("child process pid : %d\n", getpid());
    }

    return 0;
}