| // Copyright 2017 The Fuchsia 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 <inttypes.h> |
| #include <lib/syslog/cpp/log_settings.h> |
| #include <lib/syslog/cpp/macros.h> |
| #include <stdio.h> |
| #include <string.h> |
| |
| #include <chrono> |
| #include <string> |
| |
| #include "command_line_settings.h" |
| #include "garnet/lib/intel_pt_decode/decoder.h" |
| #include "src/lib/fxl/command_line.h" |
| #include "src/lib/fxl/log_settings_command_line.h" |
| #include "src/lib/fxl/strings/string_number_conversions.h" |
| #include "src/lib/fxl/strings/string_printf.h" |
| #include "third_party/processor-trace/libipt/include/intel-pt.h" |
| |
| using namespace intel_processor_trace; |
| |
| static constexpr char kUsageString[] = |
| "insntrace_print [options]\n" |
| "\n" |
| "These options are required:\n" |
| "--pt=FILE PT input file\n" |
| "--pt-list=FILE Text file containing list of PT files\n" |
| " Exactly one of --pt,--pt-list is required.\n" |
| "--ids=FILE An \"ids.txt\" file, which provides build-id\n" |
| " to debug-info-containing ELF file (sideband data)\n" |
| " May be specified multiple times.\n" |
| "--ktrace=FILE Name of the .ktrace file (sideband data)\n" |
| "--map=FILE Name of file containing mappings of ELF files to\n" |
| " their load addresses (sideband data)\n" |
| " This output currently comes from the dynamic " |
| "linker\n" |
| " when env var LD_TRACE=1 is set, and can be the " |
| "output\n" |
| " from loglistener.\n" |
| " May be specified multiple times.\n" |
| "\n" |
| "The remaining options are optional.\n" |
| "\n" |
| "Input options:\n" |
| "--elf=BINARY ELF input PT files\n" |
| " May be specified multiple times.\n" |
| " This option is not useful with PIE executables,\n" |
| " use sideband derived data instead.\n" |
| "--kernel=PATH Name of the kernel ELF file\n" |
| "--kernel-cr3=CR3 CR3 value for the kernel (base 16)\n" |
| "\n" |
| "General output options:\n" |
| "--output-format=raw|calls|chrome\n" |
| " Default is \"calls\"\n" |
| "--output-file=PATH\n" |
| " For raw,calls the default is stdout.\n" |
| " For chrome the default is tmp-ipt.json\n" |
| "\n" |
| "Options for \"--output-format=calls\":\n" |
| "--pc Dump numeric instruction addresses\n" |
| "--insn Dump instruction bytes\n" |
| "--time=abs Print absolute time\n" |
| "--time=rel Print relative time (trace begins at time 0)\n" |
| "--report-lost Report lost mtc,cyc packets\n" |
| "\n" |
| "Options for \"--output-format=chrome\":\n" |
| "--id=ID ID value to put in the output\n" |
| " For cpu tracing, this is used to specify the cpu\n" |
| " number if the PT dump is provided with --p.\n" |
| "--view=cpu|process Set the major axis of display, by cpu or process\n" |
| " Chrome only understands processes and threads.\n" |
| " Cpu view: processes are cpus," |
| " threads are processes.\n" |
| " Process view: processes are processes," |
| " threads are cpus.\n" |
| " The default is the cpu view.\n" |
| "\n" |
| "Logging options:\n" |
| " --quiet[=LEVEL] Set quietness level (opposite of verbose)\n" |
| " --verbose[=LEVEL] Set debug verbosity level\n" |
| " --log-file=FILE Write log output to FILE.\n" |
| "Quiet supersedes verbose if both are specified.\n" |
| "Defined log levels:\n" |
| "-n - verbosity level n\n" |
| " 0 - INFO - this is the default level\n" |
| " 1 - WARNING\n" |
| " 2 - ERROR\n" |
| " 3 - FATAL\n"; |
| |
| static void Usage(FILE* f) { fprintf(f, "%s", kUsageString); } |
| |
| static bool ParseOption(const char* arg, std::string_view* out_name, const char** out_value) { |
| size_t len = strlen(arg); |
| if (len < 2u || arg[0] != '-' || arg[1] != '-') |
| return false; |
| if (len == 2u) { |
| // caller has to distinguish the "--" case |
| return false; |
| } |
| |
| // Note: The option name *must* be at least one character, so start at |
| // position 3 -- "--=foo" will yield a name of "=foo" and no value. |
| // (Passing a starting |pos| that's "too big" is OK.) |
| const char* equals = strchr(arg + 3, '='); |
| if (!equals) { |
| *out_name = std::string_view(arg + 2); |
| *out_value = ""; |
| return true; |
| } |
| |
| *out_name = std::string_view(arg + 2, equals - arg - 2); |
| *out_value = equals + 1; |
| return true; |
| } |
| |
| static int ParseArgv(int argc, char** argv, DecoderConfig* decoder_config, |
| CommandLineSettings* printer_config) { |
| // While IWBN to use fxl::CommandLine here we need to support passing |
| // multiple values for certain options (akin to -I options to the compiler). |
| // So we do our own parsing, but we support the same syntax as fxl. |
| |
| int n; |
| for (n = 1; n < argc; ++n) { |
| std::string_view option; |
| const char* value; |
| |
| if (strcmp(argv[n], "--") == 0) |
| break; |
| |
| if (!ParseOption(argv[n], &option, &value)) |
| break; |
| |
| // TODO(dje): parsing of boolean options could be better |
| |
| if (option == "output-format") { |
| if (strcmp(value, "raw") == 0) { |
| printer_config->output_format = OutputFormat::kRaw; |
| } else if (strcmp(value, "calls") == 0) { |
| printer_config->output_format = OutputFormat::kCalls; |
| } else if (strcmp(value, "chrome") == 0) { |
| printer_config->output_format = OutputFormat::kChrome; |
| } else { |
| FX_LOGS(ERROR) << "Bad value for --output-format: " << value; |
| return -1; |
| } |
| continue; |
| } |
| |
| if (option == "output-file") { |
| printer_config->output_file_name = value; |
| continue; |
| } |
| |
| if (option == "time") { |
| if (strcmp(value, "abs") == 0) { |
| printer_config->abstime = true; |
| } else if (strcmp(value, "rel") == 0) { |
| printer_config->abstime = false; |
| } else { |
| FX_LOGS(ERROR) << "Bad value for --time: " << value; |
| return -1; |
| } |
| continue; |
| } |
| |
| if (option == "elf") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty ELF file name"; |
| return -1; |
| } |
| decoder_config->elf_file_names.push_back(value); |
| continue; |
| } |
| |
| if (option == "pt") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty PT file name"; |
| return -1; |
| } |
| if (decoder_config->pt_file_name != "" || decoder_config->pt_list_file_name != "") { |
| FX_LOGS(ERROR) << "Only one of --pt/--pt-list supported"; |
| return -1; |
| } |
| decoder_config->pt_file_name = value; |
| continue; |
| } |
| |
| if (option == "pt-list") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty PT-list file name"; |
| return -1; |
| } |
| if (decoder_config->pt_file_name != "" || decoder_config->pt_list_file_name != "") { |
| FX_LOGS(ERROR) << "Only one of --pt/--pt-list supported"; |
| return -1; |
| } |
| decoder_config->pt_list_file_name = value; |
| continue; |
| } |
| |
| if (option == "pc") { |
| printer_config->dump_pc = true; |
| continue; |
| } |
| |
| if (option == "insn") { |
| printer_config->dump_insn = true; |
| continue; |
| } |
| |
| if (option == "report-lost") { |
| printer_config->report_lost_mtc_cyc = true; |
| continue; |
| } |
| |
| if (option == "id") { |
| if (!fxl::StringToNumberWithError<uint32_t>(std::string_view(value), &printer_config->id, |
| fxl::Base::k16)) { |
| FX_LOGS(ERROR) << "Not a hex number: " << value; |
| return -1; |
| } |
| continue; |
| } |
| |
| if (option == "view") { |
| if (strcmp(value, "cpu") == 0) { |
| printer_config->view = OutputView::kCpu; |
| } else if (strcmp(value, "process") == 0) { |
| printer_config->view = OutputView::kProcess; |
| } else { |
| FX_LOGS(ERROR) << "Bad value for --view: " << value; |
| return -1; |
| } |
| continue; |
| } |
| |
| if (option == "kernel") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty kernel file name"; |
| return -1; |
| } |
| decoder_config->kernel_file_name = value; |
| continue; |
| } |
| |
| if (option == "kernel-cr3") { |
| if (!fxl::StringToNumberWithError<uint64_t>(std::string_view(value), |
| &decoder_config->kernel_cr3, fxl::Base::k16)) { |
| FX_LOGS(ERROR) << "Not a valid cr3 number: " << value; |
| return -1; |
| } |
| continue; |
| } |
| |
| if (option == "ids") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty ids file name"; |
| return -1; |
| } |
| decoder_config->ids_file_names.push_back(value); |
| continue; |
| } |
| |
| if (option == "ktrace") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty ktrace file name"; |
| return -1; |
| } |
| decoder_config->ktrace_file_name = value; |
| continue; |
| } |
| |
| if (option == "map") { |
| if (strlen(value) == 0) { |
| FX_LOGS(ERROR) << "Empty map file name"; |
| return -1; |
| } |
| decoder_config->map_file_names.push_back(value); |
| continue; |
| } |
| |
| if (option == "verbose") { |
| // already processed by fxl::SetLogSettingsFromCommandLine |
| continue; |
| } |
| |
| FX_LOGS(ERROR) << "Unrecognized option: " << option; |
| return -1; |
| } |
| |
| if (n < argc && strcmp(argv[n], "--") == 0) { |
| ++n; |
| } |
| |
| if (decoder_config->pt_file_name == "" && decoder_config->pt_list_file_name == "") { |
| FX_LOGS(ERROR) << "One of --pt=FILE, --pt-list=FILE must be specified"; |
| return -1; |
| } |
| if (decoder_config->ktrace_file_name == "") { |
| FX_LOGS(WARNING) << "missing --ktrace=FILE, output may be limited"; |
| } |
| if (decoder_config->ids_file_names.size() == 0) { |
| FX_LOGS(WARNING) << "missing --ids=FILE, output will be limited"; |
| } |
| if (decoder_config->map_file_names.size() == 0) { |
| FX_LOGS(WARNING) << "missing --map=FILE, output will be limited"; |
| } |
| |
| return n; |
| } |
| |
| int main(int argc, char** argv) { |
| fxl::CommandLine cl = fxl::CommandLineFromArgcArgv(argc, argv); |
| if (!fxl::SetLogSettingsFromCommandLine(cl)) |
| return EXIT_FAILURE; |
| |
| if (cl.HasOption("help")) { |
| Usage(stdout); |
| return EXIT_SUCCESS; |
| } |
| |
| DecoderConfig decoder_config; |
| CommandLineSettings printer_config; |
| int n = ParseArgv(argc, argv, &decoder_config, &printer_config); |
| if (n < 0) |
| return EXIT_FAILURE; |
| |
| if (n != argc) { |
| FX_LOGS(ERROR) << "No positional parameters"; |
| return EXIT_FAILURE; |
| } |
| |
| const auto start_time = std::chrono::steady_clock::now(); |
| |
| auto decoder = DecoderState::Create(decoder_config); |
| if (!decoder) { |
| FX_LOGS(ERROR) << "Error creating decoder"; |
| return EXIT_FAILURE; |
| } |
| |
| uint64_t total_insns; |
| if (printer_config.output_format == OutputFormat::kRaw) { |
| auto printer = RawPrinter::Create(decoder.get(), printer_config.ToRawPrinterConfig()); |
| if (!printer) { |
| FX_LOGS(ERROR) << "Error creating printer"; |
| return EXIT_FAILURE; |
| } |
| total_insns = printer->PrintFiles(); |
| } else if (printer_config.output_format == OutputFormat::kCalls) { |
| auto printer = CallPrinter::Create(decoder.get(), printer_config.ToCallPrinterConfig()); |
| if (!printer) { |
| FX_LOGS(ERROR) << "Error creating printer"; |
| return EXIT_FAILURE; |
| } |
| total_insns = printer->PrintFiles(); |
| } else { |
| FX_LOGS(ERROR) << "Invalid output format\n"; |
| return EXIT_FAILURE; |
| } |
| |
| const auto& delta = (std::chrono::steady_clock::now() - start_time); |
| int64_t seconds = std::chrono::duration_cast<std::chrono::seconds>(delta).count(); |
| int milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(delta).count() % 1000; |
| FX_LOGS(INFO) << fxl::StringPrintf("%" PRIu64 " instructions processed in %" PRId64 |
| ".%03d seconds\n", |
| total_insns, seconds, milliseconds); |
| |
| return EXIT_SUCCESS; |
| } |
