Identify the hung thread using the Wait Chain Traversal API

chrome/chrome_watcher/chrome_watcher_main.cc

 // Copyright (c) 2014 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 <windows.h>
 #include <sddl.h>
 
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/file_version_info.h"
 #include "base/files/file_path.h"
 #include "base/logging_win.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/process.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 
 #include "chrome/chrome_watcher/chrome_watcher_main_api.h"
 #include "chrome/installer/util/util_constants.h"
 #include "components/browser_watcher/endsession_watcher_window_win.h"
 #include "components/browser_watcher/exit_code_watcher_win.h"
 #include "components/browser_watcher/window_hang_monitor_win.h"
 #include "third_party/kasko/kasko_features.h"
 
 #if BUILDFLAG(ENABLE_KASKO)
+#include "chrome/chrome_watcher/wait_chain_util_win.h"
 #include "components/crash/content/app/crashpad.h"
 #include "syzygy/kasko/api/reporter.h"
 #endif
 
 namespace {
 
 // Use the same log facility as Chrome for convenience.
 // {7FE69228-633E-4f06-80C1-527FEA23E3A7}
 const GUID kChromeWatcherTraceProviderName = {
     0x7fe69228, 0x633e, 0x4f06,
@@ skipping 171 matching lines @@
   std::string env_var;
   if (env->GetVar(kKaskoCrashReportBaseDir, &env_var)) {
     base::string16 wide_env_var;
     base::UTF8ToWide(env_var.c_str(), env_var.size(), &wide_env_var);
     *base_dir = base::FilePath(wide_env_var);
   } else {
     *base_dir = base::FilePath(browser_data_directory);
   }
 }
 
+void AddCrashKey(std::vector<kasko::api::CrashKey>* crash_keys,

[Sigurður Ásgeirsson, 2016/03/24 19:30:18]

nit: crash_keys is an out param, by convention put it last?

[Patrick Monette, 2016/03/24 23:21:03]

Done.

+                 const wchar_t* key,
+                 const wchar_t* value) {
+  DCHECK(crash_keys);

[manzagop (departed), 2016/03/24 19:36:36]

DCHECK the others as well?

[Patrick Monette, 2016/03/24 23:21:03]

Done.

+
+  kasko::api::CrashKey crash_key;
+  std::wcsncpy(crash_key.name, key, kasko::api::CrashKey::kNameMaxLength);
+  std::wcsncpy(crash_key.value, value, kasko::api::CrashKey::kValueMaxLength);
+  crash_keys->push_back(crash_key);
+}
+
 void DumpHungBrowserProcess(DWORD main_thread_id,
                             const base::string16& channel,
                             const base::Process& process) {
   // Read the Crashpad module annotations for the process.
   std::vector<kasko::api::CrashKey> annotations;
   crash_reporter::ReadMainModuleAnnotationsForKasko(process, &annotations);
 
   // Add a special crash key to distinguish reports generated for a hung
   // process.
-  annotations.push_back(kasko::api::CrashKey{L"hung-process", L"1"});
+  AddCrashKey(&annotations, L"hung-process", L"1");
+
+  // Use the Wait Chain Traversal API to determine the hung thread. Defaults to
+  // UI thread on error.
+  std::vector<WAITCHAIN_NODE_INFO> wait_chain;
+  bool is_deadlock = false;
+
+  DWORD hung_thread_id = main_thread_id;
+  if (GetThreadWaitChain(main_thread_id, &wait_chain, &is_deadlock)) {
+    // The last thread in the wait chain is nominated as the hung thread.
+    DCHECK(wait_chain.back().ObjectType == WctThreadType);
+    hung_thread_id = wait_chain.back().ThreadObject.ThreadId;
+
+    AddCrashKey(&annotations, L"hung-process-is-deadlock",
+                is_deadlock ? L"true" : L"false");
+
+    for (size_t i = 0; i < wait_chain.size(); i++) {

[Sigurður Ásgeirsson, 2016/03/24 19:30:18]

Some running commentary here on what you expect the key/value pairs to denote
and look like would be helpful for the reader.

[Patrick Monette, 2016/03/24 23:21:03]

Done.

+      AddCrashKey(&annotations,
+                  base::StringPrintf(L"hung-process-wait-chain-%zu", i).c_str(),

[manzagop (departed), 2016/03/24 19:36:36]

Since the chain can contain up to 16 things, perhaps have 0 padding so
lexicographic ordering on the keys works.

[Patrick Monette, 2016/03/24 23:21:03]

Done.

+                  WaitChainNodeToString(wait_chain[i]).c_str());
+    }
+  }
 
   std::vector<const base::char16*> key_buffers;
   std::vector<const base::char16*> value_buffers;
   for (const auto& crash_key : annotations) {
     key_buffers.push_back(crash_key.name);
     value_buffers.push_back(crash_key.value);
   }
   key_buffers.push_back(nullptr);
   value_buffers.push_back(nullptr);
 
-  // Synthesize an exception for the main thread. Populate the record with the
+  // Synthesize an exception for the hung thread. Populate the record with the
   // current context of the thread to get the stack trace bucketed on the crash
   // backend.
   CONTEXT thread_context = {};
   EXCEPTION_RECORD exception_record = {};
   exception_record.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
   EXCEPTION_POINTERS exception_pointers = {&exception_record, &thread_context};
 
-  base::win::ScopedHandle main_thread(::OpenThread(
+  base::win::ScopedHandle hung_thread(::OpenThread(
       THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION,
-      FALSE, main_thread_id));
+      FALSE, hung_thread_id));
 
   bool have_context = false;
-  if (main_thread.IsValid()) {
-    DWORD suspend_count = ::SuspendThread(main_thread.Get());
+  if (hung_thread.IsValid()) {
+    DWORD suspend_count = ::SuspendThread(hung_thread.Get());
     const DWORD kSuspendFailed = static_cast<DWORD>(-1);
     if (suspend_count != kSuspendFailed) {
       // Best effort capture of the context.
       thread_context.ContextFlags = CONTEXT_FLOATING_POINT | CONTEXT_SEGMENTS |
                                     CONTEXT_INTEGER | CONTEXT_CONTROL;
-      if (::GetThreadContext(main_thread.Get(), &thread_context) == TRUE)
+      if (::GetThreadContext(hung_thread.Get(), &thread_context) == TRUE)
         have_context = true;
 
-      ::ResumeThread(main_thread.Get());
+      ::ResumeThread(hung_thread.Get());
     }
   }
 
   // TODO(erikwright): Make the dump-type channel-dependent.
   if (have_context) {
     kasko::api::SendReportForProcess(
-        process.Handle(), main_thread_id, &exception_pointers,
+        process.Handle(), hung_thread_id, &exception_pointers,
         kasko::api::LARGER_DUMP_TYPE, key_buffers.data(), value_buffers.data());
   } else {
     kasko::api::SendReportForProcess(process.Handle(), 0, nullptr,
                                      kasko::api::LARGER_DUMP_TYPE,
                                      key_buffers.data(), value_buffers.data());
   }
 }
 
 void LoggedDeregisterEventSource(HANDLE event_source_handle) {
   if (!::DeregisterEventSource(event_source_handle))
@@ skipping 141 matching lines @@
 
   // Wind logging down.
   logging::LogEventProvider::Uninitialize();
 
   return 0;
 }
 
 static_assert(
     std::is_same<decltype(&WatcherMain), ChromeWatcherMainFunction>::value,
     "WatcherMain() has wrong type");