1. 首页
  2. 文章

当执行kill -9 PID时系统发生了什么

· · 2380 次点击 · · 开始浏览    
这是一个创建于 的文章，其中的信息可能已经有所发展或是发生改变。

我们时常遇到这样的需求：要杀死一个正在运行运行的进程。这时候可以在终端输入

1

kill -9 <PID>

（其中9的意思是SIGKILL，完整的linux信号请看这里）之后你再用ps查看进程的时候，会发现那个进程已经被杀掉了。

本文将说明在LINUX系统下，用户在终端输入kill -9 <PID>之后，整个系统到底发生了什么，我们将深入到内核代码。一开始我在想这个问题的时候遇到了一些问题，比如进程是怎么知道自己收到信号的？在执行进程工作代码的同时还要不断轮询有没有新到的信号吗？代价也太大了吧？那是不是基于什么异步通知的方案呢？在说明LINUX是怎么做的之前，先解释一点基础的概念。

什么是信号（SIGNAL）

我自己的理解：信号之于进程，就好比中断之于CPU，是一种信息传递的方式。官方的解释是A signal is an asynchronous notification sent to a process or to a specific thread within the same process in order to notify it of an event that occurred. 一个程序在运行的时候，你可以发各种信号给这个进程，进程对这个信号做出响应。比如你发个SIGKILL给一个进程，该进程就知道用户要杀死它，然后就会终止进程。 一个更常见的例子，你在终端运行一个进程以后，如果是非后台进程，它会在console输出一些log，这时候shell也不能接受输入了，这时候你按下control+c，进程就被终止了，在这个过程中你就给这个进程发送了一个信号（SIGINT，interrupt signal），在默认情况下，是终止改进程。 那什么时候是非默认情况呢？这里需要引入信号处理器（signal handler）的概念，你可以为一部分信号编写特定的处理函数，比如在默认情况下，SIGINT是结束进程，你可以修改这个默认行为使它什么都不做（即一个空函数），但是有些信号的行为是无法修改的，比如SIGKILL。

kill 命令

在LINUX下有一个kill的命令，第一次用的同学会以为这是一个“杀死”某个进程的命令，其实并不是很准确。这个命令的作用就是给指定PID的进程发送信号，到底发送什么信号也是由参数指定的，如果不指定信号，默认是发送SIGTERM，它的默认行为是终止进程。其实kill也是个程序，它内部会调用system call的kill来发起真正信号传递过程。 更详细的介绍请man 2 kill

shell fork进程

当你敲下命令，按下回车，程序就执行了，其实这里也是个很复杂的过程。涉及到了shell的运行原理，每一个shell的实现都不一样，但核心原理是不变的：fork一个子进程，再调用execve那一系列系统调用。想了解一个shell是怎么写的，我觉得最好的资料是《Unix/Linux编程实践教程》第八章。本文不会详细解释shell/fork/execve，我会在另一篇博客里详细解释当你执行fork时，系统发生了什么。

好了，基础知识差不多介绍完了，下面我们进入下一阶段。

kill -9 PID

我们先讲原理再深入实现细节。所有内核代码都基于3.16.3，本文出现的所有内核代码是我删除了一些错误处理，加锁，临界判断后的结果，所以是比较核心的代码。

执行kill -9 <PID>，进程是怎么知道自己被发送了一个信号的？首先要产生信号，执行kill程序需要一个pid，根据这个pid找到这个进程的task_struct（这个是Linux下表示进程/线程的结构），然后在这个结构体的特定的成员变量里记下这个信号。 这时候信号产生了但还没有被特定的进程处理，叫做Pending signal。 等到下一次CPU调度到这个进程的时候，内核会保证先执行do\_signal这个函数看看有没有需要被处理的信号，若有，则处理；若没有，那么就直接继续执行该进程。所以我们看到，在Linux下，信号并不像中断那样有异步行为，而是每次调度到这个进程都是检查一下有没有未处理的信号。

当然信号的产生不仅仅在终端kill的时候才产生的。总结起来，大概有如下三种产生方式：

  • 硬件异常：比如除0
  • 软件通知：比如当你往一个已经被对方关闭的管道中写数据的时候，会发生SIGPIPE
  • 终端信号：你输入kill -9 <PID>，或者control+c就是这种类型

大概原理就是这个样子的，接下来我们来看一看内核的实现。

实现

首先，你在shell里输入kill这个命令，它本身就是个程序，是有源代码的，它的代码可以在Linux的coreutils里找到。代码很长，我就不全复制过来了，有兴趣的可以去仔细看看。它的核心代码是长这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

static int
send_signals (int signum, char *const *argv)
{
    ...
    kill (pid, signum);
    ...
}

int
main (int argc, char **argv)
{
    ...
    send_signals (signum, argv + optind));
    ...
}

我们看到最后调用了系统调用kill，其代码在Linux内核linux-3.16.3/kernel/signal.c中实现。在看kill源码之前，先把这个函数最终要操作的结构体看一下，这个struct很长，只列出了信号相关的部分：

1
2
3
4
5
6
7
8
9
10
11

struct task_struct {
    ...
/* signal handlers */
  struct signal_struct *signal; /* 一个进程所有线程共享一个signal */
  struct sighand_struct *sighand; 

  sigset_t blocked, real_blocked; /* 哪些信号被阻塞了 */
  sigset_t saved_sigmask; /* restored if set_restore_sigmask() was used */
  struct sigpending pending; /* 进程中的多个线程有各自的pending */
    ...
}

继续看kill系统调用，我将核心代码列在了下面，想看完整版的点这里。为了方便理解，我给核心逻辑增加了注释。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
{
    ...
    return kill_something_info(sig, &info, pid);
}

static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
{
  int ret;

    // 如果pid大于0，就把信号发送给指定的进程
  if (pid > 0) {
      ret = kill_pid_info(sig, info, find_vpid(pid));
      return ret;
  }

    // 如果pid <=0 并且不等于-1，发送信号给-pid指定的进程组
  if (pid != -1) {
      ret = __kill_pgrp_info(sig, info,
              pid ? find_vpid(-pid) : task_pgrp(current));
  } else {    
        //否则发信号给除自己所属进程之外的其它所有进程
      int retval = 0, count = 0;
      struct task_struct * p;

      for_each_process(p) {
          if (task_pid_vnr(p) > 1 &&
                  !same_thread_group(p, current)) {
              int err = group_send_sig_info(sig, info, p);
              ++count;
              if (err != -EPERM)
                  retval = err;
          }
      }
      ret = count ? retval : -ESRCH;
  }

  return ret;
}

因为这个kill_something_info函数会根据pid的正负来决定是发给特定的进程还是一个进程组，我们下面主要来看发给一个特定进程的情况，即调用kill_pid_info：

1
2
3
4
5
6
7
8
9
10
11
12

int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
{
  int error = -ESRCH;
  struct task_struct *p;
   
  p = pid_task(pid, PIDTYPE_PID);
  if (p) {
      error = group_send_sig_info(sig, info, p);
  }

  return error;
}

注意这个函数，出现了我们上文提到的task_strcut，这个是Linux下表示每个进程/线程的结构体，根据struct pid找到这个结构后，就调用了group_send_sig_info：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
{
  int ret;

    ret = do_send_sig_info(sig, info, p, true);

  return ret;
}


int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
          bool group)
{
  unsigned long flags;
  int ret = -ESRCH;

  if (lock_task_sighand(p, &flags)) {
      ret = send_signal(sig, info, p, group);
      unlock_task_sighand(p, &flags);
  }

  return ret;
}

static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
          int group)
{
  int from_ancestor_ns = 0;

#ifdef CONFIG_PID_NS
  from_ancestor_ns = si_fromuser(info) &&
             !task_pid_nr_ns(current, task_active_pid_ns(t));
#endif

  return __send_signal(sig, info, t, group, from_ancestor_ns);
}


static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
          int group, int from_ancestor_ns)
{
  struct sigpending *pending;
  struct sigqueue *q;
  int override_rlimit;
  int ret = 0, result;

    // 发送给进程和线程的区别在这里，如果是进程，则&t->signal->shared_pending，否则&t->pending
  pending = group ? &t->signal->shared_pending : &t->pending;

  /*
   * fast-pathed signals for kernel-internal things like SIGSTOP
   * or SIGKILL.
   */
  if (info == SEND_SIG_FORCED)
      goto out_set;
    
    ...

out_set:
    // 把信号通知listening signalfd. 
  signalfd_notify(t, sig);

    // 将sig加入目标进程的信号位图中，待下一次CPU调度的时候读取
  sigaddset(&pending->signal, sig);

    // 用于决定由哪个进程/线程处理该信号，然后wake_up这个进程/线程
  complete_signal(sig, t, group);
ret:
  trace_signal_generate(sig, info, t, group, result);
  return ret;
}

可以看到，最终调用到__send_signal，设置信号的数据结构，wake up需要处理信号的进程，整个信号传递的过程就结束了。这时候信号还没有被进程处理，还是一个pending signal。

信号的处理

内核调度到该进程时，会调用do_notify_resume来处理信号队列中的信号，之后这个函数又会调用do_signal，再调用handle_signal，具体过程就不用代码说明了，最后会找到每一个信号的处理函数，问题是这个怎么找到？

还记得在上文提到的task_struct吗，里面有一个成员变量sighand_struct就是用来存储每个信号的处理函数的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

struct sighand_struct {
  atomic_t        count;  /* 引用计数 */
  struct k_sigaction  action[_NSIG]; /* 存储处理函数的结构 */
  spinlock_t      siglock;    /* 自旋锁 */
  wait_queue_head_t   signalfd_wqh;   /* 等待队列 */
};


struct k_sigaction {
  struct sigaction sa;
}

struct sigaction {
  __sighandler_t  sa_handler;
  unsigned long   sa_flags;
  sigset_t    sa_mask;    /* mask last for extensibility */
};

其中sa_handler就指向了信号的处理程序。

为某个信号注册处理函数

Linux提供了修改信号的处理函数的system call，具体如何使用这些system call不是本文的重点，如果你有兴趣可以参考《Computer System: A programmer’s perspective》8.5节或者参考资料[6]，里面提供了非常详细的例子。

总结

这篇文章基于Linux 3.16.3讲述了从shell敲下kill -9 <PID>后整个系统发生了什么。主要涉及从用户态的shell程序开始，执行coreutils中kill，之后陷入到内核代码，分析了相关的数据结构，信号产生和传递的原理以及核心代码。

参考

[1] http://en.wikipedia.org/wiki/Unix_signal
[2] http://stackoverflow.com/questions/1860175/how-does-a-process-come-to-know-that-it-has-received-a-signal
[3] http://www.linuxjournal.com/article/3985
[4] http://blog.csdn.net/walkingman321/article/details/6167435
[5] http://blog.csdn.net/morphad/article/details/9236975
[6] http://www.alexonlinux.com/signal-handling-in-linux

欢迎关注微信公众号
qrcode

本文来自：

感谢作者：

查看原文：当执行kill -9 PID时系统发生了什么

2380 次点击  
加入收藏 微博
赞
收入我的专栏
上一篇：happens
下一篇：CPU漏洞之后 Ring 0究竟什么鬼？
  • 代码
  • linux
  • 函数
  • 处理函数
    0 回复
    暂无回复
    添加一条新回复 （您需要 登录 后才能回复 没有账号 ？）
    • 请尽量让自己的回复能够对别人有帮助
    • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
    • 支持 @ 本站用户；支持表情（输入 : 提示），见 Emoji cheat sheet
    • 图片支持拖拽、截图粘贴等方式上传

    用户登录

     今日阅读排行

      加载中

     一周阅读排行

      加载中