Skip to content

GitLab

T
tangled
Commit 32d4643f authored by manzagop's avatar manzagop Committed by Commit bot
Browse files
Options

Remove the Kasko based out of process browser hang instrumentation. 

This CL removes the out-of-process browser hang instrumentation used to
capture 20s hangs and failed rendezvous crash reports in one-off canary
releases. The Kasko reporter is deprecated, and CrashPad does not yet
support the use case.

The plan is to restore this functionality once CrashPad supports it.

BUG=622314

Review-Url: https://codereview.chromium.org/2086403002
Cr-Commit-Position: refs/heads/master@{#402189}
parent df911bda
Hide whitespace changes
Inline Side-by-side
Showing with 87 additions and 720 deletions
build/common.gypi
View file @ 32d4643f
...@@ -1036,19 +1036,6 @@ ...@@ -1036,19 +1036,6 @@
# http://crbug.com/574476 # http://crbug.com/574476
'fastbuild%': 2, 'fastbuild%': 2,
}], }],
# Enable hang report capture. Capture can only be enabled for 32bit
# Windows.
['OS=="win" and target_arch=="ia32" and branding=="Chrome"', {
# Enable hang reports from the watcher process.
'kasko_hang_reports%': 0,
# Enable failed rendez-vous reports.
'kasko_failed_rdv_reports%': 0,
}, {
# Enable hang reports from the watcher process.
'kasko_hang_reports%': 0,
# Enable failed rendez-vous reports.
'kasko_failed_rdv_reports%': 0,
}],
], ],
# Kasko reporting is disabled by default, but may get enabled below. # Kasko reporting is disabled by default, but may get enabled below.
...@@ -1203,8 +1190,6 @@ ...@@ -1203,8 +1190,6 @@
'use_sanitizer_options%': '<(use_sanitizer_options)', 'use_sanitizer_options%': '<(use_sanitizer_options)',
'syzyasan%': '<(syzyasan)', 'syzyasan%': '<(syzyasan)',
'kasko%': '<(kasko)', 'kasko%': '<(kasko)',
'kasko_hang_reports%': '<(kasko_hang_reports)',
'kasko_failed_rdv_reports%': '<(kasko_failed_rdv_reports)',
'syzygy_optimize%': '<(syzygy_optimize)', 'syzygy_optimize%': '<(syzygy_optimize)',
'lsan%': '<(lsan)', 'lsan%': '<(lsan)',
'msan%': '<(msan)', 'msan%': '<(msan)',
...@@ -2014,14 +1999,8 @@ ...@@ -2014,14 +1999,8 @@
}, { }, {
'win_console_app%': 0, 'win_console_app%': 0,
}], }],
# Disable hang reporting for syzyasan builds. # Enable the Kasko reporter for syzyasan builds.
['syzyasan==1', { ['syzyasan==1', {
# Note: override.
'kasko_hang_reports': 0,
'kasko_failed_rdv_reports': 0,
}],
# Enable the Kasko reporter for syzyasan builds and hang reporting.
['syzyasan==1 or kasko_hang_reports==1 or kasko_failed_rdv_reports==1', {
'kasko': 1, 'kasko': 1,
}], }],
['component=="shared_library"', { ['component=="shared_library"', {
......
chrome/browser/BUILD.gn
View file @ 32d4643f
...@@ -8,7 +8,6 @@ import("//build/config/features.gni") ...@@ -8,7 +8,6 @@ import("//build/config/features.gni")
import("//build/config/ui.gni") import("//build/config/ui.gni")
import("//chrome/common/features.gni") import("//chrome/common/features.gni")
import("//media/media_options.gni") import("//media/media_options.gni")
import("//third_party/kasko/kasko.gni")
import("//third_party/protobuf/proto_library.gni") import("//third_party/protobuf/proto_library.gni")
# //build/config/android/rules.gni imports //tools/grit/grit_rule.gni, which # //build/config/android/rules.gni imports //tools/grit/grit_rule.gni, which
...@@ -657,13 +656,6 @@ target(chrome_browser_target_type, "browser") { ...@@ -657,13 +656,6 @@ target(chrome_browser_target_type, "browser") {
"//components/version_info:generate_version_info", "//components/version_info:generate_version_info",
] ]
} }
if (is_win && enable_kasko_failed_rdv_reports) {
sources += [
"//chrome/app/chrome_crash_reporter_client_win.cc",
"//chrome/app/chrome_crash_reporter_client_win.h",
]
deps += [ "//components/crash/content/app:lib" ]
}
if (use_nss_certs) { if (use_nss_certs) {
sources += sources +=
rebase_path(gypi_values.chrome_browser_nss_sources, ".", "//chrome") rebase_path(gypi_values.chrome_browser_nss_sources, ".", "//chrome")
...@@ -844,7 +836,6 @@ target(chrome_browser_target_type, "browser") { ...@@ -844,7 +836,6 @@ target(chrome_browser_target_type, "browser") {
":chrome_process_finder", ":chrome_process_finder",
"//chrome:file_pre_reader", "//chrome:file_pre_reader",
"//chrome/chrome_watcher:client", "//chrome/chrome_watcher:client",
"//chrome/chrome_watcher:kasko_util",
"//chrome/common:metrics_constants_util_win", "//chrome/common:metrics_constants_util_win",
"//chrome/common:version_header", "//chrome/common:version_header",
"//chrome/installer/util:strings", "//chrome/installer/util:strings",
......
chrome/browser/process_singleton_win.cc
View file @ 32d4643f
...@@ -13,7 +13,6 @@ ...@@ -13,7 +13,6 @@
#include "base/command_line.h" #include "base/command_line.h"
#include "base/files/file_path.h" #include "base/files/file_path.h"
#include "base/macros.h" #include "base/macros.h"
#include "base/path_service.h"
#include "base/process/process.h" #include "base/process/process.h"
#include "base/process/process_info.h" #include "base/process/process_info.h"
#include "base/strings/string_number_conversions.h" #include "base/strings/string_number_conversions.h"
...@@ -28,27 +27,17 @@ ...@@ -28,27 +27,17 @@
#include "chrome/browser/chrome_process_finder_win.h" #include "chrome/browser/chrome_process_finder_win.h"
#include "chrome/browser/shell_integration.h" #include "chrome/browser/shell_integration.h"
#include "chrome/browser/ui/simple_message_box.h" #include "chrome/browser/ui/simple_message_box.h"
#include "chrome/common/channel_info.h"
#include "chrome/common/chrome_constants.h" #include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_paths.h" #include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_paths_internal.h" #include "chrome/common/chrome_paths_internal.h"
#include "chrome/common/chrome_switches.h" #include "chrome/common/chrome_switches.h"
#include "chrome/grit/chromium_strings.h" #include "chrome/grit/chromium_strings.h"
#include "chrome/installer/util/google_update_settings.h"
#include "chrome/installer/util/util_constants.h"
#include "chrome/installer/util/wmi.h" #include "chrome/installer/util/wmi.h"
#include "components/version_info/version_info.h"
#include "content/public/common/result_codes.h" #include "content/public/common/result_codes.h"
#include "net/base/escape.h" #include "net/base/escape.h"
#include "third_party/kasko/kasko_features.h"
#include "ui/base/l10n/l10n_util.h" #include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/win/hwnd_util.h" #include "ui/gfx/win/hwnd_util.h"
#if BUILDFLAG(ENABLE_KASKO_FAILED_RDV_REPORTS)
#include "chrome/app/chrome_crash_reporter_client_win.h"
#include "chrome/chrome_watcher/kasko_util.h"
#endif // BUILDFLAG(ENABLE_KASKO_FAILED_RDV_REPORTS)
namespace { namespace {
const char kLockfile[] = "lockfile"; const char kLockfile[] = "lockfile";
...@@ -191,67 +180,6 @@ bool DisplayShouldKillMessageBox() { ...@@ -191,67 +180,6 @@ bool DisplayShouldKillMessageBox() {
chrome::MESSAGE_BOX_RESULT_NO; chrome::MESSAGE_BOX_RESULT_NO;
} }
#if BUILDFLAG(ENABLE_KASKO_FAILED_RDV_REPORTS)
// Capture a failed rendez-vous hang report of the other process. Kasko needs
// the exception context to live either in the dumper or the dumpee. This
// means we cannot rely on kasko reporters from either browser watcher, and
// instead spin up a new reporter.
void SendFailedRdvReport(const base::Process& process, DWORD thread_id) {
// Check whether reports can be uploaded. This involves checking group policy,
// stats collection consent and whether running on a bot. The correct approach
// would be to rely on crash_reporter::GetUploadsEnabled(). However, on
// Windows, the crash client is only expected to be linked into chrome.exe
// (not the dlls). That means CrashPad globals are not set and we cannot call
// crash_reporter::GetUploadsEnabled(). As a temporary measure until Kasko is
// no longer used, we duplicate CrashPad's logic here.
ChromeCrashReporterClient crash_reporter_client;
bool enable_uploads = false;
if (!crash_reporter_client.ReportingIsEnforcedByPolicy(&enable_uploads)) {
// Breakpad provided a --disable-breakpad switch to disable crash dumping
// (not just uploading) here. Crashpad doesn't need it: dumping is enabled
// unconditionally and uploading is gated on consent, which tests/bots
// shouldn't have. As a precaution, uploading is also disabled on bots
// even if consent is present.
enable_uploads = crash_reporter_client.GetCollectStatsConsent() &&
!crash_reporter_client.IsRunningUnattended();
}
if (!enable_uploads)
return;
// TODO(manzagop): add a metric for the number of captured hang reports, for
// comparison with uploaded count?
// Only report on canary.
if (chrome::GetChannel() != version_info::Channel::CANARY) {
return;
}
// TODO(manzagop): add a metric for the number of times this does not match.
if (!EnsureTargetProcessValidForCapture(process))
return;
// Initialize a reporter, capture a report and shutdown the reporter.
base::FilePath watcher_data_directory;
if (PathService::Get(chrome::DIR_WATCHER_DATA, &watcher_data_directory)) {
base::string16 endpoint =
L"chrome_kasko_rdv_" +
base::UintToString16(base::Process::Current().Pid());
bool launched_kasko = InitializeKaskoReporter(
endpoint, watcher_data_directory.value().c_str());
if (launched_kasko) {
DumpHungProcess(thread_id, installer::kChromeChannelCanary, L"failed-rdv",
process);
// We immediately request Kasko shutdown. This may block until the
// completion of ongoing background tasks (e.g., upload). If the report is
// not uploaded by this reporter, any other Kasko reporter may upload it.
ShutdownKaskoReporter();
}
}
}
#endif // BUILDFLAG(ENABLE_KASKO_FAILED_RDV_REPORTS)
} // namespace } // namespace
// Microsoft's Softricity virtualization breaks the sandbox processes. // Microsoft's Softricity virtualization breaks the sandbox processes.
...@@ -333,14 +261,7 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() { ...@@ -333,14 +261,7 @@ ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
// Get a handle to the process that created the window. // Get a handle to the process that created the window.
base::Process process = base::Process::Open(process_id); base::Process process = base::Process::Open(process_id);
// Optionally send a failed rendez-vous report. // TODO(manzagop): capture a hang report.
// Note: we nominate the thread that created the window as the root of the
// search for a hung thread.
#if defined(GOOGLE_CHROME_BUILD)
#if BUILDFLAG(ENABLE_KASKO_FAILED_RDV_REPORTS)
SendFailedRdvReport(process, thread_id);
#endif // BUILDFLAG(ENABLE_KASKO_FAILED_RDV_REPORTS)
#endif // GOOGLE_CHROME_BUILD
// Scan for every window to find a visible one. // Scan for every window to find a visible one.
bool visible_window = false; bool visible_window = false;
......
chrome/chrome_browser.gypi
View file @ 32d4643f
...@@ -3730,15 +3730,6 @@ ...@@ -3730,15 +3730,6 @@
'../components/components.gyp:generate_version_info', '../components/components.gyp:generate_version_info',
], ],
}], }],
['OS == "win" and kasko_failed_rdv_reports == 1', {
'sources': [
'app/chrome_crash_reporter_client_win.cc',
'app/chrome_crash_reporter_client_win.h',
],
'dependencies': [
'../components/components.gyp:crash_component_lib',
],
}],
['use_nss_certs==1', { ['use_nss_certs==1', {
'sources': [ '<@(chrome_browser_nss_sources)' ], 'sources': [ '<@(chrome_browser_nss_sources)' ],
'conditions': [ 'conditions': [
...@@ -3905,7 +3896,6 @@ ...@@ -3905,7 +3896,6 @@
'chrome_watcher_client', 'chrome_watcher_client',
'file_pre_reader', 'file_pre_reader',
'installer_util_strings', 'installer_util_strings',
'kasko_util',
'metrics_constants_util_win', 'metrics_constants_util_win',
'../chrome/common_constants.gyp:version_header', '../chrome/common_constants.gyp:version_header',
'../chrome_elf/chrome_elf.gyp:chrome_elf', '../chrome_elf/chrome_elf.gyp:chrome_elf',
......
chrome/chrome_watcher/BUILD.gn
View file @ 32d4643f
...@@ -4,7 +4,6 @@ ...@@ -4,7 +4,6 @@
import("//chrome/version.gni") import("//chrome/version.gni")
import("//testing/test.gni") import("//testing/test.gni")
import("//third_party/kasko/kasko.gni")
source_set("client") { source_set("client") {
sources = [ sources = [
...@@ -16,42 +15,36 @@ source_set("client") { ...@@ -16,42 +15,36 @@ source_set("client") {
] ]
} }
if (enable_kasko) { source_set("hang_util") {
source_set("kasko_util") { sources = [
sources = [ "system_load_estimator.cc",
"kasko_util.cc", "system_load_estimator.h",
"kasko_util.h", ]
"system_load_estimator.cc", deps = [
"system_load_estimator.h", "//base",
] "//components/memory_pressure",
deps = [ ]
"//base", libs = [ "pdh.lib" ] # Used by system_load_estimator.h.
"//components/crash/content/app", ldflags = [ "/DELAYLOAD:pdh.dll" ] # Only used on report capture.
"//components/memory_pressure", }
"//third_party/kasko",
] test("system_load_estimator_unittests") {
libs = [ "pdh.lib" ] # Used by system_load_estimator.h. sources = [
ldflags = [ "/DELAYLOAD:pdh.dll" ] # Only used on report capture. "system_load_estimator_unittest.cc",
} ]
deps = [
":client",
":hang_util",
"//base/test:run_all_unittests",
"//base/test:test_support",
"//testing/gtest",
]
}
test("system_load_estimator_unittests") { group("kasko_util") {
sources = [ public_deps = [
"system_load_estimator_unittest.cc", "//third_party/kasko:kasko_features",
] ]
deps = [
":client",
":kasko_util",
"//base/test:run_all_unittests",
"//base/test:test_support",
"//testing/gtest",
]
}
} else {
group("kasko_util") {
public_deps = [
"//third_party/kasko:kasko_features",
]
}
} }
process_version("chrome_watcher_resources") { process_version("chrome_watcher_resources") {
......
chrome/chrome_watcher/chrome_watcher.gypi
View file @ 32d4643f
...@@ -9,82 +9,64 @@ ...@@ -9,82 +9,64 @@
'../../build/util/version.gypi', '../../build/util/version.gypi',
'../../build/win_precompile.gypi', '../../build/win_precompile.gypi',
], ],
'conditions': [ 'targets': [
['kasko==1', { {
'targets': [ 'target_name': 'kasko_util',
{ 'type': 'none',
'target_name': 'kasko_util', 'dependencies': [
'type': 'static_library', '../third_party/kasko/kasko.gyp:kasko_features',
'sources': [ ],
'kasko_util.cc', },
'kasko_util.h', {
'system_load_estimator.cc', 'target_name': 'hang_util',
'system_load_estimator.h', 'type': 'static_library',
], 'sources': [
'dependencies': [ 'system_load_estimator.cc',
'chrome_watcher_client', 'system_load_estimator.h',
'../base/base.gyp:base', ],
'../third_party/kasko/kasko.gyp:kasko', 'dependencies': [
'../components/components.gyp:crash_component', '../base/base.gyp:base',
'../components/components.gyp:memory_pressure' '../components/components.gyp:memory_pressure'
],
'msvs_settings': {
'VCLinkerTool': {
'DelayLoadDLLs': [
'pdh.dll', # Used by system_load_estimator.h on report capture.
], ],
'export_dependent_settings': [ 'AdditionalDependencies': [
'../third_party/kasko/kasko.gyp:kasko', 'pdh.lib',
], ],
'msvs_settings': {
'VCLinkerTool': {
'DelayLoadDLLs': [
'pdh.dll', # Used by system_load_estimator.h on report capture.
],
'AdditionalDependencies': [
'pdh.lib',
],
},
},
'all_dependent_settings': {
'msvs_settings': {
'VCLinkerTool': {
'DelayLoadDLLs': [
# Used by system_load_estimator.h on report capture.
'pdh.dll',
],
'AdditionalDependencies': [
'pdh.lib',
],
},
},
},
}, },
},
{ 'all_dependent_settings': {
# GN version: //chrome/chrome_watcher:system_load_estimator_unittests 'msvs_settings': {
'target_name': 'system_load_estimator_unittests', 'VCLinkerTool': {
'type': '<(gtest_target_type)', 'DelayLoadDLLs': [
'sources': [ # Used by system_load_estimator.h on report capture.
'system_load_estimator_unittest.cc', 'pdh.dll',
], ],
'dependencies': [ 'AdditionalDependencies': [
'kasko_util', 'pdh.lib',
'../base/base.gyp:base', ],
'../base/base.gyp:run_all_unittests', },
'../base/base.gyp:test_support_base',
'../testing/gtest.gyp:gtest',
],
}, },
},
},
{
# GN version: //chrome/chrome_watcher:system_load_estimator_unittests
'target_name': 'system_load_estimator_unittests',
'type': '<(gtest_target_type)',
'sources': [
'system_load_estimator_unittest.cc',
], ],
}, { # 'kasko==0' 'dependencies': [
'targets': [ 'hang_util',
{ '../base/base.gyp:base',
'target_name': 'kasko_util', '../base/base.gyp:run_all_unittests',
'type': 'none', '../base/base.gyp:test_support_base',
'dependencies': [ '../testing/gtest.gyp:gtest',
'../third_party/kasko/kasko.gyp:kasko_features',
],
},
], ],
}], },
], # 'conditions'
'targets': [
{ {
'target_name': 'chrome_watcher_resources', 'target_name': 'chrome_watcher_resources',
'type': 'none', 'type': 'none',
......
chrome/chrome_watcher/chrome_watcher_main.cc
View file @ 32d4643f
...@@ -35,12 +35,10 @@ ...@@ -35,12 +35,10 @@
#include "base/win/win_util.h" #include "base/win/win_util.h"
#include "chrome/chrome_watcher/chrome_watcher_main_api.h" #include "chrome/chrome_watcher/chrome_watcher_main_api.h"
#include "chrome/chrome_watcher/kasko_util.h"
#include "chrome/installer/util/util_constants.h" #include "chrome/installer/util/util_constants.h"
#include "components/browser_watcher/endsession_watcher_window_win.h" #include "components/browser_watcher/endsession_watcher_window_win.h"
#include "components/browser_watcher/exit_code_watcher_win.h" #include "components/browser_watcher/exit_code_watcher_win.h"
#include "components/browser_watcher/window_hang_monitor_win.h" #include "components/browser_watcher/window_hang_monitor_win.h"
#include "third_party/kasko/kasko_features.h"
namespace { namespace {
...@@ -181,16 +179,6 @@ void BrowserMonitor::BrowserExited() { ...@@ -181,16 +179,6 @@ void BrowserMonitor::BrowserExited() {
} }
} }
void OnWindowEvent(
base::Process process,
const base::Callback<void(const base::Process&)>& on_hung_callback,
browser_watcher::WindowHangMonitor::WindowEvent window_event) {
if (window_event == browser_watcher::WindowHangMonitor::WINDOW_HUNG &&
!on_hung_callback.is_null()) {
on_hung_callback.Run(process);
}
}
} // namespace } // namespace
// The main entry point to the watcher, declared as extern "C" to avoid name // The main entry point to the watcher, declared as extern "C" to avoid name
...@@ -215,22 +203,6 @@ extern "C" int WatcherMain(const base::char16* registry_path, ...@@ -215,22 +203,6 @@ extern "C" int WatcherMain(const base::char16* registry_path,
// chrome.exe in order to report its exit status. // chrome.exe in order to report its exit status.
::SetProcessShutdownParameters(0x100, SHUTDOWN_NORETRY); ::SetProcessShutdownParameters(0x100, SHUTDOWN_NORETRY);
base::Callback<void(const base::Process&)> on_hung_callback;
#if BUILDFLAG(ENABLE_KASKO)
bool launched_kasko = InitializeKaskoReporter(GetKaskoEndpoint(process.Pid()),
browser_data_directory);
#if BUILDFLAG(ENABLE_KASKO_HANG_REPORTS)
// Only activate hang reports for the canary channel.
if (launched_kasko &&
base::StringPiece16(channel_name) == installer::kChromeChannelCanary) {
on_hung_callback = base::Bind(&DumpHungProcess, main_thread_id,
channel_name, L"hung-process");
}
#endif // BUILDFLAG(ENABLE_KASKO_HANG_REPORTS)
#endif // BUILDFLAG(ENABLE_KASKO)
// Run a UI message loop on the main thread. // Run a UI message loop on the main thread.
base::PlatformThread::SetName("WatcherMainThread"); base::PlatformThread::SetName("WatcherMainThread");
base::MessageLoop msg_loop(base::MessageLoop::TYPE_UI); base::MessageLoop msg_loop(base::MessageLoop::TYPE_UI);
...@@ -241,22 +213,8 @@ extern "C" int WatcherMain(const base::char16* registry_path, ...@@ -241,22 +213,8 @@ extern "C" int WatcherMain(const base::char16* registry_path,
std::move(on_initialized_event))) { std::move(on_initialized_event))) {
return 1; return 1;
} }
run_loop.Run();
{ // TODO(manzagop): hang monitoring using WindowHangMonitor.
// Scoped to force |hang_monitor| destruction before Kasko is shut down.
browser_watcher::WindowHangMonitor hang_monitor(
base::TimeDelta::FromSeconds(60), base::TimeDelta::FromSeconds(20),
base::Bind(&OnWindowEvent, base::Passed(process.Duplicate()),
on_hung_callback));
hang_monitor.Initialize(process.Duplicate());
run_loop.Run();
}
#if BUILDFLAG(ENABLE_KASKO)
if (launched_kasko)
ShutdownKaskoReporter();
#endif // BUILDFLAG(ENABLE_KASKO)
// Wind logging down. // Wind logging down.
logging::LogEventProvider::Uninitialize(); logging::LogEventProvider::Uninitialize();
......
chrome/chrome_watcher/kasko_util.cc deleted 100644 → 0
View file @ df911bda
// Copyright 2016 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 "chrome/chrome_watcher/kasko_util.h"
#include <sddl.h>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "base/base_paths.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/environment.h"
#include "base/files/file_path.h"
#include "base/format_macros.h"
#include "base/macros.h"
#include "base/path_service.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/win/wait_chain.h"
#include "base/win/win_util.h"
#include "chrome/chrome_watcher/chrome_watcher_main_api.h"
#include "chrome/chrome_watcher/system_load_estimator.h"
#include "components/crash/content/app/crashpad.h"
#include "components/memory_pressure/direct_memory_pressure_calculator_win.h"
#include "components/memory_pressure/memory_pressure_calculator.h"
#include "syzygy/kasko/api/reporter.h"
namespace {
using MemoryPressureLevel =
memory_pressure::MemoryPressureCalculator::MemoryPressureLevel;
// Labels a crash report to the server as a hang report.
const wchar_t kHangReportCrashKey[] = L"hang-report";
// Helper function for determining the crash server to use. Defaults to the
// standard crash server, but can be overridden via an environment variable.
// Enables easy integration testing.
base::string16 GetKaskoCrashServerUrl() {
static const char kKaskoCrashServerUrl[] = "KASKO_CRASH_SERVER_URL";
static const wchar_t kDefaultKaskoCrashServerUrl[] =
L"https://clients2.google.com/cr/report";
std::unique_ptr<base::Environment> env(base::Environment::Create());
std::string env_var;
if (env->GetVar(kKaskoCrashServerUrl, &env_var)) {
return base::UTF8ToUTF16(env_var);
}
return kDefaultKaskoCrashServerUrl;
}
// Helper function for determining the crash reports directory to use. Defaults
// to the browser data directory, but can be overridden via an environment
// variable. Enables easy integration testing.
base::FilePath GetKaskoCrashReportsBaseDir(
const base::char16* browser_data_directory) {
static const char kKaskoCrashReportBaseDir[] = "KASKO_CRASH_REPORTS_BASE_DIR";
std::unique_ptr<base::Environment> env(base::Environment::Create());
std::string env_var;
if (env->GetVar(kKaskoCrashReportBaseDir, &env_var)) {
return base::FilePath(base::UTF8ToUTF16(env_var));
}
return base::FilePath(browser_data_directory);
}
struct EventSourceDeregisterer {
using pointer = HANDLE;
void operator()(HANDLE event_source_handle) const {
if (!::DeregisterEventSource(event_source_handle))
DPLOG(ERROR) << "DeregisterEventSource";
}
};
using ScopedEventSourceHandle =
std::unique_ptr<HANDLE, EventSourceDeregisterer>;
struct SidDeleter {
using pointer = PSID;
void operator()(PSID sid) const {
if (::LocalFree(sid) != nullptr)
DPLOG(ERROR) << "LocalFree";
}
};
using ScopedSid = std::unique_ptr<PSID, SidDeleter>;
void OnCrashReportUpload(void* context,
const base::char16* report_id,
const base::char16* minidump_path,
const base::char16* const* keys,
const base::char16* const* values) {
// Open the event source.
ScopedEventSourceHandle event_source_handle(
::RegisterEventSource(nullptr, L"Chrome"));
if (!event_source_handle) {
PLOG(ERROR) << "RegisterEventSource";
return;
}
// Get the user's SID for the log record.
base::string16 sid_string;
PSID sid = nullptr;
if (base::win::GetUserSidString(&sid_string) && !sid_string.empty()) {
if (!::ConvertStringSidToSid(sid_string.c_str(), &sid))
DPLOG(ERROR) << "ConvertStringSidToSid";
DCHECK(sid);
}
// Ensure cleanup on scope exit.
ScopedSid scoped_sid;
if (sid)
scoped_sid.reset(sid);
// Generate the message.
// Note that the format of this message must match the consumer in
// chrome/browser/crash_upload_list_win.cc.
base::string16 message =
L"Crash uploaded. Id=" + base::string16(report_id) + L".";
// Matches Omaha.
const int kCrashUploadEventId = 2;
// Report the event.
const base::char16* strings[] = {message.c_str()};
if (!::ReportEvent(event_source_handle.get(), EVENTLOG_INFORMATION_TYPE,
0, // category
kCrashUploadEventId, sid,
1, // count
0, strings, nullptr)) {
DPLOG(ERROR);
}
}
void AddCrashKey(const wchar_t *key, const wchar_t *value,
std::vector<kasko::api::CrashKey> *crash_keys) {
DCHECK(key);
DCHECK(value);
DCHECK(crash_keys);
crash_keys->resize(crash_keys->size() + 1);
kasko::api::CrashKey& crash_key = crash_keys->back();
base::wcslcpy(crash_key.name, key, kasko::api::CrashKey::kNameMaxLength);
base::wcslcpy(crash_key.value, value, kasko::api::CrashKey::kValueMaxLength);
}
// Get the |process| and the |thread_id| of the node inside the |wait_chain|
// that is of type ThreadType and belongs to a process that is valid for the
// capture of a crash dump. Returns true if such a node was found.
bool GetLastValidNodeInfo(const base::win::WaitChainNodeVector& wait_chain,
base::Process* process,
DWORD* thread_id) {
// The last thread in the wait chain is nominated as the hung thread.
base::win::WaitChainNodeVector::const_reverse_iterator it;
for (it = wait_chain.rbegin(); it != wait_chain.rend(); ++it) {
if (it->ObjectType != WctThreadType)
continue;
auto current_process = base::Process::Open(it->ThreadObject.ProcessId);
if (EnsureTargetProcessValidForCapture(current_process)) {
*process = std::move(current_process);
*thread_id = it->ThreadObject.ThreadId;
return true;
}
}
return false;
}
// Adds the entire wait chain to |crash_keys|.
//
// As an example (key : value):
// hung-process-wait-chain-00 : Thread 10242 in process 4554 with status Blocked
// hung-process-wait-chain-01 : Lock of type ThreadWait with status Owned
// hung-process-wait-chain-02 : Thread 77221 in process 4554 with status Blocked
//
void AddWaitChainToCrashKeys(const base::win::WaitChainNodeVector& wait_chain,
std::vector<kasko::api::CrashKey>* crash_keys) {
for (size_t i = 0; i < wait_chain.size(); i++) {
AddCrashKey(
base::StringPrintf(L"hung-process-wait-chain-%02" PRIuS, i).c_str(),
base::win::WaitChainNodeToString(wait_chain[i]).c_str(), crash_keys);
}
}
base::FilePath GetExeFilePathForProcess(const base::Process& process) {
wchar_t exe_name[MAX_PATH];
DWORD exe_name_len = arraysize(exe_name);
// Note: requesting the Win32 path format.
if (::QueryFullProcessImageName(process.Handle(), 0, exe_name,
&exe_name_len) == 0) {
DPLOG(ERROR) << "Failed to get executable name for process";
return base::FilePath();
}
// QueryFullProcessImageName's documentation does not specify behavior when
// the buffer is too small, but we know that GetModuleFileNameEx succeeds and
// truncates the returned name in such a case. Given that paths of arbitrary
// length may exist, the conservative approach is to reject names when
// the returned length is that of the buffer.
if (exe_name_len > 0 && exe_name_len < arraysize(exe_name))
return base::FilePath(exe_name);
return base::FilePath();
}
// Adds the executable base name for each unique pid found in the |wait_chain|
// to the |crash_keys|.
void AddProcessExeNameToCrashKeys(
const base::win::WaitChainNodeVector& wait_chain,
std::vector<kasko::api::CrashKey>* crash_keys) {
std::set<DWORD> unique_pids;
for (size_t i = 0; i < wait_chain.size(); i += 2)
unique_pids.insert(wait_chain[i].ThreadObject.ProcessId);
for (DWORD pid : unique_pids) {
// This is racy on the pid but for the purposes of this function, some error
// threshold can be tolerated. Hopefully the race doesn't happen often.
base::Process process(
base::Process::OpenWithAccess(pid, PROCESS_QUERY_LIMITED_INFORMATION));
base::string16 exe_file_path = L"N/A";
if (process.IsValid())
exe_file_path = GetExeFilePathForProcess(process).BaseName().value();
AddCrashKey(
base::StringPrintf(L"hung-process-wait-chain-pid-%u", pid).c_str(),
exe_file_path.c_str(), crash_keys);
}
}
void AddSystemLoadInformation(std::vector<kasko::api::CrashKey>* crash_keys) {
DCHECK(crash_keys);
// Add memory pressure level.
memory_pressure::DirectMemoryPressureCalculator memory_calculator;
const wchar_t* memory_pressure_level = L"";
switch (memory_calculator.CalculateCurrentPressureLevel()) {
case MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_NONE:
memory_pressure_level = L"none-or-unknown";
break;
case MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_MODERATE:
memory_pressure_level = L"moderate";
break;
case MemoryPressureLevel::MEMORY_PRESSURE_LEVEL_CRITICAL:
memory_pressure_level = L"critical";
break;
}
AddCrashKey(L"memory-pressure", memory_pressure_level, crash_keys);
// Add measures of cpu and disk load.
chrome_watcher::SystemLoadEstimator::Estimate load_estimate = {};
if (!chrome_watcher::SystemLoadEstimator::Measure(&load_estimate))
return;
AddCrashKey(L"cpu-load-percent",
base::IntToString16(load_estimate.cpu_load_pct).c_str(),
crash_keys);
AddCrashKey(L"disk-idle-percent",
base::IntToString16(load_estimate.disk_idle_pct).c_str(),
crash_keys);
AddCrashKey(L"disk-avg-queue-len",
base::IntToString16(load_estimate.avg_disk_queue_len).c_str(),
crash_keys);
}
} // namespace
bool InitializeKaskoReporter(const base::string16& endpoint,
const base::char16* browser_data_directory) {
base::string16 crash_server = GetKaskoCrashServerUrl();
base::FilePath crash_reports_base_dir =
GetKaskoCrashReportsBaseDir(browser_data_directory);
return kasko::api::InitializeReporter(
endpoint.c_str(),
crash_server.c_str(),
crash_reports_base_dir.Append(L"Crash Reports").value().c_str(),
crash_reports_base_dir.Append(kPermanentlyFailedReportsSubdir)
.value()
.c_str(),
&OnCrashReportUpload,
nullptr);
}
void ShutdownKaskoReporter() {
kasko::api::ShutdownReporter();
}
bool EnsureTargetProcessValidForCapture(const base::Process& process) {
// Ensure the target process's executable is inside the current Chrome
// directory.
base::FilePath chrome_dir;
if (!PathService::Get(base::DIR_EXE, &chrome_dir))
return false;
return chrome_dir.IsParent(GetExeFilePathForProcess(process));
}
void DumpHungProcess(DWORD main_thread_id, const base::string16& channel,
const base::char16* hang_type,
const base::Process& process) {
// Read the Crashpad module annotations for the process.
std::vector<kasko::api::CrashKey> annotations;
crash_reporter::ReadMainModuleAnnotationsForKasko(process, &annotations);
// Label the report as a hang report.
AddCrashKey(kHangReportCrashKey, hang_type, &annotations);
// Note: system load is measured as early as possible, as it is potentially
// more volatile than wait chain information.
// TODO(manzagop): consider continuous load observation, instead of punctual
// observation, which may fail to observe load.
AddSystemLoadInformation(&annotations);
// Use the Wait Chain Traversal API to determine the hung thread. Defaults to
// UI thread on error. The wait chain may point to a different thread in a
// different process for the hung thread.
DWORD hung_thread_id = main_thread_id;
base::Process hung_process = process.Duplicate();
base::win::WaitChainNodeVector wait_chain;
bool is_deadlock = false;
base::string16 thread_chain_failure_reason;
DWORD thread_chain_last_error = ERROR_SUCCESS;
if (base::win::GetThreadWaitChain(main_thread_id, &wait_chain, &is_deadlock,
&thread_chain_failure_reason,
&thread_chain_last_error)) {
bool found_valid_node =
GetLastValidNodeInfo(wait_chain, &hung_process, &hung_thread_id);
DCHECK(found_valid_node);
// Add some interesting data about the wait chain to the crash keys.
AddCrashKey(L"hung-process-is-deadlock", is_deadlock ? L"true" : L"false",
&annotations);
AddWaitChainToCrashKeys(wait_chain, &annotations);
AddProcessExeNameToCrashKeys(wait_chain, &annotations);
} else {
// The call to GetThreadWaitChain() failed. Include the reason inside the
// report using crash keys.
// TODO(pmonette): Remove this when UMA is added to wait_chain.cc.
AddCrashKey(L"hung-process-wait-chain-failure-reason",
thread_chain_failure_reason.c_str(), &annotations);
AddCrashKey(L"hung-process-wait-chain-last-error",
base::UintToString16(thread_chain_last_error).c_str(),
&annotations);
}
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 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 hung_thread(::OpenThread(
THREAD_SUSPEND_RESUME | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION,
FALSE, hung_thread_id));
bool have_context = false;
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(hung_thread.Get(), &thread_context) == TRUE)
have_context = true;
::ResumeThread(hung_thread.Get());
}
}
// TODO(manzagop): consider making the dump-type channel-dependent.
if (have_context) {
kasko::api::SendReportForProcess(
hung_process.Handle(), hung_thread_id, &exception_pointers,
kasko::api::LARGER_DUMP_TYPE, key_buffers.data(), value_buffers.data());
} else {
kasko::api::SendReportForProcess(hung_process.Handle(), 0, nullptr,
kasko::api::LARGER_DUMP_TYPE,
key_buffers.data(), value_buffers.data());
}
}
chrome/chrome_watcher/kasko_util.h deleted 100644 → 0
View file @ df911bda
// Copyright 2016 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.
#ifndef CHROME_CHROME_WATCHER_KASKO_UTIL_H_
#define CHROME_CHROME_WATCHER_KASKO_UTIL_H_
#include <windows.h>
#include "base/process/process.h"
#include "base/strings/string16.h"
// Initialize a Kasko reporter.
bool InitializeKaskoReporter(const base::string16& endpoint,
const base::char16* browser_data_directory);
// Shut down a Kasko reporter.
void ShutdownKaskoReporter();
// Ensure that a process is a valid target for report capture. This is to
// defend against against races that exist in getting a Process from a window
// name (potential HWND and process id recycling).
bool EnsureTargetProcessValidForCapture(const base::Process& process);
// Dumps a process. A crash key will be added to the report, labelling it as a
// hang report.
void DumpHungProcess(DWORD main_thread_id, const base::string16& channel,
const base::char16* hang_type,
const base::Process& process);
#endif // CHROME_CHROME_WATCHER_KASKO_UTIL_H_
third_party/kasko/BUILD.gn
View file @ 32d4643f
...@@ -9,11 +9,7 @@ import("//third_party/kasko/kasko.gni") ...@@ -9,11 +9,7 @@ import("//third_party/kasko/kasko.gni")
# GYP version: target 'kasko_features' in third_party/kasko/kasko.gyp # GYP version: target 'kasko_features' in third_party/kasko/kasko.gyp
buildflag_header("kasko_features") { buildflag_header("kasko_features") {
header = "kasko_features.h" header = "kasko_features.h"
flags = [ flags = [ "ENABLE_KASKO=$enable_kasko" ]
"ENABLE_KASKO=$enable_kasko",
"ENABLE_KASKO_HANG_REPORTS=$enable_kasko_hang_reports",
"ENABLE_KASKO_FAILED_RDV_REPORTS=$enable_kasko_failed_rdv_reports",
]
} }
if (enable_kasko) { if (enable_kasko) {
......
third_party/kasko/kasko.gni
View file @ 32d4643f
...@@ -4,17 +4,6 @@ ...@@ -4,17 +4,6 @@
import("//build/config/sanitizers/sanitizers.gni") import("//build/config/sanitizers/sanitizers.gni")
declare_args() {
# Enable the reporting of browser hangs with Kasko.
# TODO(pmonette): ensure hang reporting is disabled for syzyasan builds.
enable_kasko_hang_reports = false
# Enable the reporting of failed browser rendez-vous with Kasko.
# TODO(pmonette): ensure hang reporting is disabled for syzyasan builds.
enable_kasko_failed_rdv_reports = false
}
# Enable the Kasko crash reporter. Enabled by default on Syzyasan official # Enable the Kasko crash reporter. Enabled by default on Syzyasan official
# build. # build.
enable_kasko = (is_official_build && is_syzyasan) || enable_kasko = is_official_build && is_syzyasan
enable_kasko_hang_reports || enable_kasko_failed_rdv_reports
third_party/kasko/kasko.gyp
View file @ 32d4643f
...@@ -9,8 +9,6 @@ ...@@ -9,8 +9,6 @@
'buildflag_header_path': 'third_party/kasko/kasko_features.h', 'buildflag_header_path': 'third_party/kasko/kasko_features.h',
'buildflag_flags': [ 'buildflag_flags': [
'ENABLE_KASKO=<(kasko)', 'ENABLE_KASKO=<(kasko)',
'ENABLE_KASKO_HANG_REPORTS=<(kasko_hang_reports)',
'ENABLE_KASKO_FAILED_RDV_REPORTS=<(kasko_failed_rdv_reports)',
], ],
}, },
}, },
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment