信号

程序员文章站 2022-07-12 10:28:21

...

一、信号

什么是信号？当我们运行一个前台进程时，通过键盘Ctrl+C可以输入一个硬件中断，如果CPU当前正在执⾏这个进程的代码,则该进程的⽤户空间代码暂停执⾏,CPU从⽤户态切换到内核态处理硬件中断。终端驱动程序将Ctrl-C解释成⼀个SIGINT信号,记在该进程的PCB中(也可以说发送了⼀个SIGINT信号给该进程)。当某个时刻要从内核返回到该进程的⽤户空间代码继续执⾏之前,⾸先处理PCB中记录的信号,发现有⼀个SIGINT信号待处理,⽽这个信号的默认处理动作是终⽌进程,所以直接终⽌进程⽽不再返回它的⽤户空间代码执⾏。

我们可以通过kill -l查看系统定义的信号列表：

每个信号都有⼀个编号和⼀个宏定义名称。编号31之前为普通信号，编号34以上为实时信号。这里我们只讨论普通信号，这些信号在什么条件下产生，默认的处理动作是什么都可以通过man 7 signal进行查看：

二、信号的产生

（一）通过终端按键产生信号

对于一个正在运行中的进程我们可以通过按键强制进程终止，如按Ctrl+c产生SIGINT信号，它的默认处理动作是终止进程；按Ctrl+\产生SIGQUIT信号，它的默认处理动作是终止进程并且Core Dump 。

什么是Core Dump ？当一个进程异常终止时，可以选择把进程的用户空间的所有数据全部保存在磁盘上，这个文件就叫做core，这个过程叫做Core Dump 。进程异常终⽌通常是因为有Bug,⽐如⾮法内存访问导致段错误,事后可以⽤调试器检查core⽂件以查清错误原因,这叫做Post-mortem Debug（事后调试）。⼀个进程允许产⽣多⼤的core⽂件取决于进程的Resource Limit(这个信息保存在PCB中)。默认是不允许产⽣core⽂件的,因为core⽂件中可能包含⽤户密码等敏感信息,不安全。在开发调试阶段可以⽤ulimit命令改变这个限制,允许产⽣core⽂件。⾸先⽤ulimit命令改变Shell进程的Resource Limit,允许core⽂件最⼤为1024K: ulimit -c 1024

写一个无限循环的进程，尝试使用Ctrl+c和Ctrl+\分别终止该进程：

先改变core文件的限制：

在运行以下进程：

#include <stdio.h>                                                                                                                   
int main()
{
    while(1);
    return 0;
}

对该进程进行Ctrl+c终止，查看当前文件夹下没有core文件：

对该进程进行Ctrl+/终止，查看到当前文件夹下出现了core文件：

对该文件进行gdb调试，可以很清楚的看到进程异常退出的原因：

（二）由硬件异常产生信号

这些异常有硬件检测到通知内核，然后内核向当前进程发送信号。例如当进程执行了除以0的指令，CPU的运算单元会产生异常，内核将这个异常解释为SIGFPE信号发送给进程。再例如，当进程访问了非法内存地址，MMU会产生异常，内核将这个异常解释为SIGSEGV信号发送给进程。

（三）通过系统调用向进程发送信号

之前我们结束一个进程使用kill命令向进程发送一个信号来使进程结束。今天我们将了解到kill命令是使用kill系统调用实现的。

1）kill系统调用

 #include <sys/types.h>
 #include <signal.h>
 int kill(pid_t pid, int sig);

kill函数可以向某个进程发送某个信号。

现在我们尝试用kill函数调用来模拟实现一下kill命令：

#include <stdio.h>                                                                                                                   
#include <signal.h>
int main(int argc, char* argv[])
{
    if(argc != 3)
    {   
        printf("please enter like : kill -12 6787\n");
        return -1; 
    }   
    int sig = atoi(argv[2]);
    pid_t pid = atoi(argv[1]);
    int ret = kill(sig, pid);
    if(ret < 0)
    {   
        perror("kill error");
        return -1; 
    }   
    return 0;
}

创建一个一直运行的测试进程，尝试用我们实现的mykill命令来向该进程发送一个SIGINT信号，使得该测试进程终止：

#include <stdio.h>                                                                                                                   
int main()
{
    while(1)
    {   
        ;   
    }   
    return 0;
}

先运行test：

使用mykill命令终止test进程：

可以看到test进程结束了：

2）raise函数

#include <signal.h>
int raise(int sig);

raise函数可以给当前进程发送一个信号。（自己给自己发送信号）

3）abort函数

#include <stdlib.h>
void abort(void);

abort函数使当前进程收到SIGABRT信号而终止。就像exit函数⼀样,abort函数总是会成功的,所以没有返回值。

（四）由软件条件产生信号

当内核检测到某种软件条件发生时，也可以通过信号发送给进程。例如闹钟超时产生SIGALRM 信号；再例如向读端关闭的管道写数据时产生SIGPIPE信号。

下面主要讲alarm函数和SIGALRM信号：

#include <unistd.h>
unsigned int alarm(unsigned int seconds);

调⽤alarm函数可以设定⼀个闹钟,也就是告诉内核在seconds秒之后给当前进程发SIGALRM信号, 该信号的默认处理动作是终⽌当前进程。

在下面信号的捕捉会用alarm实现一个mysleep。

三、信号的处理方式

忽略此信号

执行该信号的默认处理动作

自定制行为：提供一个信号处理函数，使得内核在处理该信号时，切换到用户态执行该函数，这种方式叫做信号的捕捉。

四、信号的捕捉

（一）信号的捕捉流程：

如果信号的处理动作是⽤户⾃定义函数,在信号递达时就调⽤这个函数,这称为捕捉信号。由于信号处理函数的代码是在⽤户空间的,处理过程⽐较复杂,举例如下: ⽤户程序注册了SIGQUIT信号的处理函数sighandler。当前正在执⾏main函数,这时发⽣中断或异常切换到内核态。在中断处理完毕后要返回⽤户态的main函数之前检查到有信号SIGQUIT递达。内核决定返回⽤户态后不是恢复main函数的上下⽂继续执⾏,⽽是执⾏sighandler函数,sighandler和main函数使⽤不同的堆栈空间,它们之间不存在调⽤和被调⽤的关系,是两个独⽴的控制流程。 sighandler函数返回后⾃动执⾏特殊的系统调⽤sigreturn再次进⼊内核态。如果没有新的信号要递达,这次再返回⽤户态就是恢复main函数的上下⽂继续执⾏了。

（二）相关函数：

1）signal函数

#include <signal.h>
typedef void (*sighandler_t)(int);
sighandler_t signal(int signum,sighandler_t handler);

用于捕捉信号，sighandler函数可以对捕捉的信号进行自定义的处理。

2）sigaction 函数

#include <signal.h>
int sigaction(int signo, const structsigaction *act, struct sigaction *oact);

sigaction函数可以读取和修改与指定信号相关联的处理动作。调⽤成功则返回0,出错则返回- 1。signo是指定信号的编号。若act指针⾮空,则根据act修改该信号的处理动作。若oact指针⾮空,则通过oact传出该信号原来的处理动作。 act和oact指向sigaction结构体；
将sahandler赋值为常数SIGIGN传给sigaction表⽰忽略信号,赋值为常数SIG_DFL表⽰执⾏系统默认动作,赋值为⼀个函数指针表⽰⽤⾃定义函数捕捉信号,或者说向内核注册了⼀个信号处理函数,该函数返回值为void,可以带⼀个int参数,通过参数可以得知当前信号的编号,这样就可以⽤同⼀个函数处理多种信号。显然,这也是⼀个回调函数,不是被main函数调⽤,⽽是被系统所调⽤；

当某个信号的处理函数被调⽤时,内核⾃动将当前信号加⼊进程的信号屏蔽字,当信号处理函数返回时⾃动恢复原来的信号屏蔽字原来的信号屏蔽字,这样就保证了在处理某个信号时,如果这种信号再次产⽣,那么它会被阻塞到当前处理结束为⽌。如果在调⽤信号处理函数时为⽌。如果在调⽤信号处理函数时,除了当前信号被⾃动屏蔽之外,还希望⾃动屏蔽另外⼀些信号,则⽤samask字段说明这些需要额外屏蔽的信号,当信号处理函数返回时⾃动恢复原来的信号屏蔽字。

3）pause函数

#include <unistd.h>
int pause(void);

pause函数使调⽤进程挂起直到有信号递达。如果信号的处理动作是终⽌进程,则进程终⽌,pause函数没有机会返回;如果信号的处理动作是忽略,则进程继续处于挂起状态,pause不返回;如果信号的处理动作是捕捉,则调⽤了信号处理函数之后pause返回-1,errno设置为EINTR, 所以pause只有出错的返回值。错误码EINTR表⽰“被信号中断”。

（三）模拟实现sleep函数

#include <stdio.h>
#include <signal.h>
                                                                                                                                     
typedef void (*sighandler_t)(int);
//信号处理函数(若不进行处理，将按照默认行为处理方式处理)
void myhandler(int sig)
{
    (void)sig;
}   
int mysleep(int seconds)
{
    //捕捉信号，并备份原来的信号处理方式
    sighandler_t old_sig = signal(SIGALRM, myhandler);
    //通过alarm注册一个闹钟信号
    alarm(seconds);
    //借助一个函数等待闹钟信号的到来（在这个过程中该进程挂起等待）
    pause();
    //恢复SIGALRM信号
    signal(SIGALRM, old_sig);                                                                                                        
}

五、信号阻塞

（一）信号阻塞的相关概念

实际执⾏信号的处理动作称为信号递达(Delivery)
信号从产⽣到递达之间的状态,称为信号未决(Pending)。
进程可以选择阻塞 (Block )某个信号。
被阻塞的信号产⽣时将保持在未决状态,直到进程解除对此信号的阻塞,才执⾏递达的动作.
注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,⽽忽略是在递达之后可选的⼀种处理动作

（二）信号阻塞的原理

我们来看下面这张图：

我们的进程收到的信号是怎样表示的呢？每一个进程都有一个PCB来保存着我们的进程信息，进程收到哪些信号用一个位图（sigset_t）来表示，收到那个信号哪一位置1。假设当前进程收到了信号SIGINT 信号，将他的未决信号集的这一位置1，如果他的阻塞信号集的这一位置一，表示该信号被阻塞，若没有阻塞，就立即对该信号进行处理。

每个信号都有两个标志位分别表⽰阻塞(block)和未决(pending),还有⼀个函数指针表⽰处理动作。信号产⽣时,内核在进程控制块中设置该信号的未决标志,直到信号递达才清除该标志。在上图的例⼦中,SIGHUP信号未阻塞也未产⽣过,当它递达时执⾏默认处理动作。 SIGINT信号产⽣过,但正在被阻塞,所以暂时不能递达。虽然它的处理动作是忽略,但在没有解除阻塞之前不能忽略这个信号,因为进程仍有机会改变处理动作之后再解除阻塞。 SIGQUIT信号未产⽣过,⼀旦产⽣SIGQUIT信号将被阻塞,它的处理动作是⽤户⾃定义函数sighandler。如果在进程解除对某信号的阻塞之前这种信号产⽣过多次,将如何处理?POSIX.1允许系统递送该信号⼀次或多次。 Linux是这样实现的:常规信号在递达之前产⽣多次只计⼀次,⽽实时信号在递达之前产⽣多次可以依次放在⼀个队列⾥。本章不讨论实时信号。

（三）sigset_t

每个信号只有⼀个bit的未决标志,⾮0即1,不记录该信号产⽣了多少次,阻塞标志也是这样表⽰的。因此,未决和阻塞标志可以⽤相同的数据类型sigsett来存储,sigsett称为信号集,这个类型可以表⽰每个信号的“有效”或“⽆效”状态,在阻塞信号集中“有效”和“⽆效”的含义是该信号是否被阻塞,⽽在未决信号集中“有效”和“⽆效”的含义是该信号是否处于未决状态。

（四）相关函数

1）信号集操作函数

#include <signal.h>
int sigemptyset(sigset_t *set);                     //初始化为全0
int sigfillset(sigset_t *set);                      //初始化为全1
int sigaddset (sigset_t *set, int signo);           //置位为1
int sigdelset(sigset_t *set, int signo);            //置位为0
int sigismember（const sigset_t *set, int signo);   //是⼀个布尔函数,⽤于判断⼀个信号集的有效信号中是否包含某种 信号,若包含则返回1,不包含则返回0,出错返回-1 
是⼀个布尔函数,⽤于判断⼀个信号集的有效信号中是否包含某种 信号,若包含则返回1,不包含则返回0,出错返回-1

在使⽤sigset_ t类型的变量之前,⼀定要调⽤sigemptyset或sigfillset做初始化,使信号集处于确定的状态。初始化sigset_t变量之后就可以在调⽤sigaddset和sigdelset在该信号集中添加或删除某种有效信号。

2）sigprocmask函数

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);//读取或更改信号屏蔽字

如果oset是⾮空指针,则读取进程的当前信号屏蔽字通过oset参数传出。如果set是⾮空指针,则更改进程的信号屏蔽字,参数how指⽰如何更改。如果oset和set都是⾮空指针,则先将原来的信号屏蔽字备份到oset⾥,然后根据set和how参数更改信号屏蔽字。假设当前的信号屏蔽字为mask,下表说明了how参数的可选值。

3）sigpending 函数

#include <signal.h>
int sigpending(sigset_t *set);//读取当前的未决信号集通过set传出

（五）例如：

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

typedef void (*sighandler_t)(int);
void myhandler(int signo)
{
    (void)signo;
}
void print_set(sigset_t* pend)
{
    int i = 0;
    for(; i < 32; ++i)
    {   
        if(sigismember(pend, i))                                                                                                     
            putchar('1');
        else 
            putchar('0');
    }
    puts("");                                                                                                                        
}
int main()
{
    //捕捉SININT信号（signal函数捕捉）
    sighandler_t old_sig = signal(SIGINT, myhandler);
    //屏蔽SIGINT信号
    //  1）初始化未决信号集
    sigset_t set;
    sigemptyset(&set);
    //  2）设置SIGINT对应的那一位为1
    sigaddset(&set, SIGINT);
    //  3）设置信号屏蔽字为1（sigprocmask函数）
    sigset_t old_set;
    sigprocmask(SIG_BLOCK, &set, &old_set);
    //循环的读取未决信号集，每隔5秒进行处理                                                                                          
    while(1)
    {
        sigset_t pend_set;
        sigpending(&pend_set);
        print_set(&pend_set);
        sleep(1);
    }
    return 0;
}

执行结果如下：

我们修改一下代码让它可以每隔5秒处理一下SIGINT信号：

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

typedef void (*sighandler_t)(int);
void myhandler(int signo)
{
    (void)signo;
}
void print_set(sigset_t* pend)
{
    int i = 0;
    for(; i < 32; ++i)
    {
        if(sigismember(pend, i))
            putchar('1');
        else 
            putchar('0');
    }
    puts("");                                                                                                                        
}
int main()
{
    //捕捉SININT信号（signal函数捕捉）
    sighandler_t old_sig = signal(SIGINT, myhandler);
    //屏蔽SIGINT信号
    //  1）初始化未决信号集
    sigset_t set;
    sigemptyset(&set);
    //  2）设置SIGINT对应的那一位为1
    sigaddset(&set, SIGINT);
    //循环的读取未决信号集，每隔5秒进行处理
    int count = 0;
    while(1)
    {                                                                                                                                
        //  3）设置信号屏蔽字为1（sigprocmask函数）
        sigset_t old_set;
        sigprocmask(SIG_BLOCK, &set, &old_set);
        count++;
        if(count == 5)
        {
            count = 0;
            sigprocmask(SIG_UNBLOCK, &set, &old_set);
        }
        sigset_t pend_set;
        sigpending(&pend_set);
        print_set(&pend_set);
        sleep(1);
    }
    return 0;                                                                                                                        
}

六、可重入

可重入函数：同一函数在多个执行流中同时调用，无逻辑问题。

不可重入函数：同一函数在多个执行流中同时调用，有逻辑问题。

在上面的例子中，main函数调⽤insert函数向⼀个链表head中插⼊节点node1,插⼊操作分为两步,刚做完第⼀步的时候,因为硬件中断使进程切换到内核,再次回⽤户态之前检查到有信号待处理,于是切换到sighandler函数,sighandler也调⽤insert函数向同⼀个链表head中插⼊节点node2,插⼊操作的两步都做完之后从sighandler返回内核态,再次回到⽤户态就从main函数调⽤的insert函数中继续往下执⾏,先前做第⼀步之后被打断,现在继续做完第⼆步。结果是,main函数和sighandler先后向链表中插⼊两个节点,⽽最后只有⼀个节点真正插⼊链表中了。这样就造成了执行逻辑混乱，insert函数为不可重入函数。

常见的不可重入函数：

调⽤了malloc或free,因为malloc也是⽤全局链表来管理堆的。
调⽤了标准I/O库函数。标准I/O库的很多实现都以不可重⼊的⽅式使⽤全局数据结构。
使用了非常量的全局、静态变量。
调用了不可重入的函数。

七、volatile

volatile限定符是必要的，在以下情况中：

1.对于程序中存在多个执⾏流程访问同⼀全局变量的情况；

2.虽然程序只有单⼀的执⾏流程⾏流程,但变量的内存单元中的数据不需要写操作就可以⾃⼰发⽣变化,每次读上来的值都可能不⼀样的情况；

3. 虽然程序只有单⼀的执⾏流程⾏流程,即使多次向变量的内存单元中写数据,只写不读,也并不是在做⽆⽤功,⽽是有特殊意义的什么样的内存单元会具有这样的特性呢?肯定不是普通的内存,⽽是映射到内存地址空间的硬件寄存器

八、竞态条件

让我们重新来看看之前写的模拟实现的sleep函数：

出现这个问题的根本原因是系统运⾏的时序(Timing)并不像我们写程序时所设想的那样。虽然alarm(nsecs)紧接着的下⼀⾏就是pause(),但是⽆法保证pause()⼀定会在调⽤alarm(nsecs)之后的nsecs秒之内被调⽤。由于异步事件在任何时候都有可能发⽣(这⾥的异步事件指出现更⾼优先级的进程),如果我们写程序时考虑不周密,就可能由于时序问题⽽导致错误,这叫做竞态条件 。

怎么解决这个问题呢？根据这个问题产生的原因，我们想办法在alarm之前屏蔽SIGALRM信号，在pause之后解除屏蔽不就行了吗？但是，这样的话，pause就等不到SIGALRM信号了。这个时候就需要将pause函数和解除屏蔽SIGALRM信号合并成一个原子操作。这样问题就可以解决了。

下面是改进后的mysleep代码：

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

typedef void (*sighandler_t)(int);
//信号处理函数(若不进行处理，将按照默认行为处理方式处理)
void myhandler(int sig)
{
    (void)sig;
}
int mysleep(int seconds)
{
    //捕捉信号，并备份原来的信号处理方式
    sighandler_t old_sig = signal(SIGALRM, myhandler);
    //在之前屏蔽SIGALRM 信号
    sigset_t set, oldset;
    sigemptyset(&set);
    sigaddset(&set, SIGALRM);
    sigprocmask(SIG_BLOCK, &set, &oldset);
    //通过alarm注册一个闹钟信号                                                                                                      
    alarm(seconds);
    //将等待函数和信号屏蔽函数合并成原子操作(sigsuspend函数可以临时解除对某个信号的屏蔽然后挂起等待，在返回后恢复信号屏蔽字)
    sigsuspend(&oldset);
    //恢复SIGALRM信号
    signal(SIGALRM, old_sig);
    //解除屏蔽SIGALRM 信号
    sigprocmask(SIG_SETMASK, &oldset, NULL);
}

九、SIGCHLD信号

我们知道解决僵尸进程的方法有wait和waitpid函数，其中wait是阻塞式的等待，使用这个方法父进程就不能做其他事了；而使用waitpid是非阻塞式的等待，但它采用轮询式的方式，实现起来比较复杂。这里我们介绍始终新的方法。

实际上，子进程会在结束时，向父进程发送SIGCHLD信号，该信号的默认处理动作是忽略，父进程可以自己定义SIGCHLD信号的处理函数,这样⽗进程只需专⼼处理⾃⼰的⼯作,不必关⼼⼦进程了,⼦进程终⽌时会通知⽗进程,⽗进程在信号处理函数中调⽤wait清理⼦进程即可。

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

typedef void (*sighandler_t)(int);
void myhandler(int signum)
{
    (void)signum;
    int stat;
    int ret = wait(&stat);
    if(ret == -1) 
        perror("wait error");
    return;
}
int main()
{
    int pid = fork();
    if(pid > 0)
    {                                                                                                                                
        signal(SIGCHLD, myhandler);
        //father
        while(1)
        {
            printf("father working\n");
            sleep(1);
        }
    }
    else if(pid == 0)
    {
        //child
        printf("child working\n");
        sleep(1);
        printf("child working\n");
        sleep(1);                                                                                                                    
        printf("child working\n");

    }
    else
    {
        perror("fork error");
    }
    return 0;
}

尝试多fork几次，这时候就有多个子进程结束，但signal函数只能处理一个子进程。那应该怎么办呢？我们可以对信号处理函数进行更改：

typedef void (*sighandler_t)(int);

void myhandler(int signum)
{
    (void)signum;
    while(1)
    {
        pid_t ret = waitpid(0, NULL, WNOHANG);
        if(ret > 0)
        {
            printf("wait pid:%d\n", ret);
            continue;
        }                                                                                                                            
        else if(ret == 0)
        {
            printf("wait end\n");
            break;
        }                                                                                                                            
        else
            break;
    }
}

上一篇：进阶SQL总结

下一篇：信号

信号