1 //===-- StructuredDataDarwinLog.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 "StructuredDataDarwinLog.h" 10 11 #include <string.h> 12 13 #include <memory> 14 #include <sstream> 15 16 #include "lldb/Breakpoint/StoppointCallbackContext.h" 17 #include "lldb/Core/Debugger.h" 18 #include "lldb/Core/Module.h" 19 #include "lldb/Core/PluginManager.h" 20 #include "lldb/Host/OptionParser.h" 21 #include "lldb/Interpreter/CommandInterpreter.h" 22 #include "lldb/Interpreter/CommandObjectMultiword.h" 23 #include "lldb/Interpreter/CommandReturnObject.h" 24 #include "lldb/Interpreter/OptionArgParser.h" 25 #include "lldb/Interpreter/OptionValueProperties.h" 26 #include "lldb/Interpreter/OptionValueString.h" 27 #include "lldb/Interpreter/Property.h" 28 #include "lldb/Target/Process.h" 29 #include "lldb/Target/Target.h" 30 #include "lldb/Target/ThreadPlanCallOnFunctionExit.h" 31 #include "lldb/Utility/Log.h" 32 #include "lldb/Utility/RegularExpression.h" 33 34 #define DARWIN_LOG_TYPE_VALUE "DarwinLog" 35 36 using namespace lldb; 37 using namespace lldb_private; 38 39 #pragma mark - 40 #pragma mark Anonymous Namespace 41 42 // Anonymous namespace 43 44 namespace sddarwinlog_private { 45 const uint64_t NANOS_PER_MICRO = 1000; 46 const uint64_t NANOS_PER_MILLI = NANOS_PER_MICRO * 1000; 47 const uint64_t NANOS_PER_SECOND = NANOS_PER_MILLI * 1000; 48 const uint64_t NANOS_PER_MINUTE = NANOS_PER_SECOND * 60; 49 const uint64_t NANOS_PER_HOUR = NANOS_PER_MINUTE * 60; 50 51 static bool DEFAULT_FILTER_FALLTHROUGH_ACCEPTS = true; 52 53 /// Global, sticky enable switch. If true, the user has explicitly 54 /// run the enable command. When a process launches or is attached to, 55 /// we will enable DarwinLog if either the settings for auto-enable is 56 /// on, or if the user had explicitly run enable at some point prior 57 /// to the launch/attach. 58 static bool s_is_explicitly_enabled; 59 60 class EnableOptions; 61 using EnableOptionsSP = std::shared_ptr<EnableOptions>; 62 63 using OptionsMap = 64 std::map<DebuggerWP, EnableOptionsSP, std::owner_less<DebuggerWP>>; 65 66 static OptionsMap &GetGlobalOptionsMap() { 67 static OptionsMap s_options_map; 68 return s_options_map; 69 } 70 71 static std::mutex &GetGlobalOptionsMapLock() { 72 static std::mutex s_options_map_lock; 73 return s_options_map_lock; 74 } 75 76 EnableOptionsSP GetGlobalEnableOptions(const DebuggerSP &debugger_sp) { 77 if (!debugger_sp) 78 return EnableOptionsSP(); 79 80 std::lock_guard<std::mutex> locker(GetGlobalOptionsMapLock()); 81 OptionsMap &options_map = GetGlobalOptionsMap(); 82 DebuggerWP debugger_wp(debugger_sp); 83 auto find_it = options_map.find(debugger_wp); 84 if (find_it != options_map.end()) 85 return find_it->second; 86 else 87 return EnableOptionsSP(); 88 } 89 90 void SetGlobalEnableOptions(const DebuggerSP &debugger_sp, 91 const EnableOptionsSP &options_sp) { 92 std::lock_guard<std::mutex> locker(GetGlobalOptionsMapLock()); 93 OptionsMap &options_map = GetGlobalOptionsMap(); 94 DebuggerWP debugger_wp(debugger_sp); 95 auto find_it = options_map.find(debugger_wp); 96 if (find_it != options_map.end()) 97 find_it->second = options_sp; 98 else 99 options_map.insert(std::make_pair(debugger_wp, options_sp)); 100 } 101 102 #pragma mark - 103 #pragma mark Settings Handling 104 105 /// Code to handle the StructuredDataDarwinLog settings 106 107 #define LLDB_PROPERTIES_darwinlog 108 #include "StructuredDataDarwinLogProperties.inc" 109 110 enum { 111 #define LLDB_PROPERTIES_darwinlog 112 #include "StructuredDataDarwinLogPropertiesEnum.inc" 113 }; 114 115 class StructuredDataDarwinLogProperties : public Properties { 116 public: 117 static ConstString &GetSettingName() { 118 static ConstString g_setting_name("darwin-log"); 119 return g_setting_name; 120 } 121 122 StructuredDataDarwinLogProperties() : Properties() { 123 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); 124 m_collection_sp->Initialize(g_darwinlog_properties); 125 } 126 127 ~StructuredDataDarwinLogProperties() override {} 128 129 bool GetEnableOnStartup() const { 130 const uint32_t idx = ePropertyEnableOnStartup; 131 return m_collection_sp->GetPropertyAtIndexAsBoolean( 132 nullptr, idx, g_darwinlog_properties[idx].default_uint_value != 0); 133 } 134 135 llvm::StringRef GetAutoEnableOptions() const { 136 const uint32_t idx = ePropertyAutoEnableOptions; 137 return m_collection_sp->GetPropertyAtIndexAsString( 138 nullptr, idx, g_darwinlog_properties[idx].default_cstr_value); 139 } 140 141 const char *GetLoggingModuleName() const { return "libsystem_trace.dylib"; } 142 }; 143 144 using StructuredDataDarwinLogPropertiesSP = 145 std::shared_ptr<StructuredDataDarwinLogProperties>; 146 147 static const StructuredDataDarwinLogPropertiesSP &GetGlobalProperties() { 148 static StructuredDataDarwinLogPropertiesSP g_settings_sp; 149 if (!g_settings_sp) 150 g_settings_sp = std::make_shared<StructuredDataDarwinLogProperties>(); 151 return g_settings_sp; 152 } 153 154 const char *const s_filter_attributes[] = { 155 "activity", // current activity 156 "activity-chain", // entire activity chain, each level separated by ':' 157 "category", // category of the log message 158 "message", // message contents, fully expanded 159 "subsystem" // subsystem of the log message 160 161 // Consider implementing this action as it would be cheaper to filter. 162 // "message" requires always formatting the message, which is a waste of 163 // cycles if it ends up being rejected. "format", // format string 164 // used to format message text 165 }; 166 167 static ConstString GetDarwinLogTypeName() { 168 static const ConstString s_key_name("DarwinLog"); 169 return s_key_name; 170 } 171 172 static ConstString GetLogEventType() { 173 static const ConstString s_event_type("log"); 174 return s_event_type; 175 } 176 177 class FilterRule; 178 using FilterRuleSP = std::shared_ptr<FilterRule>; 179 180 class FilterRule { 181 public: 182 virtual ~FilterRule() {} 183 184 using OperationCreationFunc = 185 std::function<FilterRuleSP(bool accept, size_t attribute_index, 186 const std::string &op_arg, Status &error)>; 187 188 static void RegisterOperation(ConstString operation, 189 const OperationCreationFunc &creation_func) { 190 GetCreationFuncMap().insert(std::make_pair(operation, creation_func)); 191 } 192 193 static FilterRuleSP CreateRule(bool match_accepts, size_t attribute, 194 ConstString operation, 195 const std::string &op_arg, Status &error) { 196 // Find the creation func for this type of filter rule. 197 auto map = GetCreationFuncMap(); 198 auto find_it = map.find(operation); 199 if (find_it == map.end()) { 200 error.SetErrorStringWithFormat("unknown filter operation \"" 201 "%s\"", 202 operation.GetCString()); 203 return FilterRuleSP(); 204 } 205 206 return find_it->second(match_accepts, attribute, op_arg, error); 207 } 208 209 StructuredData::ObjectSP Serialize() const { 210 StructuredData::Dictionary *dict_p = new StructuredData::Dictionary(); 211 212 // Indicate whether this is an accept or reject rule. 213 dict_p->AddBooleanItem("accept", m_accept); 214 215 // Indicate which attribute of the message this filter references. This can 216 // drop into the rule-specific DoSerialization if we get to the point where 217 // not all FilterRule derived classes work on an attribute. (e.g. logical 218 // and/or and other compound operations). 219 dict_p->AddStringItem("attribute", s_filter_attributes[m_attribute_index]); 220 221 // Indicate the type of the rule. 222 dict_p->AddStringItem("type", GetOperationType().GetCString()); 223 224 // Let the rule add its own specific details here. 225 DoSerialization(*dict_p); 226 227 return StructuredData::ObjectSP(dict_p); 228 } 229 230 virtual void Dump(Stream &stream) const = 0; 231 232 ConstString GetOperationType() const { return m_operation; } 233 234 protected: 235 FilterRule(bool accept, size_t attribute_index, ConstString operation) 236 : m_accept(accept), m_attribute_index(attribute_index), 237 m_operation(operation) {} 238 239 virtual void DoSerialization(StructuredData::Dictionary &dict) const = 0; 240 241 bool GetMatchAccepts() const { return m_accept; } 242 243 const char *GetFilterAttribute() const { 244 return s_filter_attributes[m_attribute_index]; 245 } 246 247 private: 248 using CreationFuncMap = std::map<ConstString, OperationCreationFunc>; 249 250 static CreationFuncMap &GetCreationFuncMap() { 251 static CreationFuncMap s_map; 252 return s_map; 253 } 254 255 const bool m_accept; 256 const size_t m_attribute_index; 257 const ConstString m_operation; 258 }; 259 260 using FilterRules = std::vector<FilterRuleSP>; 261 262 class RegexFilterRule : public FilterRule { 263 public: 264 static void RegisterOperation() { 265 FilterRule::RegisterOperation(StaticGetOperation(), CreateOperation); 266 } 267 268 void Dump(Stream &stream) const override { 269 stream.Printf("%s %s regex %s", GetMatchAccepts() ? "accept" : "reject", 270 GetFilterAttribute(), m_regex_text.c_str()); 271 } 272 273 protected: 274 void DoSerialization(StructuredData::Dictionary &dict) const override { 275 dict.AddStringItem("regex", m_regex_text); 276 } 277 278 private: 279 static FilterRuleSP CreateOperation(bool accept, size_t attribute_index, 280 const std::string &op_arg, 281 Status &error) { 282 // We treat the op_arg as a regex. Validate it. 283 if (op_arg.empty()) { 284 error.SetErrorString("regex filter type requires a regex " 285 "argument"); 286 return FilterRuleSP(); 287 } 288 289 // Instantiate the regex so we can report any errors. 290 auto regex = RegularExpression(op_arg); 291 if (llvm::Error err = regex.GetError()) { 292 error.SetErrorString(llvm::toString(std::move(err))); 293 return FilterRuleSP(); 294 } 295 296 // We passed all our checks, this appears fine. 297 error.Clear(); 298 return FilterRuleSP(new RegexFilterRule(accept, attribute_index, op_arg)); 299 } 300 301 static ConstString StaticGetOperation() { 302 static ConstString s_operation("regex"); 303 return s_operation; 304 } 305 306 RegexFilterRule(bool accept, size_t attribute_index, 307 const std::string ®ex_text) 308 : FilterRule(accept, attribute_index, StaticGetOperation()), 309 m_regex_text(regex_text) {} 310 311 const std::string m_regex_text; 312 }; 313 314 class ExactMatchFilterRule : public FilterRule { 315 public: 316 static void RegisterOperation() { 317 FilterRule::RegisterOperation(StaticGetOperation(), CreateOperation); 318 } 319 320 void Dump(Stream &stream) const override { 321 stream.Printf("%s %s match %s", GetMatchAccepts() ? "accept" : "reject", 322 GetFilterAttribute(), m_match_text.c_str()); 323 } 324 325 protected: 326 void DoSerialization(StructuredData::Dictionary &dict) const override { 327 dict.AddStringItem("exact_text", m_match_text); 328 } 329 330 private: 331 static FilterRuleSP CreateOperation(bool accept, size_t attribute_index, 332 const std::string &op_arg, 333 Status &error) { 334 if (op_arg.empty()) { 335 error.SetErrorString("exact match filter type requires an " 336 "argument containing the text that must " 337 "match the specified message attribute."); 338 return FilterRuleSP(); 339 } 340 341 error.Clear(); 342 return FilterRuleSP( 343 new ExactMatchFilterRule(accept, attribute_index, op_arg)); 344 } 345 346 static ConstString StaticGetOperation() { 347 static ConstString s_operation("match"); 348 return s_operation; 349 } 350 351 ExactMatchFilterRule(bool accept, size_t attribute_index, 352 const std::string &match_text) 353 : FilterRule(accept, attribute_index, StaticGetOperation()), 354 m_match_text(match_text) {} 355 356 const std::string m_match_text; 357 }; 358 359 static void RegisterFilterOperations() { 360 ExactMatchFilterRule::RegisterOperation(); 361 RegexFilterRule::RegisterOperation(); 362 } 363 364 // ========================================================================= 365 // Commands 366 // ========================================================================= 367 368 /// Provides the main on-off switch for enabling darwin logging. 369 /// 370 /// It is valid to run the enable command when logging is already enabled. 371 /// This resets the logging with whatever settings are currently set. 372 373 static constexpr OptionDefinition g_enable_option_table[] = { 374 // Source stream include/exclude options (the first-level filter). This one 375 // should be made as small as possible as everything that goes through here 376 // must be processed by the process monitor. 377 {LLDB_OPT_SET_ALL, false, "any-process", 'a', OptionParser::eNoArgument, 378 nullptr, {}, 0, eArgTypeNone, 379 "Specifies log messages from other related processes should be " 380 "included."}, 381 {LLDB_OPT_SET_ALL, false, "debug", 'd', OptionParser::eNoArgument, nullptr, 382 {}, 0, eArgTypeNone, 383 "Specifies debug-level log messages should be included. Specifying" 384 " --debug implies --info."}, 385 {LLDB_OPT_SET_ALL, false, "info", 'i', OptionParser::eNoArgument, nullptr, 386 {}, 0, eArgTypeNone, 387 "Specifies info-level log messages should be included."}, 388 {LLDB_OPT_SET_ALL, false, "filter", 'f', OptionParser::eRequiredArgument, 389 nullptr, {}, 0, eArgRawInput, 390 // There doesn't appear to be a great way for me to have these multi-line, 391 // formatted tables in help. This looks mostly right but there are extra 392 // linefeeds added at seemingly random spots, and indentation isn't 393 // handled properly on those lines. 394 "Appends a filter rule to the log message filter chain. Multiple " 395 "rules may be added by specifying this option multiple times, " 396 "once per filter rule. Filter rules are processed in the order " 397 "they are specified, with the --no-match-accepts setting used " 398 "for any message that doesn't match one of the rules.\n" 399 "\n" 400 " Filter spec format:\n" 401 "\n" 402 " --filter \"{action} {attribute} {op}\"\n" 403 "\n" 404 " {action} :=\n" 405 " accept |\n" 406 " reject\n" 407 "\n" 408 " {attribute} :=\n" 409 " activity | // message's most-derived activity\n" 410 " activity-chain | // message's {parent}:{child} activity\n" 411 " category | // message's category\n" 412 " message | // message's expanded contents\n" 413 " subsystem | // message's subsystem\n" 414 "\n" 415 " {op} :=\n" 416 " match {exact-match-text} |\n" 417 " regex {search-regex}\n" 418 "\n" 419 "The regex flavor used is the C++ std::regex ECMAScript format. " 420 "Prefer character classes like [[:digit:]] to \\d and the like, as " 421 "getting the backslashes escaped through properly is error-prone."}, 422 {LLDB_OPT_SET_ALL, false, "live-stream", 'l', 423 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, 424 "Specify whether logging events are live-streamed or buffered. " 425 "True indicates live streaming, false indicates buffered. The " 426 "default is true (live streaming). Live streaming will deliver " 427 "log messages with less delay, but buffered capture mode has less " 428 "of an observer effect."}, 429 {LLDB_OPT_SET_ALL, false, "no-match-accepts", 'n', 430 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, 431 "Specify whether a log message that doesn't match any filter rule " 432 "is accepted or rejected, where true indicates accept. The " 433 "default is true."}, 434 {LLDB_OPT_SET_ALL, false, "echo-to-stderr", 'e', 435 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, 436 "Specify whether os_log()/NSLog() messages are echoed to the " 437 "target program's stderr. When DarwinLog is enabled, we shut off " 438 "the mirroring of os_log()/NSLog() to the program's stderr. " 439 "Setting this flag to true will restore the stderr mirroring." 440 "The default is false."}, 441 {LLDB_OPT_SET_ALL, false, "broadcast-events", 'b', 442 OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeBoolean, 443 "Specify if the plugin should broadcast events. Broadcasting " 444 "log events is a requirement for displaying the log entries in " 445 "LLDB command-line. It is also required if LLDB clients want to " 446 "process log events. The default is true."}, 447 // Message formatting options 448 {LLDB_OPT_SET_ALL, false, "timestamp-relative", 'r', 449 OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, 450 "Include timestamp in the message header when printing a log " 451 "message. The timestamp is relative to the first displayed " 452 "message."}, 453 {LLDB_OPT_SET_ALL, false, "subsystem", 's', OptionParser::eNoArgument, 454 nullptr, {}, 0, eArgTypeNone, 455 "Include the subsystem in the message header when displaying " 456 "a log message."}, 457 {LLDB_OPT_SET_ALL, false, "category", 'c', OptionParser::eNoArgument, 458 nullptr, {}, 0, eArgTypeNone, 459 "Include the category in the message header when displaying " 460 "a log message."}, 461 {LLDB_OPT_SET_ALL, false, "activity-chain", 'C', OptionParser::eNoArgument, 462 nullptr, {}, 0, eArgTypeNone, 463 "Include the activity parent-child chain in the message header " 464 "when displaying a log message. The activity hierarchy is " 465 "displayed as {grandparent-activity}:" 466 "{parent-activity}:{activity}[:...]."}, 467 {LLDB_OPT_SET_ALL, false, "all-fields", 'A', OptionParser::eNoArgument, 468 nullptr, {}, 0, eArgTypeNone, 469 "Shortcut to specify that all header fields should be displayed."}}; 470 471 class EnableOptions : public Options { 472 public: 473 EnableOptions() 474 : Options(), m_include_debug_level(false), m_include_info_level(false), 475 m_include_any_process(false), 476 m_filter_fall_through_accepts(DEFAULT_FILTER_FALLTHROUGH_ACCEPTS), 477 m_echo_to_stderr(false), m_display_timestamp_relative(false), 478 m_display_subsystem(false), m_display_category(false), 479 m_display_activity_chain(false), m_broadcast_events(true), 480 m_live_stream(true), m_filter_rules() {} 481 482 void OptionParsingStarting(ExecutionContext *execution_context) override { 483 m_include_debug_level = false; 484 m_include_info_level = false; 485 m_include_any_process = false; 486 m_filter_fall_through_accepts = DEFAULT_FILTER_FALLTHROUGH_ACCEPTS; 487 m_echo_to_stderr = false; 488 m_display_timestamp_relative = false; 489 m_display_subsystem = false; 490 m_display_category = false; 491 m_display_activity_chain = false; 492 m_broadcast_events = true; 493 m_live_stream = true; 494 m_filter_rules.clear(); 495 } 496 497 Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, 498 ExecutionContext *execution_context) override { 499 Status error; 500 501 const int short_option = m_getopt_table[option_idx].val; 502 switch (short_option) { 503 case 'a': 504 m_include_any_process = true; 505 break; 506 507 case 'A': 508 m_display_timestamp_relative = true; 509 m_display_category = true; 510 m_display_subsystem = true; 511 m_display_activity_chain = true; 512 break; 513 514 case 'b': 515 m_broadcast_events = 516 OptionArgParser::ToBoolean(option_arg, true, nullptr); 517 break; 518 519 case 'c': 520 m_display_category = true; 521 break; 522 523 case 'C': 524 m_display_activity_chain = true; 525 break; 526 527 case 'd': 528 m_include_debug_level = true; 529 break; 530 531 case 'e': 532 m_echo_to_stderr = OptionArgParser::ToBoolean(option_arg, false, nullptr); 533 break; 534 535 case 'f': 536 return ParseFilterRule(option_arg); 537 538 case 'i': 539 m_include_info_level = true; 540 break; 541 542 case 'l': 543 m_live_stream = OptionArgParser::ToBoolean(option_arg, false, nullptr); 544 break; 545 546 case 'n': 547 m_filter_fall_through_accepts = 548 OptionArgParser::ToBoolean(option_arg, true, nullptr); 549 break; 550 551 case 'r': 552 m_display_timestamp_relative = true; 553 break; 554 555 case 's': 556 m_display_subsystem = true; 557 break; 558 559 default: 560 error.SetErrorStringWithFormat("unsupported option '%c'", short_option); 561 } 562 return error; 563 } 564 565 llvm::ArrayRef<OptionDefinition> GetDefinitions() override { 566 return llvm::makeArrayRef(g_enable_option_table); 567 } 568 569 StructuredData::DictionarySP BuildConfigurationData(bool enabled) { 570 StructuredData::DictionarySP config_sp(new StructuredData::Dictionary()); 571 572 // Set the basic enabled state. 573 config_sp->AddBooleanItem("enabled", enabled); 574 575 // If we're disabled, there's nothing more to add. 576 if (!enabled) 577 return config_sp; 578 579 // Handle source stream flags. 580 auto source_flags_sp = 581 StructuredData::DictionarySP(new StructuredData::Dictionary()); 582 config_sp->AddItem("source-flags", source_flags_sp); 583 584 source_flags_sp->AddBooleanItem("any-process", m_include_any_process); 585 source_flags_sp->AddBooleanItem("debug-level", m_include_debug_level); 586 // The debug-level flag, if set, implies info-level. 587 source_flags_sp->AddBooleanItem("info-level", m_include_info_level || 588 m_include_debug_level); 589 source_flags_sp->AddBooleanItem("live-stream", m_live_stream); 590 591 // Specify default filter rule (the fall-through) 592 config_sp->AddBooleanItem("filter-fall-through-accepts", 593 m_filter_fall_through_accepts); 594 595 // Handle filter rules 596 if (!m_filter_rules.empty()) { 597 auto json_filter_rules_sp = 598 StructuredData::ArraySP(new StructuredData::Array); 599 config_sp->AddItem("filter-rules", json_filter_rules_sp); 600 for (auto &rule_sp : m_filter_rules) { 601 if (!rule_sp) 602 continue; 603 json_filter_rules_sp->AddItem(rule_sp->Serialize()); 604 } 605 } 606 return config_sp; 607 } 608 609 bool GetIncludeDebugLevel() const { return m_include_debug_level; } 610 611 bool GetIncludeInfoLevel() const { 612 // Specifying debug level implies info level. 613 return m_include_info_level || m_include_debug_level; 614 } 615 616 const FilterRules &GetFilterRules() const { return m_filter_rules; } 617 618 bool GetFallthroughAccepts() const { return m_filter_fall_through_accepts; } 619 620 bool GetEchoToStdErr() const { return m_echo_to_stderr; } 621 622 bool GetDisplayTimestampRelative() const { 623 return m_display_timestamp_relative; 624 } 625 626 bool GetDisplaySubsystem() const { return m_display_subsystem; } 627 bool GetDisplayCategory() const { return m_display_category; } 628 bool GetDisplayActivityChain() const { return m_display_activity_chain; } 629 630 bool GetDisplayAnyHeaderFields() const { 631 return m_display_timestamp_relative || m_display_activity_chain || 632 m_display_subsystem || m_display_category; 633 } 634 635 bool GetBroadcastEvents() const { return m_broadcast_events; } 636 637 private: 638 Status ParseFilterRule(llvm::StringRef rule_text) { 639 Status error; 640 641 if (rule_text.empty()) { 642 error.SetErrorString("invalid rule_text"); 643 return error; 644 } 645 646 // filter spec format: 647 // 648 // {action} {attribute} {op} 649 // 650 // {action} := 651 // accept | 652 // reject 653 // 654 // {attribute} := 655 // category | 656 // subsystem | 657 // activity | 658 // activity-chain | 659 // message | 660 // format 661 // 662 // {op} := 663 // match {exact-match-text} | 664 // regex {search-regex} 665 666 // Parse action. 667 auto action_end_pos = rule_text.find(" "); 668 if (action_end_pos == std::string::npos) { 669 error.SetErrorStringWithFormat("could not parse filter rule " 670 "action from \"%s\"", 671 rule_text.str().c_str()); 672 return error; 673 } 674 auto action = rule_text.substr(0, action_end_pos); 675 bool accept; 676 if (action == "accept") 677 accept = true; 678 else if (action == "reject") 679 accept = false; 680 else { 681 error.SetErrorString("filter action must be \"accept\" or \"deny\""); 682 return error; 683 } 684 685 // parse attribute 686 auto attribute_end_pos = rule_text.find(" ", action_end_pos + 1); 687 if (attribute_end_pos == std::string::npos) { 688 error.SetErrorStringWithFormat("could not parse filter rule " 689 "attribute from \"%s\"", 690 rule_text.str().c_str()); 691 return error; 692 } 693 auto attribute = rule_text.substr(action_end_pos + 1, 694 attribute_end_pos - (action_end_pos + 1)); 695 auto attribute_index = MatchAttributeIndex(attribute); 696 if (attribute_index < 0) { 697 error.SetErrorStringWithFormat("filter rule attribute unknown: " 698 "%s", 699 attribute.str().c_str()); 700 return error; 701 } 702 703 // parse operation 704 auto operation_end_pos = rule_text.find(" ", attribute_end_pos + 1); 705 auto operation = rule_text.substr( 706 attribute_end_pos + 1, operation_end_pos - (attribute_end_pos + 1)); 707 708 // add filter spec 709 auto rule_sp = 710 FilterRule::CreateRule(accept, attribute_index, ConstString(operation), 711 rule_text.substr(operation_end_pos + 1), error); 712 713 if (rule_sp && error.Success()) 714 m_filter_rules.push_back(rule_sp); 715 716 return error; 717 } 718 719 int MatchAttributeIndex(llvm::StringRef attribute_name) const { 720 for (const auto &Item : llvm::enumerate(s_filter_attributes)) { 721 if (attribute_name == Item.value()) 722 return Item.index(); 723 } 724 725 // We didn't match anything. 726 return -1; 727 } 728 729 bool m_include_debug_level; 730 bool m_include_info_level; 731 bool m_include_any_process; 732 bool m_filter_fall_through_accepts; 733 bool m_echo_to_stderr; 734 bool m_display_timestamp_relative; 735 bool m_display_subsystem; 736 bool m_display_category; 737 bool m_display_activity_chain; 738 bool m_broadcast_events; 739 bool m_live_stream; 740 FilterRules m_filter_rules; 741 }; 742 743 class EnableCommand : public CommandObjectParsed { 744 public: 745 EnableCommand(CommandInterpreter &interpreter, bool enable, const char *name, 746 const char *help, const char *syntax) 747 : CommandObjectParsed(interpreter, name, help, syntax), m_enable(enable), 748 m_options_sp(enable ? new EnableOptions() : nullptr) {} 749 750 protected: 751 void AppendStrictSourcesWarning(CommandReturnObject &result, 752 const char *source_name) { 753 if (!source_name) 754 return; 755 756 // Check if we're *not* using strict sources. If not, then the user is 757 // going to get debug-level info anyways, probably not what they're 758 // expecting. Unfortunately we can only fix this by adding an env var, 759 // which would have had to have happened already. Thus, a warning is the 760 // best we can do here. 761 StreamString stream; 762 stream.Printf("darwin-log source settings specify to exclude " 763 "%s messages, but setting " 764 "'plugin.structured-data.darwin-log." 765 "strict-sources' is disabled. This process will " 766 "automatically have %s messages included. Enable" 767 " the property and relaunch the target binary to have" 768 " these messages excluded.", 769 source_name, source_name); 770 result.AppendWarning(stream.GetString()); 771 } 772 773 bool DoExecute(Args &command, CommandReturnObject &result) override { 774 // First off, set the global sticky state of enable/disable based on this 775 // command execution. 776 s_is_explicitly_enabled = m_enable; 777 778 // Next, if this is an enable, save off the option data. We will need it 779 // later if a process hasn't been launched or attached yet. 780 if (m_enable) { 781 // Save off enabled configuration so we can apply these parsed options 782 // the next time an attach or launch occurs. 783 DebuggerSP debugger_sp = 784 GetCommandInterpreter().GetDebugger().shared_from_this(); 785 SetGlobalEnableOptions(debugger_sp, m_options_sp); 786 } 787 788 // Now check if we have a running process. If so, we should instruct the 789 // process monitor to enable/disable DarwinLog support now. 790 Target &target = GetSelectedOrDummyTarget(); 791 792 // Grab the active process. 793 auto process_sp = target.GetProcessSP(); 794 if (!process_sp) { 795 // No active process, so there is nothing more to do right now. 796 result.SetStatus(eReturnStatusSuccessFinishNoResult); 797 return true; 798 } 799 800 // If the process is no longer alive, we can't do this now. We'll catch it 801 // the next time the process is started up. 802 if (!process_sp->IsAlive()) { 803 result.SetStatus(eReturnStatusSuccessFinishNoResult); 804 return true; 805 } 806 807 // Get the plugin for the process. 808 auto plugin_sp = 809 process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName()); 810 if (!plugin_sp || (plugin_sp->GetPluginName() != 811 StructuredDataDarwinLog::GetStaticPluginName())) { 812 result.AppendError("failed to get StructuredDataPlugin for " 813 "the process"); 814 result.SetStatus(eReturnStatusFailed); 815 } 816 StructuredDataDarwinLog &plugin = 817 *static_cast<StructuredDataDarwinLog *>(plugin_sp.get()); 818 819 if (m_enable) { 820 // Hook up the breakpoint for the process that detects when libtrace has 821 // been sufficiently initialized to really start the os_log stream. This 822 // is insurance to assure us that logging is really enabled. Requesting 823 // that logging be enabled for a process before libtrace is initialized 824 // results in a scenario where no errors occur, but no logging is 825 // captured, either. This step is to eliminate that possibility. 826 plugin.AddInitCompletionHook(*process_sp); 827 } 828 829 // Send configuration to the feature by way of the process. Construct the 830 // options we will use. 831 auto config_sp = m_options_sp->BuildConfigurationData(m_enable); 832 const Status error = 833 process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp); 834 835 // Report results. 836 if (!error.Success()) { 837 result.AppendError(error.AsCString()); 838 result.SetStatus(eReturnStatusFailed); 839 // Our configuration failed, so we're definitely disabled. 840 plugin.SetEnabled(false); 841 } else { 842 result.SetStatus(eReturnStatusSuccessFinishNoResult); 843 // Our configuration succeeded, so we're enabled/disabled per whichever 844 // one this command is setup to do. 845 plugin.SetEnabled(m_enable); 846 } 847 return result.Succeeded(); 848 } 849 850 Options *GetOptions() override { 851 // We don't have options when this represents disable. 852 return m_enable ? m_options_sp.get() : nullptr; 853 } 854 855 private: 856 const bool m_enable; 857 EnableOptionsSP m_options_sp; 858 }; 859 860 /// Provides the status command. 861 class StatusCommand : public CommandObjectParsed { 862 public: 863 StatusCommand(CommandInterpreter &interpreter) 864 : CommandObjectParsed(interpreter, "status", 865 "Show whether Darwin log supported is available" 866 " and enabled.", 867 "plugin structured-data darwin-log status") {} 868 869 protected: 870 bool DoExecute(Args &command, CommandReturnObject &result) override { 871 auto &stream = result.GetOutputStream(); 872 873 // Figure out if we've got a process. If so, we can tell if DarwinLog is 874 // available for that process. 875 Target &target = GetSelectedOrDummyTarget(); 876 auto process_sp = target.GetProcessSP(); 877 if (!process_sp) { 878 stream.PutCString("Availability: unknown (requires process)\n"); 879 stream.PutCString("Enabled: not applicable " 880 "(requires process)\n"); 881 } else { 882 auto plugin_sp = 883 process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName()); 884 stream.Printf("Availability: %s\n", 885 plugin_sp ? "available" : "unavailable"); 886 ConstString plugin_name = StructuredDataDarwinLog::GetStaticPluginName(); 887 const bool enabled = 888 plugin_sp ? plugin_sp->GetEnabled(plugin_name) : false; 889 stream.Printf("Enabled: %s\n", enabled ? "true" : "false"); 890 } 891 892 // Display filter settings. 893 DebuggerSP debugger_sp = 894 GetCommandInterpreter().GetDebugger().shared_from_this(); 895 auto options_sp = GetGlobalEnableOptions(debugger_sp); 896 if (!options_sp) { 897 // Nothing more to do. 898 result.SetStatus(eReturnStatusSuccessFinishResult); 899 return true; 900 } 901 902 // Print filter rules 903 stream.PutCString("DarwinLog filter rules:\n"); 904 905 stream.IndentMore(); 906 907 if (options_sp->GetFilterRules().empty()) { 908 stream.Indent(); 909 stream.PutCString("none\n"); 910 } else { 911 // Print each of the filter rules. 912 int rule_number = 0; 913 for (auto rule_sp : options_sp->GetFilterRules()) { 914 ++rule_number; 915 if (!rule_sp) 916 continue; 917 918 stream.Indent(); 919 stream.Printf("%02d: ", rule_number); 920 rule_sp->Dump(stream); 921 stream.PutChar('\n'); 922 } 923 } 924 stream.IndentLess(); 925 926 // Print no-match handling. 927 stream.Indent(); 928 stream.Printf("no-match behavior: %s\n", 929 options_sp->GetFallthroughAccepts() ? "accept" : "reject"); 930 931 result.SetStatus(eReturnStatusSuccessFinishResult); 932 return true; 933 } 934 }; 935 936 /// Provides the darwin-log base command 937 class BaseCommand : public CommandObjectMultiword { 938 public: 939 BaseCommand(CommandInterpreter &interpreter) 940 : CommandObjectMultiword(interpreter, "plugin structured-data darwin-log", 941 "Commands for configuring Darwin os_log " 942 "support.", 943 "") { 944 // enable 945 auto enable_help = "Enable Darwin log collection, or re-enable " 946 "with modified configuration."; 947 auto enable_syntax = "plugin structured-data darwin-log enable"; 948 auto enable_cmd_sp = CommandObjectSP( 949 new EnableCommand(interpreter, 950 true, // enable 951 "enable", enable_help, enable_syntax)); 952 LoadSubCommand("enable", enable_cmd_sp); 953 954 // disable 955 auto disable_help = "Disable Darwin log collection."; 956 auto disable_syntax = "plugin structured-data darwin-log disable"; 957 auto disable_cmd_sp = CommandObjectSP( 958 new EnableCommand(interpreter, 959 false, // disable 960 "disable", disable_help, disable_syntax)); 961 LoadSubCommand("disable", disable_cmd_sp); 962 963 // status 964 auto status_cmd_sp = CommandObjectSP(new StatusCommand(interpreter)); 965 LoadSubCommand("status", status_cmd_sp); 966 } 967 }; 968 969 EnableOptionsSP ParseAutoEnableOptions(Status &error, Debugger &debugger) { 970 Log *log = GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS); 971 // We are abusing the options data model here so that we can parse options 972 // without requiring the Debugger instance. 973 974 // We have an empty execution context at this point. We only want to parse 975 // options, and we don't need any context to do this here. In fact, we want 976 // to be able to parse the enable options before having any context. 977 ExecutionContext exe_ctx; 978 979 EnableOptionsSP options_sp(new EnableOptions()); 980 options_sp->NotifyOptionParsingStarting(&exe_ctx); 981 982 CommandReturnObject result; 983 984 // Parse the arguments. 985 auto options_property_sp = 986 debugger.GetPropertyValue(nullptr, "plugin.structured-data.darwin-log." 987 "auto-enable-options", 988 false, error); 989 if (!error.Success()) 990 return EnableOptionsSP(); 991 if (!options_property_sp) { 992 error.SetErrorString("failed to find option setting for " 993 "plugin.structured-data.darwin-log."); 994 return EnableOptionsSP(); 995 } 996 997 const char *enable_options = 998 options_property_sp->GetAsString()->GetCurrentValue(); 999 Args args(enable_options); 1000 if (args.GetArgumentCount() > 0) { 1001 // Eliminate the initial '--' that would be required to set the settings 1002 // that themselves include '-' and/or '--'. 1003 const char *first_arg = args.GetArgumentAtIndex(0); 1004 if (first_arg && (strcmp(first_arg, "--") == 0)) 1005 args.Shift(); 1006 } 1007 1008 bool require_validation = false; 1009 llvm::Expected<Args> args_or = 1010 options_sp->Parse(args, &exe_ctx, PlatformSP(), require_validation); 1011 if (!args_or) { 1012 LLDB_LOG_ERROR( 1013 log, args_or.takeError(), 1014 "Parsing plugin.structured-data.darwin-log.auto-enable-options value " 1015 "failed: {0}"); 1016 return EnableOptionsSP(); 1017 } 1018 1019 if (!options_sp->VerifyOptions(result)) 1020 return EnableOptionsSP(); 1021 1022 // We successfully parsed and validated the options. 1023 return options_sp; 1024 } 1025 1026 bool RunEnableCommand(CommandInterpreter &interpreter) { 1027 StreamString command_stream; 1028 1029 command_stream << "plugin structured-data darwin-log enable"; 1030 auto enable_options = GetGlobalProperties()->GetAutoEnableOptions(); 1031 if (!enable_options.empty()) { 1032 command_stream << ' '; 1033 command_stream << enable_options; 1034 } 1035 1036 // Run the command. 1037 CommandReturnObject return_object; 1038 interpreter.HandleCommand(command_stream.GetData(), eLazyBoolNo, 1039 return_object); 1040 return return_object.Succeeded(); 1041 } 1042 } 1043 using namespace sddarwinlog_private; 1044 1045 #pragma mark - 1046 #pragma mark Public static API 1047 1048 // Public static API 1049 1050 void StructuredDataDarwinLog::Initialize() { 1051 RegisterFilterOperations(); 1052 PluginManager::RegisterPlugin( 1053 GetStaticPluginName(), "Darwin os_log() and os_activity() support", 1054 &CreateInstance, &DebuggerInitialize, &FilterLaunchInfo); 1055 } 1056 1057 void StructuredDataDarwinLog::Terminate() { 1058 PluginManager::UnregisterPlugin(&CreateInstance); 1059 } 1060 1061 ConstString StructuredDataDarwinLog::GetStaticPluginName() { 1062 static ConstString s_plugin_name("darwin-log"); 1063 return s_plugin_name; 1064 } 1065 1066 #pragma mark - 1067 #pragma mark PluginInterface API 1068 1069 // PluginInterface API 1070 1071 ConstString StructuredDataDarwinLog::GetPluginName() { 1072 return GetStaticPluginName(); 1073 } 1074 1075 uint32_t StructuredDataDarwinLog::GetPluginVersion() { return 1; } 1076 1077 #pragma mark - 1078 #pragma mark StructuredDataPlugin API 1079 1080 // StructuredDataPlugin API 1081 1082 bool StructuredDataDarwinLog::SupportsStructuredDataType( 1083 ConstString type_name) { 1084 return type_name == GetDarwinLogTypeName(); 1085 } 1086 1087 void StructuredDataDarwinLog::HandleArrivalOfStructuredData( 1088 Process &process, ConstString type_name, 1089 const StructuredData::ObjectSP &object_sp) { 1090 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1091 if (log) { 1092 StreamString json_stream; 1093 if (object_sp) 1094 object_sp->Dump(json_stream); 1095 else 1096 json_stream.PutCString("<null>"); 1097 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() called with json: %s", 1098 __FUNCTION__, json_stream.GetData()); 1099 } 1100 1101 // Ignore empty structured data. 1102 if (!object_sp) { 1103 LLDB_LOGF(log, 1104 "StructuredDataDarwinLog::%s() StructuredData object " 1105 "is null", 1106 __FUNCTION__); 1107 return; 1108 } 1109 1110 // Ignore any data that isn't for us. 1111 if (type_name != GetDarwinLogTypeName()) { 1112 LLDB_LOGF(log, 1113 "StructuredDataDarwinLog::%s() StructuredData type " 1114 "expected to be %s but was %s, ignoring", 1115 __FUNCTION__, GetDarwinLogTypeName().AsCString(), 1116 type_name.AsCString()); 1117 return; 1118 } 1119 1120 // Broadcast the structured data event if we have that enabled. This is the 1121 // way that the outside world (all clients) get access to this data. This 1122 // plugin sets policy as to whether we do that. 1123 DebuggerSP debugger_sp = process.GetTarget().GetDebugger().shared_from_this(); 1124 auto options_sp = GetGlobalEnableOptions(debugger_sp); 1125 if (options_sp && options_sp->GetBroadcastEvents()) { 1126 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() broadcasting event", 1127 __FUNCTION__); 1128 process.BroadcastStructuredData(object_sp, shared_from_this()); 1129 } 1130 1131 // Later, hang on to a configurable amount of these and allow commands to 1132 // inspect, including showing backtraces. 1133 } 1134 1135 static void SetErrorWithJSON(Status &error, const char *message, 1136 StructuredData::Object &object) { 1137 if (!message) { 1138 error.SetErrorString("Internal error: message not set."); 1139 return; 1140 } 1141 1142 StreamString object_stream; 1143 object.Dump(object_stream); 1144 object_stream.Flush(); 1145 1146 error.SetErrorStringWithFormat("%s: %s", message, object_stream.GetData()); 1147 } 1148 1149 Status StructuredDataDarwinLog::GetDescription( 1150 const StructuredData::ObjectSP &object_sp, lldb_private::Stream &stream) { 1151 Status error; 1152 1153 if (!object_sp) { 1154 error.SetErrorString("No structured data."); 1155 return error; 1156 } 1157 1158 // Log message payload objects will be dictionaries. 1159 const StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary(); 1160 if (!dictionary) { 1161 SetErrorWithJSON(error, "Structured data should have been a dictionary " 1162 "but wasn't", 1163 *object_sp); 1164 return error; 1165 } 1166 1167 // Validate this is really a message for our plugin. 1168 ConstString type_name; 1169 if (!dictionary->GetValueForKeyAsString("type", type_name)) { 1170 SetErrorWithJSON(error, "Structured data doesn't contain mandatory " 1171 "type field", 1172 *object_sp); 1173 return error; 1174 } 1175 1176 if (type_name != GetDarwinLogTypeName()) { 1177 // This is okay - it simply means the data we received is not a log 1178 // message. We'll just format it as is. 1179 object_sp->Dump(stream); 1180 return error; 1181 } 1182 1183 // DarwinLog dictionaries store their data 1184 // in an array with key name "events". 1185 StructuredData::Array *events = nullptr; 1186 if (!dictionary->GetValueForKeyAsArray("events", events) || !events) { 1187 SetErrorWithJSON(error, "Log structured data is missing mandatory " 1188 "'events' field, expected to be an array", 1189 *object_sp); 1190 return error; 1191 } 1192 1193 events->ForEach( 1194 [&stream, &error, &object_sp, this](StructuredData::Object *object) { 1195 if (!object) { 1196 // Invalid. Stop iterating. 1197 SetErrorWithJSON(error, "Log event entry is null", *object_sp); 1198 return false; 1199 } 1200 1201 auto event = object->GetAsDictionary(); 1202 if (!event) { 1203 // Invalid, stop iterating. 1204 SetErrorWithJSON(error, "Log event is not a dictionary", *object_sp); 1205 return false; 1206 } 1207 1208 // If we haven't already grabbed the first timestamp value, do that 1209 // now. 1210 if (!m_recorded_first_timestamp) { 1211 uint64_t timestamp = 0; 1212 if (event->GetValueForKeyAsInteger("timestamp", timestamp)) { 1213 m_first_timestamp_seen = timestamp; 1214 m_recorded_first_timestamp = true; 1215 } 1216 } 1217 1218 HandleDisplayOfEvent(*event, stream); 1219 return true; 1220 }); 1221 1222 stream.Flush(); 1223 return error; 1224 } 1225 1226 bool StructuredDataDarwinLog::GetEnabled(ConstString type_name) const { 1227 if (type_name == GetStaticPluginName()) 1228 return m_is_enabled; 1229 else 1230 return false; 1231 } 1232 1233 void StructuredDataDarwinLog::SetEnabled(bool enabled) { 1234 m_is_enabled = enabled; 1235 } 1236 1237 void StructuredDataDarwinLog::ModulesDidLoad(Process &process, 1238 ModuleList &module_list) { 1239 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1240 LLDB_LOGF(log, "StructuredDataDarwinLog::%s called (process uid %u)", 1241 __FUNCTION__, process.GetUniqueID()); 1242 1243 // Check if we should enable the darwin log support on startup/attach. 1244 if (!GetGlobalProperties()->GetEnableOnStartup() && 1245 !s_is_explicitly_enabled) { 1246 // We're neither auto-enabled or explicitly enabled, so we shouldn't try to 1247 // enable here. 1248 LLDB_LOGF(log, 1249 "StructuredDataDarwinLog::%s not applicable, we're not " 1250 "enabled (process uid %u)", 1251 __FUNCTION__, process.GetUniqueID()); 1252 return; 1253 } 1254 1255 // If we already added the breakpoint, we've got nothing left to do. 1256 { 1257 std::lock_guard<std::mutex> locker(m_added_breakpoint_mutex); 1258 if (m_added_breakpoint) { 1259 LLDB_LOGF(log, 1260 "StructuredDataDarwinLog::%s process uid %u's " 1261 "post-libtrace-init breakpoint is already set", 1262 __FUNCTION__, process.GetUniqueID()); 1263 return; 1264 } 1265 } 1266 1267 // The logging support module name, specifies the name of the image name that 1268 // must be loaded into the debugged process before we can try to enable 1269 // logging. 1270 const char *logging_module_cstr = 1271 GetGlobalProperties()->GetLoggingModuleName(); 1272 if (!logging_module_cstr || (logging_module_cstr[0] == 0)) { 1273 // We need this. Bail. 1274 LLDB_LOGF(log, 1275 "StructuredDataDarwinLog::%s no logging module name " 1276 "specified, we don't know where to set a breakpoint " 1277 "(process uid %u)", 1278 __FUNCTION__, process.GetUniqueID()); 1279 return; 1280 } 1281 1282 const ConstString logging_module_name = ConstString(logging_module_cstr); 1283 1284 // We need to see libtrace in the list of modules before we can enable 1285 // tracing for the target process. 1286 bool found_logging_support_module = false; 1287 for (size_t i = 0; i < module_list.GetSize(); ++i) { 1288 auto module_sp = module_list.GetModuleAtIndex(i); 1289 if (!module_sp) 1290 continue; 1291 1292 auto &file_spec = module_sp->GetFileSpec(); 1293 found_logging_support_module = 1294 (file_spec.GetLastPathComponent() == logging_module_name); 1295 if (found_logging_support_module) 1296 break; 1297 } 1298 1299 if (!found_logging_support_module) { 1300 LLDB_LOGF(log, 1301 "StructuredDataDarwinLog::%s logging module %s " 1302 "has not yet been loaded, can't set a breakpoint " 1303 "yet (process uid %u)", 1304 __FUNCTION__, logging_module_name.AsCString(), 1305 process.GetUniqueID()); 1306 return; 1307 } 1308 1309 // Time to enqueue the breakpoint so we can wait for logging support to be 1310 // initialized before we try to tap the libtrace stream. 1311 AddInitCompletionHook(process); 1312 LLDB_LOGF(log, 1313 "StructuredDataDarwinLog::%s post-init hook breakpoint " 1314 "set for logging module %s (process uid %u)", 1315 __FUNCTION__, logging_module_name.AsCString(), 1316 process.GetUniqueID()); 1317 1318 // We need to try the enable here as well, which will succeed in the event 1319 // that we're attaching to (rather than launching) the process and the 1320 // process is already past initialization time. In that case, the completion 1321 // breakpoint will never get hit and therefore won't start that way. It 1322 // doesn't hurt much beyond a bit of bandwidth if we end up doing this twice. 1323 // It hurts much more if we don't get the logging enabled when the user 1324 // expects it. 1325 EnableNow(); 1326 } 1327 1328 // public destructor 1329 1330 StructuredDataDarwinLog::~StructuredDataDarwinLog() { 1331 if (m_breakpoint_id != LLDB_INVALID_BREAK_ID) { 1332 ProcessSP process_sp(GetProcess()); 1333 if (process_sp) { 1334 process_sp->GetTarget().RemoveBreakpointByID(m_breakpoint_id); 1335 m_breakpoint_id = LLDB_INVALID_BREAK_ID; 1336 } 1337 } 1338 } 1339 1340 #pragma mark - 1341 #pragma mark Private instance methods 1342 1343 // Private constructors 1344 1345 StructuredDataDarwinLog::StructuredDataDarwinLog(const ProcessWP &process_wp) 1346 : StructuredDataPlugin(process_wp), m_recorded_first_timestamp(false), 1347 m_first_timestamp_seen(0), m_is_enabled(false), 1348 m_added_breakpoint_mutex(), m_added_breakpoint(), 1349 m_breakpoint_id(LLDB_INVALID_BREAK_ID) {} 1350 1351 // Private static methods 1352 1353 StructuredDataPluginSP 1354 StructuredDataDarwinLog::CreateInstance(Process &process) { 1355 // Currently only Apple targets support the os_log/os_activity protocol. 1356 if (process.GetTarget().GetArchitecture().GetTriple().getVendor() == 1357 llvm::Triple::VendorType::Apple) { 1358 auto process_wp = ProcessWP(process.shared_from_this()); 1359 return StructuredDataPluginSP(new StructuredDataDarwinLog(process_wp)); 1360 } else { 1361 return StructuredDataPluginSP(); 1362 } 1363 } 1364 1365 void StructuredDataDarwinLog::DebuggerInitialize(Debugger &debugger) { 1366 // Setup parent class first. 1367 StructuredDataPlugin::InitializeBasePluginForDebugger(debugger); 1368 1369 // Get parent command. 1370 auto &interpreter = debugger.GetCommandInterpreter(); 1371 llvm::StringRef parent_command_text = "plugin structured-data"; 1372 auto parent_command = 1373 interpreter.GetCommandObjectForCommand(parent_command_text); 1374 if (!parent_command) { 1375 // Ut oh, parent failed to create parent command. 1376 // TODO log 1377 return; 1378 } 1379 1380 auto command_name = "darwin-log"; 1381 auto command_sp = CommandObjectSP(new BaseCommand(interpreter)); 1382 bool result = parent_command->LoadSubCommand(command_name, command_sp); 1383 if (!result) { 1384 // TODO log it once we setup structured data logging 1385 } 1386 1387 if (!PluginManager::GetSettingForPlatformPlugin( 1388 debugger, StructuredDataDarwinLogProperties::GetSettingName())) { 1389 const bool is_global_setting = true; 1390 PluginManager::CreateSettingForStructuredDataPlugin( 1391 debugger, GetGlobalProperties()->GetValueProperties(), 1392 ConstString("Properties for the darwin-log" 1393 " plug-in."), 1394 is_global_setting); 1395 } 1396 } 1397 1398 Status StructuredDataDarwinLog::FilterLaunchInfo(ProcessLaunchInfo &launch_info, 1399 Target *target) { 1400 Status error; 1401 1402 // If we're not debugging this launched process, there's nothing for us to do 1403 // here. 1404 if (!launch_info.GetFlags().AnySet(eLaunchFlagDebug)) 1405 return error; 1406 1407 // Darwin os_log() support automatically adds debug-level and info-level 1408 // messages when a debugger is attached to a process. However, with 1409 // integrated support for debugging built into the command-line LLDB, the 1410 // user may specifically set to *not* include debug-level and info-level 1411 // content. When the user is using the integrated log support, we want to 1412 // put the kabosh on that automatic adding of info and debug level. This is 1413 // done by adding an environment variable to the process on launch. (This 1414 // also means it is not possible to suppress this behavior if attaching to an 1415 // already-running app). 1416 // Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM)); 1417 1418 // If the target architecture is not one that supports DarwinLog, we have 1419 // nothing to do here. 1420 auto &triple = target ? target->GetArchitecture().GetTriple() 1421 : launch_info.GetArchitecture().GetTriple(); 1422 if (triple.getVendor() != llvm::Triple::Apple) { 1423 return error; 1424 } 1425 1426 // If DarwinLog is not enabled (either by explicit user command or via the 1427 // auto-enable option), then we have nothing to do. 1428 if (!GetGlobalProperties()->GetEnableOnStartup() && 1429 !s_is_explicitly_enabled) { 1430 // Nothing to do, DarwinLog is not enabled. 1431 return error; 1432 } 1433 1434 // If we don't have parsed configuration info, that implies we have enable- 1435 // on-startup set up, but we haven't yet attempted to run the enable command. 1436 if (!target) { 1437 // We really can't do this without a target. We need to be able to get to 1438 // the debugger to get the proper options to do this right. 1439 // TODO log. 1440 error.SetErrorString("requires a target to auto-enable DarwinLog."); 1441 return error; 1442 } 1443 1444 DebuggerSP debugger_sp = target->GetDebugger().shared_from_this(); 1445 auto options_sp = GetGlobalEnableOptions(debugger_sp); 1446 if (!options_sp && debugger_sp) { 1447 options_sp = ParseAutoEnableOptions(error, *debugger_sp.get()); 1448 if (!options_sp || !error.Success()) 1449 return error; 1450 1451 // We already parsed the options, save them now so we don't generate them 1452 // again until the user runs the command manually. 1453 SetGlobalEnableOptions(debugger_sp, options_sp); 1454 } 1455 1456 if (!options_sp->GetEchoToStdErr()) { 1457 // The user doesn't want to see os_log/NSLog messages echo to stderr. That 1458 // mechanism is entirely separate from the DarwinLog support. By default we 1459 // don't want to get it via stderr, because that would be in duplicate of 1460 // the explicit log support here. 1461 1462 // Here we need to strip out any OS_ACTIVITY_DT_MODE setting to prevent 1463 // echoing of os_log()/NSLog() to stderr in the target program. 1464 launch_info.GetEnvironment().erase("OS_ACTIVITY_DT_MODE"); 1465 1466 // We will also set the env var that tells any downstream launcher from 1467 // adding OS_ACTIVITY_DT_MODE. 1468 launch_info.GetEnvironment()["IDE_DISABLED_OS_ACTIVITY_DT_MODE"] = "1"; 1469 } 1470 1471 // Set the OS_ACTIVITY_MODE env var appropriately to enable/disable debug and 1472 // info level messages. 1473 const char *env_var_value; 1474 if (options_sp->GetIncludeDebugLevel()) 1475 env_var_value = "debug"; 1476 else if (options_sp->GetIncludeInfoLevel()) 1477 env_var_value = "info"; 1478 else 1479 env_var_value = "default"; 1480 1481 launch_info.GetEnvironment()["OS_ACTIVITY_MODE"] = env_var_value; 1482 1483 return error; 1484 } 1485 1486 bool StructuredDataDarwinLog::InitCompletionHookCallback( 1487 void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id, 1488 lldb::user_id_t break_loc_id) { 1489 // We hit the init function. We now want to enqueue our new thread plan, 1490 // which will in turn enqueue a StepOut thread plan. When the StepOut 1491 // finishes and control returns to our new thread plan, that is the time when 1492 // we can execute our logic to enable the logging support. 1493 1494 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1495 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() called", __FUNCTION__); 1496 1497 // Get the current thread. 1498 if (!context) { 1499 LLDB_LOGF(log, 1500 "StructuredDataDarwinLog::%s() warning: no context, " 1501 "ignoring", 1502 __FUNCTION__); 1503 return false; 1504 } 1505 1506 // Get the plugin from the process. 1507 auto process_sp = context->exe_ctx_ref.GetProcessSP(); 1508 if (!process_sp) { 1509 LLDB_LOGF(log, 1510 "StructuredDataDarwinLog::%s() warning: invalid " 1511 "process in context, ignoring", 1512 __FUNCTION__); 1513 return false; 1514 } 1515 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() call is for process uid %d", 1516 __FUNCTION__, process_sp->GetUniqueID()); 1517 1518 auto plugin_sp = process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName()); 1519 if (!plugin_sp) { 1520 LLDB_LOGF(log, 1521 "StructuredDataDarwinLog::%s() warning: no plugin for " 1522 "feature %s in process uid %u", 1523 __FUNCTION__, GetDarwinLogTypeName().AsCString(), 1524 process_sp->GetUniqueID()); 1525 return false; 1526 } 1527 1528 // Create the callback for when the thread plan completes. 1529 bool called_enable_method = false; 1530 const auto process_uid = process_sp->GetUniqueID(); 1531 1532 std::weak_ptr<StructuredDataPlugin> plugin_wp(plugin_sp); 1533 ThreadPlanCallOnFunctionExit::Callback callback = 1534 [plugin_wp, &called_enable_method, log, process_uid]() { 1535 LLDB_LOGF(log, 1536 "StructuredDataDarwinLog::post-init callback: " 1537 "called (process uid %u)", 1538 process_uid); 1539 1540 auto strong_plugin_sp = plugin_wp.lock(); 1541 if (!strong_plugin_sp) { 1542 LLDB_LOGF(log, 1543 "StructuredDataDarwinLog::post-init callback: " 1544 "plugin no longer exists, ignoring (process " 1545 "uid %u)", 1546 process_uid); 1547 return; 1548 } 1549 // Make sure we only call it once, just in case the thread plan hits 1550 // the breakpoint twice. 1551 if (!called_enable_method) { 1552 LLDB_LOGF(log, 1553 "StructuredDataDarwinLog::post-init callback: " 1554 "calling EnableNow() (process uid %u)", 1555 process_uid); 1556 static_cast<StructuredDataDarwinLog *>(strong_plugin_sp.get()) 1557 ->EnableNow(); 1558 called_enable_method = true; 1559 } else { 1560 // Our breakpoint was hit more than once. Unexpected but no harm 1561 // done. Log it. 1562 LLDB_LOGF(log, 1563 "StructuredDataDarwinLog::post-init callback: " 1564 "skipping EnableNow(), already called by " 1565 "callback [we hit this more than once] " 1566 "(process uid %u)", 1567 process_uid); 1568 } 1569 }; 1570 1571 // Grab the current thread. 1572 auto thread_sp = context->exe_ctx_ref.GetThreadSP(); 1573 if (!thread_sp) { 1574 LLDB_LOGF(log, 1575 "StructuredDataDarwinLog::%s() warning: failed to " 1576 "retrieve the current thread from the execution " 1577 "context, nowhere to run the thread plan (process uid " 1578 "%u)", 1579 __FUNCTION__, process_sp->GetUniqueID()); 1580 return false; 1581 } 1582 1583 // Queue the thread plan. 1584 auto thread_plan_sp = 1585 ThreadPlanSP(new ThreadPlanCallOnFunctionExit(*thread_sp, callback)); 1586 const bool abort_other_plans = false; 1587 thread_sp->QueueThreadPlan(thread_plan_sp, abort_other_plans); 1588 LLDB_LOGF(log, 1589 "StructuredDataDarwinLog::%s() queuing thread plan on " 1590 "trace library init method entry (process uid %u)", 1591 __FUNCTION__, process_sp->GetUniqueID()); 1592 1593 // We return false here to indicate that it isn't a public stop. 1594 return false; 1595 } 1596 1597 void StructuredDataDarwinLog::AddInitCompletionHook(Process &process) { 1598 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1599 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() called (process uid %u)", 1600 __FUNCTION__, process.GetUniqueID()); 1601 1602 // Make sure we haven't already done this. 1603 { 1604 std::lock_guard<std::mutex> locker(m_added_breakpoint_mutex); 1605 if (m_added_breakpoint) { 1606 LLDB_LOGF(log, 1607 "StructuredDataDarwinLog::%s() ignoring request, " 1608 "breakpoint already set (process uid %u)", 1609 __FUNCTION__, process.GetUniqueID()); 1610 return; 1611 } 1612 1613 // We're about to do this, don't let anybody else try to do it. 1614 m_added_breakpoint = true; 1615 } 1616 1617 // Set a breakpoint for the process that will kick in when libtrace has 1618 // finished its initialization. 1619 Target &target = process.GetTarget(); 1620 1621 // Build up the module list. 1622 FileSpecList module_spec_list; 1623 auto module_file_spec = 1624 FileSpec(GetGlobalProperties()->GetLoggingModuleName()); 1625 module_spec_list.Append(module_file_spec); 1626 1627 // We aren't specifying a source file set. 1628 FileSpecList *source_spec_list = nullptr; 1629 1630 const char *func_name = "_libtrace_init"; 1631 const lldb::addr_t offset = 0; 1632 const LazyBool skip_prologue = eLazyBoolCalculate; 1633 // This is an internal breakpoint - the user shouldn't see it. 1634 const bool internal = true; 1635 const bool hardware = false; 1636 1637 auto breakpoint_sp = target.CreateBreakpoint( 1638 &module_spec_list, source_spec_list, func_name, eFunctionNameTypeFull, 1639 eLanguageTypeC, offset, skip_prologue, internal, hardware); 1640 if (!breakpoint_sp) { 1641 // Huh? Bail here. 1642 LLDB_LOGF(log, 1643 "StructuredDataDarwinLog::%s() failed to set " 1644 "breakpoint in module %s, function %s (process uid %u)", 1645 __FUNCTION__, GetGlobalProperties()->GetLoggingModuleName(), 1646 func_name, process.GetUniqueID()); 1647 return; 1648 } 1649 1650 // Set our callback. 1651 breakpoint_sp->SetCallback(InitCompletionHookCallback, nullptr); 1652 m_breakpoint_id = breakpoint_sp->GetID(); 1653 LLDB_LOGF(log, 1654 "StructuredDataDarwinLog::%s() breakpoint set in module %s," 1655 "function %s (process uid %u)", 1656 __FUNCTION__, GetGlobalProperties()->GetLoggingModuleName(), 1657 func_name, process.GetUniqueID()); 1658 } 1659 1660 void StructuredDataDarwinLog::DumpTimestamp(Stream &stream, 1661 uint64_t timestamp) { 1662 const uint64_t delta_nanos = timestamp - m_first_timestamp_seen; 1663 1664 const uint64_t hours = delta_nanos / NANOS_PER_HOUR; 1665 uint64_t nanos_remaining = delta_nanos % NANOS_PER_HOUR; 1666 1667 const uint64_t minutes = nanos_remaining / NANOS_PER_MINUTE; 1668 nanos_remaining = nanos_remaining % NANOS_PER_MINUTE; 1669 1670 const uint64_t seconds = nanos_remaining / NANOS_PER_SECOND; 1671 nanos_remaining = nanos_remaining % NANOS_PER_SECOND; 1672 1673 stream.Printf("%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64 ".%09" PRIu64, hours, 1674 minutes, seconds, nanos_remaining); 1675 } 1676 1677 size_t 1678 StructuredDataDarwinLog::DumpHeader(Stream &output_stream, 1679 const StructuredData::Dictionary &event) { 1680 StreamString stream; 1681 1682 ProcessSP process_sp = GetProcess(); 1683 if (!process_sp) { 1684 // TODO log 1685 return 0; 1686 } 1687 1688 DebuggerSP debugger_sp = 1689 process_sp->GetTarget().GetDebugger().shared_from_this(); 1690 if (!debugger_sp) { 1691 // TODO log 1692 return 0; 1693 } 1694 1695 auto options_sp = GetGlobalEnableOptions(debugger_sp); 1696 if (!options_sp) { 1697 // TODO log 1698 return 0; 1699 } 1700 1701 // Check if we should even display a header. 1702 if (!options_sp->GetDisplayAnyHeaderFields()) 1703 return 0; 1704 1705 stream.PutChar('['); 1706 1707 int header_count = 0; 1708 if (options_sp->GetDisplayTimestampRelative()) { 1709 uint64_t timestamp = 0; 1710 if (event.GetValueForKeyAsInteger("timestamp", timestamp)) { 1711 DumpTimestamp(stream, timestamp); 1712 ++header_count; 1713 } 1714 } 1715 1716 if (options_sp->GetDisplayActivityChain()) { 1717 llvm::StringRef activity_chain; 1718 if (event.GetValueForKeyAsString("activity-chain", activity_chain) && 1719 !activity_chain.empty()) { 1720 if (header_count > 0) 1721 stream.PutChar(','); 1722 1723 // Display the activity chain, from parent-most to child-most activity, 1724 // separated by a colon (:). 1725 stream.PutCString("activity-chain="); 1726 stream.PutCString(activity_chain); 1727 ++header_count; 1728 } 1729 } 1730 1731 if (options_sp->GetDisplaySubsystem()) { 1732 llvm::StringRef subsystem; 1733 if (event.GetValueForKeyAsString("subsystem", subsystem) && 1734 !subsystem.empty()) { 1735 if (header_count > 0) 1736 stream.PutChar(','); 1737 stream.PutCString("subsystem="); 1738 stream.PutCString(subsystem); 1739 ++header_count; 1740 } 1741 } 1742 1743 if (options_sp->GetDisplayCategory()) { 1744 llvm::StringRef category; 1745 if (event.GetValueForKeyAsString("category", category) && 1746 !category.empty()) { 1747 if (header_count > 0) 1748 stream.PutChar(','); 1749 stream.PutCString("category="); 1750 stream.PutCString(category); 1751 ++header_count; 1752 } 1753 } 1754 stream.PutCString("] "); 1755 1756 output_stream.PutCString(stream.GetString()); 1757 1758 return stream.GetSize(); 1759 } 1760 1761 size_t StructuredDataDarwinLog::HandleDisplayOfEvent( 1762 const StructuredData::Dictionary &event, Stream &stream) { 1763 // Check the type of the event. 1764 ConstString event_type; 1765 if (!event.GetValueForKeyAsString("type", event_type)) { 1766 // Hmm, we expected to get events that describe what they are. Continue 1767 // anyway. 1768 return 0; 1769 } 1770 1771 if (event_type != GetLogEventType()) 1772 return 0; 1773 1774 size_t total_bytes = 0; 1775 1776 // Grab the message content. 1777 llvm::StringRef message; 1778 if (!event.GetValueForKeyAsString("message", message)) 1779 return true; 1780 1781 // Display the log entry. 1782 const auto len = message.size(); 1783 1784 total_bytes += DumpHeader(stream, event); 1785 1786 stream.Write(message.data(), len); 1787 total_bytes += len; 1788 1789 // Add an end of line. 1790 stream.PutChar('\n'); 1791 total_bytes += sizeof(char); 1792 1793 return total_bytes; 1794 } 1795 1796 void StructuredDataDarwinLog::EnableNow() { 1797 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); 1798 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() called", __FUNCTION__); 1799 1800 // Run the enable command. 1801 auto process_sp = GetProcess(); 1802 if (!process_sp) { 1803 // Nothing to do. 1804 LLDB_LOGF(log, 1805 "StructuredDataDarwinLog::%s() warning: failed to get " 1806 "valid process, skipping", 1807 __FUNCTION__); 1808 return; 1809 } 1810 LLDB_LOGF(log, "StructuredDataDarwinLog::%s() call is for process uid %u", 1811 __FUNCTION__, process_sp->GetUniqueID()); 1812 1813 // If we have configuration data, we can directly enable it now. Otherwise, 1814 // we need to run through the command interpreter to parse the auto-run 1815 // options (which is the only way we get here without having already-parsed 1816 // configuration data). 1817 DebuggerSP debugger_sp = 1818 process_sp->GetTarget().GetDebugger().shared_from_this(); 1819 if (!debugger_sp) { 1820 LLDB_LOGF(log, 1821 "StructuredDataDarwinLog::%s() warning: failed to get " 1822 "debugger shared pointer, skipping (process uid %u)", 1823 __FUNCTION__, process_sp->GetUniqueID()); 1824 return; 1825 } 1826 1827 auto options_sp = GetGlobalEnableOptions(debugger_sp); 1828 if (!options_sp) { 1829 // We haven't run the enable command yet. Just do that now, it'll take 1830 // care of the rest. 1831 auto &interpreter = debugger_sp->GetCommandInterpreter(); 1832 const bool success = RunEnableCommand(interpreter); 1833 if (log) { 1834 if (success) 1835 LLDB_LOGF(log, 1836 "StructuredDataDarwinLog::%s() ran enable command " 1837 "successfully for (process uid %u)", 1838 __FUNCTION__, process_sp->GetUniqueID()); 1839 else 1840 LLDB_LOGF(log, 1841 "StructuredDataDarwinLog::%s() error: running " 1842 "enable command failed (process uid %u)", 1843 __FUNCTION__, process_sp->GetUniqueID()); 1844 } 1845 // Report failures to the debugger error stream. 1846 auto error_stream_sp = debugger_sp->GetAsyncErrorStream(); 1847 if (error_stream_sp) { 1848 error_stream_sp->Printf("failed to configure DarwinLog " 1849 "support\n"); 1850 error_stream_sp->Flush(); 1851 } 1852 return; 1853 } 1854 1855 // We've previously been enabled. We will re-enable now with the previously 1856 // specified options. 1857 auto config_sp = options_sp->BuildConfigurationData(true); 1858 if (!config_sp) { 1859 LLDB_LOGF(log, 1860 "StructuredDataDarwinLog::%s() warning: failed to " 1861 "build configuration data for enable options, skipping " 1862 "(process uid %u)", 1863 __FUNCTION__, process_sp->GetUniqueID()); 1864 return; 1865 } 1866 1867 // We can run it directly. 1868 // Send configuration to the feature by way of the process. 1869 const Status error = 1870 process_sp->ConfigureStructuredData(GetDarwinLogTypeName(), config_sp); 1871 1872 // Report results. 1873 if (!error.Success()) { 1874 LLDB_LOGF(log, 1875 "StructuredDataDarwinLog::%s() " 1876 "ConfigureStructuredData() call failed " 1877 "(process uid %u): %s", 1878 __FUNCTION__, process_sp->GetUniqueID(), error.AsCString()); 1879 auto error_stream_sp = debugger_sp->GetAsyncErrorStream(); 1880 if (error_stream_sp) { 1881 error_stream_sp->Printf("failed to configure DarwinLog " 1882 "support: %s\n", 1883 error.AsCString()); 1884 error_stream_sp->Flush(); 1885 } 1886 m_is_enabled = false; 1887 } else { 1888 m_is_enabled = true; 1889 LLDB_LOGF(log, 1890 "StructuredDataDarwinLog::%s() success via direct " 1891 "configuration (process uid %u)", 1892 __FUNCTION__, process_sp->GetUniqueID()); 1893 } 1894 } 1895