zoukankan      html  css  js  c++  java

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

    转自：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 ",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) ",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) ",strerror(errno));
    50.             return -2;
    51.         }

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

    55.         sleep(sleep_time);
    56.         if(sigpending(&pending_mask) == -1)
    57.         {
    58.             fprintf(stderr,"sigpending failed(%s) ",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 ",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) ",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 ",
    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: ");
    12.     fprintf(stderr,"-------------------------------- ");
    13.     fprintf(stderr,"signal_sender pid signo times ");
    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 ",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) ",signo,pid,strerror(errno));
    47.             return -2;
    48.         }
    49.     }
    50.     fprintf(stdout,"done ");
    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 内核源码 

  • 相关阅读:
    The Quad
    将OrCAD Capture CIS的设计文件（.dsn）导入到PADS Logic VX.2.3
    OrCAD Capture CIS 16.6 将版本16.6的设计文件另存为版本16.2的设计文件
    Eclipse IDE 添加jar包到Java工程中
    PADS Logic VX.2.3 修改软件界面语言
    切换Allegro PCB Editor
    Allegro PCB Design GXL (legacy) 将brd文件另存为低版本文件
    Allegro PCB Design GXL (legacy) 设置自动保存brd文件
    Could not create an acl object: Role '16'
    windows 下apache开启FastCGI
  • 原文地址：https://www.cnblogs.com/sky-heaven/p/6844543.html
Copyright © 2011-2022 走看看