Debug exit code

base/process/kill_posix.cc

 // Copyright (c) 2013 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/kill.h"
 
 #include <errno.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/process_iterator.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
 namespace base {
 
 namespace {
 
 TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
                                            bool can_block,
                                            int* exit_code) {
+  LOG(ERROR) << "In GetTerminationStatusImpl can_block=" << can_block;
+  fflush(stderr);
   int status = 0;
   const pid_t result = HANDLE_EINTR(waitpid(handle, &status,
                                             can_block ? 0 : WNOHANG));
+  LOG(ERROR) << "waitpid result=" << result << "status=" << status;
+  fflush(stderr);
+
   if (result == -1) {
     DPLOG(ERROR) << "waitpid(" << handle << ")";
     if (exit_code)
       *exit_code = 0;
+    LOG(ERROR) << "Normal termination";
+    fflush(stderr);
     return TERMINATION_STATUS_NORMAL_TERMINATION;
   } else if (result == 0) {
     // the child hasn't exited yet.
     if (exit_code)
       *exit_code = 0;
+    LOG(ERROR) << "Still running";
+    fflush(stderr);
     return TERMINATION_STATUS_STILL_RUNNING;
   }
 
   if (exit_code)
     *exit_code = status;
 
   if (WIFSIGNALED(status)) {
+    LOG(ERROR) << "WIFSIGNALED: signal" << WTERMSIG(status);
+    fflush(stderr);
     switch (WTERMSIG(status)) {
       case SIGABRT:
       case SIGBUS:
       case SIGFPE:
       case SIGILL:
       case SIGSEGV:
       case SIGTRAP:
       case SIGSYS:
+        LOG(ERROR) << "Process crashed";
         return TERMINATION_STATUS_PROCESS_CRASHED;
       case SIGKILL:
 #if defined(OS_CHROMEOS)
         // On ChromeOS, only way a process gets kill by SIGKILL
         // is by oom-killer.
         return TERMINATION_STATUS_PROCESS_WAS_KILLED_BY_OOM;
 #endif
       case SIGINT:
       case SIGTERM:
+          LOG(ERROR) << "Process was killed";
         return TERMINATION_STATUS_PROCESS_WAS_KILLED;
       default:
         break;
     }
   }
 
-  if (WIFEXITED(status) && WEXITSTATUS(status) != 0)
+  if (WIFEXITED(status) && WEXITSTATUS(status) != 0) {
+    LOG(ERROR) << "Abnormal termination";
     return TERMINATION_STATUS_ABNORMAL_TERMINATION;
+  }
 
+  LOG(ERROR) << "Normal termination (last resort)";
   return TERMINATION_STATUS_NORMAL_TERMINATION;
 }
 
 }  // namespace
 
 #if !defined(OS_NACL_NONSFI)
 bool KillProcessGroup(ProcessHandle process_group_id) {
   bool result = kill(-1 * process_group_id, SIGKILL) == 0;
   if (!result)
     DPLOG(ERROR) << "Unable to terminate process group " << process_group_id;
@@ skipping 140 matching lines @@
     return;
 
   BackgroundReaper* reaper = new BackgroundReaper(pid, 0);
   PlatformThread::CreateNonJoinable(0, reaper);
 }
 
 #endif  // !defined(OS_MACOSX)
 #endif  // !defined(OS_NACL_NONSFI)
 
 }  // namespace base