blob: 30222db2ce942df5147fd0edadaf01fe4d13ef73 [file] [log] [blame]
// 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.
// Note: aside from using windows headers to obtain the definitions of minidump
// structures, nothing here is windows specific. This seems like the best
// approach given this code is for temporary experimentation on Windows.
// Longer term, Crashpad will take over the minidump writing in this case as
// well.
#include "components/browser_watcher/postmortem_minidump_writer.h"
#include <windows.h> // NOLINT
#include <dbghelp.h>
#include <map>
#include <type_traits>
#include <vector>
#include "base/files/file_util.h"
#include "base/macros.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/safe_math.h"
#include "base/strings/string_piece.h"
#include "components/browser_watcher/minidump_user_streams.h"
#include "components/browser_watcher/stability_data_names.h"
#include "third_party/crashpad/crashpad/minidump/minidump_extensions.h"
namespace browser_watcher {
namespace {
struct ProductDetails {
std::string product;
std::string channel;
std::string platform;
std::string version;
bool GetStringFromTypedValueMap(
const google::protobuf::Map<std::string, TypedValue>& map,
const std::string& key,
std::string* out) {
auto it = map.find(key);
if (it == map.end())
return false;
const TypedValue& value = it->second;
if (value.value_case() != TypedValue::kStringValue)
return false;
*out = value.string_value();
return true;
bool GetProductDetails(
const google::protobuf::Map<std::string, TypedValue>& global_data,
ProductDetails* product_details) {
if (!GetStringFromTypedValueMap(global_data, kStabilityProduct,
return false;
if (!GetStringFromTypedValueMap(global_data, kStabilityChannel,
return false;
if (!GetStringFromTypedValueMap(global_data, kStabilityPlatform,
return false;
return GetStringFromTypedValueMap(global_data, kStabilityVersion,
int64_t GetFileOffset(base::File* file) {
return file->Seek(base::File::FROM_CURRENT, 0LL);
// Returns true if the file is empty, and false if the file is not empty or if
// there is an error.
bool IsFileEmpty(base::File* file) {
int64_t end = file->Seek(base::File::FROM_END, 0LL);
return end == 0LL;
// A class with functionality for writing minimal minidump containers to wrap
// postmortem stability reports.
// TODO(manzagop): remove this class once Crashpad takes over writing postmortem
// minidumps.
// TODO(manzagop): revisit where the module information should be transported,
// in the protocol buffer or in a module stream.
class PostmortemMinidumpWriter {
// DO NOT CHANGE VALUES. This is logged persistently in a histogram.
enum WriteStatus {
// Write to |minidump_file| a minimal minidump that wraps |report|. Returns
// true on success, false otherwise.
// Note: the caller owns |minidump_file| and is responsible for keeping it
// valid for this object's lifetime. |minidump_file| is expected to be empty
// and a binary stream.
bool WriteDump(base::PlatformFile minidump_file,
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
StabilityReport* report);
// An offset within a minidump file. Note: using this type to avoid including
// windows.h and relying on the RVA type.
using FilePosition = uint32_t;
// The minidump header is always located at the head.
static const FilePosition kHeaderPos = 0U;
bool WriteDumpImpl(const StabilityReport& report,
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
const ProductDetails& product_details);
bool AppendCrashpadInfo(const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
const std::map<std::string, std::string>& crash_keys);
bool AppendCrashpadDictionaryEntry(
const std::string& key,
const std::string& value,
std::vector<crashpad::MinidumpSimpleStringDictionaryEntry>* entries);
// Allocate |size_bytes| within the minidump. On success, |pos| contains the
// location of the allocation. Returns true on success, false otherwise.
bool Allocate(size_t size_bytes, FilePosition* pos);
// Seeks |cursor_|. The seek operation is kept separate from the write in
// order to make the call explicit. Seek operations can be costly and should
// be avoided.
bool SeekCursor(FilePosition destination);
// Write to pre-allocated space.
// Note: |pos| must match |cursor_|.
template <class DataType>
bool Write(FilePosition pos, const DataType& data);
bool WriteBytes(FilePosition pos, size_t size_bytes, const char* data);
// Allocate space for and write the contents of |data|. On success, |pos|
// contains the location of the write. Returns true on success, false
// otherwise.
template <class DataType>
bool Append(const DataType& data, FilePosition* pos);
template <class DataType>
bool AppendVec(const std::vector<DataType>& data, FilePosition* pos);
bool AppendUtf8String(base::StringPiece data, FilePosition* pos);
bool AppendBytes(base::StringPiece data, FilePosition* pos);
void RegisterDirectoryEntry(uint32_t stream_type,
FilePosition pos,
uint32_t size);
// The next allocatable FilePosition.
FilePosition next_available_byte_;
// Storage for the directory during writes.
std::vector<MINIDUMP_DIRECTORY> directory_;
// The file to write to. Only valid within the scope of a call to WriteDump.
base::File* minidump_file_;
// This function's purpose is to limit code / data size caused by uma macros.
void RecordWriteDumpStatus(PostmortemMinidumpWriter::WriteStatus status) {
UMA_HISTOGRAM_ENUMERATION("ActivityTracker.Collect.WriteDumpStatus", status,
: next_available_byte_(0U), minidump_file_(nullptr) {}
PostmortemMinidumpWriter::~PostmortemMinidumpWriter() {
DCHECK_EQ(nullptr, minidump_file_);
bool PostmortemMinidumpWriter::WriteDump(
base::PlatformFile minidump_platform_file,
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
StabilityReport* report) {
DCHECK_NE(base::kInvalidPlatformFile, minidump_platform_file);
DCHECK_EQ(0U, next_available_byte_);
DCHECK_EQ(nullptr, minidump_file_);
// Ensure the report contains the crasher's product details.
ProductDetails product_details = {};
if (!GetProductDetails(report->global_data(), &product_details)) {
// The report is missing the basic information to determine the affected
// version. Ignore the report.
return false;
// No need to keep the version details inside the report.
// We do not own |minidump_platform_file|, but we want to rely on base::File's
// API, and so we need to duplicate it.
HANDLE duplicated_handle;
BOOL duplicate_success = ::DuplicateHandle(
::GetCurrentProcess(), minidump_platform_file, ::GetCurrentProcess(),
&duplicated_handle, 0, FALSE, DUPLICATE_SAME_ACCESS);
if (!duplicate_success) {
return false;
base::File minidump_file(duplicated_handle);
minidump_file_ = &minidump_file;
DCHECK_EQ(0LL, GetFileOffset(minidump_file_));
// Write the minidump, then reset members.
bool success = WriteDumpImpl(*report, client_id, report_id, product_details);
next_available_byte_ = 0U;
minidump_file_ = nullptr;
RecordWriteDumpStatus(success ? SUCCESS : FAILED);
return success;
bool PostmortemMinidumpWriter::WriteDumpImpl(
const StabilityReport& report,
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
const ProductDetails& product_details) {
// Allocate space for the header and seek the cursor.
FilePosition pos = 0U;
if (!Allocate(sizeof(MINIDUMP_HEADER), &pos))
return false;
if (!SeekCursor(sizeof(MINIDUMP_HEADER)))
return false;
DCHECK_EQ(kHeaderPos, pos);
// Write the proto to the file.
std::string serialized_report;
if (!report.SerializeToString(&serialized_report))
return false;
FilePosition report_pos = 0U;
if (!AppendBytes(serialized_report, &report_pos))
return false;
// The directory entry for the stability report's stream.
RegisterDirectoryEntry(kStabilityReportStreamType, report_pos,
// Write mandatory crash keys. These will be read by crashpad and used as
// http request parameters for the upload. Keys and values should match
// server side configuration.
// TODO(manzagop): use product and version from the stability report. The
// current executable's values are an (imperfect) proxy.
std::map<std::string, std::string> crash_keys = {
{"prod", product_details.product + "_Postmortem"},
{"ver", product_details.version},
{"plat", product_details.platform}};
if (!AppendCrashpadInfo(client_id, report_id, crash_keys))
return false;
// Write the directory.
FilePosition directory_pos = 0U;
if (!AppendVec(directory_, &directory_pos))
return false;
// Write the header.
header.Signature = MINIDUMP_SIGNATURE;
header.Version = MINIDUMP_VERSION;
header.NumberOfStreams = directory_.size();
header.StreamDirectoryRva = directory_pos;
if (!SeekCursor(0U))
return false;
return Write(kHeaderPos, header);
bool PostmortemMinidumpWriter::AppendCrashpadInfo(
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
const std::map<std::string, std::string>& crash_keys) {
// Write the crash keys as the contents of a crashpad dictionary.
std::vector<crashpad::MinidumpSimpleStringDictionaryEntry> entries;
for (const auto& crash_key : crash_keys) {
if (!AppendCrashpadDictionaryEntry(crash_key.first, crash_key.second,
&entries)) {
return false;
// Write the dictionary's index.
FilePosition dict_pos = 0U;
uint32_t entry_count = entries.size();
if (entry_count > 0) {
if (!Append(entry_count, &dict_pos))
return false;
FilePosition unused_pos = 0U;
if (!AppendVec(entries, &unused_pos))
return false;
MINIDUMP_LOCATION_DESCRIPTOR simple_annotations = {0};
simple_annotations.DataSize = 0U;
if (entry_count > 0)
simple_annotations.DataSize = next_available_byte_ - dict_pos;
// Note: an RVA of 0 indicates the absence of a dictionary.
simple_annotations.Rva = dict_pos;
// Write the crashpad info.
crashpad::MinidumpCrashpadInfo crashpad_info;
crashpad_info.version = crashpad::MinidumpCrashpadInfo::kVersion;
crashpad_info.report_id = report_id;
crashpad_info.client_id = client_id;
crashpad_info.simple_annotations = simple_annotations;
// Note: module_list is left at 0, which means none.
FilePosition crashpad_pos = 0U;
if (!Append(crashpad_info, &crashpad_pos))
return false;
// Append a directory entry for the crashpad info stream.
crashpad_pos, sizeof(crashpad::MinidumpCrashpadInfo));
return true;
bool PostmortemMinidumpWriter::AppendCrashpadDictionaryEntry(
const std::string& key,
const std::string& value,
std::vector<crashpad::MinidumpSimpleStringDictionaryEntry>* entries) {
DCHECK_NE(nullptr, entries);
FilePosition key_pos = 0U;
if (!AppendUtf8String(key, &key_pos))
return false;
FilePosition value_pos = 0U;
if (!AppendUtf8String(value, &value_pos))
return false;
crashpad::MinidumpSimpleStringDictionaryEntry entry = {0};
entry.key = key_pos;
entry.value = value_pos;
return true;
bool PostmortemMinidumpWriter::Allocate(size_t size_bytes, FilePosition* pos) {
*pos = next_available_byte_;
base::CheckedNumeric<FilePosition> next = next_available_byte_;
next += size_bytes;
if (!next.IsValid())
return false;
next_available_byte_ += size_bytes;
return true;
bool PostmortemMinidumpWriter::SeekCursor(FilePosition destination) {
DCHECK_NE(nullptr, minidump_file_);
// Validate the write does not extend past the allocated space.
if (destination > next_available_byte_)
return false;
int64_t new_pos = minidump_file_->Seek(base::File::FROM_BEGIN,
return new_pos != -1;
template <class DataType>
bool PostmortemMinidumpWriter::Write(FilePosition pos, const DataType& data) {
"restricted to trivially copyable");
return WriteBytes(pos, sizeof(data), reinterpret_cast<const char*>(&data));
bool PostmortemMinidumpWriter::WriteBytes(FilePosition pos,
size_t size_bytes,
const char* data) {
DCHECK_NE(nullptr, minidump_file_);
DCHECK_EQ(static_cast<int64_t>(pos), GetFileOffset(minidump_file_));
// Validate the write does not extend past the next available byte.
base::CheckedNumeric<FilePosition> pos_end = pos;
pos_end += size_bytes;
if (!pos_end.IsValid() || pos_end.ValueOrDie() > next_available_byte_)
return false;
int size_bytes_signed = static_cast<int>(size_bytes);
CHECK_LE(0, size_bytes_signed);
int written_bytes =
minidump_file_->WriteAtCurrentPos(data, size_bytes_signed);
if (written_bytes < 0)
return false;
return static_cast<size_t>(written_bytes) == size_bytes;
template <class DataType>
bool PostmortemMinidumpWriter::Append(const DataType& data, FilePosition* pos) {
"restricted to trivially copyable");
if (!Allocate(sizeof(data), pos))
return false;
return Write(*pos, data);
template <class DataType>
bool PostmortemMinidumpWriter::AppendVec(const std::vector<DataType>& data,
FilePosition* pos) {
"restricted to trivially copyable");
size_t size_bytes = sizeof(DataType) * data.size();
if (!Allocate(size_bytes, pos))
return false;
return WriteBytes(*pos, size_bytes,
reinterpret_cast<const char*>(&;
bool PostmortemMinidumpWriter::AppendUtf8String(base::StringPiece data,
FilePosition* pos) {
uint32_t string_size = data.size();
if (!Append(string_size, pos))
return false;
FilePosition unused_pos = 0U;
return AppendBytes(data, &unused_pos);
bool PostmortemMinidumpWriter::AppendBytes(base::StringPiece data,
FilePosition* pos) {
if (!Allocate(data.length(), pos))
return false;
return WriteBytes(*pos, data.length(),;
void PostmortemMinidumpWriter::RegisterDirectoryEntry(uint32_t stream_type,
FilePosition pos,
uint32_t size) {
entry.StreamType = stream_type;
entry.Location.Rva = pos;
entry.Location.DataSize = size;
} // namespace
bool WritePostmortemDump(base::PlatformFile minidump_file,
const crashpad::UUID& client_id,
const crashpad::UUID& report_id,
StabilityReport* report) {
PostmortemMinidumpWriter writer;
return writer.WriteDump(minidump_file, client_id, report_id, report);
} // namespace browser_watcher