Linux signal 那些事儿（4）信号的deliver顺序

2023-11-01 16:59
文章标签 linux 顺序 信号 signal 事儿 deliver

本文主要是介绍Linux signal 那些事儿（4）信号的deliver顺序，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

from : http://blog.chinaunix.net/uid-24774106-id-4084864.html


上一篇博文提到了，如果同时有多个不同的信号处于挂起状态，kernel如何选择deliver那个信号。
    
    next_signal 负责从挂起信号中选择deliver的signo：当然，有线程显存私有的penging，有线程组共有的pending，对于线程而言，先从自己私有的pending中选，处理完毕私有的才会去处理线程组共有的pending，这个逻辑的代码在：

  1. int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
  2. {
  3.     int signr;

  5.     /* We only dequeue private signals from ourselves, we don't let
  6.      * signalfd steal them
  7.      */
  8.     signr = __dequeue_signal(&tsk->pending, mask, info);  //线程私有的penging优先
  9.     if (!signr) {
  10.         signr = __dequeue_signal(&tsk->signal->shared_pending,
  11.                      mask, info);
  12.        。。。。
  13. }
    换句话说，如果存在挂起队列中，我们用tkill/tgkill发送的信号会先于用kill发送的信号被deliver，这个我们按下不提，我们看在同一个penging队列中如何挑选下个deliver的signal：
  1. int next_signal(struct sigpending *pending, sigset_t *mask)
  2. {
  3.     unsigned long i, *s, *m, x;
  4.     int sig = 0;

  6.     s = pending->signal.sig;
  7.     m = mask->sig;

  9.     /*
  10.      * Handle the first word specially: it contains the
  11.      * synchronous signals that need to be dequeued first.
  12.      */
  13.     x = *s &~ *m;
  14.     if (x) {
  15.         if (x & SYNCHRONOUS_MASK)
  16.             x &= SYNCHRONOUS_MASK;
  17.         sig = ffz(~x) + 1;
  18.         return sig;
  19.     }

  21.     switch (_NSIG_WORDS) {
  22.     default:
  23.         for (i = 1; i < _NSIG_WORDS; ++i) {
  24.             x = *++s &~ *++m;
  25.             if (!x)
  26.                 continue;
  27.             sig = ffz(~x) + i*_NSIG_BPW + 1;
  28.             break;
  29.         }
  30.         break;

  32.     case 2:
  33.         x = s[1] &~ m[1];
  34.         if (!x)
  35.             break;
  36.         sig = ffz(~x) + _NSIG_BPW + 1;
  37.         break;

  39.     case 1:
  40.         /* Nothing to do */
  41.         break;
  42.     }

  44.     return sig;
  45. }
  1. #define SYNCHRONOUS_MASK \
  2.     (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
  3.      sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))

    上一篇博客讲了处于 SYNCHRONOUS_MASK 里面的信号是优先处理的信号，他们都是一些硬件相关 的信号，多是由于异常出错引起。其次是传统信号，[32,64 ]之间的实时信号，优先级最低。
    换句话说所有信号分成三个等级，{SIGILL( 4),SIGTRAP( 5),SIGBUS(7),SIGFPE(8),SIGSEGV(11),SIGSYS(31) },这是第一等级，传统信号中排除第一等级的信号，就是第二等级的信号，[34,64 ]之间的信号属于第三等级。如果同一等级内，存在多个信号，按照小信号优先的顺序去deliver。
    举个例子:   
  1. kill -10 $signal_pid
  2. kill -3 $signal_pid
  3. kill -12 $signal_pid
  4. kill -11 $signal_pid
  5. kill -39 $signal_pid
  6. kill -2 $signal_pid
  7. kill -5 $signal_pid
  8. kill -4 $signal_pid
  9. kill -36 $signal_pid
  10. kill -24 $signal_pid
  11. kill -38 $signal_pid
  12. kill -37 $signal_pid
  13. kill -31 $signal_pid
  14. kill -8 $signal_pid
  15. kill -7 $signal_pid
    我们可以看到，我们向同一进程发送多个信号，加入进程阻塞了所有信号（当然SIGKILL/SIGSTOP 不考虑 ）。这时候，这些个信号，都会位于挂起信号之中，一旦进程解除阻塞，那么考验deliver顺序的时候到了。
    我们按照kernel的规则，顺序应该是{4,5,7,8,11,31,           2,3，10,12,24,              36,37,38 }这么个顺序。
    写个测试程序：   
  1. root@manu-hacks:~/Dropbox/Note/signal# cat signal_delivery_order.c 
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <signal.h>
  6. #include <string.h>
  7. #include <errno.h>


  10. static int sig_cnt[NSIG];
  11. static number= 0 ;
  12. int sigorder[128]= {0};

  14. #define MSG "#%d:receiver signal %d\n"

  16. void handler(int signo)
  17. {
  18.     sigorder[number++] = signo;
  19. }

  21. int main(int argc,char* argv[])
  22. {
  23.     int i = 0; 
  24.     int k = 0;
  25.     sigset_t blockall_mask ;
  26.     sigset_t pending_mask ; 
  27.     sigset_t empty_mask ; 
  28.     struct sigaction sa ;
  29.     

  31.     sigfillset(&blockall_mask);
  32. #ifdef USE_SIGACTION
  33.     sa.sa_handler = handler;
  34.     sa.sa_mask = blockall_mask ; 
  35.     sa.sa_flags = SA_RESTART;
  36. #endif


  39.     printf("%s:PID is %ld\n",argv[0],getpid());

  41.     
  42.     for(i = 1; i < NSIG; i++)
  43.     {
  44.         if(i == SIGKILL || i == SIGSTOP)
  45.             continue;
  46. #ifdef USE_SIGACTION 
  47.         if(sigaction(i,&sa, NULL)!=0)
  48. #else 
  49.         if(signal(i,handler)== SIG_ERR)
  50. #endif 
  51.         {
  52.             fprintf(stderr,"sigaction for signo(%d) failed (%s)\n",i,strerror(errno));
  53. //            return -1;
  54.         }
  55.     }

  57.     if(argc > 1)
  58.     {
  59.         int sleep_time = atoi(argv[1]);

  61.         if(sigprocmask(SIG_SETMASK,&blockall_mask,NULL) == -1)
  62.         {
  63.             fprintf(stderr,"setprocmask to block all signal failed(%s)\n",strerror(errno));
  64.             return -2;
  65.         }

  67.         printf("I will sleep %d second\n",sleep_time);

  69.         sleep(sleep_time);
  70.         if(sigpending(&pending_mask) == -1)
  71.         {
  72.             fprintf(stderr,"sigpending failed(%s)\n",strerror(errno));
  73.             return -2;
  74.         }

  76.         for(i = 1 ; i < NSIG ; i++)
  77.         {
  78.             if(sigismember(&pending_mask,i))
  79.             printf("signo(%d) :%s\n",i,strsignal(i));
  80.         }

  82.         sigemptyset(&empty_mask);
  83.         if(sigprocmask(SIG_SETMASK,&empty_mask,NULL) == -1)
  84.         {
  85.             fprintf(stderr,"setprocmask to release all signal failed(%s)\n",strerror(errno));
  86.             return -3;
  87.         }

  89.         for( i = 0 ; i < 1000000 ; i++)
  90.         {
  91.             k = random()%1234567;
  92.             
  93.         }
  94.         
  95.     }

  97.     for(i = 0 ; i< number ; i++)
  98.     {
  99.      if(sigorder[i] != 0)
  100.         {
  101.             printf("#%d: signo=%d\n",i,sigorder[i]);
  102.         }
  103.     }

  105.     return 0;

  107. }
    注意这个USE_SIGACTION宏包裹的部分是我后来想到的，在我开始的版本中用的是signal（i,handler）来注册函数。handler函数很有意思，是我精心设计的：  
  1. void handler(int signo)
  2. {
  3.     sigorder[number++] = signo;
  4. }
   按照执行的顺序，我会讲signo的值记录在全局数组中，等到进程退出前，我打印数组的值，就能得到信号deliver的顺序。
    这个进程会阻塞 所有信号一段时间，在这段时间内，我会向该进程发送一坨信号，待阻塞解除后，打印数组的值，从而获得deliver的顺序。
    看下测试程序：   
  1. root@manu-hacks:~/code/c/self/signal_deliver# cat test_order.sh 
    #!/bin/bash 


    if [ $1 -eq 0 ]
    then
    ./sigaction_delivery_order  30  &    #正确的程序
    else
    ./signal_delivery_order  30 &        #我最初的程序，信号处理函数执行期间，没有屏蔽其他信号。
    fi
    signal_pid=$!


    sleep 2
    kill -10  $signal_pid
    kill -3  $signal_pid
    kill -12  $signal_pid
    kill -11  $signal_pid
    kill -39  $signal_pid
    kill -2   $signal_pid
    kill -5   $signal_pid
    kill -4   $signal_pid
    kill -36  $signal_pid
    kill -24  $signal_pid
    kill -38  $signal_pid
    kill -37  $signal_pid
    kill -31  $signal_pid
    kill -8   $signal_pid
    kill -7   $signal_pid


    设计很精巧，设计出这个程序后，我很得意，认为验证deliver传递顺序是水到渠成的事情。
    梦想很丰满，无奈现实很骨感，我看了执行结果，那是当头一棒啊：
  1. root@manu-hacks:~/Dropbox/Note/signal# 
  2. root@manu-hacks:~/Dropbox/Note/signal# ./test_order.sh 1 
  3. ./signal_delivery_order:PID is 31403
  4. sigaction for signo(32) failed (Invalid argument)
  5. sigaction for signo(33) failed (Invalid argument)
  6. I will sleep 30 second
  7. root@manu-hacks:~/Dropbox/Note/signal# signo(2) :Interrupt
  8. signo(3) :Quit
  9. signo(4) :Illegal instruction
  10. signo(5) :Trace/breakpoint trap
  11. signo(7) :Bus error
  12. signo(8) :Floating point exception
  13. signo(10) :User defined signal 1
  14. signo(11) :Segmentation fault
  15. signo(12) :User defined signal 2
  16. signo(24) :CPU time limit exceeded
  17. signo(31) :Bad system call
  18. signo(36) :Real-time signal 2
  19. signo(37) :Real-time signal 3
  20. signo(38) :Real-time signal 4
  21. signo(39) :Real-time signal 5
  22. #0: signo=39
  23. #1: signo=38
  24. #2: signo=37
  25. #3: signo=36
  26. #4: signo=24
  27. #5: signo=12
  28. #6: signo=10
  29. #7: signo=3
  30. #8: signo=2
  31. #9: signo=31
  32. #10: signo=11
  33. #11: signo=8
  34. #12: signo=7
  35. #13: signo=5
  36. #14: signo=4
    顺序恰恰相反！！！！
     我最初完全解释不通，我google了类似的topic，我发现，我不是第一个发现这个问题的人，绚丽也尘埃在一篇博客中提到： 
  1. 在网上找到这样一段话：
  2. 信号的优先级：信号实质上是软中断，中断有优先级，信号也有优先级。如果一个进程有多个未决信号，则对于同一个未决的实时信号，内核将按照发送的顺序来递送信号。如果存 在多个未决的实时信号，则值（或者说编号）越小的越先被递送。如果既存在不可靠信号，又存在可靠信号（实时信号），虽然POSIX对这一情况没有明确规 定，但Linux系统和大多数遵循POSIX标准的操作系统一样，将优先递送不可靠信号。

  4. 经过我反反复复地试验，我发现实验结果和上面描述的刚好相反，信号的编号越大越先被递送，一个进程如果处理SIGQUIT(3),SIGINT(2),SIGHUP(1)（通过”kill -l”可以查看信号的编号），那么先后给该进程发送SIGINT,SIGHUP,SIGQUIT，处理的顺序会是SIGQUIT,SIGINT,SIGHUP，不论改变这个三个信号的发送顺序，处理的顺序都是一样的。
    看到了，这位前辈遇到了和我一样的困惑，测试的结果和kernel完全相反。内核不会错，glibc也肯定不会瞎掺合，一定是我的测试程序存在问题：
    今天我坐公交车上，突然意识到问题的所在，我的信号处理函数没有屏蔽信号！！！
    换句话说，4号信号是先被deliver的，但是还没能handler执行，被5号信号中断掉了，5号信号还没开始执行，被7号信号中断掉了，依次类推，所以我们测试的结果和deliver的结果正好相反。
    意识到这一点，我就改进了我的程序，信号执行期间，屏蔽所有信号，这样，就能测试信号deliver的顺序了。对于我的程序而言就是加上-DUSE_SIGACTION选项，让sigaction安装信号时，指明信号处理函数执行期间，屏蔽所有信号。
     在我的64位Ubuntu上执行，结果和kernel代码以及手册上的一样。也就是说，并不是手册描述错了，而是我们的老的测试程序，在signal处理期间，没有屏蔽其他信号导致混乱。那么按照正确的方法测试：
  1. root@manu-hacks:~/code/c/self/signal_deliver# ./test_order.sh 0 
  2. ./sigaction_delivery_order:PID is 3652
  3. sigaction for signo(32) failed (Invalid argument)
  4. sigaction for signo(33) failed (Invalid argument)
  5. I will sleep 30 second
  6. root@manu-hacks:~/code/c/self/signal_deliver# signo(2) :Interrupt
  7. signo(3) :Quit
  8. signo(4) :Illegal instruction
  9. signo(5) :Trace/breakpoint trap
  10. signo(7) :Bus error
  11. signo(8) :Floating point exception
  12. signo(10) :User defined signal 1
  13. signo(11) :Segmentation fault
  14. signo(12) :User defined signal 2
  15. signo(24) :CPU time limit exceeded
  16. signo(31) :Bad system call
  17. signo(36) :Real-time signal 2
  18. signo(37) :Real-time signal 3
  19. signo(38) :Real-time signal 4
  20. signo(39) :Real-time signal 5
  21. #0: signo=4
  22. #1: signo=5
  23. #2: signo=7
  24. #3: signo=8
  25. #4: signo=11
  26. #5: signo=31
  27. #6: signo=2
  28. #7: signo=3
  29. #8: signo=10
  30. #9: signo=12
  31. #10: signo=24
  32. #11: signo=36
  33. #12: signo=37
  34. #13: signo=38
  35. #14: signo=39
     和我们预想的完全符合，和内核代码已经手册完全一样。那么这个问题完美解决。
  1. {4,5,7,8,11,31, 2,3，10,12,24, 36,37,38}
     多个挂起信号时，delivery的策略如下：     
    1   {SIGILL( 4),SIGTRAP( 5),SIGBUS(7),SIGFPE(8),SIGSEGV(11),SIGSYS(31) }第一等级
    2  非实时信号中其他信号是第二等级（SIGKILL SIGSTOP除外）
    3  实时信号是第三等级。
    存在第一等级的信号挂起，那么优先选择第一等级，
     没有第一等级，那么如果存在第二等级的信号，优先选择第二等级内信号。 
    既没有第一等级，又没有第二等级，那么选择第三等级的信号。
    如果同一个等级内都存在多个挂起信号，则小信号优先。

    这只是我们用程序测试的结果，其实systemtap提供了signal_deliver这个event让我们monitor，我们可以直观的看到信号传递的顺序:   
  1. root@manu-hacks:~/code/c/self/signal_deliver# cat signal_deliver.stp 
  2. probe kernel.trace("signal_deliver"){
  3.     if(pid() == target())
  4.     {
  5.      printf("signo(%2d) is delivered to PID %8d\n",$sig,pid());
  6.     }
  7. }
     我们可以用test_order.sh 1 ,故意用signal那个给我带来困扰的程序测试，我们会看到，传递的顺序依然是对的，这证明了我前面的推测，4是最先deliver的，只不过是因为没有屏蔽其他信号，被5号信号中断了，5又被7号信号中断了，依次类推，导致了我们看到了相反的执行顺序，给我们带来了困扰。  
  1. root@manu-hacks:~/code/c/self/signal_deliver# ./test_order.sh 1
    ./signal_delivery_order:PID is 4051
    sigaction for signo(32) failed (Invalid argument)
    sigaction for signo(33) failed (Invalid argument)
    I will sleep 30 second
    root@manu-hacks:~/code/c/self/signal_deliver# stap -x 4051 signal_deliver.stp 
    signo(2) :Interrupt
    signo(3) :Quit
    signo(4) :Illegal instruction
    signo(5) :Trace/breakpoint trap
    signo(7) :Bus error
    signo(8) :Floating point exception
    signo(10) :User defined signal 1
    signo(11) :Segmentation fault
    signo(12) :User defined signal 2
    signo(24) :CPU time limit exceeded
    signo(31) :Bad system call
    signo(36) :Real-time signal 2
    signo(37) :Real-time signal 3
    signo(38) :Real-time signal 4
    signo(39) :Real-time signal 5
    #0: signo=39
    #1: signo=38
    #2: signo=37
    #3: signo=36
    #4: signo=24
    #5: signo=12
    #6: signo=10
    #7: signo=3
    #8: signo=2
    #9: signo=31
    #10: signo=11
    #11: signo=8
    #12: signo=7
    #13: signo=5
    #14: signo=4
    signo( 4)  is delivered to PID     4051
    signo( 5)  is delivered to PID     4051
    signo( 7)  is delivered to PID     4051
    signo( 8)  is delivered to PID     4051
    signo(11)  is delivered to PID     4051
    signo(31)  is delivered to PID     4051
    signo( 2)  is delivered to PID     4051
    signo( 3)  is delivered to PID     4051
    signo(10)  is delivered to PID     4051
    signo(12)  is delivered to PID     4051
    signo(24)  is delivered to PID     4051
    signo(36)  is delivered to PID     4051
    signo(37)  is delivered to PID     4051
    signo(38)  is delivered to PID     4051
    signo(39)  is delivered to PID     4051


    ^Croot@manu-hacks:~/code/c/self/signal_deliver# 


     话说systemtap提供了很多signal相关的example脚本，非常好用，如下图，收集signal的发送情况：
    

参考文献
1  Linux实时信号排队
2  LKML：
    Subject [PATCH -tip v4 2/3] tracepoint: Add signal deliver even

这篇关于Linux signal 那些事儿（4）信号的deliver顺序的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/324435。

相关文章

ElasticSearch+Kibana通过Docker部署到Linux服务器中操作方法

ElasticSearch+Kibana通过Docker部署到Linux服务器中操作方法

《ElasticSearch+Kibana通过Docker部署到Linux服务器中操作方法》本文介绍了Elasticsearch的基本概念,包括文档和字段、索引和映射,还详细描述了如何通过Docker... 目录1、ElasticSearch概念2、ElasticSearch、Kibana和IK分词器部署
阅读更多...
Linux流媒体服务器部署流程

Linux流媒体服务器部署流程

《Linux流媒体服务器部署流程》文章详细介绍了流媒体服务器的部署步骤,包括更新系统、安装依赖组件、编译安装Nginx和RTMP模块、配置Nginx和FFmpeg,以及测试流媒体服务器的搭建... 目录流媒体服务器部署部署安装1.更新系统2.安装依赖组件3.解压4.编译安装（添加RTMP和openssl模块
阅读更多...
linux下多个硬盘划分到同一挂载点问题

linux下多个硬盘划分到同一挂载点问题

《linux下多个硬盘划分到同一挂载点问题》在Linux系统中,将多个硬盘划分到同一挂载点需要通过逻辑卷管理（LVM）来实现,首先,需要将物理存储设备（如硬盘分区）创建为物理卷,然后,将这些物理卷组成... 目录linux下多个硬盘划分到同一挂载点需要明确的几个概念硬盘插上默认的是非lvm总结Linux下多
阅读更多...
Python中顺序结构和循环结构示例代码

Python中顺序结构和循环结构示例代码

《Python中顺序结构和循环结构示例代码》：本文主要介绍Python中的条件语句和循环语句,条件语句用于根据条件执行不同的代码块,循环语句用于重复执行一段代码,文章还详细说明了range函数的使... 目录一、条件语句（1）条件语句的定义（2）条件语句的语法（a）单分支 if（b）双分支 if-else（
阅读更多...
关于Spring @Bean 相同加载顺序不同结果不同的问题记录

关于Spring @Bean 相同加载顺序不同结果不同的问题记录

《关于Spring@Bean相同加载顺序不同结果不同的问题记录》本文主要探讨了在Spring5.1.3.RELEASE版本下,当有两个全注解类定义相同类型的Bean时,由于加载顺序不同,最终生成的... 目录问题说明测试输出1测试输出2@Bean注解的BeanDefiChina编程nition加入时机总结问题说明
阅读更多...
linux进程D状态的解决思路分享

linux进程D状态的解决思路分享

《linux进程D状态的解决思路分享》在Linux系统中,进程在内核模式下等待I/O完成时会进入不间断睡眠状态（D状态）,这种状态下,进程无法通过普通方式被杀死,本文通过实验模拟了这种状态,并分析了如... 目录1. 问题描述2. 问题分析3. 实验模拟3.1 使用losetup创建一个卷作为pv的磁盘3.
阅读更多...
使用C++将处理后的信号保存为PNG和TIFF格式

使用C++将处理后的信号保存为PNG和TIFF格式

《使用C++将处理后的信号保存为PNG和TIFF格式》在信号处理领域,我们常常需要将处理结果以图像的形式保存下来,方便后续分析和展示,C++提供了多种库来处理图像数据,本文将介绍如何使用stb_ima... 目录1. PNG格式保存使用stb_imagephp_write库1.1 安装和包含库1.2 代码解
阅读更多...
C++实现封装的顺序表的操作与实践

C++实现封装的顺序表的操作与实践

《C++实现封装的顺序表的操作与实践》在程序设计中,顺序表是一种常见的线性数据结构,通常用于存储具有固定顺序的元素,与链表不同,顺序表中的元素是连续存储的,因此访问速度较快,但插入和删除操作的效率可能... 目录一、顺序表的基本概念二、顺序表类的设计1. 顺序表类的成员变量2. 构造函数和析构函数三、顺序表
阅读更多...
Linux环境变量&&进程地址空间详解

Linux环境变量&&进程地址空间详解

《Linux环境变量&&进程地址空间详解》本文介绍了Linux环境变量、命令行参数、进程地址空间以及Linux内核进程调度队列的相关知识,环境变量是系统运行环境的参数,命令行参数用于传递给程序的参数,... 目录一、初步认识环境变量1.1常见的环境变量1.2环境变量的基本概念二、命令行参数2.1通过命令编程
阅读更多...
Linux之进程状态&&进程优先级详解

Linux之进程状态&&进程优先级详解

《Linux之进程状态&&进程优先级详解》文章介绍了操作系统中进程的状态,包括运行状态、阻塞状态和挂起状态,并详细解释了Linux下进程的具体状态及其管理,此外,文章还讨论了进程的优先级、查看和修改进... 目录一、操作系统的进程状态1.1运行状态1.2阻塞状态1.3挂起二、linux下具体的状态三、进程的
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2