Add an option for starting a detached process with stdio connected

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 "platform/globals.h"
 #if defined(TARGET_OS_LINUX)
 
 #include "bin/process.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 219 matching lines @@
 
 
 class ProcessStarter {
  public:
   ProcessStarter(const char* path,
                  char* arguments[],
                  intptr_t arguments_length,
                  const char* working_directory,
                  char* environment[],
                  intptr_t environment_length,
-                 bool detach,
+                 ProcessStartMode mode,
                  intptr_t* in,
                  intptr_t* out,
                  intptr_t* err,
                  intptr_t* id,
                  intptr_t* exit_event,
                  char** os_error_message)
       : path_(path),
         working_directory_(working_directory),
-        detach_(detach),
+        mode_(mode),
         in_(in),
         out_(out),
         err_(err),
         id_(id),
         exit_event_(exit_event),
         os_error_message_(os_error_message) {
     read_in_[0] = -1;
     read_in_[1] = -1;
     read_err_[0] = -1;
     read_err_[1] = -1;
@@ skipping 40 matching lines @@
       // This runs in the new process.
       NewProcess();
     }
 
     // This runs in the original process.
 
     // Be sure to listen for exit-codes, now we have a child-process.
     ExitCodeHandler::ProcessStarted();
 
     // Register the child process if not detached.
-    if (!detach_) {
+    if (mode_ == kNormal) {
       err = RegisterProcess(pid);
       if (err != 0) return err;
     }
 
     // Notify child process to start. This is done to delay the call to exec
     // until the process is registered above, and we are ready to receive the
     // exit code.
     char msg = '1';
     int bytes_written =
         FDUtils::WriteToBlocking(read_in_[1], &msg, sizeof(msg));
     if (bytes_written != sizeof(msg)) {
       return CleanupAndReturnError();
     }
 
     // Read the result of executing the child process.
     VOID_TEMP_FAILURE_RETRY(close(exec_control_[1]));
     exec_control_[1] = -1;
-    if (!detach_) {
+    if (mode_ == kNormal) {
       err = ReadExecResult();
     } else {
       err = ReadDetachedExecResult(&pid);
     }
     VOID_TEMP_FAILURE_RETRY(close(exec_control_[0]));
     exec_control_[0] = -1;
 
     // Return error code if any failures.
     if (err != 0) {
-      if (!detach_) {
+      if (mode_ == kNormal) {
         // Since exec() failed, we're not interested in the exit code.
         // We close the reading side of the exit code pipe here.
         // GetProcessExitCodes will get a broken pipe error when it
         // tries to write to the writing side of the pipe and it will
         // ignore the error.
         VOID_TEMP_FAILURE_RETRY(close(*exit_event_));
         *exit_event_ = -1;
       }
       CloseAllPipes();
       return err;
     }
 
-    if (!detach_) {
+    if (mode_ != kDetached) {
       // Connect stdio, stdout and stderr.
       FDUtils::SetNonBlocking(read_in_[0]);
       *in_ = read_in_[0];
       VOID_TEMP_FAILURE_RETRY(close(read_in_[1]));
       FDUtils::SetNonBlocking(write_out_[1]);
       *out_ = write_out_[1];
       VOID_TEMP_FAILURE_RETRY(close(write_out_[0]));
       FDUtils::SetNonBlocking(read_err_[0]);
       *err_ = read_err_[0];
       VOID_TEMP_FAILURE_RETRY(close(read_err_[1]));
@@ skipping 25 matching lines @@
 
     // For a detached process the pipe to connect stdout is still used for
     // signaling when to do the first fork.
     result = TEMP_FAILURE_RETRY(pipe(read_in_));
     if (result < 0) {
       return CleanupAndReturnError();
     }
     FDUtils::SetCloseOnExec(read_in_[0]);
 
     // For detached processes the pipe to connect stderr and stdin are not used.
-    if (!detach_) {
+    if (mode_ != kDetached) {
       result = TEMP_FAILURE_RETRY(pipe(read_err_));
       if (result < 0) {
         return CleanupAndReturnError();
       }
       FDUtils::SetCloseOnExec(read_err_[0]);
 
       result = TEMP_FAILURE_RETRY(pipe(write_out_));
       if (result < 0) {
         return CleanupAndReturnError();
       }
       FDUtils::SetCloseOnExec(write_out_[1]);
     }
 
     return 0;
   }
 
 
   void NewProcess() {
     // Wait for parent process before setting up the child process.
     char msg;
     int bytes_read = FDUtils::ReadFromBlocking(read_in_[0], &msg, sizeof(msg));
     if (bytes_read != sizeof(msg)) {
       perror("Failed receiving notification message");
       exit(1);
     }
-    if (detach_) {
+    if (mode_ == kNormal) {
+      ExecProcess();
+    } else {
       ExecDetachedProcess();
-    } else {
-      ExecProcess();
     }
   }
 
 
   void ExecProcess() {
     VOID_TEMP_FAILURE_RETRY(close(write_out_[1]));
     VOID_TEMP_FAILURE_RETRY(close(read_in_[0]));
     VOID_TEMP_FAILURE_RETRY(close(read_err_[0]));
     VOID_TEMP_FAILURE_RETRY(close(exec_control_[0]));
 
@@ skipping 22 matching lines @@
     }
 
     VOID_TEMP_FAILURE_RETRY(
         execvp(path_, const_cast<char* const*>(program_arguments_)));
 
     ReportChildError();
   }
 
 
   void ExecDetachedProcess() {
-    ASSERT(write_out_[0] == -1);
-    ASSERT(write_out_[1] == -1);
-    ASSERT(read_err_[0] == -1);
-    ASSERT(read_err_[1] == -1);
-    // For a detached process the pipe to connect stdout is only used for
-    // signaling when to do the first fork.
-    VOID_TEMP_FAILURE_RETRY(close(read_in_[0]));
-    VOID_TEMP_FAILURE_RETRY(close(read_in_[1]));
+    if (mode_ == kDetached) {
+      ASSERT(write_out_[0] == -1);
+      ASSERT(write_out_[1] == -1);
+      ASSERT(read_err_[0] == -1);
+      ASSERT(read_err_[1] == -1);
+      // For a detached process the pipe to connect stdout is only used for
+      // signaling when to do the first fork.
+      VOID_TEMP_FAILURE_RETRY(close(read_in_[0]));
+      read_in_[0] = -1;
+      VOID_TEMP_FAILURE_RETRY(close(read_in_[1]));
+      read_in_[1] = -1;
+    } else {
+      // Don't close any fds if keeping stdio open to the detached process.
+      ASSERT(mode_ == kDetachedWithStdio);
+    }
     // Fork once more to start a new session.
     pid_t pid = TEMP_FAILURE_RETRY(fork());
     if (pid < 0) {
       ReportChildError();
     } else if (pid == 0) {
       // Start a new session.
       if (TEMP_FAILURE_RETRY(setsid()) == -1) {
         ReportChildError();
       } else {
         // Do a final fork to not be the session leader.
         pid = TEMP_FAILURE_RETRY(fork());
         if (pid < 0) {
           ReportChildError();
         } else if (pid == 0) {
-          // Close all open file descriptors except for exec_control_[1].
-          int max_fds = sysconf(_SC_OPEN_MAX);
-          if (max_fds == -1) max_fds = _POSIX_OPEN_MAX;
-          for (int fd = 0; fd < max_fds; fd++) {
-            if (fd != exec_control_[1]) {
-              VOID_TEMP_FAILURE_RETRY(close(fd));
-            }
+          if (mode_ == kDetached) {
+            SetupDetached();
+          } else {
+            SetupDetachedWithStdio();
           }
 
-          // Re-open stdin, stdout and stderr and connect them to /dev/null.
-          // The loop above should already have closed all of them, so
-          // creating new file descriptors should start at STDIN_FILENO.
-          int fd = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
-          if (fd != STDIN_FILENO) {
-            ReportChildError();
-          }
-          if (TEMP_FAILURE_RETRY(dup2(STDIN_FILENO, STDOUT_FILENO)) !=
-              STDOUT_FILENO) {
-            ReportChildError();
-          }
-          if (TEMP_FAILURE_RETRY(dup2(STDIN_FILENO, STDERR_FILENO)) !=
-              STDERR_FILENO) {
+          if (working_directory_ != NULL &&
+              TEMP_FAILURE_RETRY(chdir(working_directory_)) == -1) {
             ReportChildError();
           }
 
           // Report the final PID and do the exec.
           ReportPid(getpid());  // getpid cannot fail.
           VOID_TEMP_FAILURE_RETRY(
               execvp(path_, const_cast<char* const*>(program_arguments_)));
           ReportChildError();
         } else {
           // Exit the intermeiate process.
@@ skipping 60 matching lines @@
       child_errno = result[1];
       ReadChildError();
       return child_errno;
     } else if (bytes_read == -1) {
       return errno;
     }
     return 0;
   }
 
 
+  void SetupDetached() {
+    ASSERT(mode_ == kDetached);
+
+    // Close all open file descriptors except for exec_control_[1].
+    int max_fds = sysconf(_SC_OPEN_MAX);
+    if (max_fds == -1) max_fds = _POSIX_OPEN_MAX;
+    for (int fd = 0; fd < max_fds; fd++) {
+      if (fd != exec_control_[1]) {
+        VOID_TEMP_FAILURE_RETRY(close(fd));
+      }
+    }
+
+    // Re-open stdin, stdout and stderr and connect them to /dev/null.
+    // The loop above should already have closed all of them, so
+    // creating new file descriptors should start at STDIN_FILENO.
+    int fd = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
+    if (fd != STDIN_FILENO) {
+      ReportChildError();
+    }
+    if (TEMP_FAILURE_RETRY(dup2(STDIN_FILENO, STDOUT_FILENO)) !=
+        STDOUT_FILENO) {
+      ReportChildError();
+    }
+    if (TEMP_FAILURE_RETRY(dup2(STDIN_FILENO, STDERR_FILENO)) !=
+        STDERR_FILENO) {
+      ReportChildError();
+    }
+  }
+
+  void SetupDetachedWithStdio() {
+    // Close all open file descriptors except for
+    // exec_control_[1], write_out_[0], read_in_[1] and
+    // read_err_[1].
+    int max_fds = sysconf(_SC_OPEN_MAX);
+    if (max_fds == -1) max_fds = _POSIX_OPEN_MAX;
+    for (int fd = 0; fd < max_fds; fd++) {
+      if (fd != exec_control_[1] &&
+          fd != write_out_[0] &&
+          fd != read_in_[1] &&
+          fd != read_err_[1]) {
+        VOID_TEMP_FAILURE_RETRY(close(fd));
+      }
+    }
+
+    if (TEMP_FAILURE_RETRY(dup2(write_out_[0], STDIN_FILENO)) == -1) {
+      ReportChildError();
+    }
+    VOID_TEMP_FAILURE_RETRY(close(write_out_[0]));
+
+    if (TEMP_FAILURE_RETRY(dup2(read_in_[1], STDOUT_FILENO)) == -1) {
+      ReportChildError();
+    }
+    VOID_TEMP_FAILURE_RETRY(close(read_in_[1]));
+
+    if (TEMP_FAILURE_RETRY(dup2(read_err_[1], STDERR_FILENO)) == -1) {
+      ReportChildError();
+    }
+    VOID_TEMP_FAILURE_RETRY(close(read_err_[1]));
+  }
+
+
   int CleanupAndReturnError() {
     int actual_errno = errno;
     // If CleanupAndReturnError is called without an actual errno make
     // sure to return an error anyway.
     if (actual_errno == 0) actual_errno = EPERM;
     SetChildOsErrorMessage();
     CloseAllPipes();
     return actual_errno;
   }
 
@@ skipping 69 matching lines @@
   int read_in_[2];  // Pipe for stdout to child process.
   int read_err_[2];  // Pipe for stderr to child process.
   int write_out_[2];  // Pipe for stdin to child process.
   int exec_control_[2];  // Pipe to get the result from exec.
 
   char** program_arguments_;
   char** program_environment_;
 
   const char* path_;
   const char* working_directory_;
-  bool detach_;
+  ProcessStartMode mode_;
   intptr_t* in_;
   intptr_t* out_;
   intptr_t* err_;
   intptr_t* id_;
   intptr_t* exit_event_;
   char** os_error_message_;
 };
 
 
 int Process::Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
-                   bool detach,
+                   ProcessStartMode mode,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_event,
                    char** os_error_message) {
   ProcessStarter starter(path,
                          arguments,
                          arguments_length,
                          working_directory,
                          environment,
                          environment_length,
-                         detach,
+                         mode,
                          in,
                          out,
                          err,
                          id,
                          exit_event,
                          os_error_message);
   return starter.Start();
 }
 
 
@@ skipping 232 matching lines @@
     bzero(&act, sizeof(act));
     act.sa_handler = SIG_DFL;
     sigaction(signal, &act, NULL);
   }
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_LINUX)