1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/crash/core/app/fallback_crash_handling_win.h"
#include <memory>
#include "base/base_switches.h"
#include "base/check.h"
#include "base/command_line.h"
#include "base/notreached.h"
#include "components/app_launch_prefetch/app_launch_prefetch.h"
#include "components/crash/core/app/crash_switches.h"
#include "components/crash/core/app/fallback_crash_handler_launcher_win.h"
#include "components/crash/core/app/fallback_crash_handler_win.h"
namespace crash_reporter {
namespace switches {
const char kFallbackCrashHandler[] = "fallback-handler";
}
const uint32_t kFallbackCrashTerminationCode = 0xFFFF8001;
namespace {
// Intentionally leaked on program exit.
FallbackCrashHandlerLauncher* g_fallback_crash_handler_launcher = nullptr;
LONG WINAPI FallbackUnhandledExceptionFilter(EXCEPTION_POINTERS* exc_ptrs) {
if (!g_fallback_crash_handler_launcher)
return EXCEPTION_CONTINUE_SEARCH;
return g_fallback_crash_handler_launcher->LaunchAndWaitForHandler(exc_ptrs);
}
} // namespace
bool SetupFallbackCrashHandling(const base::CommandLine& command_line) {
DCHECK(!g_fallback_crash_handler_launcher);
// Run the same program.
base::CommandLine base_command_line(command_line.GetProgram());
base_command_line.AppendSwitchASCII("type", switches::kFallbackCrashHandler);
// This is to support testing under gtest.
if (command_line.HasSwitch(::switches::kTestChildProcess)) {
base_command_line.AppendSwitchASCII(
::switches::kTestChildProcess,
command_line.GetSwitchValueASCII(::switches::kTestChildProcess));
}
// All Chrome processes need a prefetch argument.
base_command_line.AppendArgNative(app_launch_prefetch::GetPrefetchSwitch(
app_launch_prefetch::SubprocessType::kCrashpadFallback));
// Get the database path.
base::FilePath database_path = command_line.GetSwitchValuePath("database");
if (database_path.empty()) {
NOTREACHED();
}
std::unique_ptr<FallbackCrashHandlerLauncher> fallback_launcher(
new FallbackCrashHandlerLauncher());
if (!fallback_launcher->Initialize(base_command_line, database_path)) {
NOTREACHED();
}
// This is necessary because chrome_elf stubs out the
// SetUnhandledExceptionFilter in the IAT of chrome.exe.
using SetUnhandledExceptionFilterFunction =
PTOP_LEVEL_EXCEPTION_FILTER(WINAPI*)(PTOP_LEVEL_EXCEPTION_FILTER filter);
HMODULE kernel32 = GetModuleHandle(L"kernel32.dll");
if (!kernel32)
return false;
SetUnhandledExceptionFilterFunction set_unhandled_exception_filter =
reinterpret_cast<SetUnhandledExceptionFilterFunction>(
GetProcAddress(kernel32, "SetUnhandledExceptionFilter"));
if (!set_unhandled_exception_filter)
return false;
// Success, pass ownership to the global.
g_fallback_crash_handler_launcher = fallback_launcher.release();
set_unhandled_exception_filter(&FallbackUnhandledExceptionFilter);
return true;
}
int RunAsFallbackCrashHandler(const base::CommandLine& command_line,
std::string product_name,
std::string version,
std::string channel_name) {
FallbackCrashHandler fallback_handler;
if (!fallback_handler.ParseCommandLine(command_line)) {
// TODO(siggi): Figure out how to UMA from this process, if need be.
return 1;
}
if (!fallback_handler.GenerateCrashDump(
product_name, version, channel_name,
crash_reporter::switches::kCrashpadHandler)) {
// TODO(siggi): Figure out how to UMA from this process, if need be.
return 2;
}
if (!fallback_handler.process().Terminate(kFallbackCrashTerminationCode,
false)) {
return 3;
}
return 0;
}
} // namespace crash_reporter
|
