【Linux】进程信号

最新推荐文章于 2023-06-09 18:16:36 发布

风继续吹TT

最新推荐文章于 2023-06-09 18:16:36 发布

阅读量969

点赞数 52

分类专栏： Linux 文章标签： c语言开发语言 linux 运维进程信号

本文链接：https://blog.csdn.net/Edward_Asia/article/details/124619728

版权

Linux 专栏收录该内容

18 篇文章 14 订阅

订阅专栏

5.2.1 signal、sigaction

5.3. volatile

5.4. SIGCHLD信号

1. 进程信号概念

信号是进程之间事件异步通知的一种方式，属于软中断，本质也是数据。

信号是给进程发的，进程在收到信号后，会在合适的时候执行对应的命令。

进程具有识别信号并处理信号的能力。进程收到信号，不一定会立即处理信号，在合适的时候处理，信号保存在进程PCB中。

信号是操作系统发送给进程的。

查看信号

kill -l

linux中共有62个信号，前31个为普通信号，34到64为实时信号(不学习)。

以前，我们在使用ctrl c 结束进程时，本质是向指定进程发送2号信号。

验证：

使用接口

signal：捕捉信号，修改进程对信号的默认处理动作(具体原理后面文章后面讲)
#include <signal.h>

typedef void (*sighandler_t)(int); // 函数指针

sighandler_t signal(int signum, sighandler_t handler);

代码：

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


void handler(int signo)
{
    printf("get a signal：signal no：%d, pid: %d\n", signo, getpid());
}


int main()
{
    signal(2, handler); // 通过signal捕捉信号，对2号信号的处理动作改成自定义的方式，且只有信号到来的时候这个信号才会被调用

    while(1)
    {
        printf("hello world!, pid：%d\n", getpid());
        sleep(1);
    }
    return 0;
}

运行代码，然后一直按键盘ctrl+c，尝试终止进程，但是由于我们改变了2号信号的处理方式，这里不会终止进程，只能通过其他信号终止。

键盘可以产生信号，键盘产生的信号只能用来终止前台进程，后台进程可以使用命令 kill -9 pid 杀掉。

9号信号不可被捕捉(自定义)。

一般而言，进程收到信号的处理方式有三种：

默认动作：一部分是终止自己，暂停等。

忽略动作：是一种处理方式，只不过动作就是什么也不干。

自定义动作(捕捉信号)：即修改信号的默认处理动作。

2. 信号的产生方式

2.1. 键盘产生

键盘产生信号上面已经验证了这里就不再验证。

2.2. 调用系统函数向进程发信号

系统调用接口：

kill：发送一个信号给其他进程
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid, int sig);
raise：给自己发送信号
 #include <signal.h>
 int raise(int sig);

例如：

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


static void Usage(const char* proc)
{
    printf("./test signo who\n");
}

int main(int argc, char* argv[])
{
    if(argc != 3) // 判断命令行参数
    {
        Usage(argv[0]);
        return 1;
    }
    int signo = atoi(argv[1]);
    int who = atoi(argv[2]);
    kill(who, signo); // 向指定进程发送信号

    return 0;
}

然后在命令行上产生一个sleep进程，然后运行test程序，向该进程发送9号信号结束该进程。

2.3. 由软件条件产生信号

通过某种软件(OS)，来触发信号发送，系统层面设置定时器，或者某种操作而导致条件不就绪的场景。

例如在进程间通信中：当读端不读，而且关闭了读端fd，但是写端一直在写，最终写进程会收到sigpipe(13)信号。

例如：

alarm：一定秒数后向进程发送14号信号

 #include <unistd.h>
 unsigned int alarm(unsigned int seconds);
	// 返回值为0或还剩多长时间闹钟结束

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

void handler(int signo)
{
    printf("get a signal：signal no：%d\n", signo);
    exit(0);
}

int main()
{
    int i = 1;
    for(i = 1; i <= 31; ++i)
    {
        signal(i, handler);
    }
    alarm(3); // 3秒后向进程发送14号信号

    while(1)
    {
        printf("I am a proccess\n");
        sleep(1);
    }
    return 0;
}

2.4. 程序崩溃产生信号

在Windows和Linux下进程崩溃的本质，是进程收到了对应的信号，然后进程执行信号的默认处理动作(杀死进程)

使用下面这段代码，显然可以看出这里对空指针进行了解引用操作，这里肯定会发生程序错误。

#include<stdio.h>
int main()
{
    while(1)
    {
        int *p = NULL;
        *p = 10;
        sleep(1);
    }
    return 0;
}

确实从从结果中也可以看到出现了段错误(segmentation fault)

再来对信号捕捉一下，看看这个错误是哪个信号？

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

void handler(int signo)
{
    printf("get a signal：signal no：%d, pid: %d\n", signo, getpid());
    sleep(1);
}

int main()
{
    int i = 1;
    for(i = 1; i <= 31; ++i)
    {
        signal(i, handler);
    }
    while(1)
    {
        int *p = NULL;
        *p = 10;
        sleep(1);
    }
    return 0;
}

这里的硬件异常的本质是：程序中对空指针或者野指针的解引用，会去访问这块内存，而在页表中没有映射关系，相对应的硬件MMU就会出现异常。

软件上面的错误，通常会体现在硬件或者其他软件上！

总结：

信号产生的方式虽然不同，但是最终一定都是通过OS向目标进程发送的信号！

由于收到信号后可能不会立即执行对应操作，在Linux内核中使用变量会保存信号。

进程中，采用位图来标识进程是否收到信号。

所以OS发送信号的本质是向指定进程的task_struct中的信号位图写入比特为1，所以信号的发送也可称为信号的写入。

3. waitpid接收信号

在Linux中，当一个进程退出的时候，它的退出码和退出信号都会被设置。

当一个进程异常的时候，进程的退出信号会被设置，表明当前进程的退出原因。

3.1. core dump

如果必要，操作系统会设置退出信息中的core dump标志位，并将进程在内存中的数据转储到磁盘中，还会记录程序在哪里异常，方便后期调试。

在云服务器上，将数据转储到磁盘上的功能默认是被关掉的。

查看：ulimit -a

打开该功能：ulimit -c 空间大小

如果现在运行，上面会导致程序崩溃的代码，core dump 就会起作用了，并在当前目录下形成core文件：

而在gdb调试时，通过使用dump保存的文件，就会给出崩溃原因和在哪里崩溃：这种调试方式称为事后调试。

不一定所有的退出信号都会被core dump 例如：9号信号。

3.2. status获取信号

在进程控制章节，我们讲过waipid系统调用的参数status的低8位保存的是进程退出时的信号。

来验证一下：

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

int main()
{
    if(fork() == 0)
    {
        while(1)
        {
            printf("I am child  hahaha\n");
            int a = 10;
            a /= 0;
        }
    }

    int status = 0;
    waitpid(-1, &status, 0);
    printf("exit code: %d, exit sig: %d, core dump: %d\n", (status>>8)&0xFF, status&0x7F, (status>>7)&1);
    return 0;
}

4.信号产生

4.1. 信号产生

信号在产生时可能存在一下几种情况：

实际执行信号的处理动作称为信号递达(即包括上面提到的三种处理方式：自定义捕捉、默认、忽略)。

信号从产生到递达之间的状态,称为信号未决(即信号被暂存在task_struct信号位图中)。

进程可以选择阻塞某个信号(本质进程暂时屏蔽指定信号)。

被阻塞的信号产生时将保持在未决状态,直到进程解除对此信号的阻塞,才执行递达的动作。 注意,阻塞和忽略是不同的,只要信号被阻塞就不会递达,而忽略是在递达之后可选的一种处理动作

信号在内核中的表示：

pending：保存的时已经收到，但是还没有被递达的信号。

OS发送信号的本质：修改目标进程的pending位图。

block：状态位图，表示哪些信号不应该被递达，直到解除阻塞。

handler：函数指针数组，每个信号的编号就是该数组下标，里面放的是默认、忽略、自定义处理放式的函数指针。

阻塞信号集也叫做当前进程的信号屏蔽字，这里的“屏蔽”应该理解为阻塞而不是忽略。

4.2. sigset_t

这是操作系统设置的类型，未决和阻塞标志可以用相同的数据类型sigset_t来存储,sigset_t称为信号集,这个类型可以表示每个信号的“有效”或“无效”状态, 。

sigset_t类型的变量不能单独使用，必须要配合特定的系统调用接口使用。

信号集操作函数

#include <signal.h>
int sigemptyset(sigset_t *set); // 将信号集所有的位清0
int sigfillset(sigset_t *set);  // 初始化位图，将信号集所有的位置为1
int sigaddset (sigset_t *set, int signo); // 添加信号到信号集
int sigdelset(sigset_t *set, int signo);  // 从信号集中删除信号
int sigismember（const sigset_t *set, int signo); // 是一个布尔函数,用于判断一个信号集的有效信号中是否包含某种信号,若包含则返回1,不包含则返回0,出错返回-1。

4.3. sigprocmask

调用函数sigprocmask可以读取或更改进程的信号屏蔽字(阻塞信号集) 。

#include <signal.h>
int sigprocmask(int how, const sigset_t *set, sigset_t *oset);
//返回值:若成功则为0,若出错则为-1
// set：输入型参数
// oset：输出型参数

如果oset是非空指针,则读取进程的当前信号屏蔽字通过oset参数传出。

如果set是非空指针,则更改进程的信号屏蔽字,参数how指示如何更改。

如果oset和set都是非空指针,则先将原来的信号屏蔽字备份到oset里,然后根据set和how参数更改信号屏蔽字。

how参数的可选值：

SIG_BLOCK：将set中的信号添加到信号屏蔽字中

SIG_UNBLOCK：将set中的信号从信号屏蔽字中解除阻塞

SIG_SETMASK：将信号屏蔽字设置为set

演示代码：

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

int main()
{
    sigset_t set, oset;
    sigemptyset(&set); // 初始化
    sigemptyset(&oset);
    
    sigaddset(&set, 2); // 向set中添加2号信号

    sigprocmask(SIG_BLOCK, &set, &oset); // 将set中的信号阻塞
    while(1)
    {
        printf("hello world!\n");
        sleep(1);
    }
    return 0;
}

代码中将2号信号阻塞了，那么运行代码后，发送2号信号会被阻塞。

4.4. sigpending

该系统调用不对pending表修改，而仅仅是获取进程的pending位图。

#include <signal.h>
int sigpending(sigset_t *set); // 参数为输出型参数

演示代码：

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

void show_pending(sigset_t *set)
{
    int i = 1;
    for(i = 1; i <= 31; ++i)
    {
      if(sigismember(set, i))
      {
          printf("1");
      }
      else
      {
          printf("0");
      }
    }
    printf("\n");
}

void handler(int signo)
{
    printf("2号信号已被递达，已经处理完成！\n");
}

int main()
{

    signal(2, handler); // 捕捉2号信号
    sigset_t set, oset;
    sigemptyset(&set);
    sigemptyset(&oset);
    
    sigaddset(&set, 2);

    sigprocmask(SIG_BLOCK, &set, &oset); // 阻塞2号信号
    sigset_t pending;
    
    int count = 0;

    while(1)
    {
        sigemptyset(&pending);
        sigpending(&pending); // 获取pending位图
        show_pending(&pending); // 打印pending位图
        sleep(1);
        count++;
        if(count == 10) // 10秒后解除2号信号的阻塞
        {
            sigprocmask(SIG_SETMASK, &oset, NULL); // 恢复2号信号
            printf("2号信号恢复，可以被递达!!!\n");
        }
    }
    return 0;
}

5. 信号发送后

信号什么时候被处理？

当进程从内核态返回到用户态的时候，进行信号检测并处理信号。

5.1. 用户态与内核态

用户态：用户代码和数据被访问或者执行的时候，所处的状态。自己写的代码全部都是在用户态执行。

内核态：执行OS的代码和数据时，进程所处的状态。OS的代码的执行全部都是在内核态执行(例如系统调用)。

主要区别：权限大小，内核态权限远远大于用户态。

用户态使用的是用户级页表，只能访问用户数据和代码；内核态使用的是内核级页表，只能访问内核数据和代码。

CPU内有寄存器保存了当前进程的状态。

所谓系统调用：就是进程的身份转化成为内核，然后根据内核页表找到对应函数执行。

5.2. 信号捕捉

信号捕捉本质是修改handler表中的内容。

内核实现信号捕捉的过程大致是下图这样：

上图可简化抽象为：

5.2.1 signal、sigaction

signal方法文章开始已经讲解，这里不再演示。
#include <signal.h>

typedef void (*sighandler_t)(int); // 函数指针

sighandler_t signal(int signum, sighandler_t handler);

sigaction：类似signal方法，捕捉信号，自定义信号

#include <signal.h>
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
// act：新的处理动作
// oldact：原来的处理动作

// act 结构体
struct sigaction 
{
    void     (*sa_handler)(int);
    void     (*sa_sigaction)(int, siginfo_t *, void *);
    sigset_t   sa_mask;
    int        sa_flags;
    void     (*sa_restorer)(void);
};
//当某个信号的处理函数被调用时, 内核自动将当前信号加入进程的信号屏蔽字, 当信号处理函数返回时自动恢复原来的信号屏蔽字,这样就保证了在处理某个信号时, 如果这种信号再次产生, 那么它会被阻塞到当前处理结束为止(即同一个信号不能被嵌套使用)。

//如果在调用信号处理函数时,除了当前信号被自动屏蔽之外,还希望自动屏蔽另外一些信号, 则用sa_mask字段说明这些需要额外屏蔽的信号, 当信号处理函数返回时自动恢复原来的信号屏蔽字。 

//sa_flags字段包含一些选项, 本章的代码都把sa_flags设为0, sa_sigaction是实时信号的处理函数, 本章不详细解释这两个字段

演示代码：

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


void handler(int signo)
{
    printf("get a signo: %d\n", signo);
}

int main()
{
    struct sigaction act;
    memset(&act, 0, sizeof(act));
    act.sa_handler = handler;
    
	// 本质是修改当前进程的handler函数指针数组的特定内容
    sigaction(2, &act, NULL); // 捕捉2号信号
    while(1)
    {
        printf("hello world!\n");
        sleep(1);
    }
    return 0;
}

5.3. volatile

volatile 作用：

保持内存的可见性，告知编译器，被该关键字修饰的变量，不允许被优化，对该变量的任何操作，都必须在真实的内存中进行操作

这句话是什么意思呢？我们用下面这段代码来解释：

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

int flag = 0;
//volatile int flag = 0;

void handle(int signo)
{
    flag = 1;  // 将flag改为1
    printf("change flag 0 to 1!\n");
}


int main()
{
    signal(2, handle);
    while(!flag); // flag为0时死循环，flag为1时退出循环
    printf("该进程正常退出！\n");
    return 0;
}

正常编译情况下，该程序是死循环的，如果向进程发送2号信号，循环退出，进程结束。

但是如果，在编译时加上优化，例如gcc -O3 选项，会对该程序进行优化

优化过程：

首先，flag是个全局变量，会为他在内存上开辟空间，并且while循环条件的判断室友CPU完成的。

在main函数中的while循环中，编译认为没有地方会对flag变量进行修改，那么它就将flag变量直接放入CPU的寄存器中，下一次循环时将不会再从内存中寻找flag变量加载到CPU的寄存器上进行判断，而是直接在CPU的寄存器中判断flag。导致内存上的flag发生改变时，寄存器中的flag不会改变，所以程序的运行结果可能就会出现问题。

所以就算向进程发送了2号信号，进程也不会终止：

在flag变量前加上volatile就可防止这种情况的发生。

5.4. SIGCHLD信号

子进程在退出时其实会向e'eee父进程发送SGCHLD信号，表示自己退出了。

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

void handle(int signo)
{
    printf("get a signo: %d\n", signo);
}

int main()
{
    signal(SIGCHLD, handle);
    pid_t pid = fork();
    if(pid==0)
    {//child
        int count = 5;
        while(count--)
        {
            printf("I am child, running!\n");
            sleep(1);
        }
        exit(0);
    }
    
  while(1);
    return 0;
}

并且，现在在子进程退出时，我们可以不用使用父进程等待子进程；

而可以直接将SIGCHLD信号捕获，将它的处理方式改为忽略：

signal(SIGCHLD, SIG_IGN); // 显式设置忽略17号信号，当子进程退出后，自动释放僵尸进程

风继续吹TT

关注

52
点赞
踩
29

收藏

觉得还不错? 一键收藏
打赏
44
评论
【Linux】进程信号

1. 进程信号概念信号是进程之间事件异步通知的一种方式，属于软中断，本质也是数据。信号是给进程发的，进程在收到信号后，会在合适的时候执行对应的命令。进程具有识别信号并处理信号的能力。进程收到信号，不一定会立即处理信号，在合适的时候处理，信号保存在进程PCB中。信号是操作系统发送给进程的。查看信号kill -llinux中共有62个信号，前31个为普通信号，34到64为实时信号(不学习)。以前，我们在使用ctrl c 结束进程时，本质是向指定进程发送2号信号。.
复制链接

扫一扫