[apue] 等待子程序的那些事兒
談到等待子程序，首先想到的就是SIGCHLD訊號與wait函式族，本文試圖釐清二者的方方面面，以及組合使用時可能不小心掉進去的坑。
1. 首先談單獨使用SIGCHLD的場景。下面是一段典型的程式碼片段：
1 #include "../apue.h"
2 #include <sys/wait.h>
3
4 #define CLD_NUM 2
5 static void sig_cld (int signo)
6 {
7 pid_t pid = 0;
8 int status = 0;
9 printf ("SIGCHLD received\n");
10 if (signal (SIGCHLD, sig_cld) == SIG_ERR)
11 perror ("signal error");
12 if ((pid = wait (&status)) < 0)
13 perror ("wait(in signal) error");
14 printf ("pid (wait in signal) = %d\n", pid);
15 }
16
17 int main ()
18 {
19 pid_t pid = 0;
20 __sighandler_t ret = signal (SIGCHLD, sig_cld);
21 if (ret == SIG_ERR)
22 perror ("signal error");
23 else
24 printf ("old handler %x\n", ret);
25
26 for (int i=0; i<CLD_NUM; ++ i)
27 {
28 if ((pid = fork ()) < 0)
29 perror ("fork error");
30 else if (pid == 0)
31 {
32 sleep (3);
33 printf ("child %u exit\n", getpid ());
34 _exit (0);
35 }
36
37 sleep (1);
38 }
39
40 for (int i=0; i<CLD_NUM; ++ i)
41 {
42 pause ();
43 printf ("wake up by signal %d\n", i);
44 }
45
46 printf ("parent exit\n");
47 return 0;
48 }
父程序啟動了兩個子程序，在SIGCHLD訊號處理器中呼叫wait等待已結束的子程序，回收程序資訊，防止產生殭屍程序（zombie）。上面的程式碼會有如下的輸出：
old handler 0 child 28542 exit SIGCLD received pid (wait in signal) = 28542 wake up by signal 0 child 28543 exit SIGCLD received pid (wait in signal) = 28543 wake up by signal 1 parent exit
當然捕獲SIGCHLD，也可以使用sigaction介面：
1 #include "../apue.h"
2 #include <sys/wait.h>
3
4 #define CLD_NUM 2
5 static void sig_cld (int signo, siginfo_t *info, void* param)
6 {
7 int status = 0;
8 if (signo == SIGCHLD)
9 {
10 if (info->si_code == CLD_EXITED ||
11 info->si_code == CLD_KILLED ||
12 info->si_code == CLD_DUMPED)
13 {
14 //printf ("child %d die\n", info->si_pid);
15 if (waitpid (info->si_pid, &status, 0) < 0)
16 perror ("wait(in signal) error");
17 printf ("pid (wait in signal) = %d\n", info->si_pid);
18 }
19 else
20 {
21 printf ("unknown signal code %d\n", info->si_code);
22 }
23 }
24 }
25
26 int main ()
27 {
28 pid_t pid = 0;
29 struct sigaction act;
30 sigemptyset (&act.sa_mask);
31 act.sa_sigaction = sig_cld;
32 act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP;
33 int ret = sigaction (SIGCHLD, &act, 0);
34 if (ret == -1)
35 perror ("sigaction error");
36
37 for (int i=0; i<CLD_NUM; ++ i)
38 {
39 if ((pid = fork ()) < 0)
40 perror ("fork error");
41 else if (pid == 0)
42 {
43 sleep (3);
44 printf ("child %u exit\n", getpid ());
45 _exit (0);
46 }
47
48 sleep (1);
49 }
50
51 for (int i=0; i<CLD_NUM; ++ i)
52 {
53 pause ();
54 printf ("wake up by signal %d\n", i);
55 }
56
57 printf ("parent exit\n");
58 return 0;
59 }輸出是一樣的。
關於signal與sigaction的區別，有以下幾點：
a) 使用sigaction可以避免重新安裝訊號處理器的問題；
b) 使用sigaction可以在wait之前得知是哪個子程序結束了，這是通過指定SA_SIGINFO標誌位，並提供帶siginfo_t引數的訊號處理器來實現的（info->si_pid就是結束的程序號）；
c) 使用sigaction可以獲取除子程序結束以外的狀態變更通知，例如掛起、繼續，預設接收相應通知，除非指定SA_NOCLDSTOP標誌。而對於signal而言，沒有辦法不接收子程序非結束狀態的通知（此時呼叫wait可能會卡死）；
d) 使用sigaction可以自動wait已結束的子程序，只要指定SA_NOCLDWAIT標誌即可。此時在訊號處理器中不用再呼叫wait函數了。
當使用SA_NOCLDWAIT標誌位時，使用systemtap可以觀察到子程序還是向父程序傳送了SIGCHLD訊號的：
30049 cldsig 30048 cldsig 17 SIGCHLD 30050 cldsig 30048 cldsig 17 SIGCHLD
很有可能是系統內部自動wait了相關子程序。
另外在使用SA_NOCLDWAIT時，可以不指定訊號處理器，此時sa_sigaction欄位可以設定為SIG_DFL。
關於SIGCHLD訊號，有以下幾點需要注意：
a) 如果在註冊訊號之前，就已經有已結束但未等待的子程序存在，則事件不會被觸發；
b) 可以為SIGCHLD註冊一個處理器，也可以忽略該訊號（SIG_IGN），忽略時系統自動回收已結束的子程序；
當正常捕獲SIGCHLD時，使用systemtap是可以觀察到子程序向父程序傳送的SIGCHLD訊號的：
29877 cldsig 29876 cldsig 17 SIGCHLD 29878 cldsig 29876 cldsig 17 SIGCHLD 29876 cldsig 27771 bash 17 SIGCHLD
當忽略SIGCHLD時，是看不到的，只能看到父程序結束時向bash傳送的SIGCHLD訊號：
29893 cldsig 27771 bash 17 SIGCHLD
這裡注意一下二者在細節處的一點區別。
c) 還有一個SIGCLD訊號，在大多數unix like系統中與SIGCHLD表現一致，在某些古老的unix系統上，可能有獨特的表現需要注意，這方面請參考 apue 第十章第七節
在我測試的環境上（CentOS 6.7），該訊號被定義為SIGCHLD，因此是完全相同的；
關於使用訊號等待子程序最後需要談的一點就是訊號的競爭行為，對上面的例子稍加修改，就可以演示一下：
1 #include "../apue.h"
2 #include <sys/wait.h>
3
4 #define CLD_NUM 2
5 void pid_remove (pid_t pid)
6 {
7 printf ("remove pid %u\n", pid);
8 }
9 void pid_add (pid_t pid)
10 {
11 printf ("add pid %u\n", pid);
12 }
13
14 static void sig_cld (int signo)
15 {
16 pid_t pid = 0;
17 int status = 0;
18 printf ("SIGCHLD received\n");
19 if (signal (SIGCHLD, sig_cld) == SIG_ERR)
20 perror ("signal error");
21 if ((pid = wait (&status)) < 0)
22 perror ("wait(in signal) error");
23 printf ("pid (wait in signal) = %d\n", pid);
24 pid_remove (pid);
25 }
26
27 int main ()
28 {
29 pid_t pid = 0;
30 __sighandler_t ret = signal (SIGCHLD, sig_cld);
31 if (ret == SIG_ERR)
32 perror ("signal error");
33 else
34 printf ("old handler %x\n", ret);
35
36 for (int i=0; i<CLD_NUM; ++ i)
37 {
38 if ((pid = fork ()) < 0)
39 perror ("fork error");
40 else if (pid == 0)
41 {
42 //sleep (3);
43 printf ("child %u exit\n", getpid ());
44 _exit (0);
45 }
46
47 sleep (1);
48 pid_add (pid);
49 }
50
51 sleep (1);
52 printf ("parent exit\n");
53 return 0;
54 }
父程序在啟動子程序後需要將它的資訊通過pid_add新增到某種資料結構中，當收到SIGCHLD訊號後，又通過pid_remove將它從這個資料結構中移出。
在上面的例子中，子程序一啟動就退出了，快到甚至父程序還沒有來得及執行pid_add就先執行了pid_remove，這必然導致某種問題。
（注意，為了能更好的呈現訊號競爭的問題，這裡故意在父程序sleep之後呼叫pid_add），執行結果如下：
old handler 0 child 31213 exit SIGCLD received pid (wait in signal) = 31213 remove pid 31213 add pid 31213 child 31214 exit SIGCLD received pid (wait in signal) = 31214 remove pid 31214 add pid 31214 parent exit
可以看到，remove總是在add之前執行。而解決方案也很直接，就是在pid_add完成之前，我們需要遮蔽SIGCHLD訊號：
1 #include "../apue.h"
2 #include <sys/wait.h>
3
4 #define CLD_NUM 2
5 void pid_remove (pid_t pid)
6 {
7 printf ("remove pid %u\n", pid);
8 }
9 void pid_add (pid_t pid)
10 {
11 printf ("add pid %u\n", pid);
12 }
13
14 static void sig_cld (int signo)
15 {
16 pid_t pid = 0;
17 int status = 0;
18 printf ("SIGCHLD received\n");
19 if (signal (SIGCHLD, sig_cld) == SIG_ERR)
20 perror ("signal error");
21 if ((pid = wait (&status)) < 0)
22 perror ("wait(in signal) error");
23 printf ("pid (wait in signal) = %d\n", pid);
24 pid_remove (pid);
25 }
26
27 int main ()
28 {
29 pid_t pid = 0;
30 __sighandler_t ret = signal (SIGCHLD, sig_cld);
31 if (ret == SIG_ERR)
32 perror ("signal error");
33 else
34 printf ("old handler %x\n", ret);
35
36 for (int i=0; i<CLD_NUM; ++ i)
37 {
38 sigset_t mask;
39 sigemptyset(&mask);
40 sigaddset(&mask, SIGCHLD);
41 sigprocmask(SIG_BLOCK, &mask, NULL);
42 if ((pid = fork ()) < 0)
43 perror ("fork error");
44 else if (pid == 0)
45 {
46 sigprocmask(SIG_UNBLOCK, &mask, NULL);
47 //sleep (3);
48 printf ("child %u exit\n", getpid ());
49 _exit (0);
50 }
51
52 sleep (1);
53 pid_add (pid);
54 sigprocmask(SIG_UNBLOCK, &mask, NULL);
55 }
56
57 sleep (1);
58 printf ("parent exit\n");
59 return 0;
60 }
這裡用到了sigprocmask去遮蔽以及解除某種訊號的遮蔽。新的程式碼執行結果如下：
old handler 0 child 31246 exit add pid 31246 SIGCLD received pid (wait in signal) = 31246 remove pid 31246 child 31247 exit SIGCLD received pid (wait in signal) = 31247 remove pid 31247 add pid 31247 parent exit
可以看到一切正常了，add這次位於remove之前。
總結一下，使用SIGCHLD訊號適合非同步等待子程序的場景，並且通常搭配wait來回收子程序。
2. 然後談單獨使用wait函式族的場景。典型程式碼如下：
1 #include "../apue.h"
2 #include <sys/wait.h>
3
4 #define CLD_NUM 2
5 int main ()
6 {
7 pid_t pid = 0;
8 for (int i=0; i<CLD_NUM; ++ i)
9 {
10 if ((pid = fork ()) < 0)
11 perror ("fork error");
12 else if (pid == 0)
13 {
14 sleep (3);
15 printf ("child %u exit\n", getpid ());
16 _exit (0);
17 }
18
19 sleep (1);
20 }
21
22 int status = 0;
23 for (int i=0; i<CLD_NUM; ++ i)
24 {
25 if ((pid = wait (&status)) < 0)
26 perror ("wait error");
27
28 printf ("pid = %d\n", pid);
29 }
30
31 printf ("parent exit\n");
32 return 0;
33 }
與之前場景不同的是，這裡父程序同步等待啟動的子程序結束。上面的程式碼會有如下輸出：
child 28583 exit child 28584 exit pid = 28583 pid = 28584 parent exit
關於wait函式族，需要注意以下幾點：
a) wait用於等待任何一個子程序，相當於waitpid(-1, status, 0); 當沒有任何子程序存在時，返回-1，errno設定為ECHILD；
b) waitpid相對於wait的優勢在於：
i) 可以指定子程序(組)來等待；
ii) 可以捕獲子程序除結束以外的其它狀態變更通知，如掛起（WUNTRACED）、繼續（WCONTINUED）等；
iii) 可以不阻塞的測試某個子程序是否已結束（WNOHANG）；
c) wait函式族可被訊號中斷，此時返回-1，errno設定為EINTR，必要時需要重啟wait；
總結一下，使用wait函式族適合同步等待子程序，例如某種命令執行器程序，通常配合waitpid來回收子程序。
3. 最後談談混合使用同步wait與非同步wait函式族的場景。
其實前面已經提到SIGCHLD要搭配wait使用，但那是非同步使用wait的單一場景，而這裡講的混合，是指同時在訊號處理器與執行流程中使用wait。
例如bash，它除了在主流程中同步等待前臺正在執行的子程序，還必需在訊號處理器中非同步接收後臺執行子程序的狀態反饋，這樣就不得不混合使用wait。
同步等待某個子程序一般使用waitpid，而在訊號處理器中一般使用wait，典型的程式碼如下所示：
1 #include "../apue.h"
2 #include <sys/wait.h>
3 #include <errno.h>
4
5 #define CLD_NUM 2
6
7 static void sig_cld (int signo)
8 {
9 pid_t pid = 0;
10 int status = 0;
11 printf ("SIGCLD received\n");
12 if (signal (SIGCLD, sig_cld) == SIG_ERR)
13 perror ("signal error");
14
15 if ((pid = wait (&status)) < 0)
16 perror ("wait(in signal) error");
17 else
18 printf ("pid (wait in signal) = %d\n", pid);
19 }
20
21 int main ()
22 {
23 pid_t pid = 0;
24 __sighandler_t ret = signal (SIGCLD, sig_cld);
25 if (ret == SIG_ERR)
26 perror ("signal error");
27 else
28 printf ("old handler %x\n", ret);
29
30 for (int i=0; i<CLD_NUM; ++ i)
31 {
32 if ((pid = fork ()) < 0)
33 perror ("fork error");
34 else if (pid == 0)
35 {
36 if (i % 2 == 0) {
37 // simulate background
38 sleep (3);
39 }
40 else {
41 // simulate foreground
42 sleep (4);
43 }
44
45 printf ("child %u exit\n", getpid ());
46 _exit (0);
47 }
48
49 sleep (1);
50 }
51
52 int status = 0;
53 printf ("before wait pid %u\n", pid);
54 if (waitpid (pid, &status, 0) < 0)
55 printf ("wait %u error %d\n", pid, errno);
56 else
57 printf ("wait child pid = %d\n", pid);
58
59 sleep (2);
60 printf ("parent exit\n");
61 return 0;
62 }
父程序啟動兩個子程序，第一個休眠3秒後退出，第二個休眠4秒後退出，由於父程序同步等待的是第二個子程序，因此第二個程序模擬前臺程序，第一個程序模擬後臺程序。執行輸出如下：
old handler 0 before wait pid 2481 child 2480 exit SIGCLD received pid (wait in signal) = 2480 wait 2481 error 4 child 2481 exit SIGCLD received pid (wait in signal) = 2481 parent exit
此時同步等待的waitpid被訊號中斷了（EINTR)，此種情況下，我們需要重啟waitpid：
1 int status = 0;
2 while (1) {
3 printf ("before wait pid %u\n", pid);
4 if (waitpid (pid, &status, 0) < 0)
5 {
6 int err = errno;
7 printf ("wait %u error %d\n", pid, err);
8 if (err == EINTR)
9 continue;
10 }
11 else
12 printf ("wait child pid = %d\n", pid);
13
14 break;
15 }
如果因EINTR引發的錯誤，則重新呼叫waitpid；否則，退出。新的程式碼輸出如下：
old handler 0 before wait pid 2513 child 2512 exit SIGCLD received pid (wait in signal) = 2512 wait 2513 error 4 before wait pid 2513 child 2513 exit SIGCLD received wait(in signal) error: No child processes wait child pid = 2513 parent exit
可以看到兩個程序退出時，都收到了SIGCHLD訊號，只是前臺程序被waitpid優先等待到了，所以訊號處理器中的wait返回的ECHILD錯誤，但是如果還有其它子程序在執行，這裡將會在訊號處理器的wait中卡死。
之前提到，可以使用SIG_IGN來自動回收子程序，這裡試一下使用SIG_IGN來代替sig_cld，看看有什麼改觀。
old handler 0 before wait pid 2557 child 2556 exit child 2557 exit wait 2557 error 10 parent exit
同樣的，兩個子程序都走了忽略訊號，而同步等待的waitpid因沒有程序可等返回了ECHILD。因為waitpid是指定程序等待的，所以即使還有其它子程序存在，這個也會返回錯誤，不會卡死在那裡。
相比上面的方法，似乎好了一點，但是因為我們沒有安裝處理器，所以無從得知哪個後臺程序結束了，這並不是我們想到的結果。
之前提到，可以使用sigaction代替signal以獲取更多的控制，我們看看換新的方式捕獲訊號，會不會有一些改變，新的程式碼邏輯如下：
1 #include "../apue.h"
2 #include <sys/wait.h>
3 #include <errno.h>
4
5 #define CLD_NUM 2
6
7 static void sig_cld (int signo, siginfo_t *info, void* param)
8 {
9 int status = 0;
10 if (signo == SIGCHLD)
11 {
12 if (info->si_code == CLD_EXITED ||
13 info->si_code == CLD_KILLED ||
14 info->si_code == CLD_DUMPED)
15 {
16 if (waitpid (info->si_pid, &status, 0) < 0)
17 err_ret ("wait(in signal) %u error", info->si_pid);
18 else
19 printf ("pid (wait in signal) = %d\n", info->si_pid);
20 }
21 else
22 {
23 printf ("unknown signal code %d\n", info->si_code);
24 }
25 }
26 }
27
28 int main ()
29 {
30 pid_t pid = 0;
31 struct sigaction act;
32 sigemptyset (&act.sa_mask);
33 act.sa_sigaction = sig_cld;
34 act.sa_flags = SA_SIGINFO | SA_NOCLDSTOP;
35 int ret = sigaction (SIGCHLD, &act, 0);
36 if (ret == -1)
37 perror ("sigaction error");
38
39 for (int i=0; i<CLD_NUM; ++ i)
40 {
41 if ((pid = fork ()) < 0)
42 perror ("fork error");
43 else if (pid == 0)
44 {
45 if (i % 2 == 0) {
46 // simulate background
47 sleep (3);
48 }
49 else {
50 // simulate foreground
51 sleep (4);
52 }
53
54 printf ("child %u exit\n", getpid ());
55 _exit (0);
56 }
57
58 sleep (1);
59 }
60
61 int status = 0;
62 while (1) {
63 printf ("before wait pid %u\n", pid);
64 if (waitpid (pid, &status, 0) < 0)
65 {
66 int err = errno;
67 printf ("wait %u error %d\n", pid, err);
68 if (err == EINTR)
69 continue;
70 }
71 else
72 printf ("wait child pid = %d\n", pid);
73
74 break;
75 }
76
77 sleep (2);
78 printf ("parent exit\n");
79 return 0;
80 }
執行輸出如下：
before wait pid 2585 child 2584 exit pid (wait in signal) = 2584 wait 2585 error 4 before wait pid 2585 child 2585 exit wait(in signal) 2585 error: No child processes wait child pid = 2585 parent exit
結果與使用signal很相似，但是因為在訊號處理器中我們能明確的知道是哪個子程序終結了，使用的是waitpid而不是wait，所以即使還有其它子程序未結束，也不會在訊號處理器的waitpid中卡住。
結論是無論使用signal還是sigaction，同步等待的waitpid總比SIGCHLD訊號處理器中的wait(xxx)具有更高的優先順序。當然，這個前提是在父程序同步waitpid之前，子程序還沒有結束；
如果要等待的子程序先結束了，SIGCHLD當然先被執行，這種情況下，建議先使用sigprocmask遮蔽SIGCHLD訊號，然後在waitpid之前解除遮蔽。雖然不能保證完全解決訊號競爭的問題，
也能極大的緩解此種情況，即使出現了訊號競爭，導致同步等待的waitpid返回ECHILD，我們也能從這些錯誤碼中得知發生的事情，不會出現卡死的情況。
出於好奇，我們看一下改使用SIG_IGN後的執行效果：
before wait pid 2613 child 2612 exit child 2613 exit wait 2613 error 10 parent exit
與使用signal時並無二致，仍然是忽略訊號佔了上風。結論是無論使用signal還是sigaction，當忽略SIGCHLD訊號時，訊號優先於wait被忽略。出於同樣的原因，這種方式我們並不採納。
之前提到，sigaction還有一種高階的忽略SIGCHLD的方式，即指定SA_NOCLDWAIT標誌位，同時給訊號處理器指定SIG_DFL，這種情況下，我們看看輸出會有什麼變化：
before wait pid 2719 child 2718 exit child 2719 exit wait 2719 error 10 parent exit
可以看到，與使用SIG_IGN並無二致。
與SIG_IGN不同的是，我們可以為SIGCHLD提供一個處理器，雖然在此訊號處理器中無需再次等待子程序，但是我們擁有了獲取子程序資訊的能力，相對而言，比SIG_IGN更有用一些。新的輸出如下：
before wait pid 2737 child 2736 exit pid (auto wait in signal) = 2736 wait 2737 error 4 before wait pid 2737 child 2737 exit pid (auto wait in signal) = 2737 wait 2737 error 10 parent exit
可以看到，同步waitpid仍然返回ECHILD，顯然是訊號更具有優先順序。
好了，到這裡就全明瞭了，對於混合使用同步與非同步wait的應用來說，最佳的方法應該是同步waitpid等待前臺程序，非同步使用sigaction註冊SIGCHLD訊號處理器等待後臺程序，且不設定SA_NOCLDWAIT標誌位。
在處理器中也應使用waitpid等待子程序，如返回ECHILD錯誤，證明該子程序是前臺程序，已經被同步wait掉了，不需要後續處理；否則作為後臺程序處理。
最後，我們發現同步等待的waitpid沒有被中斷的情況只在忽略訊號的時候產生，而之前也證明了忽略訊號時，系統壓根不產生SIGCHLD訊號，這兩者似乎到現在是對上了…… ：）
場景 1&2 測試程式碼
場景3 測試程式碼
完整的shell