crash-reporter: Capture and send recent update_engine logs when it crashes

user_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/user_collector.h"
 
 #include <grp.h>  // For struct group.
 #include <pwd.h>  // For struct passwd.
 #include <sys/types.h>  // For getpwuid_r, getgrnam_r, WEXITSTATUS.
 
@@ skipping 12 matching lines @@
 DEFINE_string(filter_in, "",
               "Ignore all crashes but this for testing");
 #pragma GCC diagnostic error "-Wstrict-aliasing"
 
 static const char kCollectionErrorSignature[] =
     "crash_reporter-user-collection";
 // This procfs file is used to cause kernel core file writing to
 // instead pipe the core file into a user space process.  See
 // core(5) man page.
 static const char kCorePatternFile[] = "/proc/sys/kernel/core_pattern";
+static const char kCorePipeLimitFile[] = "/proc/sys/kernel/core_pipe_limit";
+// Set core_pipe_limit to 4 so that we can catch a few unrelated concurrent
+// crashes, but finite to avoid infinitely recursing on crash handling.
+static const char kCorePipeLimit[] = "4";

[petkov, 2010/12/14 18:58:58]

the CL description says more than 2 crashes.

 static const char kCoreToMinidumpConverterPath[] = "/usr/bin/core2md";
 static const char kLeaveCoreFile[] = "/root/.leave_core";
 
+static const char kDefaultLogConfig[] = "/etc/crash_reporter_logs.conf";
+
 const char *UserCollector::kUserId = "Uid:\t";
 const char *UserCollector::kGroupId = "Gid:\t";
 
 UserCollector::UserCollector()
     : generate_diagnostics_(false),
       core_pattern_file_(kCorePatternFile),
+      core_pipe_limit_file_(kCorePipeLimitFile),
       initialized_(false) {
 }
 
 void UserCollector::Initialize(
     UserCollector::CountCrashFunction count_crash_function,
     const std::string &our_path,
     UserCollector::IsFeedbackAllowedFunction is_feedback_allowed_function,
     SystemLogging *logger,
     bool generate_diagnostics) {
   CrashCollector::Initialize(count_crash_function,
@@ skipping 12 matching lines @@
     return StringPrintf("|%s --signal=%%s --pid=%%p", our_path_.c_str());
   } else {
     return "core";
   }
 }
 
 bool UserCollector::SetUpInternal(bool enabled) {
   CHECK(initialized_);
   logger_->LogInfo("%s user crash handling",
                    enabled ? "Enabling" : "Disabling");
+  if (file_util::WriteFile(FilePath(core_pipe_limit_file_),
+                           kCorePipeLimit,
+                           strlen(kCorePipeLimit)) !=
+      static_cast<int>(strlen(kCorePipeLimit))) {
+    logger_->LogError("Unable to write %s", core_pipe_limit_file_.c_str());
+    return false;
+  }
   std::string pattern = GetPattern(enabled);
   if (file_util::WriteFile(FilePath(core_pattern_file_),
                            pattern.c_str(),
                            pattern.length()) !=
       static_cast<int>(pattern.length())) {
     logger_->LogError("Unable to write %s", core_pattern_file_.c_str());
     return false;
   }
   return true;
 }
@@ skipping 241 matching lines @@
   }
 
   // Directory like /tmp/crash_reporter.1234 which contains the
   // procfs entries and other temporary files used during conversion.
   FilePath container_dir = FilePath("/tmp").Append(
       StringPrintf("crash_reporter.%d", pid));
   std::string dump_basename = FormatDumpBasename(exec, time(NULL), pid);
   FilePath core_path = GetCrashPath(crash_path, dump_basename, "core");
   FilePath meta_path = GetCrashPath(crash_path, dump_basename, "meta");
   FilePath minidump_path = GetCrashPath(crash_path, dump_basename, "dmp");
+  FilePath log_path = GetCrashPath(crash_path, dump_basename, "log");
+
+  if (GetLogContents(FilePath(kDefaultLogConfig), exec, log_path))
+    AddCrashMetaData("log", log_path.value());
 
   if (!ConvertCoreToMinidump(pid, container_dir, core_path,
                             minidump_path)) {
     logger_->LogInfo("Leaving core file at %s due to conversion error",
                      core_path.value().c_str());
     return false;
   }
 
   // Here we commit to sending this file.  We must not return false
   // after this point or we will generate a log report as well as a
@@ skipping 61 matching lines @@
       if (!ConvertAndEnqueueCrash(pid, exec, &out_of_capacity)) {
         if (!out_of_capacity)
           EnqueueCollectionErrorLog(pid, exec);
         return false;
       }
     }
   }
 
   return true;
 }