Avoid creating zombie processes by waiting for the terminated process.

runtime/bin/process_linux.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include "bin/process.h"
+
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/wait.h>
 #include <unistd.h>
 
 #include "bin/fdutils.h"
-#include "bin/process.h"
-
 
 class ProcessInfo {
  public:
   ProcessInfo(pid_t pid, intptr_t fd) : pid_(pid), fd_(fd) { }
 
   pid_t pid() { return pid_; }
   intptr_t fd() { return fd_; }
   ProcessInfo* next() { return next_; }
   void set_next(ProcessInfo* next) { next_ = next; }
 
@@ skipping 61 matching lines @@
   ASSERT(process_signal == SIGCHLD);
   struct sigaction act;
   bzero(&act, sizeof(act));
   act.sa_handler = SIG_IGN;
   act.sa_flags = SA_NOCLDSTOP | SA_SIGINFO;
   if (sigaction(SIGCHLD, &act, 0) != 0) {
     perror("Process start: disabling signal handler failed");
   }
   ProcessInfo* process = LookupProcess(siginfo->si_pid);
   if (process != NULL) {
+    int status = 0;
+    int wait_result = waitpid(siginfo->si_pid, &status, WNOHANG);
+    if (wait_result == -1 || wait_result == 0) {
+      perror("ExitHandler waitpid failed");
+    }
     intptr_t message[2] = { siginfo->si_pid, siginfo->si_status };
     intptr_t result =
         FDUtils::WriteToBlocking(process->fd(), &message, sizeof(message));
     if (result != sizeof(message)) {
       perror("ExitHandler notification failed");
     }
     close(process->fd());
   }
   act.sa_handler = 0;
   act.sa_sigaction = ExitHandler;
@@ skipping 222 matching lines @@
   if (result == -1) {
     return false;
   }
   return true;
 }
 
 
 void Process::Exit(intptr_t id) {
   RemoveProcess(id);
 }