Add GPU fingerprint information to breakpad microdumps.

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::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,
+                  const char* gpu_fingerprint,
                   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),
+        gpu_fingerprint_(gpu_fingerprint),
         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() && dumper_->LateInit();
   }
 
   bool Dump() {
     bool success;
     LogLine("-----BEGIN BREAKPAD MICRODUMP-----");
     DumpProductInformation();
     DumpOSInformation();
+    DumpGPUInformation();
     success = DumpCrashingThread();
     if (success)
       success = DumpMappings();
     LogLine("-----END BREAKPAD MICRODUMP-----");
     dumper_->ThreadsResume();
     return success;
   }
 
  private:
   // Writes one line to the system log.
@@ skipping 100 matching lines @@
     } else if (has_uts_info) {
       LogAppend(uts.release);
       LogAppend(" ");
       LogAppend(uts.version);
     } else {
       LogAppend("no build fingerprint available");
     }
     LogCommitLine();
   }
 
+  void DumpGPUInformation() {
+    LogAppend("G ");
+    if (gpu_fingerprint_) {
+      LogAppend(gpu_fingerprint_);
+    } else {
+      LogAppend("UNKNOWN");
+    }
+    LogCommitLine();
+  }
+
   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;
 
     if (!dumper_->GetStackInfo(&stack, &stack_len, stack_pointer)) {
       // The stack pointer might not be available. In this case we don't hard
@@ skipping 160 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_;
+  const char* const gpu_fingerprint_;
   char* log_line_;
 };
 }  // namespace
 
 namespace google_breakpad {
 
 bool WriteMicrodump(pid_t crashing_process,
                     const void* blob,
                     size_t blob_size,
                     const MappingList& mappings,
                     const char* build_fingerprint,
-                    const char* product_info) {
+                    const char* product_info,
+                    const char* gpu_fingerprint) {
   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, build_fingerprint, product_info,
-                         &dumper);
+                         gpu_fingerprint, &dumper);
   if (!writer.Init())
     return false;
   return writer.Dump();
 }
 
 }  // namespace google_breakpad