Wait for exit-code thread to terminate before terminating main.

runtime/bin/process_linux.cc

 // Copyright (c) 2012, 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 <poll.h>
 #include <signal.h>
@@ skipping 83 matching lines @@
 ProcessInfo* ProcessInfoList::active_processes_ = NULL;
 dart::Mutex ProcessInfoList::mutex_;
 
 
 // The exit code handler sets up a separate thread which is signalled
 // on SIGCHLD. That separate thread can then get the exit code from
 // processes that have exited and communicate it to Dart through the
 // event loop.
 class ExitCodeHandler {
  public:
+  static const uint8_t kThreadTerminateByte = 1;

[Ivan Posva, 2012/02/01 18:09:24]

Why public? This is only used from within ExitCodeHandler.

[Mads Ager (google), 2012/02/01 18:15:18]

Good point. Done.

+
   // Ensure that the ExitCodeHandler has been initialized.
   static bool EnsureInitialized() {
     // Multiple isolates could be starting processes at the same
     // time. Make sure that only one of them initializes the
     // ExitCodeHandler.
     MutexLocker locker(&mutex_);
     if (initialized_) {
       return true;
     }
 
@@ skipping 15 matching lines @@
     initialized_ = true;
     return true;
   }
 
   // Get the write end of the pipe.
   static int WakeUpFd() {
     ASSERT(initialized_);
     return sig_chld_fds_[1];
   }
 
+  static void TerminateExitCodeThread() {
+    MutexLocker locker(&mutex_);
+    if (!initialized_) {
+      return;
+    }
+
+    uint8_t data = kThreadTerminateByte;
+    ssize_t result =
+        TEMP_FAILURE_RETRY(write(ExitCodeHandler::WakeUpFd(), &data, 1));
+    if (result < 1) {
+      perror("Failed to write to wake-up fd to terminate exit code thread");
+    }
+
+    {
+      MonitorLocker terminate_locker(&thread_terminate_monitor_);
+      while (!thread_terminated_) {
+        terminate_locker.Wait();
+      }
+    }
+  }
+
+  static void ExitCodeThreadTerminated() {
+    MonitorLocker locker(&thread_terminate_monitor_);
+    thread_terminated_ = true;
+    locker.Notify();
+  }
+
  private:
   // GetProcessExitCodes is called on a separate thread when a SIGCHLD
   // signal is received to retrieve the exit codes and post them to
   // dart.
   static void GetProcessExitCodes() {
     pid_t pid = 0;
     int status = 0;
     while ((pid = TEMP_FAILURE_RETRY(waitpid(-1, &status, WNOHANG))) > 0) {
       int exit_code = 0;
       int negative = 0;
@@ skipping 32 matching lines @@
           perror("ExitCodeHandler poll failed");
         }
       } else {
         // Read the byte from the wake-up fd.
         ASSERT(result = 1);
         intptr_t data = 0;
         ssize_t read_bytes = FDUtils::ReadFromBlocking(pollfds.fd, &data, 1);
         if (read_bytes < 1) {
           perror("Failed to read from wake-up fd in exit-code handler");
         }
+        if (data == ExitCodeHandler::kThreadTerminateByte) {
+          ExitCodeThreadTerminated();
+          return;
+        }
         // Get the exit code from all processes that have died.
         GetProcessExitCodes();
       }
     }
   }
 
   static dart::Mutex mutex_;
   static bool initialized_;
   static int sig_chld_fds_[2];
+  static bool thread_terminated_;
+  static dart::Monitor thread_terminate_monitor_;
 };
 
 
 dart::Mutex ExitCodeHandler::mutex_;
 bool ExitCodeHandler::initialized_ = false;
 int ExitCodeHandler::sig_chld_fds_[2] = { 0, 0 };
+bool ExitCodeHandler::thread_terminated_ = false;
+dart::Monitor ExitCodeHandler::thread_terminate_monitor_;
 
 
 static char* SafeStrNCpy(char* dest, const char* src, size_t n) {
   strncpy(dest, src, n);
   dest[n - 1] = '\0';
   return dest;
 }
 
 
 static void SetChildOsErrorMessage(char* os_error_message,
@@ skipping 268 matching lines @@
   if (result == -1) {
     return false;
   }
   return true;
 }
 
 
 void Process::Exit(intptr_t id) {
   ProcessInfoList::RemoveProcess(id);
 }
+
+
+void Process::TerminateExitCodeHandler() {
+  ExitCodeHandler::TerminateExitCodeThread();
+}