[dart:io] Namespaces for file IO

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.
 
 #include "platform/globals.h"
 #if defined(HOST_OS_FUCHSIA)
 
 #include "bin/process.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <launchpad/launchpad.h>
 #include <launchpad/vmo.h>
 #include <magenta/process.h>
 #include <magenta/status.h>
 #include <magenta/syscalls.h>
 #include <magenta/syscalls/object.h>
 #include <magenta/types.h>
 #include <mxio/io.h>
+#include <mxio/namespace.h>
 #include <mxio/private.h>
 #include <mxio/util.h>
 #include <poll.h>
 #include <pthread.h>
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
 #include "bin/fdutils.h"
+#include "bin/file.h"
 #include "bin/lockers.h"
 #include "bin/log.h"
+#include "bin/namespace.h"
 #include "platform/signal_blocker.h"
 #include "platform/utils.h"
 
 // #define PROCESS_LOGGING 1
 #if defined(PROCESS_LOGGING)
 #define LOG_ERR(msg, ...) Log::PrintErr("Dart Process: " msg, ##__VA_ARGS__)
 #define LOG_INFO(msg, ...) Log::Print("Dart Process: " msg, ##__VA_ARGS__)
 #else
 #define LOG_ERR(msg, ...)
 #define LOG_INFO(msg, ...)
@@ skipping 457 matching lines @@
     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,
+  ProcessStarter(Namespace* namespc,
+                 const char* path,
                  char* arguments[],
                  intptr_t arguments_length,
                  const char* working_directory,
                  char* environment[],
                  intptr_t environment_length,
                  ProcessStartMode mode,
                  intptr_t* in,
                  intptr_t* out,
                  intptr_t* err,
                  intptr_t* id,
                  intptr_t* exit_event,
                  char** os_error_message)
-      : path_(path),
+      : namespc_(namespc),
+        path_(path),
         working_directory_(working_directory),
         mode_(mode),
         in_(in),
         out_(out),
         err_(err),
         id_(id),
         exit_event_(exit_event),
         os_error_message_(os_error_message) {
     LOG_INFO("ProcessStarter: ctor %s with %ld args, mode = %d\n", path,
              arguments_length, mode);
@@ skipping 114 matching lines @@
   }
 
   mx_status_t SetupLaunchpad(launchpad_t** launchpad) {
     // TODO(zra): Use the supplied working directory when launchpad adds an
     // API to set it.
     ASSERT(launchpad != NULL);
     launchpad_t* lp = NULL;
     launchpad_create(MX_HANDLE_INVALID, program_arguments_[0], &lp);
     launchpad_set_args(lp, program_arguments_count_, program_arguments_);
     launchpad_set_environ(lp, program_environment_);
-    launchpad_clone(lp, LP_CLONE_MXIO_NAMESPACE);
-    launchpad_clone(lp, LP_CLONE_MXIO_CWD);
+    launchpad_clone(lp, LP_CLONE_MXIO_NAMESPACE | LP_CLONE_MXIO_CWD);
     launchpad_add_pipe(lp, &write_out_, 0);
     launchpad_add_pipe(lp, &read_in_, 1);
     launchpad_add_pipe(lp, &read_err_, 2);
     launchpad_add_vdso_vmo(lp);
-    launchpad_load_from_file(lp, path_);
+
+    NamespaceScope ns(namespc_, path_);
+    const int pathfd = TEMP_FAILURE_RETRY(openat64(
+        ns.fd(), ns.path(), O_RDONLY));
+    launchpad_load_from_fd(lp, pathfd);
+    VOID_TEMP_FAILURE_RETRY(close(pathfd));
 
     // If there were any errors, grab launchpad's error message and put it in
     // the os_error_message_ field.
     mx_status_t status = launchpad_get_status(lp);
     if (status != MX_OK) {
       const intptr_t kMaxMessageSize = 256;
       char* message = DartUtils::ScopedCString(kMaxMessageSize);
       snprintf(message, kMaxMessageSize, "launchpad failed: %s, %s",
                mx_status_get_string(status), launchpad_error_message(lp));
       *os_error_message_ = message;
       return status;
     }
 
     *launchpad = lp;
     return MX_OK;
   }
 
   int read_in_;    // Pipe for stdout to child process.
   int read_err_;   // Pipe for stderr to child process.
   int write_out_;  // Pipe for stdin to child process.
 
   char** program_arguments_;
   intptr_t program_arguments_count_;
   char** program_environment_;
 
+  Namespace* namespc_;
   const char* path_;
   const char* working_directory_;
   ProcessStartMode mode_;
   intptr_t* in_;
   intptr_t* out_;
   intptr_t* err_;
   intptr_t* id_;
   intptr_t* exit_event_;
   char** os_error_message_;
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ProcessStarter);
 };
 
-int Process::Start(const char* path,
+int Process::Start(Namespace* namespc,
+                   const char* path,
                    char* arguments[],
                    intptr_t arguments_length,
                    const char* working_directory,
                    char* environment[],
                    intptr_t environment_length,
                    ProcessStartMode mode,
                    intptr_t* in,
                    intptr_t* out,
                    intptr_t* err,
                    intptr_t* id,
                    intptr_t* exit_event,
                    char** os_error_message) {
   if (mode != kNormal) {
     *os_error_message = DartUtils::ScopedCopyCString(
         "Only ProcessStartMode.NORMAL is supported on this platform");
     return -1;
   }
-  ProcessStarter starter(path, arguments, arguments_length, working_directory,
-                         environment, environment_length, mode, in, out, err,
-                         id, exit_event, os_error_message);
+  ProcessStarter starter(namespc, path, arguments, arguments_length,
+                         working_directory, environment, environment_length,
+                         mode, in, out, err, id, exit_event, os_error_message);
   return starter.Start();
 }
 
 intptr_t Process::SetSignalHandler(intptr_t signal) {
   errno = ENOSYS;
   return -1;
 }
 
 void Process::ClearSignalHandler(intptr_t signal, Dart_Port port) {}
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(HOST_OS_FUCHSIA)