crash-reporter: Generate kernel crash signatures for server-side grouping of similar crashes

crash_collector.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "crash-reporter/crash_collector.h"
 
 #include <dirent.h>
 #include <pwd.h>  // For struct passwd.
 #include <sys/types.h>  // for mode_t.
 
@@ skipping 21 matching lines @@
 // Maximum crash reports per crash spool directory.  Note that this is
 // a separate maximum from the maximum rate at which we upload these
 // diagnostics.  The higher this rate is, the more space we allow for
 // core files, minidumps, and kcrash logs, and equivalently the more
 // processor and I/O bandwidth we dedicate to handling these crashes when
 // many occur at once.  Also note that if core files are configured to
 // be left on the file system, we stop adding crashes when either the
 // number of core files or minidumps reaches this number.
 const int CrashCollector::kMaxCrashDirectorySize = 32;
 
-CrashCollector::CrashCollector() : forced_crash_directory_(NULL) {
+CrashCollector::CrashCollector()
+    : forced_crash_directory_(NULL),
+      lsb_release_(kLsbRelease) {
 }
 
 CrashCollector::~CrashCollector() {
 }
 
 void CrashCollector::Initialize(
     CrashCollector::CountCrashFunction count_crash_function,
     CrashCollector::IsFeedbackAllowedFunction is_feedback_allowed_function,
     SystemLogging *logger) {
   CHECK(count_crash_function != NULL);
@@ skipping 187 matching lines @@
     SplitString(*line, separator, &sides);
     if (sides.size() != 2) {
       any_errors = true;
       continue;
     }
     dictionary->insert(std::pair<std::string, std::string>(sides[0], sides[1]));
   }
   return !any_errors;
 }
 
+void CrashCollector::AddCrashMetaData(const std::string &key,
+                                      const std::string &value) {
+  extra_metadata_.append(StringPrintf("%s=%s\n", key.c_str(), value.c_str()));
+}
+
 void CrashCollector::WriteCrashMetaData(const FilePath &meta_path,
                                         const std::string &exec_name,
                                         const std::string &payload_path) {
   std::map<std::string, std::string> contents;
-  if (!ReadKeyValueFile(FilePath(std::string(kLsbRelease)), '=', &contents)) {
-    logger_->LogError("Problem parsing %s", kLsbRelease);
+  if (!ReadKeyValueFile(FilePath(std::string(lsb_release_)), '=', &contents)) {
+    logger_->LogError("Problem parsing %s", lsb_release_);
     // Even though there was some failure, take as much as we could read.
   }
   std::string version("unknown");
   std::map<std::string, std::string>::iterator i;
   if ((i = contents.find("CHROMEOS_RELEASE_VERSION")) != contents.end()) {
     version = i->second;
   }
   int64 payload_size = -1;
   file_util::GetFileSize(FilePath(payload_path), &payload_size);
-  std::string meta_data = StringPrintf("exec_name=%s\n"
+  std::string meta_data = StringPrintf("%sexec_name=%s\n"
                                        "ver=%s\n"
                                        "payload_size=%lld\n"
                                        "done=1\n",
+                                       extra_metadata_.c_str(),
                                        exec_name.c_str(),
                                        version.c_str(),
                                        payload_size);
   if (!file_util::WriteFile(meta_path, meta_data.c_str(), meta_data.size())) {
     logger_->LogError("Unable to write %s", meta_path.value().c_str());
   }
 }