| /* | |
| * Copyright (C) 2018 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| #include <cstdint> | |
| #include <cstdio> | |
| #include <cstdlib> | |
| #include <cstring> | |
| #include <fstream> | |
| #include <iostream> | |
| #include <iterator> | |
| #include <string> | |
| #include <vector> | |
| #include "perfetto/base/build_config.h" | |
| #include "perfetto/base/logging.h" | |
| #include "perfetto/ext/base/file_utils.h" | |
| #include "perfetto/ext/base/string_utils.h" | |
| #include "perfetto/ext/base/version.h" | |
| #include "src/protozero/text_to_proto/text_to_proto.h" | |
| #include "src/traceconv/deobfuscate_profile.h" | |
| #include "src/traceconv/symbolize_profile.h" | |
| #include "src/traceconv/trace.descriptor.h" | |
| #include "src/traceconv/trace_to_bundle.h" | |
| #include "src/traceconv/trace_to_firefox.h" | |
| #include "src/traceconv/trace_to_hprof.h" | |
| #include "src/traceconv/trace_to_json.h" | |
| #include "src/traceconv/trace_to_profile.h" | |
| #include "src/traceconv/trace_to_systrace.h" | |
| #include "src/traceconv/trace_to_text.h" | |
| #include "src/traceconv/trace_unpack.h" | |
| #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) | |
| #include <fcntl.h> | |
| #include <io.h> | |
| #else | |
| #include <unistd.h> | |
| #endif | |
| namespace perfetto::trace_to_text { | |
| namespace { | |
| int Usage(const char* argv0) { | |
| fprintf(stderr, R"( | |
| Trace format conversion tool. | |
| Usage: %s MODE [OPTIONS] [input_file] [output_file] | |
| CONVERSION MODES AND THEIR SUPPORTED OPTIONS: | |
| systrace Converts to systrace HTML format | |
| --truncate [start|end] Truncates trace to keep start or end | |
| --full-sort Forces full trace sorting | |
| json Converts to Chrome JSON format | |
| --truncate [start|end] Truncates trace to keep start or end | |
| --full-sort Forces full trace sorting | |
| ctrace Converts to compressed systrace format | |
| --truncate [start|end] Truncates trace to keep start or end | |
| --full-sort Forces full trace sorting | |
| text Converts to human-readable text format | |
| (no additional options) | |
| profile Converts heap profiles to pprof format | |
| (profile.proto - default: heap profiles) | |
| --perf Extract perf/CPU profiles instead | |
| --no-annotations Don't add derived annotations to frames | |
| --timestamps T1,T2,... Generate profiles for specific timestamps | |
| --pid PID Generate profiles for specific process | |
| java_heap_profile Converts Java heap profiles to pprof format | |
| (profile.proto) | |
| --no-annotations Don't add derived annotations to frames | |
| --timestamps T1,T2,... Generate profiles for specific timestamps | |
| --pid PID Generate profiles for specific process | |
| hprof Converts heap profile to hprof format | |
| --timestamps T1,T2,... Generate profiles for specific timestamps | |
| --pid PID Generate profiles for specific process | |
| symbolize Symbolizes addresses in profiles | |
| (no additional options) | |
| deobfuscate Deobfuscates obfuscated profiles | |
| (no additional options) | |
| firefox Converts to Firefox profiler format | |
| (no additional options) | |
| decompress_packets Decompresses compressed trace packets | |
| (no additional options) | |
| bundle Creates bundle with trace + debug data | |
| (outputs TAR with symbols/deobfuscation mappings) | |
| Requires input and output file paths (no stdin/stdout) | |
| --symbol-paths PATH1,PATH2,... Additional paths to search for symbols | |
| (beyond automatic discovery) | |
| --no-auto-symbol-paths Disable automatic symbol path discovery | |
| binary Converts text proto to binary format | |
| (no additional options) | |
| NOTES: | |
| - If no input file is specified, reads from stdin | |
| - If no output file is specified, writes to stdout | |
| - Input/output files can be '-' to explicitly use stdin/stdout | |
| )", | |
| argv0); | |
| return 1; | |
| } | |
| uint64_t StringToUint64OrDie(const char* str) { | |
| char* end; | |
| uint64_t number = static_cast<uint64_t>(strtoll(str, &end, 10)); | |
| if (*end != '\0') { | |
| PERFETTO_ELOG("Invalid %s. Expected decimal integer.", str); | |
| exit(1); | |
| } | |
| return number; | |
| } | |
| int TextToTrace(std::istream* input, std::ostream* output) { | |
| std::string trace_text(std::istreambuf_iterator<char>{*input}, | |
| std::istreambuf_iterator<char>{}); | |
| auto proto_status = | |
| protozero::TextToProto(kTraceDescriptor.data(), kTraceDescriptor.size(), | |
| ".perfetto.protos.Trace", "trace", trace_text); | |
| if (!proto_status.ok()) { | |
| PERFETTO_ELOG("Failed to parse trace: %s", | |
| proto_status.status().c_message()); | |
| return 1; | |
| } | |
| const std::vector<uint8_t>& trace_proto = proto_status.value(); | |
| output->write(reinterpret_cast<const char*>(trace_proto.data()), | |
| static_cast<int64_t>(trace_proto.size())); | |
| return 0; | |
| } | |
| int Main(int argc, char** argv) { | |
| std::vector<const char*> positional_args; | |
| Keep truncate_keep = Keep::kAll; | |
| uint64_t pid = 0; | |
| std::vector<uint64_t> timestamps; | |
| bool full_sort = false; | |
| bool perf_profile = false; | |
| bool profile_no_annotations = false; | |
| std::vector<std::string> symbol_paths; | |
| bool no_auto_symbol_paths = false; | |
| for (int i = 1; i < argc; i++) { | |
| if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0) { | |
| printf("%s\n", base::GetVersionString()); | |
| return 0; | |
| } | |
| if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--truncate") == 0) { | |
| i++; | |
| if (i <= argc && strcmp(argv[i], "start") == 0) { | |
| truncate_keep = Keep::kStart; | |
| } else if (i <= argc && strcmp(argv[i], "end") == 0) { | |
| truncate_keep = Keep::kEnd; | |
| } else { | |
| PERFETTO_ELOG( | |
| "--truncate must specify whether to keep the end or the " | |
| "start of the trace."); | |
| return Usage(argv[0]); | |
| } | |
| } else if (i <= argc && strcmp(argv[i], "--pid") == 0) { | |
| i++; | |
| pid = StringToUint64OrDie(argv[i]); | |
| } else if (i <= argc && strcmp(argv[i], "--timestamps") == 0) { | |
| i++; | |
| std::vector<std::string> ts_strings = base::SplitString(argv[i], ","); | |
| for (const std::string& ts : ts_strings) { | |
| timestamps.emplace_back(StringToUint64OrDie(ts.c_str())); | |
| } | |
| } else if (strcmp(argv[i], "--perf") == 0) { | |
| perf_profile = true; | |
| } else if (strcmp(argv[i], "--no-annotations") == 0) { | |
| profile_no_annotations = true; | |
| } else if (strcmp(argv[i], "--full-sort") == 0) { | |
| full_sort = true; | |
| } else if (i < argc && strcmp(argv[i], "--symbol-paths") == 0) { | |
| i++; | |
| symbol_paths = base::SplitString(argv[i], ","); | |
| } else if (strcmp(argv[i], "--no-auto-symbol-paths") == 0) { | |
| no_auto_symbol_paths = true; | |
| } else { | |
| positional_args.push_back(argv[i]); | |
| } | |
| } | |
| if (positional_args.empty()) | |
| return Usage(argv[0]); | |
| std::istream* input_stream; | |
| std::ifstream file_istream; | |
| if (positional_args.size() > 1) { | |
| const char* file_path = positional_args[1]; | |
| file_istream.open(file_path, std::ios_base::in | std::ios_base::binary); | |
| if (!file_istream.is_open()) | |
| PERFETTO_FATAL("Could not open %s", file_path); | |
| input_stream = &file_istream; | |
| } else { | |
| #if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) | |
| if (isatty(STDIN_FILENO)) { | |
| PERFETTO_ELOG("Reading from stdin but it's connected to a TTY"); | |
| PERFETTO_LOG("It is unlikely that you want to type in some binary."); | |
| PERFETTO_LOG("Either pass a file path to the cmdline or pipe stdin"); | |
| return Usage(argv[0]); | |
| } | |
| #endif | |
| input_stream = &std::cin; | |
| } | |
| #if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) | |
| // We don't want the runtime to replace "\n" with "\r\n" on `std::cout`. | |
| _setmode(_fileno(stdout), _O_BINARY); | |
| #endif | |
| std::ostream* output_stream; | |
| std::ofstream file_ostream; | |
| if (positional_args.size() > 2) { | |
| const char* file_path = positional_args[2]; | |
| file_ostream.open(file_path, std::ios_base::out | std::ios_base::trunc | | |
| std::ios_base::binary); | |
| if (!file_ostream.is_open()) | |
| PERFETTO_FATAL("Could not open %s", file_path); | |
| output_stream = &file_ostream; | |
| } else { | |
| output_stream = &std::cout; | |
| } | |
| std::string format(positional_args[0]); | |
| if ((format != "profile" && format != "hprof" && | |
| format != "java_heap_profile") && | |
| (pid != 0 || !timestamps.empty())) { | |
| PERFETTO_ELOG( | |
| "--pid and --timestamps are supported only for profile, hprof, " | |
| "and java_heap_profile formats."); | |
| return 1; | |
| } | |
| if (perf_profile && format != "profile") { | |
| PERFETTO_ELOG("--perf requires profile format."); | |
| return 1; | |
| } | |
| if (format == "binary") { | |
| return TextToTrace(input_stream, output_stream); | |
| } | |
| if (format == "json") | |
| return TraceToJson(input_stream, output_stream, /*compress=*/false, | |
| truncate_keep, full_sort); | |
| if (format == "systrace") | |
| return TraceToSystrace(input_stream, output_stream, /*ctrace=*/false, | |
| truncate_keep, full_sort); | |
| if (format == "ctrace") | |
| return TraceToSystrace(input_stream, output_stream, /*ctrace=*/true, | |
| truncate_keep, full_sort); | |
| if (truncate_keep != Keep::kAll) { | |
| PERFETTO_ELOG( | |
| "--truncate is unsupported for " | |
| "text|profile|symbolize|decompress_packets format."); | |
| return 1; | |
| } | |
| if (full_sort) { | |
| PERFETTO_ELOG( | |
| "--full-sort is unsupported for " | |
| "text|profile|symbolize|decompress_packets format."); | |
| return 1; | |
| } | |
| if (format == "text") { | |
| return TraceToText(input_stream, output_stream) ? 0 : 1; | |
| } | |
| if (format == "profile") { | |
| return perf_profile | |
| ? TraceToPerfProfile(input_stream, output_stream, pid, | |
| timestamps, !profile_no_annotations) | |
| : TraceToHeapProfile(input_stream, output_stream, pid, | |
| timestamps, !profile_no_annotations); | |
| } | |
| if (format == "java_heap_profile") { | |
| return TraceToJavaHeapProfile(input_stream, output_stream, pid, timestamps, | |
| !profile_no_annotations); | |
| } | |
| if (format == "hprof") | |
| return TraceToHprof(input_stream, output_stream, pid, timestamps); | |
| if (format == "symbolize") | |
| return SymbolizeProfile(input_stream, output_stream); | |
| if (format == "deobfuscate") | |
| return DeobfuscateProfile(input_stream, output_stream); | |
| if (format == "firefox") | |
| return TraceToFirefoxProfile(input_stream, output_stream); | |
| if (format == "decompress_packets") | |
| return UnpackCompressedPackets(input_stream, output_stream); | |
| if (format == "bundle") { | |
| // Bundle mode requires both input and output file paths | |
| if (positional_args.size() < 3) { | |
| PERFETTO_ELOG("Bundle mode requires both input and output file paths"); | |
| return Usage(argv[0]); | |
| } | |
| const char* input_file = positional_args[1]; | |
| const char* output_file = positional_args[2]; | |
| // Validate that stdin/stdout are not used for bundle mode | |
| if (strcmp(input_file, "-") == 0) { | |
| PERFETTO_ELOG( | |
| "Bundle mode does not support stdin input, provide file path"); | |
| return 1; | |
| } | |
| if (strcmp(output_file, "-") == 0) { | |
| PERFETTO_ELOG( | |
| "Bundle mode does not support stdout output, provide file path"); | |
| return 1; | |
| } | |
| // Validate input file exists and is readable | |
| if (!base::FileExists(input_file)) { | |
| PERFETTO_ELOG("Input file does not exist: %s", input_file); | |
| return 1; | |
| } | |
| BundleContext context; | |
| context.symbol_paths = symbol_paths; | |
| context.no_auto_symbol_paths = no_auto_symbol_paths; | |
| return TraceToBundle(input_file, output_file, context); | |
| } | |
| return Usage(argv[0]); | |
| } | |
| } // namespace | |
| } // namespace perfetto::trace_to_text | |
| int main(int argc, char** argv) { | |
| return perfetto::trace_to_text::Main(argc, argv); | |
| } |