Changes to the process implementation.

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>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "bin/fdutils.h"
 #include "bin/thread.h"
 
 
 // ProcessInfo is used to map a process id to the file descriptor for
 // the pipe used to communicate the exit code of the process to Dart.
 // ProcessInfo objects are kept in the static singly-linked
 // ProcessInfoList.
 class ProcessInfo {
  public:
   ProcessInfo(pid_t pid, intptr_t fd) : pid_(pid), fd_(fd) { }
+  ~ProcessInfo() {
+    int closed = TEMP_FAILURE_RETRY(close(fd_));
+    if (closed != 0) {
+      FATAL("Failed to close process exit code pipe");
+    }
+  }
   pid_t pid() { return pid_; }
   intptr_t fd() { return fd_; }
   ProcessInfo* next() { return next_; }
   void set_next(ProcessInfo* info) { next_ = info; }
 
  private:
   pid_t pid_;
   intptr_t fd_;
   ProcessInfo* next_;
 };
@@ skipping 56 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 char kTerminateByte = 1;

[Søren Gjesse, 2012/02/01 07:39:17]

uint8_t?

[Mads Ager (google), 2012/02/01 09:08:57]

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 Terminate() {
+    MutexLocker locker(&mutex_);
+    if (!initialized_) {
+      return;
+    }
+    char data = ExitCodeHandler::kTerminateByte;
+    ssize_t result = TEMP_FAILURE_RETRY(write(WakeUpFd(), &data, 1));
+    if (result < 1) {
+      perror("Failed to write to wake-up fd in SIGCHLD handler");
+    }
+  }
+
  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;
       if (WIFEXITED(status)) {
         exit_code = WEXITSTATUS(status);
       }
       if (WIFSIGNALED(status)) {
         exit_code = WTERMSIG(status);
         negative = 1;
       }
       intptr_t exit_code_fd = ProcessInfoList::LookupProcessExitFd(pid);
       if (exit_code_fd != 0) {
-        int message[3] = { pid, exit_code, negative };
+        int message[2] = { exit_code, negative };
         ssize_t result =
             FDUtils::WriteToBlocking(exit_code_fd, &message, sizeof(message));
         if (result != sizeof(message) && errno != EPIPE) {
           perror("ExitHandler notification failed");
         }
-        TEMP_FAILURE_RETRY(close(exit_code_fd));
+        ProcessInfoList::RemoveProcess(pid);
       }
     }
   }
 
 
   // Entry point for the separate exit code handler thread started by
   // the ExitCodeHandler.
   static void ExitCodeHandlerEntry(uword param) {
     struct pollfd pollfds;
     pollfds.fd = param;
     pollfds.events |= POLLIN;
     while (true) {
       int result = TEMP_FAILURE_RETRY(poll(&pollfds, 1, -1));
       if (result == -1) {
         ASSERT(EAGAIN == EWOULDBLOCK);
         if (errno != EWOULDBLOCK) {
           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");
         }
+        // Check if the ExitCodeHandler has been terminated.
+        if (data == ExitCodeHandler::kTerminateByte) {
+          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];
 };
@@ skipping 280 matching lines @@
 
 bool Process::Kill(intptr_t id) {
   int result = TEMP_FAILURE_RETRY(kill(id, SIGKILL));
   if (result == -1) {
     return false;
   }
   return true;
 }
 
 
-void Process::Exit(intptr_t id) {
-  ProcessInfoList::RemoveProcess(id);
+void Process::TerminateExitCodeHandler() {
+  ExitCodeHandler::Terminate();
 }