Switch to using vfork() instead of fork() when we can.

base/process_util_posix.cc

 // Copyright (c) 2006-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 <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <sys/resource.h>
@@ skipping 206 matching lines @@
     if ((flags == -1) || (fcntl(i, F_SETFD, flags | FD_CLOEXEC) == -1)) {
       DLOG(ERROR) << "fcntl failure.";
     }
   }
 }
 
 bool LaunchApp(const std::vector<std::string>& argv,
                const environment_vector& environ,
                const file_handle_mapping_vector& fds_to_remap,
                bool wait, ProcessHandle* process_handle) {
-  pid_t pid = fork();
+  // We call vfork() for additional performance (avoids touching the page
+  // tables).  This makes things a bit more dangerous since the child and
+  // parent share the same address space and stack.  Try to do most of our
+  // operations before the fork, and hope that everything we do have to do
+  // will be ok...
+  bool use_vfork = (environ.size() == 0);

[agl, 2009/08/20 20:35:16]

const

[agl, 2009/08/20 20:35:16]

Comment about why we can't modify the environment here.

+
+  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));
+  }
+
+  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;
+
+  pid_t pid = use_vfork ? vfork() : fork();
   if (pid < 0)
     return false;
 
   if (pid == 0) {
     // Child process
-    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));
-    }
 
-    for (environment_vector::const_iterator it = environ.begin();
-         it != environ.end(); ++it) {
-      if (it->first) {
-        if (it->second) {
-          setenv(it->first, it->second, 1);
-        } else {
-          unsetenv(it->first);
+    if (!use_vfork) {
+      for (environment_vector::const_iterator it = environ.begin();
+           it != environ.end(); ++it) {
+        if (it->first) {
+          if (it->second) {
+            setenv(it->first, it->second, 1);
+          } else {
+            unsetenv(it->first);
+          }
         }
       }
     }
 
     // Obscure fork() rule: in the child, if you don't end up doing exec*(),
     // you call _exit() instead of exit(). This is because _exit() does not
     // call any previously-registered (in the parent) exit handlers, which
     // might do things like block waiting for threads that don't even exist
     // in the child.
     if (!ShuffleFileDescriptors(fd_shuffle))
       _exit(127);
 
-    // If we are using the SUID sandbox, it sets a magic environment variable
-    // ("SBX_D"), so we remove that variable from the environment here on the
-    // off chance that it's already set.
-    unsetenv("SBX_D");
-
     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 {
     // Parent process
     if (wait)
       HANDLE_EINTR(waitpid(pid, 0, 0));
 
     if (process_handle)
@@ skipping 345 matching lines @@
                       const ProcessFilter* filter) {
   bool exited_cleanly =
       WaitForProcessesToExit(executable_name, wait_milliseconds,
                              filter);
   if (!exited_cleanly)
     KillProcesses(executable_name, exit_code, filter);
   return exited_cleanly;
 }
 
 }  // namespace base