1 //===-- CommandObjectLog.cpp ------------------------------------*- 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 #include "CommandObjectLog.h" 10 #include "lldb/Core/Debugger.h" 11 #include "lldb/Core/Module.h" 12 #include "lldb/Core/StreamFile.h" 13 #include "lldb/Host/OptionParser.h" 14 #include "lldb/Interpreter/CommandInterpreter.h" 15 #include "lldb/Interpreter/CommandReturnObject.h" 16 #include "lldb/Interpreter/OptionArgParser.h" 17 #include "lldb/Interpreter/Options.h" 18 #include "lldb/Symbol/LineTable.h" 19 #include "lldb/Symbol/ObjectFile.h" 20 #include "lldb/Symbol/SymbolFile.h" 21 #include "lldb/Symbol/SymbolVendor.h" 22 #include "lldb/Target/Process.h" 23 #include "lldb/Target/Target.h" 24 #include "lldb/Utility/Args.h" 25 #include "lldb/Utility/FileSpec.h" 26 #include "lldb/Utility/Log.h" 27 #include "lldb/Utility/RegularExpression.h" 28 #include "lldb/Utility/Stream.h" 29 #include "lldb/Utility/Timer.h" 30 31 using namespace lldb; 32 using namespace lldb_private; 33 34 static constexpr OptionDefinition g_log_options[] = { 35 // clang-format off 36 { LLDB_OPT_SET_1, false, "file", 'f', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeFilename, "Set the destination file to log to." }, 37 { LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Enable thread safe logging to avoid interweaved log lines." }, 38 { LLDB_OPT_SET_1, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Enable verbose logging." }, 39 { LLDB_OPT_SET_1, false, "sequence", 's', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Prepend all log lines with an increasing integer sequence id." }, 40 { LLDB_OPT_SET_1, false, "timestamp", 'T', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Prepend all log lines with a timestamp." }, 41 { LLDB_OPT_SET_1, false, "pid-tid", 'p', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Prepend all log lines with the process and thread ID that generates the log line." }, 42 { LLDB_OPT_SET_1, false, "thread-name",'n', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Prepend all log lines with the thread name for the thread that generates the log line." }, 43 { LLDB_OPT_SET_1, false, "stack", 'S', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Append a stack backtrace to each log line." }, 44 { LLDB_OPT_SET_1, false, "append", 'a', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Append to the log file instead of overwriting." }, 45 { LLDB_OPT_SET_1, false, "file-function",'F',OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Prepend the names of files and function that generate the logs." }, 46 // clang-format on 47 }; 48 49 class CommandObjectLogEnable : public CommandObjectParsed { 50 public: 51 // Constructors and Destructors 52 CommandObjectLogEnable(CommandInterpreter &interpreter) 53 : CommandObjectParsed(interpreter, "log enable", 54 "Enable logging for a single log channel.", 55 nullptr), 56 m_options() { 57 CommandArgumentEntry arg1; 58 CommandArgumentEntry arg2; 59 CommandArgumentData channel_arg; 60 CommandArgumentData category_arg; 61 62 // Define the first (and only) variant of this arg. 63 channel_arg.arg_type = eArgTypeLogChannel; 64 channel_arg.arg_repetition = eArgRepeatPlain; 65 66 // There is only one variant this argument could be; put it into the 67 // argument entry. 68 arg1.push_back(channel_arg); 69 70 category_arg.arg_type = eArgTypeLogCategory; 71 category_arg.arg_repetition = eArgRepeatPlus; 72 73 arg2.push_back(category_arg); 74 75 // Push the data for the first argument into the m_arguments vector. 76 m_arguments.push_back(arg1); 77 m_arguments.push_back(arg2); 78 } 79 80 ~CommandObjectLogEnable() override = default; 81 82 Options *GetOptions() override { return &m_options; } 83 84 class CommandOptions : public Options { 85 public: 86 CommandOptions() : Options(), log_file(), log_options(0) {} 87 88 ~CommandOptions() override = default; 89 90 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 91 ExecutionContext *execution_context) override { 92 Status error; 93 const int short_option = m_getopt_table[option_idx].val; 94 95 switch (short_option) { 96 case 'f': 97 log_file.SetFile(option_arg, FileSpec::Style::native); 98 FileSystem::Instance().Resolve(log_file); 99 break; 100 case 't': 101 log_options |= LLDB_LOG_OPTION_THREADSAFE; 102 break; 103 case 'v': 104 log_options |= LLDB_LOG_OPTION_VERBOSE; 105 break; 106 case 's': 107 log_options |= LLDB_LOG_OPTION_PREPEND_SEQUENCE; 108 break; 109 case 'T': 110 log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP; 111 break; 112 case 'p': 113 log_options |= LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD; 114 break; 115 case 'n': 116 log_options |= LLDB_LOG_OPTION_PREPEND_THREAD_NAME; 117 break; 118 case 'S': 119 log_options |= LLDB_LOG_OPTION_BACKTRACE; 120 break; 121 case 'a': 122 log_options |= LLDB_LOG_OPTION_APPEND; 123 break; 124 case 'F': 125 log_options |= LLDB_LOG_OPTION_PREPEND_FILE_FUNCTION; 126 break; 127 default: 128 error.SetErrorStringWithFormat("unrecognized option '%c'", 129 short_option); 130 break; 131 } 132 133 return error; 134 } 135 136 void OptionParsingStarting(ExecutionContext *execution_context) override { 137 log_file.Clear(); 138 log_options = 0; 139 } 140 141 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 142 return llvm::makeArrayRef(g_log_options); 143 } 144 145 // Instance variables to hold the values for command options. 146 147 FileSpec log_file; 148 uint32_t log_options; 149 }; 150 151 protected: 152 bool DoExecute(Args &args, CommandReturnObject &result) override { 153 if (args.GetArgumentCount() < 2) { 154 result.AppendErrorWithFormat( 155 "%s takes a log channel and one or more log types.\n", 156 m_cmd_name.c_str()); 157 return false; 158 } 159 160 // Store into a std::string since we're about to shift the channel off. 161 const std::string channel = args[0].ref; 162 args.Shift(); // Shift off the channel 163 char log_file[PATH_MAX]; 164 if (m_options.log_file) 165 m_options.log_file.GetPath(log_file, sizeof(log_file)); 166 else 167 log_file[0] = '\0'; 168 169 std::string error; 170 llvm::raw_string_ostream error_stream(error); 171 bool success = 172 GetDebugger().EnableLog(channel, args.GetArgumentArrayRef(), log_file, 173 m_options.log_options, error_stream); 174 result.GetErrorStream() << error_stream.str(); 175 176 if (success) 177 result.SetStatus(eReturnStatusSuccessFinishNoResult); 178 else 179 result.SetStatus(eReturnStatusFailed); 180 return result.Succeeded(); 181 } 182 183 CommandOptions m_options; 184 }; 185 186 class CommandObjectLogDisable : public CommandObjectParsed { 187 public: 188 // Constructors and Destructors 189 CommandObjectLogDisable(CommandInterpreter &interpreter) 190 : CommandObjectParsed(interpreter, "log disable", 191 "Disable one or more log channel categories.", 192 nullptr) { 193 CommandArgumentEntry arg1; 194 CommandArgumentEntry arg2; 195 CommandArgumentData channel_arg; 196 CommandArgumentData category_arg; 197 198 // Define the first (and only) variant of this arg. 199 channel_arg.arg_type = eArgTypeLogChannel; 200 channel_arg.arg_repetition = eArgRepeatPlain; 201 202 // There is only one variant this argument could be; put it into the 203 // argument entry. 204 arg1.push_back(channel_arg); 205 206 category_arg.arg_type = eArgTypeLogCategory; 207 category_arg.arg_repetition = eArgRepeatPlus; 208 209 arg2.push_back(category_arg); 210 211 // Push the data for the first argument into the m_arguments vector. 212 m_arguments.push_back(arg1); 213 m_arguments.push_back(arg2); 214 } 215 216 ~CommandObjectLogDisable() override = default; 217 218 protected: 219 bool DoExecute(Args &args, CommandReturnObject &result) override { 220 if (args.empty()) { 221 result.AppendErrorWithFormat( 222 "%s takes a log channel and one or more log types.\n", 223 m_cmd_name.c_str()); 224 return false; 225 } 226 227 const std::string channel = args[0].ref; 228 args.Shift(); // Shift off the channel 229 if (channel == "all") { 230 Log::DisableAllLogChannels(); 231 result.SetStatus(eReturnStatusSuccessFinishNoResult); 232 } else { 233 std::string error; 234 llvm::raw_string_ostream error_stream(error); 235 if (Log::DisableLogChannel(channel, args.GetArgumentArrayRef(), 236 error_stream)) 237 result.SetStatus(eReturnStatusSuccessFinishNoResult); 238 result.GetErrorStream() << error_stream.str(); 239 } 240 return result.Succeeded(); 241 } 242 }; 243 244 class CommandObjectLogList : public CommandObjectParsed { 245 public: 246 // Constructors and Destructors 247 CommandObjectLogList(CommandInterpreter &interpreter) 248 : CommandObjectParsed(interpreter, "log list", 249 "List the log categories for one or more log " 250 "channels. If none specified, lists them all.", 251 nullptr) { 252 CommandArgumentEntry arg; 253 CommandArgumentData channel_arg; 254 255 // Define the first (and only) variant of this arg. 256 channel_arg.arg_type = eArgTypeLogChannel; 257 channel_arg.arg_repetition = eArgRepeatStar; 258 259 // There is only one variant this argument could be; put it into the 260 // argument entry. 261 arg.push_back(channel_arg); 262 263 // Push the data for the first argument into the m_arguments vector. 264 m_arguments.push_back(arg); 265 } 266 267 ~CommandObjectLogList() override = default; 268 269 protected: 270 bool DoExecute(Args &args, CommandReturnObject &result) override { 271 std::string output; 272 llvm::raw_string_ostream output_stream(output); 273 if (args.empty()) { 274 Log::ListAllLogChannels(output_stream); 275 result.SetStatus(eReturnStatusSuccessFinishResult); 276 } else { 277 bool success = true; 278 for (const auto &entry : args.entries()) 279 success = 280 success && Log::ListChannelCategories(entry.ref, output_stream); 281 if (success) 282 result.SetStatus(eReturnStatusSuccessFinishResult); 283 } 284 result.GetOutputStream() << output_stream.str(); 285 return result.Succeeded(); 286 } 287 }; 288 289 class CommandObjectLogTimer : public CommandObjectParsed { 290 public: 291 // Constructors and Destructors 292 CommandObjectLogTimer(CommandInterpreter &interpreter) 293 : CommandObjectParsed(interpreter, "log timers", 294 "Enable, disable, dump, and reset LLDB internal " 295 "performance timers.", 296 "log timers < enable <depth> | disable | dump | " 297 "increment <bool> | reset >") {} 298 299 ~CommandObjectLogTimer() override = default; 300 301 protected: 302 bool DoExecute(Args &args, CommandReturnObject &result) override { 303 result.SetStatus(eReturnStatusFailed); 304 305 if (args.GetArgumentCount() == 1) { 306 auto sub_command = args[0].ref; 307 308 if (sub_command.equals_lower("enable")) { 309 Timer::SetDisplayDepth(UINT32_MAX); 310 result.SetStatus(eReturnStatusSuccessFinishNoResult); 311 } else if (sub_command.equals_lower("disable")) { 312 Timer::DumpCategoryTimes(&result.GetOutputStream()); 313 Timer::SetDisplayDepth(0); 314 result.SetStatus(eReturnStatusSuccessFinishResult); 315 } else if (sub_command.equals_lower("dump")) { 316 Timer::DumpCategoryTimes(&result.GetOutputStream()); 317 result.SetStatus(eReturnStatusSuccessFinishResult); 318 } else if (sub_command.equals_lower("reset")) { 319 Timer::ResetCategoryTimes(); 320 result.SetStatus(eReturnStatusSuccessFinishResult); 321 } 322 } else if (args.GetArgumentCount() == 2) { 323 auto sub_command = args[0].ref; 324 auto param = args[1].ref; 325 326 if (sub_command.equals_lower("enable")) { 327 uint32_t depth; 328 if (param.consumeInteger(0, depth)) { 329 result.AppendError( 330 "Could not convert enable depth to an unsigned integer."); 331 } else { 332 Timer::SetDisplayDepth(depth); 333 result.SetStatus(eReturnStatusSuccessFinishNoResult); 334 } 335 } else if (sub_command.equals_lower("increment")) { 336 bool success; 337 bool increment = OptionArgParser::ToBoolean(param, false, &success); 338 if (success) { 339 Timer::SetQuiet(!increment); 340 result.SetStatus(eReturnStatusSuccessFinishNoResult); 341 } else 342 result.AppendError("Could not convert increment value to boolean."); 343 } 344 } 345 346 if (!result.Succeeded()) { 347 result.AppendError("Missing subcommand"); 348 result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str()); 349 } 350 return result.Succeeded(); 351 } 352 }; 353 354 CommandObjectLog::CommandObjectLog(CommandInterpreter &interpreter) 355 : CommandObjectMultiword(interpreter, "log", 356 "Commands controlling LLDB internal logging.", 357 "log <subcommand> [<command-options>]") { 358 LoadSubCommand("enable", 359 CommandObjectSP(new CommandObjectLogEnable(interpreter))); 360 LoadSubCommand("disable", 361 CommandObjectSP(new CommandObjectLogDisable(interpreter))); 362 LoadSubCommand("list", 363 CommandObjectSP(new CommandObjectLogList(interpreter))); 364 LoadSubCommand("timers", 365 CommandObjectSP(new CommandObjectLogTimer(interpreter))); 366 } 367 368 CommandObjectLog::~CommandObjectLog() = default; 369