Prototype implementation of zygotes

base/process_util_linux.cc

 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/process_util.h"
 
 #include <ctype.h>
 #include <dirent.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_tokenizer.h"
 #include "base/string_util.h"
+#include "base/zygote_manager.h"
 
 namespace {
 
 enum ParsingState {
   KEY_NAME,
   KEY_VALUE
 };
 
 // Reads /proc/<pid>/stat and populates |proc_stats| with the values split by
 // spaces.
 void GetProcStats(pid_t pid, std::vector<std::string>* proc_stats) {
   FilePath stat_file("/proc");
   stat_file = stat_file.Append(IntToString(pid));
   stat_file = stat_file.Append("stat");
   std::string mem_stats;
   if (!file_util::ReadFileToString(stat_file, &mem_stats))
     return;
   SplitString(mem_stats, ' ', proc_stats);
 }
 
 }  // namespace
 
 namespace base {
 
+bool ForkApp(const std::vector<std::string>& argv,
+             const file_handle_mapping_vector& fds_to_remap,
+             ProcessHandle* process_handle) {
+  ZygoteManager* zm = ZygoteManager::Get();
+  if (!zm)
+    return LaunchApp(argv, fds_to_remap, false, process_handle);
+
+  pid_t pid = zm->LongFork(argv, fds_to_remap);
+  if (pid < 0)
+    return false;
+
+  if (process_handle)
+    *process_handle = pid;
+  return true;
+}
+
 bool LaunchApp(const std::vector<std::string>& argv,
                const file_handle_mapping_vector& fds_to_remap,
                bool wait, ProcessHandle* process_handle) {
   pid_t pid = fork();
   if (pid < 0)
     return false;
 
   if (pid == 0) {
     InjectiveMultimap fd_shuffle;
     for (file_handle_mapping_vector::const_iterator
         it = fds_to_remap.begin(); it != fds_to_remap.end(); ++it) {
       fd_shuffle.push_back(InjectionArc(it->first, it->second, false));
     }
 
     if (!ShuffleFileDescriptors(fd_shuffle))
       exit(127);
 
     CloseSuperfluousFds(fd_shuffle);
 
     scoped_array<char*> argv_cstr(new char*[argv.size() + 1]);
     for (size_t i = 0; i < argv.size(); i++)
       argv_cstr[i] = const_cast<char*>(argv[i].c_str());
     argv_cstr[argv.size()] = NULL;
     execvp(argv_cstr[0], argv_cstr.get());
+    LOG(ERROR) << "LaunchApp: exec failed!, argv_cstr[0] " << argv_cstr[0]
+        << ", errno " << errno;
     exit(127);
   } else {
     if (wait)
       HANDLE_EINTR(waitpid(pid, 0, 0));
 
     if (process_handle)
       *process_handle = pid;
   }
 
   return true;
@@ skipping 197 matching lines @@
           (*io_counters).WriteTransferCount = StringToInt64(tokenizer.token());
         }
         state = KEY_NAME;
         break;
     }
   }
   return true;
 }
 
 }  // namespace base