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。

相关文章

Linux脚本(shell)的使用方式

Linux脚本(shell)的使用方式

《Linux脚本(shell)的使用方式》：本文主要介绍Linux脚本(shell)的使用方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录概述语法详解数学运算表达式Shell变量变量分类环境变量Shell内部变量自定义变量：定义、赋值自定义变量：引用、修改、删
阅读更多...
Linux链表操作方式

Linux链表操作方式

《Linux链表操作方式》：本文主要介绍Linux链表操作方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、链表基础概念与内核链表优势二、内核链表结构与宏解析三、内核链表的优点四、用户态链表示例五、双向循环链表在内核中的实现优势六、典型应用场景七、调试技巧与
阅读更多...
全屋WiFi 7无死角! 华硕 RP-BE58无线信号放大器体验测评

全屋WiFi 7无死角! 华硕 RP-BE58无线信号放大器体验测评

《全屋WiFi7无死角!华硕RP-BE58无线信号放大器体验测评》家里网络总是有很多死角没有网，我决定入手一台支持Mesh组网的WiFi7路由系统以彻底解决网络覆盖问题，最终选择了一款功能非常... 自2023年WiFi 7技术标准（IEEE 802.11be）正式落地以来，这项第七代无线网络技术就以超高速
阅读更多...
详解Linux中常见环境变量的特点与设置

详解Linux中常见环境变量的特点与设置

《详解Linux中常见环境变量的特点与设置》环境变量是操作系统和用户设置的一些动态键值对,为运行的程序提供配置信息,理解环境变量对于系统管理、软件开发都很重要,下面小编就为大家详细介绍一下吧... 目录前言一、环境变量的概念二、常见的环境变量三、环境变量特点及其相关指令3.1 环境变量的全局性3.2、环境变
阅读更多...
Linux系统中的firewall-offline-cmd详解(收藏版)

Linux系统中的firewall-offline-cmd详解(收藏版)

《Linux系统中的firewall-offline-cmd详解(收藏版)》firewall-offline-cmd是firewalld的一个命令行工具,专门设计用于在没有运行firewalld服务的... 目录主要用途基本语法选项1. 状态管理2. 区域管理3. 服务管理4. 端口管理5. ICMP 阻断
阅读更多...
Linux实现线程同步的多种方式汇总

Linux实现线程同步的多种方式汇总

《Linux实现线程同步的多种方式汇总》本文详细介绍了Linux下线程同步的多种方法,包括互斥锁、自旋锁、信号量以及它们的使用示例,通过这些同步机制,可以解决线程安全问题,防止资源竞争导致的错误,示例... 目录什么是线程同步？一、互斥锁（单人洗手间规则）适用场景：特点：二、条件变量（咖啡厅取餐系统）工作流
阅读更多...
Linux中修改Apache HTTP Server(httpd)默认端口的完整指南

Linux中修改Apache HTTP Server(httpd)默认端口的完整指南

《Linux中修改ApacheHTTPServer(httpd)默认端口的完整指南》ApacheHTTPServer（简称httpd）是Linux系统中最常用的Web服务器之一,本文将详细介绍如何... 目录一、修改 httpd 默认端口的步骤1. 查找 httpd 配置文件路径2. 编辑配置文件3. 保存
阅读更多...
Linux使用scp进行远程目录文件复制的详细步骤和示例

Linux使用scp进行远程目录文件复制的详细步骤和示例

《Linux使用scp进行远程目录文件复制的详细步骤和示例》在Linux系统中,scp（安全复制协议）是一个使用SSH（安全外壳协议）进行文件和目录安全传输的命令,它允许在远程主机之间复制文件和目录,... 目录1. 什么是scp？2. 语法3. 示例示例 1: 复制本地目录到远程主机示例 2: 复制远程主
阅读更多...
Java中JSON格式反序列化为Map且保证存取顺序一致的问题

Java中JSON格式反序列化为Map且保证存取顺序一致的问题

《Java中JSON格式反序列化为Map且保证存取顺序一致的问题》：本文主要介绍Java中JSON格式反序列化为Map且保证存取顺序一致的问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未... 目录背景问题解决方法总结背景做项目涉及两个微服务之间传数据时，需要提供方将Map类型的数据序列化为co
阅读更多...
Linux基础命令@grep、wc、管道符的使用详解

Linux基础命令@grep、wc、管道符的使用详解

《Linux基础命令@grep、wc、管道符的使用详解》：本文主要介绍Linux基础命令@grep、wc、管道符的使用,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐... 目录grep概念语法作用演示一演示二演示三，带选项 -nwc概念语法作用wc，不带选项-c，统计字节数-
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2