[microdump] Add build fingerprint and product info metadata.

src/client/linux/microdump_writer/microdump_writer.cc

 // Copyright (c) 2014, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
 using google_breakpad::SeccompUnwinder;
 using google_breakpad::ThreadInfo;
 using google_breakpad::UContextReader;
 
 const size_t kLineBufferSize = 2048;
 
 class MicrodumpWriter {
  public:
   MicrodumpWriter(const ExceptionHandler::CrashContext* context,
                   const MappingList& mappings,
+                  const char* build_fingerprint,
+                  const char* product_info,
                   LinuxDumper* dumper)
       : ucontext_(context ? &context->context : NULL),
 #if !defined(__ARM_EABI__) && !defined(__mips__)
         float_state_(context ? &context->float_state : NULL),
 #endif
         dumper_(dumper),
         mapping_list_(mappings),
+        build_fingerprint_(build_fingerprint),
+        product_info_(product_info),
         log_line_(NULL) {
     log_line_ = reinterpret_cast<char*>(Alloc(kLineBufferSize));
     if (log_line_)
       log_line_[0] = '\0';  // Clear out the log line buffer.
   }
 
   ~MicrodumpWriter() { dumper_->ThreadsResume(); }
 
   bool Init() {
     // In the exceptional case where the system was out of memory and there
     // wasn't even room to allocate the line buffer, bail out. There is nothing
     // useful we can possibly achieve without the ability to Log. At least let's
     // try to not crash.
     if (!dumper_->Init() || !log_line_)
       return false;
     return dumper_->ThreadsSuspend();
   }
 
   bool Dump() {
     bool success;
     LogLine("-----BEGIN BREAKPAD MICRODUMP-----");
-    success = DumpOSInformation();
-    if (success)
-      success = DumpCrashingThread();
+    DumpProductInformation();
+    DumpOSInformation();
+    success = DumpCrashingThread();
     if (success)
       success = DumpMappings();
     LogLine("-----END BREAKPAD MICRODUMP-----");
     dumper_->ThreadsResume();
     return success;
   }
 
  private:
   // Writes one line to the system log.
   void LogLine(const char* msg) {
@@ skipping 32 matching lines @@
     for (size_t i = 0; i < length; ++i, ++ptr)
       LogAppend(*ptr);
   }
 
   // Writes out the current line buffer on the system log.
   void LogCommitLine() {
     LogLine(log_line_);
     my_strlcpy(log_line_, "", kLineBufferSize);
   }
 
-  bool DumpOSInformation() {
-    struct utsname uts;
-    if (uname(&uts))
-      return false;
+  void DumpProductInformation() {
+    LogAppend("V ");
+    if (product_info_) {
+      LogAppend(product_info_);
+    } else {
+      LogAppend("UNKNOWN:0.0.0.0");
+    }
+    LogCommitLine();
+  }
+
+  void DumpOSInformation() {
     const uint8_t n_cpus = static_cast<uint8_t>(sysconf(_SC_NPROCESSORS_CONF));
 
 #if defined(__ANDROID__)
     const char kOSId[] = "A";
 #else
     const char kOSId[] = "L";
 #endif
 
 // We cannot depend on uts.machine. On multiarch devices it always returns the
 // primary arch, not the one that match the executable being run.
@@ skipping 11 matching lines @@
 #error "This code has not been ported to your platform yet"
 #endif
 
     LogAppend("O ");
     LogAppend(kOSId);
     LogAppend(" ");
     LogAppend(kArch);
     LogAppend(" ");
     LogAppend(n_cpus);
     LogAppend(" ");
-    LogAppend(uts.machine);
-    LogAppend(" ");
-    LogAppend(uts.release);
-    LogAppend(" ");
-    LogAppend(uts.version);
+    // If the client has attached a build fingerprint to the MinidumpDescriptor
+    // use that one. Otherwise try to get some basic info from uname().
+    if (build_fingerprint_) {
+      LogAppend(build_fingerprint_);
+    } else {
+      struct utsname uts;
+      if (uname(&uts) == 0) {
+        LogAppend(uts.machine);
+        LogAppend(" ");
+        LogAppend(uts.release);
+        LogAppend(" ");
+        LogAppend(uts.version);
+      } else {
+        LogAppend("no build fingerprint available");
+      }
+    }
     LogCommitLine();
-    return true;
   }
 
   bool DumpThreadStack(uint32_t thread_id,
                        uintptr_t stack_pointer,
                        int max_stack_len,
                        uint8_t** stack_copy) {
     *stack_copy = NULL;
     const void* stack;
     size_t stack_len;
 
@@ skipping 162 matching lines @@
   }
 
   void* Alloc(unsigned bytes) { return dumper_->allocator()->Alloc(bytes); }
 
   const struct ucontext* const ucontext_;
 #if !defined(__ARM_EABI__) && !defined(__mips__)
   const google_breakpad::fpstate_t* const float_state_;
 #endif
   LinuxDumper* dumper_;
   const MappingList& mapping_list_;
+  const char* const build_fingerprint_;
+  const char* const product_info_;
   char* log_line_;
 };
 }  // namespace
 
 namespace google_breakpad {
 
 bool WriteMicrodump(pid_t crashing_process,
                     const void* blob,
                     size_t blob_size,
-                    const MappingList& mappings) {
+                    const MappingList& mappings,
+                    const char* build_fingerprint,
+                    const char* product_info) {
   LinuxPtraceDumper dumper(crashing_process);
   const ExceptionHandler::CrashContext* context = NULL;
   if (blob) {
     if (blob_size != sizeof(ExceptionHandler::CrashContext))
       return false;
     context = reinterpret_cast<const ExceptionHandler::CrashContext*>(blob);
     dumper.set_crash_address(
         reinterpret_cast<uintptr_t>(context->siginfo.si_addr));
     dumper.set_crash_signal(context->siginfo.si_signo);
     dumper.set_crash_thread(context->tid);
   }
-  MicrodumpWriter writer(context, mappings, &dumper);
+  MicrodumpWriter writer(context, mappings, build_fingerprint, product_info,
+                         &dumper);
   if (!writer.Init())
     return false;
   return writer.Dump();
 }
 
 }  // namespace google_breakpad