crash-reporter: write conversion failure diagnostics into fake dmp files

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 68 matching lines @@
                       sanitized_exec_name.c_str(),
                       tm.tm_year + 1900,
                       tm.tm_mon + 1,
                       tm.tm_mday,
                       tm.tm_hour,
                       tm.tm_min,
                       tm.tm_sec,
                       pid);
 }
 
+FilePath CrashCollector::GetCrashPath(const FilePath &crash_directory,
+                                      const std::string &basename,
+                                      const std::string &extension) {
+  return crash_directory.Append(StringPrintf("%s.%s",
+                                             basename.c_str(),
+                                             extension.c_str()));
+}
+
 FilePath CrashCollector::GetCrashDirectoryInfo(
     uid_t process_euid,
     uid_t default_user_id,
     gid_t default_user_group,
     mode_t *mode,
     uid_t *directory_owner,
     gid_t *directory_group) {
   if (process_euid == default_user_id) {
     *mode = kUserCrashPathMode;
     *directory_owner = default_user_id;
@@ skipping 19 matching lines @@
     logger_->LogError("Cannot find user named %s", name.c_str());
     return false;
   }
 
   *uid = passwd_result->pw_uid;
   *gid = passwd_result->pw_gid;
   return true;
 }
 
 bool CrashCollector::GetCreatedCrashDirectoryByEuid(uid_t euid,
-                                                    FilePath *crash_directory) {
+                                                    FilePath *crash_directory,
+                                                    bool *out_of_capacity) {
   uid_t default_user_id;
   gid_t default_user_group;
 
+  if (out_of_capacity != NULL) *out_of_capacity = false;
+
   // For testing.
   if (forced_crash_directory_ != NULL) {
     *crash_directory = FilePath(forced_crash_directory_);
     return true;
   }
 
   if (!GetUserInfoFromName(kDefaultUserName,
                            &default_user_id,
                            &default_user_group)) {
     logger_->LogError("Could not find default user info");
@@ skipping 24 matching lines @@
     umask(old_mask);
   }
 
   if (!file_util::PathExists(*crash_directory)) {
     logger_->LogError("Unable to create crash directory %s",
                       crash_directory->value().c_str());
     return false;
   }
 
   if (!CheckHasCapacity(*crash_directory)) {
+    if (out_of_capacity != NULL) *out_of_capacity = true;
     return false;
   }
 
   return true;
 }
 
 // Return true if the given crash directory has not already reached
 // maximum capacity.
 bool CrashCollector::CheckHasCapacity(const FilePath &crash_directory) {
   DIR* dir = opendir(crash_directory.value().c_str());
@@ skipping 78 matching lines @@
   }
   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("%sexec_name=%s\n"
                                        "ver=%s\n"
+                                       "payload=%s\n"
                                        "payload_size=%lld\n"
                                        "done=1\n",
                                        extra_metadata_.c_str(),
                                        exec_name.c_str(),
                                        version.c_str(),
+                                       payload_path.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());
   }
 }