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