Add ARM support

kernel_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/kernel_collector.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 
 const char KernelCollector::kClearingSequence[] = " ";
 static const char kDefaultKernelStackSignature[] =
     "kernel-UnspecifiedStackSignature";
 static const char kKernelExecName[] = "kernel";
 const pid_t kKernelPid = 0;
 static const char kKernelSignatureKey[] = "sig";
 // Byte length of maximum human readable portion of a kernel crash signature.
 static const int kMaxHumanStringLength = 40;
 static const char kPreservedDumpPath[] = "/sys/kernel/debug/preserved/kcrash";
 const uid_t kRootUid = 0;
 // Time in seconds from the final kernel log message for a call stack
 // to count towards the signature of the kcrash.
 static const int kSignatureTimestampWindow = 2;
 // Kernel log timestamp regular expression.
 static const std::string kTimestampRegex("^<.*>\\[\\s*(\\d+\\.\\d+)\\]");
 
+/*
+ * For ARM we see:

[kmixter1, 2011/04/05 00:09:26]

Could you change the comment to be more descriptive (contents of dmesg
indicating the PC of the panic on ARM)?

[sjg, 2011/04/05 17:45:04]

done

+ *   "<5>[   39.458982] PC is at write_breakme+0xd0/0x1b4"
+ * For x86:
+ *   "<0>[   37.474699] EIP: [<790ed488>] write_breakme+0x80/0x108 \
+ *    SS:ESP 0068:e9dd3efc
+ */
+static const std::string pcRegex[KernelCollector::archCount] = {

[kmixter1, 2011/04/05 00:09:26]

I suspect that if archCount is greater than the number of initializers, this
will silently work and set strings to empty string as per the default
initializer.  Better to do a check in initializer if this is what you're trying
to guard against. Also, this should be named something more like s_pc_regexp.  I
agree with Mike though that pcRegex should just be a const char *[]. 
kTimestampRegex should have been const char * as well - I just didn't realize
this was a style rule when I wrote the code.

[sjg, 2011/04/05 17:45:04]

OK have changed the varname and added a check in constructor.

+  " PC is at ([^\\+ ]+).*",
+  " EIP: \\[<.*>\\] ([^\\+ ]+).*",  // X86 uses EIP for the program counter
+  " Unsupported architecture"
+};
+
 KernelCollector::KernelCollector()
     : is_enabled_(false),
       preserved_dump_path_(kPreservedDumpPath) {
+  // We expect crash dumps in the format of the architecture we are built for.
+  arch_ = GetCompilerArch();
+  if (arch_ == archUnknown)
+    LOG(WARNING) << "KernelCollector does not understand this architecture";
 }
 
 KernelCollector::~KernelCollector() {
 }
 
 void KernelCollector::OverridePreservedDumpPath(const FilePath &file_path) {
   preserved_dump_path_ = file_path;
 }
 
 bool KernelCollector::LoadPreservedDump(std::string *contents) {
@@ skipping 43 matching lines @@
     hash = hash * 16127 + input[i];
   return hash;
 }
 
 void KernelCollector::ProcessStackTrace(
     pcrecpp::StringPiece kernel_dump,
     bool print_diagnostics,
     unsigned *hash,
     float *last_stack_timestamp) {
   pcrecpp::RE line_re("(.+)", pcrecpp::MULTILINE());
-  pcrecpp::RE stack_trace_start_re(kTimestampRegex + " Call Trace:$");
+  pcrecpp::RE stack_trace_start_re(kTimestampRegex +
+        " (Call Trace|Backtrace):$");
   // Match lines such as the following and grab out "error_code".
-  // <4>[ 6066.849504]  [<7937bcee>] error_code+0x66/0x6c
+  // <4>[ 6066.849504]  [<7937bcee>] ? error_code+0x66/0x6c
+  // The ? may or may not be present
+
+  // For ARM:

[kmixter1, 2011/04/05 00:09:26]

Could you add the x86 example?  It may be easier to understand then why the
second line of the regexp is what it is.

[sjg, 2011/04/05 17:45:04]

It is above - I have changed it around to be more explicit.

+  // <4>[ 3498.731164] [<c0057220>] (__bug+0x20/0x2c) from [<c018062c>]
+  // (write_breakme+0xdc/0x1bc)
   pcrecpp::RE stack_entry_re(kTimestampRegex +
-                             "  \\[<.*>\\]([\\s\\?]+)([^\\+ ]+)");
+    "\\s+\\[<[[:xdigit:]]+>\\]"      // Matches "  [<7937bcee>]"
+    "([\\s\\?(]+)"                   // Matches " ? ("

[kmixter1, 2011/04/05 00:09:26]

Matches " ? (" (ARM) or " ? " (x86).

[sjg, 2011/04/05 17:45:04]

done

+    "([^\\+ )]+)");                  // Matches until \ + space )

[kmixter1, 2011/04/05 00:09:26]

nit: it took me a while to parse this comment.  Maybe matches until a delimiter?

[sjg, 2011/04/05 17:45:04]

done

   std::string line;
   std::string hashable;
 
   *hash = 0;
   *last_stack_timestamp = 0;
 
   while (line_re.FindAndConsume(&kernel_dump, &line)) {
     std::string certainty;
     std::string function_name;
     if (stack_trace_start_re.PartialMatch(line, last_stack_timestamp)) {
@@ skipping 22 matching lines @@
   }
 
   *hash = HashString(hashable);
 
   if (print_diagnostics) {
     printf("Hash based on stack trace: \"%s\" at %f.\n",
            hashable.c_str(), *last_stack_timestamp);
   }
 }
 
+enum KernelCollector::ArchKind KernelCollector::GetCompilerArch(void)
+{
+#if defined(COMPILER_GCC) && defined(ARCH_CPU_ARM_FAMILY)
+  return archArm;
+#elif defined(COMPILER_GCC) && defined(ARCH_CPU_X86_FAMILY)
+  return archX86;
+#else
+  return archUnknown;
+#endif
+}
+
+void KernelCollector::SetArch(enum ArchKind arch)
+{
+  arch_ = arch;
+}
+
 bool KernelCollector::FindCrashingFunction(
-    pcrecpp::StringPiece kernel_dump,
-    bool print_diagnostics,
-    float stack_trace_timestamp,
-    std::string *crashing_function) {
-  pcrecpp::RE eip_re(kTimestampRegex + " EIP: \\[<.*>\\] ([^\\+ ]+).*",
+  pcrecpp::StringPiece kernel_dump,
+  bool print_diagnostics,
+  float stack_trace_timestamp,
+  std::string *crashing_function) {
+  float timestamp = 0;
+
+  // Use the correct regex for this architecture.
+  pcrecpp::RE eip_re(kTimestampRegex + pcRegex[arch_],
                      pcrecpp::MULTILINE());
-  float timestamp = 0;
+
   while (eip_re.FindAndConsume(&kernel_dump, &timestamp, crashing_function)) {
     if (print_diagnostics) {
       printf("@%f: found crashing function %s\n",
              timestamp,
              crashing_function->c_str());
     }
   }
   if (timestamp == 0) {
     if (print_diagnostics) {
       printf("Found no crashing function.\n");
@@ skipping 136 matching lines @@
         kernel_crash_path.value());
 
     LOG(INFO) << "Stored kcrash to " << kernel_crash_path.value();
   }
   if (!ClearPreservedDump()) {
     return false;
   }
 
   return true;
 }