Linux 信号处理原理与实现

什么是信号

信号本质上是在软件层次上对中断机制的一种模拟，其主要有以下几种来源：

• 程序错误：除零，非法内存访问等。
• 外部信号：终端 Ctrl-C 产生 SGINT 信号，定时器到期产生SIGALRM等。
• 显式请求：kill函数允许进程发送任何信号给其他进程或进程组。

目前 Linux 支持64种信号。信号分为非实时信号(不可靠信号)和实时信号(可靠信号)两种类型，对应于 Linux 的信号值为 1-31 和 34-64。

信号是异步的，一个进程不必通过任何操作来等待信号的到达。事实上，进程也不知道信号到底什么时候到达。一般来说，我们只需要在进程中设置信号相应的处理函数，当有信号到达的时候，由系统异步触发相应的处理函数即可。如下代码：

1. #include <signal.h> 
2. #include <unistd.h> 
3. #include <stdio.h> 
4.  
5. void sigcb(int signo) { 
6.     switch (signo) { 
7.     case SIGHUP: 
8.         printf("Get a signal -- SIGHUP\n"); 
9.         break; 
10.     case SIGINT: 
11.         printf("Get a signal -- SIGINT\n"); 
12.         break; 
13.     case SIGQUIT: 
14.         printf("Get a signal -- SIGQUIT\n"); 
15.         break; 
16.     } 
17.     return; 
18. } 
19.  
20. int main() { 
21.     signal(SIGHUP, sigcb); 
22.     signal(SIGINT, sigcb); 
23.     signal(SIGQUIT, sigcb); 
24.     for (;;) { 
25.         sleep(1); 
26.     } 
27. } 

运行程序后，当我们按下 Ctrl+C 后，屏幕上将会打印 Get a signal -- SIGINT。当然我们可以使用 kill -s SIGINT pid 命令来发送一个信号给进程，屏幕同样打印出 Get a signal -- SIGINT 的信息。

信号实现原理

接下来我们分析一下Linux对信号处理机制的实现原理。

信号处理相关的数据结构

在进程管理结构 task_struct 中有几个与信号处理相关的字段，如下：

1. struct task_struct { 
2.     ... 
3.     int sigpending; 
4.     ... 
5.     struct signal_struct *sig; 
6.     sigset_t blocked; 
7.     struct sigpending pending; 
8.     ... 
9. } 

成员 sigpending 表示进程是否有信号需要处理(1表示有，0表示没有)。成员 blocked 表示被屏蔽的信息，每个位代表一个被屏蔽的信号。成员 sig 表示信号相应的处理方法，其类型是 struct signal_struct，定义如下：

1. #define  _NSIG  64 
2.  
3. struct signal_struct { 
4.  atomic_t  count; 
5.  struct k_sigaction action[_NSIG]; 
6.  spinlock_t  siglock; 
7. }; 
8.  
9. typedef void (*__sighandler_t)(int); 
10.  
11. struct sigaction { 
12.  __sighandler_t sa_handler; 
13.  unsigned long sa_flags; 
14.  void (*sa_restorer)(void); 
15.  sigset_t sa_mask; 
16. }; 
17.  
18. struct k_sigaction { 
19.  struct sigaction sa; 
20. }; 

可以看出，struct signal_struct 是个比较复杂的结构，其 action 成员是个 struct k_sigaction 结构的数组，数组中的每个成员代表着相应信号的处理信息，而 struct k_sigaction 结构其实是 struct sigaction 的简单封装。

我们再来看看 struct sigaction 这个结构，其中 sa_handler 成员是类型为 __sighandler_t 的函数指针，代表着信号处理的方法。

最后我们来看看 struct task_struct 结构的 pending 成员，其类型为 struct sigpending，存储着进程接收到的信号队列，struct sigpending 的定义如下：

1. struct sigqueue { 
2.  struct sigqueue *next; 
3.  siginfo_t info; 
4. }; 
5.  
6. struct sigpending { 
7.  struct sigqueue *head, **tail; 
8.  sigset_t signal; 
9. }; 

当进程接收到一个信号时，就需要把接收到的信号添加 pending 这个队列中。

发送信号

可以通过 kill() 系统调用发送一个信号给指定的进程，其原型如下：

1. int kill(pid_t pid, int sig); 

参数 pid 指定要接收信号进程的ID，而参数 sig 是要发送的信号。kill() 系统调用最终会进入内核态，并且调用内核函数 sys_kill()，代码如下：

1. asmlinkage long 
2. sys_kill(int pid, int sig) 
3. { 
4.  struct siginfo info; 
5.  
6.  info.si_signo = sig; 
7.  info.si_errno = 0; 
8.  info.si_code = SI_USER; 
9.  info.si_pid = current->pid; 
10.  info.si_uid = current->uid; 
11.  
12.  return kill_something_info(sig, &info, pid); 
13. } 

sys_kill() 的代码比较简单，首先初始化 info 变量的成员，接着调用 kill_something_info() 函数来处理发送信号的操作。kill_something_info() 函数的代码如下：

1. static int kill_something_info(int sig, struct siginfo *info, int pid) 
2. { 
3.  if (!pid) { 
4.   return kill_pg_info(sig, info, current->pgrp); 
5.  } else if (pid == -1) { 
6.   int retval = 0, count = 0; 
7.   struct task_struct * p; 
8.  
9.   read_lock(&tasklist_lock); 
10.   for_each_task(p) { 
11.    if (p->pid > 1 && p != current) { 
12.     int err = send_sig_info(sig, info, p); 
13.     ++count; 
14.     if (err != -EPERM) 
15.      retval = err; 
16.    } 
17.   } 
18.   read_unlock(&tasklist_lock); 
19.   return count ? retval : -ESRCH; 
20.  } else if (pid < 0) { 
21.   return kill_pg_info(sig, info, -pid); 
22.  } else { 
23.   return kill_proc_info(sig, info, pid); 
24.  } 
25. } 

kill_something_info() 函数根据传入pid 的不同来进行不同的操作，有如下4种可能：

• pid 等于0时，表示信号将送往所有与调用 kill() 的那个进程属同一个使用组的进程。
• pid 大于零时，pid 是信号要送往的进程ID。
• pid 等于-1时，信号将送往调用进程有权给其发送信号的所有进程，除了进程1(init)。
• pid 小于-1时，信号将送往以-pid为组标识的进程。

我们这里只分析 pid 大于0的情况，从上面的代码可以知道，当 pid 大于0时，会调用 kill_proc_info() 函数来处理信号发送操作，其代码如下：

1. inline int 
2. kill_proc_info(int sig, struct siginfo *info, pid_t pid) 
3. { 
4.  int error; 
5.  struct task_struct *p; 
6.  
7.  read_lock(&tasklist_lock); 
8.  p = find_task_by_pid(pid); 
9.  error = -ESRCH; 
10.  if (p) 
11.   error = send_sig_info(sig, info, p); 
12.  read_unlock(&tasklist_lock); 
13.  return error; 
14. } 

kill_proc_info() 首先通过调用 find_task_by_pid() 函数来获得 pid 对应的进程管理结构，然后通过 send_sig_info() 函数来发送信号给此进程，send_sig_info() 函数代码如下：

1. int 
2. send_sig_info(int sig, struct siginfo *info, struct task_struct *t) 
3. { 
4.     unsigned long flags; 
5.     int ret; 
6.  
7.     ret = -EINVAL; 
8.     if (sig < 0 || sig > _NSIG) 
9.         goto out_nolock; 
10.  
11.     ret = -EPERM; 
12.     if (bad_signal(sig, info, t)) 
13.         goto out_nolock; 
14.  
15.     ret = 0; 
16.     if (!sig || !t->sig) 
17.         goto out_nolock; 
18.  
19.     spin_lock_irqsave(&t->sigmask_lock, flags); 
20.     handle_stop_signal(sig, t); 
21.  
22.     if (ignored_signal(sig, t)) 
23.         goto out; 
24.  
25.     if (sig < SIGRTMIN && sigismember(&t->pending.signal, sig)) 
26.         goto out; 
27.  
28.     ret = deliver_signal(sig, info, t); 
29. out: 
30.     spin_unlock_irqrestore(&t->sigmask_lock, flags); 
31.     if ((t->state & TASK_INTERRUPTIBLE) && signal_pending(t)) 
32.         wake_up_process(t); 
33.  
34. out_nolock: 
35.     return ret; 
36. } 

send_sig_info() 首先调用 bad_signal() 函数来检查是否有权发送信号给进程，然后调用 ignored_signal() 函数来检查信号是否被忽略，接着调用 deliver_signal() 函数开始发送信号，最后如果进程是睡眠状态就唤醒进程。我们接着来分析 deliver_signal() 函数：

1. static int deliver_signal(int sig, struct siginfo *info, struct task_struct *t) 
2. { 
3.  int retval = send_signal(sig, info, &t->pending); 
4.  
5.  if (!retval && !sigismember(&t->blocked, sig)) 
6.   signal_wake_up(t); 
7.  
8.  return retval; 
9. } 

deliver_signal() 首先调用 send_signal() 函数进行信号的发送，然后调用 signal_wake_up() 函数唤醒进程。我们来分析一下最重要的函数 send_signal()：

1. static int send_signal(int sig, struct siginfo *info, struct sigpending *signals) 
2. { 
3.     struct sigqueue * q = NULL; 
4.  
5.     if (atomic_read(&nr_queued_signals) < max_queued_signals) { 
6.         q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC); 
7.     } 
8.  
9.     if (q) { 
10.         atomic_inc(&nr_queued_signals); 
11.         q->next = NULL; 
12.         *signals->tail = q; 
13.         signals->tail = &q->next; 
14.         switch ((unsigned long) info) { 
15.             case 0: 
16.                 q->info.si_signo = sig; 
17.                 q->info.si_errno = 0; 
18.                 q->info.si_code = SI_USER; 
19.                 q->info.si_pid = current->pid; 
20.                 q->info.si_uid = current->uid; 
21.                 break; 
22.             case 1: 
23.                 q->info.si_signo = sig; 
24.                 q->info.si_errno = 0; 
25.                 q->info.si_code = SI_KERNEL; 
26.                 q->info.si_pid = 0; 
27.                 q->info.si_uid = 0; 
28.                 break; 
29.             default: 
30.                 copy_siginfo(&q->info, info); 
31.                 break; 
32.         } 
33.     } else if (sig >= SIGRTMIN && info && (unsigned long)info != 1 
34.            && info->si_code != SI_USER) { 
35.         return -EAGAIN; 
36.     } 
37.  
38.     sigaddset(&signals->signal, sig); 
39.     return 0; 
40. } 

send_signal() 函数虽然比较长，但逻辑还是比较简单的。在 信号处理相关的数据结构 一节我们介绍过进程管理结构 task_struct 有个 pending 的成员变量，其用于保存接收到的信号队列。send_signal() 函数的第三个参数就是进程管理结构的 pending 成员变量。

send_signal() 首先调用 kmem_cache_alloc() 函数来申请一个类型为 struct sigqueue 的队列节点，然后把节点添加到 pending 队列中，接着根据参数 info 的值来进行不同的操作，最后通过 sigaddset() 函数来设置信号对应的标志位，表示进程接收到该信号。

signal_wake_up() 函数会把进程的 sigpending 成员变量设置为1，表示有信号需要处理，如果进程是睡眠可中断状态还会唤醒进程。

至此，发送信号的流程已经完成，我们可以通过下面的调用链来更加直观的理解此过程：

1. kill()    
2.   ｜                                         User Space 
3. ========================================================= 
4.   ｜                                         Kernel Space 
5. sys_kill() 
6.   └→  kill_something_info() 
7.      └→ kill_proc_info() 
8.         └→  find_task_by_pid() 
9.         └→ send_sig_info() 
10.            └→ bad_signal() 
11.            └→ handle_stop_signal() 
12.            └→ ignored_signal() 
13.            └→ deliver_signal() 
14.               └→ send_signal() 
15.               |  └→  kmem_cache_alloc() 
16.               |  └→ sigaddset() 
17.               └→ signal_wake_up() 

内核触发信号处理函数

上面介绍了怎么发生一个信号给指定的进程，但是什么时候会触发信号相应的处理函数呢?为了尽快让信号得到处理，Linux把信号处理过程放置在进程从内核态返回到用户态前，也就是在 ret_from_sys_call 处：

1. // arch/i386/kernel/entry.S 
2.  
3. ENTRY(ret_from_sys_call) 
4.  ... 
5. ret_with_reschedule: 
6.  ... 
7.  cmpl $0, sigpending(%ebx)  // 检查进程的sigpending成员是否等于1 
8.  jne signal_return          // 如果是就跳转到 signal_return 处执行 
9. restore_all: 
10.  RESTORE_ALL 
11.  
12.  ALIGN 
13. signal_return: 
14.  sti                             // 开启硬件中断 
15.  testl $(VM_MASK),EFLAGS(%esp) 
16.  movl %esp,%eax 
17.  jne v86_signal_return 
18.  xorl %edx,%edx 
19.  call SYMBOL_NAME(do_signal)    // 调用do_signal()函数进行处理 
20.  jmp restore_all 

由于这是一段汇编代码，有点不太直观(大概知道意思就可以了)，所以我在代码中进行了注释。主要的逻辑就是首先检查进程的 sigpending 成员是否等于1，如果是调用 do_signal() 函数进行处理，由于 do_signal() 函数代码比较长，所以我们分段来说明，如下：

1. int do_signal(struct pt_regs *regs, sigset_t *oldset) 
2. { 
3.  siginfo_t info; 
4.  struct k_sigaction *ka; 
5.  
6.  if ((regs->xcs & 3) != 3) 
7.   return 1; 
8.  
9.  if (!oldset) 
10.   oldset = &current->blocked; 
11.  
12.  for (;;) { 
13.   unsigned long signr; 
14.  
15.   spin_lock_irq(&current->sigmask_lock); 
16.   signr = dequeue_signal(&current->blocked, &info); 
17.   spin_unlock_irq(&current->sigmask_lock); 
18.  
19.   if (!signr) 
20.    break; 

上面这段代码的主要逻辑是通过 dequeue_signal() 函数获取到进程接收队列中的一个信号，如果没有信号，那么就跳出循环。我们接着来分析：

1. ka = &current->sig->action[signr-1]; 
2. if (ka->sa.sa_handler == SIG_IGN) { 
3.  if (signr != SIGCHLD) 
4.   continue; 
5.  /* Check for SIGCHLD: it's special.  */ 
6.  while (sys_wait4(-1, NULL, WNOHANG, NULL) > 0) 
7.   /* nothing */; 
8.  continue; 
9. } 

上面这段代码首先获取到信号对应的处理方法，如果对此信号的处理是忽略的话，那么就直接跳过。

1. if (ka->sa.sa_handler == SIG_DFL) { 
2.   int exit_code = signr; 
3.  
4.   /* Init gets no signals it doesn't want.  */ 
5.   if (current->pid == 1) 
6.    continue; 
7.  
8.   switch (signr) { 
9.   case SIGCONT: case SIGCHLD: case SIGWINCH: 
10.    continue; 
11.  
12.   case SIGTSTP: case SIGTTIN: case SIGTTOU: 
13.    if (is_orphaned_pgrp(current->pgrp)) 
14.     continue; 
15.    /* FALLTHRU */ 
16.  
17.   case SIGSTOP: 
18.    current->state = TASK_STOPPED; 
19.    current->exit_code = signr; 
20.    if (!(current->p_pptr->sig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP)) 
21.     notify_parent(current, SIGCHLD); 
22.    schedule(); 
23.    continue; 
24.  
25.   case SIGQUIT: case SIGILL: case SIGTRAP: 
26.   case SIGABRT: case SIGFPE: case SIGSEGV: 
27.   case SIGBUS: case SIGSYS: case SIGXCPU: case SIGXFSZ: 
28.    if (do_coredump(signr, regs)) 
29.     exit_code |= 0x80; 
30.    /* FALLTHRU */ 
31.  
32.   default: 
33.    sigaddset(&current->pending.signal, signr); 
34.    recalc_sigpending(current); 
35.    current->flags |= PF_SIGNALED; 
36.    do_exit(exit_code); 
37.    /* NOTREACHED */ 
38.   } 
39.  } 
40.  ... 
41.  handle_signal(signr, ka, &info, oldset, regs); 
42.  return 1; 
43. } 
44. ... 
45. return 0; 

上面的代码表示，如果指定为默认的处理方法，那么就使用系统的默认处理方法去处理信号，比如 SIGSEGV 信号的默认处理方法就是使用 do_coredump() 函数来生成一个 core dump 文件，并且通过调用 do_exit() 函数退出进程。

如果指定了自定义的处理方法，那么就通过 handle_signal() 函数去进行处理，handle_signal() 函数代码如下：

1. static void 
2. handle_signal(unsigned long sig, struct k_sigaction *ka, 
3.        siginfo_t *info, sigset_t *oldset, struct pt_regs * regs) 
4. { 
5.  ... 
6.  if (ka->sa.sa_flags & SA_SIGINFO) 
7.   setup_rt_frame(sig, ka, info, oldset, regs); 
8.  else 
9.   setup_frame(sig, ka, oldset, regs); 
10.  
11.  if (ka->sa.sa_flags & SA_ONESHOT) 
12.   ka->sa.sa_handler = SIG_DFL; 
13.  
14.  if (!(ka->sa.sa_flags & SA_NODEFER)) { 
15.   spin_lock_irq(&current->sigmask_lock); 
16.   sigorsets(&current->blocked,&current->blocked,&ka->sa.sa_mask); 
17.   sigaddset(&current->blocked,sig); 
18.   recalc_sigpending(current); 
19.   spin_unlock_irq(&current->sigmask_lock); 
20.  } 
21. } 

由于信号处理程序是由用户提供的，所以信号处理程序的代码是在用户态的。而从系统调用返回到用户态前还是属于内核态，CPU是禁止内核态执行用户态代码的，那么怎么办?

答案先返回到用户态执行信号处理程序，执行完信号处理程序后再返回到内核态，再在内核态完成收尾工作。听起来有点绕，事实也的确是这样。下面通过一副图片来直观的展示这个过程(图片来源网络)：

signal

为了达到这个目的，Linux经历了一个十分崎岖的过程。我们知道，从内核态返回到用户态时，CPU要从内核栈中找到返回到用户态的地址(就是调用系统调用的下一条代码指令地址)，Linux为了先让信号处理程序执行，所以就需要把这个返回地址修改为信号处理程序的入口，这样当从系统调用返回到用户态时，就可以执行信号处理程序了。

所以，handle_signal() 调用了 setup_frame() 函数来构建这个过程的运行环境(其实就是修改内核栈和用户栈相应的数据来完成)。我们先来看看内核栈的内存布局图：

signal-kernel-stack

图中的 eip 就是内核态返回到用户态后开始执行的第一条指令地址，所以把 eip 改成信号处理程序的地址就可以在内核态返回到用户态的时候自动执行信号处理程序了。我们看看 setup_frame() 函数其中有一行代码就是修改 eip 的值，如下：

1. static void setup_frame(int sig, struct k_sigaction *ka, 
2.    sigset_t *set, struct pt_regs * regs) 
3. { 
4.     ... 
5.     regs->eip = (unsigned long) ka->sa.sa_handler; // regs是内核栈中保存的寄存器集合 
6.     ... 
7. } 

现在可以在内核态返回到用户态时自动执行信号处理程序了，但是当信号处理程序执行完怎么返回到内核态呢?Linux的做法就是在用户态栈空间构建一个 Frame(帧)(我也不知道为什么要这样叫)，构建这个帧的目的就是为了执行完信号处理程序后返回到内核态，并恢复原来内核栈的内容。返回到内核态的方式是调用一个名为 sigreturn() 系统调用，然后再 sigreturn() 中恢复原来内核栈的内容。

怎样能在执行完信号处理程序后调用 sigreturn() 系统调用呢?其实跟前面修改内核栈 eip 的值一样，这里修改的是用户栈 eip 的值，修改后跳转到一个执行下面代码的地方(用户栈的某一处)：

1. popl %eax  
2. movl $__NR_sigreturn,%eax  
3. int $0x80 

从上面的汇编代码可以知道，这里就是调用了 sigreturn() 系统调用。修改用户栈的代码在 setup_frame() 中，代码如下：

1. static void setup_frame(int sig, struct k_sigaction *ka, 
2.    sigset_t *set, struct pt_regs * regs) 
3. { 
4.  ... 
5.   err |= __put_user(frame->retcode, &frame->pretcode); 
6.   /* This is popl %eax ; movl $,%eax ; int $0x80 */ 
7.   err |= __put_user(0xb858, (short *)(frame->retcode+0)); 
8.   err |= __put_user(__NR_sigreturn, (int *)(frame->retcode+2)); 
9.   err |= __put_user(0x80cd, (short *)(frame->retcode+6)); 
10.  ... 
11. } 

这几行代码比较难懂，其实就是修改信号程序程序返回后要执行代码的地址。修改后如下图：

signal-user-stack

这样执行完信号处理程序后就会调用 sigreturn()，而 sigreturn() 要做的工作就是恢复原来内核栈的内容了，我们来看看 sigreturn() 的代码：

1. asmlinkage int sys_sigreturn(unsigned long __unused) 
2. { 
3.  struct pt_regs *regs = (struct pt_regs *) &__unused; 
4.  struct sigframe *frame = (struct sigframe *)(regs->esp - 8); 
5.  sigset_t set; 
6.  int eax; 
7.  
8.  if (verify_area(VERIFY_READ, frame, sizeof(*frame))) 
9.   goto badframe; 
10.  if (__get_user(set.sig[0], &frame->sc.oldmask) 
11.      || (_NSIG_WORDS > 1 
12.   && __copy_from_user(&set.sig[1], &frame->extramask, 
13.         sizeof(frame->extramask)))) 
14.   goto badframe; 
15.  
16.  sigdelsetmask(&set, ~_BLOCKABLE); 
17.  spin_lock_irq(&current->sigmask_lock); 
18.  current->blocked = set; 
19.  recalc_sigpending(current); 
20.  spin_unlock_irq(&current->sigmask_lock); 
21.  
22.  if (restore_sigcontext(regs, &frame->sc, &eax)) 
23.   goto badframe; 
24.  return eax; 
25.  
26. badframe: 
27.  force_sig(SIGSEGV, current); 
28.  return 0; 
29. } 

其中最重要的是调用 restore_sigcontext() 恢复原来内核栈的内容，要恢复原来内核栈的内容首先是要指定原来内核栈的内容，所以先要保存原来内核栈的内容。保存原来内核栈的内容也是在 setup_frame() 函数中，setup_frame() 函数把原来内核栈的内容保存到用户栈中(也就是上面所说的 帧 中)。restore_sigcontext() 函数就是从用户栈中读取原来内核栈的数据，然后恢复之。保存内核栈内容主要由 setup_sigcontext() 函数完成，有兴趣可以查阅代码，这里就不做详细说明了。

这样，当从 sigreturn() 系统调用返回时，就可以按原来的路径返回到用户程序的下一个执行点(比如调用系统调用的下一行代码)。

设置信号处理程序

最后我们来分析一下怎么设置一个信号处理程序。

用户可以通过 signal() 系统调用设置一个信号处理程序，我们来看看 signal() 系统调用的代码：

1. asmlinkage unsigned long 
2. sys_signal(int sig, __sighandler_t handler) 
3. { 
4.  struct k_sigaction new_sa, old_sa; 
5.  int ret; 
6.  
7.  new_sa.sa.sa_handler = handler; 
8.  new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK; 
9.  
10.  ret = do_sigaction(sig, &new_sa, &old_sa); 
11.  
12.  return ret ? ret : (unsigned long)old_sa.sa.sa_handler; 
13. } 

代码比较简单，就是先设置一个新的 struct k_sigaction 结构，把其 sa.sa_handler 字段设置为用户自定义的处理程序。然后通过 do_sigaction() 函数进行设置，代码如下：

1. int 
2. do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact) 
3. { 
4.     struct k_sigaction *k; 
5.  
6.     if (sig < 1 || sig > _NSIG || 
7.         (act && (sig == SIGKILL || sig == SIGSTOP))) 
8.         return -EINVAL; 
9.  
10.     k = &current->sig->action[sig-1]; 
11.  
12.     spin_lock(&current->sig->siglock); 
13.  
14.     if (oact) 
15.         *oact = *k; 
16.  
17.     if (act) { 
18.         *k = *act; 
19.         sigdelsetmask(&k->sa.sa_mask, sigmask(SIGKILL) | sigmask(SIGSTOP)); 
20.          
21.         if (k->sa.sa_handler == SIG_IGN 
22.             || (k->sa.sa_handler == SIG_DFL 
23.             && (sig == SIGCONT || 
24.                 sig == SIGCHLD || 
25.                 sig == SIGWINCH))) { 
26.             spin_lock_irq(&current->sigmask_lock); 
27.             if (rm_sig_from_queue(sig, current)) 
28.                 recalc_sigpending(current); 
29.             spin_unlock_irq(&current->sigmask_lock); 
30.         } 
31.     } 
32.  
33.     spin_unlock(&current->sig->siglock); 
34.     return 0; 
35. } 

这个函数也不难，我们上面介绍过，进程管理结构中有个 sig 的字段，它是一个 struct k_sigaction 结构的数组，每个元素保存着对应信号的处理程序，所以 do_sigaction() 函数就是修改这个信号处理程序。代码 k = ¤t->sig->action[sig-1] 就是获取对应信号的处理程序，然后把其设置为新的信号处理程序即可。

原文链接：https://mp.weixin.qq.com/s/rcpK-UEYIy628b77IG-obA