码迷，mamicode.com
首页 > 系统相关 > 详细

Linux signal 那些事儿（2）【转】

时间：2017-05-12 11:37:02      阅读：345      评论：0      收藏：0      [点我收藏+]

标签：failed   special   handler   函数   limited   nal   ignore   time   数字   

转自：http://blog.chinaunix.net/uid-24774106-id-4064447.html

上一篇博文，基本算是给glibc的signal函数翻了个身。现在glibc的signal基本修正了传统的UNIX的一些弊端，我们说signal并没有我们想象的那么不堪。但是signal也有不尽人意的地方。比如信号处理期间，我们期望屏蔽某些信号，而不仅仅是屏蔽自身，这时候signal就不行了。信号既然是进程间通信IPC的一种机制，我们期望获取更多的信息，而不仅仅是signo，这时候signal/kill这个机制就基本不行了。
    上面所说的都是signal的一些毛病，但是这些都不是致命的，致命的问题在于老的signal机制的不可靠。信号分成可靠性信号和非可靠性信号，并不是说用sigaction安装，用sigqueue发送的信号就是可靠性性信号，用signal安装，kill/tkill发送的信号就是非可靠性信号。这种理解是错误的。这在Linux环境进程间通信（二）：信号（上）一文中讲的非常清楚了。
    信号值位于[SIGRTMIN,SIGRTMAX] 之间的信号，就是可靠信号，位于[SIGHUP,SIGSYS]之间信号，都是非可靠性信号，与安装函数是signal还是sigaction无关，与发送函数是kill还是sigqueue无关。
技术分享
    1～31之间的所有信号都称为不可靠信号，原因就在于信号不可排队，如果kernel发现同一个信号已经有挂起信号，当前信号就会被丢弃，就好象从来没有被发送过一样，无法引起信号的传递，也无法让进程执行信号处理函数。这种实现的机理，造成了这些信号的不可靠。这正所谓：我本将心向明月，奈何明月照沟渠。
    为了解决这个问题，Linux引入了实时信号,信号值在[32~64]区间内，或者称之为可靠信号。这种信号，kernel不会ignore，哪怕已经有了好多同一个信号，kernel会把新收到信号放入queue之中，等待被传递出去。
    空口说白话，不是我们的风格，我现在用代码证明之。我参考了Linux Programming Interface 一书的例子，写了两个程序，一个是signal_receiver ,一个是signal_sender.
    先看signal_receiver的code：    

  1. manu@manu-hacks:~/code/c/self/signal$ cat signal_receiver.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 volatile sig_atomic_t get_SIGINT = 0;

  13. void handler(int signo)
  14. {
  15.     if(signo == SIGINT)
  16.         get_SIGINT = 1;
  17.     else
  18.         sig_cnt[signo]++;
  19. }

  21. int main(int argc,char* argv[])
  22. {
  23.     int i = 0;
  24.     sigset_t blockall_mask ;
  25.     sigset_t pending_mask ;
  26.     sigset_t empty_mask ;
  27.     printf("%s:PID is %ld\n",argv[0],getpid());

  29.     
  30.     for(i = 1; i < NSIG; i++)
  31.     {
  32.         if(i == SIGKILL || i == SIGSTOP)
  33.             continue;

  35.         if(signal(i,&handler) == SIG_ERR)
  36.         {
  37.             fprintf(stderr,"signal for signo(%d) failed (%s)\n",i,strerror(errno));
  38. //            return -1;
  39.         }
  40.     }

  42.     if(argc > 1)
  43.     {
  44.         int sleep_time = atoi(argv[1]);
  45.         sigfillset(&blockall_mask);

  47.         if(sigprocmask(SIG_SETMASK,&blockall_mask,NULL) == -1)
  48.         {
  49.             fprintf(stderr,"setprocmask to block all signal failed(%s)\n",strerror(errno));
  50.             return -2;
  51.         }

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

  55.         sleep(sleep_time);
  56.         if(sigpending(&pending_mask) == -1)
  57.         {
  58.             fprintf(stderr,"sigpending failed(%s)\n",strerror(errno));
  59.             return -2;
  60.         }

  62.         for(i = 1 ; i < NSIG ; i++)
  63.         {
  64.             if(sigismember(&pending_mask,i))
  65.             printf("signo(%d) :%s\n",i,strsignal(i));
  66.         }

  68.         sigemptyset(&empty_mask);
  69.         if(sigprocmask(SIG_SETMASK,&empty_mask,NULL) == -1)
  70.         {
  71.             fprintf(stderr,"setprocmask to release all signal failed(%s)\n",strerror(errno));
  72.             return -3;
  73.         }
  74.         
  75.     }

  77.     while(!get_SIGINT)
  78.         continue ; //why not use pause ? I will explain later

  80.     for(i = 1; i < NSIG ; i++)
  81.     {
  82.         if(sig_cnt[i] != 0 )
  83.         {
  84.             printf("%s:signal %d caught %d time%s\n",
  85.                     argv[0],i,sig_cnt[i],(sig_cnt[i] >1)?"s":"");
  86.         }
  87.     }

  89.     return 0;

  91. }

     因为我们知道，SIGKILL和SIGSTOP这两个信号是不能够定制自己的信号处理函数的，当然也不能block，原因很简单，OS或者说root才是final boss，必须有稳定终结进程的办法。假如所有的信号，进程都能ignore，OS如何终结进程？
    这个signal_receiver会等待所有的信号，接收到某信号后，该信号的捕捉到的次数++，SIGINT会终结进程，进程退出前，会打印信号的捕捉统计。
    如果进程有参数，表示sleep时间，signal_receiver会先屏蔽所有信号（当然，SIGKILL和SIGSTOP并不能被真正屏蔽）。然后sleep 一段时间后，取消信号屏蔽。我们可以想象，在信号屏蔽期间，我们收到的信号，都会在kernel记录下来，但是并不能delivery，这种信号称之挂起信号。如果在sleep期间或者说信号屏蔽期间，我收到SIGUSR1 这个信号1次和10000次，对内核来说，都是没差别的，因为后面的9999次都会被ignore掉。SIGUSR1属于不可靠信号，位图表示有没有挂起信号，有的话，直接ignore，没有的话，则记录在kernel。
    然后我们看下，signal_sender： 

  1. manu@manu-hacks:~/code/c/self/signal$ cat signal_sender.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <getopt.h>
  5. #include <signal.h>
  6. #include <string.h>
  7. #include <errno.h>

  9. void usage()
  10. {
  11.     fprintf(stderr,"USAGE:\n");
  12.     fprintf(stderr,"--------------------------------\n");
  13.     fprintf(stderr,"signal_sender pid signo times\n");
  14. }

  16. int main(int argc,char* argv[])
  17. {
  18.     pid_t pid = -1 ;
  19.     int signo = -1;
  20.     int times = -1;
  21.     int i ;


  24.     if(argc < 4 )
  25.     {
  26.         usage();
  27.         return -1;
  28.     }
  29.     
  30.     pid = atol(argv[1]);
  31.     signo = atoi(argv[2]);
  32.     times = atoi(argv[3]);

  34.     if(pid <= 0 || times < 0 || signo <1 ||signo >=64 ||signo == 32 || signo ==33)
  35.     {
  36.         usage();
  37.         return -1;
  38.     }

  40.     printf("pid = %ld,signo = %d,times = %d\n",pid,signo,times);

  42.     for( i = 0 ; i < times ; i++)
  43.     {
  44.         if(kill(pid,signo) == -1)
  45.         {
  46.             fprintf(stderr, "send signo(%d) to pid(%ld) failed,reason(%s)\n",signo,pid,strerror(errno));
  47.             return -2;
  48.         }
  49.     }
  50.     fprintf(stdout,"done\n");
  51.     return 0;

  53. }

     signal_sender需要三个参数，pid signo times，就是向拿个进程发送什么信号多少次的意思。如 signal_sender 1234 10 10000,含义是向pid=1234的 进程发送10号信号（SIGUSR1），连续发送10000次。
    有这两个进程，我们就可以实验了  。 

  1. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver &
  2. [1] 23416
  3. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver:PID is 23416
  4. signal for signo(32) failed (Invalid argument)
  5. signal for signo(33) failed (Invalid argument)

  7. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 23416 10 10000
  8. pid = 23416,signo = 10,times = 10000
  9. done
  10. manu@manu-hacks:~/code/c/self/signal$ sleep 20 ; ./signal_sender 23416 2 1
  11. pid = 23416,signo = 2,times = 1
  12. done
  13. ./signal_receiver:signal 10 caught 2507 times
  14. [1]+ Done ./signal_receiver

    signal_receiver等待signal的来临，singal_sender向其发送SIGUSR1 10000次，然后sleep 20秒，确保sig_receiver处理完成。但是我们发现，其实一共才caught信号SIGUSR1  2507次，7000多次的发送都丢失了，所以我们称SIGUSR1 是非可靠信号，存在丢信号的问题。
    俗话说不怕不识货，就怕货比货 ，我们让可靠信号参战，看下效果：

  1. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver &
  2. [1] 26067
  3. ./signal_receiver:PID is 26067
  4. signal for signo(32) failed (Invalid argument)
  5. signal for signo(33) failed (Invalid argument)
  6. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 26067 10 10000
  7. pid = 26067,signo = 10,times = 10000
  8. done
  9. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 26067 36 10000
  10. pid = 26067,signo = 36,times = 10000
  11. done
  12. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 26067 2 1
  13. pid = 26067,signo = 2,times = 1
  14. done
  15. ./signal_receiver:signal 10 caught 2879 times
  16. ./signal_receiver:signal 36 caught 10000 times
  17. [1]+ Done ./signal_receiver

    可靠性信号36，发送10000次，signal_receiver全部收到，不可靠性信号10，共收到2879次。这个数字是不可预期的，取决于内核进程的调度。
    这个如果还不够直观，我们在比较一次，让signal_receiver先屏蔽所有信号一段时间，如30s，然后解除屏蔽。

  1. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver 30 &
  2. [1] 27639
  3. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver:PID is 27639
  4. signal for signo(32) failed (Invalid argument)
  5. signal for signo(33) failed (Invalid argument)
  6. I will sleep 30 second

  8. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 27639 10 10000
  9. pid = 27639,signo = 10,times = 10000
  10. done
  11. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 27639 36 10000
  12. pid = 27639,signo = 36,times = 10000
  13. done
  14. manu@manu-hacks:~/code/c/self/signal$
  15. manu@manu-hacks:~/code/c/self/signal$ signo(10) :User defined signal 1
  16. signo(36) :Real-time signal 2

  18. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 27639 2 1
  19. pid = 27639,signo = 2,times = 1
  20. done
  21. ./signal_receiver:signal 10 caught 1 time
  22. ./signal_receiver:signal 36 caught 10000 times
  23. [1]+ Done ./signal_receiver 30

      这个比较反差比较大，不可靠signal10 共收到1次，可靠性信号36 共caught到10000次。原因就在于sigprocmask将所有的信号都屏蔽了，造成所有的信号都不能delivery。对1～31的信号，内核发现已经有相应的挂起信号，则ignore到新来的信号。但是可靠性信号则不同，会添加队列中去，尽管已经有了相同的信号。需要注意的是，signal pending有上限，并不能无限制的发：

  1. manu@manu-hacks:~/code/c/self/signal$ ulimit -a
  2. core file size (blocks, -c) 0
  3. data seg size (kbytes, -d) unlimited
  4. scheduling priority (-e) 0
  5. file size (blocks, -f) unlimited
  6. pending signals (-i) 15408
  7. max locked memory (kbytes, -l) 64
  8. max memory size (kbytes, -m) unlimited
  9. open files (-n) 1024
  10. pipe size (512 bytes, -p) 8
  11. POSIX message queues (bytes, -q) 819200
  12. real-time priority (-r) 0
  13. stack size (kbytes, -s) 8192
  14. cpu time (seconds, -t) unlimited
  15. max user processes (-u) 15408
  16. virtual memory (kbytes, -v) unlimited
  17. file locks (-x) unlimited

    我发送100万，最终会收到15408个可靠信号：

  1. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver 30 &
  2. [1] 16488
  3. manu@manu-hacks:~/code/c/self/signal$ ./signal_receiver:PID is 16488
  4. signal for signo(32) failed (Invalid argument)
  5. signal for signo(33) failed (Invalid argument)
  6. I will sleep 30 second

  8. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 16488 36 1000000
  9. pid = 16488,signo = 36,times = 1000000
  10. done
  11. manu@manu-hacks:~/code/c/self/signal$ signo(36) :Real-time signal 2

  13. manu@manu-hacks:~/code/c/self/signal$ ./signal_sender 16488 2 1
  14. pid = 16488,signo = 2,times = 1
  15. done
  16. ./signal_receiver:signal 36 caught 15408 times
  17. [1]+ Done ./signal_receiver 30

      内核是怎么做到的？
    技术分享
    上图是内核中signal相关的数据结构。其中task_struct中有sigpending类型的成员变量pending
    

  1. struct task_struct {
  2.     volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */
  3.     void *stack;
  4.     atomic_t usage;
  5.     unsigned int flags; /* per process flags, defined below */
  6.     unsigned int ptrace;
  7.         ...
  8.         ...
  9. /* signal handlers */
  10.     struct signal_struct *signal;
  11.     struct sighand_struct *sighand;

  13.     sigset_t blocked, real_blocked;
  14.     sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
  15.     struct sigpending pending;

  17.        ...
  18. }

  20. struct signal_struct {
  21.       atomic_t     sigcnt;
  22.       atomic_t     live;
  23.       int     nr_threads;
  24.       ...
  25.       ...
  26.       /* shared signal handling: */
  27.       struct sigpending    shared_pending;
  28.       ...
  29. }

  31. struct sigpending {
  32.     struct list_head list;
  33.     sigset_t signal;
  34. };

  36. #define _NSIG        64

  38. #ifdef __i386__
  39. # define _NSIG_BPW    32
  40. #else
  41. # define _NSIG_BPW    64
  42. #endif

  44. #define _NSIG_WORDS    (_NSIG / _NSIG_BPW)

  46. typedef unsigned long old_sigset_t;        /* at least 32 bits */

  48. typedef struct {
  49.     unsigned long sig[_NSIG_WORDS];
  50. } sigset_t;

      task_struct中的pending，和signal->shared_pending都是记录挂起信号的数据结构，读到此处，你可能会迷惑，为何有两个这样的结构。这牵扯到thread与信号的一些问题，我们此处简化，就认为是一个就好，后面讲述线程与信号关系的时候，再展开。
    技术分享  
    我们看到了，kill也好，tkill也罢，最终都走到了_send_signal.当然了kill系统调用根据pid的情况会分成多个分支如pid >0 pid = 0 pid=-1;pid < 0&pid !=-1,总之了，我的图只绘制了pid >0 的分支。tkill也有类似情况。
    那么kernel是怎么做到的非可靠信号和可靠信号的的这些差别的呢？

  1. static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
  2.             int group, int from_ancestor_ns)
  3. {
  4.     struct sigpending *pending;
  5.     struct sigqueue *q;
  6.     int override_rlimit;
  7.     int ret = 0, result;

  9.     assert_spin_locked(&t->sighand->siglock);

  11.     result = TRACE_SIGNAL_IGNORED;
  12.     if (!prepare_signal(sig, t,
  13.             from_ancestor_ns || (info == SEND_SIG_FORCED)))
  14.         goto ret;

  16.     pending = group ? &t->signal->shared_pending : &t->pending;
  17.     /*
  18.      * Short-circuit ignored signals and support queuing
  19.      * exactly one non-rt signal, so that we can get more
  20.      * detailed information about the cause of the signal.
  21.      */
  22.     result = TRACE_SIGNAL_ALREADY_PENDING;
  23.     if (legacy_queue(pending, sig)) //如果是低于32的信号，并且已经在pending中出现了的信号，就直接返回了，ignore
  24.         goto ret;

  26.     result = TRACE_SIGNAL_DELIVERED;
  27.     /*
  28.      * fast-pathed signals for kernel-internal things like SIGSTOP
  29.      * or SIGKILL.
  30.      */
  31.     if (info == SEND_SIG_FORCED)
  32.         goto out_set;

  34.     /*
  35.      * Real-time signals must be queued if sent by sigqueue, or
  36.      * some other real-time mechanism. It is implementation
  37.      * defined whether kill() does so. We attempt to do so, on
  38.      * the principle of least surprise, but since kill is not
  39.      * allowed to fail with EAGAIN when low on memory we just
  40.      * make sure at least one signal gets delivered and don‘t
  41.      * pass on the info struct.
  42.      */
  43.     if (sig < SIGRTMIN)
  44.         override_rlimit = (is_si_special(info) || info->si_code >= 0);
  45.     else
  46.         override_rlimit = 0;
      //分配sigqueue结构，并且链入到相应的pending。
  1.     q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
  2.         override_rlimit);
  3.     if (q) {
  4.         list_add_tail(&q->list, &pending->list);
  5.         switch ((unsigned long) info) {
  6.         case (unsigned long) SEND_SIG_NOINFO:
  7.             q->info.si_signo = sig;
  8.             q->info.si_errno = 0;
  9.             q->info.si_code = SI_USER;
  10.             q->info.si_pid = task_tgid_nr_ns(current,
  11.                             task_active_pid_ns(t));
  12.             q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
  13.             break;
  14.         case (unsigned long) SEND_SIG_PRIV:
  15.             q->info.si_signo = sig;
  16.             q->info.si_errno = 0;
  17.             q->info.si_code = SI_KERNEL;
  18.             q->info.si_pid = 0;
  19.             q->info.si_uid = 0;
  20.             break;
  21.         default:
  22.             copy_siginfo(&q->info, info);
  23.             if (from_ancestor_ns)
  24.                 q->info.si_pid = 0;
  25.             break;
  26.         }

  28.         userns_fixup_signal_uid(&q->info, t);

  30.     } else if (!is_si_special(info)) {
  31.         if (sig >= SIGRTMIN && info->si_code != SI_USER) {
  32.             /*
  33.              * Queue overflow, abort. We may abort if the
  34.              * signal was rt and sent by user using something
  35.              * other than kill().
  36.              */
  37.             result = TRACE_SIGNAL_OVERFLOW_FAIL;
  38.             ret = -EAGAIN;
  39.             goto ret;
  40.         } else {
  41.             /*
  42.              * This is a silent loss of information. We still
  43.              * send the signal, but the *info bits are lost.
  44.              */
  45.             result = TRACE_SIGNAL_LOSE_INFO;
  46.         }
  47.     }

  49. out_set:
  50.     signalfd_notify(t, sig);
  51.     sigaddset(&pending->signal, sig);  //加入位图
  52.     complete_signal(sig, t, group);
  53. ret:
  54.     trace_signal_generate(sig, info, t, group, result);
  55.     return ret;
  56. }

  58. static inline int legacy_queue(struct sigpending *signals, int sig)
  59. {
  60.     return (sig < SIGRTMIN) && sigismember(&signals->signal, sig); //是不可靠信号，并且该信号已经存在挂起信号，

    那么15408的限制是在哪里呢？在__sigqueue_alloc 里面。

  1. static struct sigqueue *
  2. __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
  3. {
  4.     struct sigqueue *q = NULL;
  5.     struct user_struct *user;

  7.     /*
  8.      * Protect access to @t credentials. This can go away when all
  9.      * callers hold rcu read lock.
  10.      */
  11.     rcu_read_lock();
  12.     user = get_uid(__task_cred(t)->user);
  13.     atomic_inc(&user->sigpending);    //计数器+1
  14.     rcu_read_unlock();

  16.     if (override_rlimit ||
  17.      atomic_read(&user->sigpending) <=
  18.             task_rlimit(t, RLIMIT_SIGPENDING)) {
  19.         q = kmem_cache_alloc(sigqueue_cachep, flags);
  20.     } else {
  21.         print_dropped_signal(sig);
  22.     }

  24.     if (unlikely(q == NULL)) {
  25.         atomic_dec(&user->sigpending);
  26.         free_uid(user);
  27.     } else {
  28.         INIT_LIST_HEAD(&q->list);
  29.         q->flags = 0;
  30.         q->user = user;
  31.     }

  33.     return q;
  34. }

     我们看到，legacy_queue就是用来判断是否是非可靠信号（signo低于32），并且相同signo值已经存在在挂起信号之中，如果是，直接返回。
     而对于可靠信号，会分配一个sigqueue的结构，然后讲sigqueue链入到sigpending结构的中链表中。从而就不会丢失信号。当然对pending信号的总数作了限制，限制最多不可超过15408.当然了这个值是可以修改的：
    技术分享


参考文献：
1 Linux programming interface
2 深入理解linux内核
3 linux kernel 3.8.0 内核源码 

Linux signal 那些事儿（2）【转】

标签：failed   special   handler   函数   limited   nal   ignore   time   数字   

原文地址：http://www.cnblogs.com/sky-heaven/p/6844543.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！