1 //===-- CommandObjectTrace.cpp --------------------------------------------===// 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 #include "CommandObjectTrace.h" 10 11 #include "llvm/Support/JSON.h" 12 #include "llvm/Support/MemoryBuffer.h" 13 14 #include "lldb/Core/Debugger.h" 15 #include "lldb/Core/PluginManager.h" 16 #include "lldb/Host/OptionParser.h" 17 #include "lldb/Interpreter/CommandInterpreter.h" 18 #include "lldb/Interpreter/CommandObject.h" 19 #include "lldb/Interpreter/CommandOptionArgumentTable.h" 20 #include "lldb/Interpreter/CommandReturnObject.h" 21 #include "lldb/Interpreter/OptionArgParser.h" 22 #include "lldb/Interpreter/OptionGroupFormat.h" 23 #include "lldb/Interpreter/OptionValueBoolean.h" 24 #include "lldb/Interpreter/OptionValueLanguage.h" 25 #include "lldb/Interpreter/OptionValueString.h" 26 #include "lldb/Interpreter/Options.h" 27 #include "lldb/Target/Process.h" 28 #include "lldb/Target/Trace.h" 29 30 using namespace lldb; 31 using namespace lldb_private; 32 using namespace llvm; 33 34 // CommandObjectTraceSave 35 #define LLDB_OPTIONS_trace_save 36 #include "CommandOptions.inc" 37 38 #pragma mark CommandObjectTraceSave 39 40 class CommandObjectTraceSave : public CommandObjectParsed { 41 public: 42 class CommandOptions : public Options { 43 public: 44 CommandOptions() { OptionParsingStarting(nullptr); } 45 46 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 47 ExecutionContext *execution_context) override { 48 Status error; 49 const int short_option = m_getopt_table[option_idx].val; 50 51 switch (short_option) { 52 case 'c': { 53 m_compact = true; 54 break; 55 } 56 default: 57 llvm_unreachable("Unimplemented option"); 58 } 59 return error; 60 } 61 62 void OptionParsingStarting(ExecutionContext *execution_context) override { 63 m_compact = false; 64 }; 65 66 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 67 return llvm::ArrayRef(g_trace_save_options); 68 }; 69 70 bool m_compact; 71 }; 72 73 Options *GetOptions() override { return &m_options; } 74 75 CommandObjectTraceSave(CommandInterpreter &interpreter) 76 : CommandObjectParsed( 77 interpreter, "trace save", 78 "Save the trace of the current target in the specified directory, " 79 "which will be created if needed. " 80 "This directory will contain a trace bundle, with all the " 81 "necessary files the reconstruct the trace session even on a " 82 "different computer. " 83 "Part of this bundle is the bundle description file with the name " 84 "trace.json. This file can be used by the \"trace load\" command " 85 "to load this trace in LLDB." 86 "Note: if the current target contains information of multiple " 87 "processes or targets, they all will be included in the bundle.", 88 "trace save [<cmd-options>] <bundle_directory>", 89 eCommandRequiresProcess | eCommandTryTargetAPILock | 90 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused | 91 eCommandProcessMustBeTraced) { 92 AddSimpleArgumentList(eArgTypeDirectoryName); 93 } 94 95 void 96 HandleArgumentCompletion(CompletionRequest &request, 97 OptionElementVector &opt_element_vector) override { 98 lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks( 99 GetCommandInterpreter(), lldb::eDiskFileCompletion, request, nullptr); 100 } 101 102 ~CommandObjectTraceSave() override = default; 103 104 protected: 105 void DoExecute(Args &command, CommandReturnObject &result) override { 106 if (command.size() != 1) { 107 result.AppendError("a single path to a directory where the trace bundle " 108 "will be created is required"); 109 return; 110 } 111 112 FileSpec bundle_dir(command[0].ref()); 113 FileSystem::Instance().Resolve(bundle_dir); 114 115 ProcessSP process_sp = m_exe_ctx.GetProcessSP(); 116 117 TraceSP trace_sp = process_sp->GetTarget().GetTrace(); 118 119 if (llvm::Expected<FileSpec> desc_file = 120 trace_sp->SaveToDisk(bundle_dir, m_options.m_compact)) { 121 result.AppendMessageWithFormatv( 122 "Trace bundle description file written to: {0}", *desc_file); 123 result.SetStatus(eReturnStatusSuccessFinishResult); 124 } else { 125 result.AppendError(toString(desc_file.takeError())); 126 } 127 } 128 129 CommandOptions m_options; 130 }; 131 132 // CommandObjectTraceLoad 133 #define LLDB_OPTIONS_trace_load 134 #include "CommandOptions.inc" 135 136 #pragma mark CommandObjectTraceLoad 137 138 class CommandObjectTraceLoad : public CommandObjectParsed { 139 public: 140 class CommandOptions : public Options { 141 public: 142 CommandOptions() { OptionParsingStarting(nullptr); } 143 144 ~CommandOptions() override = default; 145 146 Status SetOptionValue(uint32_t option_idx, StringRef option_arg, 147 ExecutionContext *execution_context) override { 148 Status error; 149 const int short_option = m_getopt_table[option_idx].val; 150 151 switch (short_option) { 152 case 'v': { 153 m_verbose = true; 154 break; 155 } 156 default: 157 llvm_unreachable("Unimplemented option"); 158 } 159 return error; 160 } 161 162 void OptionParsingStarting(ExecutionContext *execution_context) override { 163 m_verbose = false; 164 } 165 166 ArrayRef<OptionDefinition> GetDefinitions() override { 167 return ArrayRef(g_trace_load_options); 168 } 169 170 bool m_verbose; // Enable verbose logging for debugging purposes. 171 }; 172 173 CommandObjectTraceLoad(CommandInterpreter &interpreter) 174 : CommandObjectParsed( 175 interpreter, "trace load", 176 "Load a post-mortem processor trace session from a trace bundle.", 177 "trace load <trace_description_file>") { 178 AddSimpleArgumentList(eArgTypeFilename); 179 } 180 181 void 182 HandleArgumentCompletion(CompletionRequest &request, 183 OptionElementVector &opt_element_vector) override { 184 lldb_private::CommandCompletions::InvokeCommonCompletionCallbacks( 185 GetCommandInterpreter(), lldb::eDiskFileCompletion, request, nullptr); 186 } 187 188 ~CommandObjectTraceLoad() override = default; 189 190 Options *GetOptions() override { return &m_options; } 191 192 protected: 193 void DoExecute(Args &command, CommandReturnObject &result) override { 194 if (command.size() != 1) { 195 result.AppendError("a single path to a JSON file containing a the " 196 "description of the trace bundle is required"); 197 return; 198 } 199 200 const FileSpec trace_description_file(command[0].ref()); 201 202 llvm::Expected<lldb::TraceSP> trace_or_err = 203 Trace::LoadPostMortemTraceFromFile(GetDebugger(), 204 trace_description_file); 205 206 if (!trace_or_err) { 207 result.AppendErrorWithFormat( 208 "%s\n", llvm::toString(trace_or_err.takeError()).c_str()); 209 return; 210 } 211 212 if (m_options.m_verbose) { 213 result.AppendMessageWithFormatv("loading trace with plugin {0}\n", 214 trace_or_err.get()->GetPluginName()); 215 } 216 217 result.SetStatus(eReturnStatusSuccessFinishResult); 218 } 219 220 CommandOptions m_options; 221 }; 222 223 // CommandObjectTraceDump 224 #define LLDB_OPTIONS_trace_dump 225 #include "CommandOptions.inc" 226 227 #pragma mark CommandObjectTraceDump 228 229 class CommandObjectTraceDump : public CommandObjectParsed { 230 public: 231 class CommandOptions : public Options { 232 public: 233 CommandOptions() { OptionParsingStarting(nullptr); } 234 235 ~CommandOptions() override = default; 236 237 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 238 ExecutionContext *execution_context) override { 239 Status error; 240 const int short_option = m_getopt_table[option_idx].val; 241 242 switch (short_option) { 243 case 'v': { 244 m_verbose = true; 245 break; 246 } 247 default: 248 llvm_unreachable("Unimplemented option"); 249 } 250 return error; 251 } 252 253 void OptionParsingStarting(ExecutionContext *execution_context) override { 254 m_verbose = false; 255 } 256 257 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 258 return llvm::ArrayRef(g_trace_dump_options); 259 } 260 261 bool m_verbose; // Enable verbose logging for debugging purposes. 262 }; 263 264 CommandObjectTraceDump(CommandInterpreter &interpreter) 265 : CommandObjectParsed(interpreter, "trace dump", 266 "Dump the loaded processor trace data.", 267 "trace dump") {} 268 269 ~CommandObjectTraceDump() override = default; 270 271 Options *GetOptions() override { return &m_options; } 272 273 protected: 274 void DoExecute(Args &command, CommandReturnObject &result) override { 275 Status error; 276 // TODO: fill in the dumping code here! 277 if (error.Success()) { 278 result.SetStatus(eReturnStatusSuccessFinishResult); 279 } else { 280 result.AppendErrorWithFormat("%s\n", error.AsCString()); 281 } 282 } 283 284 CommandOptions m_options; 285 }; 286 287 // CommandObjectTraceSchema 288 #define LLDB_OPTIONS_trace_schema 289 #include "CommandOptions.inc" 290 291 #pragma mark CommandObjectTraceSchema 292 293 class CommandObjectTraceSchema : public CommandObjectParsed { 294 public: 295 class CommandOptions : public Options { 296 public: 297 CommandOptions() { OptionParsingStarting(nullptr); } 298 299 ~CommandOptions() override = default; 300 301 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 302 ExecutionContext *execution_context) override { 303 Status error; 304 const int short_option = m_getopt_table[option_idx].val; 305 306 switch (short_option) { 307 case 'v': { 308 m_verbose = true; 309 break; 310 } 311 default: 312 llvm_unreachable("Unimplemented option"); 313 } 314 return error; 315 } 316 317 void OptionParsingStarting(ExecutionContext *execution_context) override { 318 m_verbose = false; 319 } 320 321 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 322 return llvm::ArrayRef(g_trace_schema_options); 323 } 324 325 bool m_verbose; // Enable verbose logging for debugging purposes. 326 }; 327 328 CommandObjectTraceSchema(CommandInterpreter &interpreter) 329 : CommandObjectParsed(interpreter, "trace schema", 330 "Show the schema of the given trace plugin.", 331 "trace schema <plug-in>. Use the plug-in name " 332 "\"all\" to see all schemas.\n") { 333 AddSimpleArgumentList(eArgTypeNone); 334 } 335 336 ~CommandObjectTraceSchema() override = default; 337 338 Options *GetOptions() override { return &m_options; } 339 340 protected: 341 void DoExecute(Args &command, CommandReturnObject &result) override { 342 Status error; 343 if (command.empty()) { 344 result.AppendError( 345 "trace schema cannot be invoked without a plug-in as argument"); 346 return; 347 } 348 349 StringRef plugin_name(command[0].c_str()); 350 if (plugin_name == "all") { 351 size_t index = 0; 352 while (true) { 353 StringRef schema = PluginManager::GetTraceSchema(index++); 354 if (schema.empty()) 355 break; 356 357 result.AppendMessage(schema); 358 } 359 } else { 360 if (Expected<StringRef> schemaOrErr = 361 Trace::FindPluginSchema(plugin_name)) 362 result.AppendMessage(*schemaOrErr); 363 else 364 error = Status::FromError(schemaOrErr.takeError()); 365 } 366 367 if (error.Success()) { 368 result.SetStatus(eReturnStatusSuccessFinishResult); 369 } else { 370 result.AppendErrorWithFormat("%s\n", error.AsCString()); 371 } 372 } 373 374 CommandOptions m_options; 375 }; 376 377 // CommandObjectTrace 378 379 CommandObjectTrace::CommandObjectTrace(CommandInterpreter &interpreter) 380 : CommandObjectMultiword(interpreter, "trace", 381 "Commands for loading and using processor " 382 "trace information.", 383 "trace [<sub-command-options>]") { 384 LoadSubCommand("load", 385 CommandObjectSP(new CommandObjectTraceLoad(interpreter))); 386 LoadSubCommand("dump", 387 CommandObjectSP(new CommandObjectTraceDump(interpreter))); 388 LoadSubCommand("save", 389 CommandObjectSP(new CommandObjectTraceSave(interpreter))); 390 LoadSubCommand("schema", 391 CommandObjectSP(new CommandObjectTraceSchema(interpreter))); 392 } 393 394 CommandObjectTrace::~CommandObjectTrace() = default; 395 396 Expected<CommandObjectSP> CommandObjectTraceProxy::DoGetProxyCommandObject() { 397 ProcessSP process_sp = m_interpreter.GetExecutionContext().GetProcessSP(); 398 399 if (!process_sp) 400 return createStringError(inconvertibleErrorCode(), 401 "Process not available."); 402 if (m_live_debug_session_only && !process_sp->IsLiveDebugSession()) 403 return createStringError(inconvertibleErrorCode(), 404 "Process must be alive."); 405 406 if (Expected<TraceSP> trace_sp = process_sp->GetTarget().GetTraceOrCreate()) 407 return GetDelegateCommand(**trace_sp); 408 else 409 return createStringError(inconvertibleErrorCode(), 410 "Tracing is not supported. %s", 411 toString(trace_sp.takeError()).c_str()); 412 } 413 414 CommandObject *CommandObjectTraceProxy::GetProxyCommandObject() { 415 if (Expected<CommandObjectSP> delegate = DoGetProxyCommandObject()) { 416 m_delegate_sp = *delegate; 417 m_delegate_error.clear(); 418 return m_delegate_sp.get(); 419 } else { 420 m_delegate_sp.reset(); 421 m_delegate_error = toString(delegate.takeError()); 422 return nullptr; 423 } 424 } 425