1 //===-- CommandObjectTraceStartIntelPT.h ----------------------*- C++ //-*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H 10 #define LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H 11 12 #include "../../../../source/Commands/CommandObjectTrace.h" 13 #include "TraceIntelPT.h" 14 #include "lldb/Interpreter/CommandInterpreter.h" 15 #include "lldb/Interpreter/CommandReturnObject.h" 16 17 namespace lldb_private { 18 namespace trace_intel_pt { 19 20 class CommandObjectThreadTraceStartIntelPT 21 : public CommandObjectMultipleThreads { 22 public: 23 class CommandOptions : public Options { 24 public: 25 CommandOptions() : Options() { OptionParsingStarting(nullptr); } 26 27 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 28 ExecutionContext *execution_context) override; 29 30 void OptionParsingStarting(ExecutionContext *execution_context) override; 31 32 llvm::ArrayRef<OptionDefinition> GetDefinitions() override; 33 34 uint64_t m_ipt_trace_size; 35 bool m_enable_tsc; 36 llvm::Optional<uint64_t> m_psb_period; 37 }; 38 39 CommandObjectThreadTraceStartIntelPT(TraceIntelPT &trace, 40 CommandInterpreter &interpreter) 41 : CommandObjectMultipleThreads( 42 interpreter, "thread trace start", 43 "Start tracing one or more threads with intel-pt. " 44 "Defaults to the current thread. Thread indices can be " 45 "specified as arguments.\n Use the thread-index \"all\" to trace " 46 "all threads including future threads.", 47 "thread trace start [<thread-index> <thread-index> ...] " 48 "[<intel-pt-options>]", 49 lldb::eCommandRequiresProcess | lldb::eCommandTryTargetAPILock | 50 lldb::eCommandProcessMustBeLaunched | 51 lldb::eCommandProcessMustBePaused), 52 m_trace(trace), m_options() {} 53 54 Options *GetOptions() override { return &m_options; } 55 56 protected: 57 bool DoExecuteOnThreads(Args &command, CommandReturnObject &result, 58 llvm::ArrayRef<lldb::tid_t> tids) override; 59 60 TraceIntelPT &m_trace; 61 CommandOptions m_options; 62 }; 63 64 class CommandObjectProcessTraceStartIntelPT : public CommandObjectParsed { 65 public: 66 class CommandOptions : public Options { 67 public: 68 CommandOptions() : Options() { OptionParsingStarting(nullptr); } 69 70 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 71 ExecutionContext *execution_context) override; 72 73 void OptionParsingStarting(ExecutionContext *execution_context) override; 74 75 llvm::ArrayRef<OptionDefinition> GetDefinitions() override; 76 77 uint64_t m_ipt_trace_size; 78 uint64_t m_process_buffer_size_limit; 79 bool m_enable_tsc; 80 llvm::Optional<uint64_t> m_psb_period; 81 bool m_per_cpu_tracing; 82 bool m_disable_cgroup_filtering; 83 }; 84 85 CommandObjectProcessTraceStartIntelPT(TraceIntelPT &trace, 86 CommandInterpreter &interpreter) 87 : CommandObjectParsed( 88 interpreter, "process trace start", 89 "Start tracing this process with intel-pt, including future " 90 "threads. If --per-cpu-tracing is not provided, this traces each " 91 "thread independently, thus using a trace buffer per thread. " 92 "Threads traced with the \"thread trace start\" command are left " 93 "unaffected ant not retraced. This is the recommended option " 94 "unless the number of threads is huge. If --per-cpu-tracing is " 95 "passed, each cpu core is traced instead of each thread, which " 96 "uses a fixed number of trace buffers, but might result in less " 97 "data available for less frequent threads.", 98 "process trace start [<intel-pt-options>]", 99 lldb::eCommandRequiresProcess | lldb::eCommandTryTargetAPILock | 100 lldb::eCommandProcessMustBeLaunched | 101 lldb::eCommandProcessMustBePaused), 102 m_trace(trace), m_options() {} 103 104 Options *GetOptions() override { return &m_options; } 105 106 protected: 107 bool DoExecute(Args &command, CommandReturnObject &result) override; 108 109 TraceIntelPT &m_trace; 110 CommandOptions m_options; 111 }; 112 113 namespace ParsingUtils { 114 /// Convert an integral size expression like 12KiB or 4MB into bytes. The units 115 /// are taken loosely to help users input sizes into LLDB, e.g. KiB and KB are 116 /// considered the same (2^20 bytes) for simplicity. 117 /// 118 /// \param[in] size_expression 119 /// String expression which is an integral number plus a unit that can be 120 /// lower or upper case. Supported units: K, KB and KiB for 2^10 bytes; M, 121 /// MB and MiB for 2^20 bytes; and B for bytes. A single integral number is 122 /// considered bytes. 123 /// \return 124 /// The converted number of bytes or \a llvm::None if the expression is 125 /// invalid. 126 llvm::Optional<uint64_t> 127 ParseUserFriendlySizeExpression(llvm::StringRef size_expression); 128 } // namespace ParsingUtils 129 130 } // namespace trace_intel_pt 131 } // namespace lldb_private 132 133 #endif // LLDB_SOURCE_PLUGINS_TRACE_INTEL_PT_COMMANDOBJECTTRACESTARTINTELPT_H 134