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 #include "lldb/lldb-python.h"
11
12 #include "CommandObjectLog.h"
13
14 // C Includes
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 #include "lldb/lldb-private-log.h"
19
20 #include "lldb/Interpreter/Args.h"
21 #include "lldb/Core/Debugger.h"
22 #include "lldb/Host/FileSpec.h"
23 #include "lldb/Core/Log.h"
24 #include "lldb/Core/Module.h"
25 #include "lldb/Interpreter/Options.h"
26 #include "lldb/Core/RegularExpression.h"
27 #include "lldb/Core/Stream.h"
28 #include "lldb/Core/StreamFile.h"
29 #include "lldb/Core/Timer.h"
30
31 #include "lldb/Core/Debugger.h"
32 #include "lldb/Interpreter/CommandInterpreter.h"
33 #include "lldb/Interpreter/CommandReturnObject.h"
34
35 #include "lldb/Symbol/LineTable.h"
36 #include "lldb/Symbol/ObjectFile.h"
37 #include "lldb/Symbol/SymbolFile.h"
38 #include "lldb/Symbol/SymbolVendor.h"
39
40 #include "lldb/Target/Process.h"
41 #include "lldb/Target/Target.h"
42
43 using namespace lldb;
44 using namespace lldb_private;
45
46
47 class CommandObjectLogEnable : public CommandObjectParsed
48 {
49 public:
50 //------------------------------------------------------------------
51 // Constructors and Destructors
52 //------------------------------------------------------------------
CommandObjectLogEnable(CommandInterpreter & interpreter)53 CommandObjectLogEnable(CommandInterpreter &interpreter) :
54 CommandObjectParsed (interpreter,
55 "log enable",
56 "Enable logging for a single log channel.",
57 NULL),
58 m_options (interpreter)
59 {
60
61 CommandArgumentEntry arg1;
62 CommandArgumentEntry arg2;
63 CommandArgumentData channel_arg;
64 CommandArgumentData category_arg;
65
66 // Define the first (and only) variant of this arg.
67 channel_arg.arg_type = eArgTypeLogChannel;
68 channel_arg.arg_repetition = eArgRepeatPlain;
69
70 // There is only one variant this argument could be; put it into the argument entry.
71 arg1.push_back (channel_arg);
72
73 category_arg.arg_type = eArgTypeLogCategory;
74 category_arg.arg_repetition = eArgRepeatPlus;
75
76 arg2.push_back (category_arg);
77
78 // Push the data for the first argument into the m_arguments vector.
79 m_arguments.push_back (arg1);
80 m_arguments.push_back (arg2);
81 }
82
83 virtual
~CommandObjectLogEnable()84 ~CommandObjectLogEnable()
85 {
86 }
87
88 Options *
GetOptions()89 GetOptions ()
90 {
91 return &m_options;
92 }
93
94 // int
95 // HandleArgumentCompletion (Args &input,
96 // int &cursor_index,
97 // int &cursor_char_position,
98 // OptionElementVector &opt_element_vector,
99 // int match_start_point,
100 // int max_return_elements,
101 // bool &word_complete,
102 // StringList &matches)
103 // {
104 // std::string completion_str (input.GetArgumentAtIndex(cursor_index));
105 // completion_str.erase (cursor_char_position);
106 //
107 // if (cursor_index == 1)
108 // {
109 // //
110 // Log::AutoCompleteChannelName (completion_str.c_str(), matches);
111 // }
112 // return matches.GetSize();
113 // }
114 //
115
116 class CommandOptions : public Options
117 {
118 public:
119
CommandOptions(CommandInterpreter & interpreter)120 CommandOptions (CommandInterpreter &interpreter) :
121 Options (interpreter),
122 log_file (),
123 log_options (0)
124 {
125 }
126
127
128 virtual
~CommandOptions()129 ~CommandOptions ()
130 {
131 }
132
133 virtual Error
SetOptionValue(uint32_t option_idx,const char * option_arg)134 SetOptionValue (uint32_t option_idx, const char *option_arg)
135 {
136 Error error;
137 const int short_option = m_getopt_table[option_idx].val;
138
139 switch (short_option)
140 {
141 case 'f': log_file.SetFile(option_arg, true); break;
142 case 't': log_options |= LLDB_LOG_OPTION_THREADSAFE; break;
143 case 'v': log_options |= LLDB_LOG_OPTION_VERBOSE; break;
144 case 'g': log_options |= LLDB_LOG_OPTION_DEBUG; break;
145 case 's': log_options |= LLDB_LOG_OPTION_PREPEND_SEQUENCE; break;
146 case 'T': log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP; break;
147 case 'p': log_options |= LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD;break;
148 case 'n': log_options |= LLDB_LOG_OPTION_PREPEND_THREAD_NAME; break;
149 case 'S': log_options |= LLDB_LOG_OPTION_BACKTRACE; break;
150 default:
151 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
152 break;
153 }
154
155 return error;
156 }
157
158 void
OptionParsingStarting()159 OptionParsingStarting ()
160 {
161 log_file.Clear();
162 log_options = 0;
163 }
164
165 const OptionDefinition*
GetDefinitions()166 GetDefinitions ()
167 {
168 return g_option_table;
169 }
170
171 // Options table: Required for subclasses of Options.
172
173 static OptionDefinition g_option_table[];
174
175 // Instance variables to hold the values for command options.
176
177 FileSpec log_file;
178 uint32_t log_options;
179 };
180
181 protected:
182 virtual bool
DoExecute(Args & args,CommandReturnObject & result)183 DoExecute (Args& args,
184 CommandReturnObject &result)
185 {
186 if (args.GetArgumentCount() < 2)
187 {
188 result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str());
189 }
190 else
191 {
192 std::string channel(args.GetArgumentAtIndex(0));
193 args.Shift (); // Shift off the channel
194 char log_file[PATH_MAX];
195 if (m_options.log_file)
196 m_options.log_file.GetPath(log_file, sizeof(log_file));
197 else
198 log_file[0] = '\0';
199 bool success = m_interpreter.GetDebugger().EnableLog (channel.c_str(),
200 args.GetConstArgumentVector(),
201 log_file,
202 m_options.log_options,
203 result.GetErrorStream());
204 if (success)
205 result.SetStatus (eReturnStatusSuccessFinishNoResult);
206 else
207 result.SetStatus (eReturnStatusFailed);
208 }
209 return result.Succeeded();
210 }
211
212 CommandOptions m_options;
213 };
214
215 OptionDefinition
216 CommandObjectLogEnable::CommandOptions::g_option_table[] =
217 {
218 { LLDB_OPT_SET_1, false, "file", 'f', required_argument, NULL, 0, eArgTypeFilename, "Set the destination file to log to."},
219 { LLDB_OPT_SET_1, false, "threadsafe", 't', no_argument, NULL, 0, eArgTypeNone, "Enable thread safe logging to avoid interweaved log lines." },
220 { LLDB_OPT_SET_1, false, "verbose", 'v', no_argument, NULL, 0, eArgTypeNone, "Enable verbose logging." },
221 { LLDB_OPT_SET_1, false, "debug", 'g', no_argument, NULL, 0, eArgTypeNone, "Enable debug logging." },
222 { LLDB_OPT_SET_1, false, "sequence", 's', no_argument, NULL, 0, eArgTypeNone, "Prepend all log lines with an increasing integer sequence id." },
223 { LLDB_OPT_SET_1, false, "timestamp", 'T', no_argument, NULL, 0, eArgTypeNone, "Prepend all log lines with a timestamp." },
224 { LLDB_OPT_SET_1, false, "pid-tid", 'p', no_argument, NULL, 0, eArgTypeNone, "Prepend all log lines with the process and thread ID that generates the log line." },
225 { LLDB_OPT_SET_1, false, "thread-name",'n', no_argument, NULL, 0, eArgTypeNone, "Prepend all log lines with the thread name for the thread that generates the log line." },
226 { LLDB_OPT_SET_1, false, "stack", 'S', no_argument, NULL, 0, eArgTypeNone, "Append a stack backtrace to each log line." },
227 { 0, false, NULL, 0, 0, NULL, 0, eArgTypeNone, NULL }
228 };
229
230 class CommandObjectLogDisable : public CommandObjectParsed
231 {
232 public:
233 //------------------------------------------------------------------
234 // Constructors and Destructors
235 //------------------------------------------------------------------
CommandObjectLogDisable(CommandInterpreter & interpreter)236 CommandObjectLogDisable(CommandInterpreter &interpreter) :
237 CommandObjectParsed (interpreter,
238 "log disable",
239 "Disable one or more log channel categories.",
240 NULL)
241 {
242 CommandArgumentEntry arg1;
243 CommandArgumentEntry arg2;
244 CommandArgumentData channel_arg;
245 CommandArgumentData category_arg;
246
247 // Define the first (and only) variant of this arg.
248 channel_arg.arg_type = eArgTypeLogChannel;
249 channel_arg.arg_repetition = eArgRepeatPlain;
250
251 // There is only one variant this argument could be; put it into the argument entry.
252 arg1.push_back (channel_arg);
253
254 category_arg.arg_type = eArgTypeLogCategory;
255 category_arg.arg_repetition = eArgRepeatPlus;
256
257 arg2.push_back (category_arg);
258
259 // Push the data for the first argument into the m_arguments vector.
260 m_arguments.push_back (arg1);
261 m_arguments.push_back (arg2);
262 }
263
264 virtual
~CommandObjectLogDisable()265 ~CommandObjectLogDisable()
266 {
267 }
268
269 protected:
270 virtual bool
DoExecute(Args & args,CommandReturnObject & result)271 DoExecute (Args& args,
272 CommandReturnObject &result)
273 {
274 const size_t argc = args.GetArgumentCount();
275 if (argc == 0)
276 {
277 result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str());
278 }
279 else
280 {
281 Log::Callbacks log_callbacks;
282
283 std::string channel(args.GetArgumentAtIndex(0));
284 args.Shift (); // Shift off the channel
285 if (Log::GetLogChannelCallbacks (ConstString(channel.c_str()), log_callbacks))
286 {
287 log_callbacks.disable (args.GetConstArgumentVector(), &result.GetErrorStream());
288 result.SetStatus(eReturnStatusSuccessFinishNoResult);
289 }
290 else if (channel == "all")
291 {
292 Log::DisableAllLogChannels(&result.GetErrorStream());
293 }
294 else
295 {
296 LogChannelSP log_channel_sp (LogChannel::FindPlugin(channel.c_str()));
297 if (log_channel_sp)
298 {
299 log_channel_sp->Disable(args.GetConstArgumentVector(), &result.GetErrorStream());
300 result.SetStatus(eReturnStatusSuccessFinishNoResult);
301 }
302 else
303 result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0));
304 }
305 }
306 return result.Succeeded();
307 }
308 };
309
310 class CommandObjectLogList : public CommandObjectParsed
311 {
312 public:
313 //------------------------------------------------------------------
314 // Constructors and Destructors
315 //------------------------------------------------------------------
CommandObjectLogList(CommandInterpreter & interpreter)316 CommandObjectLogList(CommandInterpreter &interpreter) :
317 CommandObjectParsed (interpreter,
318 "log list",
319 "List the log categories for one or more log channels. If none specified, lists them all.",
320 NULL)
321 {
322 CommandArgumentEntry arg;
323 CommandArgumentData channel_arg;
324
325 // Define the first (and only) variant of this arg.
326 channel_arg.arg_type = eArgTypeLogChannel;
327 channel_arg.arg_repetition = eArgRepeatStar;
328
329 // There is only one variant this argument could be; put it into the argument entry.
330 arg.push_back (channel_arg);
331
332 // Push the data for the first argument into the m_arguments vector.
333 m_arguments.push_back (arg);
334 }
335
336 virtual
~CommandObjectLogList()337 ~CommandObjectLogList()
338 {
339 }
340
341 protected:
342 virtual bool
DoExecute(Args & args,CommandReturnObject & result)343 DoExecute (Args& args,
344 CommandReturnObject &result)
345 {
346 const size_t argc = args.GetArgumentCount();
347 if (argc == 0)
348 {
349 Log::ListAllLogChannels (&result.GetOutputStream());
350 result.SetStatus(eReturnStatusSuccessFinishResult);
351 }
352 else
353 {
354 for (size_t i=0; i<argc; ++i)
355 {
356 Log::Callbacks log_callbacks;
357
358 std::string channel(args.GetArgumentAtIndex(i));
359 if (Log::GetLogChannelCallbacks (ConstString(channel.c_str()), log_callbacks))
360 {
361 log_callbacks.list_categories (&result.GetOutputStream());
362 result.SetStatus(eReturnStatusSuccessFinishResult);
363 }
364 else if (channel == "all")
365 {
366 Log::ListAllLogChannels (&result.GetOutputStream());
367 result.SetStatus(eReturnStatusSuccessFinishResult);
368 }
369 else
370 {
371 LogChannelSP log_channel_sp (LogChannel::FindPlugin(channel.c_str()));
372 if (log_channel_sp)
373 {
374 log_channel_sp->ListCategories(&result.GetOutputStream());
375 result.SetStatus(eReturnStatusSuccessFinishNoResult);
376 }
377 else
378 result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0));
379 }
380 }
381 }
382 return result.Succeeded();
383 }
384 };
385
386 class CommandObjectLogTimer : public CommandObjectParsed
387 {
388 public:
389 //------------------------------------------------------------------
390 // Constructors and Destructors
391 //------------------------------------------------------------------
CommandObjectLogTimer(CommandInterpreter & interpreter)392 CommandObjectLogTimer(CommandInterpreter &interpreter) :
393 CommandObjectParsed (interpreter,
394 "log timers",
395 "Enable, disable, dump, and reset LLDB internal performance timers.",
396 "log timers < enable <depth> | disable | dump | increment <bool> | reset >")
397 {
398 }
399
400 virtual
~CommandObjectLogTimer()401 ~CommandObjectLogTimer()
402 {
403 }
404
405 protected:
406 virtual bool
DoExecute(Args & args,CommandReturnObject & result)407 DoExecute (Args& args,
408 CommandReturnObject &result)
409 {
410 const size_t argc = args.GetArgumentCount();
411 result.SetStatus(eReturnStatusFailed);
412
413 if (argc == 1)
414 {
415 const char *sub_command = args.GetArgumentAtIndex(0);
416
417 if (strcasecmp(sub_command, "enable") == 0)
418 {
419 Timer::SetDisplayDepth (UINT32_MAX);
420 result.SetStatus(eReturnStatusSuccessFinishNoResult);
421 }
422 else if (strcasecmp(sub_command, "disable") == 0)
423 {
424 Timer::DumpCategoryTimes (&result.GetOutputStream());
425 Timer::SetDisplayDepth (0);
426 result.SetStatus(eReturnStatusSuccessFinishResult);
427 }
428 else if (strcasecmp(sub_command, "dump") == 0)
429 {
430 Timer::DumpCategoryTimes (&result.GetOutputStream());
431 result.SetStatus(eReturnStatusSuccessFinishResult);
432 }
433 else if (strcasecmp(sub_command, "reset") == 0)
434 {
435 Timer::ResetCategoryTimes ();
436 result.SetStatus(eReturnStatusSuccessFinishResult);
437 }
438
439 }
440 else if (argc == 2)
441 {
442 const char *sub_command = args.GetArgumentAtIndex(0);
443
444 if (strcasecmp(sub_command, "enable") == 0)
445 {
446 bool success;
447 uint32_t depth = Args::StringToUInt32(args.GetArgumentAtIndex(1), 0, 0, &success);
448 if (success)
449 {
450 Timer::SetDisplayDepth (depth);
451 result.SetStatus(eReturnStatusSuccessFinishNoResult);
452 }
453 else
454 result.AppendError("Could not convert enable depth to an unsigned integer.");
455 }
456 if (strcasecmp(sub_command, "increment") == 0)
457 {
458 bool success;
459 bool increment = Args::StringToBoolean(args.GetArgumentAtIndex(1), false, &success);
460 if (success)
461 {
462 Timer::SetQuiet (!increment);
463 result.SetStatus(eReturnStatusSuccessFinishNoResult);
464 }
465 else
466 result.AppendError("Could not convert increment value to boolean.");
467 }
468 }
469
470 if (!result.Succeeded())
471 {
472 result.AppendError("Missing subcommand");
473 result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
474 }
475 return result.Succeeded();
476 }
477 };
478
479 //----------------------------------------------------------------------
480 // CommandObjectLog constructor
481 //----------------------------------------------------------------------
CommandObjectLog(CommandInterpreter & interpreter)482 CommandObjectLog::CommandObjectLog(CommandInterpreter &interpreter) :
483 CommandObjectMultiword (interpreter,
484 "log",
485 "A set of commands for operating on logs.",
486 "log <command> [<command-options>]")
487 {
488 LoadSubCommand ("enable", CommandObjectSP (new CommandObjectLogEnable (interpreter)));
489 LoadSubCommand ("disable", CommandObjectSP (new CommandObjectLogDisable (interpreter)));
490 LoadSubCommand ("list", CommandObjectSP (new CommandObjectLogList (interpreter)));
491 LoadSubCommand ("timers", CommandObjectSP (new CommandObjectLogTimer (interpreter)));
492 }
493
494 //----------------------------------------------------------------------
495 // Destructor
496 //----------------------------------------------------------------------
~CommandObjectLog()497 CommandObjectLog::~CommandObjectLog()
498 {
499 }
500
501
502
503
504