Collect unclean shutdown debug information

components/browser_watcher/postmortem_minidump_writer_win.cc

+// 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 <string>
+
+#include "base/files/file_util.h"
+#include "base/numerics/safe_math.h"
+#include "third_party/crashpad/crashpad/minidump/minidump_extensions.h"
+
+namespace browser_watcher {
+
+// The stream type assigned to the minidump stream that holds the serialized
+// stability report.
+// Note: the value was obtained by adding 1 to the stream type used for holding
+// the SyzyAsan proto.
+// TODO(manzagop): centralize the stream type definitions to avoid issues.
+const uint32_t kStabilityReportStreamType = 0x4B6B0002;
+
+PostmortemMinidumpWriter::PostmortemMinidumpWriter(
+    base::PlatformFile minidump_file)
+    : next_available_byte_(0U), cursor_(0U), minidump_file_(minidump_file) {
+  CHECK(minidump_file);
+}
+
+bool PostmortemMinidumpWriter::WriteDump(const StabilityReport& report,
+                                         const crashpad::UUID& client_id,
+                                         const crashpad::UUID& report_id,
+                                         const std::string& product_name,
+                                         const std::string& version_number) {
+  DCHECK_NE(base::kInvalidPlatformFile, minidump_file_);
+  DCHECK_EQ(0U, next_available_byte_);
+  DCHECK(directory_.empty());
+
+  // Allocate space for the header and seek the cursor.
+  Position 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;
+  Position report_pos = 0U;
+  if (!AppendBytes(serialized_report, &report_pos))
+    return false;
+
+  // The directory entry for the stability report's stream.
+  RegisterDirectoryEntry(kStabilityReportStreamType, report_pos,
+                         serialized_report.length());
+
+  // 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 = {
+      {"product", product_name + "_Postmortem"}, {"version", version_number}};
+  if (!AppendCrashpadInfo(client_id, report_id, crash_keys))
+    return false;
+
+  // Write the directory.
+  Position directory_pos = 0U;
+  if (!AppendVec(directory_, &directory_pos))
+    return false;
+
+  // Write the header.
+  MINIDUMP_HEADER 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.
+  Position dict_pos = 0U;
+  uint32_t entry_count = entries.size();
+  if (entry_count > 0) {
+    if (!Append(entry_count, &dict_pos))
+      return false;
+    Position unused_pos = 0U;
+    if (!AppendVec(entries, &unused_pos))
+      return false;
+  }
+
+  MINIDUMP_LOCATION_DESCRIPTOR simple_annotations;
+  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.
+
+  Position crashpad_pos = 0U;
+  if (!Append(crashpad_info, &crashpad_pos))
+    return false;
+
+  // Append a directory entry for the crashpad info stream.
+  RegisterDirectoryEntry(crashpad::kMinidumpStreamTypeCrashpadInfo,
+                         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);
+
+  Position key_pos = 0U;
+  if (!AppendUtf8String(key, &key_pos))
+    return false;
+  Position value_pos = 0U;
+  if (!AppendUtf8String(value, &value_pos))
+    return false;
+
+  crashpad::MinidumpSimpleStringDictionaryEntry entry = {0};
+  entry.key = key_pos;
+  entry.value = value_pos;
+  entries->push_back(entry);
+
+  return true;
+}
+
+bool PostmortemMinidumpWriter::Allocate(size_t size_bytes, Position* pos) {
+  DCHECK(pos);
+  *pos = next_available_byte_;
+
+  base::CheckedNumeric<Position> next = next_available_byte_;
+  next += size_bytes;
+  if (!next.IsValid())
+    return false;
+
+  next_available_byte_ += size_bytes;
+  return true;
+}
+
+bool PostmortemMinidumpWriter::SeekCursor(Position destination) {
+  // Validate the write does not extend past the allocated space.
+  if (destination > next_available_byte_)
+    return false;
+
+  LARGE_INTEGER offset = {0};
+  offset.LowPart = destination;
+  if (!::SetFilePointerEx(minidump_file_, offset, nullptr, FILE_BEGIN))
+    return false;
+
+  cursor_ = destination;
+  return true;
+}
+
+bool PostmortemMinidumpWriter::WriteBytes(Position pos,
+                                          size_t size_bytes,
+                                          const void* data) {
+  DCHECK(data);
+  DCHECK_NE(base::kInvalidPlatformFile, minidump_file_);
+  DCHECK_EQ(cursor_, pos);
+
+  // Validate the write does not extend past the next available byte.
+  base::CheckedNumeric<Position> pos_end = pos;
+  pos_end += size_bytes;
+  if (!pos_end.IsValid() || pos_end.ValueOrDie() > next_available_byte_)
+    return false;
+
+  // Write.
+  DWORD written_bytes = 0U;
+  BOOL success =
+      ::WriteFile(minidump_file_, data, size_bytes, &written_bytes, nullptr);
+  if (!success || size_bytes != written_bytes)
+    return false;
+
+  // Advance cursor.
+  cursor_ += size_bytes;
+  return true;
+}
+
+bool PostmortemMinidumpWriter::AppendUtf8String(base::StringPiece data,
+                                                Position* pos) {
+  DCHECK(pos);
+  uint32_t string_size = data.size();
+  if (!Append(string_size, pos))
+    return false;
+
+  Position unused_pos = 0U;
+  return AppendBytes(data, &unused_pos);
+}
+
+bool PostmortemMinidumpWriter::AppendBytes(base::StringPiece data,
+                                           Position* pos) {
+  DCHECK(pos);
+  if (!Allocate(data.length(), pos))
+    return false;
+  return WriteBytes(*pos, data.length(), data.data());
+}
+
+void PostmortemMinidumpWriter::RegisterDirectoryEntry(uint32_t stream_type,
+                                                      Position pos,
+                                                      uint32_t size) {
+  MINIDUMP_DIRECTORY entry = {0};
+  entry.StreamType = stream_type;
+  entry.Location.Rva = pos;
+  entry.Location.DataSize = size;
+  directory_.push_back(entry);
+}
+
+}  // namespace browser_watcher