Add retry logic for FindThreadIDWithSyscall()

components/crash/content/browser/crash_handler_host_linux.cc

 // Copyright 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 "components/crash/content/browser/crash_handler_host_linux.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 10 matching lines @@
 #include "base/linux_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "breakpad/src/client/linux/handler/exception_handler.h"
 #include "breakpad/src/client/linux/minidump_writer/linux_dumper.h"
 #include "breakpad/src/client/linux/minidump_writer/minidump_writer.h"
 #include "build/build_config.h"
 #include "components/crash/content/app/breakpad_linux_impl.h"
 #include "content/public/browser/browser_thread.h"
 
 #if defined(OS_ANDROID) && !defined(__LP64__)
 #include <sys/linux-syscalls.h>
 
 #define SYS_read __NR_read
 #endif
 
 using content::BrowserThread;
 using google_breakpad::ExceptionHandler;
 
 namespace breakpad {
 
 namespace {
 
 const size_t kNumFDs = 1;
 // The length of the control message:
 const size_t kControlMsgSize =
     CMSG_SPACE(kNumFDs * sizeof(int)) + CMSG_SPACE(sizeof(struct ucred));
 // The length of the regular payload:
 const size_t kCrashContextSize = sizeof(ExceptionHandler::CrashContext);
 
+// Crashing thread might be in "running" state, i.e. after sys_sendmsg() and
+// before sys_read(). Retry 3 times with interval of 100 ms when translating
+// TID.
+const int kNumAttemptsTranslatingTid = 3;
+const int kRetryIntervalTranslatingTidInMs = 100;
+
 // Handles the crash dump and frees the allocated BreakpadInfo struct.
 void CrashDumpTask(CrashHandlerHostLinux* handler,
                    std::unique_ptr<BreakpadInfo> info) {
   if (handler->IsShuttingDown() && info->upload) {
     base::DeleteFile(base::FilePath(info->filename), false);
 #if defined(ADDRESS_SANITIZER)
     base::DeleteFile(base::FilePath(info->log_filename), false);
 #endif
     return;
   }
@@ skipping 205 matching lines @@
   // namespaces also have /proc/[pid]/syscall, so we can look through
   // |actual_crashing_pid|'s thread group and find the thread that's in the
   // read syscall with the right arguments.
 
   std::string expected_syscall_data;
   // /proc/[pid]/syscall is formatted as follows:
   // syscall_number arg1 ... arg6 sp pc
   // but we just check syscall_number through arg3.
   base::StringAppendF(&expected_syscall_data, "%d 0x%x %p 0x1 ",
                       SYS_read, tid_fd, tid_buf_addr);
+
+  FindCrashingThreadAndDump(crashing_pid,
+                            expected_syscall_data,
+                            std::move(crash_context),
+                            std::move(crash_keys),
+                            uptime,
+                            oom_size,
+                            signal_fd.release(),
+                            0);
+}
+
+void CrashHandlerHostLinux::FindCrashingThreadAndDump(
+    pid_t crashing_pid,
+    const std::string& expected_syscall_data,
+    std::unique_ptr<char[]> crash_context,
+    std::unique_ptr<CrashKeyStorage> crash_keys,
+    uint64_t uptime,
+    size_t oom_size,
+    int signal_fd,
+    int attempt) {
   bool syscall_supported = false;
-  pid_t crashing_tid =
-      base::FindThreadIDWithSyscall(crashing_pid,
-                                    expected_syscall_data,
-                                    &syscall_supported);
+  pid_t crashing_tid = -1;
+  crashing_tid = base::FindThreadIDWithSyscall(crashing_pid,

[Lei Zhang, 2016/07/25 18:46:57]

Combine with previous line?

[wzhong, 2016/07/25 19:27:46]

Done.

+                                               expected_syscall_data,
+                                               &syscall_supported);
+  ++attempt;
+  if (crashing_tid == -1 && syscall_supported &&
+      attempt <= kNumAttemptsTranslatingTid) {
+    LOG(WARNING) << "Could not translate tid, attempt = " << attempt
+                 << " retry ...";
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&CrashHandlerHostLinux::FindCrashingThreadAndDump,
+                 base::Unretained(this),
+                 crashing_pid,
+                 expected_syscall_data,
+                 base::Passed(&crash_context),
+                 base::Passed(&crash_keys),
+                 uptime,
+                 oom_size,
+                 signal_fd,
+                 attempt),
+      base::TimeDelta::FromMilliseconds(kRetryIntervalTranslatingTidInMs));
+    return;
+  }
+
+
   if (crashing_tid == -1) {
     // We didn't find the thread we want. Maybe it didn't reach
     // sys_read() yet or the thread went away.  We'll just take a
     // guess here and assume the crashing thread is the thread group
     // leader.  If procfs syscall is not supported by the kernel, then
     // we assume the kernel also does not support TID namespacing and
     // trust the TID passed by the crashing process.
     LOG(WARNING) << "Could not translate tid - assuming crashing thread is "
         "thread group leader; syscall_supported=" << syscall_supported;
     crashing_tid = crashing_pid;
@@ skipping 33 matching lines @@
 
 
   BrowserThread::GetBlockingPool()->PostSequencedWorkerTask(
       worker_pool_token_,
       FROM_HERE,
       base::Bind(&CrashHandlerHostLinux::WriteDumpFile,
                  base::Unretained(this),
                  base::Passed(&info),
                  base::Passed(&crash_context),
                  crashing_pid,
-                 signal_fd.release()));
+                 signal_fd));
 }
 
 void CrashHandlerHostLinux::WriteDumpFile(std::unique_ptr<BreakpadInfo> info,
                                           std::unique_ptr<char[]> crash_context,
                                           pid_t crashing_pid,
                                           int signal_fd) {
   DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
       worker_pool_token_));
 
   // Set |info->distro| here because base::GetLinuxDistro() needs to run on a
@@ skipping 83 matching lines @@
   // no-ops.
   shutting_down_ = true;
   uploader_thread_->Stop();
 }
 
 bool CrashHandlerHostLinux::IsShuttingDown() const {
   return shutting_down_;
 }
 
 }  // namespace breakpad