Linux: inform the Zygote when it's waiting on a dead process

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 <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
@@ skipping 186 matching lines @@
   } else {
     actual_child = child;
   }
 
   base::EnsureProcessTerminated(actual_child);
 }
 
 void Zygote::HandleGetTerminationStatus(int fd,
                                         const Pickle& pickle,
                                         PickleIterator iter) {
+  bool known_dead;
   base::ProcessHandle child;
 
-  if (!pickle.ReadInt(&iter, &child)) {
+  if (!pickle.ReadBool(&iter, &known_dead) ||
+      !pickle.ReadInt(&iter, &child)) {
     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) {
-    status = base::GetTerminationStatus(child, &exit_code);
+    if (known_dead) {
+      // 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);
+    } else {
+      status = base::GetTerminationStatus(child, &exit_code);
+    }
   } else {
     // Assume that if we can't find the child in the sandbox, then
     // it terminated normally.
     status = base::TERMINATION_STATUS_NORMAL_TERMINATION;
     exit_code = RESULT_CODE_NORMAL_EXIT;
   }
 
   Pickle write_pickle;
   write_pickle.WriteInt(static_cast<int>(status));
   write_pickle.WriteInt(exit_code);
@@ skipping 259 matching lines @@
                                     PickleIterator iter) {
   if (HANDLE_EINTR(write(fd, &sandbox_flags_, sizeof(sandbox_flags_))) !=
                    sizeof(sandbox_flags_)) {
     PLOG(ERROR) << "write";
   }
 
   return false;
 }
 
 }  // namespace content