chrome: respect --child-clean-exit.

content/zygote/zygote_linux.cc

 // Copyright (c) 2012 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 "content/zygote/zygote_linux.h"
 
 #include <fcntl.h>
+#include <pthread.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/linux_util.h"
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/posix/global_descriptors.h"
 #include "base/posix/unix_domain_socket_linux.h"
 #include "base/process_util.h"
 #include "content/common/sandbox_linux.h"
 #include "content/common/set_process_title.h"
 #include "content/common/zygote_commands_linux.h"
 #include "content/public/common/content_descriptors.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_linux.h"
 #include "content/public/common/zygote_fork_delegate_linux.h"
 #include "ipc/ipc_channel.h"
 #include "ipc/ipc_switches.h"
 
 // See http://code.google.com/p/chromium/wiki/LinuxZygote
 
 namespace content {
 
@@ skipping 66 matching lines @@
   return sandbox_flags_ & kSandboxLinuxSUID;
 }
 
 bool Zygote::HandleRequestFromBrowser(int fd) {
   std::vector<int> fds;
   char buf[kZygoteMaxMessageLength];
   const ssize_t len = UnixDomainSocket::RecvMsg(fd, buf, sizeof(buf), &fds);
 
   if (len == 0 || (len == -1 && errno == ECONNRESET)) {
     // EOF from the browser. We should die.
-    _exit(0);
+    if (CommandLine::ForCurrentProcess()->
+        HasSwitch(switches::kChildCleanExit)) {
+      // Zygote children are reaped in a separate detached thread (see the
+      // implementation of EnsureProcessGetsReaped()). If we _exit() or exit()
+      // here, the reaping wait may not have completed. For this reason, we
+      // only terminate this thread (instead of terminating the whole process).
+      // The zygote will then exit only when all children have exited and have
+      // been reaped.
+      pthread_exit(0);
+    }
+    else
+      _exit(0);
     return false;
   }
 
   if (len == -1) {
     PLOG(ERROR) << "Error reading message from browser";
     return false;
   }
 
   Pickle pickle(buf, len);
   PickleIterator iter(pickle);
@@ skipping 65 matching lines @@
     LOG(WARNING) << "Error parsing GetTerminationStatus request "
                  << "from browser";
     return;
   }
 
   base::TerminationStatus status;
   int exit_code;
   if (UsingSUIDSandbox())
     child = real_pids_to_sandbox_pids[child];
   if (child) {
-    if (known_dead) {
+    if (known_dead &&
+        !CommandLine::ForCurrentProcess()->
+        HasSwitch(switches::kChildCleanExit)) {
       // If we know that the process is already dead and the kernel is cleaning
       // it up, we do want to wait until it becomes a zombie and not risk
       // returning eroneously that it is still running. However, we do not
       // want to risk a bug where we're told a process is dead when it's not.
       // By sending SIGKILL, we make sure that WaitForTerminationStatus will
       // return quickly even in this case.
       if (kill(child, SIGKILL)) {
         PLOG(ERROR) << "kill (" << child << ")";
       }
       status = base::WaitForTerminationStatus(child, &exit_code);
@@ skipping 265 matching lines @@
                                     PickleIterator iter) {
   if (HANDLE_EINTR(write(fd, &sandbox_flags_, sizeof(sandbox_flags_))) !=
                    sizeof(sandbox_flags_)) {
     PLOG(ERROR) << "write";
   }
 
   return false;
 }
 
 }  // namespace content