crashreporter/minidump-analyzer/minidump-analyzer.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "minidump-analyzer.h"

#include <cstdio>
#include <cstring>
#include <string>
#include <sstream>

#include "json/json.h"
#include "google_breakpad/processor/basic_source_line_resolver.h"
#include "google_breakpad/processor/call_stack.h"
#include "google_breakpad/processor/code_module.h"
#include "google_breakpad/processor/code_modules.h"
#include "google_breakpad/processor/minidump.h"
#include "google_breakpad/processor/minidump_processor.h"
#include "google_breakpad/processor/process_state.h"
#include "google_breakpad/processor/stack_frame.h"
#include "processor/pathname_stripper.h"

#include "mozilla/FStream.h"
#include "mozilla/Unused.h"

#if defined(XP_WIN)

#  include <windows.h>
#  include "mozilla/glue/WindowsDllServices.h"

#elif defined(XP_UNIX) || defined(XP_MACOSX)

#  include <sys/types.h>
#  include <sys/stat.h>
#  include <unistd.h>

#endif

#include "MinidumpAnalyzerUtils.h"

#if XP_WIN && HAVE_64BIT_BUILD && defined(_M_X64)
#  include "MozStackFrameSymbolizer.h"
#endif

namespace CrashReporter {

#if defined(XP_WIN)

static mozilla::glue::BasicDllServices gDllServices;

#endif

using std::hex;
using std::ios;
using std::ios_base;
using std::map;
using std::showbase;
using std::string;
using std::stringstream;
using std::wstring;

using google_breakpad::BasicSourceLineResolver;
using google_breakpad::CallStack;
using google_breakpad::CodeModule;
using google_breakpad::CodeModules;
using google_breakpad::Minidump;
using google_breakpad::MinidumpProcessor;
using google_breakpad::PathnameStripper;
using google_breakpad::ProcessResult;
using google_breakpad::ProcessState;
using google_breakpad::StackFrame;

using mozilla::IFStream;
using mozilla::OFStream;
using mozilla::Unused;

MinidumpAnalyzerOptions gMinidumpAnalyzerOptions;

// Path of the minidump to be analyzed.
static string gMinidumpPath;

struct ModuleCompare {
  bool operator()(const CodeModule* aLhs, const CodeModule* aRhs) const {
    return aLhs->base_address() < aRhs->base_address();
  }
};

typedef map<const CodeModule*, unsigned int, ModuleCompare> OrderedModulesMap;

static void AddModulesFromCallStack(OrderedModulesMap& aOrderedModules,
                                    const CallStack* aStack) {
  int frameCount = aStack->frames()->size();

  for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {
    const StackFrame* frame = aStack->frames()->at(frameIndex);

    if (frame->module) {
      aOrderedModules.insert(
          std::pair<const CodeModule*, unsigned int>(frame->module, 0));
    }
  }
}

static void PopulateModuleList(const ProcessState& aProcessState,
                               OrderedModulesMap& aOrderedModules,
                               bool aFullStacks) {
  int threadCount = aProcessState.threads()->size();
  int requestingThread = aProcessState.requesting_thread();

  if (!aFullStacks && (requestingThread != -1)) {
    AddModulesFromCallStack(aOrderedModules,
                            aProcessState.threads()->at(requestingThread));
  } else {
    for (int threadIndex = 0; threadIndex < threadCount; ++threadIndex) {
      AddModulesFromCallStack(aOrderedModules,
                              aProcessState.threads()->at(threadIndex));
    }
  }

  int moduleCount = 0;
  for (auto& itr : aOrderedModules) {
    itr.second = moduleCount++;
  }
}

static const char kExtraDataExtension[] = ".extra";

static string ToHex(uint64_t aValue) {
  stringstream output;

  output << hex << showbase << aValue;

  return output.str();
}

// Convert the stack frame trust value into a readable string.

static string FrameTrust(const StackFrame::FrameTrust aTrust) {
  switch (aTrust) {
    case StackFrame::FRAME_TRUST_NONE:
      return "none";
    case StackFrame::FRAME_TRUST_SCAN:
      return "scan";
    case StackFrame::FRAME_TRUST_CFI_SCAN:
      return "cfi_scan";
    case StackFrame::FRAME_TRUST_FP:
      return "frame_pointer";
    case StackFrame::FRAME_TRUST_CFI:
      return "cfi";
    case StackFrame::FRAME_TRUST_PREWALKED:
      return "prewalked";
    case StackFrame::FRAME_TRUST_CONTEXT:
      return "context";
  }

  return "none";
}

// Convert the result value of the minidump processing step into a readable
// string.

static string ResultString(ProcessResult aResult) {
  switch (aResult) {
    case google_breakpad::PROCESS_OK:
      return "OK";
    case google_breakpad::PROCESS_ERROR_MINIDUMP_NOT_FOUND:
      return "ERROR_MINIDUMP_NOT_FOUND";
    case google_breakpad::PROCESS_ERROR_NO_MINIDUMP_HEADER:
      return "ERROR_NO_MINIDUMP_HEADER";
    case google_breakpad::PROCESS_ERROR_NO_THREAD_LIST:
      return "ERROR_NO_THREAD_LIST";
    case google_breakpad::PROCESS_ERROR_GETTING_THREAD:
      return "ERROR_GETTING_THREAD";
    case google_breakpad::PROCESS_ERROR_GETTING_THREAD_ID:
      return "ERROR_GETTING_THREAD_ID";
    case google_breakpad::PROCESS_ERROR_DUPLICATE_REQUESTING_THREADS:
      return "ERROR_DUPLICATE_REQUESTING_THREADS";
    case google_breakpad::PROCESS_SYMBOL_SUPPLIER_INTERRUPTED:
      return "SYMBOL_SUPPLIER_INTERRUPTED";
    default:
      return "";
  }
}

// Convert the list of stack frames to JSON and append them to the array
// specified in the |aNode| parameter.

static void ConvertStackToJSON(const ProcessState& aProcessState,
                               const OrderedModulesMap& aOrderedModules,
                               const CallStack* aStack, Json::Value& aNode) {
  int frameCount = aStack->frames()->size();

  for (int frameIndex = 0; frameIndex < frameCount; ++frameIndex) {
    const StackFrame* frame = aStack->frames()->at(frameIndex);
    Json::Value frameNode;

    if (frame->module) {
      const auto& itr = aOrderedModules.find(frame->module);

      if (itr != aOrderedModules.end()) {
        frameNode["module_index"] = (*itr).second;
      }
    }

    frameNode["trust"] = FrameTrust(frame->trust);
    // The 'ip' field is equivalent to socorro's 'offset' field
    frameNode["ip"] = ToHex(frame->instruction);

    aNode.append(frameNode);
  }
}

// Extract the list of certifications subjects from the list of modules and
// store it in the |aCertSubjects| parameter

static void RetrieveCertSubjects(const CodeModules* modules,
                                 Json::Value& aCertSubjects) {
#if defined(XP_WIN)
  if (modules) {
    for (size_t i = 0; i < modules->module_count(); i++) {
      const CodeModule* module = modules->GetModuleAtIndex(i);
      auto certSubject = gDllServices.GetBinaryOrgName(
          UTF8ToWide(module->code_file()).c_str());
      if (certSubject) {
        string strSubject(WideToUTF8(certSubject.get()));
        // Json::Value::operator[] creates and returns a null member if the key
        // does not exist.
        Json::Value& subjectNode = aCertSubjects[strSubject];
        if (!subjectNode) {
          // If the member is null, we want to convert that to an array.
          subjectNode = Json::Value(Json::arrayValue);
        }

        // Now we're guaranteed that subjectNode is an array. Add the new entry.
        subjectNode.append(PathnameStripper::File(module->code_file()));
      }
    }
  }
#endif  // defined(XP_WIN)
}

// Convert the list of modules to JSON and append them to the array specified
// in the |aNode| parameter.

static int ConvertModulesToJSON(const ProcessState& aProcessState,
                                const OrderedModulesMap& aOrderedModules,
                                Json::Value& aNode) {
  const CodeModules* modules = aProcessState.modules();

  if (!modules) {
    return -1;
  }

  uint64_t mainAddress = 0;
  const CodeModule* mainModule = modules->GetMainModule();

  if (mainModule) {
    mainAddress = mainModule->base_address();
  }

  int mainModuleIndex = -1;

  for (const auto& itr : aOrderedModules) {
    const CodeModule* module = itr.first;

    if ((module->base_address() == mainAddress) && mainModule) {
      mainModuleIndex = itr.second;
    }

    Json::Value moduleNode;
    moduleNode["filename"] = PathnameStripper::File(module->code_file());
    moduleNode["code_id"] = PathnameStripper::File(module->code_identifier());
    moduleNode["version"] = module->version();
    moduleNode["debug_file"] = PathnameStripper::File(module->debug_file());
    moduleNode["debug_id"] = module->debug_identifier();
    moduleNode["base_addr"] = ToHex(module->base_address());
    moduleNode["end_addr"] = ToHex(module->base_address() + module->size());

    aNode.append(moduleNode);
  }

  return mainModuleIndex;
}

// Convert the list of unloaded modules to JSON and append them to the array
// specified in the |aNode| parameter. Return the number of unloaded modules
// that were found.

static size_t ConvertUnloadedModulesToJSON(const ProcessState& aProcessState,
                                           Json::Value& aNode) {
  const CodeModules* unloadedModules = aProcessState.unloaded_modules();
  if (!unloadedModules) {
    return 0;
  }

  const size_t unloadedModulesLen = unloadedModules->module_count();
  for (size_t i = 0; i < unloadedModulesLen; i++) {
    const CodeModule* unloadedModule = unloadedModules->GetModuleAtIndex(i);

    Json::Value unloadedModuleNode;
    unloadedModuleNode["filename"] =
        PathnameStripper::File(unloadedModule->code_file());
    unloadedModuleNode["code_id"] =
        PathnameStripper::File(unloadedModule->code_identifier());
    unloadedModuleNode["base_addr"] = ToHex(unloadedModule->base_address());
    unloadedModuleNode["end_addr"] =
        ToHex(unloadedModule->base_address() + unloadedModule->size());

    aNode.append(unloadedModuleNode);
  }

  return unloadedModulesLen;
}

// Convert the process state to JSON, this includes information about the
// crash, the module list and stack traces for every thread

static void ConvertProcessStateToJSON(const ProcessState& aProcessState,
                                      Json::Value& aStackTraces,
                                      const bool aFullStacks,
                                      Json::Value& aCertSubjects) {
  // Crash info
  Json::Value crashInfo;
  int requestingThread = aProcessState.requesting_thread();

  if (aProcessState.crashed()) {
    crashInfo["type"] = aProcessState.crash_reason();
    crashInfo["address"] = ToHex(aProcessState.crash_address());

    if (requestingThread != -1) {
      // Record the crashing thread index only if this is a full minidump
      // and all threads' stacks are present, otherwise only the crashing
      // thread stack is written out and this field is set to 0.
      crashInfo["crashing_thread"] = aFullStacks ? requestingThread : 0;
    }
  } else {
    crashInfo["type"] = Json::Value(Json::nullValue);
    // Add assertion info, if available
    string assertion = aProcessState.assertion();

    if (!assertion.empty()) {
      crashInfo["assertion"] = assertion;
    }
  }

  aStackTraces["crash_info"] = crashInfo;

  // Modules
  OrderedModulesMap orderedModules;
  PopulateModuleList(aProcessState, orderedModules, aFullStacks);

  Json::Value modules(Json::arrayValue);
  int mainModule = ConvertModulesToJSON(aProcessState, orderedModules, modules);

  if (mainModule != -1) {
    aStackTraces["main_module"] = mainModule;
  }

  aStackTraces["modules"] = modules;

  Json::Value unloadedModules(Json::arrayValue);
  size_t unloadedModulesLen =
      ConvertUnloadedModulesToJSON(aProcessState, unloadedModules);

  if (unloadedModulesLen > 0) {
    aStackTraces["unloaded_modules"] = unloadedModules;
  }

  RetrieveCertSubjects(aProcessState.modules(), aCertSubjects);
  RetrieveCertSubjects(aProcessState.unloaded_modules(), aCertSubjects);

  // Threads
  Json::Value threads(Json::arrayValue);
  int threadCount = aProcessState.threads()->size();

  if (!aFullStacks && (requestingThread != -1)) {
    // Only add the crashing thread
    Json::Value thread;
    Json::Value stack(Json::arrayValue);
    const CallStack* rawStack = aProcessState.threads()->at(requestingThread);

    ConvertStackToJSON(aProcessState, orderedModules, rawStack, stack);
    thread["frames"] = stack;
    threads.append(thread);
  } else {
    for (int threadIndex = 0; threadIndex < threadCount; ++threadIndex) {
      Json::Value thread;
      Json::Value stack(Json::arrayValue);
      const CallStack* rawStack = aProcessState.threads()->at(threadIndex);

      ConvertStackToJSON(aProcessState, orderedModules, rawStack, stack);
      thread["frames"] = stack;
      threads.append(thread);
    }
  }

  aStackTraces["threads"] = threads;
}

// Process the minidump file and append the JSON-formatted stack traces to
// the node specified in |aStackTraces|. We also populate |aCertSubjects| with
// information about the certificates used to sign modules, when present and
// supported by the underlying OS.
static bool ProcessMinidump(Json::Value& aStackTraces,
                            Json::Value& aCertSubjects, const string& aDumpFile,
                            const bool aFullStacks) {
#if XP_WIN && HAVE_64BIT_BUILD && defined(_M_X64)
  MozStackFrameSymbolizer symbolizer;
  MinidumpProcessor minidumpProcessor(&symbolizer, false);
#else
  BasicSourceLineResolver resolver;
  // We don't have a valid symbol resolver so we pass nullptr instead.
  MinidumpProcessor minidumpProcessor(nullptr, &resolver);
#endif

  // Process the minidump.
#if defined(XP_WIN)
  // Breakpad invokes std::ifstream directly, so this path needs to be ANSI
  Minidump dump(UTF8ToMBCS(aDumpFile));
#else
  Minidump dump(aDumpFile);
#endif  // defined(XP_WIN)
  if (!dump.Read()) {
    return false;
  }

  ProcessResult rv;
  ProcessState processState;
  rv = minidumpProcessor.Process(&dump, &processState);
  aStackTraces["status"] = ResultString(rv);

  ConvertProcessStateToJSON(processState, aStackTraces, aFullStacks,
                            aCertSubjects);

  return true;
}

static bool ReadExtraFile(const string& aExtraDataPath, Json::Value& aExtra) {
  IFStream f(
#if defined(XP_WIN)
      UTF8ToWide(aExtraDataPath).c_str(),
#else
      aExtraDataPath.c_str(),
#endif  // defined(XP_WIN)
      ios::in);
  if (!f.is_open()) {
    return false;
  }

  Json::CharReaderBuilder builder;
  return parseFromStream(builder, f, &aExtra, nullptr);
}

// Update the extra data file by adding the StackTraces and ModuleSignatureInfo
// fields that contain the JSON outputs of this program.
static bool UpdateExtraDataFile(const string& aDumpPath,
                                const Json::Value& aStackTraces,
                                const Json::Value& aCertSubjects) {
  string extraDataPath(aDumpPath);
  int dot = extraDataPath.rfind('.');

  if (dot < 0) {
    return false;  // Not a valid dump path
  }

  extraDataPath.replace(dot, extraDataPath.length() - dot, kExtraDataExtension);

  Json::Value extra;
  if (!ReadExtraFile(extraDataPath, extra)) {
    return false;
  }

  OFStream f(
#if defined(XP_WIN)
      UTF8ToWide(extraDataPath).c_str(),
#else
      extraDataPath.c_str(),
#endif  // defined(XP_WIN)
      ios::out | ios::trunc);

  bool res = false;
  if (f.is_open()) {
    Json::StreamWriterBuilder builder;
    builder["indentation"] = "";

    // The StackTraces field is not stored as a string because it's not a
    // crash annotation. It's only used by the crash reporter client which
    // strips it before submitting the other annotations to Socorro.
    extra["StackTraces"] = aStackTraces;

    if (!!aCertSubjects) {
      extra["ModuleSignatureInfo"] = Json::writeString(builder, aCertSubjects);
    }

    std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter());
    writer->write(extra, &f);
    f << "\n";
    res = !f.fail();
    f.close();
  }

  return res;
}

bool GenerateStacks(const string& aDumpPath, const bool aFullStacks) {
  Json::Value stackTraces;
  Json::Value certSubjects;

  if (!ProcessMinidump(stackTraces, certSubjects, aDumpPath, aFullStacks)) {
    return false;
  }

  return UpdateExtraDataFile(aDumpPath, stackTraces, certSubjects);
}

}  // namespace CrashReporter

using namespace CrashReporter;

#if defined(XP_WIN)
#  define XP_LITERAL(s) L##s
#else
#  define XP_LITERAL(s) s
#endif

template <typename CharT>
struct CharTraits;

template <>
struct CharTraits<char> {
  static int compare(const char* left, const char* right) {
    return strcmp(left, right);
  }

  static string& assign(string& left, const char* right) {
    left = right;
    return left;
  }
};

#if defined(XP_WIN)

template <>
struct CharTraits<wchar_t> {
  static int compare(const wchar_t* left, const wchar_t* right) {
    return wcscmp(left, right);
  }

  static string& assign(string& left, const wchar_t* right) {
    left = WideToUTF8(right);
    return left;
  }
};

#endif  // defined(XP_WIN)

static void LowerPriority() {
#if defined(XP_WIN)
  Unused << SetPriorityClass(GetCurrentProcess(),
                             PROCESS_MODE_BACKGROUND_BEGIN);
#else  // Linux, MacOS X, etc...
  Unused << nice(20);
#endif
}

template <typename CharT, typename Traits = CharTraits<CharT>>
static void ParseArguments(int argc, CharT** argv) {
  if (argc <= 1) {
    exit(EXIT_FAILURE);
  }

  for (int i = 1; i < argc - 1; i++) {
    if (!Traits::compare(argv[i], XP_LITERAL("--full"))) {
      gMinidumpAnalyzerOptions.fullMinidump = true;
    } else if (!Traits::compare(argv[i], XP_LITERAL("--force-use-module")) &&
               (i < argc - 2)) {
      Traits::assign(gMinidumpAnalyzerOptions.forceUseModule, argv[i + 1]);
      ++i;
    } else {
      exit(EXIT_FAILURE);
    }
  }

  Traits::assign(gMinidumpPath, argv[argc - 1]);
}

#if defined(XP_WIN)
// WARNING: Windows does *NOT* use UTF8 for char strings off the command line!
// Using wmain here so that the CRT doesn't need to perform a wasteful and
// lossy UTF-16 to MBCS conversion; ParseArguments will convert to UTF8
// directly.
extern "C" int wmain(int argc, wchar_t** argv)
#else
int main(int argc, char** argv)
#endif
{
  LowerPriority();
  ParseArguments(argc, argv);

  if (!GenerateStacks(gMinidumpPath, gMinidumpAnalyzerOptions.fullMinidump)) {
    exit(EXIT_FAILURE);
  }

  exit(EXIT_SUCCESS);
}