blob: 01f63f364ddd88d54a1a1a0a7deff59e1366f842 [file] [log] [blame]
// Copyright 2017 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/app/fallback_crash_handler_win.h"
#include <dbghelp.h>
#include <psapi.h>
#include <algorithm>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "base/command_line.h"
#include "base/files/file.h"
#include "base/files/file_util.h"
#include "base/macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/process/process_handle.h"
#include "base/strings/string_number_conversions.h"
#include "base/win/scoped_handle.h"
#include "base/win/win_util.h"
#include "third_party/crashpad/crashpad/client/crash_report_database.h"
#include "third_party/crashpad/crashpad/client/settings.h"
#include "third_party/crashpad/crashpad/minidump/minidump_extensions.h"
namespace crash_reporter {
namespace {
using FilePosition = uint32_t;
const FilePosition kInvalidFilePos = static_cast<FilePosition>(-1);
using StringStringMap = std::map<std::string, std::string>;
void AcquireMemoryMetrics(const base::Process& process,
StringStringMap* crash_keys) {
// Grab the process private memory.
// This is best effort, though really shouldn't ever fail.
PROCESS_MEMORY_COUNTERS_EX process_memory = {sizeof(process_memory)};
if (GetProcessMemoryInfo(
sizeof(process_memory))) {
// This is in units of bytes, re-scale to pages for consistency with
// system metrics.
const uint64_t kPageSize = 4096;
base::Uint64ToString(process_memory.PrivateUsage / kPageSize)));
base::Uint64ToString(process_memory.PeakWorkingSetSize / kPageSize)));
base::Uint64ToString(process_memory.PeakPagefileUsage / kPageSize)));
// Grab system commit memory. Also best effort.
PERFORMANCE_INFORMATION perf_info = {sizeof(perf_info)};
if (GetPerformanceInfo(&perf_info, sizeof(perf_info))) {
// Record the remaining committable memory and the limit. This is in units
// of system pages.
base::UintToString(perf_info.CommitLimit - perf_info.CommitTotal)));
"SystemCommitLimit", base::UintToString(perf_info.CommitLimit)));
// This class is a helper to edit minidump files written by MiniDumpWriteDump.
// It assumes the minidump file it operates on has a directory entry pointing to
// a CrashpadInfo entry, which it updates to point to the SimpleDictionary data
// it appends to the file contents.
class MinidumpUpdater {
// Reads the existing directory from |file|.
bool Initialize(base::File* file);
// Appends the simple dictionary with |crash_keys| to the file, and updates
// the CrashpadInfo with its location.
bool AppendSimpleDictionary(const StringStringMap& crash_keys);
// Writes |data_len| bytes from |data| to the file at the current location.
bool WriteData(const void* data, size_t data_len);
bool WriteAndAdvance(const void* data,
size_t data_len,
FilePosition* position);
base::File* file_;
std::vector<MINIDUMP_DIRECTORY> directory_;
MinidumpUpdater::MinidumpUpdater() : file_(nullptr) {}
bool MinidumpUpdater::Initialize(base::File* file) {
DCHECK(file && file->IsValid());
// Read the file header.
MINIDUMP_HEADER header = {};
int bytes_read =
file->Read(0, reinterpret_cast<char*>(&header), sizeof(header));
if (bytes_read != sizeof(header))
return false;
if (header.Signature != MINIDUMP_SIGNATURE || header.NumberOfStreams == 0)
return false;
// Read the stream directory.
int bytes_to_read = header.NumberOfStreams * sizeof(directory_[0]);
bytes_read =
reinterpret_cast<char*>(&directory_[0]), bytes_to_read);
if (bytes_read != bytes_to_read)
return false;
// Crashpad has some fairly unreasonable checking on the minidump header and
// directory. Match with those checks for now to allow Crashpad to read the
// CrashpadInfo and upload these dumps.
// Start by removing any unused directory entries.
// TODO(siggi): Fix Crashpad to ignore unused streams.
directory_.erase(std::remove_if(directory_.begin(), directory_.end(),
[](const MINIDUMP_DIRECTORY& entry) {
return entry.StreamType == UnusedStream;
// Update the header.
// TODO(siggi): Fix Crashpad's version checking.
header.Version = MINIDUMP_VERSION;
header.NumberOfStreams = base::saturated_cast<ULONG32>(directory_.size());
// Write back the potentially shortened and packed dictionary.
int bytes_to_write = header.NumberOfStreams * sizeof(directory_[0]);
int bytes_written = file->Write(header.StreamDirectoryRva,
reinterpret_cast<const char*>(&directory_[0]),
if (bytes_written != bytes_to_write)
return false;
// Write back the header.
bytes_written =
file->Write(0, reinterpret_cast<const char*>(&header), sizeof(header));
if (bytes_written != sizeof(header))
return false;
// Success, stash the file.
file_ = file;
return true;
bool MinidumpUpdater::AppendSimpleDictionary(
const StringStringMap& crash_keys) {
// Start by finding the Crashpad directory entry and reading the CrashpadInfo.
FilePosition crashpad_info_pos = 0;
crashpad::MinidumpCrashpadInfo crashpad_info;
for (const auto& entry : directory_) {
if (entry.StreamType == crashpad::kMinidumpStreamTypeCrashpadInfo) {
// This file is freshly written, so it must contain the same version
// CrashpadInfo structure this code compiled against.
if (entry.Location.DataSize != sizeof(crashpad_info))
return false;
crashpad_info_pos = entry.Location.Rva;
// No CrashpadInfo directory entry found.
if (crashpad_info_pos == 0)
return false;
int bytes_read =
file_->Read(crashpad_info_pos, reinterpret_cast<char*>(&crashpad_info),
if (bytes_read != sizeof(crashpad_info))
return false;
if (crashpad_info.version != crashpad::MinidumpCrashpadInfo::kVersion)
return false;
// Seek to the tail of the file, where we're going to extend it.
FilePosition next_available_byte = file_->Seek(base::File::FROM_END, 0);
if (next_available_byte == kInvalidFilePos)
return false;
// Write the key/value pairs and collect their locations.
std::vector<crashpad::MinidumpSimpleStringDictionaryEntry> entries;
for (const auto& kv : crash_keys) {
// The key of a key/value pair should never be empty.
crashpad::MinidumpSimpleStringDictionaryEntry entry = {0};
// Skip this key/value if the value is empty.
if (!kv.second.empty()) {
entry.key = next_available_byte;
uint32_t key_len = base::saturated_cast<uint32_t>(kv.first.size());
if (!WriteAndAdvance(&key_len, sizeof(key_len), &next_available_byte) ||
!WriteAndAdvance(&kv.first[0], key_len, &next_available_byte)) {
return false;
entry.value = next_available_byte;
uint32_t value_len = base::saturated_cast<uint32_t>(kv.second.size());
if (!WriteAndAdvance(&value_len, sizeof(value_len),
&next_available_byte) ||
!WriteAndAdvance(&kv.second[0], value_len, &next_available_byte)) {
return false;
// Write the dictionary array itself - note the array is count-prefixed.
FilePosition dict_pos = next_available_byte;
uint32_t entry_count = base::saturated_cast<uint32_t>(entries.size());
if (!WriteAndAdvance(&entry_count, sizeof(entry_count),
&next_available_byte) ||
!WriteAndAdvance(&entries[0], entry_count * sizeof(entries[0]),
&next_available_byte)) {
return false;
// Touch up the CrashpadInfo and write it back to the file.
crashpad_info.simple_annotations.DataSize = next_available_byte - dict_pos;
crashpad_info.simple_annotations.Rva = dict_pos;
int bytes_written = file_->Write(
crashpad_info_pos, reinterpret_cast<const char*>(&crashpad_info),
if (bytes_written != sizeof(crashpad_info))
return false;
return true;
bool MinidumpUpdater::WriteData(const void* data, size_t data_len) {
DCHECK_NE(0U, data_len);
if (data_len > INT_MAX)
return false;
int bytes_to_write = static_cast<int>(data_len);
int written_bytes = file_->WriteAtCurrentPos(
reinterpret_cast<const char*>(data), bytes_to_write);
if (written_bytes == -1)
return false;
return true;
bool MinidumpUpdater::WriteAndAdvance(const void* data,
size_t data_len,
FilePosition* position) {
DCHECK_EQ(file_->Seek(base::File::FROM_CURRENT, 0), *position);
if (!WriteData(data, data_len))
return false;
*position += base::saturated_cast<FilePosition>(data_len);
return true;
// Writes a minidump file for |process| to |dump_file| with embedded
// CrashpadInfo, containing |crash_keys|, |client_id| and |report_id|.
// The |dump_file| must be open for read as well as write.
bool MiniDumpWriteDumpWithCrashpadInfo(const base::Process& process,
uint32_t minidump_type,
const StringStringMap& crash_keys,
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
base::File* dump_file) {
DCHECK(dump_file && dump_file->IsValid());
// The CrashpadInfo structure and its associated directory entry are injected
// into the minidump, to minimize the work to patching up the dump.
crashpad::MinidumpCrashpadInfo crashpad_info;
crashpad_info.version = crashpad::MinidumpCrashpadInfo::kVersion;
crashpad_info.client_id = client_id;
crashpad_info.report_id = report_id;
MINIDUMP_USER_STREAM crashpad_info_stream = {
crashpad::kMinidumpStreamTypeCrashpadInfo, // Type
sizeof(crashpad_info), // BufferSize
&crashpad_info // Buffer
1, // UserStreamCount
&crashpad_info_stream // UserStreamArray
// Write the minidump to the provided dump file.
if (!MiniDumpWriteDump(
process.Handle(), // Process handle.
process.Pid(), // Process Id.
dump_file->GetPlatformFile(), // File handle.
static_cast<MINIDUMP_TYPE>(minidump_type), // Minidump type.
exc_info, // Exception Param
&user_stream_info, // UserStreamParam,
nullptr)) { // CallbackParam
return false;
// Retouch the minidump to make it Crashpad compatible.
MinidumpUpdater updater;
if (!updater.Initialize(dump_file))
return false;
if (!updater.AppendSimpleDictionary(crash_keys))
return false;
return true;
// Appends the full contents of |source| to |dest| from the current position
// of |dest|.
bool AppendFileContents(base::File* source, base::PlatformFile dest) {
DCHECK(source && source->IsValid());
DCHECK_NE(base::kInvalidPlatformFile, dest);
// Rewind the source.
if (source->Seek(base::File::FROM_BEGIN, 0) == kInvalidFilePos)
return false;
std::vector<char> buf;
while (true) {
int bytes_read =
source->ReadAtCurrentPos(&buf[0], static_cast<int>(buf.size()));
if (bytes_read == -1)
return false;
if (bytes_read == 0)
DWORD bytes_written = 0;
// Due to handle instrumentation, the destination can't be wrapped in
// a base::File, so we go basic Win32 API here.
if (!WriteFile(dest, &buf[0], bytes_read, &bytes_written, nullptr) ||
static_cast<int>(bytes_written) != bytes_read) {
return false;
return true;
} // namespace
: thread_id_(base::kInvalidThreadId), exception_ptrs_(0UL) {}
FallbackCrashHandler::~FallbackCrashHandler() {}
bool FallbackCrashHandler::ParseCommandLine(const base::CommandLine& cmd_line) {
// Retrieve the handle to the process to dump.
unsigned int uint_process;
if (!base::StringToUint(cmd_line.GetSwitchValueASCII("process"),
&uint_process)) {
return false;
// Before taking ownership of the supposed handle, see whether it's really
// a process handle.
base::ProcessHandle process_handle = base::win::Uint32ToHandle(uint_process);
if (base::GetProcId(process_handle) == base::kNullProcessId)
return false;
// Retrieve the thread id argument.
unsigned int thread_id = 0;
if (!base::StringToUint(cmd_line.GetSwitchValueASCII("thread"), &thread_id)) {
return false;
thread_id_ = thread_id;
// Retrieve the "exception-pointers" argument.
uint64_t uint_exc_ptrs = 0;
if (!base::StringToUint64(cmd_line.GetSwitchValueASCII("exception-pointers"),
&uint_exc_ptrs)) {
return false;
exception_ptrs_ = static_cast<uintptr_t>(uint_exc_ptrs);
// Retrieve the "database" argument.
database_dir_ = cmd_line.GetSwitchValuePath("database");
if (database_dir_.empty())
return false;
// Everything checks out, take ownership of the process handle.
process_ = base::Process(process_handle);
return true;
bool FallbackCrashHandler::GenerateCrashDump(const std::string& product,
const std::string& version,
const std::string& channel,
const std::string& process_type) {
std::unique_ptr<crashpad::CrashReportDatabase> database =
if (!database)
return false;
crashpad::CrashReportDatabase::NewReport* report = nullptr;
crashpad::CrashReportDatabase::OperationStatus status =
if (status != crashpad::CrashReportDatabase::kNoError)
return false;
// Make sure we release the report on early exit.
crashpad::CrashReportDatabase::CallErrorWritingCrashReport on_error(
database.get(), report);
exc_info.ThreadId = thread_id_;
exc_info.ExceptionPointers =
exc_info.ClientPointers = TRUE; // ExceptionPointers in client.
// Mandatory crash keys. These will be read by Crashpad and used as
// http request parameters for the upload. Keys and values need to match
// server side configuration.
#if defined(ARCH_CPU_64_BITS)
const char* platform = "Win64";
const char* platform = "Win32";
std::map<std::string, std::string> crash_keys = {{"prod", product},
{"ver", version},
{"channel", channel},
{"plat", platform},
{"ptype", process_type}};
// Add memory metrics relating to system-wide and target process memory usage.
AcquireMemoryMetrics(process_, &crash_keys);
crashpad::UUID client_id;
crashpad::Settings* settings = database->GetSettings();
if (settings) {
// If GetSettings() or GetClientID() fails client_id will be left at its
// default value, all zeroes, which is appropriate.
base::FilePath dump_file_path;
if (!base::CreateTemporaryFile(&dump_file_path))
return false;
// Open the file with delete on close, to try and ensure it's cleaned up on
// any kind of failure.
base::File dump_file(dump_file_path, base::File::FLAG_OPEN |
base::File::FLAG_READ |
base::File::FLAG_WRITE |
if (!dump_file.IsValid())
return false;
uint32_t minidump_type = MiniDumpWithUnloadedModules |
MiniDumpWithProcessThreadData |
MiniDumpWithFullMemoryInfo |
// Capture more detail for canary and dev channels. The prefix search caters
// for the soon to be outdated "-m" suffixed multi-install channels.
if (channel.find("canary") == 0 || channel.find("dev") == 0)
minidump_type |= MiniDumpWithIndirectlyReferencedMemory;
// Write the minidump to the temp file, and then copy the data to the
// Crashpad-provided handle, as the latter is only open for write.
if (!MiniDumpWriteDumpWithCrashpadInfo(process_, minidump_type, &exc_info,
crash_keys, client_id, report->uuid,
&dump_file) ||
!AppendFileContents(&dump_file, report->handle)) {
return false;
crashpad::UUID report_id = {};
status = database->FinishedWritingCrashReport(report, &report_id);
if (status != crashpad::CrashReportDatabase::kNoError)
return false;
return true;
} // namespace crash_reporter