Linux signal 那些事儿 （3）

    这篇博客，想集中在signal 与线程的关系上，顺带介绍内核signal相关的结构。如何组织我其实并没想好，想到哪就写到哪里吧。主题一定会落在signal之内而不跑题。
    提到signal与thread的关系，就得先提POSIX标准。POSIX标准决定了Linux为何将signal如此实现：
   1 信号处理函数必须在多线程应用的所有线程之间共享，但是，每个线程要有自己的挂起信号掩码和阻塞信号掩码。
   2 POSIX 函数kill/sigqueue必须面向所有的多线程应用而不是某个特殊的线程。
   3 每个发给多线程应用的信号仅传送给1个线程，这个线程是由内核从不会阻塞该信号的线程中随意选出。
   4 如果发送一个致命信号到多线程，那么内核将杀死该应用的所有线程，而不仅仅是接收信号的那个线程。

    上面是POSIX标准，也就是提出来的要求，Linux要遵循POSIX标准，那Linux是怎么做到的呢？
    到了此处，我们需要理清一些基本的概念：

1. struct task_struct {
   
2. 
   
3.     pid_t pid;
   
4.     pid_t tgid
   
5.       .....
   
6.     struct task_struct *group_leader;    /* threadgroup leader */
   
7.       ......
   
8.     struct list_head thread_group;
   
9.         ....
   
10. }

    从字面意思上看 pid，是process id，其则不然，pid是thread id。从字面意思上看，tgid是thread group id，其则是真正的pid。
    有点绕是不是？对于一个多线程的程序，无论是哪个线程执行getpid，结果都是一样的，最终返回的同一个值 tgid。如果我们实现了gettid（很不幸的是glibc没有这个函数，所以我们要用syscall），我们就会发现，各个线程返回的值不同，此时，返回的值是内核task_struct中的pid。对于多线程应用/proc/pid/task可以看到的，就是线程的thread id，也就是task_struct中的pid。
   
    我在我的博文Linux线程之线程 线程组 进程 轻量级进程（LWP）提到了这个问题。我不想多浪费笔墨赘述。
    group leader字段，指向线程组的第一个线程。对于我们自己的程序而言，main函数所在的线程，也就是线程组的第一个线程，所以group leader就会他自己。一旦用pthread_create创建了线程，那么main所在的线程，还有创建出来的线程，隶属于同一个线程组，线程的group leader还是main函数所在的线程id。
    thread_group，同一线程组的所有线程的队列。对于group_leader,这是一个队列头，对于同一线程组的其他线程，通过这个字段挂入队列。可以根据这个队列，遍历线程组的所有线程。
     是时候看看内核代码了,下面的代码属于do_fork函数及copy_process函数的一些代码。       

1.     p->pid = pid_nr(pid);
   
2.     p->tgid = p->pid;
   
3.     if (clone_flags & CLONE_THREAD)//创建线程，tgid等于当前线程的
   
4.         p->tgid = current->tgid;
   
5. 
   
6. 
   
7.     p->group_leader = p;
   
8.     INIT_LIST_HEAD(&p->thread_group);
   
9. 
   
10.     if (clone_flags & CLONE_THREAD) { //线程处理部分，group_leader都是第一个线程。同时挂入队列
    
11.         current->signal->nr_threads++;
    
12.         atomic_inc(&current->signal->live);
    
13.         atomic_inc(&current->signal->sigcnt);
    
14.         p->group_leader = current->group_leader;
    
15.         list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group);
    
16.     }

    代码表明，第一个线程呢，pid和tgid相同，都是分配的那个pid，group_leader也是自己。后面第二个线程，pid是自己的，但是tgid 等于创建者的tgid，group_leader指向第一个线程的task_struct. 后面创建的所有的线程，都会挂入队列，方便遍线程组的所有线程。
    有了线程组的概念，我们就可以进一步解释signal相关的内容了。 

1.     /* signal handlers */
   
2.     struct signal_struct *signal;
   
3.     struct sighand_struct *sighand;
   
4. 
   
5.     sigset_t blocked, real_blocked;
   
6.     sigset_t saved_sigmask;    /* restored if set_restore_sigmask() was used */
   
7.     struct sigpending pending;

    
    线程组里面的所有成员共享一个signal_struct类型结构，同一线程组的多线程的task_struct 中的signal指针都是指向同一个signal_struct。sighand成员变量也是如此，统一个线程组的多个线程指向同一个signalhand_struct结构。  

1. static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
   
2. {
   
3.     struct signal_struct *sig;
   
4. 
   
5.     if (clone_flags & CLONE_THREAD) //线程，直接返回，表明同一线程组共享
   
6.         return 0;
   
7. 
   
8.     sig = kmem_cache_zalloc(signal_cachep, GFP_KERNEL);
   
9.     tsk->signal = sig;
   
10.     if (!sig)
    
11.         return -ENOMEM;
    
12. 
    
13.     sig->nr_threads = 1;
    
14.     atomic_set(&sig->live, 1);
    
15.     atomic_set(&sig->sigcnt, 1);
    
16.     init_waitqueue_head(&sig->wait_chldexit);
    
17.     sig->curr_target = tsk;
    
18.         。。。。
    
19. }
    
20. 
    
21. 
    
22. static int copy_sighand(unsigned long clone_flags, struct task_struct *tsk)
    
23. {
    
24.     struct sighand_struct *sig;
    
25. 
    
26.     if (clone_flags & CLONE_SIGHAND) {
    
27.         atomic_inc(&current->sighand->count); //如果发现是线程，直接讲引用计数++，无需分配sighand_struct结构
28.         return 0;
29.     }
    
30.     sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL);
    
31.     rcu_assign_pointer(tsk->sighand, sig);
    
32.     if (!sig)
    
33.         return -ENOMEM;
    
34.     atomic_set(&sig->count, 1);
    
35.     memcpy(sig->action, current->sighand->action, sizeof(sig->action));
    
36.     return 0;
    
37. }

    这就基本实现了多线程应用中，信号处理程序是共享的，因为他们共用一个signalhand_struct。
    上一篇博文提到，signal->shared_pending 和pending两个挂起信号相关的数据结构，此处我们可以具体讲解了。signal是线程组共享的结构，自然下属的shared_pending也是线程组共享的。就像POSIX提到的，kill/sigqueue发送信号，发送的对象并不是线程组某个特定的线程，而是整个线程组。自然，如果kernel会将信号记录在全线程组共享的signal->shared_pending,表示，线程组收到信号X一枚。
    有筒子说了，我就要给某个特定的线程发信号，有没有办法，内核怎么办？这是个好问题。   

1.   int tkill(int tid, int sig);
   
2. 
   
3.   int tgkill(int tgid, int tid, int sig)

    这两个API是给线程组特定线程发信号的，毫不意外，内核会将信号记录在线程自己的结构pending中。

1. pending = group ? &t->signal->shared_pending : &t->pending;

    对于kill/sigqueue，__send_signal传进来的是group是true，对于tkill/tgkill传进来的是false。会将信号写入相应的挂起信号位图。

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;
   
8. 
   
9.     assert_spin_locked(&t->sighand->siglock);
   
10. 
    
11.     result = TRACE_SIGNAL_IGNORED;
    
12.     if (!prepare_signal(sig, t,
    
13.             from_ancestor_ns || (info == SEND_SIG_FORCED)))
    
14.         goto ret;
    
15. 
    
16.     pending = group ? &t->signal->shared_pending : &t->pending;   // tkill用的自己的pending，
17.                                                                   // kill/sigqueue用的线程组共享的signal->shared_pending
18.     /*
    
19.      * Short-circuit ignored signals and support queuing
    
20.      * exactly one non-rt signal, so that we can get more
    
21.      * detailed information about the cause of the signal.
    
22.      */
    
23.     result = TRACE_SIGNAL_ALREADY_PENDING;
    
24.     if (legacy_queue(pending, sig))
    
25.         goto ret;
    
26. 
    
27.     result = TRACE_SIGNAL_DELIVERED;
    
28.     /*
    
29.      * fast-pathed signals for kernel-internal things like SIGSTOP
    
30.      * or SIGKILL.
    
31.      */
    
32.     if (info == SEND_SIG_FORCED)
    
33.         goto out_set;
    
34. 
    
35.     /*
    
36.      * Real-time signals must be queued if sent by sigqueue, or
    
37.      * some other real-time mechanism. It is implementation
    
38.      * defined whether kill() does so. We attempt to do so, on
    
39.      * the principle of least surprise, but since kill is not
    
40.      * allowed to fail with EAGAIN when low on memory we just
    
41.      * make sure at least one signal gets delivered and don't
    
42.      * pass on the info struct.
    
43.      */
    
44.     if (sig < SIGRTMIN)
    
45.         override_rlimit = (is_si_special(info) || info->si_code >= 0);
    
46.     else
    
47.         override_rlimit = 0;
    
48. 
    
49.     q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
    
50.         override_rlimit);
    
51.     if (q) {
    
52.         list_add_tail(&q->list, &pending->list);
    
53.         switch ((unsigned long) info) {
    
54.         case (unsigned long) SEND_SIG_NOINFO:
    
55.             q->info.si_signo = sig;
    
56.             q->info.si_errno = 0;
    
57.             q->info.si_code = SI_USER;
    
58.             q->info.si_pid = task_tgid_nr_ns(current,
    
59.                             task_active_pid_ns(t));
    
60.             q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
    
61.             break;
    
62.         case (unsigned long) SEND_SIG_PRIV:
    
63.             q->info.si_signo = sig;
    
64.             q->info.si_errno = 0;
    
65.             q->info.si_code = SI_KERNEL;
    
66.             q->info.si_pid = 0;
    
67.             q->info.si_uid = 0;
    
68.             break;
    
69.         default:
    
70.             copy_siginfo(&q->info, info);
    
71.             if (from_ancestor_ns)
    
72.                 q->info.si_pid = 0;
    
73.             break;
    
74.         }
    
75. 
    
76.         userns_fixup_signal_uid(&q->info, t);
    
77. 
    
78.     } else if (!is_si_special(info)) {
    
79.         if (sig >= SIGRTMIN && info->si_code != SI_USER) {
    
80.             /*
    
81.              * Queue overflow, abort. We may abort if the
    
82.              * signal was rt and sent by user using something
    
83.              * other than kill().
    
84.              */
    
85.             result = TRACE_SIGNAL_OVERFLOW_FAIL;
    
86.             ret = -EAGAIN;
    
87.             goto ret;
    
88.         } else {
    
89.             /*
    
90.              * This is a silent loss of information. We still
    
91.              * send the signal, but the *info bits are lost.
    
92.              */
    
93.             result = TRACE_SIGNAL_LOSE_INFO;
    
94.         }
    
95.     }
    
96. 
    
97. out_set:
    
98.     signalfd_notify(t, sig);
    
99.     sigaddset(&pending->signal, sig);//修改位图，表明该信号存在挂起信号。
    
100.     complete_signal(sig, t, group);
     
101. ret:
     
102.     trace_signal_generate(sig, info, t, group, result);
     
103.     return ret;
     
104. }

    线程存在一个很让人迷惑的问题，如何让线程组的所有线程一起退出。我们都知道，多线程的程序有一个线程访问了非法地址，引发段错误，会造成所有线程一起退出。这也是多线程程序脆弱的地方。但是如何做到的呢？
    do_signal--->get_signal_to_deliver中，会选择信号，如果发现需要退出，会执行do_group_exit。这个名字顾名思义了，线程组退出。   

1. void
   
2. do_group_exit(int exit_code)
   
3. {
   
4.     struct signal_struct *sig = current->signal;
   
5. 
   
6.     BUG_ON(exit_code & 0x80); /* core dumps don't get here */
   
7. 
   
8.     if (signal_group_exit(sig))
   
9.         exit_code = sig->group_exit_code;
   
10.     else if (!thread_group_empty(current)) {
    
11.         struct sighand_struct *const sighand = current->sighand;
    
12.         spin_lock_irq(&sighand->siglock);
    
13.         if (signal_group_exit(sig))
    
14.             /* Another thread got here before we took the lock. */
    
15.             exit_code = sig->group_exit_code;
    
16.         else {
    
17.             sig->group_exit_code = exit_code;
    
18.             sig->flags = SIGNAL_GROUP_EXIT;
    
19.             zap_other_threads(current);
    
20.         }
    
21.         spin_unlock_irq(&sighand->siglock);
    
22.     }
    
23. 
    
24.     do_exit(exit_code);
    
25.     /* NOTREACHED */
    
26. }

    如果是多线程，会走入到else中，主要的操作都在zap_other_threads函数中：

1. /*
   
2.  * Nuke all other threads in the group.
   
3.  */
   
4. int zap_other_threads(struct task_struct *p)
   
5. {
   
6.     struct task_struct *t = p;
   
7.     int count = 0;
   
8. 
   
9.     p->signal->group_stop_count = 0;
   
10. 
    
11.     while_each_thread(p, t) {
    
12.         task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
    
13.         count++;
    
14. 
    
15.         /* Don't bother with already dead threads */
    
16.         if (t->exit_state)
    
17.             continue;
    
18.         sigaddset(&t->pending.signal, SIGKILL);
    
19.         signal_wake_up(t, 1);
    
20.     }
    
21. 
    
22.     return count;
    
23. }

    不多说了，就是给每一个线程都挂上一个SIGKILL的信号，当CPU选择线程执行时候的时候，自然会处理这个信号，而对SIGKILL的处理，会再次调用do_group_exit。这一次会调用do_exit退出。当线程组所有进程都执行过之后，整个线程组就消亡了。
    
    讲完这些，需要讲block了。我第一篇就讲到，我们有时候需要阻塞某些信号。POSIX说了多线程中每个线程要有自己的阻塞信号。不必说，task_struct中的blocked就是阻塞信号位图。我们的glibc的sigprocmask函数，就是设置进程的blocked。
    那些block的信号为何不能传递，内核是怎么做到的？
        

1. int next_signal(struct sigpending *pending, sigset_t *mask)
   
2. {
   
3.     unsigned long i, *s, *m, x;
   
4.     int sig = 0;
   
5. 
   
6.     s = pending->signal.sig;
   
7.     m = mask->sig;
   
8. 
   
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.     }
    
20. 
    
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;
    
31. 
    
32.     case 2:
    
33.         x = s[1] &~ m[1];
    
34.         if (!x)
    
35.             break;
    
36.         sig = ffz(~x) + _NSIG_BPW + 1;
    
37.         break;
    
38. 
    
39.     case 1:
    
40.         /* Nothing to do */
    
41.         break;
    
42.     }
    
43. 
    
44.     return sig;
    
45. }

    m就是task_struct中的blocked，阻塞的信号就不会不会被取出传递了。很有意思的一点是信号传递的顺序。在Linux programming interface一书中提到小signo优先的策略，比如SIGINT（2）和SIGQUIT（3）同时存在，SIGINT（2） 先deliver，然后才是SIGQUIT（3）.我们看代码，很有意思的是有同步信号：

1. #define SYNCHRONOUS_MASK \
   
2.     (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
   
3.      sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))

    有SIGSEGV SIGBUS SIGILL SIGTRAP SIGFPE SIGSYS，那么这几个信号优先。没有这几个信号，按照小信号优先。当然了，这些是Linux kernel的实现，毕竟不是POSIX标准，不可依赖这种顺序。
   另外，dequeue很有意思，先去task_struct中的pending中取，取不到再去整个线程组共享的shered_pending位图去取。    

1. int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
   
2. {
   
3.     int signr;
   
4. 
   
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);
   
9.     if (!signr) {
   
10.         signr = __dequeue_signal(&tsk->signal->shared_pending,
    
11.                      mask, info);

       。。。。
}

参考文献:
1 Linux2.6内核中的线程组初探
2 Linux kernel 3.8.0