Linux Kernel: Signal

specific_send_sig_info(sig, info, t):
  if (sig_ignored(t, sig)):
        // task_struct->block 是一个 64 bit 的 mask, 标识哪些 sig 被
        // block. 被 block 的 sig 不能被 ignore, 因为它们需要被放在 pending
        // signal 中以便 unblock 时进程能再次收到这个 sig
        if (sigismember(&t->blocked, sig)):
          return 0;
        // 若 t->sighand 中 sig 对应的 handler 为 SIG_IGN 或 handler 为
        // SIG_DFL 但 sig 的默认 handler 也为 ignore, 则忽略这个 sig
        handler = t->sighand->action[sig-1].sa.sa_handler;
        return   handler == SIG_IGN || (handler == SIG_DFL && sig_kernel_ignore(sig));
    goto out;
  // 没有 ignore 的 sig 最终需在放在 t->pending 中, sigpending->signal 是
  // 一个 bitmask, 标识 pending 列表中是否已经存在相同 sig 的 signal.
  //
  // 对于普通的 (非 real time) 的 signal, 对于同一个 sig, pending 列表中
  // 最多只会保存一个对应的 signal, 即多个普通 signal 不会累积在 pending
  // 中.
  //
  // 但对于 real time signal, 多个 real time signal 是可以在 pending 中累
  // 积的
  if (LEGACY_QUEUE(&t->pending, sig)):
        (((sig) < SIGRTMIN) && sigismember(&(pending)->signal, (sig)))
    goto out;

  send_signal(sig, info, t, &t->pending);
  // 如果 sig 没有 block, 则唤醒进程以便它能及时响应这个 signal
  if (!ret && !sigismember(&t->blocked, sig)):
    signal_wake_up(t, sig == SIGKILL);
      // 设置 TIF_SIGPENDING, 以便 ret_from_intr 时能发现有 pending signal
      set_tsk_thread_flag(t, TIF_SIGPENDING);
      // 正常情况下只有处于 TASK_INTERRUPTIBLE 状态的进程才会被唤醒, 但若
      // sig 为 SIG_KILL, 则 TASK_STOPPED 状态和 TASK_TRACED 状态的进程也
      // 会被唤醒.
      //
      // 所以正在 sleep 或阻塞在 read 上的进程会被唤醒, 这也是 signal 导致系统调
      // 用提前返回的原因. 另外, 处于 D 状态 (TASK_UNINTERRUPTIBLE) 的进
      // 程不会被唤醒, 所以 D 状态的进程无法及时响应 signal
      mask = TASK_INTERRUPTIBLE;
      if (resume):
        mask |= TASK_STOPPED | TASK_TRACED;
      wake_up_state(t, mask)

send_signal(sig, info, t, pending):
  // 分配一个 sigqueue, 后面需要将它插入 pending 链表中
  q = __sigqueue_alloc(t, GFP_ATOMIC);
  list_add_tail(&q->list, &signals->list);
  switch ((unsigned long) info):
    // send_signal 时传入的 info (siginfo) 一般是由上层填充的, 包含
    // signo, errno, code, pid, uid, addr 等数据. 然后 send_signal 时通过
    // copy_siginfo 将 info 复制到 q->info 中.
    //
    // 但有时 kernel 有时会通过 force_sig, send_sig 发送一些信号, 而且这
    // 些信号并不需要通过 siginfo 传递大部分信息, 为了避免 copy_siginfo,
    // kernel 使用特定的 0, 1 做为 info 并在这里进行特殊的处理.
    case 0:
      q->info.si_signo = sig;
      q->info.si_errno = 0;
      q->info.si_code = SI_USER;
      q->info.si_pid = current->pid;
      q->info.si_uid = current->uid;
      break;
    case 1:
      q->info.si_signo = sig;
      q->info.si_errno = 0;
      q->info.si_code = SI_KERNEL;
      q->info.si_pid = 0;
      q->info.si_uid = 0;
      break;
    default:
      copy_siginfo(&q->info, info);
      break;

    sigaddset(&pending->signal, sig);

group_send_sig_info:
  __group_send_sig_info(sig, info, p);
    // 同一个 thread group 的 t->signal 和 t->sighand 是共享的 (t->blocked
    // 和 t->pending 是单独的), 所以 sig_ignored 对 p 或者 p 这个线程组中
    // 的所有线程都会返回相同的结果
    if (sig_ignored(p, sig)):
      return ret;
    // sig 将被加入 p->shared_pending 而不是 t->pending
    if (LEGACY_QUEUE(&p->signal->shared_pending, sig)):
      return ret;
    // 与 specific_send_sig_info 相同, 只不过是加入到 p->shared_pending 而不
    // 是 t->pending
    send_signal(sig, info, p, &p->signal->shared_pending);
    // 对于 specific_send_sig_info 来说, 这里会通过 signal_wake_up 唤
    // 醒 p 来响应这个信号. 但对于 group_send_sig_info 来说, 这里会通
    // 过__group_complete_signal 来选择 p 所在的 thread group 中的某一
    // 个 "合适" 的线程来响应这个信号
    __group_complete_signal(sig, p);

// __group_complete_signal 的目的是从 p 所在的 thread group 中选择一个
// 线程来唤醒, 以响应之前已经加入到 p->shared_pending 中的信号
__group_complete_signal(sig, p):
  // wants_signal 用来检查 thread p 是否 "应该" 响应 sig, 响应 sig 的条件
  // 为:
  // 1. sig 没有被 p block
  // 2. p->state 不是 mask 所指定的 state
  // 3. p 正占用着 cpu 或 p 没有任何 pending 信号 (p->pending 及
  //    p->shared_pending 为空)
  if (wants_signal(sig, p, mask)):
        #define wants_signal(sig, p, mask)                      \
          (!sigismember(&(p)->blocked, sig)             \
           && !((p)->state & mask)                      \
           && !((p)->flags & PF_EXITING)                 \
           && (task_curr(p) || !signal_pending(p)))
    // 优先选择 kill syscall 最初指定的线程来响应信号
    t = p;
  else:
    // 从 thread group 中选择一个 wants_signal 为真的
    // p->signal->curr_target 记录了上次响应信号的 thread, 通过这个可以
    // 在一定程度上实现信号处理的 load balancing
    t = p->signal->curr_target;
    if (t == NULL):
      t = p->signal->curr_target = p;
    // 遍历所有的 thread
    while (!wants_signal(sig, t, mask)):
      t = next_thread(t);
      // 没有任何一个 thread wants_signal, 那这里无法唤醒任何线程: 只能等
      // 着某个线程 "自然" 唤醒后来处理这个信号了
      if (t == p->signal->curr_target)
        return;
    p->signal->curr_target = t;

  if (sig_fatal(p, sig) ....):
    // 如果是 fatal 信号, 直接 kill 掉 thread group 中所有线程, 这一点
    // 与 get_signal_to_deliver 里的逻辑差不多
    ...
  // 最后, 唤醒 t 来响应这个信号
  signal_wake_up(t, sig == SIGKILL);

sys_kill(int pid, int sig):
  struct siginfo info;

  info.si_signo = sig;
  info.si_errno = 0;
  info.si_code = SI_USER;
  info.si_pid = current->tgid;
  info.si_uid = current->uid;

  kill_something_info(sig, &info, pid);
  // 若 pid 为 0, 则表示要给当前进程所在进程组的所有进程发送信号. 关于进
  // 程组, 参考 [[file:process.org::*Processes%20Relationship][Processes Relationship]]
  if (!pid):
    return kill_pg_info(sig, info, process_group(current));
      // pg 是指 process group, 即进程组
      do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
        group_send_sig_info(sig, info, p);
      } while_each_task_pid(pgrp, PIDTYPE_PGID, p);

  // 若 pid 为负数, 则给 -pid 所指示的进程组的每个进程发送信号
  else if (pid < 0):
    return kill_pg_info(sig, info, -pid);
  // 给 pid 指示的进程发送信号
  else:
    return kill_proc_info(sig, info, pid);
      p = find_task_by_pid(pid);
      group_send_sig_info(sig, info, p);

do_page_fault:
  info.si_signo = SIGSEGV;
  info.si_errno = 0;
  info.si_addr = (void __user *)address;
  force_sig_info(SIGSEGV, &info, tsk);
    // 若 sig 被 blocked, 则 force_sig_info 强制把它 unblock; 若
    // sa_handler 被修改为 SIG_IGN, 则 force_sig_info 会强制把
    // sa_handler 变为 SIG_DFL...
    //
    // 所以看起来应用把 sa_handler 写成一个空函数和直接设置为 SIG_IGN 还是
    // 有些差别的
    if (sigismember(&t->blocked, sig) ||
        t->sighand->action[sig-1].sa.sa_handler == SIG_IGN):
      t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
      sigdelset(&t->blocked, sig);
      recalc_sigpending_tsk(t);
    specific_send_sig_info(sig, info, t);

get_signal_to_deliver:
  sigset_t *mask = &current->blocked;
  signr = dequeue_signal(current, mask, info);
    int signr = __dequeue_signal(&tsk->pending, mask, info);
      // 从 pending->signal 这个 bitmask 找到 mask 之外的第一个 pending
      // 的 signr
      sig = next_signal(pending, mask);
      // 从 pending 列表中找到对应于 sig 的 siginfo
      collect_signal(sig, pending, info)
    // 若 pending 中没有, 则查找 shared_pending. group_send_sig_info 时
    // 会将信号加入到 shared_pending 中
    if (!signr):
      signr = __dequeue_signal(&tsk->signal->shared_pending, mask, info);
  // 没有任何 pending signal
  if (!signr):
    break;

  // 找到一个 pending signal
  ka = &current->sighand->action[signr-1];
  if (ka->sa.sa_handler == SIG_IGN):
    continue;
  if (ka->sa.sa_handler != SIG_DFL):
    // 找到一个有 sa_handler 的信号, 返回到上层, 后续会调用 handle_signal
    // 来处理它
    *return_ka = *ka;
    if (ka->sa.sa_flags & SA_ONESHOT):
      ka->sa.sa_handler = SIG_DFL;
    break;
  // 前两个判断都不满足, 走 SIG_DFL 的处理路径
  if (sig_kernel_ignore(signr)):
    continue;
  if (current->pid == 1):
    continue;
  // sig 是 SIGSTOP 一类的信号
  if (sig_kernel_stop(signr)):
    do_signal_stop(signr)
    continue
  // 剩下的全是 fatal 信号
  if (sig_kernel_coredump(signr)):
    // 需要生成 coredump
    do_coredump((long)signr, signr, regs);
  // 对于 fatal 信号, 不仅仅是当前线程退出, 而是整个 thread group 中的所
  // 有线程都会退出
  do_group_exit(signr);
    zap_other_threads(current);
      for (t = next_thread(p); t != p; t = next_thread(t)):
        // 相当于给其它每个子线程都发送一个 SIGKILL
        sigaddset(&t->pending.signal, SIGKILL);
        rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
        signal_wake_up(t, 1);
    // do_exit 不会返回, 所以后面的 handle_signal 并不会执行
    do_exit(exit_code);

handle_signal(sig, info, ka, ...):
  // 最初应用通过 sigaction 时使用了 SA_SIGINFO 这个 flag, 表示上层的
  // handler 执行时需要拿到 siginfo 信息, kernel 需要调用 sigaction 时注
  // 册的 sa_sigaction 回调, 而不是 sa_handler.
  //
  // sa_sigaction 回调的原型为:
  //
  // void (sa_action *) (int signr, siginfo_t * info, void *)
  if (ka->sa.sa_flags & SA_SIGINFO):
    setup_rt_frame(sig, ka, info, oldset, regs);
  else:
    setup_frame(sig, ka, oldset, regs);

setup_frame:
  struct sigframe __user *frame;
  frame = get_sigframe(ka, regs, sizeof(*frame));
    // 在 user mode stack 上向下扩展出一块区域, 存放 sigframe
    esp = regs->esp;
    return (void __user *)((esp - frame_size) & -8ul);

  __put_user(sig, &frame->sig);
  setup_sigcontext(&frame->sc, &frame->fpstate, regs, set->sig[0]);
    // 将 regs 中原始内容保存在 sigframe 的 sigcontext 中, 因为后面 regs
    // 中的内容会被替换为 sa_handler 对应的部分
    __put_user(regs->edi, &sc->edi);
    __put_user(regs->esi, &sc->esi);
    __put_user(regs->ebp, &sc->ebp);
    __put_user(regs->esp, &sc->esp);
    __put_user(regs->ebx, &sc->ebx);
    __put_user(regs->edx, &sc->edx);
    __put_user(regs->ecx, &sc->ecx);
    __put_user(regs->eax, &sc->eax);
    __put_user(regs->eip, &sc->eip);
    __put_user(regs->xcs, (unsigned int __user *)&sc->cs);
    __put_user(regs->eflags, &sc->eflags);
    __put_user(regs->esp, &sc->esp_at_signal);

  restorer = &__kernel_sigreturn;
  __put_user(restorer, &frame->pretcode);

  // 这里对 regs 重新赋值, 当 do_signal 返回后 iret 会负责用 regs 恢复
  // user space 的上下文, 导致 user space 会跳转到 sa_handler, 并且参数为
  // sig, esp 为 frame.
  //
  // 所以, sa_handler 在 user mode 执行时 stack 的布局 (从高到低) 为:
  //
  // ..
  // sigcontext
  // sig
  // pretcode (__kernel_sigreturn)  <-- esp
  //
  // 因为 x86 默认使用栈来传递参数, 所以 sa_handler 执行时第一个参数 signr
  // 与栈上的 sig 是对应的 // 这里对 regs 重新赋值, 当 do_signal 返回后
  // iret 会负责用 regs 恢复 user space 的上下文, 导致 user space 会跳转到
  // sa_handler, 并且参数为 sig, esp 为 frame.
  //
  // 所以, 参考 sigframe 的定义, sa_handler 在 user mode 执行时 stack 的
  // 布局 (从高到低) 为:
  //
  // --high
  // ..
  // sigcontext
  // sig
  // pretcode (__kernel_sigreturn)  <-- esp
  // --low
  //
  regs->esp = (unsigned long) frame;
  regs->eip = (unsigned long) ka->sa.sa_handler;
  // x86 默认使用栈来传递参数, 这里并不明确设置 eax 的目的...
  regs->eax = (unsigned long) sig;
  regs->edx = (unsigned long) 0;
  regs->ecx = (unsigned long) 0;
  regs->xcs = __USER_CS;

pop %eax
mov $0x77,%eax
int $0x80

sys_sigreturn:
  // 为什么是 regs->esp - 8?
  // 根据前面描述的 sa_handler 的栈布局:
  //
  // --high
  // sigcontext
  // sig
  // pretcode (__kernel_sigreturn)  <-- esp
  // --low
  //
  // 当 sa_handler 结束时调用 ret 之前, esp 是指向 __kernel_sigreturn 的,
  // 也就是 sigframe. ret 指令会导致 esp + 4, 然后 __kernel_sigreturn 的
  // 第一句是 pop %eax, 导致 esp 再次 + 4, 此后通过 int 0x80 进入 syscall
  // 导致当前的 esp 已经偏离 sigframe 8 字节, 所以这里需要 -8 ... 至于
  // __kernel_sigreturn 为啥会 pop %eax 不清楚...
  //
  // 对应于 sys_rt_sigreturn 的 __kernel_rt_sigreturn 并没有这个 pop 操
  // 作, 所以 sys_rt_sigreturn 获得 sigframe 时只需要 - 4
  struct sigframe __user *frame = (struct sigframe __user *)(regs->esp - 8);
  // 使用 frame->sc 恢复旧的 regs
  restore_sigcontext(regs, &frame->sc, &eax)

#include <signal.h>

void * foo(int signr) {

}

int main(int argc, char *argv[]) {
    signal(10, foo);
    sleep(1000);
    return 0;
}