Fuchsia: Adds support for Process.kill()

runtime/bin/process_fuchsia.cc

 // Copyright (c) 2016, 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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_FUCHSIA)
 
 #include "bin/process.h"
@@ skipping 43 matching lines @@
 // ProcessInfoList.
 class ProcessInfo {
  public:
   ProcessInfo(mx_handle_t process, intptr_t fd)
       : process_(process), exit_pipe_fd_(fd) {}
   ~ProcessInfo() {
     int closed = NO_RETRY_EXPECTED(close(exit_pipe_fd_));
     if (closed != 0) {
       FATAL("Failed to close process exit code pipe");
     }
+    mx_handle_close(process_);
   }
   mx_handle_t process() const { return process_; }
   intptr_t exit_pipe_fd() const { return exit_pipe_fd_; }
   ProcessInfo* next() const { return next_; }
   void set_next(ProcessInfo* info) { next_ = info; }
 
  private:
   mx_handle_t process_;
   intptr_t exit_pipe_fd_;
   ProcessInfo* next_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessInfo);
 };
 
 
 // Singly-linked list of ProcessInfo objects for all active processes
 // started from Dart.
 class ProcessInfoList {
  public:
   static void AddProcess(mx_handle_t process, intptr_t fd) {
     MutexLocker locker(mutex_);
     ProcessInfo* info = new ProcessInfo(process, fd);
     info->set_next(active_processes_);
     active_processes_ = info;
   }
 
-
   static intptr_t LookupProcessExitFd(mx_handle_t process) {
     MutexLocker locker(mutex_);
     ProcessInfo* current = active_processes_;
     while (current != NULL) {
       if (current->process() == process) {
         return current->exit_pipe_fd();
       }
       current = current->next();
     }
     return 0;
   }
 
+  static bool Exists(mx_handle_t process) {
+    return LookupProcessExitFd(process) != 0;
+  }
 
   static void RemoveProcess(mx_handle_t process) {
     MutexLocker locker(mutex_);
     ProcessInfo* prev = NULL;
     ProcessInfo* current = active_processes_;
     while (current != NULL) {
       if (current->process() == process) {
         if (prev == NULL) {
           active_processes_ = current->next();
         } else {
@@ skipping 185 matching lines @@
              mx_status_get_string(status));
     }
     LOG_INFO("ExitCodeHandler thread process %ld exited with %d\n", process,
              return_code);
 
     const intptr_t exit_code_fd = ProcessInfoList::LookupProcessExitFd(process);
     LOG_INFO("ExitCodeHandler thread sending %ld code %d on fd %ld\n", process,
              return_code, exit_code_fd);
     if (exit_code_fd != 0) {
       int exit_message[2];
-      exit_message[0] = return_code;
-      exit_message[1] = 0;  // Do not negate return_code.
+      exit_message[0] = abs(return_code);
+      exit_message[1] = return_code >= 0 ? 0 : 1;
       intptr_t result = FDUtils::WriteToBlocking(exit_code_fd, &exit_message,
                                                  sizeof(exit_message));
       ASSERT((result == -1) || (result == sizeof(exit_code_fd)));
       if ((result == -1) && (errno != EPIPE)) {
         int err = errno;
         FATAL1("Failed to write exit code to pipe: %d\n", err);
       }
       LOG_INFO("ExitCodeHandler thread wrote %ld bytes to fd %ld\n", result,
                exit_code_fd);
       LOG_INFO("ExitCodeHandler thread removing process %ld from list\n",
@@ skipping 224 matching lines @@
   DEBUG_ASSERT(err_data.IsEmpty());
 
   // Calculate the exit code.
   intptr_t exit_code = exit_code_data.ints[0];
   intptr_t negative = exit_code_data.ints[1];
   if (negative != 0) {
     exit_code = -exit_code;
   }
   result->set_exit_code(exit_code);
 
+  // Close the process handle.
+  mx_handle_t process = static_cast<mx_handle_t>(pid);
+  mx_handle_close(process);
   return true;
 }
 
 
 bool Process::Kill(intptr_t id, int signal) {
-  errno = ENOSYS;
-  return false;
+  LOG_INFO("Sending signal %d to process with id %ld\n", signal, id);
+  // mx_task_kill is definitely going to kill the process.
+  if ((signal != SIGTERM) && (signal != SIGKILL)) {
+    LOG_ERR("Signal %d not supported\n", signal);
+    errno = ENOSYS;
+    return false;
+  }
+  // We can only use mx_task_kill if we know id is a process handle, and we only
+  // know that for sure if it's in our list.
+  mx_handle_t process = static_cast<mx_handle_t>(id);
+  if (!ProcessInfoList::Exists(process)) {
+    LOG_ERR("Process %ld wasn't in the ProcessInfoList\n", id);
+    errno = ESRCH;  // No such process.
+    return false;
+  }
+  mx_status_t status = mx_task_kill(process);
+  if (status != NO_ERROR) {
+    LOG_ERR("mx_task_kill failed: %s\n", mx_status_get_string(status));
+    errno = EPERM;  // TODO(zra): Figure out what it really should be.
+    return false;
+  }
+  LOG_INFO("Signal %d sent successfully to process %ld\n", signal, id);
+  return true;
 }
 
 
 class ProcessStarter {
  public:
   ProcessStarter(const char* path,
                  char* arguments[],
                  intptr_t arguments_length,
                  const char* working_directory,
                  char* environment[],
@@ skipping 241 matching lines @@
 void Process::ClearSignalHandler(intptr_t signal) {
   UNIMPLEMENTED();
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_FUCHSIA)
 
 #endif  // !defined(DART_IO_DISABLED)