Add support for starting a detached process

runtime/bin/process_win.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_WINDOWS)
 
 #include <process.h>  // NOLINT
 
 #include "bin/builtin.h"
@@ skipping 288 matching lines @@
                               HANDLE handles4[2]) {
   CloseProcessPipe(handles1);
   CloseProcessPipe(handles2);
   CloseProcessPipe(handles3);
   CloseProcessPipe(handles4);
 }
 
 
 static int SetOsErrorMessage(char** os_error_message) {
   int error_code = GetLastError();
-  static const int kMaxMessageLength = 256;
+  const int kMaxMessageLength = 256;
   wchar_t message[kMaxMessageLength];
   FormatMessageIntoBuffer(error_code, message, kMaxMessageLength);
   *os_error_message = StringUtils::WideToUtf8(message);
   return error_code;
 }
 
 
+// Open an inheritable handle to NUL.
+static HANDLE OpenNul() {
+  SECURITY_ATTRIBUTES inherit_handle;
+  inherit_handle.nLength = sizeof(SECURITY_ATTRIBUTES);
+  inherit_handle.bInheritHandle = TRUE;
+  inherit_handle.lpSecurityDescriptor = NULL;
+  HANDLE nul = CreateFile(L"NUL",
+                          GENERIC_READ | GENERIC_WRITE,
+                          0,
+                          &inherit_handle,
+                          OPEN_EXISTING,
+                          0,
+                          NULL);
+  if (nul == INVALID_HANDLE_VALUE) {
+    Log::PrintErr("CloseHandle failed %d\n", GetLastError());
+  }
+  return nul;
+}
+
+
 typedef BOOL (WINAPI *InitProcThreadAttrListFn)(
     LPPROC_THREAD_ATTRIBUTE_LIST, DWORD, DWORD, PSIZE_T);
 
 typedef BOOL (WINAPI *UpdateProcThreadAttrFn)(
     LPPROC_THREAD_ATTRIBUTE_LIST, DWORD, DWORD_PTR,
     PVOID, SIZE_T, PVOID, PSIZE_T);
 
 typedef VOID (WINAPI *DeleteProcThreadAttrListFn)(
      LPPROC_THREAD_ATTRIBUTE_LIST);
 
@@ skipping 51 matching lines @@
   return 0;
 }
 
 
 int Process::Start(const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
+                   bool detach,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_handler,
                    char** os_error_message) {
   HANDLE stdin_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE stdout_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE stderr_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
   HANDLE exit_handles[2] = { INVALID_HANDLE_VALUE, INVALID_HANDLE_VALUE };
 
   // Generate unique pipe names for the four named pipes needed.
   wchar_t pipe_names[4][kMaxPipeNameSize];
   int status = GenerateNames<4>(pipe_names);
   if (status != 0) {
     SetOsErrorMessage(os_error_message);
     Log::PrintErr("UuidCreateSequential failed %d\n", status);
     return status;
   }
 
-  if (!CreateProcessPipe(stdin_handles, pipe_names[0], kInheritRead)) {
-    int error_code = SetOsErrorMessage(os_error_message);
-    CloseProcessPipes(
-        stdin_handles, stdout_handles, stderr_handles, exit_handles);
-    return error_code;
-  }
-  if (!CreateProcessPipe(stdout_handles, pipe_names[1], kInheritWrite)) {
-    int error_code = SetOsErrorMessage(os_error_message);
-    CloseProcessPipes(
-        stdin_handles, stdout_handles, stderr_handles, exit_handles);
-    return error_code;
-  }
-  if (!CreateProcessPipe(stderr_handles, pipe_names[2], kInheritWrite)) {
-    int error_code = SetOsErrorMessage(os_error_message);
-    CloseProcessPipes(
-        stdin_handles, stdout_handles, stderr_handles, exit_handles);
-    return error_code;
-  }
-  if (!CreateProcessPipe(exit_handles, pipe_names[3], kInheritNone)) {
-    int error_code = SetOsErrorMessage(os_error_message);
-    CloseProcessPipes(
-        stdin_handles, stdout_handles, stderr_handles, exit_handles);
-    return error_code;
+  if (!detach) {
+    // Open pipes for stdin, stdout, stderr and for communicating the exit
+    // code.
+    if (!CreateProcessPipe(stdin_handles, pipe_names[0], kInheritRead)) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
+    if (!CreateProcessPipe(stdout_handles, pipe_names[1], kInheritWrite)) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
+    if (!CreateProcessPipe(stderr_handles, pipe_names[2], kInheritWrite)) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
+    if (!CreateProcessPipe(exit_handles, pipe_names[3], kInheritNone)) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
+  } else {
+    // Open NUL for stdin, stdout and stderr.
+    stdin_handles[kReadHandle] = OpenNul();
+    if (stdin_handles[kReadHandle] == INVALID_HANDLE_VALUE) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
+    stdout_handles[kWriteHandle] = OpenNul();
+    if (stdout_handles[kWriteHandle] == INVALID_HANDLE_VALUE) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
+    stderr_handles[kWriteHandle] = OpenNul();
+    if (stderr_handles[kWriteHandle] == INVALID_HANDLE_VALUE) {
+      int error_code = SetOsErrorMessage(os_error_message);
+      CloseProcessPipes(
+          stdin_handles, stdout_handles, stderr_handles, exit_handles);
+      return error_code;
+    }
   }
 
   // Setup info structures.
   STARTUPINFOEXW startup_info;
   ZeroMemory(&startup_info, sizeof(startup_info));
   startup_info.StartupInfo.cb = sizeof(startup_info);
   startup_info.StartupInfo.hStdInput = stdin_handles[kReadHandle];
   startup_info.StartupInfo.hStdOutput = stdout_handles[kWriteHandle];
   startup_info.StartupInfo.hStdError = stderr_handles[kWriteHandle];
   startup_info.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
@@ skipping 134 matching lines @@
   }
 
   const wchar_t* system_working_directory = NULL;
   if (working_directory != NULL) {
     system_working_directory = StringUtils::Utf8ToWide(working_directory);
   }
 
   // Create process.
   DWORD creation_flags =
       EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT;
+  if (detach) {
+    creation_flags |= DETACHED_PROCESS;
+  }
   BOOL result = CreateProcessW(NULL,   // ApplicationName
                                command_line,
                                NULL,   // ProcessAttributes
                                NULL,   // ThreadAttributes
                                TRUE,   // InheritHandles
                                creation_flags,
                                environment_block,
                                system_working_directory,
                                reinterpret_cast<STARTUPINFOW*>(&startup_info),
                                &process_info);
-
   // Deallocate command-line and environment block strings.
   delete[] command_line;
   delete[] environment_block;
   if (system_working_directory != NULL) {
     free(const_cast<wchar_t*>(system_working_directory));
   }
 
   if (supports_proc_thread_attr_lists) {
     delete_proc_thread_attr_list(attribute_list);
     free(attribute_list);
   }
 
   if (result == 0) {
     int error_code = SetOsErrorMessage(os_error_message);
     CloseProcessPipes(
         stdin_handles, stdout_handles, stderr_handles, exit_handles);
     return error_code;
   }
 
-  ProcessInfoList::AddProcess(process_info.dwProcessId,
-                              process_info.hProcess,
-                              exit_handles[kWriteHandle]);
+  CloseHandle(stdin_handles[kReadHandle]);
+  CloseHandle(stdout_handles[kWriteHandle]);
+  CloseHandle(stderr_handles[kWriteHandle]);
+  if (!detach) {
+    ProcessInfoList::AddProcess(process_info.dwProcessId,
+                                process_info.hProcess,
+                                exit_handles[kWriteHandle]);
 
-  // Connect the three std streams.
-  FileHandle* stdin_handle = new FileHandle(stdin_handles[kWriteHandle]);
-  CloseHandle(stdin_handles[kReadHandle]);
-  FileHandle* stdout_handle = new FileHandle(stdout_handles[kReadHandle]);
-  CloseHandle(stdout_handles[kWriteHandle]);
-  FileHandle* stderr_handle = new FileHandle(stderr_handles[kReadHandle]);
-  CloseHandle(stderr_handles[kWriteHandle]);
-  FileHandle* exit_handle = new FileHandle(exit_handles[kReadHandle]);
-  *in = reinterpret_cast<intptr_t>(stdout_handle);
-  *out = reinterpret_cast<intptr_t>(stdin_handle);
-  *err = reinterpret_cast<intptr_t>(stderr_handle);
-  *exit_handler = reinterpret_cast<intptr_t>(exit_handle);
+    // Connect the three std streams.
+    FileHandle* stdin_handle = new FileHandle(stdin_handles[kWriteHandle]);
+    FileHandle* stdout_handle = new FileHandle(stdout_handles[kReadHandle]);
+    FileHandle* stderr_handle = new FileHandle(stderr_handles[kReadHandle]);
+    FileHandle* exit_handle = new FileHandle(exit_handles[kReadHandle]);
+    *in = reinterpret_cast<intptr_t>(stdout_handle);
+    *out = reinterpret_cast<intptr_t>(stdin_handle);
+    *err = reinterpret_cast<intptr_t>(stderr_handle);
+    *exit_handler = reinterpret_cast<intptr_t>(exit_handle);
+  }
 
   CloseHandle(process_info.hThread);
 
   // Return process id.
   *id = process_info.dwProcessId;
   return 0;
 }
 
 
 class BufferList: public BufferListBase {
@@ skipping 185 matching lines @@
   oh[2].FreeDataBuffer();
   intptr_t exit_code = exit[0];
   intptr_t negative = exit[1];
   if (negative) exit_code = -exit_code;
   result->set_exit_code(exit_code);
   return true;
 }
 
 
 bool Process::Kill(intptr_t id, int signal) {
-  USE(signal);  // signal is not used on windows.
+  USE(signal);  // signal is not used on Windows.
   HANDLE process_handle;
   HANDLE wait_handle;
   HANDLE exit_pipe;
+  // First check the process info list for the process to get a handle to it.
   bool success = ProcessInfoList::LookupProcess(id,
                                                 &process_handle,
                                                 &wait_handle,
                                                 &exit_pipe);
-  // The process is already dead.
-  if (!success) return false;
+  // For detached processes we don't have the process registered in the
+  // process info list. Try to look it up through the OS.
+  if (!success) {
+    process_handle = OpenProcess(PROCESS_TERMINATE, FALSE, id);
+    // The process is already dead.
+    if (process_handle == INVALID_HANDLE_VALUE) return false;
+  }
   BOOL result = TerminateProcess(process_handle, -1);
   return result ? true : false;
 }
 
 
 void Process::TerminateExitCodeHandler() {
   // Nothing needs to be done on Windows.
 }
 
 
@@ skipping 92 matching lines @@
       USE(SetConsoleCtrlHandler(SignalHandler, false));
     }
   }
   delete handler;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_WINDOWS)