Postmortem dumper: dump user data

components/browser_watcher/dump_postmortem_minidump_main_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.
 
 // A utility for printing the contents of a postmortem stability minidump.
 
 #include <windows.h>  // NOLINT
 #include <dbghelp.h>
 
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
                       base::FilePath* minidump_path) {
   *minidump_path = cmd->GetSwitchValuePath("minidump");
   if (minidump_path->empty()) {
     LOG(ERROR) << "Missing minidump file.\n";
     LOG(ERROR) << base::StringPrintf(kUsage, cmd->GetProgram().value().c_str());
     return false;
   }
   return true;
 }
 
 void Indent(FILE* out, size_t indent_level) {

[bcwhite, 2017/01/27 15:16:57]

"int" for indent_level is fine and will eliminate the "0U" in favor of just "0"
below.

[manzagop (departed), 2017/01/27 19:16:42]

Done.

   DCHECK(out);
   for (size_t i = 0; i < indent_level; ++i)
     fprintf(out, "  ");
 }
 
+void PrintUserData(
+    FILE* out,
+    size_t indent_level,
+    const google::protobuf::Map<std::string, browser_watcher::TypedValue>&
+        user_data) {
+  DCHECK(out);
+  Indent(out, indent_level);
+  fprintf(out, "User data (%zu)\n", user_data.size());
+  for (const auto& kv : user_data) {
+    Indent(out, indent_level + 1);
+    fprintf(out, "%s : ", kv.first.c_str());
+    const browser_watcher::TypedValue& value = kv.second;
+    switch (kv.second.value_case()) {
+      case browser_watcher::TypedValue::kBytesValue: {
+        const std::string& bytes_value = value.bytes_value();
+        for (size_t i = 0; i < bytes_value.size(); ++i)
+          fprintf(out, "%02X", bytes_value.at(i));

[bcwhite, 2017/01/27 15:16:57]

perhaps "%02X "  (separate bytes with a space?)

[manzagop (departed), 2017/01/27 19:16:42]

Done.

+        fprintf(out, "\n");
+        break;
+      }
+      case browser_watcher::TypedValue::kBytesReference:
+        fprintf(out, "bytes reference (address: %llu, size: %lld)\n",

[bcwhite, 2017/01/27 15:16:57]

Should size be "%llu" as well?

[manzagop (departed), 2017/01/27 19:16:42]

Hm. The size is stored and analyzed as unsigned, but looks like I actually
created the proto's field as signed.

Is this something we need to address?

Note we also have a signed / unsigned mismatch for the CodeModule proto. This is
a preexisting proto (breakpad/server side) that we reused. It stores module
address and size as signed numbers.

[bcwhite, 2017/01/27 20:03:24]

The address could be a problem, given that a randomized address space has a 50%
chance of this being negative, but the size shouldn't be.  It's probably worth
fixing the proto to be consistent.

[manzagop (departed), 2017/01/27 20:15:42]

I created https://crbug.com/686187

+                value.bytes_reference().address(),
+                value.bytes_reference().size());
+        break;
+      case browser_watcher::TypedValue::kStringValue:
+        fprintf(out, "%s\n", value.string_value().c_str());

[bcwhite, 2017/01/27 15:16:57]

"\"%s\"\n"
in case there are spaces at the head or tail.  Also clearly indicates that the
value is a string so there is no confusion should the string be hexadecimal
digits.

[manzagop (departed), 2017/01/27 19:16:42]

Done.

+        break;
+      case browser_watcher::TypedValue::kStringReference:
+        fprintf(out, "string reference (address: %llu, size: %lld)\n",
+                value.string_reference().address(),
+                value.string_reference().size());
+        break;
+      case browser_watcher::TypedValue::kCharValue:
+        fprintf(out, "%s\n", value.char_value().c_str());

[bcwhite, 2017/01/27 15:16:57]

"'%s'\n"

[manzagop (departed), 2017/01/27 19:16:42]

Done.

+        break;
+      case browser_watcher::TypedValue::kBoolValue:
+        fprintf(out, "%d\n", value.bool_value());

[bcwhite, 2017/01/27 15:16:57]

"%s", value.bool_value() ? "true" : "false"

[manzagop (departed), 2017/01/27 19:16:42]

Done.

+        break;
+      case browser_watcher::TypedValue::kSignedValue:
+        fprintf(out, "%lld\n", value.signed_value());
+        break;
+      case browser_watcher::TypedValue::kUnsignedValue:
+        fprintf(out, "%llu\n", value.unsigned_value());
+        break;
+      case browser_watcher::TypedValue::VALUE_NOT_SET:
+        fprintf(out, "<not set>\n");
+        break;
+    }
+  }
+}
+
 void PrintActivity(FILE* out,
                    size_t indent_level,
                    const browser_watcher::Activity& activity) {
   DCHECK(out);
   Indent(out, indent_level);
   fprintf(out, "Activity\n");
   Indent(out, indent_level + 1);
   fprintf(out, "type: %d\n", activity.type());
   Indent(out, indent_level + 1);
   fprintf(out, "time: %lld\n", activity.time());
   switch (activity.type()) {
     case browser_watcher::Activity::UNKNOWN:
       break;
     case browser_watcher::Activity::ACT_TASK_RUN:
       Indent(out, indent_level + 1);
       fprintf(out, "origin_address: %llx\n", activity.origin_address());
       fprintf(out, "task_sequence_id: %lld\n", activity.task_sequence_id());
       break;
     case browser_watcher::Activity::ACT_LOCK_ACQUIRE:
       Indent(out, indent_level + 1);
       fprintf(out, "lock_address: %llx\n", activity.lock_address());
       break;
     case browser_watcher::Activity::ACT_EVENT_WAIT:
       Indent(out, indent_level + 1);
       fprintf(out, "event_address: %llx\n", activity.event_address());
       break;
     case browser_watcher::Activity::ACT_THREAD_JOIN:
       Indent(out, indent_level + 1);
       fprintf(out, "thread_id: %lld\n", activity.thread_id());

[bcwhite, 2017/01/27 15:16:57]

Should you display these in hex?

[manzagop (departed), 2017/01/27 19:16:42]

I believe they're most commonly seen in decimal.

       break;
     case browser_watcher::Activity::ACT_PROCESS_WAIT:
       Indent(out, indent_level + 1);
       fprintf(out, "process_id: %lld\n", activity.process_id());
       break;
   }
+
+  PrintUserData(out, indent_level + 1, activity.user_data());
 }
 
 void PrintProcessState(FILE* out,
                        const browser_watcher::ProcessState& process) {
   fprintf(out, "Process %lld (%d threads)\n", process.process_id(),
           process.threads_size());
   for (const browser_watcher::ThreadState& thread : process.threads()) {
     fprintf(out, "Thread %lld (%s) : %d activities\n", thread.thread_id(),
             thread.thread_name().c_str(), thread.activity_count());
     for (const browser_watcher::Activity& activity : thread.activities())
       PrintActivity(out, 1, activity);
   }
 }
 
 // TODO(manzagop): flesh out as StabilityReport gets fleshed out.
 void PrintReport(FILE* out, const browser_watcher::StabilityReport& report) {
+  PrintUserData(out, 0U, report.global_data());
   for (int i = 0; i < report.process_states_size(); ++i) {
     const browser_watcher::ProcessState process = report.process_states(i);
     PrintProcessState(out, process);
   }
 }
 
 int Main(int argc, char** argv) {
   base::CommandLine::Init(argc, argv);
 
   // Get the dump.
@@ skipping 39 matching lines @@
   PrintReport(stdout, report);
 
   return 0;
 }
 
 }  // namespace
 
 int main(int argc, char** argv) {
   return Main(argc, argv);
 }