Rework Windows process handling.

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 142 matching lines @@
       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");
+        // If the process has been closed, the read end of the exit
+        // pipe has been closed. It is therefore not a problem that
+        // WriteFile fails with a broken pipe error. Other errors

[Søren Gjesse, 2012/02/02 12:26:07]

WriteFile -> WriteToBlocking (or just write)

[Mads Ager (google), 2012/02/02 13:47:45]

Done.

+        // should not happen.
+        if (result != -1 && result != sizeof(message)) {
+          FATAL("Failed to write entire process exit message");
+        } else if (result == -1 && errno != EPIPE) {
+          FATAL1("Failed to write exit code: %d", errno);
         }
-        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;
@@ skipping 314 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::TerminateExitCodeThread();
 }