// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// A utility for printing the contents of a postmortem stability minidump.

#include <windows.h>  // NOLINT

#include <dbghelp.h>

#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_file.h"
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "components/browser_watcher/stability_report.pb.h"

namespace {

const char kUsage[] =
    "Usage: %ls --minidump=<minidump file>\n"
    "\n"
    "  Dumps the contents of a postmortem minidump in a human readable way.\n";

bool ParseCommandLine(const base::CommandLine* cmd,
                      base::FilePath* minidump_path) {
  *minidump_path = cmd->GetSwitchValuePath("minidump");
  if (minidump_path->empty()) {
    LOG(ERROR) << "Missing minidump file.\n";
    LOG(ERROR) << base::StringPrintf(kUsage, cmd->GetProgram().value().c_str());
    return false;
  }
  return true;
}

void Indent(FILE* out, int indent_level) {
  DCHECK(out);
  for (int i = 0; i < indent_level; ++i)
    fprintf(out, "  ");
}

void PrintUserData(
    FILE* out,
    int indent_level,
    const google::protobuf::Map<std::string, browser_watcher::TypedValue>&
        user_data) {
  DCHECK(out);
  Indent(out, indent_level);
  fprintf(out, "User data (%zu)\n", user_data.size());
  for (const auto& kv : user_data) {
    Indent(out, indent_level + 1);
    fprintf(out, "%s : ", kv.first.c_str());
    const browser_watcher::TypedValue& value = kv.second;
    switch (kv.second.value_case()) {
      case browser_watcher::TypedValue::kBytesValue: {
        const std::string& bytes_value = value.bytes_value();
        for (size_t i = 0; i < bytes_value.size(); ++i)
          fprintf(out, "%02X ", bytes_value.at(i));
        fprintf(out, "\n");
        break;
      }
      case browser_watcher::TypedValue::kBytesReference:
        fprintf(out, "bytes reference (address: %llX, size: %llX)\n",
                value.bytes_reference().address(),
                value.bytes_reference().size());
        break;
      case browser_watcher::TypedValue::kStringValue:
        fprintf(out, "\"%s\"\n", value.string_value().c_str());
        break;
      case browser_watcher::TypedValue::kStringReference:
        fprintf(out, "string reference (address: %llX, size: %llX)\n",
                value.string_reference().address(),
                value.string_reference().size());
        break;
      case browser_watcher::TypedValue::kCharValue:
        fprintf(out, "'%s'\n", value.char_value().c_str());
        break;
      case browser_watcher::TypedValue::kBoolValue:
        fprintf(out, "%s\n", value.bool_value() ? "true" : "false");
        break;
      case browser_watcher::TypedValue::kSignedValue:
        fprintf(out, "%lld\n", value.signed_value());
        break;
      case browser_watcher::TypedValue::kUnsignedValue:
        fprintf(out, "%llu\n", value.unsigned_value());
        break;
      case browser_watcher::TypedValue::VALUE_NOT_SET:
        fprintf(out, "<not set>\n");
        break;
    }
  }
}

void PrintActivity(FILE* out,
                   int indent_level,
                   const browser_watcher::Activity& activity) {
  DCHECK(out);
  Indent(out, indent_level);
  fprintf(out, "Activity\n");
  Indent(out, indent_level + 1);
  fprintf(out, "type: %d\n", activity.type());
  Indent(out, indent_level + 1);
  fprintf(out, "time: %lld\n", activity.time());
  Indent(out, indent_level + 1);
  fprintf(out, "address: %llX\n", activity.address());
  switch (activity.type()) {
    case browser_watcher::Activity::UNKNOWN:
      break;
    case browser_watcher::Activity::ACT_TASK_RUN:
      Indent(out, indent_level + 1);
      fprintf(out, "origin_address: %llX\n", activity.origin_address());
      fprintf(out, "task_sequence_id: %lld\n", activity.task_sequence_id());
      break;
    case browser_watcher::Activity::ACT_LOCK_ACQUIRE:
      Indent(out, indent_level + 1);
      fprintf(out, "lock_address: %llX\n", activity.lock_address());
      break;
    case browser_watcher::Activity::ACT_EVENT_WAIT:
      Indent(out, indent_level + 1);
      fprintf(out, "event_address: %llX\n", activity.event_address());
      break;
    case browser_watcher::Activity::ACT_THREAD_JOIN:
      Indent(out, indent_level + 1);
      fprintf(out, "thread_id: %lld\n", activity.thread_id());
      break;
    case browser_watcher::Activity::ACT_PROCESS_WAIT:
      Indent(out, indent_level + 1);
      fprintf(out, "process_id: %lld\n", activity.process_id());
      break;
    case browser_watcher::Activity::ACT_GENERIC:
      Indent(out, indent_level + 1);
      fprintf(out, "id: %u, data: %d\n", activity.generic_id(),
              activity.generic_data());
      break;
  }

  PrintUserData(out, indent_level + 1, activity.user_data());
}

void PrintProcessState(FILE* out,
                       const browser_watcher::ProcessState& process) {
  std::string process_type;
  switch (process.process_type()) {
    case browser_watcher::ProcessState::UNKNOWN_PROCESS:
      process_type = "unknown type";
      break;
    case browser_watcher::ProcessState::BROWSER_PROCESS:
      process_type = "browser";
      break;
    case browser_watcher::ProcessState::WATCHER_PROCESS:
      process_type = "watcher";
      break;
    default:
      base::SStringPrintf(&process_type, "process type %d",
                          process.process_type());
      break;
  }

  fprintf(out, "Process %lld (%s, %d threads)\n", process.process_id(),
          process_type.c_str(), process.threads_size());

  if (process.has_memory_state() &&
      process.memory_state().has_windows_memory()) {
    const auto& windows_memory = process.memory_state().windows_memory();
    if (windows_memory.has_process_private_usage()) {
      fprintf(out, "process_private_usage: %u pages\n",
              windows_memory.process_private_usage());
    }
    if (windows_memory.has_process_peak_workingset_size()) {
      fprintf(out, "process_peak_workingset_size: %u pages\n",
              windows_memory.process_peak_workingset_size());
    }
    if (windows_memory.has_process_peak_pagefile_usage()) {
      fprintf(out, "process_peak_pagefile_usage: %u pages\n",
              windows_memory.process_peak_pagefile_usage());
    }
    if (windows_memory.has_process_allocation_attempt()) {
      fprintf(out, "process_allocation_attempt: %u bytes\n",
              windows_memory.process_allocation_attempt());
    }
    if (windows_memory.has_process_handle_count()) {
      fprintf(out, "process_handle_count: %u handles\n",
              windows_memory.process_handle_count());
    }
  }

  for (const browser_watcher::ThreadState& thread : process.threads()) {
    fprintf(out, "Thread %lld (%s) : %d activities\n", thread.thread_id(),
            thread.thread_name().c_str(), thread.activity_count());
    for (const browser_watcher::Activity& activity : thread.activities())
      PrintActivity(out, 1, activity);
  }

  PrintUserData(out, 1, process.data());
}

// TODO(manzagop): flesh out as StabilityReport gets fleshed out.
void PrintReport(FILE* out, const browser_watcher::StabilityReport& report) {
  if (report.has_system_memory_state() &&
      report.system_memory_state().has_windows_memory()) {
    const auto& windows_memory = report.system_memory_state().windows_memory();

    if (windows_memory.has_system_commit_limit()) {
      fprintf(out, "system_commit_limit: %u pages\n",
              windows_memory.system_commit_limit());
    }
    if (windows_memory.has_system_commit_remaining()) {
      fprintf(out, "system_commit_remaining: %u pages\n",
              windows_memory.system_commit_remaining());
    }
    if (windows_memory.has_system_handle_count()) {
      fprintf(out, "system_handle_count: %u handles\n",
              windows_memory.system_handle_count());
    }
  }
  PrintUserData(out, 0, report.global_data());
  for (int i = 0; i < report.process_states_size(); ++i) {
    const browser_watcher::ProcessState process = report.process_states(i);
    PrintProcessState(out, process);
  }
}

bool GetStabilityStreamRvaAndSize(RVA directory_rva,
                                  ULONG32 stream_count,
                                  FILE* file,
                                  RVA* report_rva,
                                  ULONG32* report_size_bytes) {
  std::vector<MINIDUMP_DIRECTORY> directory;
  directory.resize(stream_count);

  CHECK_EQ(0, fseek(file, directory_rva, SEEK_SET));
  CHECK_EQ(stream_count, fread(directory.data(), sizeof(MINIDUMP_DIRECTORY),
                               stream_count, file));

  for (const MINIDUMP_DIRECTORY& entry : directory) {
    constexpr ULONG32 kStabilityStream = static_cast<ULONG32>(0x4B6B0002);
    if (entry.StreamType == kStabilityStream) {
      *report_rva = entry.Location.Rva;
      *report_size_bytes = entry.Location.DataSize;
      return true;
    }
  }

  return false;
}

int Main(int argc, char** argv) {
  base::CommandLine::Init(argc, argv);

  // Get the dump.
  base::FilePath minidump_path;
  if (!ParseCommandLine(base::CommandLine::ForCurrentProcess(), &minidump_path))
    return 1;

  // Read the minidump to extract the proto.
  base::ScopedFILE minidump_file;
  minidump_file.reset(base::OpenFile(minidump_path, "rb"));
  CHECK(minidump_file.get());

  // Read the header.
  // TODO(manzagop): leverage Crashpad to do this.
  MINIDUMP_HEADER header = {};
  CHECK_EQ(1U, fread(&header, sizeof(header), 1U, minidump_file.get()));
  CHECK_EQ(static_cast<ULONG32>(MINIDUMP_SIGNATURE), header.Signature);
  fprintf(stdout, "Number of streams: %u\n", header.NumberOfStreams);
  RVA directory_rva = header.StreamDirectoryRva;

  RVA report_rva;
  ULONG32 report_size_bytes;
  CHECK(GetStabilityStreamRvaAndSize(directory_rva, header.NumberOfStreams,
                                     minidump_file.get(), &report_rva,
                                     &report_size_bytes));

  // Read the serialized stability report.
  std::string serialized_report;
  serialized_report.resize(report_size_bytes);
  CHECK_EQ(0, fseek(minidump_file.get(), report_rva, SEEK_SET));
  CHECK_EQ(report_size_bytes, fread(&serialized_report.at(0), 1,
                                    report_size_bytes, minidump_file.get()));

  browser_watcher::StabilityReport report;
  CHECK(report.ParseFromString(serialized_report));

  // Note: we can't use the usual protocol buffer human readable API due to
  // the use of optimize_for = LITE_RUNTIME.
  PrintReport(stdout, report);

  return 0;
}

}  // namespace

int main(int argc, char** argv) {
  return Main(argc, argv);
}