可以看到 Pause 容器做如下两件事情：

1. 注册各种信号处理函数，主要处理两类信息：退出信号和 child 信号。收到 SIGINT 或是 SIGTERM 后，直接退出。收到 SIGCHLD 信号，调用 waitpid, 回收退出进程
2. 主进程 for 循环调用 pause() 函数，使进程进入休眠状态，直到被终止或是收到信号

可疑的 waitpid

还是 c 的基础不够扎实，一直以为 waitpid 是父进程等待回收退出的子进程，但是真的这样嘛?

1. zerun.dong$ man waitpid 
2. WAIT(2)                     BSD System Calls Manual                    WAIT(2) 
3.  
4. NAME 
5.      wait, wait3, wait4, waitpid — wait for process termination 
6.  
7. SYNOPSIS 
8.      #include <sys/wait.h> 

在 mac 上查看 man 手册，wait for process termination 也确实这么写的。登到 ubuntu 18.04 查看一下

1. :~# man waitpid 
2. WAIT(2)                                                      Linux Programmer's Manual                                                      WAIT(2) 
3.  
4. NAME 
5.        wait, waitpid, waitid – wait for process to change state 

对于 linux man 手册，就变成了 wait for process to change state 等待进程的状态变更!!!

1. All of these system calls are used to wait for state changes in a child of the calling process, and obtain information about the child whose 
2. state has changed.  A state change is considered to be: the child terminated; the child was stopped by a signal; or the child was resumed by 
3. a  signal.   In the case of a terminated child, performing a wait allows the system to release the resources associated with the child; if a 
4. wait is not performed, then the terminated child remains in a "zombie" state (see NOTES below). 

并且还很贴心的提供了测试代码

1. #include <sys/wait.h> 
2. #include <stdlib.h> 
3. #include <unistd.h> 
4. #include <stdio.h> 
5.  
6. int main(int argc, char *argv[]) 
7. { 
8.    pid_t cpid, w; 
9.    int wstatus; 
10.  
11.    cpid = fork(); 
12.    if (cpid == -1) { 
13.        perror("fork"); 
14.        exit(EXIT_FAILURE); 
15.    } 
16.  
17.    if (cpid == 0) {            /* Code executed by child */ 
18.        printf("Child PID is %ld ", (long) getpid()); 
19.        if (argc == 1) 
20.            pause();                    /* Wait for signals */ 
21.        _exit(atoi(argv[1])); 
22.  
23.    } else {                    /* Code executed by parent */ 
24.        do { 
25.            w = waitpid(cpid, &wstatus, WUNTRACED | WCONTINUED); 
26.            if (w == -1) { 
27.                perror("waitpid"); 
28.                exit(EXIT_FAILURE); 
29.            } 
30.  
31.            if (WIFEXITED(wstatus)) { 
32.                printf("exited, status=%d ", WEXITSTATUS(wstatus)); 
33.            } else if (WIFSIGNALED(wstatus)) { 
34.                printf("killed by signal %d ", WTERMSIG(wstatus)); 
35.            } else if (WIFSTOPPED(wstatus)) { 
36.                printf("stopped by signal %d ", WSTOPSIG(wstatus)); 
37.            } else if (WIFCONTINUED(wstatus)) { 
38.                printf("continued "); 
39.            } 
40.        } while (!WIFEXITED(wstatus) && !WIFSIGNALED(wstatus)); 
41.        exit(EXIT_SUCCESS); 
42.    } 
43. } 

子进程一直处于 pause 状态，而父进程则调用 waitpid 等待子进程状态变更。让我们开启一个 session 运行代码，另外一个 session 发送信号

1. ~$ ./a.out 
2. Child PID is 70718 
3. stopped by signal 19 
4.  
5. continued 
6. stopped by signal 19 
7. continued 
8. ^C 
9. ~# ps aux | grep a.out 
10. zerun.d+   70717  0.0  0.0   4512   744 pts/0    S+   06:48   0:00 ./a.out 
11. zerun.d+   70718  0.0  0.0   4512    72 pts/0    S+   06:48   0:00 ./a.out 
12. root       71155  0.0  0.0  16152  1060 pts/1    S+   06:49   0:00 grep –color=auto a.out 
13. ~# 
14. ~# kill -STOP 70718 
15. ~# 
16. ~# ps aux | grep a.out 
17. zerun.d+   70717  0.0  0.0   4512   744 pts/0    S+   06:48   0:00 ./a.out 
18. zerun.d+   70718  0.0  0.0   4512    72 pts/0    T+   06:48   0:00 ./a.out 
19. root       71173  0.0  0.0  16152  1060 pts/1    S+   06:49   0:00 grep –color=auto a.out 
20. ~# 
21. ~# kill -CONT 70718 
22. ~# 
23. ~# ps aux | grep a.out 
24. zerun.d+   70717  0.0  0.0   4512   744 pts/0    S+   06:48   0:00 ./a.out 
25. zerun.d+   70718  0.0  0.0   4512    72 pts/0    S+   06:48   0:00 ./a.out 
26. root       71296  0.0  0.0  16152  1056 pts/1    R+   06:49   0:00 grep –color=auto a.out 

通过向子进程发送信号 STOP CONT 来控制进程。

看来不同操作系统，同名 c 函数行为是不太一样的。大惊小怪，就是菜:(

共享哪些 NS

一般提起 POD 就知道，同一个 POD 内的容器如果互相访问，只需调用 localhost 即可。如果把 k8s 集群想象成分布式操作系统，那么 POD 就是进程组的概念，一定要共享某些东西的，那么默认共享哪些 namespace 呢?

使用 minikube 搭建环境，先看一下 POD 定义文件