clang-module-cache
+# Skip ctags-style tags files
+tags
+
# We should ignore Xcode-style embedding of llvm/ at lldb root dir.
# Do not add trailing '/'s, they skip symlinks.
/llvm
/DerivedData
+
+# Ignore test trace directories.
+20??-??-??-??_??_??/
+
+# Ignore crashlog support files.
+crashinfo.lock
+crashinfo.so
+
lldbPluginObjectContainerMachOArchive
lldbPluginObjectContainerBSDArchive
lldbPluginPlatformMacOSX
+ lldbPluginStructuredDataDarwinLog
lldbPluginDynamicLoaderMacOSXDYLD
lldbPluginUnwindAssemblyInstEmulation
lldbPluginUnwindAssemblyX86
--- /dev/null
+# Change Notes
+
+## Summary
+
+This document describes the DarwinLog logging feature.
+
+## StructuredDataDarwinLog feature
+
+The DarwinLog feature supports logging os_log*() and NSLog() messages
+to the command-line lldb console, as well as making those messages
+available to LLDB clients via the event system. Starting with fall
+2016 OSes, Apple platforms introduce a new fire-hose, stream-style
+logging system where the bulk of the log processing happens on the log
+consumer side. This reduces logging impact on the system when there
+are no consumers, making it cheaper to include logging at all times.
+However, it also increases the work needed on the consumer end when
+log messages are desired.
+
+The debugserver binary has been modified to support collection of
+os_log*()/NSLog() messages, selection of which messages appear in the
+stream, and fine-grained filtering of what gets passed on to the LLDB
+client. DarwinLog also tracks the activity chain (i.e. os_activity()
+hierarchy) in effect at the time the log messages were issued. The
+user is able to configure a number of aspects related to the
+formatting of the log message header fields.
+
+The DarwinLog support is written in a way which should support the
+lldb client side on non-Apple clients talking to an Apple device or
+macOS system; hence, the plugin support is built into all LLDB
+clients, not just those built on an Apple platform.
+
+StructuredDataDarwinLog implements the 'DarwinLog' feature type, and
+the plugin name for it shows up as 'darwin-log'.
+
+The user interface to the darwin-log support is via the following:
+
+* 'plugin structured-data darwin-log enable' command
+
+ This is the main entry point for enabling the command. It can be
+ set before launching a process or while the process is running.
+ If the user wants to squelch seeing info-level or debug-level
+ messages, which is the default behavior, then the enable command
+ must be made prior to launching the process; otherwise, the
+ info-level and debug-level messages will always show up. Also,
+ there is a similar "echo os_log()/NSLog() messages to target
+ process stderr" mechanism which is properly disabled when enabling
+ the DarwinLog support prior to launch. This cannot be squelched
+ if enabling DarwinLog after launch.
+
+ See the help for this command. There are a number of options
+ to shrink or expand the number of messages that are processed
+ on the remote side and sent over to the client, and other
+ options to control the formatting of messages displayed.
+
+ This command is sticky. Once enabled, it will stay enabled for
+ future process launches.
+
+* 'plugin structured-data darwin-log disable' command
+
+ Executing this command disables os_log() capture in the currently
+ running process and signals LLDB to stop attempting to launch
+ new processes with DarwinLog support enabled.
+
+* 'settings set \
+ plugin.structured-data.darwin-log.enable-on-startup'
+
+ and
+
+ 'settings set \
+ plugin.structured-data.darwin-log.auto-enable-options -- {options}'
+
+ When enable-on-startup is set to true, then LLDB will automatically
+ enable DarwinLog on startup of relevant processes. It will use the
+ content provided in the auto-enable-options settings as the
+ options to pass to the enable command.
+
+ Note the '--' required after auto-enable-command. That is necessary
+ for raw commands like settings set. The '--' will not become part
+ of the options for the enable command.
+
+### Message flow and related performance considerations
+
+os_log()-style collection is not free. The more data that must be
+processed, the slower it will be. There are several knobs available
+to the developer to limit how much data goes through the pipe, and how
+much data ultimately goes over the wire to the LLDB client. The
+user's goal should be to ensure he or she only collects as many log
+messages are needed, but no more.
+
+The flow of data looks like the following:
+
+1. Data comes into debugserver from the low-level OS facility that
+ receives log messages. The data that comes through this pipe can
+ be limited or expanded by the '--debug', '--info' and
+ '--all-processes' options of the 'plugin structured-data darwin-log
+ enable' command. options. Exclude as many categories as possible
+ here (also the default). The knobs here are very coarse - for
+ example, whether to include os_log_info()-level or
+ os_log_debug()-level info, or to include callstacks in the log
+ message event data.
+
+2. The debugserver process filters the messages that arrive through a
+ message log filter that may be fully customized by the user. It
+ works similar to a rules-based packet filter: a set of rules are
+ matched against the log message, each rule tried in sequential
+ order. The first rule that matches then either accepts or rejects
+ the message. If the log message does not match any rule, then the
+ message gets the no-match (i.e. fall-through) action. The no-match
+ action defaults to accepting but may be set to reject.
+
+ Filters can be added via the enable command's '--filter
+ {filter-spec}' option. Filters are added in order, and multiple
+ --filter entries can be provided to the enable command.
+
+ Filters take the following form:
+
+ {action} {attribute} {op}
+
+ {action} :=
+ accept |
+ reject
+
+ {attribute} :=
+ category | // The log message category
+ subsystem | // The log message subsystem}
+ activity | // The child-most activity in force
+ // at the time the message was logged.
+ activity-chain | // The complete activity chain, specified
+ // as {parent-activity}:{child-activity}:
+ // {grandchild-activity}
+ message | // The fully expanded message contents.
+ // Note this one is expensive because it
+ // requires expanding the message. Avoid
+ // this if possible, or add it further
+ // down the filter chain.
+
+ {op} :=
+ match {exact-match-text} |
+ regex {search-regex} // uses C++ std::regex
+ // ECMAScript variant.
+
+e.g.
+ --filter "accept subsystem match com.example.mycompany.myproduct"
+ --filter "accept subsystem regex com.example.+"
+ --filter "reject category regex spammy-system-[[:digit:]]+"
+
+3. Messages that are accepted by the log message filter get sent to
+ the lldb client, where they are mapped to the
+ StructuredDataDarwinLog plugin. By default, command-line lldb will
+ issue a Process-level event containing the log message content, and
+ will request the plugin to print the message if the plugin is
+ enabled to do so.
+
+### Log message display
+
+Several settings control aspects of displaying log messages in
+command-line LLDB. See the enable command's help for a description
+of these.
+
+
--- /dev/null
+# Change Notes
+
+## Overview
+
+This document describes an infrastructural feature called Structured
+Data plugins. See the DarwinLog.md doc for a description of one
+such plugin that makes use of this feature.
+
+## StructuredDataPlugin
+
+StructuredDataPlugin instances have the following characteristics:
+
+* Each plugin instance is bound to a single Process instance.
+
+* Each StructuredData feature has a type name that identifies the
+ feature. For instance, the type name for the DarwinLog feature is
+ "DarwinLog". This feature type name is used in various places.
+
+* The process monitor reports the list of supported StructuredData
+ features advertised by the process monitor. Process goes through the
+ list of supported feature type names, and asks each known
+ StructuredDataPlugin if it can handle the feature. The first plugin
+ that supports the feature is mapped to that Process instance for
+ that feature. Plugins are only mapped when the process monitor
+ advertises that a feature is supported.
+
+* The feature may send asynchronous messages in StructuredData format
+ to the Process instance. Process instances route the asynchronous
+ structured data messages to the plugin mapped to that feature type,
+ if one exists.
+
+* Plugins can request that the Process instance forward on
+ configuration data to the process monitor if the plugin needs/wants
+ to configure the feature. Plugins may call the new Process method
+
+ ```C++
+ virtual Error
+ ConfigureStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp)
+ ```
+
+ where type_name is the feature name and config_sp points to the
+ configuration structured data, which may be nullptr.
+
+* Plugins for features present in a process are notified when modules
+ are loaded into the Process instance via this StructuredDataPlugin
+ method:
+
+ ```C++
+ virtual void
+ ModulesDidLoad(Process &process, ModuleList &module_list);
+ ```
+
+* Plugins may optionally broadcast their received structured data as
+ an LLDB process-level event via the following new Process call:
+
+ ```C++
+ void
+ BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
+ const lldb::StructuredDataPluginSP &plugin_sp);
+ ```
+
+ IDE clients might use this feature to receive information about the
+ process as it is running to monitor memory usage, CPU usage, and
+ logging.
+
+ Internally, the event type created is an instance of
+ EventDataStructuredData.
+
+* In the case where a plugin chooses to broadcast a received
+ StructuredData event, the command-line LLDB Debugger instance
+ listens for them. The Debugger instance then gives the plugin an
+ opportunity to display info to either the debugger output or error
+ stream at a time that is safe to write to them. The plugin can
+ choose to display something appropriate regarding the structured
+ data that time.
+
+* Plugins can provide a ProcessLaunchInfo filter method when the
+ plugin is registered. If such a filter method is provided, then
+ when a process is about to be launched for debugging, the filter
+ callback is invoked, given both the launch info and the target. The
+ plugin may then alter the launch info if needed to better support
+ the feature of the plugin.
+
+* The plugin is entirely independent of the type of Process-derived
+ class that it is working with. The only requirements from the
+ process monitor are the following feature-agnostic elements:
+
+ * Provide a way to discover features supported by the process
+ monitor for the current process.
+
+ * Specify the list of supported feature type names to Process.
+ The process monitor does this by calling the following new
+ method on Process:
+
+ ```C++
+ void
+ MapSupportedStructuredDataPlugins(const StructuredData::Array
+ &supported_type_names)
+ ```
+
+ The supported_type_names specifies an array of string entries,
+ where each entry specifies the name of a StructuredData feature.
+
+ * Provide a way to forward on configuration data for a feature type
+ to the process monitor. This is the manner by which LLDB can
+ configure a feature, perhaps based on settings or commands from
+ the user. The following virtual method on Process (described
+ earlier) does the job:
+
+ ```C++
+ virtual Error
+ ConfigureStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp)
+ ```
+
+ * Listen for asynchronous structured data packets from the process
+ monitor, and forward them on to Process via this new Process
+ member method:
+
+ ```C++
+ bool
+ RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp)
+ ```
+
+* StructuredData producers must send their top-level data as a
+ Dictionary type, with a key called 'type' specifying a string value,
+ where the value is equal to the StructuredData feature/type name
+ previously advertised. Everything else about the content of the
+ dictionary is entirely up to the feature.
+
+* StructuredDataPlugin commands show up under 'plugin structured-data
+ plugin-name'.
+
+* StructuredDataPlugin settings show up under
+ 'plugin.structured-data.{plugin-name}.
#include "lldb/API/SBSourceManager.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
+#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBSymbol.h"
#include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBSymbolContextList.h"
class LLDB_API SBSourceManager;
class LLDB_API SBStream;
class LLDB_API SBStringList;
+class LLDB_API SBStructuredData;
class LLDB_API SBSymbol;
class LLDB_API SBSymbolContext;
class LLDB_API SBSymbolContextList;
friend class SBHostOS;
friend class SBPlatform;
friend class SBProcess;
+ friend class SBStructuredData;
friend class SBThread;
friend class SBTarget;
friend class SBValue;
eBroadcastBitInterrupt = (1 << 1),
eBroadcastBitSTDOUT = (1 << 2),
eBroadcastBitSTDERR = (1 << 3),
- eBroadcastBitProfileData = (1 << 4)
+ eBroadcastBitProfileData = (1 << 4),
+ eBroadcastBitStructuredData = (1 << 5)
};
SBProcess ();
static bool
GetInterruptedFromEvent (const lldb::SBEvent &event);
-
+
+ static lldb::SBStructuredData
+ GetStructuredDataFromEvent (const lldb::SBEvent &event);
+
static bool
EventIsProcessEvent (const lldb::SBEvent &event);
+ static bool
+ EventIsStructuredDataEvent (const lldb::SBEvent &event);
+
lldb::SBBroadcaster
GetBroadcaster () const;
friend class SBProcess;
friend class SBSection;
friend class SBSourceManager;
+ friend class SBStructuredData;
friend class SBSymbol;
friend class SBSymbolContext;
friend class SBSymbolContextList;
--- /dev/null
+//===-- SBStructuredData.h --------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SBStructuredData_h
+#define SBStructuredData_h
+
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBModule.h"
+
+namespace lldb {
+
+ class SBStructuredData
+ {
+ public:
+
+ SBStructuredData();
+
+ SBStructuredData(const lldb::SBStructuredData &rhs);
+
+ SBStructuredData(const lldb::EventSP &event_sp);
+
+ ~SBStructuredData();
+
+ lldb::SBStructuredData &
+ operator =(const lldb::SBStructuredData &rhs);
+
+ bool
+ IsValid() const;
+
+ void
+ Clear();
+
+ lldb::SBError
+ GetAsJSON(lldb::SBStream &stream) const;
+
+ lldb::SBError
+ GetDescription(lldb::SBStream &stream) const;
+
+ private:
+
+ class Impl;
+ std::unique_ptr<Impl> m_impl_up;
+ };
+}
+
+#endif /* SBStructuredData_h */
/// //----------------------------------------------------------
/// enum
/// {
-/// eBroadcastBitStateChanged = (1 << 0),
-/// eBroadcastBitInterrupt = (1 << 1),
-/// eBroadcastBitSTDOUT = (1 << 2),
-/// eBroadcastBitSTDERR = (1 << 3),
-/// eBroadcastBitProfileData = (1 << 4)
+/// eBroadcastBitOne = (1 << 0),
+/// eBroadcastBitTwo = (1 << 1),
+/// eBroadcastBitThree = (1 << 2),
+/// ...
/// };
/// \endcode
//----------------------------------------------------------------------
// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/ConstString.h"
+#include "lldb/Core/StructuredData.h"
#include "lldb/Host/Predicate.h"
#include "lldb/Core/Broadcaster.h"
};
//----------------------------------------------------------------------
+/// This class handles one or more StructuredData::Dictionary entries
+/// that are raised for structured data events.
+//----------------------------------------------------------------------
+
+class EventDataStructuredData : public EventData
+{
+public:
+
+ //------------------------------------------------------------------
+ // Constructors
+ //------------------------------------------------------------------
+ EventDataStructuredData();
+
+ EventDataStructuredData(const lldb::ProcessSP &process_sp,
+ const StructuredData::ObjectSP &object_sp,
+ const lldb::StructuredDataPluginSP &plugin_sp);
+
+ ~EventDataStructuredData() override;
+
+ //------------------------------------------------------------------
+ // Member functions
+ //------------------------------------------------------------------
+ const ConstString &
+ GetFlavor() const override;
+
+ void
+ Dump(Stream *s) const override;
+
+ const lldb::ProcessSP&
+ GetProcess() const;
+
+ const StructuredData::ObjectSP&
+ GetObject() const;
+
+ const lldb::StructuredDataPluginSP&
+ GetStructuredDataPlugin() const;
+
+ void
+ SetProcess(const lldb::ProcessSP &process_sp);
+
+ void
+ SetObject(const StructuredData::ObjectSP &object_sp);
+
+ void
+ SetStructuredDataPlugin(const lldb::StructuredDataPluginSP &plugin_sp);
+
+ //------------------------------------------------------------------
+ // Static functions
+ //------------------------------------------------------------------
+ static const EventDataStructuredData*
+ GetEventDataFromEvent(const Event *event_ptr);
+
+ static lldb::ProcessSP
+ GetProcessFromEvent(const Event *event_ptr);
+
+ static StructuredData::ObjectSP
+ GetObjectFromEvent(const Event *event_ptr);
+
+ static lldb::StructuredDataPluginSP
+ GetPluginFromEvent(const Event *event_ptr);
+
+ static const ConstString &
+ GetFlavorString ();
+
+private:
+
+ lldb::ProcessSP m_process_sp;
+ StructuredData::ObjectSP m_object_sp;
+ lldb::StructuredDataPluginSP m_plugin_sp;
+
+ DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData);
+};
+
+//----------------------------------------------------------------------
// lldb::Event
//----------------------------------------------------------------------
class Event
CommandInterpreter &interpreter);
//------------------------------------------------------------------
+ // StructuredDataPlugin
+ //------------------------------------------------------------------
+
+ //------------------------------------------------------------------
+ /// Register a StructuredDataPlugin class along with optional
+ /// callbacks for debugger initialization and Process launch info
+ /// filtering and manipulation.
+ ///
+ /// @param[in] name
+ /// The name of the plugin.
+ ///
+ /// @param[in] description
+ /// A description string for the plugin.
+ ///
+ /// @param[in] create_callback
+ /// The callback that will be invoked to create an instance of
+ /// the callback. This may not be nullptr.
+ ///
+ /// @param[in] debugger_init_callback
+ /// An optional callback that will be made when a Debugger
+ /// instance is initialized.
+ ///
+ /// @param[in] filter_callback
+ /// An optional callback that will be invoked before LLDB
+ /// launches a process for debugging. The callback must
+ /// do the following:
+ /// 1. Only do something if the plugin's behavior is enabled.
+ /// 2. Only make changes for processes that are relevant to the
+ /// plugin. The callback gets a pointer to the Target, which
+ /// can be inspected as needed. The ProcessLaunchInfo is
+ /// provided in read-write mode, and may be modified by the
+ /// plugin if, for instance, additional environment variables
+ /// are needed to support the feature when enabled.
+ ///
+ /// @return
+ /// Returns true upon success; otherwise, false.
+ //------------------------------------------------------------------
+ static bool
+ RegisterPlugin(const ConstString &name,
+ const char *description,
+ StructuredDataPluginCreateInstance create_callback,
+ DebuggerInitializeCallback debugger_init_callback = nullptr,
+ StructuredDataFilterLaunchInfo filter_callback
+ = nullptr);
+
+ static bool
+ UnregisterPlugin(StructuredDataPluginCreateInstance create_callback);
+
+ static StructuredDataPluginCreateInstance
+ GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx);
+
+ static StructuredDataPluginCreateInstance
+ GetStructuredDataPluginCreateCallbackForPluginName(const ConstString &name);
+
+ static StructuredDataFilterLaunchInfo
+ GetStructuredDataFilterCallbackAtIndex(uint32_t idx,
+ bool &iteration_complete);
+
+ //------------------------------------------------------------------
// SymbolFile
//------------------------------------------------------------------
static bool
static bool CreateSettingForOperatingSystemPlugin(Debugger &debugger,
const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property);
+
+ static lldb::OptionValuePropertiesSP
+ GetSettingForStructuredDataPlugin(Debugger &debugger,
+ const ConstString &setting_name);
+
+ static bool
+ CreateSettingForStructuredDataPlugin(Debugger &debugger,
+ const lldb::OptionValuePropertiesSP &properties_sp,
+ const ConstString &description,
+ bool is_global_property);
};
} // namespace lldb_private
LongestCommonPrefix (std::string &common_prefix);
//------------------------------------------------------------------
+ /// Add or replace an environment variable with the given value.
+ ///
+ /// This command adds the environment variable if it is not already
+ /// present using the given value. If the environment variable is
+ /// already in the list, it replaces the first such occurrence
+ /// with the new value.
+ //------------------------------------------------------------------
+ void
+ AddOrReplaceEnvironmentVariable(const char *env_var_name,
+ const char *new_value);
+
/// Return whether a given environment variable exists.
///
/// This command treats Args like a list of environment variables,
/// @param[in] env_var_name
/// Specifies the name of the environment variable to check.
///
+ /// @param[out] argument_index
+ /// If non-null, then when the environment variable is found,
+ /// the index of the argument position will be returned in
+ /// the size_t pointed to by this argument.
+ ///
/// @return
/// true if the specified env var name exists in the list in
/// either of the above-mentioned formats; otherwise, false.
//------------------------------------------------------------------
bool
- ContainsEnvironmentVariable(const char *env_var_name) const;
+ ContainsEnvironmentVariable(const char *env_var_name,
+ size_t *argument_index = nullptr) const;
protected:
//------------------------------------------------------------------
eBroadcastBitInterrupt = (1 << 1),
eBroadcastBitSTDOUT = (1 << 2),
eBroadcastBitSTDERR = (1 << 3),
- eBroadcastBitProfileData = (1 << 4)
+ eBroadcastBitProfileData = (1 << 4),
+ eBroadcastBitStructuredData = (1 << 5),
};
enum
AdvanceAddressToNextBranchInstruction (Address default_stop_addr,
AddressRange range_bounds);
+ //------------------------------------------------------------------
+ /// Configure asynchronous structured data feature.
+ ///
+ /// Each Process type that supports using an asynchronous StructuredData
+ /// feature should implement this to enable/disable/configure the feature.
+ /// The default implementation here will always return an error indiciating
+ /// the feature is unsupported.
+ ///
+ /// StructuredDataPlugin implementations will call this to configure
+ /// a feature that has been reported as being supported.
+ ///
+ /// @param[in] type_name
+ /// The StructuredData type name as previously discovered by
+ /// the Process-derived instance.
+ ///
+ /// @param[in] config
+ /// Configuration data for the feature being enabled. This config
+ /// data, which may be null, will be passed along to the feature
+ /// to process. The feature will dictate whether this is a dictionary,
+ /// an array or some other object. If the feature needs to be
+ /// set up properly before it can be enabled, then the config should
+ /// also take an enable/disable flag.
+ ///
+ /// @return
+ /// Returns the result of attempting to configure the feature.
+ //------------------------------------------------------------------
+ virtual Error
+ ConfigureStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp);
+
+ //------------------------------------------------------------------
+ /// Broadcasts the given structured data object from the given
+ /// plugin.
+ ///
+ /// StructuredDataPlugin instances can use this to optionally
+ /// broadcast any of their data if they want to make it available
+ /// for clients. The data will come in on the structured data
+ /// event bit (eBroadcastBitStructuredData).
+ ///
+ /// @param[in] object_sp
+ /// The structured data object to broadcast.
+ ///
+ /// @param[in] plugin_sp
+ /// The plugin that will be reported in the event's plugin
+ /// parameter.
+ //------------------------------------------------------------------
+ void
+ BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
+ const lldb::StructuredDataPluginSP &plugin_sp);
+
+ //------------------------------------------------------------------
+ /// Returns the StructuredDataPlugin associated with a given type
+ /// name, if there is one.
+ ///
+ /// There will only be a plugin for a given StructuredDataType if the
+ /// debugged process monitor claims that the feature is supported.
+ /// This is one way to tell whether a feature is available.
+ ///
+ /// @return
+ /// The plugin if one is available for the specified feature;
+ /// otherwise, returns an empty shared pointer.
+ //------------------------------------------------------------------
+ lldb::StructuredDataPluginSP
+ GetStructuredDataPlugin(const ConstString &type_name) const;
+
protected:
void
SetState (lldb::EventSP &event_sp);
}
//------------------------------------------------------------------
+ /// Loads any plugins associated with asynchronous structured data
+ /// and maps the relevant supported type name to the plugin.
+ ///
+ /// Processes can receive asynchronous structured data from the
+ /// process monitor. This method will load and map any structured
+ /// data plugins that support the given set of supported type names.
+ /// Later, if any of these features are enabled, the process monitor
+ /// is free to generate asynchronous structured data. The data must
+ /// come in as a single \b StructuredData::Dictionary. That dictionary
+ /// must have a string field named 'type', with a value that equals
+ /// the relevant type name string (one of the values in
+ /// \b supported_type_names).
+ ///
+ /// @param[in] supported_type_names
+ /// An array of zero or more type names. Each must be unique.
+ /// For each entry in the list, a StructuredDataPlugin will be
+ /// searched for that supports the structured data type name.
+ //------------------------------------------------------------------
+ void
+ MapSupportedStructuredDataPlugins(const StructuredData::Array
+ &supported_type_names);
+
+ //------------------------------------------------------------------
+ /// Route the incoming structured data dictionary to the right plugin.
+ ///
+ /// The incoming structured data must be a dictionary, and it must
+ /// have a key named 'type' that stores a string value. The string
+ /// value must be the name of the structured data feature that
+ /// knows how to handle it.
+ ///
+ /// @param[in] object_sp
+ /// When non-null and pointing to a dictionary, the 'type'
+ /// key's string value is used to look up the plugin that
+ /// was registered for that structured data type. It then
+ /// calls the following method on the StructuredDataPlugin
+ /// instance:
+ ///
+ /// virtual void
+ /// HandleArrivalOfStructuredData(Process &process,
+ /// const ConstString &type_name,
+ /// const StructuredData::ObjectSP
+ /// &object_sp)
+ ///
+ /// @return
+ /// True if the structured data was routed to a plugin; otherwise,
+ /// false.
+ //------------------------------------------------------------------
+ bool
+ RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp);
+
+ //------------------------------------------------------------------
// Type definitions
//------------------------------------------------------------------
typedef std::map<lldb::LanguageType, lldb::LanguageRuntimeSP> LanguageRuntimeCollection;
{
}
};
+
+ using StructuredDataPluginMap = std::map<ConstString,
+ lldb::StructuredDataPluginSP>;
//------------------------------------------------------------------
// Member variables
bool m_can_interpret_function_calls; // Some targets, e.g the OSX kernel, don't support the ability to modify the stack.
WarningsCollection m_warnings_issued; // A set of object pointers which have already had warnings printed
std::mutex m_run_thread_plan_lock;
-
+ StructuredDataPluginMap m_structured_data_plugin_map;
+
+
enum {
eCanJITDontKnow= 0,
eCanJITYes,
void
BroadcastAsyncProfileData(const std::string &one_profile_data);
-
+
static void
STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len);
--- /dev/null
+//===-- StructuredDataPlugin.h ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef StructuredDataPlugin_h
+#define StructuredDataPlugin_h
+
+#include "lldb/Core/PluginInterface.h"
+#include "lldb/Core/StructuredData.h"
+
+namespace lldb_private
+{
+
+class CommandObjectMultiword;
+
+// -----------------------------------------------------------------------------
+/// Plugin that supports process-related structured data sent asynchronously
+/// from the debug monitor (e.g. debugserver, lldb-server, etc.)
+///
+/// This plugin type is activated by a Process-derived instance when that
+/// instance detects that a given structured data feature is available.
+///
+/// StructuredDataPlugin instances are inherently tied to a process. The
+/// main functionality they support is the ability to consume asynchronously-
+/// delivered structured data from the process monitor, and do something
+/// reasonable with it. Something reasonable can include broadcasting a
+/// StructuredData event, which other parts of the system can then do with
+/// as they please. An IDE could use this facility to retrieve CPU usage,
+/// memory usage, and other run-time aspects of the process. That data
+/// can then be displayed meaningfully to the user through the IDE.
+
+/// For command-line LLDB, the Debugger instance listens for the structured
+/// data events raised by the plugin, and give the plugin both the output
+/// and error streams such that the plugin can display something about the
+/// event, at a time when the debugger ensures it is safe to write to the
+/// output or error streams.
+// -----------------------------------------------------------------------------
+
+class StructuredDataPlugin :
+ public PluginInterface,
+ public std::enable_shared_from_this<StructuredDataPlugin>
+{
+public:
+
+ virtual ~StructuredDataPlugin();
+
+ lldb::ProcessSP
+ GetProcess() const;
+
+ // -------------------------------------------------------------------------
+ // Public instance API
+ // -------------------------------------------------------------------------
+
+ // -------------------------------------------------------------------------
+ /// Return whether this plugin supports the given StructuredData feature.
+ ///
+ /// When Process is informed of a list of process-monitor-supported
+ /// structured data features, Process will go through the list of plugins,
+ /// one at a time, and have the first plugin that supports a given feature
+ /// be the plugin instantiated to handle that feature. There is a 1-1
+ /// correspondence between a Process instance and a StructuredDataPlugin
+ /// mapped to that process. A plugin can support handling multiple
+ /// features, and if that happens, there is a single plugin instance
+ /// created covering all of the mapped features for a given process.
+ ///
+ /// @param[in] type_name
+ /// The name of the feature tag supported by a process.
+ /// e.g. "darwin-log".
+ ///
+ /// @return
+ /// true if the plugin supports the feature; otherwise, false.
+ // -------------------------------------------------------------------------
+ virtual bool
+ SupportsStructuredDataType(const ConstString &type_name) = 0;
+
+ // -------------------------------------------------------------------------
+ /// Handle the arrival of asynchronous structured data from the process.
+ ///
+ /// When asynchronous structured data arrives from the process monitor,
+ /// it is immediately delivered to the plugin mapped for that feature
+ /// if one exists. The structured data that arrives from a process
+ /// monitor must be a dictionary, and it must have a string field named
+ /// "type" that must contain the StructuredData feature name set as the
+ /// value. This is the manner in which the data is routed to the proper
+ /// plugin instance.
+ ///
+ /// @param[in] process
+ /// The process instance that just received the structured data.
+ /// This will always be the same process for a given instance of
+ /// a plugin.
+ ///
+ /// @param[in] type_name
+ /// The name of the feature tag for the asynchronous structured data.
+ /// Note this data will also be present in the \b object_sp dictionary
+ /// under the string value with key "type".
+ ///
+ /// @param[in] object_sp
+ /// A shared pointer to the structured data that arrived. This must
+ /// be a dictionary. The only key required is the aforementioned
+ /// key named "type" that must be a string value containing the
+ /// structured data type name.
+ // -------------------------------------------------------------------------
+ virtual void
+ HandleArrivalOfStructuredData(Process &process,
+ const ConstString &type_name,
+ const StructuredData::ObjectSP
+ &object_sp) = 0;
+
+
+ // -------------------------------------------------------------------------
+ /// Get a human-readable description of the contents of the data.
+ ///
+ /// In command-line LLDB, this method will be called by the Debugger
+ /// instance for each structured data event generated, and the output
+ /// will be printed to the LLDB console. If nothing is added to the stream,
+ /// nothing will be printed; otherwise, a newline will be added to the end
+ /// when displayed.
+ ///
+ /// @param[in] object_sp
+ /// A shared pointer to the structured data to format.
+ ///
+ /// @param[in] stream
+ /// The stream where the structured data should be pretty printed.
+ ///
+ /// @return
+ /// The error if formatting the object contents failed; otherwise,
+ /// success.
+ // -------------------------------------------------------------------------
+ virtual Error
+ GetDescription(const StructuredData::ObjectSP &object_sp,
+ lldb_private::Stream &stream) = 0;
+
+ // -------------------------------------------------------------------------
+ /// Returns whether the plugin's features are enabled.
+ ///
+ /// This is a convenience method for plugins that can enable or disable
+ /// their functionality. It allows retrieval of this state without
+ /// requiring a cast.
+ ///
+ /// @param[in] type_name
+ /// The name of the feature tag for the asynchronous structured data.
+ /// This is needed for plugins that support more than one feature.
+ // -------------------------------------------------------------------------
+ virtual bool
+ GetEnabled(const ConstString &type_name) const;
+
+ // -------------------------------------------------------------------------
+ /// Allow the plugin to do work related to modules that loaded in the
+ /// the corresponding process.
+ ///
+ /// This method defaults to doing nothing. Plugins can override it
+ /// if they have any behavior they want to enable/modify based on loaded
+ /// modules.
+ ///
+ /// @param[in] process
+ /// The process that just was notified of modules having been loaded.
+ /// This will always be the same process for a given instance of
+ /// a plugin.
+ ///
+ /// @param[in] module_list
+ /// The list of modules that the process registered as having just
+ /// loaded. See \b Process::ModulesDidLoad(...).
+ // -------------------------------------------------------------------------
+ virtual void
+ ModulesDidLoad(Process &process, ModuleList &module_list);
+
+protected:
+
+ // -------------------------------------------------------------------------
+ // Derived-class API
+ // -------------------------------------------------------------------------
+ StructuredDataPlugin(const lldb::ProcessWP &process_wp);
+
+ // -------------------------------------------------------------------------
+ /// Derived classes must call this before attempting to hook up commands
+ /// to the 'plugin structured-data' tree.
+ ///
+ /// This ensures the relevant command and options hook points for all
+ /// StructuredDataPlugin derived classes are available for this debugger.
+ /// If this has already happened, this call is a no-op.
+ ///
+ /// @param[in] debugger
+ /// The Debugger instance for which we're creating the required shared
+ /// components for the StructuredDataPlugin derived classes.
+ // -------------------------------------------------------------------------
+ static void
+ InitializeBasePluginForDebugger(Debugger &debugger);
+
+private:
+
+ lldb::ProcessWP m_process_wp;
+
+ DISALLOW_COPY_AND_ASSIGN(StructuredDataPlugin);
+
+};
+
+}
+
+#endif
--- /dev/null
+//===-- ThreadPlanCallOnFunctionExit.h --------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ThreadPlanCallOnFunctionExit_h
+#define ThreadPlanCallOnFunctionExit_h
+
+#include "lldb/Target/ThreadPlan.h"
+
+#include <functional>
+
+namespace lldb_private {
+
+// =============================================================================
+/// This thread plan calls a function object when the current function exits.
+// =============================================================================
+
+class ThreadPlanCallOnFunctionExit : public ThreadPlan
+{
+public:
+
+ /// Definition for the callback made when the currently executing thread
+ /// finishes executing its function.
+ using Callback = std::function<void()>;
+
+ ThreadPlanCallOnFunctionExit(Thread &thread, const Callback &callback);
+
+ void
+ DidPush() override;
+
+ // -------------------------------------------------------------------------
+ // ThreadPlan API
+ // -------------------------------------------------------------------------
+
+ void
+ GetDescription (Stream *s, lldb::DescriptionLevel level) override;
+
+ bool
+ ValidatePlan (Stream *error) override;
+
+ bool
+ ShouldStop (Event *event_ptr) override;
+
+ bool
+ WillStop () override;
+
+protected:
+
+ bool
+ DoPlanExplainsStop (Event *event_ptr) override;
+
+ lldb::StateType
+ GetPlanRunState () override;
+
+private:
+
+ Callback m_callback;
+ lldb::ThreadPlanSP m_step_out_threadplan_sp;
+
+};
+
+}
+
+#endif /* ThreadPlanCallOnFunctionExit_h */
class EvaluateExpressionOptions;
class Event;
class EventData;
+class EventDataStructuredData;
class ExecutionContext;
class ExecutionContextRef;
class ExecutionContextRefLocker;
class StreamString;
class StringList;
struct StringSummaryFormat;
+class StructuredDataPlugin;
class SystemRuntime;
class TypeSummaryImpl;
class TypeSummaryOptions;
typedef std::unique_ptr<lldb_private::DynamicLoader> DynamicLoaderUP;
typedef std::shared_ptr<lldb_private::Event> EventSP;
typedef std::shared_ptr<lldb_private::EventData> EventDataSP;
+ typedef std::shared_ptr<lldb_private::EventDataStructuredData> EventDataStructuredDataSP;
typedef std::shared_ptr<lldb_private::ExecutionContextRef> ExecutionContextRefSP;
typedef std::shared_ptr<lldb_private::ExpressionVariable> ExpressionVariableSP;
typedef std::shared_ptr<lldb_private::File> FileSP;
typedef std::weak_ptr<lldb_private::Stream> StreamWP;
typedef std::shared_ptr<lldb_private::StreamFile> StreamFileSP;
typedef std::shared_ptr<lldb_private::StringSummaryFormat> StringTypeSummaryImplSP;
+ typedef std::shared_ptr<lldb_private::StructuredDataPlugin>
+ StructuredDataPluginSP;
+ typedef std::weak_ptr<lldb_private::StructuredDataPlugin>
+ StructuredDataPluginWP;
typedef std::shared_ptr<lldb_private::SymbolFile> SymbolFileSP;
typedef std::shared_ptr<lldb_private::SymbolFileType> SymbolFileTypeSP;
typedef std::weak_ptr<lldb_private::SymbolFileType> SymbolFileTypeWP;
typedef Language *(*LanguageCreateInstance) (lldb::LanguageType language);
typedef LanguageRuntime *(*LanguageRuntimeCreateInstance) (Process *process, lldb::LanguageType language);
typedef lldb::CommandObjectSP (*LanguageRuntimeGetCommandObject) (CommandInterpreter& interpreter);
+ typedef lldb::StructuredDataPluginSP (*StructuredDataPluginCreateInstance)
+ (Process &process);
+ typedef Error (*StructuredDataFilterLaunchInfo)(ProcessLaunchInfo &launch_info, Target *target);
typedef SystemRuntime *(*SystemRuntimeCreateInstance) (Process *process);
typedef lldb::PlatformSP (*PlatformCreateInstance) (bool force, const ArchSpec *arch);
typedef lldb::ProcessSP (*ProcessCreateInstance) (lldb::TargetSP target_sp, lldb::ListenerSP listener_sp, const FileSpec *crash_file_path);
23059A0719532B96007B8189 /* LinuxSignals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23059A0519532B96007B8189 /* LinuxSignals.cpp */; };
23059A101958B319007B8189 /* SBUnixSignals.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23059A0F1958B319007B8189 /* SBUnixSignals.cpp */; };
23059A121958B3B2007B8189 /* SBUnixSignals.h in Headers */ = {isa = PBXBuildFile; fileRef = 23059A111958B37B007B8189 /* SBUnixSignals.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ 230EC4591D63C3A7008DF59F /* CMakeLists.txt in CopyFiles */ = {isa = PBXBuildFile; fileRef = 230EC4571D63C3A7008DF59F /* CMakeLists.txt */; };
+ 230EC45B1D63C3BA008DF59F /* ThreadPlanCallOnFunctionExit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 230EC4581D63C3A7008DF59F /* ThreadPlanCallOnFunctionExit.cpp */; };
2326CF441BDD643700A5CEAC /* liblldb-core.a in Frameworks */ = {isa = PBXBuildFile; fileRef = 2689FFCA13353D7A00698AC0 /* liblldb-core.a */; };
2326CF491BDD67D800A5CEAC /* libncurses.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 2326CF471BDD67C100A5CEAC /* libncurses.dylib */; };
2326CF4B1BDD681800A5CEAC /* libz.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 2326CF4A1BDD681800A5CEAC /* libz.dylib */; };
233B007F1960CB280090E598 /* ProcessLaunchInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 233B007E1960CB280090E598 /* ProcessLaunchInfo.cpp */; };
236124A41986B4E2004EFC37 /* IOObject.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 236124A21986B4E2004EFC37 /* IOObject.cpp */; };
236124A51986B4E2004EFC37 /* Socket.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 236124A31986B4E2004EFC37 /* Socket.cpp */; };
+ 2374D7461D4BAA1D005C9575 /* CMakeLists.txt in CopyFiles */ = {isa = PBXBuildFile; fileRef = 2374D7431D4BAA1D005C9575 /* CMakeLists.txt */; };
2374D7521D4BB299005C9575 /* GDBRemoteClientBase.h in CopyFiles */ = {isa = PBXBuildFile; fileRef = 2374D74F1D4BB299005C9575 /* GDBRemoteClientBase.h */; };
2374D7531D4BB2FF005C9575 /* GDBRemoteClientBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2374D74E1D4BB299005C9575 /* GDBRemoteClientBase.cpp */; };
2377C2F819E613C100737875 /* PipePosix.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2377C2F719E613C100737875 /* PipePosix.cpp */; };
+ 238F2B9E1D2C82D0001FF92A /* StructuredDataPlugin.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 238F2B9D1D2C82D0001FF92A /* StructuredDataPlugin.cpp */; };
+ 238F2BA11D2C835A001FF92A /* StructuredDataPlugin.h in Headers */ = {isa = PBXBuildFile; fileRef = 238F2B9F1D2C835A001FF92A /* StructuredDataPlugin.h */; };
+ 238F2BA21D2C835A001FF92A /* SystemRuntime.h in Headers */ = {isa = PBXBuildFile; fileRef = 238F2BA01D2C835A001FF92A /* SystemRuntime.h */; };
+ 238F2BA81D2C85FA001FF92A /* StructuredDataDarwinLog.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 238F2BA61D2C85FA001FF92A /* StructuredDataDarwinLog.cpp */; };
+ 238F2BA91D2C85FA001FF92A /* StructuredDataDarwinLog.h in Headers */ = {isa = PBXBuildFile; fileRef = 238F2BA71D2C85FA001FF92A /* StructuredDataDarwinLog.h */; };
239481861C59EBDD00DF7168 /* libncurses.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 239481851C59EBDD00DF7168 /* libncurses.dylib */; };
239504DE1BDD453200963CEA /* SocketAddressTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2321F9391BDD332400BA9A93 /* SocketAddressTest.cpp */; };
239504DF1BDD453200963CEA /* SocketTest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2321F93A1BDD332400BA9A93 /* SocketTest.cpp */; };
23D065911D4A7BEE0008EDE6 /* RenderScriptx86ABIFixups.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23D065861D4A7BDA0008EDE6 /* RenderScriptx86ABIFixups.cpp */; };
23D4007D1C2101F2000C3885 /* DWARFDebugMacro.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23E77CD61C20F29F007192AD /* DWARFDebugMacro.cpp */; };
23D4007E1C210201000C3885 /* DebugMacros.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23E77CDB1C20F2F2007192AD /* DebugMacros.cpp */; };
+ 23DCBE9B1D63E14B0084C36B /* SBLanguageRuntime.i in CopyFiles */ = {isa = PBXBuildFile; fileRef = 23DCBE971D63E14B0084C36B /* SBLanguageRuntime.i */; };
+ 23DCBE9D1D63E14B0084C36B /* SBTypeEnumMember.i in CopyFiles */ = {isa = PBXBuildFile; fileRef = 23DCBE991D63E14B0084C36B /* SBTypeEnumMember.i */; };
+ 23DCBE9E1D63E14B0084C36B /* SBUnixSignals.i in CopyFiles */ = {isa = PBXBuildFile; fileRef = 23DCBE9A1D63E14B0084C36B /* SBUnixSignals.i */; };
+ 23DCBEA21D63E7190084C36B /* SBStructuredData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23DCBEA01D63E6440084C36B /* SBStructuredData.cpp */; };
+ 23DCBEA31D63E71F0084C36B /* SBStructuredData.h in Headers */ = {isa = PBXBuildFile; fileRef = 23DCBE9F1D63E3800084C36B /* SBStructuredData.h */; settings = {ATTRIBUTES = (Public, ); }; };
23DCEA461D1C4D0F00A602B4 /* SBMemoryRegionInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23DCEA421D1C4C6900A602B4 /* SBMemoryRegionInfo.cpp */; };
23DCEA471D1C4D0F00A602B4 /* SBMemoryRegionInfoList.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23DCEA431D1C4C6900A602B4 /* SBMemoryRegionInfoList.cpp */; };
23DDF226196C3EE600BB8417 /* CommandOptionValidators.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23DDF224196C3EE600BB8417 /* CommandOptionValidators.cpp */; };
2374D7521D4BB299005C9575 /* GDBRemoteClientBase.h in CopyFiles */,
23D0658C1D4A7BDA0008EDE6 /* RenderScriptRuntime.h in CopyFiles */,
23D0658A1D4A7BDA0008EDE6 /* RenderScriptExpressionOpts.h in CopyFiles */,
+ 230EC4591D63C3A7008DF59F /* CMakeLists.txt in CopyFiles */,
49DEF1221CD7BD90006A7C7D /* BlockPointer.h in CopyFiles */,
+ 2374D7461D4BAA1D005C9575 /* CMakeLists.txt in CopyFiles */,
4CC7C6531D5299140076FF94 /* DWARFASTParserOCaml.h in CopyFiles */,
+ 23DCBE9D1D63E14B0084C36B /* SBTypeEnumMember.i in CopyFiles */,
AF90106515AB7D3600FF120D /* lldb.1 in CopyFiles */,
+ 23DCBE9B1D63E14B0084C36B /* SBLanguageRuntime.i in CopyFiles */,
+ 23DCBE9E1D63E14B0084C36B /* SBUnixSignals.i in CopyFiles */,
23D065881D4A7BDA0008EDE6 /* CMakeLists.txt in CopyFiles */,
);
runOnlyForDeploymentPostprocessing = 1;
23059A0619532B96007B8189 /* LinuxSignals.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = LinuxSignals.h; path = Utility/LinuxSignals.h; sourceTree = "<group>"; };
23059A0F1958B319007B8189 /* SBUnixSignals.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBUnixSignals.cpp; path = source/API/SBUnixSignals.cpp; sourceTree = "<group>"; };
23059A111958B37B007B8189 /* SBUnixSignals.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBUnixSignals.h; path = include/lldb/API/SBUnixSignals.h; sourceTree = "<group>"; };
+ 230EC4571D63C3A7008DF59F /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = CMakeLists.txt; path = source/Target/CMakeLists.txt; sourceTree = "<group>"; };
+ 230EC4581D63C3A7008DF59F /* ThreadPlanCallOnFunctionExit.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadPlanCallOnFunctionExit.cpp; path = source/Target/ThreadPlanCallOnFunctionExit.cpp; sourceTree = "<group>"; };
23173F8B192BA93F005C708F /* lldb-x86-register-enums.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "lldb-x86-register-enums.h"; path = "Utility/lldb-x86-register-enums.h"; sourceTree = "<group>"; };
2321F9381BDD332400BA9A93 /* CMakeLists.txt */ = {isa = PBXFileReference; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
2321F9391BDD332400BA9A93 /* SocketAddressTest.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SocketAddressTest.cpp; sourceTree = "<group>"; };
236124A31986B4E2004EFC37 /* Socket.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Socket.cpp; sourceTree = "<group>"; };
236124A61986B50E004EFC37 /* IOObject.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = IOObject.h; path = include/lldb/Host/IOObject.h; sourceTree = "<group>"; };
236124A71986B50E004EFC37 /* Socket.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = Socket.h; path = include/lldb/Host/Socket.h; sourceTree = "<group>"; };
+ 2374D7431D4BAA1D005C9575 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
2374D74E1D4BB299005C9575 /* GDBRemoteClientBase.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GDBRemoteClientBase.cpp; sourceTree = "<group>"; };
2374D74F1D4BB299005C9575 /* GDBRemoteClientBase.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GDBRemoteClientBase.h; sourceTree = "<group>"; };
2377C2F719E613C100737875 /* PipePosix.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PipePosix.cpp; sourceTree = "<group>"; };
237C577A19AF9D9F00213D59 /* HostInfoLinux.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = HostInfoLinux.h; path = include/lldb/Host/linux/HostInfoLinux.h; sourceTree = SOURCE_ROOT; };
+ 238F2B9D1D2C82D0001FF92A /* StructuredDataPlugin.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StructuredDataPlugin.cpp; path = source/Target/StructuredDataPlugin.cpp; sourceTree = "<group>"; };
+ 238F2B9F1D2C835A001FF92A /* StructuredDataPlugin.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = StructuredDataPlugin.h; path = include/lldb/Target/StructuredDataPlugin.h; sourceTree = "<group>"; };
+ 238F2BA01D2C835A001FF92A /* SystemRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SystemRuntime.h; path = include/lldb/Target/SystemRuntime.h; sourceTree = "<group>"; };
+ 238F2BA61D2C85FA001FF92A /* StructuredDataDarwinLog.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StructuredDataDarwinLog.cpp; sourceTree = "<group>"; };
+ 238F2BA71D2C85FA001FF92A /* StructuredDataDarwinLog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StructuredDataDarwinLog.h; sourceTree = "<group>"; };
239481851C59EBDD00DF7168 /* libncurses.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libncurses.dylib; path = ../../../../../usr/lib/libncurses.dylib; sourceTree = "<group>"; };
239504C21BDD3FD600963CEA /* gtest_common.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = gtest_common.h; sourceTree = "<group>"; };
239504C61BDD3FF300963CEA /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
23D065851D4A7BDA0008EDE6 /* RenderScriptRuntime.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderScriptRuntime.h; sourceTree = "<group>"; };
23D065861D4A7BDA0008EDE6 /* RenderScriptx86ABIFixups.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderScriptx86ABIFixups.cpp; sourceTree = "<group>"; };
23D065871D4A7BDA0008EDE6 /* RenderScriptx86ABIFixups.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderScriptx86ABIFixups.h; sourceTree = "<group>"; };
+ 23DCBE971D63E14B0084C36B /* SBLanguageRuntime.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBLanguageRuntime.i; sourceTree = "<group>"; };
+ 23DCBE981D63E14B0084C36B /* SBStructuredData.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBStructuredData.i; sourceTree = "<group>"; };
+ 23DCBE991D63E14B0084C36B /* SBTypeEnumMember.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBTypeEnumMember.i; sourceTree = "<group>"; };
+ 23DCBE9A1D63E14B0084C36B /* SBUnixSignals.i */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c.preprocessed; path = SBUnixSignals.i; sourceTree = "<group>"; };
+ 23DCBE9F1D63E3800084C36B /* SBStructuredData.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = SBStructuredData.h; path = include/lldb/API/SBStructuredData.h; sourceTree = "<group>"; };
+ 23DCBEA01D63E6440084C36B /* SBStructuredData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBStructuredData.cpp; path = source/API/SBStructuredData.cpp; sourceTree = "<group>"; };
23DCEA421D1C4C6900A602B4 /* SBMemoryRegionInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBMemoryRegionInfo.cpp; path = source/API/SBMemoryRegionInfo.cpp; sourceTree = "<group>"; };
23DCEA431D1C4C6900A602B4 /* SBMemoryRegionInfoList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SBMemoryRegionInfoList.cpp; path = source/API/SBMemoryRegionInfoList.cpp; sourceTree = "<group>"; };
23DDF224196C3EE600BB8417 /* CommandOptionValidators.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = CommandOptionValidators.cpp; path = source/Interpreter/CommandOptionValidators.cpp; sourceTree = "<group>"; };
path = platforms;
sourceTree = "<group>";
};
+ 238F2BA41D2C858F001FF92A /* StructuredData */ = {
+ isa = PBXGroup;
+ children = (
+ 238F2BA51D2C85B2001FF92A /* DarwinLog */,
+ );
+ path = StructuredData;
+ sourceTree = "<group>";
+ };
+ 238F2BA51D2C85B2001FF92A /* DarwinLog */ = {
+ isa = PBXGroup;
+ children = (
+ 238F2BA71D2C85FA001FF92A /* StructuredDataDarwinLog.h */,
+ 238F2BA61D2C85FA001FF92A /* StructuredDataDarwinLog.cpp */,
+ );
+ path = DarwinLog;
+ sourceTree = "<group>";
+ };
23AB0526199FF5D3003B8084 /* FreeBSD */ = {
isa = PBXGroup;
children = (
26C5577E132575B6008FD8FE /* Platform */,
260C898A10F57C5600BB2B04 /* Process */,
3FBA69DA1B6066D20008F44A /* ScriptInterpreter */,
+ 238F2BA41D2C858F001FF92A /* StructuredData */,
AF11CB34182CA85A00D9B618 /* SystemRuntime */,
260C89B110F57C5600BB2B04 /* SymbolFile */,
260C89E010F57C5600BB2B04 /* SymbolVendor */,
2611FEEE142D83060017FEA3 /* interface */ = {
isa = PBXGroup;
children = (
- 254FBBA61A91672800BD6378 /* SBAttachInfo.i */,
- 254FBB921A81AA5200BD6378 /* SBLaunchInfo.i */,
2611FEEF142D83060017FEA3 /* SBAddress.i */,
+ 254FBBA61A91672800BD6378 /* SBAttachInfo.i */,
2611FEF0142D83060017FEA3 /* SBBlock.i */,
2611FEF1142D83060017FEA3 /* SBBreakpoint.i */,
2611FEF2142D83060017FEA3 /* SBBreakpointLocation.i */,
2611FF00142D83060017FEA3 /* SBHostOS.i */,
2611FF02142D83060017FEA3 /* SBInstruction.i */,
2611FF03142D83060017FEA3 /* SBInstructionList.i */,
+ 23DCBE971D63E14B0084C36B /* SBLanguageRuntime.i */,
+ 254FBB921A81AA5200BD6378 /* SBLaunchInfo.i */,
2611FF04142D83060017FEA3 /* SBLineEntry.i */,
2611FF05142D83060017FEA3 /* SBListener.i */,
264297591D1DF2AA003F2BF4 /* SBMemoryRegionInfo.i */,
2611FF09142D83060017FEA3 /* SBSourceManager.i */,
2611FF0A142D83060017FEA3 /* SBStream.i */,
2611FF0B142D83060017FEA3 /* SBStringList.i */,
+ 23DCBE981D63E14B0084C36B /* SBStructuredData.i */,
2611FF0C142D83060017FEA3 /* SBSymbol.i */,
2611FF0D142D83060017FEA3 /* SBSymbolContext.i */,
2611FF0E142D83060017FEA3 /* SBSymbolContextList.i */,
8CCB018419BA54930009FD44 /* SBThreadCollection.i */,
2611FF11142D83060017FEA3 /* SBType.i */,
9475C18A14E5EA1C001BFC6D /* SBTypeCategory.i */,
+ 23DCBE991D63E14B0084C36B /* SBTypeEnumMember.i */,
9461569214E3567F003A195C /* SBTypeFilter.i */,
9461569314E3567F003A195C /* SBTypeFormat.i */,
9475C18B14E5F818001BFC6D /* SBTypeNameSpecifier.i */,
9461569414E3567F003A195C /* SBTypeSummary.i */,
9461569514E3567F003A195C /* SBTypeSynthetic.i */,
+ 23DCBE9A1D63E14B0084C36B /* SBUnixSignals.i */,
2611FF12142D83060017FEA3 /* SBValue.i */,
2611FF13142D83060017FEA3 /* SBValueList.i */,
94235B9D1A8D601A00EB2EED /* SBVariablesOptions.i */,
26C72C951243229A0068DC16 /* SBStream.cpp */,
9A357670116E7B5200E8ED2F /* SBStringList.h */,
9A357672116E7B6400E8ED2F /* SBStringList.cpp */,
+ 23DCBE9F1D63E3800084C36B /* SBStructuredData.h */,
+ 23DCBEA01D63E6440084C36B /* SBStructuredData.cpp */,
26DE205A11618FF600A093E2 /* SBSymbol.h */,
26DE20641161904E00A093E2 /* SBSymbol.cpp */,
26DE204011618AB900A093E2 /* SBSymbolContext.h */,
26BC7DEF10F1B80200F91463 /* Target */ = {
isa = PBXGroup;
children = (
+ 230EC4571D63C3A7008DF59F /* CMakeLists.txt */,
8CF02AE019DCBF3B00B14BE0 /* InstrumentationRuntime.h */,
8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */,
8CF02AEE19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.h */,
26BC7F3A10F1B90C00F91463 /* StackID.cpp */,
2615DB841208A9C90021781D /* StopInfo.h */,
2615DB861208A9E40021781D /* StopInfo.cpp */,
+ 238F2B9F1D2C835A001FF92A /* StructuredDataPlugin.h */,
+ 238F2B9D1D2C82D0001FF92A /* StructuredDataPlugin.cpp */,
+ 238F2BA01D2C835A001FF92A /* SystemRuntime.h */,
AF81DEF91828A23F0042CF19 /* SystemRuntime.cpp */,
26BC7DF810F1B81A00F91463 /* Target.h */,
26BC7F3B10F1B90C00F91463 /* Target.cpp */,
49EC3E98118F90AC00B1265E /* ThreadPlanCallFunction.cpp */,
EB8375E81B553DFE00BA907D /* ThreadPlanCallFunctionUsingABI.h */,
EB8375E61B553DE800BA907D /* ThreadPlanCallFunctionUsingABI.cpp */,
+ 230EC4581D63C3A7008DF59F /* ThreadPlanCallOnFunctionExit.cpp */,
4C7CF7E31295E10E00B4FBB5 /* ThreadPlanCallUserExpression.h */,
4C7CF7E51295E12B00B4FBB5 /* ThreadPlanCallUserExpression.cpp */,
4C56543219D1EFB5002E9C44 /* ThreadPlanPython.h */,
4CEE62F71145F1C70064CF93 /* GDB Remote */ = {
isa = PBXGroup;
children = (
+ 2374D7431D4BAA1D005C9575 /* CMakeLists.txt */,
2374D74F1D4BB299005C9575 /* GDBRemoteClientBase.h */,
2374D74E1D4BB299005C9575 /* GDBRemoteClientBase.cpp */,
6D55B2931A8A808400A70529 /* GDBRemoteCommunicationServerCommon.h */,
9A357671116E7B5200E8ED2F /* SBStringList.h in Headers */,
26DE205B11618FF600A093E2 /* SBSymbol.h in Headers */,
262F12B71835469C00AEB384 /* SBPlatform.h in Headers */,
+ 23DCBEA31D63E71F0084C36B /* SBStructuredData.h in Headers */,
26DE204111618AB900A093E2 /* SBSymbolContext.h in Headers */,
268F9D53123AA15200B91E9B /* SBSymbolContextList.h in Headers */,
2668022C115FD13D008E1FE4 /* SBTarget.h in Headers */,
4984BA181B979C08008658D4 /* ExpressionVariable.h in Headers */,
26C7C4841BFFEA7E009BD01F /* WindowsMiniDump.h in Headers */,
30B38A001CAAA6D7009524E3 /* ClangUtil.h in Headers */,
+ 238F2BA11D2C835A001FF92A /* StructuredDataPlugin.h in Headers */,
AF8AD62F1BEC28A400150209 /* PlatformAppleTVSimulator.h in Headers */,
+ 238F2BA91D2C85FA001FF92A /* StructuredDataDarwinLog.h in Headers */,
AF8AD63A1BEC28C400150209 /* PlatformRemoteAppleWatch.h in Headers */,
257906651BD5AFD000178368 /* Acceptor.h in Headers */,
+ 238F2BA21D2C835A001FF92A /* SystemRuntime.h in Headers */,
260A63171861008E00FECF8E /* IOHandler.h in Headers */,
267F68581CC02EAE0086832B /* RegisterContextPOSIX_s390x.h in Headers */,
6D0F614F1C80AB0C00A4ECEE /* JavaLanguageRuntime.h in Headers */,
9461569D14E358A6003A195C /* SBTypeSynthetic.cpp in Sources */,
26680324116005D9008E1FE4 /* SBThread.cpp in Sources */,
26680326116005DB008E1FE4 /* SBTarget.cpp in Sources */,
+ 23DCBEA21D63E7190084C36B /* SBStructuredData.cpp in Sources */,
26680327116005DC008E1FE4 /* SBSourceManager.cpp in Sources */,
3F81692C1ABB7A1E001DA9DF /* SystemInitializerFull.cpp in Sources */,
26680328116005DE008E1FE4 /* SBProcess.cpp in Sources */,
268900C213353E5F00698AC0 /* DWARFDebugPubnamesSet.cpp in Sources */,
268900C313353E5F00698AC0 /* DWARFDebugRanges.cpp in Sources */,
25EF23781AC09B3700908DF0 /* AdbClient.cpp in Sources */,
+ 238F2BA81D2C85FA001FF92A /* StructuredDataDarwinLog.cpp in Sources */,
94380B8219940B0A00BFE4A8 /* StringLexer.cpp in Sources */,
268900C413353E5F00698AC0 /* DWARFDefines.cpp in Sources */,
945563101BEAD0650073F75F /* PlatformiOSSimulatorCoreSimulatorSupport.mm in Sources */,
26D5E163135BB054006EA0A7 /* OptionGroupPlatform.cpp in Sources */,
94CD131A19BA33B400DB7BED /* TypeValidator.cpp in Sources */,
26BD407F135D2AE000237D80 /* FileLineResolver.cpp in Sources */,
+ 230EC45B1D63C3BA008DF59F /* ThreadPlanCallOnFunctionExit.cpp in Sources */,
AE44FB311BB07EB80033EB62 /* GoLexer.cpp in Sources */,
26A7A035135E6E4200FB369E /* OptionValue.cpp in Sources */,
9A22A161135E30370024DDC3 /* EmulateInstructionARM.cpp in Sources */,
945261C81B9A14D300BF138D /* CXXFunctionPointer.cpp in Sources */,
94CB256716B096F10059775D /* TypeCategoryMap.cpp in Sources */,
94CB257016B0A4270059775D /* TypeFormat.cpp in Sources */,
+ 238F2B9E1D2C82D0001FF92A /* StructuredDataPlugin.cpp in Sources */,
94CB257116B0A4270059775D /* TypeSummary.cpp in Sources */,
94CB257216B0A4270059775D /* TypeSynthetic.cpp in Sources */,
94CB257416B1D3880059775D /* FormatCache.cpp in Sources */,
--- /dev/null
+"""
+Base class for DarwinLog tests.
+"""
+
+# System imports
+from __future__ import print_function
+
+import json
+import os
+import pexpect
+import platform
+import re
+import sys
+import threading
+
+
+# lldb imports
+import lldb
+from lldb import SBProcess, SBTarget
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import lldbtest_config
+from lldbsuite.test import lldbutil
+
+
+def expand_darwinlog_command(command):
+ return "plugin structured-data darwin-log " + command
+
+
+def expand_darwinlog_settings_set_command(command):
+ return "settings set plugin.structured-data.darwin-log." + command
+
+
+class DarwinLogTestBase(lldbtest.TestBase):
+ """Base class for DarwinLog test cases that are pexpect-based."""
+ NO_DEBUG_INFO_TESTCASE = True
+
+ CONTINUE_REGEX = re.compile(r"Process \d+ resuming")
+
+ def setUp(self):
+ # Call super's setUp().
+ super(DarwinLogTestBase, self).setUp()
+
+ # Until other systems support this, exit
+ # early if we're not macOS version 10.12
+ # or greater.
+ version = platform.mac_ver()[0].split('.')
+ if ((int(version[0]) == 10) and (int(version[1]) < 12) or
+ (int(version[0]) < 10)):
+ self.skipTest("DarwinLog tests currently require macOS 10.12+")
+ return
+
+ self.child = None
+ self.child_prompt = '(lldb) '
+ self.strict_sources = False
+ self.enable_process_monitor_logging = False
+
+ def run_lldb_to_breakpoint(self, exe, source_file, line,
+ enable_command=None, settings_commands=None):
+
+ # Set self.child_prompt, which is "(lldb) ".
+ prompt = self.child_prompt
+
+ # So that the child gets torn down after the test.
+ self.child = pexpect.spawn('%s %s %s' % (lldbtest_config.lldbExec,
+ self.lldbOption, exe))
+ child = self.child
+
+ # Turn on logging for what the child sends back.
+ if self.TraceOn():
+ child.logfile_read = sys.stdout
+
+ if self.enable_process_monitor_logging:
+ if platform.system() == 'Darwin':
+ self.runCmd("settings set target.process.extra-startup-command "
+ "QSetLogging:bitmask=LOG_DARWIN_LOG;")
+ self.expect_prompt()
+
+ # Run the enable command if we have one.
+ if enable_command is not None:
+ self.runCmd(enable_command)
+ self.expect_prompt()
+
+ # Disable showing of source lines at our breakpoint.
+ # This is necessary for the logging tests, because the very
+ # text we want to match for output from the running inferior
+ # will show up in the source as well. We don't want the source
+ # output to erroneously make a match with our expected output.
+ self.runCmd("settings set stop-line-count-before 0")
+ self.expect_prompt()
+ self.runCmd("settings set stop-line-count-after 0")
+ self.expect_prompt()
+
+ # While we're debugging, turn on packet logging.
+ self.runCmd("log enable -f /tmp/packets.log gdb-remote packets")
+ self.expect_prompt()
+
+ # Prevent mirroring of NSLog/os_log content to stderr. We want log
+ # messages to come exclusively through our log channel.
+ self.runCmd("settings set target.env-vars IDE_DISABLED_OS_ACTIVITY_DT_MODE=1")
+ self.expect_prompt()
+
+ # Run any darwin-log settings commands now, before we enable logging.
+ if settings_commands is not None:
+ for setting_command in settings_commands:
+ self.runCmd(
+ expand_darwinlog_settings_set_command(setting_command))
+ self.expect_prompt()
+
+ # Set breakpoint right before the os_log() macros. We don't
+ # set it on the os_log*() calls because these are a number of
+ # nested-scoped calls that will cause the debugger to stop
+ # multiple times on the same line. That is difficult to match
+ # os_log() content by since it is non-deterministic what the
+ # ordering between stops and log lines will be. This is why
+ # we stop before, and then have the process run in a sleep
+ # afterwards, so we get the log messages while the target
+ # process is "running" (sleeping).
+ child.sendline('breakpoint set -f %s -l %d' % (source_file, line))
+ child.expect_exact(prompt)
+
+ # Now run to the breakpoint that we just set.
+ child.sendline('run')
+ child.expect_exact(prompt)
+
+ # Ensure we stopped at a breakpoint.
+ self.runCmd("thread list")
+ self.expect(re.compile(r"stop reason = breakpoint"))
+
+ # Now we're ready to check if DarwinLog is available.
+ if not self.darwin_log_available():
+ self.skipTest("DarwinLog not available")
+
+ def runCmd(self, cmd):
+ self.child.sendline(cmd)
+
+ def expect_prompt(self, exactly=True):
+ self.expect(self.child_prompt, exactly=exactly)
+
+ def expect(self, pattern, exactly=False, *args, **kwargs):
+ if exactly:
+ return self.child.expect_exact(pattern, *args, **kwargs)
+ return self.child.expect(pattern, *args, **kwargs)
+
+ def darwin_log_available(self):
+ self.runCmd("plugin structured-data darwin-log status")
+ self.expect(re.compile(r"Availability: ([\S]+)"))
+ return self.child.match is not None and (
+ self.child.match.group(1) == "available")
+
+ def do_test(self, enable_options, expect_regexes=None,
+ settings_commands=None):
+ """Test that a single fall-through reject rule rejects all logging."""
+ self.build(dictionary=self.d)
+ self.setTearDownCleanup(dictionary=self.d)
+
+ # Build the darwin-log enable command.
+ enable_cmd = expand_darwinlog_command('enable')
+ if enable_options is not None and len(enable_options) > 0:
+ enable_cmd += ' ' + ' '.join(enable_options)
+
+ exe = os.path.join(os.getcwd(), self.exe_name)
+ self.run_lldb_to_breakpoint(exe, self.source, self.line,
+ enable_command=enable_cmd,
+ settings_commands=settings_commands)
+ self.expect_prompt()
+
+ # Now go.
+ self.runCmd("process continue")
+ self.expect(self.CONTINUE_REGEX)
+
+ if expect_regexes is None:
+ # Expect matching a log line or program exit.
+ # Test methods determine which ones are valid.
+ expect_regexes = (
+ [re.compile(r"source-log-([^-]+)-(\S+)"),
+ re.compile(r"exited with status")
+ ])
+ self.expect(expect_regexes)
+
+
+def remove_add_mode_entry(log_entries):
+ """libtrace creates an "Add Mode:..." message when logging is enabled.
+ Strip this out of results since our test subjects don't create it."""
+ return [entry for entry in log_entries
+ if "message" in entry and
+ not entry["message"].startswith("Add Mode:")]
+
+
+class DarwinLogEventBasedTestBase(lldbtest.TestBase):
+ """Base class for event-based DarwinLog tests."""
+ NO_DEBUG_INFO_TESTCASE = True
+
+ class EventListenerThread(threading.Thread):
+ def __init__(self, listener, process, trace_on, max_entry_count):
+ super(DarwinLogEventBasedTestBase.EventListenerThread, self).__init__()
+ self.process = process
+ self.listener = listener
+ self.trace_on = trace_on
+ self.max_entry_count = max_entry_count
+ self.exception = None
+ self.structured_data_event_count = 0
+ self.wait_seconds = 2
+ self.max_timeout_count = 4
+ self.log_entries = []
+
+ def handle_structured_data_event(self, event):
+ structured_data = SBProcess.GetStructuredDataFromEvent(event)
+ if not structured_data.IsValid():
+ if self.trace_on:
+ print("invalid structured data")
+ return
+
+ # Track that we received a valid structured data event.
+ self.structured_data_event_count += 1
+
+ # Grab the individual log entries from the JSON.
+ stream = lldb.SBStream()
+ structured_data.GetAsJSON(stream)
+ dict = json.loads(stream.GetData())
+ self.log_entries.extend(dict["events"])
+ if self.trace_on:
+ print("Structured data (raw):", stream.GetData())
+
+ # Print the pretty-printed version.
+ if self.trace_on:
+ stream.Clear()
+ structured_data.PrettyPrint(stream)
+ print("Structured data (pretty print):",
+ stream.GetData())
+
+ def done(self, timeout_count):
+ """Returns True when we're done listening for events."""
+ # See if we should consider the number of events retrieved.
+ if self.max_entry_count is not None:
+ if len(self.log_entries) >= self.max_entry_count:
+ # We've received the max threshold of events expected,
+ # we can exit here.
+ if self.trace_on:
+ print("Event listener thread exiting due to max "
+ "expected log entry count being reached.")
+ return True
+
+ # If our event timeout count has exceeded our maximum timeout count,
+ # we're done.
+ if timeout_count >= self.max_timeout_count:
+ if self.trace_on:
+ print("Event listener thread exiting due to max number of "
+ "WaitForEvent() timeouts being reached.")
+ return True
+
+ # If our process is dead, we're done.
+ if not self.process.is_alive:
+ if self.trace_on:
+ print("Event listener thread exiting due to test inferior "
+ "exiting.")
+ return True
+
+ # We're not done.
+ return False
+
+ def run(self):
+ event = lldb.SBEvent()
+ try:
+ timeout_count = 0
+
+ # Wait up to 4 times for the event to arrive.
+ while not self.done(timeout_count):
+ if self.trace_on:
+ print("Calling wait for event...")
+ if self.listener.WaitForEvent(self.wait_seconds, event):
+ while event.IsValid():
+ # Check if it's a process event.
+ if SBProcess.EventIsStructuredDataEvent(event):
+ self.handle_structured_data_event(event)
+ else:
+ if self.trace_on:
+ print("ignoring unexpected event:",
+ lldbutil.get_description(event))
+ # Grab the next event, if there is one.
+ event.Clear()
+ if not self.listener.GetNextEvent(event):
+ if self.trace_on:
+ print("listener has no more events "
+ "available at this time")
+ else:
+ if self.trace_on:
+ print("timeout occurred waiting for event...")
+ timeout_count += 1
+ self.listener.Clear()
+ except Exception as e:
+ self.exception = e
+
+ def setUp(self):
+ # Call super's setUp().
+ super(DarwinLogEventBasedTestBase, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ # Enable debugserver logging of the darwin log collection
+ # mechanism.
+ self.runCmd("settings set target.process.extra-startup-command "
+ "QSetLogging:bitmask=LOG_DARWIN_LOG;")
+
+ def do_test(self, enable_options, settings_commands=None,
+ run_enable_after_breakpoint=False, max_entry_count=None):
+ """Runs the test inferior, returning collected events.
+
+ This method runs the test inferior to the first breakpoint hit.
+ It then adds a listener for structured data events, and collects
+ all events from that point forward until end of execution of the
+ test inferior. It then returns those events.
+
+ @return
+ A list of structured data events received, in the order they
+ were received.
+ """
+ self.build(dictionary=self.d)
+ self.setTearDownCleanup(dictionary=self.d)
+
+ exe = os.path.join(os.getcwd(), self.exe_name)
+
+ # Create a target by the debugger.
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target, lldbtest.VALID_TARGET)
+
+ # Run the darwin-log settings commands.
+ if settings_commands is not None:
+ for setting_command in settings_commands:
+ self.runCmd(
+ expand_darwinlog_settings_set_command(setting_command))
+
+ # Build the darwin-log enable command.
+ enable_cmd = expand_darwinlog_command("enable")
+ if enable_options is not None and len(enable_options) > 0:
+ enable_cmd += ' ' + ' '.join(enable_options)
+
+ # Run the darwin-log enable command now if we are not supposed
+ # to do it at the first breakpoint. This tests the start-up
+ # code, which has the benefit of being able to set os_log-related
+ # environment variables.
+ if not run_enable_after_breakpoint:
+ self.runCmd(enable_cmd)
+
+ # Create the breakpoint.
+ breakpoint = target.BreakpointCreateByLocation(self.source, self.line)
+ self.assertIsNotNone(breakpoint)
+ self.assertTrue(breakpoint.IsValid())
+ self.assertEqual(1, breakpoint.GetNumLocations(),
+ "Should have found one breakpoint")
+
+ # Enable packet logging.
+ # self.runCmd("log enable -f /tmp/packets.log gdb-remote packets")
+ # self.runCmd("log enable lldb process")
+
+ # Launch the process - doesn't stop at entry.
+ process = target.LaunchSimple(None, None, os.getcwd())
+ self.assertIsNotNone(process, lldbtest.PROCESS_IS_VALID)
+
+ # Keep track of whether we're tracing output.
+ trace_on = self.TraceOn()
+
+ # Get the next thread that stops.
+ from lldbsuite.test.lldbutil import get_stopped_thread
+ thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
+
+ self.assertIsNotNone(thread, "There should be a thread stopped "
+ "due to breakpoint")
+
+ # The process should be stopped at this point.
+ self.expect("process status", lldbtest.PROCESS_STOPPED,
+ patterns=['Process .* stopped'])
+
+ # The stop reason of the thread should be breakpoint.
+ self.expect("thread list", lldbtest.STOPPED_DUE_TO_BREAKPOINT,
+ substrs=['stopped', 'stop reason = breakpoint'])
+
+ # And our one and only breakpoint should have been hit.
+ self.assertEquals(breakpoint.GetHitCount(), 1)
+
+ # Now setup the structured data listener.
+ #
+ # Grab the broadcaster for the process. We'll be attaching our
+ # listener to it.
+ broadcaster = process.GetBroadcaster()
+ self.assertIsNotNone(broadcaster)
+
+ listener = lldb.SBListener("SBStructuredData listener")
+ self.assertIsNotNone(listener)
+
+ rc = broadcaster.AddListener(listener,
+ lldb.SBProcess.eBroadcastBitStructuredData)
+ self.assertTrue(rc, "Successfully add listener to process broadcaster")
+
+ # Start the listening thread to retrieve the events.
+ # Bump up max entry count for the potentially included Add Mode:
+ # entry.
+ if max_entry_count is not None:
+ max_entry_count += 1
+ event_thread = self.EventListenerThread(listener, process, trace_on,
+ max_entry_count)
+ event_thread.start()
+
+ # Continue the test inferior. We should get any events after this.
+ process.Continue()
+
+ # Wait until the event thread terminates.
+ # print("main thread now waiting for event thread to receive events.")
+ event_thread.join()
+
+ # If the process is still alive, we kill it here.
+ if process.is_alive:
+ process.Kill()
+
+ # Fail on any exceptions that occurred during event execution.
+ if event_thread.exception is not None:
+ # Re-raise it here so it shows up as a test error.
+ raise event_thread
+
+ # Return the collected logging events.
+ return remove_add_mode_entry(event_thread.log_entries)
--- /dev/null
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+# System imports
+from __future__ import print_function
+
+# LLDB imports
+from lldbsuite.test import darwin_log
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+
+
+class TestDarwinLogBasic(darwin_log.DarwinLogEventBasedTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ @decorators.add_test_categories(['pyapi'])
+ @decorators.skipUnlessDarwin
+ def test_SBStructuredData_gets_broadcasted(self):
+ """Exercise SBStructuredData API."""
+
+ # Run the test.
+ log_entries = self.do_test(None, max_entry_count=2)
+
+ # Validate that we received our two log entries.
+ self.assertEqual(len(log_entries), 1,
+ "Expected one log entry to arrive via events.")
+ self.assertEqual(log_entries[0]['message'], "Hello, world",
+ "Log message should match expected content.")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger = os_log_create("org.llvm.lldb.test", "basic-test");
+ if (!logger)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_log(logger, "Hello, world");
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+// The number of seconds to wait at the end of the test inferior before
+// exiting. This delay is needed to ensure the logging infrastructure
+// has flushed out the message. If we finished before all messages were
+// flushed, then the test will never see the unflushed messages, causing
+// some test logic to fail.
+#define FINAL_WAIT_SECONDS 5
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterMatchActivityChain(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterMatchActivityChain, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterMatchActivityChain, self).tearDown()
+
+ # ==========================================================================
+ # activity-chain filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_chain_match(self):
+ """Test that fall-through reject, accept full-match activity chain works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity-chain match "
+ "parent-activity:child-activity\""])
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_chain_partial_match(self):
+ """Test that fall-through reject, doesn't accept only partial match of activity-chain."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity-chain match parent-activity:child-activity\"", # Match the second fully.
+ "--filter \"accept activity-chain match parent-ac\""]) # Only partially match the first.
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_chain_full_match(self):
+ """Test that fall-through accept, reject match activity-chain works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject activity-chain match parent-activity\""])
+
+ # We should only see the second log message as we rejected the first
+ # via activity-chain rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_chain_second_rule(self):
+ """Test that fall-through reject, accept activity-chain on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity-chain match non-existent\"",
+ "--filter \"accept activity-chain match parent-activity:child-activity\""])
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the activity-chain of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterMatchActivity(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterMatchActivity, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterMatchActivity, self).tearDown()
+
+ # ==========================================================================
+ # activity filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_match(self):
+ """Test that fall-through reject, accept match activity works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity match child-activity\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_partial_match(self):
+ """Test that fall-through reject, accept match activity via partial match does not accept."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity match child-activity\"", # Fully match second message.
+ "--filter \"accept activity match parent-\""] # Only partially match first message.
+ )
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_full_match(self):
+ """Test that fall-through accept, reject match activity works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject activity match parent-activity\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via activity rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_second_rule(self):
+ """Test that fall-through reject, accept regex activity on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity match non-existent\"",
+ "--filter \"accept activity match child-activity\""
+ ]
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the activity of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterMatchCategory(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterMatchCategory, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterMatchCategory, self).tearDown()
+
+ # ==========================================================================
+ # category filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_category_full_match(self):
+ """Test that fall-through reject, accept match single category works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept category match cat2\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that category.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_category_partial_match(self):
+ """Test that fall-through reject, accept regex category via partial match works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept category match cat2\"", # Fully match the second message.
+ "--filter \"accept category match at1\""] # Only partially match first message. Should not show up.
+ )
+
+ # We should only see the second log message as we only accept
+ # that category.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_category_full_match(self):
+ """Test that fall-through accept, reject match category works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject category match cat1\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via category rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_category_second_rule(self):
+ """Test that fall-through reject, accept match category on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept category match non-existent\"",
+ "--filter \"accept category match cat2\""
+ ]
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the category of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterMatchMessage(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterMatchMessage, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ self.strict_sources = True
+
+ # Turn on process monitor logging while we work out issues.
+ self.enable_process_monitor_logging = True
+
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterMatchMessage, self).tearDown()
+
+ # ==========================================================================
+ # category filter tests
+ # ==========================================================================
+
+ EXPECT_REGEXES = [
+ re.compile(r"log message ([^-]+)-(\S+)"),
+ re.compile(r"exited with status")
+ ]
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_message_full_match(self):
+ """Test that fall-through reject, accept match whole message works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept message match log message sub2-cat2\""],
+ expect_regexes=self.EXPECT_REGEXES
+ )
+
+ # We should only see the second log message as we only accept
+ # that message contents.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_no_accept_message_partial_match(self):
+ """Test that fall-through reject, match message via partial content match doesn't accept."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept message match log message sub2-cat2\"",
+ "--filter \"accept message match sub1-cat1\""],
+ expect_regexes=self.EXPECT_REGEXES
+ )
+
+ # We should only see the second log message as the partial match on
+ # the first message should not pass.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_category_full_match(self):
+ """Test that fall-through accept, reject match message works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject message match log message sub1-cat1\""],
+ expect_regexes=self.EXPECT_REGEXES
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via message contents rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_category_second_rule(self):
+ """Test that fall-through reject, accept match category on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept message match non-existent\"",
+ "--filter \"accept message match log message sub2-cat2\""],
+ expect_regexes=self.EXPECT_REGEXES
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the category of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_log(logger_sub1, "log message sub%d-cat%d", 1, 1);
+ os_log(logger_sub2, "log message sub%d-cat%d", 2, 2);
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(1);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterMatchSubsystem(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterMatchSubsystem, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterMatchSubsystem, self).tearDown()
+
+ # ==========================================================================
+ # subsystem filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_subsystem_full_match(self):
+ """Test that fall-through reject, accept match single subsystem works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept subsystem match org.llvm.lldb.test.sub2\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that subsystem.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_subsystem_partial_match(self):
+ """Test that fall-through reject, doesn't accept match subsystem via partial-match."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept subsystem match org.llvm.lldb.test.sub2\"", # Fully match second message subsystem.
+ "--filter \"accept subsystem match sub1\""] # Only partially match first subsystem.
+ )
+
+ # We should only see the second log message as we only accept
+ # that subsystem.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_subsystem_full_match(self):
+ """Test that fall-through accept, reject match subsystem works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject subsystem match org.llvm.lldb.test.sub1\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via subsystem rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_subsystem_second_rule(self):
+ """Test that fall-through reject, accept match subsystem on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept subsystem match non-existent\"",
+ "--filter \"accept subsystem match org.llvm.lldb.test.sub2\""
+ ]
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the subsystem of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterRegexActivityChain(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterRegexActivityChain, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterRegexActivityChain, self).tearDown()
+
+ # ==========================================================================
+ # activity-chain filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_chain_full_match(self):
+ """Test that fall-through reject, accept full-match activity chain works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity-chain regex "
+ "parent-activity:child-activity\""])
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_chain_partial_match(self):
+ """Test that fall-through reject, accept activity-chain via partial match works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity-chain regex :child-activity\""])
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_chain_full_match(self):
+ """Test that fall-through accept, reject activity-chain works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject activity-chain regex parent-activity:child-..tivity\""])
+
+ # We should only see the second log message as we rejected the first
+ # via activity-chain rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat1"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_chain_partial_match(self):
+ """Test that fall-through accept, reject activity-chain by partial match works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject activity-chain regex ^p[^:]+$\""])
+
+ # We should only see the second log message as we rejected the first
+ # via activity-chain rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_chain_second_rule(self):
+ """Test that fall-through reject, accept activity-chain on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity-chain regex non-existent\"",
+ "--filter \"accept activity-chain regex child-activity\""])
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the activity-chain of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterRegexActivity(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterRegexActivity, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterRegexActivity, self).tearDown()
+
+ # ==========================================================================
+ # activity filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_full_match(self):
+ """Test that fall-through reject, accept regex full-match activity works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity regex child-activity\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_partial_match(self):
+ """Test that fall-through reject, regex accept activity via partial match works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity regex child-.*\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that activity.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_full_match(self):
+ """Test that fall-through accept, reject regex activity works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject activity regex parent-activity\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via activity rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_activity_partial_match(self):
+ """Test that fall-through accept, reject regex activity by partial match works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject activity regex p.+-activity\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via activity rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_activity_second_rule(self):
+ """Test that fall-through reject, accept regex activity on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept activity regex non-existent\"",
+ "--filter \"accept activity regex child-activity\""
+ ]
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the activity of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterRegexCategory(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterRegexCategory, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterRegexCategory, self).tearDown()
+
+ # ==========================================================================
+ # category filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_category_full_match(self):
+ """Test that fall-through reject, accept regex single category works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept category regex cat2\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that category.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_category_partial_match(self):
+ """Test that fall-through reject, accept regex category via partial match works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept category regex .+2\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that category.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_category_full_match(self):
+ """Test that fall-through accept, reject regex category works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject category regex cat1\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via category rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_category_partial_match(self):
+ """Test that fall-through accept, reject regex category by partial match works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject category regex t1\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via category rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_category_second_rule(self):
+ """Test that fall-through reject, accept regex category on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept category regex non-existent\"",
+ "--filter \"accept category regex cat2\""
+ ]
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the category of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+# System imports
+from __future__ import print_function
+
+import re
+
+# LLDB imports
+import lldb
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterRegexMessage(darwin_log.DarwinLogEventBasedTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_message_full_match(self):
+ """Test that fall-through reject, accept regex whole message works."""
+ log_entries = self.do_test(
+ ["--no-match-accepts false",
+ # Note below, the four '\' characters are to get us two
+ # backslashes over on the gdb-remote side, which then
+ # becomes one as the cstr interprets it as an escape
+ # sequence. This needs to be rationalized. Initially I
+ # supported std::regex ECMAScript, which has the
+ # [[:digit:]] character classes and such. That was much
+ # more tenable. The backslashes have to travel through
+ # so many layers of escaping. (And note if you take
+ # off the Python raw string marker here, you need to put
+ # in 8 backslashes to go to two on the remote side.)
+ r'--filter "accept message regex log message sub2-cat\\\\d+"'])
+
+ # We should have received at least one log entry.
+ self.assertIsNotNone(log_entries,
+ "Log entry list should not be None.")
+ self.assertEqual(len(log_entries), 1,
+ "Should receive one log entry.")
+ self.assertRegexpMatches(log_entries[0]["message"], r"sub2-cat2",
+ "First os_log call should have been skipped.")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_message_partial_match(self):
+ """Test that fall-through reject, accept regex message via partial
+ match works."""
+ log_entries = self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept message regex [^-]+2\""])
+
+ # We should only see the second log message as we only accept
+ # that message contents.
+ self.assertIsNotNone(log_entries,
+ "Log entry list should not be None.")
+ self.assertEqual(len(log_entries), 1,
+ "Should receive one log entry.")
+ self.assertRegexpMatches(log_entries[0]["message"], r"sub2-cat2",
+ "First os_log call should have been skipped.")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_message_full_match(self):
+ """Test that fall-through accept, reject regex message works."""
+ log_entries = self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject message regex log message sub1-cat1\""])
+
+ # We should only see the second log message as we rejected the first
+ # via message contents rejection.
+ self.assertIsNotNone(log_entries,
+ "Log entry list should not be None.")
+ self.assertEqual(len(log_entries), 1,
+ "Should receive one log entry.")
+ self.assertRegexpMatches(log_entries[0]["message"], r"sub2-cat2",
+ "First os_log call should have been skipped.")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_message_partial_match(self):
+ """Test that fall-through accept, reject regex message by partial
+ match works."""
+ log_entries = self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject message regex t1\""])
+
+ # We should only see the second log message as we rejected the first
+ # via partial message contents rejection.
+ self.assertIsNotNone(log_entries,
+ "Log entry list should not be None.")
+ self.assertEqual(len(log_entries), 1,
+ "Should receive one log entry.")
+ self.assertRegexpMatches(log_entries[0]["message"], r"sub2-cat2",
+ "First os_log call should have been skipped.")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_message_second_rule(self):
+ """Test that fall-through reject, accept regex message on second rule
+ works."""
+ log_entries = self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept message regex non-existent\"",
+ "--filter \"accept message regex cat2\""])
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the message of the second log message.
+ self.assertIsNotNone(log_entries,
+ "Log entry list should not be None.")
+ self.assertEqual(len(log_entries), 1,
+ "Should receive one log entry.")
+ self.assertRegexpMatches(log_entries[0]["message"], r"sub2-cat2",
+ "First os_log call should have been skipped.")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_log(logger_sub1, "log message sub%d-cat%d", 1, 1);
+ os_log(logger_sub2, "log message sub%d-cat%d", 2, 2);
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test basic DarwinLog functionality provided by the StructuredDataDarwinLog
+plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogFilterRegexSubsystem(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogFilterRegexSubsystem, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogFilterRegexSubsystem, self).tearDown()
+
+ # ==========================================================================
+ # basic filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_fallthrough_reject(self):
+ """Test that a single fall-through reject regex rule rejects all logging."""
+ self.do_test(
+ ["--no-match-accepts false"]
+ )
+
+ # We should not match any log lines.
+ self.assertIsNotNone(self.child.match)
+ self.assertFalse((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) in ["sub1", "sub2"]),
+ "log line should not have been received")
+
+ # ==========================================================================
+ # subsystem filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_subsystem_full_match(self):
+ """Test that fall-through reject, accept regex single subsystem works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept subsystem regex org.llvm.lldb.test.sub2\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that subsystem.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_subsystem_partial_match(self):
+ """Test that fall-through reject, accept regex subsystem via partial-match works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept subsystem regex org.llvm.+.sub2\""]
+ )
+
+ # We should only see the second log message as we only accept
+ # that subsystem.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_subsystem_full_match(self):
+ """Test that fall-through accept, reject regex subsystem works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject subsystem regex org.llvm.lldb.test.sub1\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via subsystem rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_reject_subsystem_partial_match(self):
+ """Test that fall-through accept, reject regex subsystem by partial match works."""
+ self.do_test(
+ ["--no-match-accepts true",
+ "--filter \"reject subsystem regex org.*sub1\""]
+ )
+
+ # We should only see the second log message as we rejected the first
+ # via subsystem rejection.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_filter_accept_subsystem_second_rule(self):
+ """Test that fall-through reject, accept regex subsystem on second rule works."""
+ self.do_test(
+ ["--no-match-accepts false",
+ "--filter \"accept subsystem regex non-existent\"",
+ "--filter \"accept subsystem regex org.llvm.lldb.test.sub2\""
+ ]
+ )
+
+ # We should only see the second message since we reject by default,
+ # the first filter doesn't match any, and the second filter matches
+ # the subsystem of the second log message.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) == "sub2"),
+ "first log line should not be present, second log line "
+ "should be")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_log(logger_sub1, "source-log-sub1-cat1");
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub2, "source-log-sub2-cat2");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test DarwinLog log message formatting options provided by the
+StructuredDataDarwinLog plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogMessageFormat(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogMessageFormat, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogMessageFormat, self).tearDown()
+
+ # ==========================================================================
+ # Test settings around log message formatting
+ # ==========================================================================
+
+ REGEXES = [
+ re.compile(r"\[([^]]+)\] This is the log message."), # Match log
+ # with header.
+ re.compile(r"This is the log message."), # Match no-header content.
+ re.compile(r"exited with status") # Fallback if no log emitted.
+ ]
+
+ @decorators.skipUnlessDarwin
+ def test_display_without_header_works(self):
+ """Test that turning off log message headers works as advertised."""
+ self.do_test([], expect_regexes=self.REGEXES)
+
+ # We should not match the first pattern as we shouldn't have header
+ # content.
+ self.assertIsNotNone(self.child.match)
+ self.assertFalse((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) != ""),
+ "we should not have seen a header")
+
+
+ @decorators.skipUnlessDarwin
+ def test_display_with_header_works(self):
+ """Test that displaying any header works."""
+ self.do_test(
+ ["--timestamp-relative", "--subsystem", "--category",
+ "--activity-chain"],
+ expect_regexes=self.REGEXES,
+ settings_commands=[
+ "display-header true"
+ ])
+
+ # We should match the first pattern as we should have header
+ # content.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) != ""),
+ "we should have printed a header")
+
+ def assert_header_contains_timestamp(self, header):
+ fields = header.split(',')
+ self.assertGreater(len(fields), 0,
+ "there should have been header content present")
+ self.assertRegexpMatches(fields[0],
+ r"^\d+:\d{2}:\d{2}.\d{9}$",
+ "time field should match expected format")
+
+ @decorators.skipUnlessDarwin
+ def test_header_timefield_only_works(self):
+ """Test that displaying a header with only the timestamp works."""
+ self.do_test(["--timestamp-relative"], expect_regexes=self.REGEXES)
+
+ # We should match the first pattern as we should have header
+ # content.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) != ""),
+ "we should have printed a header")
+ header = self.child.match.group(1)
+ self.assertEqual(len(header.split(',')), 1,
+ "there should only be one header field")
+ self.assert_header_contains_timestamp(header)
+
+ @decorators.skipUnlessDarwin
+ def test_header_subsystem_only_works(self):
+ """Test that displaying a header with only the subsystem works."""
+ self.do_test(["--subsystem"], expect_regexes=self.REGEXES)
+
+ # We should match the first pattern as we should have header
+ # content.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) != ""),
+ "we should have printed a header")
+ header = self.child.match.group(1)
+ self.assertEqual(len(header.split(',')), 1,
+ "there should only be one header field")
+ self.assertEquals(header,
+ "subsystem=org.llvm.lldb.test.sub1")
+
+ @decorators.skipUnlessDarwin
+ def test_header_category_only_works(self):
+ """Test that displaying a header with only the category works."""
+ self.do_test(["--category"], expect_regexes=self.REGEXES)
+
+ # We should match the first pattern as we should have header
+ # content.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) != ""),
+ "we should have printed a header")
+ header = self.child.match.group(1)
+ self.assertEqual(len(header.split(',')), 1,
+ "there should only be one header field")
+ self.assertEquals(header,
+ "category=cat1")
+
+ @decorators.skipUnlessDarwin
+ def test_header_activity_chain_only_works(self):
+ """Test that displaying a header with only the activity chain works."""
+ self.do_test(["--activity-chain"], expect_regexes=self.REGEXES)
+
+ # We should match the first pattern as we should have header
+ # content.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 0) and
+ (self.child.match.group(1) != ""),
+ "we should have printed a header")
+ header = self.child.match.group(1)
+ self.assertEqual(len(header.split(',')), 1,
+ "there should only be one header field")
+ self.assertEquals(header,
+ "activity-chain=parent-activity:child-activity")
+
+ # @decorators.skipUnlessDarwin
+ # def test_header_activity_no_chain_only_works(self):
+ # """Test that displaying a header with only the activity works."""
+ # self.do_test(
+ # [],
+ # expect_regexes=self.REGEXES,
+ # settings_commands=[
+ # "display-header true",
+ # "format-include-timestamp false",
+ # "format-include-activity true",
+ # "format-include-category false",
+ # "format-include-subsystem false",
+ # "display-activity-chain false"
+ # ])
+
+ # # We should match the first pattern as we should have header
+ # # content.
+ # self.assertIsNotNone(self.child.match)
+ # self.assertTrue((len(self.child.match.groups()) > 0) and
+ # (self.child.match.group(1) != ""),
+ # "we should have printed a header")
+ # header = self.child.match.group(1)
+ # self.assertEqual(len(header.split(',')), 1,
+ # "there should only be one header field")
+ # self.assertEquals(header,
+ # "activity=child-activity")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/activity.h>
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ if (!logger_sub1)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_activity_t parent_activity = os_activity_create("parent-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(parent_activity, ^{
+ os_activity_t child_activity = os_activity_create("child-activity",
+ OS_ACTIVITY_CURRENT, OS_ACTIVITY_FLAG_DEFAULT);
+ os_activity_apply(child_activity, ^{
+ os_log(logger_sub1, "This is the log message.");
+ });
+ });
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test DarwinLog "source include debug-level" functionality provided by the
+StructuredDataDarwinLog plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogSourceDebug(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogSourceDebug, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ # Indicate we want strict-sources behavior.
+ self.strict_sources = True
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogSourceDebug, self).tearDown()
+
+ # ==========================================================================
+ # source include/exclude debug filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ def test_source_default_exclude_debug(self):
+ """Test that default excluding of debug-level log messages works."""
+ self.do_test([])
+
+ # We should only see the second log message as the first is a
+ # debug-level message and we're not including debug-level messages.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_source_explicitly_include_debug(self):
+ """Test that explicitly including debug-level log messages works."""
+ self.do_test(["--debug"])
+
+ # We should only see the second log message as the first is a
+ # debug-level message and we're not including debug-level messages.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat1"),
+ "first log line should be present since we're "
+ "including debug-level log messages")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_log_debug(logger_sub1, "source-log-sub1-cat1");
+ os_log(logger_sub2, "source-log-sub2-cat2");
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
--- /dev/null
+LEVEL = ../../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules
--- /dev/null
+"""
+Test DarwinLog "source include info-level" functionality provided by the
+StructuredDataDarwinLog plugin.
+
+These tests are currently only supported when running against Darwin
+targets.
+"""
+
+from __future__ import print_function
+
+import lldb
+import os
+import re
+
+from lldbsuite.test import decorators
+from lldbsuite.test import lldbtest
+from lldbsuite.test import darwin_log
+
+
+class TestDarwinLogSourceInfo(darwin_log.DarwinLogTestBase):
+
+ mydir = lldbtest.TestBase.compute_mydir(__file__)
+
+ def setUp(self):
+ # Call super's setUp().
+ super(TestDarwinLogSourceInfo, self).setUp()
+
+ # Source filename.
+ self.source = 'main.c'
+
+ # Output filename.
+ self.exe_name = 'a.out'
+ self.d = {'C_SOURCES': self.source, 'EXE': self.exe_name}
+
+ # Locate breakpoint.
+ self.line = lldbtest.line_number(self.source, '// break here')
+
+ # Indicate we want strict-sources behavior.
+ self.strict_sources = True
+
+ def tearDown(self):
+ # Shut down the process if it's still running.
+ if self.child:
+ self.runCmd('process kill')
+ self.expect_prompt()
+ self.runCmd('quit')
+
+ # Let parent clean up
+ super(TestDarwinLogSourceInfo, self).tearDown()
+
+ # ==========================================================================
+ # source include/exclude debug filter tests
+ # ==========================================================================
+
+ @decorators.skipUnlessDarwin
+ @decorators.expectedFailureAll(bugnumber="rdar://27316264")
+ def test_source_exclude_info_level(self):
+ """Test that default excluding of info-level log messages works."""
+ self.do_test([])
+
+ # We should only see the second log message as the first is an
+ # info-level message and we're not including debug-level messages.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat2"),
+ "first log line should not be present, second log line "
+ "should be")
+
+ @decorators.skipUnlessDarwin
+ def test_source_include_info_level(self):
+ """Test that explicitly including info-level log messages works."""
+ self.do_test(
+ ["--info"]
+ )
+
+ # We should only see the second log message as the first is a
+ # debug-level message and we're not including debug-level messages.
+ self.assertIsNotNone(self.child.match)
+ self.assertTrue((len(self.child.match.groups()) > 1) and
+ (self.child.match.group(2) == "cat1"),
+ "first log line should be present since we're "
+ "including info-level log messages")
--- /dev/null
+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <os/log.h>
+#include <stdio.h>
+
+#include "../../common/darwin_log_common.h"
+
+int main(int argc, char** argv)
+{
+ os_log_t logger_sub1 = os_log_create("org.llvm.lldb.test.sub1", "cat1");
+ os_log_t logger_sub2 = os_log_create("org.llvm.lldb.test.sub2", "cat2");
+ if (!logger_sub1 || !logger_sub2)
+ return 1;
+
+ // Note we cannot use the os_log() line as the breakpoint because, as of
+ // the initial writing of this test, we get multiple breakpoints for that
+ // line, which confuses the pexpect test logic.
+ printf("About to log\n"); // break here
+ os_log_info(logger_sub1, "source-log-sub1-cat1");
+ os_log(logger_sub2, "source-log-sub2-cat2");
+
+ // Sleep, as the darwin log reporting doesn't always happen until a bit
+ // later. We need the message to come out before the process terminates.
+ sleep(FINAL_WAIT_SECONDS);
+
+ return 0;
+}
eBroadcastBitInterrupt = (1 << 1),
eBroadcastBitSTDOUT = (1 << 2),
eBroadcastBitSTDERR = (1 << 3),
- eBroadcastBitProfileData = (1 << 4)
+ eBroadcastBitProfileData = (1 << 4),
+ eBroadcastBitStructuredData = (1 << 5)
};
SBProcess ();
static bool
GetInterruptedFromEvent (const lldb::SBEvent &event);
+ static lldb::SBStructuredData
+ GetStructuredDataFromEvent (const lldb::SBEvent &event);
+
static bool
EventIsProcessEvent (const lldb::SBEvent &event);
+ static bool
+ EventIsStructuredDataEvent (const lldb::SBEvent &event);
+
lldb::SBBroadcaster
GetBroadcaster () const;
--- /dev/null
+//===-- SWIG Interface for SBStructuredData ---------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+ %feature("docstring",
+ "A class representing a StructuredData event.
+
+ This class wraps the event type generated by StructuredData
+ features."
+ ) SBStructuredData;
+ class SBStructuredData
+ {
+ public:
+
+ SBStructuredData();
+
+ SBStructuredData(const lldb::SBStructuredData &rhs);
+
+ SBStructuredData(const lldb::EventSP &event_sp);
+
+ ~SBStructuredData();
+
+ bool
+ IsValid() const;
+
+ void
+ Clear();
+
+ lldb::SBError
+ GetAsJSON(lldb::SBStream &stream) const;
+
+ lldb::SBError
+ GetDescription(lldb::SBStream &stream) const;
+ };
+}
/// Some launch options specified by logical OR'ing
/// lldb::LaunchFlags enumeration values together.
///
- /// @param[in] stop_at_endtry
+ /// @param[in] stop_at_entry
/// If false do not stop the inferior at the entry point.
///
/// @param[out]
#include "lldb/API/SBSourceManager.h"
#include "lldb/API/SBStream.h"
#include "lldb/API/SBStringList.h"
+#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBSymbol.h"
#include "lldb/API/SBSymbolContext.h"
#include "lldb/API/SBSymbolContextList.h"
%include "./interface/SBSourceManager.i"
%include "./interface/SBStream.i"
%include "./interface/SBStringList.i"
+%include "./interface/SBStructuredData.i"
%include "./interface/SBSymbol.i"
%include "./interface/SBSymbolContext.i"
%include "./interface/SBSymbolContextList.i"
SBSourceManager.cpp
SBStream.cpp
SBStringList.cpp
+ SBStructuredData.cpp
SBSymbol.cpp
SBSymbolContext.cpp
SBSymbolContextList.cpp
if (err != nullptr)
::fwrite (stdio_buffer, 1, len, err);
}
-
+
if (event_type & Process::eBroadcastBitStateChanged)
{
StateType event_state = SBProcess::GetStateFromEvent (event);
#include "lldb/API/SBFileSpec.h"
#include "lldb/API/SBMemoryRegionInfo.h"
#include "lldb/API/SBMemoryRegionInfoList.h"
+#include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBThread.h"
#include "lldb/API/SBThreadCollection.h"
#include "lldb/API/SBStream.h"
SBProcess
SBProcess::GetProcessFromEvent (const SBEvent &event)
{
- SBProcess process(Process::ProcessEventData::GetProcessFromEvent (event.get()));
- return process;
+ ProcessSP process_sp =
+ Process::ProcessEventData::GetProcessFromEvent (event.get());
+ if (!process_sp)
+ {
+ // StructuredData events also know the process they come from.
+ // Try that.
+ process_sp = EventDataStructuredData::GetProcessFromEvent(event.get());
+ }
+
+ return SBProcess(process_sp);
}
bool
return Process::ProcessEventData::GetInterruptedFromEvent(event.get());
}
+lldb::SBStructuredData
+SBProcess::GetStructuredDataFromEvent (const lldb::SBEvent &event)
+{
+ return SBStructuredData(event.GetSP());
+}
+
bool
SBProcess::EventIsProcessEvent (const SBEvent &event)
{
- return event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass();
+ return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
+ !EventIsStructuredDataEvent (event);
+}
+
+bool
+SBProcess::EventIsStructuredDataEvent (const lldb::SBEvent &event)
+{
+ EventSP event_sp = event.GetSP();
+ EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
+ return event_data &&
+ (event_data->GetFlavor() == EventDataStructuredData::GetFlavorString());
}
SBBroadcaster
--- /dev/null
+//===-- SBStructuredData.cpp ------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBStructuredData.h"
+
+#include "lldb/API/SBStream.h"
+#include "lldb/Core/Error.h"
+#include "lldb/Core/Event.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/StructuredData.h"
+#include "lldb/Target/StructuredDataPlugin.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#pragma mark --
+#pragma mark Impl
+
+class SBStructuredData::Impl
+{
+public:
+
+ Impl() :
+ m_plugin_wp(),
+ m_data_sp()
+ {
+ }
+
+ Impl(const Impl &rhs) = default;
+
+ Impl(const EventSP &event_sp) :
+ m_plugin_wp(EventDataStructuredData::GetPluginFromEvent(event_sp.get())),
+ m_data_sp(EventDataStructuredData::GetObjectFromEvent(event_sp.get()))
+ {
+ }
+
+ ~Impl() = default;
+
+ Impl&
+ operator =(const Impl &rhs) = default;
+
+ bool
+ IsValid() const
+ {
+ return m_data_sp.get() != nullptr;
+ }
+
+ void
+ Clear()
+ {
+ m_plugin_wp.reset();
+ m_data_sp.reset();
+ }
+
+ SBError
+ GetAsJSON(lldb::SBStream &stream) const
+ {
+ SBError sb_error;
+
+ if (!m_data_sp)
+ {
+ sb_error.SetErrorString("No structured data.");
+ return sb_error;
+ }
+
+ m_data_sp->Dump(stream.ref());
+ return sb_error;
+ }
+
+ lldb::SBError
+ GetDescription(lldb::SBStream &stream) const
+ {
+ SBError sb_error;
+
+ if (!m_data_sp)
+ {
+ sb_error.SetErrorString("Cannot pretty print structured data: "
+ "no data to print.");
+ return sb_error;
+ }
+
+ // Grab the plugin.
+ auto plugin_sp = StructuredDataPluginSP(m_plugin_wp);
+ if (!plugin_sp)
+ {
+ sb_error.SetErrorString("Cannot pretty print structured data: "
+ "plugin doesn't exist.");
+ return sb_error;
+ }
+
+ // Get the data's description.
+ auto error = plugin_sp->GetDescription(m_data_sp, stream.ref());
+ if (!error.Success())
+ sb_error.SetError(error);
+
+ return sb_error;
+ }
+
+private:
+
+ StructuredDataPluginWP m_plugin_wp;
+ StructuredData::ObjectSP m_data_sp;
+
+};
+
+#pragma mark --
+#pragma mark SBStructuredData
+
+
+SBStructuredData::SBStructuredData() :
+ m_impl_up(new Impl())
+{
+}
+
+SBStructuredData::SBStructuredData(const lldb::SBStructuredData &rhs) :
+ m_impl_up(new Impl(*rhs.m_impl_up.get()))
+{
+}
+
+SBStructuredData::SBStructuredData(const lldb::EventSP &event_sp) :
+ m_impl_up(new Impl(event_sp))
+{
+}
+
+SBStructuredData::~SBStructuredData()
+{
+}
+
+SBStructuredData &
+SBStructuredData::operator =(const lldb::SBStructuredData &rhs)
+{
+ *m_impl_up = *rhs.m_impl_up;
+ return *this;
+}
+
+bool
+SBStructuredData::IsValid() const
+{
+ return m_impl_up->IsValid();
+}
+
+void
+SBStructuredData::Clear()
+{
+ m_impl_up->Clear();
+}
+
+SBError
+SBStructuredData::GetAsJSON(lldb::SBStream &stream) const
+{
+ return m_impl_up->GetAsJSON(stream);
+}
+
+lldb::SBError
+SBStructuredData::GetDescription(lldb::SBStream &stream) const
+{
+ return m_impl_up->GetDescription(stream);
+}
+
#include "Plugins/Process/mach-core/ProcessMachCore.h"
#include "Plugins/SymbolVendor/MacOSX/SymbolVendorMacOSX.h"
#endif
+#include "Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h"
#if defined(__FreeBSD__)
#include "Plugins/Process/FreeBSD/ProcessFreeBSD.h"
PlatformRemoteAppleWatch::Initialize();
DynamicLoaderDarwinKernel::Initialize();
#endif
+
+ // This plugin is valid on any host that talks to a Darwin remote.
+ // It shouldn't be limited to __APPLE__.
+ StructuredDataDarwinLog::Initialize();
+
//----------------------------------------------------------------------
// Platform agnostic plugins
//----------------------------------------------------------------------
platform_gdb_server::PlatformRemoteGDBServer::Terminate();
process_gdb_remote::ProcessGDBRemote::Terminate();
+ StructuredDataDarwinLog::Terminate();
+
DynamicLoaderMacOSXDYLD::Terminate();
DynamicLoaderMacOS::Terminate();
DynamicLoaderPOSIXDYLD::Terminate();
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/Thread.h"
#include "lldb/Utility/AnsiTerminal.h"
return total_bytes;
}
-
// This function handles events that were broadcast by the process.
void
Debugger::HandleProcessEvent (const EventSP &event_sp)
{
using namespace lldb;
const uint32_t event_type = event_sp->GetType();
- ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
+ ProcessSP process_sp = (event_type == Process::eBroadcastBitStructuredData)
+ ? EventDataStructuredData::GetProcessFromEvent(event_sp.get())
+ : Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
StreamSP output_stream_sp = GetAsyncOutputStream();
StreamSP error_stream_sp = GetAsyncErrorStream();
const bool got_state_changed = (event_type & Process::eBroadcastBitStateChanged) != 0;
const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0;
const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0;
+ const bool got_structured_data = (event_type &
+ Process::eBroadcastBitStructuredData) != 0;
+
if (got_state_changed)
{
StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
GetProcessSTDERR (process_sp.get(), error_stream_sp.get());
}
+ // Give structured data events an opportunity to display.
+ if (got_structured_data)
+ {
+ StructuredDataPluginSP plugin_sp =
+ EventDataStructuredData::GetPluginFromEvent(event_sp.get());
+ if (plugin_sp)
+ {
+ auto structured_data_sp =
+ EventDataStructuredData::GetObjectFromEvent(event_sp.get());
+ if (output_stream_sp)
+ {
+ StreamString content_stream;
+ Error error = plugin_sp->GetDescription(structured_data_sp,
+ content_stream);
+ if (error.Success())
+ {
+ if (!content_stream.GetString().empty())
+ {
+ // Add newline.
+ content_stream.PutChar('\n');
+ content_stream.Flush();
+
+ // Print it.
+ output_stream_sp->PutCString(content_stream
+ .GetString().c_str());
+ }
+ }
+ else
+ {
+ error_stream_sp->Printf("Failed to print structured "
+ "data with plugin %s: %s",
+ plugin_sp->GetPluginName()
+ .AsCString(),
+ error.AsCString());
+ }
+ }
+ }
+ }
+
// Now display any stopped state changes after any STDIO
if (got_state_changed && state_is_stopped)
{
BroadcastEventSpec process_event_spec (broadcaster_class_process,
Process::eBroadcastBitStateChanged |
Process::eBroadcastBitSTDOUT |
- Process::eBroadcastBitSTDERR);
+ Process::eBroadcastBitSTDERR |
+ Process::eBroadcastBitStructuredData);
BroadcastEventSpec thread_event_spec (broadcaster_class_thread,
Thread::eBroadcastBitStackChanged |
using namespace lldb;
using namespace lldb_private;
+#pragma mark -
+#pragma mark Event
+
+//------------------------------------------------------------------
+// Event functions
+//------------------------------------------------------------------
+
Event::Event (Broadcaster *broadcaster, uint32_t event_type, EventData *data) :
m_broadcaster_wp(broadcaster->GetBroadcasterImpl()),
m_type(event_type),
m_data_sp->DoOnRemoval (this);
}
+#pragma mark -
+#pragma mark EventData
+
+//------------------------------------------------------------------
+// EventData functions
+//------------------------------------------------------------------
+
EventData::EventData() = default;
EventData::~EventData() = default;
s->PutCString ("Generic Event Data");
}
+#pragma mark -
+#pragma mark EventDataBytes
+
+//------------------------------------------------------------------
+// EventDataBytes functions
+//------------------------------------------------------------------
+
+
EventDataBytes::EventDataBytes () :
m_bytes()
{
{
m_bytes.swap (new_bytes);
}
+
+#pragma mark -
+#pragma mark EventStructuredData
+
+//------------------------------------------------------------------
+// EventDataStructuredData definitions
+//------------------------------------------------------------------
+
+EventDataStructuredData::EventDataStructuredData() :
+ EventData(),
+ m_process_sp(),
+ m_object_sp(),
+ m_plugin_sp()
+{
+}
+
+EventDataStructuredData::EventDataStructuredData(const ProcessSP &process_sp,
+ const StructuredData::ObjectSP
+ &object_sp,
+ const
+ lldb::StructuredDataPluginSP
+ &plugin_sp) :
+ EventData(),
+ m_process_sp(process_sp),
+ m_object_sp(object_sp),
+ m_plugin_sp(plugin_sp)
+{
+}
+
+EventDataStructuredData::~EventDataStructuredData()
+{
+}
+
+//------------------------------------------------------------------
+// EventDataStructuredData member functions
+//------------------------------------------------------------------
+
+const ConstString &
+EventDataStructuredData::GetFlavor() const
+{
+ return EventDataStructuredData::GetFlavorString();
+}
+
+void
+EventDataStructuredData::Dump(Stream *s) const
+{
+ if (!s)
+ return;
+
+ if (m_object_sp)
+ m_object_sp->Dump(*s);
+}
+
+const ProcessSP&
+EventDataStructuredData::GetProcess() const
+{
+ return m_process_sp;
+}
+
+const StructuredData::ObjectSP&
+EventDataStructuredData::GetObject() const
+{
+ return m_object_sp;
+}
+
+const lldb::StructuredDataPluginSP&
+EventDataStructuredData::GetStructuredDataPlugin() const
+{
+ return m_plugin_sp;
+}
+
+void
+EventDataStructuredData::SetProcess(const ProcessSP &process_sp)
+{
+ m_process_sp = process_sp;
+}
+
+void
+EventDataStructuredData::SetObject(const StructuredData::ObjectSP &object_sp)
+{
+ m_object_sp = object_sp;
+}
+
+void
+EventDataStructuredData::SetStructuredDataPlugin(const
+ lldb::StructuredDataPluginSP
+ &plugin_sp)
+{
+ m_plugin_sp = plugin_sp;
+}
+
+//------------------------------------------------------------------
+// EventDataStructuredData static functions
+//------------------------------------------------------------------
+
+const EventDataStructuredData*
+EventDataStructuredData::GetEventDataFromEvent(const Event *event_ptr)
+{
+ if (event_ptr == nullptr)
+ return nullptr;
+
+ const EventData *event_data = event_ptr->GetData();
+ if (!event_data || event_data->GetFlavor() !=
+ EventDataStructuredData::GetFlavorString())
+ return nullptr;
+
+ return static_cast<const EventDataStructuredData*>(event_data);
+}
+
+ProcessSP
+EventDataStructuredData::GetProcessFromEvent(const Event *event_ptr)
+{
+ auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
+ if (event_data)
+ return event_data->GetProcess();
+ else
+ return ProcessSP();
+}
+
+StructuredData::ObjectSP
+EventDataStructuredData::GetObjectFromEvent(const Event *event_ptr)
+{
+ auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
+ if (event_data)
+ return event_data->GetObject();
+ else
+ return StructuredData::ObjectSP();
+}
+
+lldb::StructuredDataPluginSP
+EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr)
+{
+ auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
+ if (event_data)
+ return event_data->GetStructuredDataPlugin();
+ else
+ return StructuredDataPluginSP();
+}
+
+const ConstString &
+EventDataStructuredData::GetFlavorString ()
+{
+ static ConstString s_flavor("EventDataStructuredData");
+ return s_flavor;
+}
+
+
return none_instance(interpreter);
}
+#pragma mark -
+#pragma mark StructuredDataPlugin
+
+// -----------------------------------------------------------------------------
+// StructuredDataPlugin
+// -----------------------------------------------------------------------------
+
+struct StructuredDataPluginInstance
+{
+ StructuredDataPluginInstance() :
+ name(),
+ description(),
+ create_callback(nullptr),
+ debugger_init_callback(nullptr),
+ filter_callback(nullptr)
+ {
+ }
+
+ ConstString name;
+ std::string description;
+ StructuredDataPluginCreateInstance create_callback;
+ DebuggerInitializeCallback debugger_init_callback;
+ StructuredDataFilterLaunchInfo filter_callback;
+};
+
+typedef std::vector<StructuredDataPluginInstance> StructuredDataPluginInstances;
+
+static std::recursive_mutex &
+GetStructuredDataPluginMutex()
+{
+ static std::recursive_mutex g_instances_mutex;
+ return g_instances_mutex;
+}
+
+static StructuredDataPluginInstances &
+GetStructuredDataPluginInstances ()
+{
+ static StructuredDataPluginInstances g_instances;
+ return g_instances;
+}
+
+bool
+PluginManager::RegisterPlugin(const ConstString &name,
+ const char *description,
+ StructuredDataPluginCreateInstance
+ create_callback,
+ DebuggerInitializeCallback debugger_init_callback,
+ StructuredDataFilterLaunchInfo filter_callback)
+{
+ if (create_callback)
+ {
+ StructuredDataPluginInstance instance;
+ assert((bool)name);
+ instance.name = name;
+ if (description && description[0])
+ instance.description = description;
+ instance.create_callback = create_callback;
+ instance.debugger_init_callback = debugger_init_callback;
+ instance.filter_callback = filter_callback;
+ std::lock_guard<std::recursive_mutex> guard(
+ GetStructuredDataPluginMutex());
+ GetStructuredDataPluginInstances().push_back(instance);
+ }
+ return false;
+}
+
+bool
+PluginManager::UnregisterPlugin(StructuredDataPluginCreateInstance create_callback)
+{
+ if (create_callback)
+ {
+ std::lock_guard<std::recursive_mutex> guard(
+ GetStructuredDataPluginMutex());
+ StructuredDataPluginInstances &instances =
+ GetStructuredDataPluginInstances();
+
+ StructuredDataPluginInstances::iterator pos, end = instances.end();
+ for (pos = instances.begin(); pos != end; ++ pos)
+ {
+ if (pos->create_callback == create_callback)
+ {
+ instances.erase(pos);
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+StructuredDataPluginCreateInstance
+PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx)
+{
+ std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
+ StructuredDataPluginInstances &instances =
+ GetStructuredDataPluginInstances();
+ if (idx < instances.size())
+ return instances[idx].create_callback;
+ return nullptr;
+}
+
+StructuredDataPluginCreateInstance
+PluginManager::GetStructuredDataPluginCreateCallbackForPluginName(
+ const ConstString &name)
+{
+ if (name)
+ {
+ std::lock_guard<std::recursive_mutex> guard(
+ GetStructuredDataPluginMutex());
+ StructuredDataPluginInstances &instances =
+ GetStructuredDataPluginInstances();
+
+ StructuredDataPluginInstances::iterator pos, end = instances.end();
+ for (pos = instances.begin(); pos != end; ++ pos)
+ {
+ if (name == pos->name)
+ return pos->create_callback;
+ }
+ }
+ return nullptr;
+}
+
+StructuredDataFilterLaunchInfo
+PluginManager::GetStructuredDataFilterCallbackAtIndex(uint32_t idx,
+ bool &iteration_complete)
+{
+ std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
+ StructuredDataPluginInstances &instances =
+ GetStructuredDataPluginInstances();
+ if (idx < instances.size())
+ {
+ iteration_complete = false;
+ return instances[idx].filter_callback;
+ }
+ else
+ {
+ iteration_complete = true;
+ }
+ return nullptr;
+}
+
#pragma mark SymbolFile
struct SymbolFileInstance
os.debugger_init_callback(debugger);
}
}
+
+ // Initialize the StructuredDataPlugin plugins
+ {
+ std::lock_guard<std::recursive_mutex>
+ guard(GetStructuredDataPluginMutex());
+ for (auto &plugin: GetStructuredDataPluginInstances())
+ {
+ if (plugin.debugger_init_callback)
+ plugin.debugger_init_callback(debugger);
+ }
+ }
}
// This is the preferred new way to register plugin specific settings. e.g.
const char* kProcessPluginName("process");
const char* kSymbolFilePluginName("symbol-file");
const char* kJITLoaderPluginName("jit-loader");
+const char* kStructuredDataPluginName("structured-data");
} // anonymous namespace
}
return false;
}
+
+lldb::OptionValuePropertiesSP
+PluginManager::GetSettingForStructuredDataPlugin(Debugger &debugger,
+ const ConstString &setting_name)
+{
+ return GetSettingForPlugin(debugger, setting_name, ConstString(kStructuredDataPluginName));
+}
+
+bool
+PluginManager::CreateSettingForStructuredDataPlugin(Debugger &debugger,
+ const lldb::OptionValuePropertiesSP &properties_sp,
+ const ConstString &description,
+ bool is_global_property)
+{
+ return CreateSettingForPlugin(debugger,
+ ConstString(kStructuredDataPluginName),
+ ConstString("Settings for structured data plug-ins"),
+ properties_sp,
+ description,
+ is_global_property);
+}
}
}
+void
+Args::AddOrReplaceEnvironmentVariable(const char *env_var_name,
+ const char *new_value)
+{
+ if (!env_var_name || !new_value)
+ return;
+
+ // Build the new entry.
+ StreamString stream;
+ stream << env_var_name;
+ stream << '=';
+ stream << new_value;
+ stream.Flush();
+
+ // Find the environment variable if present and replace it.
+ for (size_t i = 0; i < GetArgumentCount(); ++i)
+ {
+ // Get the env var value.
+ const char *arg_value = GetArgumentAtIndex(i);
+ if (!arg_value)
+ continue;
+
+ // Find the name of the env var: before the first =.
+ auto equal_p = strchr(arg_value, '=');
+ if (!equal_p)
+ continue;
+
+ // Check if the name matches the given env_var_name.
+ if (strncmp(env_var_name, arg_value, equal_p - arg_value) == 0)
+ {
+ ReplaceArgumentAtIndex(i, stream.GetString().c_str());
+ return;
+ }
+ }
+
+ // We didn't find it. Append it instead.
+ AppendArgument(stream.GetString().c_str());
+}
+
bool
-Args::ContainsEnvironmentVariable(const char *env_var_name) const
+Args::ContainsEnvironmentVariable(const char *env_var_name,
+ size_t *argument_index) const
{
// Validate args.
if (!env_var_name)
equal_p - argument_value) == 0)
{
// We matched.
+ if (argument_index)
+ *argument_index = i;
return true;
}
}
if (strcmp(argument_value, env_var_name) == 0)
{
// We matched.
+ if (argument_index)
+ *argument_index = i;
return true;
}
}
add_subdirectory(Platform)
add_subdirectory(Process)
add_subdirectory(ScriptInterpreter)
+add_subdirectory(StructuredData)
add_subdirectory(SymbolFile)
add_subdirectory(SystemRuntime)
add_subdirectory(SymbolVendor)
#include "llvm/ADT/StringExtras.h"
+#include "lldb/Target/Process.h"
#include "lldb/Target/UnixSignals.h"
#include "lldb/Utility/LLDBAssert.h"
case 'A':
delegate.HandleAsyncMisc(llvm::StringRef(response.GetStringRef()).substr(1));
break;
+
+ case 'J':
+ // Asynchronous JSON packet, destined for a
+ // StructuredDataPlugin.
+ {
+ // Parse the content into a StructuredData instance.
+ auto payload_index = strlen("JSON-async:");
+ StructuredData::ObjectSP json_sp =
+ StructuredData::ParseJSON(response.GetStringRef()
+ .substr(payload_index));
+ if (log)
+ {
+ if (json_sp)
+ log->Printf(
+ "GDBRemoteCommmunicationClientBase::%s() "
+ "received Async StructuredData packet: %s",
+ __FUNCTION__,
+ response.GetStringRef().
+ substr(payload_index).c_str());
+ else
+ log->Printf("GDBRemoteCommmunicationClientBase::%s"
+ "() received StructuredData packet:"
+ " parse failure", __FUNCTION__);
+ }
+
+ // Pass the data to the process to route to the
+ // appropriate plugin. The plugin controls what happens
+ // to it from there.
+ bool routed = delegate.HandleAsyncStructuredData(json_sp);
+ if (log)
+ log->Printf("GDBRemoteCommmunicationClientBase::%s()"
+ " packet %s", __FUNCTION__,
+ routed ? "handled" : "not handled");
+ break;
+ }
case 'T':
case 'S':
// Do this with the continue lock held.
HandleAsyncMisc(llvm::StringRef data) = 0;
virtual void
HandleStopReply() = 0;
+
+ //
+ /// Processes async structured data.
+ ///
+ /// @return
+ /// true if the data was handled; otherwise, false.
+ //
+ virtual bool
+ HandleAsyncStructuredData(const StructuredData::ObjectSP
+ &object_sp) = 0;
};
GDBRemoteClientBase(const char *comm_name, const char *listener_name);
#include "lldb/Interpreter/Args.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/UnixSignals.h"
+#include "lldb/Utility/LLDBAssert.h"
#include "lldb/Target/Target.h"
// Project includes
m_gdb_server_name(),
m_gdb_server_version(UINT32_MAX),
m_default_packet_timeout(0),
- m_max_packet_size(0)
+ m_max_packet_size(0),
+ m_qSupported_response(),
+ m_supported_async_json_packets_is_valid(false),
+ m_supported_async_json_packets_sp()
{
}
m_gdb_server_version = UINT32_MAX;
m_default_packet_timeout = 0;
m_max_packet_size = 0;
+ m_qSupported_response.clear();
+ m_supported_async_json_packets_is_valid = false;
+ m_supported_async_json_packets_sp.reset();
}
// These flags should be reset when we first connect to a GDB server
/*send_async=*/false) == PacketResult::Success)
{
const char *response_cstr = response.GetStringRef().c_str();
+
+ // Hang on to the qSupported packet, so that platforms can do custom
+ // configuration of the transport before attaching/launching the
+ // process.
+ m_qSupported_response = response_cstr;
+
if (::strstr (response_cstr, "qXfer:auxv:read+"))
m_supports_qXfer_auxv_read = eLazyBoolYes;
if (::strstr (response_cstr, "qXfer:libraries-svr4:read+"))
}
}
+StructuredData::Array*
+GDBRemoteCommunicationClient::GetSupportedStructuredDataPlugins()
+{
+ if (!m_supported_async_json_packets_is_valid)
+ {
+ // Query the server for the array of supported asynchronous JSON
+ // packets.
+ m_supported_async_json_packets_is_valid = true;
+
+ Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(
+ GDBR_LOG_PROCESS));
+
+ // Poll it now.
+ StringExtractorGDBRemote response;
+ const bool send_async = false;
+ if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response,
+ send_async) == PacketResult::Success)
+ {
+ m_supported_async_json_packets_sp = StructuredData::ParseJSON(
+ response.GetStringRef());
+ if (m_supported_async_json_packets_sp &&
+ !m_supported_async_json_packets_sp->GetAsArray())
+ {
+ // We were returned something other than a JSON array. This
+ // is invalid. Clear it out.
+ if (log)
+ log->Printf("GDBRemoteCommunicationClient::%s(): "
+ "QSupportedAsyncJSONPackets returned invalid "
+ "result: %s", __FUNCTION__,
+ response.GetStringRef().c_str());
+ m_supported_async_json_packets_sp.reset();
+ }
+ }
+ else
+ {
+ if (log)
+ log->Printf("GDBRemoteCommunicationClient::%s(): "
+ "QSupportedAsyncJSONPackets unsupported",
+ __FUNCTION__);
+ }
+
+ if (log && m_supported_async_json_packets_is_valid)
+ {
+ StreamString stream;
+ m_supported_async_json_packets_sp->Dump(stream);
+ log->Printf("GDBRemoteCommunicationClient::%s(): supported async "
+ "JSON packets: %s", __FUNCTION__,
+ stream.GetString().c_str());
+ }
+ }
+
+ return m_supported_async_json_packets_sp
+ ? m_supported_async_json_packets_sp->GetAsArray()
+ : nullptr;
+}
+
+Error
+GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
+ const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp)
+{
+ Error error;
+
+ if (type_name.GetLength() == 0)
+ {
+ error.SetErrorString("invalid type_name argument");
+ return error;
+ }
+
+ // Build command: Configure{type_name}: serialized config
+ // data.
+ StreamGDBRemote stream;
+ stream.PutCString("QConfigure");
+ stream.PutCString(type_name.AsCString());
+ stream.PutChar(':');
+ if (config_sp)
+ {
+ // Gather the plain-text version of the configuration data.
+ StreamString unescaped_stream;
+ config_sp->Dump(unescaped_stream);
+ unescaped_stream.Flush();
+
+ // Add it to the stream in escaped fashion.
+ stream.PutEscapedBytes(unescaped_stream.GetData(),
+ unescaped_stream.GetSize());
+ }
+ stream.Flush();
+
+ // Send the packet.
+ const bool send_async = false;
+ StringExtractorGDBRemote response;
+ auto result = SendPacketAndWaitForResponse(stream.GetString().c_str(),
+ response, send_async);
+ if (result == PacketResult::Success)
+ {
+ // We failed if the config result comes back other than OK.
+ if (strcmp(response.GetStringRef().c_str(), "OK") == 0)
+ {
+ // Okay!
+ error.Clear();
+ }
+ else
+ {
+ error.SetErrorStringWithFormat("configuring StructuredData feature "
+ "%s failed with error %s",
+ type_name.AsCString(),
+ response.GetStringRef().c_str());
+ }
+ }
+ else
+ {
+ // Can we get more data here on the failure?
+ error.SetErrorStringWithFormat("configuring StructuredData feature %s "
+ "failed when sending packet: "
+ "PacketResult=%d", type_name.AsCString(),
+ result);
+ }
+ return error;
+}
+
void
GDBRemoteCommunicationClient::OnRunPacketSent(bool first)
{
void
ServeSymbolLookups(lldb_private::Process *process);
+ //------------------------------------------------------------------
+ /// Return the feature set supported by the gdb-remote server.
+ ///
+ /// This method returns the remote side's response to the qSupported
+ /// packet. The response is the complete string payload returned
+ /// to the client.
+ ///
+ /// @return
+ /// The string returned by the server to the qSupported query.
+ //------------------------------------------------------------------
+ const std::string&
+ GetServerSupportedFeatures() const
+ {
+ return m_qSupported_response;
+ }
+
+ //------------------------------------------------------------------
+ /// Return the array of async JSON packet types supported by the remote.
+ ///
+ /// This method returns the remote side's array of supported JSON
+ /// packet types as a list of type names. Each of the results are
+ /// expected to have an Enable{type_name} command to enable and configure
+ /// the related feature. Each type_name for an enabled feature will
+ /// possibly send async-style packets that contain a payload of a
+ /// binhex-encoded JSON dictionary. The dictionary will have a
+ /// string field named 'type', that contains the type_name of the
+ /// supported packet type.
+ ///
+ /// There is a Plugin category called structured-data plugins.
+ /// A plugin indicates whether it knows how to handle a type_name.
+ /// If so, it can be used to process the async JSON packet.
+ ///
+ /// @return
+ /// The string returned by the server to the qSupported query.
+ //------------------------------------------------------------------
+ lldb_private::StructuredData::Array*
+ GetSupportedStructuredDataPlugins();
+
+ //------------------------------------------------------------------
+ /// Configure a StructuredData feature on the remote end.
+ ///
+ /// @see \b Process::ConfigureStructuredData(...) for details.
+ //------------------------------------------------------------------
+ Error
+ ConfigureRemoteStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp);
+
protected:
LazyBool m_supports_not_sending_acks;
LazyBool m_supports_thread_suffix;
uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if qGDBServerVersion is not supported
uint32_t m_default_packet_timeout;
uint64_t m_max_packet_size; // as returned by qSupported
+ std::string m_qSupported_response; // the complete response to qSupported
+
+ bool m_supported_async_json_packets_is_valid;
+ lldb_private::StructuredData::ObjectSP m_supported_async_json_packets_sp;
bool
GetCurrentProcessInfo (bool allow_lazy_pid = true);
{
Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
if (log)
- log->Printf ("ProcessGDBRemote::DidLaunch()");
+ log->Printf ("ProcessGDBRemote::%s()", __FUNCTION__);
if (GetID() != LLDB_INVALID_PROCESS_ID)
{
BuildDynamicRegisterInfo (false);
GetTarget().SetArchitecture (process_arch);
}
}
+
+ // Find out which StructuredDataPlugins are supported by the
+ // debug monitor. These plugins transmit data over async $J packets.
+ auto supported_packets_array =
+ m_gdb_comm.GetSupportedStructuredDataPlugins();
+ if (supported_packets_array)
+ MapSupportedStructuredDataPlugins(*supported_packets_array);
}
}
return object_sp;
}
+Error
+ProcessGDBRemote::ConfigureStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP
+ &config_sp)
+{
+ return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
+}
// Establish the largest memory read/write payloads we should use.
// If the remote stub has a max packet size, stay under that size.
BuildDynamicRegisterInfo(true);
}
+bool
+ProcessGDBRemote::HandleAsyncStructuredData(const StructuredData::ObjectSP
+ &object_sp)
+{
+ return RouteAsyncStructuredData(object_sp);
+}
+
class CommandObjectProcessGDBRemoteSpeedTest: public CommandObjectParsed
{
public:
StructuredData::ObjectSP
GetLoadedDynamicLibrariesInfos (lldb::addr_t image_list_address, lldb::addr_t image_count) override;
+ Error
+ ConfigureStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp) override;
+
StructuredData::ObjectSP
GetLoadedDynamicLibrariesInfos () override;
HandleAsyncMisc(llvm::StringRef data) override;
void
HandleStopReply() override;
+ bool
+ HandleAsyncStructuredData(const StructuredData::ObjectSP
+ &object_sp) override;
DISALLOW_COPY_AND_ASSIGN (ProcessGDBRemote);
};
--- /dev/null
+add_subdirectory(DarwinLog)
+
--- /dev/null
+list(APPEND SOURCES
+ StructuredDataDarwinLog.cpp
+ )
+
+add_lldb_library(lldbPluginStructuredDataDarwinLog ${SOURCES})
--- /dev/null
+//===-- StructuredDataDarwinLog.cpp -----------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "StructuredDataDarwinLog.h"
+
+// C includes
+#include <string.h>
+
+// C++ includes
+#include <sstream>
+
+#include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/RegularExpression.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/OptionValueProperties.h"
+#include "lldb/Interpreter/OptionValueString.h"
+#include "lldb/Interpreter/Property.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/ThreadPlanCallOnFunctionExit.h"
+
+#define DARWIN_LOG_TYPE_VALUE "DarwinLog"
+
+using namespace lldb;
+using namespace lldb_private;
+
+#pragma mark -
+#pragma mark Anonymous Namespace
+
+// -----------------------------------------------------------------------------
+// Anonymous namespace
+// -----------------------------------------------------------------------------
+
+namespace sddarwinlog_private
+{
+ const uint64_t NANOS_PER_MICRO = 1000;
+ const uint64_t NANOS_PER_MILLI = NANOS_PER_MICRO * 1000;
+ const uint64_t NANOS_PER_SECOND = NANOS_PER_MILLI * 1000;
+ const uint64_t NANOS_PER_MINUTE = NANOS_PER_SECOND * 60;
+ const uint64_t NANOS_PER_HOUR = NANOS_PER_MINUTE * 60;
+
+ static bool DEFAULT_FILTER_FALLTHROUGH_ACCEPTS = true;
+
+ //------------------------------------------------------------------
+ /// Global, sticky enable switch. If true, the user has explicitly
+ /// run the enable command. When a process launches or is attached to,
+ /// we will enable DarwinLog if either the settings for auto-enable is
+ /// on, or if the user had explicitly run enable at some point prior
+ /// to the launch/attach.
+ //------------------------------------------------------------------
+ static bool s_is_explicitly_enabled;
+
+ class EnableOptions;
+ using EnableOptionsSP = std::shared_ptr<EnableOptions>;
+
+ using OptionsMap = std::map<DebuggerWP, EnableOptionsSP,
+ std::owner_less<DebuggerWP>>;
+
+ static OptionsMap&
+ GetGlobalOptionsMap()
+ {
+ static OptionsMap s_options_map;
+ return s_options_map;
+ }
+
+ static std::mutex&
+ GetGlobalOptionsMapLock()
+ {
+ static std::mutex s_options_map_lock;
+ return s_options_map_lock;
+ }
+
+ EnableOptionsSP
+ GetGlobalEnableOptions(const DebuggerSP &debugger_sp)
+ {
+ if (!debugger_sp)
+ return EnableOptionsSP();
+
+ std::lock_guard<std::mutex> locker(GetGlobalOptionsMapLock());
+ OptionsMap &options_map = GetGlobalOptionsMap();
+ DebuggerWP debugger_wp(debugger_sp);
+ auto find_it = options_map.find(debugger_wp);
+ if (find_it != options_map.end())
+ return find_it->second;
+ else
+ return EnableOptionsSP();
+ }
+
+ void
+ SetGlobalEnableOptions(const DebuggerSP &debugger_sp,
+ const EnableOptionsSP &options_sp)
+ {
+ std::lock_guard<std::mutex> locker(GetGlobalOptionsMapLock());
+ OptionsMap &options_map = GetGlobalOptionsMap();
+ DebuggerWP debugger_wp(debugger_sp);
+ auto find_it = options_map.find(debugger_wp);
+ if (find_it != options_map.end())
+ find_it->second = options_sp;
+ else
+ options_map.insert(std::make_pair(debugger_wp, options_sp));
+ }
+
+#pragma mark -
+#pragma mark Settings Handling
+
+ //------------------------------------------------------------------
+ /// Code to handle the StructuredDataDarwinLog settings
+ //------------------------------------------------------------------
+
+ static PropertyDefinition
+ g_properties[] =
+ {
+ {
+ "enable-on-startup" , // name
+ OptionValue::eTypeBoolean, // type
+ true, // global
+ false, // default uint value
+ nullptr, // default cstring value
+ nullptr, // enum values
+ "Enable Darwin os_log collection when debugged process is launched "
+ "or attached." // description
+ },
+ {
+ "auto-enable-options" , // name
+ OptionValue::eTypeString, // type
+ true, // global
+ 0, // default uint value
+ "", // default cstring value
+ nullptr, // enum values
+ "Specify the options to 'plugin structured-data darwin-log enable' "
+ "that should be applied when automatically enabling logging on "
+ "startup/attach." // description
+ },
+ // Last entry sentinel.
+ {
+ nullptr,
+ OptionValue::eTypeInvalid,
+ false,
+ 0 ,
+ nullptr,
+ nullptr,
+ nullptr
+ }
+ };
+
+ enum {
+ ePropertyEnableOnStartup = 0,
+ ePropertyAutoEnableOptions = 1
+ };
+
+ class StructuredDataDarwinLogProperties : public Properties
+ {
+ public:
+
+ static ConstString &
+ GetSettingName ()
+ {
+ static ConstString g_setting_name("darwin-log");
+ return g_setting_name;
+ }
+
+ StructuredDataDarwinLogProperties() :
+ Properties ()
+ {
+ m_collection_sp.reset(new OptionValueProperties(GetSettingName()));
+ m_collection_sp->Initialize(g_properties);
+ }
+
+ virtual
+ ~StructuredDataDarwinLogProperties()
+ {
+ }
+
+ bool
+ GetEnableOnStartup() const
+ {
+ const uint32_t idx = ePropertyEnableOnStartup;
+ return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx,
+ g_properties[idx].default_uint_value != 0);
+ }
+
+ const char*
+ GetAutoEnableOptions() const
+ {
+ const uint32_t idx = ePropertyAutoEnableOptions;
+ return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx,
+ g_properties[idx].default_cstr_value);
+ }
+
+ const char*
+ GetLoggingModuleName() const
+ {
+ return "libsystem_trace.dylib";
+ }
+ };
+
+ using StructuredDataDarwinLogPropertiesSP =
+ std::shared_ptr<StructuredDataDarwinLogProperties>;
+
+ static const StructuredDataDarwinLogPropertiesSP&
+ GetGlobalProperties()
+ {
+ static StructuredDataDarwinLogPropertiesSP g_settings_sp;
+ if (!g_settings_sp)
+ g_settings_sp.reset(new StructuredDataDarwinLogProperties());
+ return g_settings_sp;
+ }
+
+ const char *const s_filter_attributes[] =
+ {
+ "activity", // current activity
+ "activity-chain", // entire activity chain, each level separated by ':'
+ "category", // category of the log message
+ "message", // message contents, fully expanded
+ "subsystem" // subsystem of the log message
+
+ // Consider impelmenting this action as it would be cheaper to filter.
+ // "message" requires always formatting the message, which is a waste
+ // of cycles if it ends up being rejected.
+ // "format", // format string used to format message text
+ };
+
+ static const ConstString&
+ GetDarwinLogTypeName()
+ {
+ static const ConstString s_key_name("DarwinLog");
+ return s_key_name;
+ }
+
+ static const ConstString&
+ GetLogEventType()
+ {
+ static const ConstString s_event_type("log");
+ return s_event_type;
+ }
+
+ class FilterRule;
+ using FilterRuleSP = std::shared_ptr<FilterRule>;
+
+ class FilterRule
+ {
+ public:
+
+ virtual
+ ~FilterRule()
+ {
+ }
+
+ using OperationCreationFunc =
+ std::function<FilterRuleSP(bool accept,
+ size_t attribute_index,
+ const std::string &op_arg,
+ Error &error)>;
+
+ static void
+ RegisterOperation(const ConstString &operation,
+ const OperationCreationFunc &creation_func)
+ {
+ GetCreationFuncMap().insert(std::make_pair(operation,
+ creation_func));
+ }
+
+ static
+ FilterRuleSP CreateRule(bool match_accepts, size_t attribute,
+ const ConstString &operation,
+ const std::string &op_arg, Error &error)
+ {
+ // Find the creation func for this type of filter rule.
+ auto map = GetCreationFuncMap();
+ auto find_it = map.find(operation);
+ if (find_it == map.end())
+ {
+ error.SetErrorStringWithFormat("unknown filter operation \""
+ "%s\"",
+ operation.GetCString());
+ return FilterRuleSP();
+ }
+
+ return find_it->second(match_accepts, attribute, op_arg, error);
+ }
+
+ StructuredData::ObjectSP Serialize() const
+ {
+ StructuredData::Dictionary *dict_p =
+ new StructuredData::Dictionary();
+
+ // Indicate whether this is an accept or reject rule.
+ dict_p->AddBooleanItem("accept", m_accept);
+
+ // Indicate which attribute of the message this filter references.
+ // This can drop into the rule-specific DoSerialization if we get
+ // to the point where not all FilterRule derived classes work on
+ // an attribute. (e.g. logical and/or and other compound
+ // operations).
+ dict_p->AddStringItem("attribute",
+ s_filter_attributes[m_attribute_index]);
+
+ // Indicate the type of the rule.
+ dict_p->AddStringItem("type", GetOperationType().GetCString());
+
+ // Let the rule add its own specific details here.
+ DoSerialization(*dict_p);
+
+ return StructuredData::ObjectSP(dict_p);
+ }
+
+ virtual void
+ Dump(Stream &stream) const = 0;
+
+ const ConstString&
+ GetOperationType() const
+ {
+ return m_operation;
+ }
+
+ protected:
+
+ FilterRule(bool accept, size_t attribute_index,
+ const ConstString &operation) :
+ m_accept(accept),
+ m_attribute_index(attribute_index),
+ m_operation(operation)
+ {
+ }
+
+ virtual void
+ DoSerialization(StructuredData::Dictionary &dict) const = 0;
+
+ bool
+ GetMatchAccepts() const
+ {
+ return m_accept;
+ }
+
+ const char*
+ GetFilterAttribute() const
+ {
+ return s_filter_attributes[m_attribute_index];
+ }
+
+ private:
+
+ using CreationFuncMap = std::map<ConstString, OperationCreationFunc>;
+
+ static CreationFuncMap&
+ GetCreationFuncMap()
+ {
+ static CreationFuncMap s_map;
+ return s_map;
+ }
+
+ const bool m_accept;
+ const size_t m_attribute_index;
+ const ConstString m_operation;
+
+ };
+
+ using FilterRules = std::vector<FilterRuleSP>;
+
+ class RegexFilterRule : public FilterRule
+ {
+ public:
+
+ static void
+ RegisterOperation()
+ {
+ FilterRule::RegisterOperation(StaticGetOperation(),
+ CreateOperation);
+ }
+
+ void
+ Dump(Stream &stream) const override
+ {
+ stream.Printf("%s %s regex %s",
+ GetMatchAccepts() ? "accept" : "reject",
+ GetFilterAttribute(), m_regex_text.c_str());
+ }
+
+ protected:
+
+ void
+ DoSerialization(StructuredData::Dictionary &dict) const override
+ {
+ dict.AddStringItem("regex", m_regex_text);
+ }
+
+ private:
+
+ static FilterRuleSP
+ CreateOperation(bool accept, size_t attribute_index,
+ const std::string &op_arg, Error &error)
+ {
+ // We treat the op_arg as a regex. Validate it.
+ if (op_arg.empty())
+ {
+ error.SetErrorString("regex filter type requires a regex "
+ "argument");
+ return FilterRuleSP();
+ }
+
+ // Instantiate the regex so we can report any errors.
+ auto regex = RegularExpression(op_arg.c_str());
+ if (!regex.IsValid())
+ {
+ char error_text[256];
+ error_text[0] = '\0';
+ regex.GetErrorAsCString(error_text, sizeof(error_text));
+ error.SetErrorString(error_text);
+ return FilterRuleSP();
+ }
+
+ // We passed all our checks, this appears fine.
+ error.Clear();
+ return FilterRuleSP(new RegexFilterRule(accept, attribute_index,
+ op_arg));
+ }
+
+ static const ConstString &
+ StaticGetOperation()
+ {
+ static ConstString s_operation("regex");
+ return s_operation;
+ }
+
+ RegexFilterRule(bool accept, size_t attribute_index,
+ const std::string ®ex_text) :
+ FilterRule(accept, attribute_index, StaticGetOperation()),
+ m_regex_text(regex_text)
+ {
+ }
+
+ const std::string m_regex_text;
+ };
+
+ class ExactMatchFilterRule : public FilterRule
+ {
+ public:
+
+ static void
+ RegisterOperation()
+ {
+ FilterRule::RegisterOperation(StaticGetOperation(),
+ CreateOperation);
+ }
+
+ void
+ Dump(Stream &stream) const override
+ {
+ stream.Printf("%s %s match %s",
+ GetMatchAccepts() ? "accept" : "reject",
+ GetFilterAttribute(), m_match_text.c_str());
+ }
+
+ protected:
+
+ void
+ DoSerialization(StructuredData::Dictionary &dict) const override
+ {
+ dict.AddStringItem("exact_text", m_match_text);
+ }
+
+ private:
+
+ static FilterRuleSP
+ CreateOperation(bool accept, size_t attribute_index,
+ const std::string &op_arg, Error &error)
+ {
+ if (op_arg.empty())
+ {
+ error.SetErrorString("exact match filter type requires an "
+ "argument containing the text that must "
+ "match the specified message attribute.");
+ return FilterRuleSP();
+ }
+
+ error.Clear();
+ return FilterRuleSP(new ExactMatchFilterRule(accept,
+ attribute_index,
+ op_arg));
+ }
+
+ static const ConstString &
+ StaticGetOperation()
+ {
+ static ConstString s_operation("match");
+ return s_operation;
+ }
+
+ ExactMatchFilterRule(bool accept, size_t attribute_index,
+ const std::string &match_text) :
+ FilterRule(accept, attribute_index, StaticGetOperation()),
+ m_match_text(match_text)
+ {
+ }
+
+ const std::string m_match_text;
+ };
+
+ static void
+ RegisterFilterOperations()
+ {
+ ExactMatchFilterRule::RegisterOperation();
+ RegexFilterRule::RegisterOperation();
+ }
+
+ // =========================================================================
+ // Commands
+ // =========================================================================
+
+ // -------------------------------------------------------------------------
+ /// Provides the main on-off switch for enabling darwin logging.
+ ///
+ /// It is valid to run the enable command when logging is already enabled.
+ /// This resets the logging with whatever settings are currently set.
+ // -------------------------------------------------------------------------
+ class EnableOptions : public Options
+ {
+ public:
+
+ EnableOptions() :
+ Options(),
+ m_include_debug_level(false),
+ m_include_info_level(false),
+ m_include_any_process(false),
+ m_filter_fall_through_accepts(DEFAULT_FILTER_FALLTHROUGH_ACCEPTS),
+ m_echo_to_stderr(false),
+ m_display_timestamp_relative(false),
+ m_display_subsystem(false),
+ m_display_category(false),
+ m_display_activity_chain(false),
+ m_broadcast_events(true),
+ m_live_stream(true),
+ m_filter_rules()
+ {
+ }
+
+ void
+ OptionParsingStarting (ExecutionContext *execution_context) override
+ {
+ m_include_debug_level = false;
+ m_include_info_level = false;
+ m_include_any_process = false;
+ m_filter_fall_through_accepts = DEFAULT_FILTER_FALLTHROUGH_ACCEPTS;
+ m_echo_to_stderr = false;
+ m_display_timestamp_relative = false;
+ m_display_subsystem = false;
+ m_display_category = false;
+ m_display_activity_chain = false;
+ m_broadcast_events = true;
+ m_live_stream = true;
+ m_filter_rules.clear();
+ }
+
+ Error
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
+ {
+ Error error;
+
+ const int short_option = m_getopt_table[option_idx].val;
+ switch (short_option)
+ {
+ case 'a':
+ m_include_any_process = true;
+ break;
+
+ case 'A':
+ m_display_timestamp_relative = true;
+ m_display_category = true;
+ m_display_subsystem = true;
+ m_display_activity_chain = true;
+ break;
+
+ case 'b':
+ m_broadcast_events =
+ Args::StringToBoolean(option_arg, true, nullptr);
+ break;
+
+ case 'c':
+ m_display_category = true;
+ break;
+
+ case 'C':
+ m_display_activity_chain = true;
+ break;
+
+ case 'd':
+ m_include_debug_level = true;
+ break;
+
+ case 'e':
+ m_echo_to_stderr =
+ Args::StringToBoolean(option_arg, false, nullptr);
+ break;
+
+ case 'f':
+ return ParseFilterRule(option_arg);
+
+ case 'i':
+ m_include_info_level = true;
+ break;
+
+ case 'l':
+ m_live_stream =
+ Args::StringToBoolean(option_arg, false, nullptr);
+ break;
+
+ case 'n':
+ m_filter_fall_through_accepts =
+ Args::StringToBoolean(option_arg, true, nullptr);
+ break;
+
+ case 'r':
+ m_display_timestamp_relative = true;
+ break;
+
+ case 's':
+ m_display_subsystem = true;
+ break;
+
+ default:
+ error.SetErrorStringWithFormat("unsupported option '%c'",
+ short_option);
+ }
+ return error;
+ }
+
+ const OptionDefinition*
+ GetDefinitions () override
+ {
+ return g_enable_option_table;
+ }
+
+ StructuredData::DictionarySP
+ BuildConfigurationData(bool enabled)
+ {
+ StructuredData::DictionarySP config_sp(new StructuredData::
+ Dictionary());
+
+ // Set the basic enabled state.
+ config_sp->AddBooleanItem("enabled", enabled);
+
+ // If we're disabled, there's nothing more to add.
+ if (!enabled)
+ return config_sp;
+
+ // Handle source stream flags.
+ auto source_flags_sp =
+ StructuredData::DictionarySP(new StructuredData::Dictionary());
+ config_sp->AddItem("source-flags", source_flags_sp);
+
+ source_flags_sp->AddBooleanItem("any-process",
+ m_include_any_process);
+ source_flags_sp->AddBooleanItem("debug-level",
+ m_include_debug_level);
+ // The debug-level flag, if set, im\13plies info-level.
+ source_flags_sp->AddBooleanItem("info-level",
+ m_include_info_level ||
+ m_include_debug_level);
+ source_flags_sp->AddBooleanItem("live-stream",
+ m_live_stream);
+
+ // Specify default filter rule (the fall-through)
+ config_sp->AddBooleanItem("filter-fall-through-accepts",
+ m_filter_fall_through_accepts);
+
+
+ // Handle filter rules
+ if (!m_filter_rules.empty())
+ {
+ auto json_filter_rules_sp =
+ StructuredData::ArraySP(new StructuredData::Array);
+ config_sp->AddItem("filter-rules",
+ json_filter_rules_sp);
+ for (auto &rule_sp : m_filter_rules)
+ {
+ if (!rule_sp)
+ continue;
+ json_filter_rules_sp->AddItem(rule_sp->Serialize());
+ }
+ }
+ return config_sp;
+ }
+
+ bool
+ GetIncludeDebugLevel() const
+ {
+ return m_include_debug_level;
+ }
+
+ bool
+ GetIncludeInfoLevel() const
+ {
+ // Specifying debug level implies info level.
+ return m_include_info_level || m_include_debug_level;
+ }
+
+ const FilterRules&
+ GetFilterRules() const
+ {
+ return m_filter_rules;
+ }
+
+ bool
+ GetFallthroughAccepts() const
+ {
+ return m_filter_fall_through_accepts;
+ }
+
+ bool
+ GetEchoToStdErr() const
+ {
+ return m_echo_to_stderr;
+ }
+
+ bool
+ GetDisplayTimestampRelative() const
+ {
+ return m_display_timestamp_relative;
+ }
+
+ bool
+ GetDisplaySubsystem() const
+ {
+ return m_display_subsystem;
+ }
+ bool
+ GetDisplayCategory() const
+ {
+ return m_display_category;
+ }
+ bool
+ GetDisplayActivityChain() const
+ {
+ return m_display_activity_chain;
+ }
+
+ bool
+ GetDisplayAnyHeaderFields() const
+ {
+ return
+ m_display_timestamp_relative ||
+ m_display_activity_chain ||
+ m_display_subsystem ||
+ m_display_category;
+ }
+
+ bool
+ GetBroadcastEvents() const
+ {
+ return m_broadcast_events;
+ }
+
+ private:
+
+ Error
+ ParseFilterRule(const char *rule_text_cstr)
+ {
+ Error error;
+
+ if (!rule_text_cstr || !rule_text_cstr[0])
+ {
+ error.SetErrorString("invalid rule_text");
+ return error;
+ }
+
+ // filter spec format:
+ //
+ // {action} {attribute} {op}
+ //
+ // {action} :=
+ // accept |
+ // reject
+ //
+ // {attribute} :=
+ // category |
+ // subsystem |
+ // activity |
+ // activity-chain |
+ // message |
+ // format
+ //
+ // {op} :=
+ // match {exact-match-text} |
+ // regex {search-regex}
+
+ const std::string rule_text(rule_text_cstr);
+
+ // Parse action.
+ auto action_end_pos = rule_text.find(" ");
+ if (action_end_pos == std::string::npos)
+ {
+ error.SetErrorStringWithFormat("could not parse filter rule "
+ "action from \"%s\"",
+ rule_text_cstr);
+ return error;
+ }
+ auto action = rule_text.substr(0, action_end_pos);
+ bool accept;
+ if (action == "accept")
+ accept = true;
+ else if (action == "reject")
+ accept = false;
+ else
+ {
+ error.SetErrorString("filter action must be \"accept\" or "
+ "\"deny\"");
+ return error;
+ }
+
+ // parse attribute
+ auto attribute_end_pos = rule_text.find(" ", action_end_pos + 1);
+ if (attribute_end_pos == std::string::npos)
+ {
+ error.SetErrorStringWithFormat("could not parse filter rule "
+ "attribute from \"%s\"",
+ rule_text_cstr);
+ return error;
+ }
+ auto attribute =
+ rule_text.substr(action_end_pos + 1,
+ attribute_end_pos - (action_end_pos + 1));
+ auto attribute_index = MatchAttributeIndex(attribute);
+ if (attribute_index < 0)
+ {
+ error.SetErrorStringWithFormat("filter rule attribute unknown: "
+ "%s", attribute.c_str());
+ return error;
+ }
+
+ // parse operation
+ auto operation_end_pos = rule_text.find(" ", attribute_end_pos + 1);
+ auto operation =
+ rule_text.substr(attribute_end_pos + 1,
+ operation_end_pos - (attribute_end_pos + 1));
+
+ // add filter spec
+ auto rule_sp =
+ FilterRule::CreateRule(accept, attribute_index,
+ ConstString(operation),
+ rule_text.substr(operation_end_pos + 1),
+ error);
+
+ if (rule_sp && error.Success())
+ m_filter_rules.push_back(rule_sp);
+
+ return error;
+ }
+
+ int
+ MatchAttributeIndex(const std::string &attribute_name)
+ {
+ auto attribute_count =
+ sizeof(s_filter_attributes) / sizeof(s_filter_attributes[0]);
+ for (size_t i = 0; i < attribute_count; ++i)
+ {
+ if (attribute_name == s_filter_attributes[i])
+ return static_cast<int>(i);
+ }
+
+ // We didn't match anything.
+ return -1;
+ }
+
+ static OptionDefinition g_enable_option_table[];
+
+ bool m_include_debug_level;
+ bool m_include_info_level;
+ bool m_include_any_process;
+ bool m_filter_fall_through_accepts;
+ bool m_echo_to_stderr;
+ bool m_display_timestamp_relative;
+ bool m_display_subsystem;
+ bool m_display_category;
+ bool m_display_activity_chain;
+ bool m_broadcast_events;
+ bool m_live_stream;
+ FilterRules m_filter_rules;
+ };
+
+ OptionDefinition
+ EnableOptions::g_enable_option_table[] =
+ {
+ // Source stream include/exclude options (the first-level filter).
+ // This one should be made as small as possible as everything that
+ // goes through here must be processed by the process monitor.
+ { LLDB_OPT_SET_ALL, false, "any-process", 'a',
+ OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+ "Specifies log messages from other related processes should be "
+ "included." },
+ { LLDB_OPT_SET_ALL, false, "debug", 'd', OptionParser::eNoArgument,
+ nullptr, nullptr, 0, eArgTypeNone,
+ "Specifies debug-level log messages should be included. Specifying"
+ " --debug implies --info."},
+ { LLDB_OPT_SET_ALL, false, "info", 'i', OptionParser::eNoArgument,
+ nullptr, nullptr, 0, eArgTypeNone,
+ "Specifies info-level log messages should be included." },
+ { LLDB_OPT_SET_ALL, false, "filter", 'f',
+ OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgRawInput,
+ // There doesn't appear to be a great way for me to have these
+ // multi-line, formatted tables in help. This looks mostly right
+ // but there are extra linefeeds added at seemingly random spots,
+ // and indentation isn't handled properly on those lines.
+ "Appends a filter rule to the log message filter chain. Multiple "
+ "rules may be added by specifying this option multiple times, "
+ "once per filter rule. Filter rules are processed in the order "
+ "they are specified, with the --no-match-accepts setting used "
+ "for any message that doesn't match one of the rules.\n"
+ "\n"
+ " Filter spec format:\n"
+ "\n"
+ " --filter \"{action} {attribute} {op}\"\n"
+ "\n"
+ " {action} :=\n"
+ " accept |\n"
+ " reject\n"
+ "\n"
+ " {attribute} :=\n"
+ " activity | // message's most-derived activity\n"
+ " activity-chain | // message's {parent}:{child} activity\n"
+ " category | // message's category\n"
+ " message | // message's expanded contents\n"
+ " subsystem | // message's subsystem\n"
+ "\n"
+ " {op} :=\n"
+ " match {exact-match-text} |\n"
+ " regex {search-regex}\n"
+ "\n"
+ "The regex flavor used is the C++ std::regex ECMAScript format. "
+ "Prefer character classes like [[:digit:]] to \\d and the like, as "
+ "getting the backslashes escaped through properly is error-prone."
+ },
+ { LLDB_OPT_SET_ALL, false, "live-stream", 'l',
+ OptionParser::eRequiredArgument, nullptr, nullptr, 0,
+ eArgTypeBoolean,
+ "Specify whether logging events are live-streamed or buffered. "
+ "True indicates live streaming, false indicates buffered. The "
+ "default is true (live streaming). Live streaming will deliver "
+ "log messages with less delay, but buffered capture mode has less "
+ "of an observer effect." },
+ { LLDB_OPT_SET_ALL, false, "no-match-accepts", 'n',
+ OptionParser::eRequiredArgument, nullptr, nullptr, 0,
+ eArgTypeBoolean,
+ "Specify whether a log message that doesn't match any filter rule "
+ "is accepted or rejected, where true indicates accept. The "
+ "default is true." },
+ { LLDB_OPT_SET_ALL, false, "echo-to-stderr", 'e',
+ OptionParser::eRequiredArgument, nullptr, nullptr, 0,
+ eArgTypeBoolean,
+ "Specify whether os_log()/NSLog() messages are echoed to the "
+ "target program's stderr. When DarwinLog is enabled, we shut off "
+ "the mirroring of os_log()/NSLog() to the program's stderr. "
+ "Setting this flag to true will restore the stderr mirroring."
+ "The default is false." },
+ { LLDB_OPT_SET_ALL, false, "broadcast-events", 'b',
+ OptionParser::eRequiredArgument, nullptr, nullptr, 0,
+ eArgTypeBoolean,
+ "Specify if the plugin should broadcast events. Broadcasting "
+ "log events is a requirement for displaying the log entries in "
+ "LLDB command-line. It is also required if LLDB clients want to "
+ "process log events. The default is true." },
+ // Message formatting options
+ { LLDB_OPT_SET_ALL, false, "timestamp-relative", 'r',
+ OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+ "Include timestamp in the message header when printing a log "
+ "message. The timestamp is relative to the first displayed "
+ "message." },
+ { LLDB_OPT_SET_ALL, false, "subsystem", 's',
+ OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+ "Include the subsystem in the the message header when displaying "
+ "a log message." },
+ { LLDB_OPT_SET_ALL, false, "category", 'c',
+ OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+ "Include the category in the the message header when displaying "
+ "a log message." },
+ { LLDB_OPT_SET_ALL, false, "activity-chain", 'C',
+ OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+ "Include the activity parent-child chain in the the message header "
+ "when displaying a log message. The activity hierarchy is "
+ "displayed as {grandparent-activity}:"
+ "{parent-activity}:{activity}[:...]."},
+ { LLDB_OPT_SET_ALL, false, "all-fields", 'A',
+ OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone,
+ "Shortcut to specify that all header fields should be displayed." },
+
+ // Tail sentinel entry
+ { 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr }
+ };
+
+ class EnableCommand : public CommandObjectParsed
+ {
+ public:
+
+ EnableCommand(CommandInterpreter &interpreter, bool enable,
+ const char *name, const char *help,
+ const char *syntax) :
+ CommandObjectParsed(interpreter, name, help, syntax),
+ m_enable(enable),
+ m_options_sp(enable ? new EnableOptions() : nullptr)
+ {
+ }
+
+ protected:
+
+ void
+ AppendStrictSourcesWarning(CommandReturnObject &result,
+ const char *source_name)
+ {
+ if (!source_name)
+ return;
+
+ // Check if we're *not* using strict sources. If not,
+ // then the user is going to get debug-level info
+ // anyways, probably not what they're expecting.
+ // Unfortunately we can only fix this by adding an
+ // env var, which would have had to have happened
+ // already. Thus, a warning is the best we can do here.
+ StreamString stream;
+ stream.Printf("darwin-log source settings specify to exclude "
+ "%s messages, but setting "
+ "'plugin.structured-data.darwin-log."
+ "strict-sources' is disabled. This process will "
+ "automatically have %s messages included. Enable"
+ " the property and relaunch the target binary to have"
+ " these messages excluded.", source_name,
+ source_name);
+ result.AppendWarning(stream.GetString().c_str());
+ }
+
+ bool
+ DoExecute (Args& command, CommandReturnObject &result) override
+ {
+ // First off, set the global sticky state of enable/disable
+ // based on this command execution.
+ s_is_explicitly_enabled = m_enable;
+
+ // Next, if this is an enable, save off the option data.
+ // We will need it later if a process hasn't been launched or
+ // attached yet.
+ if (m_enable)
+ {
+ // Save off enabled configuration so we can apply these parsed
+ // options the next time an attach or launch occurs.
+ DebuggerSP debugger_sp =
+ GetCommandInterpreter().GetDebugger().shared_from_this();
+ SetGlobalEnableOptions(debugger_sp, m_options_sp);
+ }
+
+ // Now check if we have a running process. If so, we should
+ // instruct the process monitor to enable/disable DarwinLog support
+ // now.
+ Target *target = GetSelectedOrDummyTarget();
+ if (!target)
+ {
+ // No target, so there is nothing more to do right now.
+ result.SetStatus(eReturnStatusSuccessFinishNoResult);
+ return true;
+ }
+
+ // Grab the active process.
+ auto process_sp = target->GetProcessSP();
+ if (!process_sp)
+ {
+ // No active process, so there is nothing more to do right
+ // now.
+ result.SetStatus(eReturnStatusSuccessFinishNoResult);
+ return true;
+ }
+
+ // If the process is no longer alive, we can't do this now.
+ // We'll catch it the next time the process is started up.
+ if (!process_sp->IsAlive())
+ {
+ result.SetStatus(eReturnStatusSuccessFinishNoResult);
+ return true;
+ }
+
+ // Get the plugin for the process.
+ auto plugin_sp =
+ process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
+ if (!plugin_sp ||
+ (plugin_sp->GetPluginName() !=
+ StructuredDataDarwinLog::GetStaticPluginName()))
+ {
+ result.AppendError("failed to get StructuredDataPlugin for "
+ "the process");
+ result.SetStatus(eReturnStatusFailed);
+ }
+ StructuredDataDarwinLog &plugin =
+ *static_cast<StructuredDataDarwinLog*>(plugin_sp.get());
+
+ if (m_enable)
+ {
+ // To do this next part right, we need to track whether we
+ // added the proper environment variable at launch time.
+ // It is incorrect to assume that we're enabling after launch,
+ // and that therefore if we needed the env var set to properly
+ // handle the options, that it is set incorrectly. The env var
+ // could have been added if this is a re-enable using different
+ // arguments. This is a bit tricky as the point where we
+ // have to set the env var, we don't yet have a process or the
+ // associated darwin-log plugin instance, and thus don't have a
+ // great place to stick this knowledge.
+#if 0
+ // Check if we're attempting to disable debug-level or
+ // info-level content but we haven't launched with the magic
+ // env var that suppresses the "always add" of those. In
+ // that scenario, the user is asking *not* to see debug or
+ // info level messages, but will see them anyway. Warn and
+ // show how to correct it.
+ if (!m_options_sp->GetIncludeDebugLevel() &&
+ !GetGlobalProperties()->GetUseStrictSources())
+ {
+ AppendStrictSourcesWarning(result, "debug-level");
+ }
+
+ if (!m_options_sp->GetIncludeInfoLevel() &&
+ !GetGlobalProperties()->GetUseStrictSources())
+ {
+ AppendStrictSourcesWarning(result, "info-level");
+ }
+#endif
+
+ // Hook up the breakpoint for the process that detects when
+ // libtrace has been sufficiently initialized to really start
+ // the os_log stream. This is insurance to assure us that
+ // logging is really enabled. Requesting that logging be
+ // enabled for a process before libtrace is initialized
+ // results in a scenario where no errors occur, but no logging
+ // is captured, either. This step is to eliminate that
+ // possibility.
+ plugin.AddInitCompletionHook(*process_sp.get());
+ }
+
+ // Send configuration to the feature by way of the process.
+ // Construct the options we will use.
+ auto config_sp = m_options_sp->BuildConfigurationData(m_enable);
+ const Error error =
+ process_sp->ConfigureStructuredData(GetDarwinLogTypeName(),
+ config_sp);
+
+ // Report results.
+ if (!error.Success())
+ {
+ result.AppendError(error.AsCString());
+ result.SetStatus(eReturnStatusFailed);
+ // Our configuration failed, so we're definitely disabled.
+ plugin.SetEnabled(false);
+ }
+ else
+ {
+ result.SetStatus(eReturnStatusSuccessFinishNoResult);
+ // Our configuration succeeeded, so we're enabled/disabled
+ // per whichever one this command is setup to do.
+ plugin.SetEnabled(m_enable);
+ }
+ return result.Succeeded();
+ }
+
+ Options*
+ GetOptions () override
+ {
+ // We don't have options when this represents disable.
+ return m_enable ? m_options_sp.get() : nullptr;
+ }
+
+ private:
+ const bool m_enable;
+ EnableOptionsSP m_options_sp;
+ };
+
+ // -------------------------------------------------------------------------
+ /// Provides the status command.
+ // -------------------------------------------------------------------------
+ class StatusCommand : public CommandObjectParsed
+ {
+ public:
+
+ StatusCommand(CommandInterpreter &interpreter) :
+ CommandObjectParsed(interpreter, "status",
+ "Show whether Darwin log supported is available"
+ " and enabled.",
+ "plugin structured-data darwin-log status")
+ {
+ }
+
+ protected:
+
+ bool
+ DoExecute (Args& command, CommandReturnObject &result) override
+ {
+ auto &stream = result.GetOutputStream();
+
+ // Figure out if we've got a process. If so, we can tell if
+ // DarwinLog is available for that process.
+ Target *target = GetSelectedOrDummyTarget();
+ auto process_sp = target ? target->GetProcessSP() : ProcessSP();
+ if (!target || !process_sp)
+ {
+ stream.PutCString("Availability: unknown (requires process)\n");
+ stream.PutCString("Enabled: not applicable "
+ "(requires process)\n");
+ }
+ else
+ {
+ auto plugin_sp =
+ process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
+ stream.Printf("Availability: %s\n", plugin_sp ? "available" :
+ "unavailable");
+ auto &plugin_name =
+ StructuredDataDarwinLog::GetStaticPluginName();
+ const bool enabled = plugin_sp ?
+ plugin_sp->GetEnabled(plugin_name) : false;
+ stream.Printf("Enabled: %s\n", enabled ? "true" :
+ "false");
+ }
+
+ // Display filter settings.
+ DebuggerSP debugger_sp =
+ GetCommandInterpreter().GetDebugger().shared_from_this();
+ auto options_sp = GetGlobalEnableOptions(debugger_sp);
+ if (!options_sp)
+ {
+ // Nothing more to do.
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+
+ // Print filter rules
+ stream.PutCString("DarwinLog filter rules:\n");
+
+ stream.IndentMore();
+
+ if (options_sp->GetFilterRules().empty())
+ {
+ stream.Indent();
+ stream.PutCString("none\n");
+ }
+ else
+ {
+ // Print each of the filter rules.
+ int rule_number = 0;
+ for (auto rule_sp : options_sp->GetFilterRules())
+ {
+ ++rule_number;
+ if (!rule_sp)
+ continue;
+
+ stream.Indent();
+ stream.Printf("%02d: ", rule_number);
+ rule_sp->Dump(stream);
+ stream.PutChar('\n');
+ }
+ }
+ stream.IndentLess();
+
+ // Print no-match handling.
+ stream.Indent();
+ stream.Printf("no-match behavior: %s\n",
+ options_sp->GetFallthroughAccepts() ? "accept" :
+ "reject");
+
+ result.SetStatus(eReturnStatusSuccessFinishResult);
+ return true;
+ }
+ };
+
+ // -------------------------------------------------------------------------
+ /// Provides the darwin-log base command
+ // -------------------------------------------------------------------------
+ class BaseCommand : public CommandObjectMultiword
+ {
+ public:
+ BaseCommand(CommandInterpreter &interpreter) :
+ CommandObjectMultiword(interpreter,
+ "plugin structured-data darwin-log",
+ "Commands for configuring Darwin os_log "
+ "support.",
+ "")
+ {
+ // enable
+ auto enable_help = "Enable Darwin log collection, or re-enable "
+ "with modified configuration.";
+ auto enable_syntax = "plugin structured-data darwin-log enable";
+ auto enable_cmd_sp =
+ CommandObjectSP(new EnableCommand(interpreter,
+ true, // enable
+ "enable",
+ enable_help,
+ enable_syntax));
+ LoadSubCommand("enable", enable_cmd_sp);
+
+ // disable
+ auto disable_help = "Disable Darwin log collection.";
+ auto disable_syntax = "plugin structured-data darwin-log disable";
+ auto disable_cmd_sp =
+ CommandObjectSP(new EnableCommand(interpreter,
+ false, // disable
+ "disable",
+ disable_help,
+ disable_syntax));
+ LoadSubCommand("disable", disable_cmd_sp);
+
+ // status
+ auto status_cmd_sp =
+ CommandObjectSP(new StatusCommand(interpreter));
+ LoadSubCommand("status", status_cmd_sp);
+ }
+ };
+
+ EnableOptionsSP
+ ParseAutoEnableOptions(Error &error, Debugger &debugger)
+ {
+ // We are abusing the options data model here so that we can parse
+ // options without requiring the Debugger instance.
+
+ // We have an empty execution context at this point. We only want
+ // to parse options, and we don't need any context to do this here.
+ // In fact, we want to be able to parse the enable options before having
+ // any context.
+ ExecutionContext exe_ctx;
+
+ EnableOptionsSP options_sp(new EnableOptions());
+ options_sp->NotifyOptionParsingStarting(&exe_ctx);
+
+ CommandReturnObject result;
+
+ // Parse the arguments.
+ auto options_property_sp =
+ debugger.GetPropertyValue(nullptr,
+ "plugin.structured-data.darwin-log."
+ "auto-enable-options",
+ false,
+ error);
+ if (!error.Success())
+ return EnableOptionsSP();
+ if (!options_property_sp)
+ {
+ error.SetErrorString("failed to find option setting for "
+ "plugin.structured-data.darwin-log.");
+ return EnableOptionsSP();
+ }
+
+ const char *enable_options = options_property_sp->GetAsString()->GetCurrentValue();
+ Args args(enable_options);
+ if (args.GetArgumentCount() > 0)
+ {
+ // Eliminate the initial '--' that would be required to set the
+ // settings that themselves include '-' and/or '--'.
+ const char *first_arg = args.GetArgumentAtIndex(0);
+ if (first_arg && (strcmp(first_arg, "--") == 0))
+ args.Shift();
+ }
+
+ // ParseOptions calls getopt_long_only, which always skips the zero'th item in the array and starts at position 1,
+ // so we need to push a dummy value into position zero.
+ args.Unshift("dummy_string");
+ bool require_validation = false;
+ error = args.ParseOptions(*options_sp.get(), &exe_ctx, PlatformSP(),
+ require_validation);
+ if (!error.Success())
+ return EnableOptionsSP();
+
+ if (!options_sp->VerifyOptions(result))
+ return EnableOptionsSP();
+
+ // We successfully parsed and validated the options.
+ return options_sp;
+ }
+
+ bool
+ RunEnableCommand(CommandInterpreter &interpreter)
+ {
+ StreamString command_stream;
+
+ command_stream << "plugin structured-data darwin-log enable";
+ auto enable_options = GetGlobalProperties()->GetAutoEnableOptions();
+ if (enable_options && (strlen(enable_options) > 0))
+ {
+ command_stream << ' ';
+ command_stream << enable_options;
+ }
+
+ // Run the command.
+ CommandReturnObject return_object;
+ interpreter.HandleCommand(command_stream.GetString().c_str(),
+ eLazyBoolNo,
+ return_object);
+ return return_object.Succeeded();
+ }
+}
+using namespace sddarwinlog_private;
+
+#pragma mark -
+#pragma mark Public static API
+
+// -----------------------------------------------------------------------------
+// Public static API
+// -----------------------------------------------------------------------------
+
+void
+StructuredDataDarwinLog::Initialize()
+{
+ RegisterFilterOperations();
+ PluginManager::RegisterPlugin(GetStaticPluginName(),
+ "Darwin os_log() and os_activity() support",
+ &CreateInstance,
+ &DebuggerInitialize,
+ &FilterLaunchInfo);
+}
+
+void
+StructuredDataDarwinLog::Terminate()
+{
+ PluginManager::UnregisterPlugin(&CreateInstance);
+}
+
+const ConstString&
+StructuredDataDarwinLog::GetStaticPluginName()
+{
+ static ConstString s_plugin_name("darwin-log");
+ return s_plugin_name;
+}
+
+#pragma mark -
+#pragma mark PluginInterface API
+
+// -----------------------------------------------------------------------------
+// PluginInterface API
+// -----------------------------------------------------------------------------
+
+ConstString
+StructuredDataDarwinLog::GetPluginName()
+{
+ return GetStaticPluginName();
+}
+
+uint32_t
+StructuredDataDarwinLog::GetPluginVersion()
+{
+ return 1;
+}
+
+#pragma mark -
+#pragma mark StructuredDataPlugin API
+
+// -----------------------------------------------------------------------------
+// StructuredDataPlugin API
+// -----------------------------------------------------------------------------
+
+bool
+StructuredDataDarwinLog::SupportsStructuredDataType(
+ const ConstString &type_name)
+{
+ return type_name == GetDarwinLogTypeName();
+}
+
+void
+StructuredDataDarwinLog::HandleArrivalOfStructuredData(Process &process,
+ const ConstString
+ &type_name,
+ const
+ StructuredData::ObjectSP
+ &object_sp)
+{
+ Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+ if (log)
+ {
+ StreamString json_stream;
+ if (object_sp)
+ object_sp->Dump(json_stream);
+ else
+ json_stream.PutCString("<null>");
+ log->Printf("StructuredDataDarwinLog::%s() called with json: %s",
+ __FUNCTION__, json_stream.GetString().c_str());
+ }
+
+ // Ignore empty structured data.
+ if (!object_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() StructuredData object "
+ "is null", __FUNCTION__);
+ return;
+ }
+
+ // Ignore any data that isn't for us.
+ if (type_name != GetDarwinLogTypeName())
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() StructuredData type "
+ "expected to be %s but was %s, ignoring", __FUNCTION__,
+ GetDarwinLogTypeName().AsCString(),
+ type_name.AsCString());
+ return;
+ }
+
+ // Broadcast the structured data event if we have that enabled.
+ // This is the way that the outside world (all clients) get access
+ // to this data. This plugin sets policy as to whether we do that.
+ DebuggerSP debugger_sp =
+ process.GetTarget().GetDebugger().shared_from_this();
+ auto options_sp = GetGlobalEnableOptions(debugger_sp);
+ if (options_sp && options_sp->GetBroadcastEvents())
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() broadcasting event",
+ __FUNCTION__);
+ process.BroadcastStructuredData(object_sp, shared_from_this());
+ }
+
+ // Later, hang on to a configurable amount of these and allow commands
+ // to inspect, including showing backtraces.
+}
+
+static void
+SetErrorWithJSON(Error &error, const char *message,
+ StructuredData::Object &object)
+{
+ if (!message)
+ {
+ error.SetErrorString("Internal error: message not set.");
+ return;
+ }
+
+ StreamString object_stream;
+ object.Dump(object_stream);
+ object_stream.Flush();
+
+ error.SetErrorStringWithFormat("%s: %s", message,
+ object_stream.GetString().c_str());
+}
+
+Error
+StructuredDataDarwinLog::GetDescription(const StructuredData::ObjectSP
+ &object_sp,
+ lldb_private::Stream &stream)
+{
+ Error error;
+
+ if (!object_sp)
+ {
+ error.SetErrorString("No structured data.");
+ return error;
+ }
+
+ // Log message payload objects will be dictionaries.
+ const StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary();
+ if (!dictionary)
+ {
+ SetErrorWithJSON(error, "Structured data should have been a dictionary "
+ "but wasn't", *object_sp);
+ return error;
+ }
+
+ // Validate this is really a message for our plugin.
+ ConstString type_name;
+ if (!dictionary->GetValueForKeyAsString("type", type_name))
+ {
+ SetErrorWithJSON(error, "Structured data doesn't contain mandatory "
+ "type field", *object_sp);
+ return error;
+ }
+
+ if (type_name != GetDarwinLogTypeName())
+ {
+ // This is okay - it simply means the data we received is not a log
+ // message. We'll just format it as is.
+ object_sp->Dump(stream);
+ return error;
+ }
+
+ // DarwinLog dictionaries store their data
+ // in an array with key name "events".
+ StructuredData::Array *events = nullptr;
+ if (!dictionary->GetValueForKeyAsArray("events", events) ||
+ !events)
+ {
+ SetErrorWithJSON(error, "Log structured data is missing mandatory "
+ "'events' field, expected to be an array", *object_sp);
+ return error;
+ }
+
+ events->ForEach([&stream, &error, &object_sp, this]
+ (StructuredData::Object *object)
+ {
+ if (!object)
+ {
+ // Invalid. Stop iterating.
+ SetErrorWithJSON(error, "Log event entry is null", *object_sp);
+ return false;
+ }
+
+ auto event = object->GetAsDictionary();
+ if (!event)
+ {
+ // Invalid, stop iterating.
+ SetErrorWithJSON(error, "Log event is not a dictionary",
+ *object_sp);
+ return false;
+ }
+
+ // If we haven't already grabbed the first timestamp
+ // value, do that now.
+ if (!m_recorded_first_timestamp)
+ {
+ uint64_t timestamp = 0;
+ if (event->GetValueForKeyAsInteger("timestamp",
+ timestamp))
+ {
+ m_first_timestamp_seen = timestamp;
+ m_recorded_first_timestamp = true;
+ }
+ }
+
+ HandleDisplayOfEvent(*event, stream);
+ return true;
+ });
+
+ stream.Flush();
+ return error;
+}
+
+bool
+StructuredDataDarwinLog::GetEnabled(const ConstString &type_name) const
+{
+ if (type_name == GetStaticPluginName())
+ return m_is_enabled;
+ else
+ return false;
+}
+
+void
+StructuredDataDarwinLog::SetEnabled(bool enabled)
+{
+ m_is_enabled = enabled;
+}
+
+void
+StructuredDataDarwinLog::ModulesDidLoad(Process &process,
+ ModuleList &module_list)
+{
+ Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s called (process uid %u)",
+ __FUNCTION__, process.GetUniqueID());
+
+ // Check if we should enable the darwin log support on startup/attach.
+ if (!GetGlobalProperties()->GetEnableOnStartup() &&
+ !s_is_explicitly_enabled)
+ {
+ // We're neither auto-enabled or explicitly enabled, so we shouldn't
+ // try to enable here.
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s not applicable, we're not "
+ "enabled (process uid %u)", __FUNCTION__,
+ process.GetUniqueID());
+ return;
+ }
+
+ // If we already added the breakpoint, we've got nothing left to do.
+ {
+ std::lock_guard<std::mutex> locker(m_added_breakpoint_mutex);
+ if (m_added_breakpoint)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s process uid %u's "
+ "post-libtrace-init breakpoint is already set",
+ __FUNCTION__, process.GetUniqueID());
+ return;
+ }
+ }
+
+ // The logging support module name, specifies the name of
+ // the image name that must be loaded into the debugged process before
+ // we can try to enable logging.
+ const char *logging_module_cstr =
+ GetGlobalProperties()->GetLoggingModuleName();
+ if (!logging_module_cstr || (logging_module_cstr[0] == 0))
+ {
+ // We need this. Bail.
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s no logging module name "
+ "specified, we don't know where to set a breakpoint "
+ "(process uid %u)", __FUNCTION__,
+ process.GetUniqueID());
+ return;
+ }
+
+ const ConstString logging_module_name =
+ ConstString(logging_module_cstr);
+
+ // We need to see libtrace in the list of modules before we can enable
+ // tracing for the target process.
+ bool found_logging_support_module = false;
+ for (size_t i = 0; i < module_list.GetSize(); ++i)
+ {
+ auto module_sp = module_list.GetModuleAtIndex(i);
+ if (!module_sp)
+ continue;
+
+ auto &file_spec = module_sp->GetFileSpec();
+ found_logging_support_module =
+ (file_spec.GetLastPathComponent() == logging_module_name);
+ if (found_logging_support_module)
+ break;
+ }
+
+ if (!found_logging_support_module)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s logging module %s "
+ "has not yet been loaded, can't set a breakpoint "
+ "yet (process uid %u)", __FUNCTION__,
+ logging_module_name.AsCString(),
+ process.GetUniqueID());
+ return;
+ }
+
+ // Time to enqueue the breakpoint so we can wait for logging support
+ // to be initialized before we try to tap the libtrace stream.
+ AddInitCompletionHook(process);
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s post-init hook breakpoint "
+ "set for logging module %s (process uid %u)", __FUNCTION__,
+ logging_module_name.AsCString(),
+ process.GetUniqueID());
+
+ // We need to try the enable here as well, which will succeed
+ // in the event that we're attaching to (rather than launching) the
+ // process and the process is already past initialization time. In that
+ // case, the completion breakpoint will never get hit and therefore won't
+ // start that way. It doesn't hurt much beyond a bit of bandwidth
+ // if we end up doing this twice. It hurts much more if we don't get
+ // the logging enabled when the user expects it.
+ EnableNow();
+}
+
+#pragma mark -
+#pragma mark Private instance methods
+
+// -----------------------------------------------------------------------------
+// Private constructors
+// -----------------------------------------------------------------------------
+
+StructuredDataDarwinLog::StructuredDataDarwinLog(const ProcessWP &process_wp) :
+ StructuredDataPlugin(process_wp),
+ m_recorded_first_timestamp(false),
+ m_first_timestamp_seen(0),
+ m_is_enabled(false),
+ m_added_breakpoint_mutex(),
+ m_added_breakpoint()
+{
+}
+
+// -----------------------------------------------------------------------------
+// Private static methods
+// -----------------------------------------------------------------------------
+
+StructuredDataPluginSP
+StructuredDataDarwinLog::CreateInstance(Process &process)
+{
+ // Currently only Apple targets support the os_log/os_activity
+ // protocol.
+ if (process.GetTarget().GetArchitecture().GetTriple().getVendor() ==
+ llvm::Triple::VendorType::Apple)
+ {
+ auto process_wp = ProcessWP(process.shared_from_this());
+ return StructuredDataPluginSP(new StructuredDataDarwinLog(process_wp));
+ }
+ else
+ {
+ return StructuredDataPluginSP();
+ }
+}
+
+void
+StructuredDataDarwinLog::DebuggerInitialize(Debugger &debugger)
+{
+ // Setup parent class first.
+ StructuredDataPlugin::InitializeBasePluginForDebugger(debugger);
+
+ // Get parent command.
+ auto &interpreter = debugger.GetCommandInterpreter();
+ std::string parent_command_text = "plugin structured-data";
+ auto parent_command =
+ interpreter.GetCommandObjectForCommand(parent_command_text);
+ if (!parent_command)
+ {
+ // Ut oh, parent failed to create parent command.
+ // TODO log
+ return;
+ }
+
+ auto command_name = "darwin-log";
+ auto command_sp = CommandObjectSP(new BaseCommand(interpreter));
+ bool result = parent_command->LoadSubCommand(command_name, command_sp);
+ if (!result)
+ {
+ // TODO log it once we setup structured data logging
+ }
+
+ if (!PluginManager::GetSettingForPlatformPlugin(debugger,
+ StructuredDataDarwinLogProperties::GetSettingName()))
+ {
+ const bool is_global_setting = true;
+ PluginManager::CreateSettingForStructuredDataPlugin(debugger,
+ GetGlobalProperties()->GetValueProperties(),
+ ConstString ("Properties for the darwin-log"
+ " plug-in."),
+ is_global_setting);
+ }
+
+}
+
+Error
+StructuredDataDarwinLog::FilterLaunchInfo(ProcessLaunchInfo &launch_info,
+ Target *target)
+{
+ Error error;
+
+ // If we're not debugging this launched process, there's nothing for us
+ // to do here.
+ if (!launch_info.GetFlags().AnySet(eLaunchFlagDebug))
+ return error;
+
+ // Darwin os_log() support automatically adds debug-level and info-level
+ // messages when a debugger is attached to a process. However, with
+ // integrated suppport for debugging built into the command-line LLDB,
+ // the user may specifically set to *not* include debug-level and info-level
+ // content. When the user is using the integrated log support, we want
+ // to put the kabosh on that automatic adding of info and debug level.
+ // This is done by adding an environment variable to the process on launch.
+ // (This also means it is not possible to suppress this behavior if
+ // attaching to an already-running app).
+ // Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
+
+ // If the target architecture is not one that supports DarwinLog, we have
+ // nothing to do here.
+ auto &triple = target ? target->GetArchitecture().GetTriple() :
+ launch_info.GetArchitecture().GetTriple();
+ if (triple.getVendor() !=
+ llvm::Triple::Apple)
+ {
+ return error;
+ }
+
+ // If DarwinLog is not enabled (either by explicit user command or via
+ // the auto-enable option), then we have nothing to do.
+ if (!GetGlobalProperties()->GetEnableOnStartup() &&
+ !s_is_explicitly_enabled)
+ {
+ // Nothing to do, DarwinLog is not enabled.
+ return error;
+ }
+
+ // If we don't have parsed configuration info, that implies we have
+ // enable-on-startup set up, but we haven't yet attempted to run the
+ // enable command.
+ if (!target)
+ {
+ // We really can't do this without a target. We need to be able
+ // to get to the debugger to get the proper options to do this right.
+ // TODO log.
+ error.SetErrorString("requires a target to auto-enable DarwinLog.");
+ return error;
+ }
+
+ DebuggerSP debugger_sp = target->GetDebugger().shared_from_this();
+ auto options_sp = GetGlobalEnableOptions(debugger_sp);
+ if (!options_sp && debugger_sp)
+ {
+ options_sp = ParseAutoEnableOptions(error, *debugger_sp.get());
+ if (!options_sp || !error.Success())
+ return error;
+
+ // We already parsed the options, save them now so we don't generate
+ // them again until the user runs the command manually.
+ SetGlobalEnableOptions(debugger_sp, options_sp);
+ }
+
+ auto &env_vars = launch_info.GetEnvironmentEntries();
+ if (!options_sp->GetEchoToStdErr())
+ {
+ // The user doesn't want to see os_log/NSLog messages echo to stderr.
+ // That mechanism is entirely separate from the DarwinLog support.
+ // By default we don't want to get it via stderr, because that would
+ // be in duplicate of the explicit log support here.
+
+ // Here we need to strip out any OS_ACTIVITY_DT_MODE setting to prevent
+ // echoing of os_log()/NSLog() to stderr in the target program.
+ size_t argument_index;
+ if (env_vars.ContainsEnvironmentVariable("OS_ACTIVITY_DT_MODE",
+ &argument_index))
+ env_vars.DeleteArgumentAtIndex(argument_index);
+
+ // We will also set the env var that tells any downstream launcher
+ // from adding OS_ACTIVITY_DT_MODE.
+ env_vars.AddOrReplaceEnvironmentVariable(
+ "IDE_DISABLED_OS_ACTIVITY_DT_MODE", "1");
+ }
+
+ // Set the OS_ACTIVITY_MODE env var appropriately to enable/disable
+ // debug and info level messages.
+ const char *env_var_value;
+ if (options_sp->GetIncludeDebugLevel())
+ env_var_value = "debug";
+ else if (options_sp->GetIncludeInfoLevel())
+ env_var_value = "info";
+ else
+ env_var_value = "";
+
+ if (env_var_value)
+ {
+ const char *env_var_name = "OS_ACTIVITY_MODE";
+ launch_info.GetEnvironmentEntries()
+ .AddOrReplaceEnvironmentVariable(env_var_name, env_var_value);
+ }
+
+ return error;
+}
+
+bool
+StructuredDataDarwinLog::InitCompletionHookCallback(void *baton,
+ StoppointCallbackContext *context,
+ lldb::user_id_t break_id,
+ lldb::user_id_t break_loc_id)
+{
+ // We hit the init function. We now want to enqueue our new thread plan,
+ // which will in turn enqueue a StepOut thread plan. When the StepOut
+ // finishes and control returns to our new thread plan, that is the time
+ // when we can execute our logic to enable the logging support.
+
+ Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() called", __FUNCTION__);
+
+ // Get the current thread.
+ if (!context)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: no context, "
+ "ignoring", __FUNCTION__);
+ return false;
+ }
+
+ // Get the plugin from the process.
+ auto process_sp = context->exe_ctx_ref.GetProcessSP();
+ if (!process_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: invalid "
+ "process in context, ignoring", __FUNCTION__);
+ return false;
+ }
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() call is for process uid %d",
+ __FUNCTION__, process_sp->GetUniqueID());
+
+ auto plugin_sp =
+ process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
+ if (!plugin_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: no plugin for "
+ "feature %s in process uid %u",
+ __FUNCTION__, GetDarwinLogTypeName().AsCString(),
+ process_sp->GetUniqueID());
+ return false;
+ }
+
+ // Create the callback for when the thread plan completes.
+ bool called_enable_method = false;
+ const auto process_uid = process_sp->GetUniqueID();
+
+ std::weak_ptr<StructuredDataPlugin> plugin_wp(plugin_sp);
+ ThreadPlanCallOnFunctionExit::Callback callback =
+ [plugin_wp, &called_enable_method, log, process_uid]() {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::post-init callback: "
+ "called (process uid %u)", process_uid);
+
+ auto strong_plugin_sp = plugin_wp.lock();
+ if (!strong_plugin_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::post-init callback: "
+ "plugin no longer exists, ignoring (process "
+ "uid %u)", process_uid);
+ return;
+ }
+ // Make sure we only call it once, just in case the
+ // thread plan hits the breakpoint twice.
+ if (!called_enable_method)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::post-init callback: "
+ "calling EnableNow() (process uid %u)",
+ process_uid);
+ static_cast<StructuredDataDarwinLog*>(strong_plugin_sp.get())
+ ->EnableNow();
+ called_enable_method = true;
+ }
+ else
+ {
+ // Our breakpoint was hit more than once. Unexpected but
+ // no harm done. Log it.
+ if (log)
+ log->Printf("StructuredDataDarwinLog::post-init callback: "
+ "skipping EnableNow(), already called by "
+ "callback [we hit this more than once] "
+ "(process uid %u)", process_uid);
+ }
+ };
+
+ // Grab the current thread.
+ auto thread_sp = context->exe_ctx_ref.GetThreadSP();
+ if (!thread_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: failed to "
+ "retrieve the current thread from the execution "
+ "context, nowhere to run the thread plan (process uid "
+ "%u)", __FUNCTION__, process_sp->GetUniqueID());
+ return false;
+ }
+
+ // Queue the thread plan.
+ auto thread_plan_sp
+ = ThreadPlanSP(new ThreadPlanCallOnFunctionExit(*thread_sp.get(),
+ callback));
+ const bool abort_other_plans = false;
+ thread_sp->QueueThreadPlan(thread_plan_sp, abort_other_plans);
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() queuing thread plan on "
+ "trace library init method entry (process uid %u)",
+ __FUNCTION__, process_sp->GetUniqueID());
+
+ // We return false here to indicate that it isn't a public stop.
+ return false;
+}
+
+void
+StructuredDataDarwinLog::AddInitCompletionHook(Process &process)
+{
+ Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() called (process uid %u)",
+ __FUNCTION__, process.GetUniqueID());
+
+ // Make sure we haven't already done this.
+ {
+ std::lock_guard<std::mutex> locker(m_added_breakpoint_mutex);
+ if (m_added_breakpoint)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() ignoring request, "
+ "breakpoint already set (process uid %u)",
+ __FUNCTION__, process.GetUniqueID());
+ return;
+ }
+
+ // We're about to do this, don't let anybody else try to do it.
+ m_added_breakpoint = true;
+ }
+
+ // Set a breakpoint for the process that will kick in when libtrace
+ // has finished its initialization.
+ Target &target = process.GetTarget();
+
+ // Build up the module list.
+ FileSpecList module_spec_list;
+ auto module_file_spec =
+ FileSpec(GetGlobalProperties()->GetLoggingModuleName(), false);
+ module_spec_list.Append(module_file_spec);
+
+ // We aren't specifying a source file set.
+ FileSpecList *source_spec_list = nullptr;
+
+ const char *func_name = "_libtrace_init";
+ const lldb::addr_t offset = 0;
+ const LazyBool skip_prologue = eLazyBoolCalculate;
+ // This is an internal breakpoint - the user shouldn't see it.
+ const bool internal = true;
+ const bool hardware = false;
+
+ auto breakpoint_sp =
+ target.CreateBreakpoint(&module_spec_list, source_spec_list, func_name,
+ eFunctionNameTypeFull, eLanguageTypeC, offset,
+ skip_prologue, internal, hardware);
+ if (!breakpoint_sp)
+ {
+ // Huh? Bail here.
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() failed to set "
+ "breakpoint in module %s, function %s (process uid %u)",
+ __FUNCTION__,
+ GetGlobalProperties()->GetLoggingModuleName(),
+ func_name, process.GetUniqueID());
+ return;
+ }
+
+ // Set our callback.
+ breakpoint_sp->SetCallback(InitCompletionHookCallback, nullptr);
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() breakpoint set in module %s,"
+ "function %s (process uid %u)",
+ __FUNCTION__,
+ GetGlobalProperties()->GetLoggingModuleName(),
+ func_name, process.GetUniqueID());
+}
+
+void
+StructuredDataDarwinLog::DumpTimestamp(Stream &stream, uint64_t timestamp)
+{
+ const uint64_t delta_nanos = timestamp - m_first_timestamp_seen;
+
+ const uint64_t hours = delta_nanos / NANOS_PER_HOUR;
+ uint64_t nanos_remaining = delta_nanos % NANOS_PER_HOUR;
+
+ const uint64_t minutes = nanos_remaining / NANOS_PER_MINUTE;
+ nanos_remaining = nanos_remaining % NANOS_PER_MINUTE;
+
+ const uint64_t seconds = nanos_remaining / NANOS_PER_SECOND;
+ nanos_remaining = nanos_remaining % NANOS_PER_SECOND;
+
+ stream.Printf("%02" PRIu64 ":%02" PRIu64 ":%02" PRIu64 ".%09" PRIu64,
+ hours, minutes, seconds, nanos_remaining);
+}
+
+size_t
+StructuredDataDarwinLog::DumpHeader(Stream &output_stream,
+ const StructuredData::Dictionary &event)
+{
+ StreamString stream;
+
+ ProcessSP process_sp = GetProcess();
+ if (!process_sp)
+ {
+ // TODO log
+ return 0;
+ }
+
+ DebuggerSP debugger_sp =
+ process_sp->GetTarget().GetDebugger().shared_from_this();
+ if (!debugger_sp)
+ {
+ // TODO log
+ return 0;
+ }
+
+ auto options_sp = GetGlobalEnableOptions(debugger_sp);
+ if (!options_sp)
+ {
+ // TODO log
+ return 0;
+ }
+
+ // Check if we should even display a header.
+ if (!options_sp->GetDisplayAnyHeaderFields())
+ return 0;
+
+ stream.PutChar('[');
+
+ int header_count = 0;
+ if (options_sp->GetDisplayTimestampRelative())
+ {
+ uint64_t timestamp = 0;
+ if (event.GetValueForKeyAsInteger("timestamp", timestamp))
+ {
+ DumpTimestamp(stream, timestamp);
+ ++header_count;
+ }
+ }
+
+ if (options_sp->GetDisplayActivityChain())
+ {
+ std::string activity_chain;
+ if (event.GetValueForKeyAsString("activity-chain", activity_chain) &&
+ !activity_chain.empty())
+ {
+ if (header_count > 0)
+ stream.PutChar(',');
+
+ // Switch over to the #if 0 branch once we figure out
+ // how we want to present settings for the tri-state of
+ // no-activity, activity (most derived only), or activity-chain.
+#if 1
+ // Display the activity chain, from parent-most to child-most
+ // activity, separated by a colon (:).
+ stream.PutCString("activity-chain=");
+ stream.PutCString(activity_chain.c_str());
+#else
+ if (GetGlobalProperties()->GetDisplayActivityChain())
+ {
+ // Display the activity chain, from parent-most to child-most
+ // activity, separated by a colon (:).
+ stream.PutCString("activity-chain=");
+ stream.PutCString(activity_chain.c_str());
+ }
+ else
+ {
+ // We're only displaying the child-most activity.
+ stream.PutCString("activity=");
+ auto pos = activity_chain.find_last_of(':');
+ if (pos == std::string::npos)
+ {
+ // The activity chain only has one level, use the whole
+ // thing.
+ stream.PutCString(activity_chain.c_str());
+ }
+ else
+ {
+ // Display everything after the final ':'.
+ stream.PutCString(activity_chain.substr(pos+1).c_str());
+ }
+ }
+#endif
+ ++header_count;
+ }
+ }
+
+ if (options_sp->GetDisplaySubsystem())
+ {
+ std::string subsystem;
+ if (event.GetValueForKeyAsString("subsystem",
+ subsystem) &&
+ !subsystem.empty())
+ {
+ if (header_count > 0)
+ stream.PutChar(',');
+ stream.PutCString("subsystem=");
+ stream.PutCString(subsystem.c_str());
+ ++header_count;
+ }
+ }
+
+ if (options_sp->GetDisplayCategory())
+ {
+ std::string category;
+ if (event.GetValueForKeyAsString("category",
+ category) &&
+ !category.empty())
+ {
+ if (header_count > 0)
+ stream.PutChar(',');
+ stream.PutCString("category=");
+ stream.PutCString(category.c_str());
+ ++header_count;
+ }
+ }
+ stream.PutCString("] ");
+
+ auto &result = stream.GetString();
+ output_stream.PutCString(result.c_str());
+
+ return result.size();
+}
+
+size_t
+StructuredDataDarwinLog::HandleDisplayOfEvent(const StructuredData::Dictionary
+ &event, Stream &stream)
+{
+ // Check the type of the event.
+ ConstString event_type;
+ if (!event.GetValueForKeyAsString("type", event_type))
+ {
+ // Hmm, we expected to get events that describe
+ // what they are. Continue anyway.
+ return 0;
+ }
+
+ if (event_type != GetLogEventType())
+ return 0;
+
+ size_t total_bytes = 0;
+
+ // Grab the message content.
+ std::string message;
+ if (!event.GetValueForKeyAsString("message", message))
+ return true;
+
+ // Display the log entry.
+ const auto len = message.length();
+
+ total_bytes += DumpHeader(stream, event);
+
+ stream.Write(message.c_str(), len);
+ total_bytes += len;
+
+ // Add an end of line.
+ stream.PutChar('\n');
+ total_bytes += sizeof(char);
+
+ return total_bytes;
+}
+
+void
+StructuredDataDarwinLog::EnableNow()
+{
+ Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() called", __FUNCTION__);
+
+ // Run the enable command.
+ auto process_sp = GetProcess();
+ if (!process_sp)
+ {
+ // Nothing to do.
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: failed to get "
+ "valid process, skipping", __FUNCTION__);
+ return;
+ }
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() call is for process uid %u",
+ __FUNCTION__, process_sp->GetUniqueID());
+
+ // If we have configuration data, we can directly enable it now.
+ // Otherwise, we need to run through the command interpreter to parse
+ // the auto-run options (which is the only way we get here without having
+ // already-parsed configuration data).
+ DebuggerSP debugger_sp =
+ process_sp->GetTarget().GetDebugger().shared_from_this();
+ if (!debugger_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: failed to get "
+ "debugger shared pointer, skipping (process uid %u)",
+ __FUNCTION__, process_sp->GetUniqueID());
+ return;
+ }
+
+ auto options_sp = GetGlobalEnableOptions(debugger_sp);
+ if (!options_sp)
+ {
+ // We haven't run the enable command yet. Just do that now, it'll
+ // take care of the rest.
+ auto &interpreter = debugger_sp->GetCommandInterpreter();
+ const bool success = RunEnableCommand(interpreter);
+ if (log)
+ {
+ if (success)
+ log->Printf("StructuredDataDarwinLog::%s() ran enable command "
+ "successfully for (process uid %u)",
+ __FUNCTION__, process_sp->GetUniqueID());
+ else
+ log->Printf("StructuredDataDarwinLog::%s() error: running "
+ "enable command failed (process uid %u)",
+ __FUNCTION__, process_sp->GetUniqueID());
+ }
+ // Report failures to the debugger error stream.
+ auto error_stream_sp = debugger_sp->GetAsyncErrorStream();
+ if (error_stream_sp)
+ {
+ error_stream_sp->Printf("failed to configure DarwinLog "
+ "support\n");
+ error_stream_sp->Flush();
+ }
+ return;
+ }
+
+ // We've previously been enabled. We will re-enable now with the
+ // previously specified options.
+ auto config_sp = options_sp->BuildConfigurationData(true);
+ if (!config_sp)
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() warning: failed to "
+ "build configuration data for enable options, skipping "
+ "(process uid %u)", __FUNCTION__,
+ process_sp->GetUniqueID());
+ return;
+ }
+
+ // We can run it directly.
+ // Send configuration to the feature by way of the process.
+ const Error error =
+ process_sp->ConfigureStructuredData(GetDarwinLogTypeName(),
+ config_sp);
+
+ // Report results.
+ if (!error.Success())
+ {
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() "
+ "ConfigureStructuredData() call failed "
+ "(process uid %u): %s",
+ __FUNCTION__, process_sp->GetUniqueID(),
+ error.AsCString());
+ auto error_stream_sp = debugger_sp->GetAsyncErrorStream();
+ if (error_stream_sp)
+ {
+ error_stream_sp->Printf("failed to configure DarwinLog "
+ "support: %s\n", error.AsCString());
+ error_stream_sp->Flush();
+ }
+ m_is_enabled = false;
+ }
+ else
+ {
+ m_is_enabled = true;
+ if (log)
+ log->Printf("StructuredDataDarwinLog::%s() success via direct "
+ "configuration (process uid %u)", __FUNCTION__,
+ process_sp->GetUniqueID());
+ }
+}
--- /dev/null
+//===-- StructuredDataDarwinLog.h -------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef StructuredDataDarwinLog_h
+#define StructuredDataDarwinLog_h
+
+#include "lldb/Target/StructuredDataPlugin.h"
+
+#include <mutex>
+
+// Forward declarations
+namespace sddarwinlog_private
+{
+ class EnableCommand;
+}
+
+namespace lldb_private
+{
+
+class StructuredDataDarwinLog : public StructuredDataPlugin
+{
+ friend sddarwinlog_private::EnableCommand;
+
+public:
+
+ // -------------------------------------------------------------------------
+ // Public static API
+ // -------------------------------------------------------------------------
+
+ static void
+ Initialize();
+
+ static void
+ Terminate();
+
+ static const ConstString&
+ GetStaticPluginName();
+
+ // -------------------------------------------------------------------------
+ /// Return whether the DarwinLog functionality is enabled.
+ ///
+ /// The DarwinLog functionality is enabled if the user expicitly enabled
+ /// it with the enable command, or if the user has the setting set
+ /// that controls if we always enable it for newly created/attached
+ /// processes.
+ ///
+ /// @return
+ /// True if DarwinLog support is/will be enabled for existing or
+ /// newly launched/attached processes.
+ // -------------------------------------------------------------------------
+ static bool
+ IsEnabled();
+
+ // -------------------------------------------------------------------------
+ // PluginInterface API
+ // -------------------------------------------------------------------------
+
+ ConstString
+ GetPluginName() override;
+
+ uint32_t
+ GetPluginVersion() override;
+
+ // -------------------------------------------------------------------------
+ // StructuredDataPlugin API
+ // -------------------------------------------------------------------------
+
+ bool
+ SupportsStructuredDataType(const ConstString &type_name) override;
+
+ void
+ HandleArrivalOfStructuredData(Process &process,
+ const ConstString &type_name,
+ const StructuredData::ObjectSP
+ &object_sp) override;
+
+ Error
+ GetDescription(const StructuredData::ObjectSP &object_sp,
+ lldb_private::Stream &stream) override;
+
+
+ bool
+ GetEnabled(const ConstString &type_name) const override;
+
+ void
+ ModulesDidLoad(Process &process, ModuleList &module_list) override;
+
+private:
+
+ // -------------------------------------------------------------------------
+ // Private constructors
+ // -------------------------------------------------------------------------
+
+ StructuredDataDarwinLog(const lldb::ProcessWP &process_wp);
+
+ // -------------------------------------------------------------------------
+ // Private static methods
+ // -------------------------------------------------------------------------
+
+ static lldb::StructuredDataPluginSP
+ CreateInstance(Process &process);
+
+ static void
+ DebuggerInitialize(Debugger &debugger);
+
+ static bool
+ InitCompletionHookCallback(void *baton, StoppointCallbackContext *context,
+ lldb::user_id_t break_id,
+ lldb::user_id_t break_loc_id);
+
+ static Error
+ FilterLaunchInfo(ProcessLaunchInfo &launch_info, Target *target);
+
+ // -------------------------------------------------------------------------
+ // Internal helper methods used by friend classes
+ // -------------------------------------------------------------------------
+ void
+ SetEnabled(bool enabled);
+
+ void
+ AddInitCompletionHook(Process &process);
+
+ // -------------------------------------------------------------------------
+ // Private methods
+ // -------------------------------------------------------------------------
+
+ void
+ DumpTimestamp(Stream &stream, uint64_t timestamp);
+
+ size_t
+ DumpHeader(Stream &stream, const StructuredData::Dictionary &event);
+
+ size_t
+ HandleDisplayOfEvent(const StructuredData::Dictionary &event,
+ Stream &stream);
+
+ // -------------------------------------------------------------------------
+ /// Call the enable command again, using whatever settings were initially
+ /// made.
+ // -------------------------------------------------------------------------
+
+ void
+ EnableNow();
+
+ // -------------------------------------------------------------------------
+ // Private data
+ // -------------------------------------------------------------------------
+ bool m_recorded_first_timestamp;
+ uint64_t m_first_timestamp_seen;
+ bool m_is_enabled;
+ std::mutex m_added_breakpoint_mutex;
+ bool m_added_breakpoint;
+};
+
+}
+
+#endif /* StructuredDataPluginDarwinLog_hpp */
StackFrameList.cpp
StackID.cpp
StopInfo.cpp
+ StructuredDataPlugin.cpp
SystemRuntime.cpp
Target.cpp
TargetList.cpp
ThreadPlanBase.cpp
ThreadPlanCallFunction.cpp
ThreadPlanCallFunctionUsingABI.cpp
+ ThreadPlanCallOnFunctionExit.cpp
ThreadPlanCallUserExpression.cpp
ThreadPlanPython.cpp
ThreadPlanRunToAddress.cpp
// group, since then we can handle ^C interrupts ourselves w/o having to worry
// about the target getting them as well.
launch_info.SetLaunchInSeparateProcessGroup(true);
-
+
+ // Allow any StructuredData process-bound plugins to adjust the launch info
+ // if needed
+ size_t i = 0;
+ bool iteration_complete = false;
+ // Note iteration can't simply go until a nullptr callback is returned, as
+ // it is valid for a plugin to not supply a filter.
+ auto get_filter_func =
+ PluginManager::GetStructuredDataFilterCallbackAtIndex;
+ for (auto filter_callback = get_filter_func(i, iteration_complete);
+ !iteration_complete;
+ filter_callback = get_filter_func(++i, iteration_complete))
+ {
+ if (filter_callback)
+ {
+ // Give this ProcessLaunchInfo filter a chance to adjust the launch
+ // info.
+ error = (*filter_callback)(launch_info, target);
+ if (!error.Success())
+ {
+ if (log)
+ log->Printf("Platform::%s() StructuredDataPlugin launch "
+ "filter failed.", __FUNCTION__);
+ return process_sp;
+ }
+ }
+ }
+
error = LaunchProcess (launch_info);
if (error.Success())
{
#include "lldb/Target/Process.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StopInfo.h"
+#include "lldb/Target/StructuredDataPlugin.h"
#include "lldb/Target/SystemRuntime.h"
#include "lldb/Target/Target.h"
#include "lldb/Target/TargetList.h"
SetEventName(eBroadcastBitSTDOUT, "stdout-available");
SetEventName(eBroadcastBitSTDERR, "stderr-available");
SetEventName(eBroadcastBitProfileData, "profile-data-available");
+ SetEventName(eBroadcastBitStructuredData, "structured-data-available");
m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlStop, "control-stop");
m_private_state_control_broadcaster.SetEventName(eBroadcastInternalStateControlPause, "control-pause");
m_listener_sp->StartListeningForEvents(this, eBroadcastBitStateChanged | eBroadcastBitInterrupt |
eBroadcastBitSTDOUT | eBroadcastBitSTDERR |
- eBroadcastBitProfileData);
+ eBroadcastBitProfileData |
+ eBroadcastBitStructuredData);
m_private_state_listener_sp->StartListeningForEvents(&m_private_state_broadcaster,
eBroadcastBitStateChanged | eBroadcastBitInterrupt);
BroadcastEventIfUnique (eBroadcastBitProfileData, new ProcessEventData (shared_from_this(), GetState()));
}
+void
+Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
+ const StructuredDataPluginSP &plugin_sp)
+{
+ BroadcastEvent(eBroadcastBitStructuredData,
+ new EventDataStructuredData(shared_from_this(),
+ object_sp, plugin_sp));
+}
+
+StructuredDataPluginSP
+Process::GetStructuredDataPlugin(const ConstString &type_name) const
+{
+ auto find_it = m_structured_data_plugin_map.find(type_name);
+ if (find_it != m_structured_data_plugin_map.end())
+ return find_it->second;
+ else
+ return StructuredDataPluginSP();
+}
+
size_t
Process::GetAsyncProfileData (char *buf, size_t buf_size, Error &error)
{
// loading shared libraries might cause a new one to try and load
if (!m_os_ap)
LoadOperatingSystemPlugin(false);
+
+ // Give structured-data plugins a chance to see the modified modules.
+ for (auto pair : m_structured_data_plugin_map)
+ {
+ if (pair.second)
+ pair.second->ModulesDidLoad(*this, module_list);
+ }
}
void
} while (range_end != LLDB_INVALID_ADDRESS);
return error;
+}
+
+Error
+Process::ConfigureStructuredData(const ConstString &type_name,
+ const StructuredData::ObjectSP &config_sp)
+{
+ // If you get this, the Process-derived class needs to implement a method
+ // to enable an already-reported asynchronous structured data feature.
+ // See ProcessGDBRemote for an example implementation over gdb-remote.
+ return Error("unimplemented");
+}
+
+void
+Process::MapSupportedStructuredDataPlugins(const StructuredData::Array
+ &supported_type_names)
+{
+ Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+ // Bail out early if there are no type names to map.
+ if (supported_type_names.GetSize() == 0)
+ {
+ if (log)
+ log->Printf("Process::%s(): no structured data types supported",
+ __FUNCTION__);
+ return;
+ }
+
+ // Convert StructuredData type names to ConstString instances.
+ std::set<ConstString> const_type_names;
+
+ if (log)
+ log->Printf("Process::%s(): the process supports the following async "
+ "structured data types:", __FUNCTION__);
+
+ supported_type_names.ForEach([&const_type_names, &log]
+ (StructuredData::Object *object) {
+ if (!object)
+ {
+ // Invalid - shouldn't be null objects in the array.
+ return false;
+ }
+
+ auto type_name = object->GetAsString();
+ if (!type_name)
+ {
+ // Invalid format - all type names should be strings.
+ return false;
+ }
+
+ const_type_names.insert(ConstString(type_name->GetValue()));
+ if (log)
+ log->Printf("- %s", type_name->GetValue().c_str());
+ return true;
+ });
+
+ // For each StructuredDataPlugin, if the plugin handles any of the
+ // types in the supported_type_names, map that type name to that plugin.
+ uint32_t plugin_index = 0;
+ for (auto create_instance =
+ PluginManager::GetStructuredDataPluginCreateCallbackAtIndex(plugin_index);
+ create_instance && !const_type_names.empty();
+ ++plugin_index)
+ {
+ // Create the plugin.
+ StructuredDataPluginSP plugin_sp = (*create_instance)(*this);
+ if (!plugin_sp)
+ {
+ // This plugin doesn't think it can work with the process.
+ // Move on to the next.
+ continue;
+ }
+
+ // For any of the remaining type names, map any that this plugin
+ // supports.
+ std::vector<ConstString> names_to_remove;
+ for (auto &type_name : const_type_names)
+ {
+ if (plugin_sp->SupportsStructuredDataType(type_name))
+ {
+ m_structured_data_plugin_map.insert(std::make_pair(type_name,
+ plugin_sp));
+ names_to_remove.push_back(type_name);
+ if (log)
+ log->Printf("Process::%s(): using plugin %s for type name "
+ "%s", __FUNCTION__,
+ plugin_sp->GetPluginName().GetCString(),
+ type_name.GetCString());
+ }
+ }
+ // Remove the type names that were consumed by this plugin.
+ for (auto &type_name : names_to_remove)
+ const_type_names.erase(type_name);
+ }
+}
+
+bool
+Process::RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp)
+{
+ // Nothing to do if there's no data.
+ if (!object_sp)
+ return false;
+
+ // The contract is this must be a dictionary, so we can look up the
+ // routing key via the top-level 'type' string value within the dictionary.
+ StructuredData::Dictionary *dictionary = object_sp->GetAsDictionary();
+ if (!dictionary)
+ return false;
+
+ // Grab the async structured type name (i.e. the feature/plugin name).
+ ConstString type_name;
+ if (!dictionary->GetValueForKeyAsString("type", type_name))
+ return false;
+
+ // Check if there's a plugin registered for this type name.
+ auto find_it = m_structured_data_plugin_map.find(type_name);
+ if (find_it == m_structured_data_plugin_map.end())
+ {
+ // We don't have a mapping for this structured data type.
+ return false;
+ }
+
+ // Route the structured data to the plugin.
+ find_it->second->HandleArrivalOfStructuredData(*this, type_name, object_sp);
+ return true;
}
--- /dev/null
+//===-- StructuredDataPlugin.cpp --------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/StructuredDataPlugin.h"
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandObjectMultiword.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+namespace
+{
+ class CommandStructuredData : public CommandObjectMultiword
+ {
+ public:
+ CommandStructuredData(CommandInterpreter &interpreter) :
+ CommandObjectMultiword(interpreter,
+ "structured-data",
+ "Parent for per-plugin structured data commands",
+ "plugin structured-data <plugin>")
+ {
+ }
+
+ ~CommandStructuredData()
+ {
+ }
+ };
+}
+
+StructuredDataPlugin::StructuredDataPlugin(const ProcessWP &process_wp) :
+ PluginInterface(),
+ m_process_wp(process_wp)
+{
+}
+
+StructuredDataPlugin::~StructuredDataPlugin()
+{
+}
+
+bool
+StructuredDataPlugin::GetEnabled(const ConstString &type_name) const
+{
+ // By default, plugins are always enabled. Plugin authors should override
+ // this if there is an enabled/disabled state for their plugin.
+ return true;
+}
+
+ProcessSP
+StructuredDataPlugin::GetProcess() const
+{
+ return m_process_wp.lock();
+}
+
+void
+StructuredDataPlugin::InitializeBasePluginForDebugger(Debugger &debugger)
+{
+ // Create our mutliword command anchor if it doesn't already exist.
+ auto &interpreter = debugger.GetCommandInterpreter();
+ if (!interpreter.GetCommandObject("plugin structured-data"))
+ {
+ // Find the parent command.
+ auto parent_command =
+ debugger.GetCommandInterpreter().GetCommandObject("plugin");
+ if (!parent_command)
+ return;
+
+ // Create the structured-data ommand object.
+ auto command_name = "structured-data";
+ auto command_sp =
+ CommandObjectSP(new CommandStructuredData(interpreter));
+
+ // Hook it up under the top-level plugin command.
+ parent_command->LoadSubCommand(command_name,
+ command_sp);
+ }
+}
+
+void
+StructuredDataPlugin::ModulesDidLoad(Process &process, ModuleList &module_list)
+{
+ // Default implementation does nothing.
+}
--- /dev/null
+//===-- ThreadPlanCallOnFunctionExit.cpp ------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Target/ThreadPlanCallOnFunctionExit.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+ThreadPlanCallOnFunctionExit::ThreadPlanCallOnFunctionExit(Thread &thread,
+ const Callback
+ &callback) :
+ ThreadPlan(ThreadPlanKind::eKindGeneric, "CallOnFunctionExit",
+ thread,
+ eVoteNoOpinion, eVoteNoOpinion // TODO check with Jim on these
+ ),
+ m_callback(callback)
+{
+ // We are not a user-generated plan.
+ SetIsMasterPlan(false);
+}
+
+void
+ThreadPlanCallOnFunctionExit::DidPush()
+{
+ // We now want to queue the "step out" thread plan so it executes
+ // and completes.
+
+ // Set stop vote to eVoteNo.
+ m_step_out_threadplan_sp = GetThread()
+ .QueueThreadPlanForStepOut(false, // abort other plans
+ nullptr, // addr_context
+ true, // first instruction
+ true, // stop other threads
+ eVoteNo, // do not say "we're stopping"
+ eVoteNoOpinion, // don't care about
+ // run state broadcasting
+ 0, // frame_idx
+ eLazyBoolCalculate // avoid code w/o debinfo
+ );
+}
+
+// -------------------------------------------------------------------------
+// ThreadPlan API
+// -------------------------------------------------------------------------
+
+void
+ThreadPlanCallOnFunctionExit::GetDescription(Stream *s, lldb::DescriptionLevel
+ level)
+{
+ if (!s)
+ return;
+ s->Printf("Running until completion of current function, then making "
+ "callback.");
+}
+
+bool
+ThreadPlanCallOnFunctionExit::ValidatePlan(Stream *error)
+{
+ // We'll say we're always good since I don't know what would make this
+ // invalid.
+ return true;
+}
+
+bool
+ThreadPlanCallOnFunctionExit::ShouldStop(Event *event_ptr)
+{
+ // If this is where we find out that an internal stop came in, then:
+ // Check if the step-out plan completed. If it did, then we want to
+ // run the callback here (our reason for living...)
+ if (m_step_out_threadplan_sp &&
+ m_step_out_threadplan_sp->IsPlanComplete())
+ {
+ m_callback();
+
+ // We no longer need the pointer to the step-out thread plan.
+ m_step_out_threadplan_sp.reset();
+
+ // Indicate that this plan is done and can be discarded.
+ SetPlanComplete();
+
+ // We're done now, but we want to return false so that we
+ // don't cause the thread to really stop.
+ }
+
+ return false;
+}
+
+bool
+ThreadPlanCallOnFunctionExit::WillStop()
+{
+ // The code looks like the return value is ignored via ThreadList::
+ // ShouldStop().
+ // This is called when we really are going to stop. We don't care
+ // and don't need to do anything here.
+ return false;
+}
+
+bool
+ThreadPlanCallOnFunctionExit::DoPlanExplainsStop (Event *event_ptr)
+{
+ // We don't ever explain a stop. The only stop that is relevant
+ // to us directly is the step_out plan we added to do the heavy lifting
+ // of getting us past the current method.
+ return false;
+}
+
+lldb::StateType
+ThreadPlanCallOnFunctionExit::GetPlanRunState()
+{
+ // This value doesn't matter - we'll never be the top thread plan, so
+ // nobody will ask us this question.
+ return eStateRunning;
+}
objects = {
/* Begin PBXBuildFile section */
+ 23043C9D1D35DBEC00FC25CA /* JSON.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 233B4EA51D2DB54300E98261 /* JSON.cpp */; };
+ 23043C9E1D35DBFA00FC25CA /* StringConvert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 233B4EA81D2DB96A00E98261 /* StringConvert.cpp */; };
+ 2307CCCB1D4A5D630016ABC0 /* LogFilterExactMatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 237821AE1D4917D20028B7A1 /* LogFilterExactMatch.cpp */; };
+ 233B4EA71D2DB54300E98261 /* JSON.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 233B4EA51D2DB54300E98261 /* JSON.cpp */; };
+ 233B4EA91D2DB96A00E98261 /* StringConvert.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 233B4EA81D2DB96A00E98261 /* StringConvert.cpp */; };
+ 23562ED21D3424DF00AB2BD4 /* LogMessageOsLog.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23562ED01D3424DF00AB2BD4 /* LogMessageOsLog.cpp */; };
+ 23562ED31D3424DF00AB2BD4 /* LogMessageOsLog.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23562ED01D3424DF00AB2BD4 /* LogMessageOsLog.cpp */; };
+ 23562ED61D342A5A00AB2BD4 /* ActivityStore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23562ED51D342A5A00AB2BD4 /* ActivityStore.cpp */; };
+ 23562ED71D342A5A00AB2BD4 /* ActivityStore.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23562ED51D342A5A00AB2BD4 /* ActivityStore.cpp */; };
+ 23562ED91D342B0000AB2BD4 /* LogMessage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23562ED81D342B0000AB2BD4 /* LogMessage.cpp */; };
+ 23562EDA1D342B0000AB2BD4 /* LogMessage.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23562ED81D342B0000AB2BD4 /* LogMessage.cpp */; };
+ 237821B01D4917D20028B7A1 /* LogFilterExactMatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 237821AE1D4917D20028B7A1 /* LogFilterExactMatch.cpp */; };
+ 23AC04C61D2F41A00072351D /* LogFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AC04C41D2F41A00072351D /* LogFilter.cpp */; };
+ 23AC04C71D2F41A00072351D /* LogFilter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AC04C41D2F41A00072351D /* LogFilter.cpp */; };
+ 23AC04CA1D2F42250072351D /* LogFilterChain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AC04C81D2F42250072351D /* LogFilterChain.cpp */; };
+ 23AC04CB1D2F42250072351D /* LogFilterChain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AC04C81D2F42250072351D /* LogFilterChain.cpp */; };
+ 23AC04CF1D2F58AF0072351D /* LogFilterRegex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AC04CD1D2F58AF0072351D /* LogFilterRegex.cpp */; };
+ 23AC04D01D2F58AF0072351D /* LogFilterRegex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AC04CD1D2F58AF0072351D /* LogFilterRegex.cpp */; };
+ 23AE72E41D25DECF00945BCE /* DarwinLogCollector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AE72E21D25DECF00945BCE /* DarwinLogCollector.cpp */; };
+ 23AE72E51D25DEE100945BCE /* DarwinLogCollector.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23AE72E21D25DECF00945BCE /* DarwinLogCollector.cpp */; };
+ 23D1B0291D497E8B00FF831B /* OsLogger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23D1B0271D497E8B00FF831B /* OsLogger.cpp */; };
+ 23D1B02A1D497E8B00FF831B /* OsLogger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 23D1B0271D497E8B00FF831B /* OsLogger.cpp */; };
264D5D581293835600ED4C01 /* DNBArch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 264D5D571293835600ED4C01 /* DNBArch.cpp */; };
2660D9CE1192280900958FBD /* StringExtractor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2660D9CC1192280900958FBD /* StringExtractor.cpp */; };
266B5ED11460A68200E43F0A /* DNBArchImplARM64.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 266B5ECF1460A68200E43F0A /* DNBArchImplARM64.cpp */; };
/* End PBXBuildFile section */
/* Begin PBXFileReference section */
+ 2307CCCC1D4A5DAE0016ABC0 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
+ 233B4EA51D2DB54300E98261 /* JSON.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSON.cpp; sourceTree = "<group>"; };
+ 233B4EA61D2DB54300E98261 /* JSON.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSON.h; sourceTree = "<group>"; };
+ 233B4EA81D2DB96A00E98261 /* StringConvert.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = StringConvert.cpp; path = ../../../source/Host/common/StringConvert.cpp; sourceTree = "<group>"; };
+ 23562ECF1D34110D00AB2BD4 /* DarwinLogTypes.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DarwinLogTypes.h; sourceTree = "<group>"; };
+ 23562ED01D3424DF00AB2BD4 /* LogMessageOsLog.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LogMessageOsLog.cpp; sourceTree = "<group>"; };
+ 23562ED11D3424DF00AB2BD4 /* LogMessageOsLog.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LogMessageOsLog.h; sourceTree = "<group>"; };
+ 23562ED41D3426DD00AB2BD4 /* ActivityStore.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ActivityStore.h; sourceTree = "<group>"; };
+ 23562ED51D342A5A00AB2BD4 /* ActivityStore.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ActivityStore.cpp; sourceTree = "<group>"; };
+ 23562ED81D342B0000AB2BD4 /* LogMessage.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LogMessage.cpp; sourceTree = "<group>"; };
+ 237821AD1D4917D20028B7A1 /* CMakeLists.txt */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = CMakeLists.txt; sourceTree = "<group>"; };
+ 237821AE1D4917D20028B7A1 /* LogFilterExactMatch.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LogFilterExactMatch.cpp; sourceTree = "<group>"; };
+ 237821AF1D4917D20028B7A1 /* LogFilterExactMatch.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LogFilterExactMatch.h; sourceTree = "<group>"; };
+ 23AC04C41D2F41A00072351D /* LogFilter.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LogFilter.cpp; sourceTree = "<group>"; };
+ 23AC04C51D2F41A00072351D /* LogFilter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LogFilter.h; sourceTree = "<group>"; };
+ 23AC04C81D2F42250072351D /* LogFilterChain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LogFilterChain.cpp; sourceTree = "<group>"; };
+ 23AC04C91D2F42250072351D /* LogFilterChain.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LogFilterChain.h; sourceTree = "<group>"; };
+ 23AC04CC1D2F42F10072351D /* DarwinLogInterfaces.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DarwinLogInterfaces.h; sourceTree = "<group>"; };
+ 23AC04CD1D2F58AF0072351D /* LogFilterRegex.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = LogFilterRegex.cpp; sourceTree = "<group>"; };
+ 23AC04CE1D2F58AF0072351D /* LogFilterRegex.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LogFilterRegex.h; sourceTree = "<group>"; };
+ 23AC04D11D2F60130072351D /* LogMessage.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = LogMessage.h; sourceTree = "<group>"; };
+ 23AE72E21D25DECF00945BCE /* DarwinLogCollector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DarwinLogCollector.cpp; sourceTree = "<group>"; };
+ 23AE72E31D25DECF00945BCE /* DarwinLogCollector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DarwinLogCollector.h; sourceTree = "<group>"; };
+ 23AE72E61D25DEFB00945BCE /* ActivityStreamSPI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ActivityStreamSPI.h; sourceTree = "<group>"; };
+ 23CF6F5E1D28A3760088ADC9 /* DarwinLogEvent.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = DarwinLogEvent.h; sourceTree = "<group>"; };
+ 23D1B0271D497E8B00FF831B /* OsLogger.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = OsLogger.cpp; sourceTree = "<group>"; };
+ 23D1B0281D497E8B00FF831B /* OsLogger.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = OsLogger.h; sourceTree = "<group>"; };
260828DE0CBAF7F400F95054 /* DNBRuntimeAction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DNBRuntimeAction.h; sourceTree = "<group>"; };
260E7331114BFFE600D1DFB3 /* DNBThreadResumeActions.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DNBThreadResumeActions.cpp; sourceTree = "<group>"; };
260E7332114BFFE600D1DFB3 /* DNBThreadResumeActions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DNBThreadResumeActions.h; sourceTree = "<group>"; };
name = Products;
sourceTree = "<group>";
};
+ 23AC04C31D2F3E9A0072351D /* DarwinLog */ = {
+ isa = PBXGroup;
+ children = (
+ 237821AD1D4917D20028B7A1 /* CMakeLists.txt */,
+ 23562ED41D3426DD00AB2BD4 /* ActivityStore.h */,
+ 23562ED51D342A5A00AB2BD4 /* ActivityStore.cpp */,
+ 23AE72E61D25DEFB00945BCE /* ActivityStreamSPI.h */,
+ 23AE72E31D25DECF00945BCE /* DarwinLogCollector.h */,
+ 23AE72E21D25DECF00945BCE /* DarwinLogCollector.cpp */,
+ 23CF6F5E1D28A3760088ADC9 /* DarwinLogEvent.h */,
+ 23AC04CC1D2F42F10072351D /* DarwinLogInterfaces.h */,
+ 23562ECF1D34110D00AB2BD4 /* DarwinLogTypes.h */,
+ 23AC04C51D2F41A00072351D /* LogFilter.h */,
+ 23AC04C41D2F41A00072351D /* LogFilter.cpp */,
+ 23AC04C91D2F42250072351D /* LogFilterChain.h */,
+ 23AC04C81D2F42250072351D /* LogFilterChain.cpp */,
+ 237821AF1D4917D20028B7A1 /* LogFilterExactMatch.h */,
+ 237821AE1D4917D20028B7A1 /* LogFilterExactMatch.cpp */,
+ 23AC04CE1D2F58AF0072351D /* LogFilterRegex.h */,
+ 23AC04CD1D2F58AF0072351D /* LogFilterRegex.cpp */,
+ 23AC04D11D2F60130072351D /* LogMessage.h */,
+ 23562ED81D342B0000AB2BD4 /* LogMessage.cpp */,
+ 23562ED11D3424DF00AB2BD4 /* LogMessageOsLog.h */,
+ 23562ED01D3424DF00AB2BD4 /* LogMessageOsLog.cpp */,
+ );
+ path = DarwinLog;
+ sourceTree = "<group>";
+ };
266B5ECE1460A68200E43F0A /* arm64 */ = {
isa = PBXGroup;
children = (
26C637E20C71334A0024798E /* DNBRegisterInfo.cpp */,
260E7332114BFFE600D1DFB3 /* DNBThreadResumeActions.h */,
260E7331114BFFE600D1DFB3 /* DNBThreadResumeActions.cpp */,
+ 233B4EA61D2DB54300E98261 /* JSON.h */,
+ 233B4EA51D2DB54300E98261 /* JSON.cpp */,
264F679A1B2F9EB200140093 /* JSONGenerator.h */,
AF67AC000D34604D0022D128 /* PseudoTerminal.h */,
AF67ABFF0D34604D0022D128 /* PseudoTerminal.cpp */,
26C637FE0C71334A0024798E /* PThreadEvent.cpp */,
26C638000C71334A0024798E /* PThreadMutex.h */,
2672DBEE0EEF446700E92059 /* PThreadMutex.cpp */,
+ 233B4EA81D2DB96A00E98261 /* StringConvert.cpp */,
26C638020C71334A0024798E /* SysSignal.h */,
26C638010C71334A0024798E /* SysSignal.cpp */,
26C638060C71334A0024798E /* TTYState.h */,
26C637E60C71334A0024798E /* MacOSX */ = {
isa = PBXGroup;
children = (
- AF0934BA18E12B92005A11FD /* Genealogy.h */,
- AF0934BB18E12B92005A11FD /* GenealogySPI.h */,
+ 23AC04C31D2F3E9A0072351D /* DarwinLog */,
2695DD920D3EBFF6007E4CA2 /* CFBundle.h */,
2695DD910D3EBFF6007E4CA2 /* CFBundle.cpp */,
2695DD9A0D3EC160007E4CA2 /* CFString.h */,
2695DD9B0D3EC160007E4CA2 /* CFString.cpp */,
26C637E70C71334A0024798E /* CFUtils.h */,
+ 2307CCCC1D4A5DAE0016ABC0 /* CMakeLists.txt */,
2675D41C0CCEB6CF000F49AF /* arm */,
266B5ECE1460A68200E43F0A /* arm64 */,
26C637E90C71334A0024798E /* i386 */,
4971AE7113D10F4F00649E37 /* HasAVX.s */,
26C637E80C71334A0024798E /* dbgnub-mig.defs */,
AFEC3363194A8B0B00FF05C6 /* Genealogy.cpp */,
+ AF0934BA18E12B92005A11FD /* Genealogy.h */,
+ AF0934BB18E12B92005A11FD /* GenealogySPI.h */,
26C637EF0C71334A0024798E /* MachException.h */,
26C637EE0C71334A0024798E /* MachException.cpp */,
26C637F10C71334A0024798E /* MachProcess.h */,
26C637F80C71334A0024798E /* MachVMRegion.cpp */,
26B67DE00EE9BC30006C8BC0 /* MachTask.h */,
26B67DE10EE9BC30006C8BC0 /* MachTask.mm */,
+ 23D1B0281D497E8B00FF831B /* OsLogger.h */,
+ 23D1B0271D497E8B00FF831B /* OsLogger.cpp */,
9457ECF61419864100DFE7D8 /* stack_logging.h */,
);
path = MacOSX;
26CE05A9115C36250022F371 /* debugserver.cpp in Sources */,
26CE05AA115C36260022F371 /* RNBContext.cpp in Sources */,
26CE05AB115C36270022F371 /* RNBServices.cpp in Sources */,
+ 23D1B0291D497E8B00FF831B /* OsLogger.cpp in Sources */,
26CE05AC115C36280022F371 /* RNBSocket.cpp in Sources */,
26CE05AD115C36280022F371 /* RNBRemote.cpp in Sources */,
26CE05AE115C36320022F371 /* dbgnub-mig.defs in Sources */,
26CE05B0115C36340022F371 /* MachException.cpp in Sources */,
26CE05B1115C36350022F371 /* MachProcess.mm in Sources */,
26CE05B2115C36360022F371 /* MachThread.cpp in Sources */,
+ 233B4EA71D2DB54300E98261 /* JSON.cpp in Sources */,
26CE05B3115C36370022F371 /* MachThreadList.cpp in Sources */,
26CE05B4115C36380022F371 /* MachVMMemory.cpp in Sources */,
26CE05B5115C36380022F371 /* MachVMRegion.cpp in Sources */,
26CE05B6115C36390022F371 /* MachTask.mm in Sources */,
26CE05B7115C363B0022F371 /* DNB.cpp in Sources */,
AFEC3364194A8B0B00FF05C6 /* Genealogy.cpp in Sources */,
+ 23AC04CF1D2F58AF0072351D /* LogFilterRegex.cpp in Sources */,
+ 233B4EA91D2DB96A00E98261 /* StringConvert.cpp in Sources */,
+ 23562ED21D3424DF00AB2BD4 /* LogMessageOsLog.cpp in Sources */,
26CE05B8115C363C0022F371 /* DNBBreakpoint.cpp in Sources */,
26CE05B9115C363D0022F371 /* DNBDataRef.cpp in Sources */,
+ 23AC04CA1D2F42250072351D /* LogFilterChain.cpp in Sources */,
+ 23562ED61D342A5A00AB2BD4 /* ActivityStore.cpp in Sources */,
26CE05BA115C363E0022F371 /* DNBLog.cpp in Sources */,
+ 23AC04C61D2F41A00072351D /* LogFilter.cpp in Sources */,
26CE05BB115C363F0022F371 /* DNBRegisterInfo.cpp in Sources */,
26CE05BC115C36420022F371 /* PThreadEvent.cpp in Sources */,
26CE05BD115C36430022F371 /* PThreadMutex.cpp in Sources */,
26CE05BE115C36440022F371 /* SysSignal.cpp in Sources */,
+ 23AE72E41D25DECF00945BCE /* DarwinLogCollector.cpp in Sources */,
26CE05BF115C364D0022F371 /* DNBArchImplX86_64.cpp in Sources */,
26CE05C0115C364F0022F371 /* DNBArchImplI386.cpp in Sources */,
26CE05C1115C36510022F371 /* DNBArchImpl.cpp in Sources */,
26CE05C2115C36550022F371 /* DNBArchImpl.cpp in Sources */,
- 26CE05C3115C36580022F371 /* CFString.cpp in Sources */,
26CE05C5115C36590022F371 /* CFBundle.cpp in Sources */,
+ 26CE05C3115C36580022F371 /* CFString.cpp in Sources */,
+ 26CE05C4115C36590022F371 /* CFData.cpp in Sources */,
+ 23562ED91D342B0000AB2BD4 /* LogMessage.cpp in Sources */,
26CE05F1115C387C0022F371 /* PseudoTerminal.cpp in Sources */,
2660D9CE1192280900958FBD /* StringExtractor.cpp in Sources */,
264D5D581293835600ED4C01 /* DNBArch.cpp in Sources */,
4971AE7213D10F4F00649E37 /* HasAVX.s in Sources */,
+ 237821B01D4917D20028B7A1 /* LogFilterExactMatch.cpp in Sources */,
266B5ED11460A68200E43F0A /* DNBArchImplARM64.cpp in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
456F67461AD46CE9002850C2 /* DNBError.cpp in Sources */,
456F67471AD46CE9002850C2 /* DNBThreadResumeActions.cpp in Sources */,
456F67481AD46CE9002850C2 /* debugserver.cpp in Sources */,
+ 23043C9D1D35DBEC00FC25CA /* JSON.cpp in Sources */,
456F67491AD46CE9002850C2 /* RNBContext.cpp in Sources */,
+ 23D1B02A1D497E8B00FF831B /* OsLogger.cpp in Sources */,
456F674A1AD46CE9002850C2 /* RNBServices.cpp in Sources */,
456F674B1AD46CE9002850C2 /* RNBSocket.cpp in Sources */,
456F674C1AD46CE9002850C2 /* RNBRemote.cpp in Sources */,
456F674D1AD46CE9002850C2 /* dbgnub-mig.defs in Sources */,
456F674E1AD46CE9002850C2 /* MachException.cpp in Sources */,
456F674F1AD46CE9002850C2 /* MachProcess.mm in Sources */,
+ 2307CCCB1D4A5D630016ABC0 /* LogFilterExactMatch.cpp in Sources */,
456F67501AD46CE9002850C2 /* MachThread.cpp in Sources */,
456F67511AD46CE9002850C2 /* MachThreadList.cpp in Sources */,
456F67521AD46CE9002850C2 /* MachVMMemory.cpp in Sources */,
456F67531AD46CE9002850C2 /* MachVMRegion.cpp in Sources */,
+ 23562ED71D342A5A00AB2BD4 /* ActivityStore.cpp in Sources */,
456F67541AD46CE9002850C2 /* MachTask.mm in Sources */,
456F67551AD46CE9002850C2 /* DNB.cpp in Sources */,
456F67561AD46CE9002850C2 /* Genealogy.cpp in Sources */,
456F67571AD46CE9002850C2 /* DNBBreakpoint.cpp in Sources */,
456F67581AD46CE9002850C2 /* DNBDataRef.cpp in Sources */,
456F67591AD46CE9002850C2 /* DNBLog.cpp in Sources */,
+ 23562ED31D3424DF00AB2BD4 /* LogMessageOsLog.cpp in Sources */,
456F675A1AD46CE9002850C2 /* DNBRegisterInfo.cpp in Sources */,
456F675B1AD46CE9002850C2 /* PThreadEvent.cpp in Sources */,
456F675C1AD46CE9002850C2 /* PThreadMutex.cpp in Sources */,
456F675D1AD46CE9002850C2 /* SysSignal.cpp in Sources */,
+ 23AE72E51D25DEE100945BCE /* DarwinLogCollector.cpp in Sources */,
456F675E1AD46CE9002850C2 /* DNBArchImplX86_64.cpp in Sources */,
+ 23562EDA1D342B0000AB2BD4 /* LogMessage.cpp in Sources */,
456F675F1AD46CE9002850C2 /* DNBArchImplI386.cpp in Sources */,
456F67601AD46CE9002850C2 /* DNBArchImpl.cpp in Sources */,
+ 23AC04C71D2F41A00072351D /* LogFilter.cpp in Sources */,
+ 23043C9E1D35DBFA00FC25CA /* StringConvert.cpp in Sources */,
456F67611AD46CE9002850C2 /* DNBArchImpl.cpp in Sources */,
456F67621AD46CE9002850C2 /* CFString.cpp in Sources */,
+ 456F67631AD46CE9002850C2 /* CFData.cpp in Sources */,
+ 23AC04CB1D2F42250072351D /* LogFilterChain.cpp in Sources */,
456F67641AD46CE9002850C2 /* CFBundle.cpp in Sources */,
456F67651AD46CE9002850C2 /* PseudoTerminal.cpp in Sources */,
456F67661AD46CE9002850C2 /* StringExtractor.cpp in Sources */,
456F67671AD46CE9002850C2 /* DNBArch.cpp in Sources */,
456F67681AD46CE9002850C2 /* HasAVX.s in Sources */,
+ 23AC04D01D2F58AF0072351D /* LogFilterRegex.cpp in Sources */,
456F67691AD46CE9002850C2 /* DNBArchImplARM64.cpp in Sources */,
);
runOnlyForDeploymentPostprocessing = 0;
"LLDB_COMPRESSION_CFLAGS[sdk=macosx10.11]" = "-DHAVE_LIBCOMPRESSION=1";
LLDB_COMPRESSION_LDFLAGS = "";
"LLDB_COMPRESSION_LDFLAGS[sdk=macosx10.11]" = "-weak-lcompression";
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 0;
LLDB_ZLIB_CFLAGS = "-DHAVE_LIBZ=1";
LLDB_ZLIB_LDFLAGS = "-lz";
MACOSX_DEPLOYMENT_TARGET = 10.10;
"LLDB_COMPRESSION_CFLAGS[sdk=macosx10.11]" = "-DHAVE_LIBCOMPRESSION=1";
LLDB_COMPRESSION_LDFLAGS = "";
"LLDB_COMPRESSION_LDFLAGS[sdk=macosx10.11]" = "-weak-lcompression";
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 0;
LLDB_ZLIB_CFLAGS = "-DHAVE_LIBZ=1";
LLDB_ZLIB_LDFLAGS = "-lz";
MACOSX_DEPLOYMENT_TARGET = 10.10;
"LLDB_COMPRESSION_CFLAGS[sdk=macosx10.11]" = "-DHAVE_LIBCOMPRESSION=1";
LLDB_COMPRESSION_LDFLAGS = "";
"LLDB_COMPRESSION_LDFLAGS[sdk=macosx10.11]" = "-weak-lcompression";
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 1;
LLDB_ZLIB_CFLAGS = "-DHAVE_LIBZ=1";
LLDB_ZLIB_LDFLAGS = "-lz";
MACOSX_DEPLOYMENT_TARGET = 10.10;
"-DDT_VARIANT_$(DT_VARIANT)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
"-DDT_VARIANT_$(DT_VARIANT)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
"-DDT_VARIANT_$(DT_VARIANT)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
"-Wparentheses",
"$(LLDB_ENERGY_CFLAGS)",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
+ OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)";
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
"OTHER_LDFLAGS[sdk=iphoneos*][arch=*]" = (
"-framework",
GCC_WARN_UNINITIALIZED_AUTOS = YES;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 0;
MACOSX_DEPLOYMENT_TARGET = 10.10;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx.internal;
"-DDT_VARIANT_$(DT_VARIANT)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
"OTHER_LDFLAGS[sdk=iphoneos*][arch=*]" = (
GCC_WARN_UNINITIALIZED_AUTOS = YES;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 0;
MACOSX_DEPLOYMENT_TARGET = 10.10;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx.internal;
"$(LLDB_ENERGY_CFLAGS)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
"OTHER_LDFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"$(LLDB_ENERGY_CFLAGS)",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"-DDEBUGSERVER_PROGRAM_SYMBOL=debugserver_nonui",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
"OTHER_LDFLAGS[sdk=iphoneos*][arch=*]" = (
GCC_WARN_UNINITIALIZED_AUTOS = YES;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 0;
MACOSX_DEPLOYMENT_TARGET = 10.10;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx.internal;
"-DDT_VARIANT_$(DT_VARIANT)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
OTHER_LDFLAGS = "";
GCC_WARN_UNINITIALIZED_AUTOS = YES;
GCC_WARN_UNUSED_FUNCTION = YES;
GCC_WARN_UNUSED_VARIABLE = YES;
+ LLDB_OS_LOG_CFLAGS = "-DLLDB_USE_OS_LOG=$(LLDB_USE_OS_LOG)";
+ LLDB_USE_OS_LOG = 0;
MACOSX_DEPLOYMENT_TARGET = 10.10;
ONLY_ACTIVE_ARCH = YES;
SDKROOT = macosx.internal;
"-DDT_VARIANT_$(DT_VARIANT)",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CFLAGS[sdk=iphoneos*][arch=*]" = (
"-Wparentheses",
"-DOS_OBJECT_USE_OBJC=0",
"$(LLDB_COMPRESSION_CFLAGS)",
"$(LLDB_ZLIB_CFLAGS)",
+ "$(LLDB_OS_LOG_CFLAGS)",
);
"OTHER_CPLUSPLUSFLAGS[sdk=iphoneos*][arch=*]" = "$(OTHER_CFLAGS)";
"OTHER_LDFLAGS[sdk=iphoneos*][arch=*]" = (
include_directories(${CMAKE_CURRENT_BINARY_DIR}/..)
include_directories(${LLDB_SOURCE_DIR}/source)
+include_directories(MacOSX/DarwinLog)
if (CMAKE_SYSTEM_NAME MATCHES "Darwin")
include_directories(MacOSX)
DNBLog.cpp
DNBRegisterInfo.cpp
DNBThreadResumeActions.cpp
+ JSON.cpp
+ # JSON reader depends on the following LLDB-common files
+ ${LLDB_SOURCE_DIR}/source/Host/common/StringConvert.cpp
+ ${LLDB_SOURCE_DIR}/source/Utility/StringExtractor.cpp
+ # end JSON reader dependencies
libdebugserver.cpp
PseudoTerminal.cpp
PThreadEvent.cpp
#endif
#endif
+#include "MacOSX/DarwinLog/DarwinLogCollector.h"
#include "MacOSX/MachProcess.h"
#include "MacOSX/MachTask.h"
#include "MacOSX/Genealogy.h"
return 0;
}
+DarwinLogEventVector
+DNBProcessGetAvailableDarwinLogEvents(nub_process_t pid)
+{
+ return DarwinLogCollector::GetEventsForProcess(pid);
+}
+
nub_size_t
DNBProcessGetStopCount (nub_process_t pid)
{
#ifndef __DNB_h__
#define __DNB_h__
+#include "MacOSX/DarwinLog/DarwinLogEvent.h"
#include "MacOSX/Genealogy.h"
#include "MacOSX/ThreadInfo.h"
#include "JSONGenerator.h"
int DNBProcessMemoryRegionInfo (nub_process_t pid, nub_addr_t addr, DNBRegionInfo *region_info) DNB_EXPORT;
std::string DNBProcessGetProfileData (nub_process_t pid, DNBProfileDataScanType scanType) DNB_EXPORT;
nub_bool_t DNBProcessSetEnableAsyncProfiling (nub_process_t pid, nub_bool_t enable, uint64_t interval_usec, DNBProfileDataScanType scan_type) DNB_EXPORT;
+DarwinLogEventVector DNBProcessGetAvailableDarwinLogEvents(nub_process_t pid);
+
//----------------------------------------------------------------------
// Process status
#define LOG_WATCHPOINTS (1u << 11)
#define LOG_STEP (1u << 12)
#define LOG_TASK (1u << 13)
+#define LOG_DARWIN_LOG (1u << 14)
#define LOG_LO_USER (1u << 16)
#define LOG_HI_USER (1u << 31)
#define LOG_ALL 0xFFFFFFFFu
--- /dev/null
+//===--------------------- JSON.cpp -----------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "JSON.h"
+
+// C includes
+#include <assert.h>
+#include <limits.h>
+
+// C++ includes
+#include <iomanip>
+#include <sstream>
+#include "lldb/Host/StringConvert.h"
+
+using namespace lldb_private;
+
+std::string
+JSONString::json_string_quote_metachars (const std::string &s)
+{
+ if (s.find('"') == std::string::npos)
+ return s;
+
+ std::string output;
+ const size_t s_size = s.size();
+ const char *s_chars = s.c_str();
+ for (size_t i = 0; i < s_size; i++)
+ {
+ unsigned char ch = *(s_chars + i);
+ if (ch == '"')
+ {
+ output.push_back ('\\');
+ }
+ output.push_back (ch);
+ }
+ return output;
+}
+
+JSONString::JSONString () :
+ JSONValue(JSONValue::Kind::String),
+ m_data()
+{
+}
+
+JSONString::JSONString (const char* s) :
+ JSONValue(JSONValue::Kind::String),
+ m_data(s ? s : "")
+{
+}
+
+JSONString::JSONString (const std::string& s) :
+ JSONValue(JSONValue::Kind::String),
+ m_data(s)
+{
+}
+
+void
+JSONString::Write (std::ostream& s)
+{
+ s << "\"" << json_string_quote_metachars(m_data).c_str() <<"\"";
+}
+
+uint64_t
+JSONNumber::GetAsUnsigned() const
+{
+ switch (m_data_type)
+ {
+ case DataType::Unsigned:
+ return m_data.m_unsigned;
+ case DataType::Signed:
+ return (uint64_t)m_data.m_signed;
+ case DataType::Double:
+ return (uint64_t)m_data.m_double;
+ }
+ assert("Unhandled data type");
+}
+
+int64_t
+JSONNumber::GetAsSigned() const
+{
+ switch (m_data_type)
+ {
+ case DataType::Unsigned:
+ return (int64_t)m_data.m_unsigned;
+ case DataType::Signed:
+ return m_data.m_signed;
+ case DataType::Double:
+ return (int64_t)m_data.m_double;
+ }
+ assert("Unhandled data type");
+}
+
+double
+JSONNumber::GetAsDouble() const
+{
+ switch (m_data_type)
+ {
+ case DataType::Unsigned:
+ return (double)m_data.m_unsigned;
+ case DataType::Signed:
+ return (double)m_data.m_signed;
+ case DataType::Double:
+ return m_data.m_double;
+ }
+ assert("Unhandled data type");
+}
+
+void
+JSONNumber::Write (std::ostream& s)
+{
+ switch (m_data_type)
+ {
+ case DataType::Unsigned:
+ s << m_data.m_unsigned;
+ break;
+ case DataType::Signed:
+ s << m_data.m_signed;
+ break;
+ case DataType::Double:
+ // Set max precision to emulate %g.
+ s << std::setprecision(std::numeric_limits<double>::digits10 + 1);
+ s << m_data.m_double;
+ break;
+ }
+}
+
+JSONTrue::JSONTrue () :
+ JSONValue(JSONValue::Kind::True)
+{
+}
+
+void
+JSONTrue::Write(std::ostream& s)
+{
+ s << "true";
+}
+
+JSONFalse::JSONFalse () :
+ JSONValue(JSONValue::Kind::False)
+{
+}
+
+void
+JSONFalse::Write(std::ostream& s)
+{
+ s << "false";
+}
+
+JSONNull::JSONNull () :
+ JSONValue(JSONValue::Kind::Null)
+{
+}
+
+void
+JSONNull::Write(std::ostream& s)
+{
+ s << "null";
+}
+
+JSONObject::JSONObject () :
+ JSONValue(JSONValue::Kind::Object)
+{
+}
+
+void
+JSONObject::Write (std::ostream& s)
+{
+ bool first = true;
+ s << '{';
+ auto iter = m_elements.begin(), end = m_elements.end();
+ for (;iter != end; iter++)
+ {
+ if (first)
+ first = false;
+ else
+ s << ',';
+ JSONString key(iter->first);
+ JSONValue::SP value(iter->second);
+ key.Write(s);
+ s << ':';
+ value->Write(s);
+ }
+ s << '}';
+}
+
+bool
+JSONObject::SetObject (const std::string& key,
+ JSONValue::SP value)
+{
+ if (key.empty() || nullptr == value.get())
+ return false;
+ m_elements[key] = value;
+ return true;
+}
+
+JSONValue::SP
+JSONObject::GetObject (const std::string& key) const
+{
+ auto iter = m_elements.find(key), end = m_elements.end();
+ if (iter == end)
+ return JSONValue::SP();
+ return iter->second;
+}
+
+bool
+JSONObject::GetObjectAsBool (const std::string& key, bool& value) const
+{
+ auto value_sp = GetObject(key);
+ if (!value_sp)
+ {
+ // The given key doesn't exist, so we have no value.
+ return false;
+ }
+
+ if (JSONTrue::classof(value_sp.get()))
+ {
+ // We have the value, and it is true.
+ value = true;
+ return true;
+ }
+ else if (JSONFalse::classof(value_sp.get()))
+ {
+ // We have the value, and it is false.
+ value = false;
+ return true;
+ }
+ else
+ {
+ // We don't have a valid bool value for the given key.
+ return false;
+ }
+}
+
+bool
+JSONObject::GetObjectAsString (const std::string& key, std::string& value) const
+{
+ auto value_sp = GetObject(key);
+ if (!value_sp)
+ {
+ // The given key doesn't exist, so we have no value.
+ return false;
+ }
+
+ if (!JSONString::classof(value_sp.get()))
+ return false;
+
+ value = static_cast<JSONString*>(value_sp.get())->GetData();
+ return true;
+}
+
+JSONArray::JSONArray () :
+ JSONValue(JSONValue::Kind::Array)
+{
+}
+
+void
+JSONArray::Write (std::ostream& s)
+{
+ bool first = true;
+ s << '[';
+ auto iter = m_elements.begin(), end = m_elements.end();
+ for (;iter != end; iter++)
+ {
+ if (first)
+ first = false;
+ else
+ s << ',';
+ (*iter)->Write(s);
+ }
+ s << ']';
+}
+
+bool
+JSONArray::SetObject (Index i,
+ JSONValue::SP value)
+{
+ if (value.get() == nullptr)
+ return false;
+ if (i < m_elements.size())
+ {
+ m_elements[i] = value;
+ return true;
+ }
+ if (i == m_elements.size())
+ {
+ m_elements.push_back(value);
+ return true;
+ }
+ return false;
+}
+
+bool
+JSONArray::AppendObject (JSONValue::SP value)
+{
+ if (value.get() == nullptr)
+ return false;
+ m_elements.push_back(value);
+ return true;
+}
+
+JSONValue::SP
+JSONArray::GetObject (Index i)
+{
+ if (i < m_elements.size())
+ return m_elements[i];
+ return JSONValue::SP();
+}
+
+JSONArray::Size
+JSONArray::GetNumElements ()
+{
+ return m_elements.size();
+}
+
+
+JSONParser::JSONParser (const char *cstr) :
+ StringExtractor(cstr)
+{
+}
+
+JSONParser::Token
+JSONParser::GetToken (std::string &value)
+{
+ std::ostringstream error;
+
+ value.clear();
+ SkipSpaces ();
+ const uint64_t start_index = m_index;
+ const char ch = GetChar();
+ switch (ch)
+ {
+ case '{': return Token::ObjectStart;
+ case '}': return Token::ObjectEnd;
+ case '[': return Token::ArrayStart;
+ case ']': return Token::ArrayEnd;
+ case ',': return Token::Comma;
+ case ':': return Token::Colon;
+ case '\0': return Token::EndOfFile;
+ case 't':
+ if (GetChar() == 'r')
+ if (GetChar() == 'u')
+ if (GetChar() == 'e')
+ return Token::True;
+ break;
+
+ case 'f':
+ if (GetChar() == 'a')
+ if (GetChar() == 'l')
+ if (GetChar() == 's')
+ if (GetChar() == 'e')
+ return Token::False;
+ break;
+
+ case 'n':
+ if (GetChar() == 'u')
+ if (GetChar() == 'l')
+ if (GetChar() == 'l')
+ return Token::Null;
+ break;
+
+ case '"':
+ {
+ while (1)
+ {
+ bool was_escaped = false;
+ int escaped_ch = GetEscapedChar(was_escaped);
+ if (escaped_ch == -1)
+ {
+ error << "error: an error occurred getting a character from offset " <<start_index;
+ value = std::move(error.str());
+ return Token::Error;
+
+ }
+ else
+ {
+ const bool is_end_quote = escaped_ch == '"';
+ const bool is_null = escaped_ch == 0;
+ if (was_escaped || (!is_end_quote && !is_null))
+ {
+ if (CHAR_MIN <= escaped_ch && escaped_ch <= CHAR_MAX)
+ {
+ value.append(1, (char)escaped_ch);
+ }
+ else
+ {
+ error << "error: wide character support is needed for unicode character 0x" << std::setprecision(4) << std::hex << escaped_ch;
+ error << " at offset " << start_index;
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ }
+ else if (is_end_quote)
+ {
+ return Token::String;
+ }
+ else if (is_null)
+ {
+ value = "error: missing end quote for string";
+ return Token::Error;
+ }
+ }
+ }
+ }
+ break;
+
+ case '-':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ {
+ bool done = false;
+ bool got_decimal_point = false;
+ uint64_t exp_index = 0;
+ bool got_int_digits = (ch >= '0') && (ch <= '9');
+ bool got_frac_digits = false;
+ bool got_exp_digits = false;
+ while (!done)
+ {
+ const char next_ch = PeekChar();
+ switch (next_ch)
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (exp_index != 0)
+ {
+ got_exp_digits = true;
+ }
+ else if (got_decimal_point)
+ {
+ got_frac_digits = true;
+ }
+ else
+ {
+ got_int_digits = true;
+ }
+ ++m_index; // Skip this character
+ break;
+
+ case '.':
+ if (got_decimal_point)
+ {
+ error << "error: extra decimal point found at offset " << start_index;
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ else
+ {
+ got_decimal_point = true;
+ ++m_index; // Skip this character
+ }
+ break;
+
+ case 'e':
+ case 'E':
+ if (exp_index != 0)
+ {
+ error << "error: extra exponent character found at offset " << start_index;
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ else
+ {
+ exp_index = m_index;
+ ++m_index; // Skip this character
+ }
+ break;
+
+ case '+':
+ case '-':
+ // The '+' and '-' can only come after an exponent character...
+ if (exp_index == m_index - 1)
+ {
+ ++m_index; // Skip the exponent sign character
+ }
+ else
+ {
+ error << "error: unexpected " << next_ch << " character at offset " << start_index;
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ break;
+
+ default:
+ done = true;
+ break;
+ }
+ }
+
+ if (m_index > start_index)
+ {
+ value = m_packet.substr(start_index, m_index - start_index);
+ if (got_decimal_point)
+ {
+ if (exp_index != 0)
+ {
+ // We have an exponent, make sure we got exponent digits
+ if (got_exp_digits)
+ {
+ return Token::Float;
+ }
+ else
+ {
+ error << "error: got exponent character but no exponent digits at offset in float value \"" << value.c_str() << "\"";
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ }
+ else
+ {
+ // No exponent, but we need at least one decimal after the decimal point
+ if (got_frac_digits)
+ {
+ return Token::Float;
+ }
+ else
+ {
+ error << "error: no digits after decimal point \"" << value.c_str() << "\"";
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ }
+ }
+ else
+ {
+ // No decimal point
+ if (got_int_digits)
+ {
+ // We need at least some integer digits to make an integer
+ return Token::Integer;
+ }
+ else
+ {
+ error << "error: no digits negate sign \"" << value.c_str() << "\"";
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ }
+ }
+ else
+ {
+ error << "error: invalid number found at offset " << start_index;
+ value = std::move(error.str());
+ return Token::Error;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ error << "error: failed to parse token at offset " << start_index << " (around character '" << ch << "')";
+ value = std::move(error.str());
+ return Token::Error;
+}
+
+int
+JSONParser::GetEscapedChar(bool &was_escaped)
+{
+ was_escaped = false;
+ const char ch = GetChar();
+ if (ch == '\\')
+ {
+ was_escaped = true;
+ const char ch2 = GetChar();
+ switch (ch2)
+ {
+ case '"':
+ case '\\':
+ case '/':
+ default:
+ break;
+
+ case 'b': return '\b';
+ case 'f': return '\f';
+ case 'n': return '\n';
+ case 'r': return '\r';
+ case 't': return '\t';
+ case 'u':
+ {
+ const int hi_byte = DecodeHexU8();
+ const int lo_byte = DecodeHexU8();
+ if (hi_byte >=0 && lo_byte >= 0)
+ return hi_byte << 8 | lo_byte;
+ return -1;
+ }
+ break;
+ }
+ return ch2;
+ }
+ return ch;
+}
+
+JSONValue::SP
+JSONParser::ParseJSONObject ()
+{
+ // The "JSONParser::Token::ObjectStart" token should have already been consumed
+ // by the time this function is called
+ std::unique_ptr<JSONObject> dict_up(new JSONObject());
+
+ std::string value;
+ std::string key;
+ while (1)
+ {
+ JSONParser::Token token = GetToken(value);
+
+ if (token == JSONParser::Token::String)
+ {
+ key.swap(value);
+ token = GetToken(value);
+ if (token == JSONParser::Token::Colon)
+ {
+ JSONValue::SP value_sp = ParseJSONValue();
+ if (value_sp)
+ dict_up->SetObject(key, value_sp);
+ else
+ break;
+ }
+ }
+ else if (token == JSONParser::Token::ObjectEnd)
+ {
+ return JSONValue::SP(dict_up.release());
+ }
+ else if (token == JSONParser::Token::Comma)
+ {
+ continue;
+ }
+ else
+ {
+ break;
+ }
+ }
+ return JSONValue::SP();
+}
+
+JSONValue::SP
+JSONParser::ParseJSONArray ()
+{
+ // The "JSONParser::Token::ObjectStart" token should have already been consumed
+ // by the time this function is called
+ std::unique_ptr<JSONArray> array_up(new JSONArray());
+
+ std::string value;
+ std::string key;
+ while (1)
+ {
+ JSONValue::SP value_sp = ParseJSONValue();
+ if (value_sp)
+ array_up->AppendObject(value_sp);
+ else
+ break;
+
+ JSONParser::Token token = GetToken(value);
+ if (token == JSONParser::Token::Comma)
+ {
+ continue;
+ }
+ else if (token == JSONParser::Token::ArrayEnd)
+ {
+ return JSONValue::SP(array_up.release());
+ }
+ else
+ {
+ break;
+ }
+ }
+ return JSONValue::SP();
+}
+
+JSONValue::SP
+JSONParser::ParseJSONValue ()
+{
+ std::string value;
+ const JSONParser::Token token = GetToken(value);
+ switch (token)
+ {
+ case JSONParser::Token::ObjectStart:
+ return ParseJSONObject();
+
+ case JSONParser::Token::ArrayStart:
+ return ParseJSONArray();
+
+ case JSONParser::Token::Integer:
+ {
+ if (value.front() == '-')
+ {
+ bool success = false;
+ int64_t sval = StringConvert::ToSInt64(value.c_str(), 0, 0, &success);
+ if (success)
+ return JSONValue::SP(new JSONNumber(sval));
+ }
+ else
+ {
+ bool success = false;
+ uint64_t uval = StringConvert::ToUInt64(value.c_str(), 0, 0, &success);
+ if (success)
+ return JSONValue::SP(new JSONNumber(uval));
+ }
+ }
+ break;
+
+ case JSONParser::Token::Float:
+ {
+ bool success = false;
+ double val = StringConvert::ToDouble(value.c_str(), 0.0, &success);
+ if (success)
+ return JSONValue::SP(new JSONNumber(val));
+ }
+ break;
+
+ case JSONParser::Token::String:
+ return JSONValue::SP(new JSONString(value));
+
+ case JSONParser::Token::True:
+ return JSONValue::SP(new JSONTrue());
+
+ case JSONParser::Token::False:
+ return JSONValue::SP(new JSONFalse());
+
+ case JSONParser::Token::Null:
+ return JSONValue::SP(new JSONNull());
+
+ default:
+ break;
+ }
+ return JSONValue::SP();
+
+}
--- /dev/null
+//===---------------------JSON.h --------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef utility_JSON_h_
+#define utility_JSON_h_
+
+// This cross-project usage is fine as StringExtractor.h is entirely
+// self-contained.
+#include "lldb/Utility/StringExtractor.h"
+
+// C includes
+#include <inttypes.h>
+#include <stdint.h>
+
+// C++ includes
+#include <map>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <vector>
+
+class JSONValue
+{
+public:
+ virtual void
+ Write (std::ostream& s) = 0;
+
+ typedef std::shared_ptr<JSONValue> SP;
+
+ enum class Kind
+ {
+ String,
+ Number,
+ True,
+ False,
+ Null,
+ Object,
+ Array
+ };
+
+ JSONValue (Kind k) :
+ m_kind(k)
+ {}
+
+ Kind
+ GetKind() const
+ {
+ return m_kind;
+ }
+
+ virtual
+ ~JSONValue () = default;
+
+private:
+ const Kind m_kind;
+};
+
+class JSONString : public JSONValue
+{
+public:
+ JSONString ();
+ JSONString (const char* s);
+ JSONString (const std::string& s);
+
+ JSONString (const JSONString& s) = delete;
+ JSONString&
+ operator = (const JSONString& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ typedef std::shared_ptr<JSONString> SP;
+
+ std::string
+ GetData () { return m_data; }
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::String;
+ }
+
+ ~JSONString() override = default;
+
+private:
+
+ static std::string
+ json_string_quote_metachars (const std::string&);
+
+ std::string m_data;
+};
+
+class JSONNumber : public JSONValue
+{
+public:
+ typedef std::shared_ptr<JSONNumber> SP;
+
+ // We cretae a constructor for all integer and floating point type with using templates and
+ // SFINAE to avoid having ambiguous overloads because of the implicit type promotion. If we
+ // would have constructors only with int64_t, uint64_t and double types then constructing a
+ // JSONNumber from an int32_t (or any other similar type) would fail to compile.
+
+ template <typename T,
+ typename std::enable_if<std::is_integral<T>::value &&
+ std::is_unsigned<T>::value>::type* = nullptr>
+ explicit JSONNumber (T u) :
+ JSONValue(JSONValue::Kind::Number),
+ m_data_type(DataType::Unsigned)
+ {
+ m_data.m_unsigned = u;
+ }
+
+ template <typename T,
+ typename std::enable_if<std::is_integral<T>::value &&
+ std::is_signed<T>::value>::type* = nullptr>
+ explicit JSONNumber (T s) :
+ JSONValue(JSONValue::Kind::Number),
+ m_data_type(DataType::Signed)
+ {
+ m_data.m_signed = s;
+ }
+
+ template <typename T,
+ typename std::enable_if<std::is_floating_point<T>::value>::type* = nullptr>
+ explicit JSONNumber (T d) :
+ JSONValue(JSONValue::Kind::Number),
+ m_data_type(DataType::Double)
+ {
+ m_data.m_double = d;
+ }
+
+ ~JSONNumber() override = default;
+
+ JSONNumber (const JSONNumber& s) = delete;
+ JSONNumber&
+ operator = (const JSONNumber& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ uint64_t
+ GetAsUnsigned() const;
+
+ int64_t
+ GetAsSigned() const;
+
+ double
+ GetAsDouble() const;
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::Number;
+ }
+
+private:
+ enum class DataType : uint8_t
+ {
+ Unsigned,
+ Signed,
+ Double
+ } m_data_type;
+
+ union
+ {
+ uint64_t m_unsigned;
+ int64_t m_signed;
+ double m_double;
+ } m_data;
+};
+
+class JSONTrue : public JSONValue
+{
+public:
+ JSONTrue ();
+
+ JSONTrue (const JSONTrue& s) = delete;
+ JSONTrue&
+ operator = (const JSONTrue& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ typedef std::shared_ptr<JSONTrue> SP;
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::True;
+ }
+
+ ~JSONTrue() override = default;
+};
+
+class JSONFalse : public JSONValue
+{
+public:
+ JSONFalse ();
+
+ JSONFalse (const JSONFalse& s) = delete;
+ JSONFalse&
+ operator = (const JSONFalse& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ typedef std::shared_ptr<JSONFalse> SP;
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::False;
+ }
+
+ ~JSONFalse() override = default;
+};
+
+class JSONNull : public JSONValue
+{
+public:
+ JSONNull ();
+
+ JSONNull (const JSONNull& s) = delete;
+ JSONNull&
+ operator = (const JSONNull& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ typedef std::shared_ptr<JSONNull> SP;
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::Null;
+ }
+
+ ~JSONNull() override = default;
+};
+
+class JSONObject : public JSONValue
+{
+public:
+ JSONObject ();
+
+ JSONObject (const JSONObject& s) = delete;
+ JSONObject&
+ operator = (const JSONObject& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ typedef std::shared_ptr<JSONObject> SP;
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::Object;
+ }
+
+ bool
+ SetObject (const std::string& key,
+ JSONValue::SP value);
+
+ JSONValue::SP
+ GetObject (const std::string& key) const;
+
+ // -------------------------------------------------------------------------
+ /// Return keyed value as bool
+ ///
+ /// @param[in] key
+ /// The value of the key to lookup
+ ///
+ /// @param[out] value
+ /// The value of the key as a bool. Undefined if the key doesn't
+ /// exist or if the key is not either true or false.
+ ///
+ /// @return
+ /// true if the key existed as was a bool value; false otherwise.
+ /// Note the return value is *not* the value of the bool, use
+ /// \b value for that.
+ // -------------------------------------------------------------------------
+ bool
+ GetObjectAsBool (const std::string& key, bool& value) const;
+
+ bool
+ GetObjectAsString (const std::string& key, std::string& value) const;
+
+ ~JSONObject() override = default;
+
+private:
+ typedef std::map<std::string, JSONValue::SP> Map;
+ typedef Map::iterator Iterator;
+ Map m_elements;
+};
+
+class JSONArray : public JSONValue
+{
+public:
+ JSONArray ();
+
+ JSONArray (const JSONArray& s) = delete;
+ JSONArray&
+ operator = (const JSONArray& s) = delete;
+
+ void
+ Write(std::ostream& s) override;
+
+ typedef std::shared_ptr<JSONArray> SP;
+
+ static bool classof(const JSONValue *V)
+ {
+ return V->GetKind() == JSONValue::Kind::Array;
+ }
+
+private:
+ typedef std::vector<JSONValue::SP> Vector;
+ typedef Vector::iterator Iterator;
+ typedef Vector::size_type Index;
+ typedef Vector::size_type Size;
+
+public:
+ bool
+ SetObject (Index i,
+ JSONValue::SP value);
+
+ bool
+ AppendObject (JSONValue::SP value);
+
+ JSONValue::SP
+ GetObject (Index i);
+
+ Size
+ GetNumElements ();
+
+ ~JSONArray() override = default;
+
+ Vector m_elements;
+};
+
+class JSONParser : public StringExtractor
+{
+public:
+ enum Token
+ {
+ Invalid,
+ Error,
+ ObjectStart,
+ ObjectEnd,
+ ArrayStart,
+ ArrayEnd,
+ Comma,
+ Colon,
+ String,
+ Integer,
+ Float,
+ True,
+ False,
+ Null,
+ EndOfFile
+ };
+
+ JSONParser (const char *cstr);
+
+ int
+ GetEscapedChar (bool &was_escaped);
+
+ Token
+ GetToken (std::string &value);
+
+ JSONValue::SP
+ ParseJSONValue ();
+
+protected:
+ JSONValue::SP
+ ParseJSONObject ();
+
+ JSONValue::SP
+ ParseJSONArray ();
+};
+
+#endif // utility_JSON_h_
add_subdirectory(i386)
#add_subdirectory(ppc)
add_subdirectory(x86_64)
+add_subdirectory(DarwinLog)
include_directories(..)
lldbUtility
lldbDebugserverMacOSX_I386
lldbDebugserverMacOSX_X86_64
+ lldbDebugserverMacOSX_DarwinLog
)
add_lldb_executable(debugserver
MachThreadList.cpp
MachVMMemory.cpp
MachVMRegion.cpp
+ OsLogger.cpp
${generated_mach_interfaces}
${DEBUGSERVER_VERS_GENERATED_FILE}
)
--- /dev/null
+//===-- ActivityStore.cpp ---------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ActivityStore.h"
+
+ActivityStore::ActivityStore()
+{
+}
+
+ActivityStore::~ActivityStore()
+{
+}
--- /dev/null
+//===-- ActivityStore.h -----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ActivityStore_h
+#define ActivityStore_h
+
+#include <string>
+
+#include "ActivityStreamSPI.h"
+
+class ActivityStore
+{
+public:
+
+ virtual
+ ~ActivityStore();
+
+ virtual const char*
+ GetActivityForID(os_activity_id_t activity_id) const = 0;
+
+ virtual std::string
+ GetActivityChainForID(os_activity_id_t activity_id) const = 0;
+
+protected:
+
+ ActivityStore();
+
+};
+
+#endif /* ActivityStore_h */
--- /dev/null
+//===-- ActivityStreamAPI.h -------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ActivityStreamSPI_h
+#define ActivityStreamSPI_h
+
+#include <sys/time.h>
+#include <xpc/xpc.h>
+
+#define OS_ACTIVITY_MAX_CALLSTACK 32
+
+// Enums
+
+enum
+{
+ OS_ACTIVITY_STREAM_PROCESS_ONLY = 0x00000001,
+ OS_ACTIVITY_STREAM_SKIP_DECODE = 0x00000002,
+ OS_ACTIVITY_STREAM_PAYLOAD = 0x00000004,
+ OS_ACTIVITY_STREAM_HISTORICAL = 0x00000008,
+ OS_ACTIVITY_STREAM_CALLSTACK = 0x00000010,
+ OS_ACTIVITY_STREAM_DEBUG = 0x00000020,
+ OS_ACTIVITY_STREAM_BUFFERED = 0x00000040,
+ OS_ACTIVITY_STREAM_NO_SENSITIVE = 0x00000080,
+ OS_ACTIVITY_STREAM_INFO = 0x00000100,
+ OS_ACTIVITY_STREAM_PROMISCUOUS = 0x00000200,
+ OS_ACTIVITY_STREAM_PRECISE_TIMESTAMPS = 0x00000200
+};
+typedef uint32_t os_activity_stream_flag_t;
+
+enum
+{
+ OS_ACTIVITY_STREAM_TYPE_ACTIVITY_CREATE = 0x0201,
+ OS_ACTIVITY_STREAM_TYPE_ACTIVITY_TRANSITION = 0x0202,
+ OS_ACTIVITY_STREAM_TYPE_ACTIVITY_USERACTION = 0x0203,
+
+ OS_ACTIVITY_STREAM_TYPE_TRACE_MESSAGE = 0x0300,
+
+ OS_ACTIVITY_STREAM_TYPE_LOG_MESSAGE = 0x0400,
+ OS_ACTIVITY_STREAM_TYPE_LEGACY_LOG_MESSAGE = 0x0480,
+
+ OS_ACTIVITY_STREAM_TYPE_SIGNPOST_BEGIN = 0x0601,
+ OS_ACTIVITY_STREAM_TYPE_SIGNPOST_END = 0x0602,
+ OS_ACTIVITY_STREAM_TYPE_SIGNPOST_EVENT = 0x0603,
+
+ OS_ACTIVITY_STREAM_TYPE_STATEDUMP_EVENT = 0x0A00,
+};
+typedef uint32_t os_activity_stream_type_t;
+
+enum
+{
+ OS_ACTIVITY_STREAM_EVENT_STARTED = 1,
+ OS_ACTIVITY_STREAM_EVENT_STOPPED = 2,
+ OS_ACTIVITY_STREAM_EVENT_FAILED = 3,
+ OS_ACTIVITY_STREAM_EVENT_CHUNK_STARTED = 4,
+ OS_ACTIVITY_STREAM_EVENT_CHUNK_FINISHED = 5,
+};
+typedef uint32_t os_activity_stream_event_t;
+
+// Types
+
+typedef uint64_t os_activity_id_t;
+typedef struct os_activity_stream_s *os_activity_stream_t;
+typedef struct os_activity_stream_entry_s *os_activity_stream_entry_t;
+
+#define OS_ACTIVITY_STREAM_COMMON() \
+ uint64_t trace_id; \
+ uint64_t timestamp; \
+ uint64_t thread; \
+ const uint8_t *image_uuid; \
+ const char *image_path; \
+ struct timeval tv_gmt; \
+ struct timezone tz; \
+ uint32_t offset \
+
+
+typedef struct os_activity_stream_common_s {
+ OS_ACTIVITY_STREAM_COMMON();
+} *os_activity_stream_common_t;
+
+struct os_activity_create_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ const char *name;
+ os_activity_id_t creator_aid;
+ uint64_t unique_pid;
+};
+
+struct os_activity_transition_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ os_activity_id_t transition_id;
+};
+
+typedef struct os_log_message_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ const char *format;
+ const uint8_t *buffer;
+ size_t buffer_sz;
+ const uint8_t *privdata;
+ size_t privdata_sz;
+ const char *subsystem;
+ const char *category;
+ uint32_t oversize_id;
+ uint8_t ttl;
+ bool persisted;
+} *os_log_message_t;
+
+typedef struct os_trace_message_v2_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ const char *format;
+ const void *buffer;
+ size_t bufferLen;
+ xpc_object_t __unsafe_unretained payload;
+} *os_trace_message_v2_t;
+
+typedef struct os_activity_useraction_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ const char *action;
+ bool persisted;
+} *os_activity_useraction_t;
+
+typedef struct os_signpost_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ const char *format;
+ const uint8_t *buffer;
+ size_t buffer_sz;
+ const uint8_t *privdata;
+ size_t privdata_sz;
+ const char *subsystem;
+ const char *category;
+ uint64_t duration_nsec;
+ uint32_t callstack_depth;
+ uint64_t callstack[OS_ACTIVITY_MAX_CALLSTACK];
+} *os_signpost_t;
+
+typedef struct os_activity_statedump_s {
+ OS_ACTIVITY_STREAM_COMMON();
+ char *message;
+ size_t message_size;
+ char image_path_buffer[PATH_MAX];
+} *os_activity_statedump_t;
+
+struct os_activity_stream_entry_s {
+ os_activity_stream_type_t type;
+
+ // information about the process streaming the data
+ pid_t pid;
+ uint64_t proc_id;
+ const uint8_t *proc_imageuuid;
+ const char *proc_imagepath;
+
+ // the activity associated with this streamed event
+ os_activity_id_t activity_id;
+ os_activity_id_t parent_id;
+
+ union {
+ struct os_activity_stream_common_s common;
+ struct os_activity_create_s activity_create;
+ struct os_activity_transition_s activity_transition;
+ struct os_log_message_s log_message;
+ struct os_trace_message_v2_s trace_message;
+ struct os_activity_useraction_s useraction;
+ struct os_signpost_s signpost;
+ struct os_activity_statedump_s statedump;
+ };
+};
+
+// Blocks
+
+typedef bool (^os_activity_stream_block_t)(os_activity_stream_entry_t entry,
+ int error);
+
+typedef void (^os_activity_stream_event_block_t)(
+ os_activity_stream_t stream,
+ os_activity_stream_event_t event);
+
+// SPI entry point prototypes
+
+typedef os_activity_stream_t
+ (*os_activity_stream_for_pid_t)(pid_t pid, os_activity_stream_flag_t flags,
+ os_activity_stream_block_t stream_block);
+
+typedef void
+(*os_activity_stream_resume_t)(os_activity_stream_t stream);
+
+typedef void
+ (*os_activity_stream_cancel_t)(os_activity_stream_t stream);
+
+typedef char *
+ (*os_log_copy_formatted_message_t)(os_log_message_t log_message);
+
+typedef void
+ (*os_activity_stream_set_event_handler_t)
+ (os_activity_stream_t stream, os_activity_stream_event_block_t block);
+
+#endif /* ActivityStreamSPI_h */
--- /dev/null
+# Due to sources including headers like:
+# #include "MacOSX/i386/DNBArchImplI386.h"
+# we must include the grandparent directory...
+include_directories(${LLDB_SOURCE_DIR}/tools/debugserver/source)
+
+add_library(lldbDebugserverMacOSX_DarwinLog
+ ActivityStore.cpp
+ DarwinLogCollector.cpp
+ LogFilter.cpp
+ LogFilterChain.cpp
+ LogFilterExactMatch.cpp
+ LogFilterRegex.cpp
+ LogMessage.cpp
+ LogMessageOsLog.cpp
+ )
--- /dev/null
+//===-- DarwinLogCollector.cpp ----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DarwinLogCollector.h"
+#include "ActivityStreamSPI.h"
+
+#include <dlfcn.h>
+
+#include <cinttypes>
+#include <mutex>
+#include <vector>
+
+#include "DarwinLogTypes.h"
+#include "DNB.h"
+#include "DNBLog.h"
+#include "LogFilterChain.h"
+#include "LogFilterExactMatch.h"
+#include "LogFilterRegex.h"
+#include "LogMessageOsLog.h"
+#include "MachProcess.h"
+#include "RNBContext.h"
+#include "RNBDefs.h"
+#include "RNBRemote.h"
+
+// Use an anonymous namespace for variables and methods that have no
+// reason to leak out through the interface.
+namespace
+{
+ /// Specify max depth that the activity parent-child chain will search
+ /// back to get the full activity chain name. If we do more than this,
+ /// we assume either we hit a loop or it's just too long.
+ static const size_t MAX_ACTIVITY_CHAIN_DEPTH = 10;
+
+ // Used to tap into and retrieve logs from target process.
+ // (Consumer of os_log).
+ static os_activity_stream_for_pid_t s_os_activity_stream_for_pid;
+ static os_activity_stream_resume_t s_os_activity_stream_resume;
+ static os_activity_stream_cancel_t s_os_activity_stream_cancel;
+ static os_log_copy_formatted_message_t s_os_log_copy_formatted_message;
+ static os_activity_stream_set_event_handler_t
+ s_os_activity_stream_set_event_handler;
+
+ bool
+ LookupSPICalls()
+ {
+ static std::once_flag s_once_flag;
+ static bool s_has_spi;
+
+ std::call_once(s_once_flag, [] {
+ s_os_activity_stream_for_pid = (os_activity_stream_for_pid_t)
+ dlsym(RTLD_DEFAULT, "os_activity_stream_for_pid");
+ s_os_activity_stream_resume = (os_activity_stream_resume_t)
+ dlsym(RTLD_DEFAULT, "os_activity_stream_resume");
+ s_os_activity_stream_cancel = (os_activity_stream_cancel_t)
+ dlsym(RTLD_DEFAULT, "os_activity_stream_cancel");
+ s_os_log_copy_formatted_message = (os_log_copy_formatted_message_t)
+ dlsym(RTLD_DEFAULT, "os_log_copy_formatted_message");
+ s_os_activity_stream_set_event_handler =
+ (os_activity_stream_set_event_handler_t)
+ dlsym(RTLD_DEFAULT, "os_activity_stream_set_event_handler");
+
+ // We'll indicate we're all set if every function entry point
+ // was found.
+ s_has_spi =
+ (s_os_activity_stream_for_pid != nullptr) &&
+ (s_os_activity_stream_resume != nullptr) &&
+ (s_os_activity_stream_cancel != nullptr) &&
+ (s_os_log_copy_formatted_message != nullptr) &&
+ (s_os_activity_stream_set_event_handler != nullptr);
+ if (s_has_spi)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "Found os_log SPI calls.");
+ // Tell LogMessageOsLog how to format messages when search
+ // criteria requires it.
+ LogMessageOsLog::SetFormatterFunction(
+ s_os_log_copy_formatted_message);
+ }
+ else
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "Failed to find os_log SPI "
+ "calls.");
+ }
+ });
+
+ return s_has_spi;
+ }
+
+ using Mutex = std::mutex;
+ static Mutex s_collector_mutex;
+ static std::vector<DarwinLogCollectorSP> s_collectors;
+
+ static void
+ TrackCollector(const DarwinLogCollectorSP &collector_sp)
+ {
+ std::lock_guard<Mutex> locker(s_collector_mutex);
+ if (std::find(s_collectors.begin(), s_collectors.end(), collector_sp)
+ != s_collectors.end())
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "attempted to add same collector multiple times");
+ return;
+ }
+ s_collectors.push_back(collector_sp);
+ }
+
+ static void
+ StopTrackingCollector(const DarwinLogCollectorSP &collector_sp)
+ {
+ std::lock_guard<Mutex> locker(s_collector_mutex);
+ s_collectors.erase(std::remove(s_collectors.begin(), s_collectors.end(),
+ collector_sp),
+ s_collectors.end());
+ }
+
+ static DarwinLogCollectorSP
+ FindCollectorForProcess(pid_t pid)
+ {
+ std::lock_guard<Mutex> locker(s_collector_mutex);
+ for (const auto &collector_sp : s_collectors)
+ {
+ if (collector_sp && (collector_sp->GetProcessID() == pid))
+ return collector_sp;
+ }
+ return DarwinLogCollectorSP();
+ }
+
+ static FilterTarget
+ TargetStringToEnum(const std::string &filter_target_name)
+ {
+ if (filter_target_name == "activity")
+ return eFilterTargetActivity;
+ else if (filter_target_name == "activity-chain")
+ return eFilterTargetActivityChain;
+ else if (filter_target_name == "category")
+ return eFilterTargetCategory;
+ else if (filter_target_name == "message")
+ return eFilterTargetMessage;
+ else if (filter_target_name == "subsystem")
+ return eFilterTargetSubsystem;
+ else
+ return eFilterTargetInvalid;
+ }
+
+ class Configuration
+ {
+ public:
+
+ Configuration(const JSONObject &config) :
+ m_is_valid(false),
+ m_activity_stream_flags(OS_ACTIVITY_STREAM_PROCESS_ONLY),
+ m_filter_chain_sp(nullptr)
+ {
+ // Parse out activity stream flags
+ if (!ParseSourceFlags(config))
+ {
+ m_is_valid = false;
+ return;
+ }
+
+ // Parse filter rules
+ if (!ParseFilterRules(config))
+ {
+ m_is_valid = false;
+ return;
+ }
+
+ // Everything worked.
+ m_is_valid = true;
+ }
+
+ bool
+ ParseSourceFlags(const JSONObject &config)
+ {
+ // Get the source-flags dictionary.
+ auto source_flags_sp = config.GetObject("source-flags");
+ if (!source_flags_sp)
+ return false;
+ if (!JSONObject::classof(source_flags_sp.get()))
+ return false;
+
+ const JSONObject &source_flags =
+ *static_cast<JSONObject*>(source_flags_sp.get());
+
+ // Parse out the flags.
+ bool include_any_process = false;
+ bool include_callstacks = false;
+ bool include_info_level = false;
+ bool include_debug_level = false;
+ bool live_stream = false;
+
+ if (!source_flags.GetObjectAsBool("any-process",
+ include_any_process))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Source-flag 'any-process' missing from "
+ "configuration.");
+ return false;
+ }
+ if (!source_flags.GetObjectAsBool("callstacks",
+ include_callstacks))
+ {
+ // We currently suppress the availability of this on the lldb
+ // side. We include here for devices when we enable in the
+ // future.
+ // DNBLogThreadedIf(LOG_DARWIN_LOG,
+ // "Source-flag 'callstacks' missing from "
+ // "configuration.");
+
+ // OK. We just skip callstacks.
+ // return false;
+ }
+ if (!source_flags.GetObjectAsBool("info-level",
+ include_info_level))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Source-flag 'info-level' missing from "
+ "configuration.");
+ return false;
+ }
+ if (!source_flags.GetObjectAsBool("debug-level",
+ include_debug_level))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Source-flag 'debug-level' missing from "
+ "configuration.");
+ return false;
+ }
+ if (!source_flags.GetObjectAsBool("live-stream",
+ live_stream))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Source-flag 'live-stream' missing from "
+ "configuration.");
+ return false;
+ }
+
+ // Setup the SPI flags based on this.
+ m_activity_stream_flags = 0;
+ if (!include_any_process)
+ m_activity_stream_flags |= OS_ACTIVITY_STREAM_PROCESS_ONLY;
+ if (include_callstacks)
+ m_activity_stream_flags |= OS_ACTIVITY_STREAM_CALLSTACK;
+ if (include_info_level)
+ m_activity_stream_flags |= OS_ACTIVITY_STREAM_INFO;
+ if (include_debug_level)
+ m_activity_stream_flags |= OS_ACTIVITY_STREAM_DEBUG;
+ if (!live_stream)
+ m_activity_stream_flags |= OS_ACTIVITY_STREAM_BUFFERED;
+
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "m_activity_stream_flags = 0x%03x",
+ m_activity_stream_flags);
+
+ return true;
+ }
+
+ bool
+ ParseFilterRules(const JSONObject &config)
+ {
+ // Retrieve the default rule.
+ bool filter_default_accept = true;
+ if (!config.GetObjectAsBool("filter-fall-through-accepts",
+ filter_default_accept))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Setting 'filter-fall-through-accepts' "
+ "missing from configuration.");
+ return false;
+ }
+ m_filter_chain_sp.reset(new LogFilterChain(filter_default_accept));
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "DarwinLog no-match rule: %s.",
+ filter_default_accept ? "accept" : "reject");
+
+ // If we don't have the filter-rules array, we're done.
+ auto filter_rules_sp = config.GetObject("filter-rules");
+ if (!filter_rules_sp)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "No 'filter-rules' config element, all log "
+ "entries will use the no-match action (%s).",
+ filter_default_accept ? "accept" : "reject");
+ return true;
+ }
+ if (!JSONArray::classof(filter_rules_sp.get()))
+ return false;
+ const JSONArray &rules_config =
+ *static_cast<JSONArray*>(filter_rules_sp.get());
+
+ // Create the filters.
+ for (auto &rule_sp : rules_config.m_elements)
+ {
+ if (!JSONObject::classof(rule_sp.get()))
+ return false;
+ const JSONObject &rule_config = *static_cast<JSONObject*>
+ (rule_sp.get());
+
+ // Get whether this filter accepts or rejects.
+ bool filter_accepts = true;
+ if (!rule_config.GetObjectAsBool("accept", filter_accepts))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Filter 'accept' element missing.");
+ return false;
+ }
+
+ // Grab the target log field attribute for the match.
+ std::string target_attribute;
+ if (!rule_config.GetObjectAsString("attribute",
+ target_attribute))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Filter 'attribute' element missing.");
+ return false;
+ }
+ auto target_enum = TargetStringToEnum(target_attribute);
+ if (target_enum == eFilterTargetInvalid)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Filter attribute '%s' unsupported.",
+ target_attribute.c_str());
+ return false;
+ }
+
+ // Handle operation-specific fields and filter creation.
+ std::string filter_type;
+ if (!rule_config.GetObjectAsString("type", filter_type))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Filter 'type' element missing.");
+ return false;
+ }
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "Reading filter of type '%s'", filter_type
+ .c_str());
+
+ LogFilterSP filter_sp;
+ if (filter_type == "regex")
+ {
+ // Grab the regex for the match.
+ std::string regex;
+ if (!rule_config.GetObjectAsString("regex",
+ regex))
+ {
+ DNBLogError("Regex filter missing 'regex' element.");
+ return false;
+ }
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "regex for filter: \"%s\"", regex.c_str());
+
+ // Create the regex filter.
+ auto regex_filter =
+ new LogFilterRegex(filter_accepts, target_enum, regex);
+ filter_sp.reset(regex_filter);
+
+ // Validate that the filter is okay.
+ if (!regex_filter->IsValid())
+ {
+ DNBLogError("Invalid regex in filter: "
+ "regex=\"%s\", error=%s",
+ regex.c_str(),
+ regex_filter->GetErrorAsCString());
+ return false;
+ }
+ }
+ else if (filter_type == "match")
+ {
+ // Grab the regex for the match.
+ std::string exact_text;
+ if (!rule_config.GetObjectAsString("exact_text",
+ exact_text))
+ {
+ DNBLogError("Exact match filter missing "
+ "'exact_text' element.");
+ return false;
+ }
+
+ // Create the filter.
+ filter_sp.reset(new LogFilterExactMatch(filter_accepts,
+ target_enum,
+ exact_text));
+ }
+
+ // Add the filter to the chain.
+ m_filter_chain_sp->AppendFilter(filter_sp);
+ }
+ return true;
+ }
+
+ bool
+ IsValid() const
+ {
+ return m_is_valid;
+ }
+
+ os_activity_stream_flag_t
+ GetActivityStreamFlags() const
+ {
+ return m_activity_stream_flags;
+ }
+
+ const LogFilterChainSP &
+ GetLogFilterChain() const
+ {
+ return m_filter_chain_sp;
+ }
+
+ private:
+
+ bool m_is_valid;
+ os_activity_stream_flag_t m_activity_stream_flags;
+ LogFilterChainSP m_filter_chain_sp;
+
+ };
+}
+
+bool
+DarwinLogCollector::IsSupported()
+{
+ // We're supported if we have successfully looked up the SPI entry points.
+ return LookupSPICalls();
+}
+
+bool
+DarwinLogCollector::StartCollectingForProcess(nub_process_t pid,
+ const JSONObject &config)
+{
+ // If we're currently collecting for this process, kill the existing
+ // collector.
+ if (CancelStreamForProcess(pid))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "%s() killed existing DarwinLog collector for pid %d.",
+ __FUNCTION__, pid);
+ }
+
+ // If the process isn't alive, we're done.
+ if (!DNBProcessIsAlive(pid))
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "%s() cannot collect for pid %d: process not alive.",
+ __FUNCTION__, pid);
+ return false;
+ }
+
+ // Validate the configuration.
+ auto spi_config = Configuration(config);
+ if (!spi_config.IsValid())
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG,
+ "%s() invalid configuration, will not enable log "
+ "collection", __FUNCTION__);
+ return false;
+ }
+
+ // Create the stream collector that will manage collected data
+ // for this pid.
+ DarwinLogCollectorSP collector_sp(new DarwinLogCollector(pid,
+ spi_config.GetLogFilterChain()));
+ std::weak_ptr<DarwinLogCollector> collector_wp(collector_sp);
+
+ // Setup the stream handling block.
+ os_activity_stream_block_t block = ^bool (os_activity_stream_entry_t entry,
+ int error) {
+ // Check if our collector is still alive.
+ DarwinLogCollectorSP inner_collector_sp = collector_wp.lock();
+ if (!inner_collector_sp)
+ return false;
+ return inner_collector_sp->HandleStreamEntry(entry, error);
+ };
+
+ os_activity_stream_event_block_t stream_event_block =
+ ^void (os_activity_stream_t stream, os_activity_stream_event_t event) {
+ switch (event)
+ {
+ case OS_ACTIVITY_STREAM_EVENT_STARTED:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received stream event: "
+ "OS_ACTIVITY_STREAM_EVENT_STARTED, stream %p.",
+ (void*)stream);
+ break;
+ case OS_ACTIVITY_STREAM_EVENT_STOPPED:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received stream event: "
+ "OS_ACTIVITY_STREAM_EVENT_STOPPED, stream %p.",
+ (void*)stream);
+ break;
+ case OS_ACTIVITY_STREAM_EVENT_FAILED:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received stream event: "
+ "OS_ACTIVITY_STREAM_EVENT_FAILED, stream %p.",
+ (void*)stream);
+ break;
+ case OS_ACTIVITY_STREAM_EVENT_CHUNK_STARTED:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received stream event: "
+ "OS_ACTIVITY_STREAM_EVENT_CHUNK_STARTED, stream %p.",
+ (void*)stream);
+ break;
+ case OS_ACTIVITY_STREAM_EVENT_CHUNK_FINISHED:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received stream event: "
+ "OS_ACTIVITY_STREAM_EVENT_CHUNK_FINISHED, stream %p.",
+ (void*)stream);
+ break;
+ }
+ };
+
+ // Create the stream.
+ os_activity_stream_t activity_stream =
+ (*s_os_activity_stream_for_pid)(pid,
+ spi_config.GetActivityStreamFlags(),
+ block);
+ collector_sp->SetActivityStream(activity_stream);
+
+ // Specify the stream-related event handler.
+ (*s_os_activity_stream_set_event_handler)(
+ activity_stream, stream_event_block);
+
+ // Start the stream.
+ (*s_os_activity_stream_resume)(activity_stream);
+
+ TrackCollector(collector_sp);
+ return true;
+}
+
+DarwinLogEventVector
+DarwinLogCollector::GetEventsForProcess(nub_process_t pid)
+{
+ auto collector_sp = FindCollectorForProcess(pid);
+ if (!collector_sp)
+ {
+ // We're not tracking a stream for this process.
+ return DarwinLogEventVector();
+ }
+
+ return collector_sp->RemoveEvents();
+}
+
+bool
+DarwinLogCollector::CancelStreamForProcess(nub_process_t pid)
+{
+ auto collector_sp = FindCollectorForProcess(pid);
+ if (!collector_sp)
+ {
+ // We're not tracking a stream for this process.
+ return false;
+ }
+
+ collector_sp->CancelActivityStream();
+ StopTrackingCollector(collector_sp);
+
+ return true;
+}
+
+const char*
+DarwinLogCollector::GetActivityForID(os_activity_id_t activity_id) const
+{
+ auto find_it = m_activity_map.find(activity_id);
+ return (find_it != m_activity_map.end()) ?
+ find_it->second.m_name.c_str() :
+ nullptr;
+}
+
+/// Retrieve the full parent-child chain for activity names. These
+/// can be arbitrarily deep. This method assumes the caller has already
+/// locked the activity mutex.
+void
+DarwinLogCollector::GetActivityChainForID_internal(os_activity_id_t activity_id,
+ std::string &result,
+ size_t depth) const
+{
+ if (depth > MAX_ACTIVITY_CHAIN_DEPTH)
+ {
+ // Terminating condition - too deeply nested.
+ return;
+ }
+ else if (activity_id == 0)
+ {
+ // Terminating condition - no activity.
+ return;
+ }
+
+ auto find_it = m_activity_map.find(activity_id);
+ if (find_it == m_activity_map.end())
+ {
+ //Terminating condition - no data for activity_id.
+ return;
+ }
+
+ // Activity name becomes parent activity name chain + ':' + our activity
+ // name.
+ GetActivityChainForID_internal(find_it->second.m_parent_id, result,
+ depth + 1);
+ if (!result.empty())
+ result += ':';
+ result += find_it->second.m_name;
+}
+
+std::string
+DarwinLogCollector::GetActivityChainForID(os_activity_id_t activity_id) const
+{
+ std::string result;
+ {
+ std::lock_guard<std::mutex> locker(m_activity_info_mutex);
+ GetActivityChainForID_internal(activity_id, result, 1);
+ }
+ return result;
+}
+
+DarwinLogCollector::DarwinLogCollector(nub_process_t pid,
+ const LogFilterChainSP &filter_chain_sp):
+ ActivityStore(),
+ m_pid(pid),
+ m_activity_stream(0),
+ m_events(),
+ m_events_mutex(),
+ m_filter_chain_sp(filter_chain_sp),
+ m_activity_info_mutex(),
+ m_activity_map()
+{
+}
+
+DarwinLogCollector::~DarwinLogCollector()
+{
+ // Cancel the stream.
+ if (m_activity_stream)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "tearing down activity stream "
+ "collector for %d", m_pid);
+ (*s_os_activity_stream_cancel)(m_activity_stream);
+ m_activity_stream = 0;
+ }
+ else
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "no stream to tear down for %d",
+ m_pid);
+ }
+}
+
+void
+DarwinLogCollector::SignalDataAvailable()
+{
+ RNBRemoteSP remoteSP(g_remoteSP);
+ if (!remoteSP)
+ {
+ // We're done. This is unexpected.
+ StopTrackingCollector(shared_from_this());
+ return;
+ }
+
+ RNBContext& ctx = remoteSP->Context();
+ ctx.Events().SetEvents(RNBContext::event_darwin_log_data_available);
+ // Wait for the main thread to consume this notification if it requested
+ // we wait for it.
+ ctx.Events().WaitForResetAck(RNBContext::event_darwin_log_data_available);
+}
+
+void
+DarwinLogCollector::SetActivityStream(os_activity_stream_t activity_stream)
+{
+ m_activity_stream = activity_stream;
+}
+
+bool
+DarwinLogCollector::HandleStreamEntry(os_activity_stream_entry_t entry,
+ int error)
+{
+ if ((error == 0) && (entry != nullptr))
+ {
+ if (entry->pid != m_pid)
+ {
+ // For now, skip messages not originating from our process.
+ // Later we might want to keep all messages related to an event
+ // that we're tracking, even when it came from another process,
+ // possibly doing work on our behalf.
+ return true;
+ }
+
+ switch (entry->type)
+ {
+ case OS_ACTIVITY_STREAM_TYPE_ACTIVITY_CREATE:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received activity create: "
+ "%s, creator aid %" PRIu64 ", unique_pid %" PRIu64
+ "(activity id=%" PRIu64 ", parent id=%" PRIu64 ")",
+ entry->activity_create.name,
+ entry->activity_create.creator_aid,
+ entry->activity_create.unique_pid, entry->activity_id,
+ entry->parent_id
+ );
+ {
+ std::lock_guard<std::mutex> locker(m_activity_info_mutex);
+ m_activity_map.insert(std::make_pair(
+ entry->activity_id,
+ ActivityInfo(
+ entry->activity_create.name,
+ entry->activity_id,
+ entry->parent_id)));
+ }
+ break;
+
+ case OS_ACTIVITY_STREAM_TYPE_ACTIVITY_TRANSITION:
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received activity transition:"
+ "new aid: %" PRIu64 "(activity id=%" PRIu64
+ ", parent id=%" PRIu64 ", tid %" PRIu64 ")",
+ entry->activity_transition.transition_id,
+ entry->activity_id, entry->parent_id,
+ entry->activity_transition.thread);
+ break;
+
+ case OS_ACTIVITY_STREAM_TYPE_LOG_MESSAGE:
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "received log message: "
+ "(activity id=%" PRIu64 ", parent id=%" PRIu64 ", "
+ "tid %" PRIu64 "): format %s",
+ entry->activity_id, entry->parent_id,
+ entry->log_message.thread,
+ entry->log_message.format ? entry->log_message.format :
+ "<invalid-format>");
+
+ // Do the real work here.
+ {
+ // Ensure our process is still alive. If not, we can
+ // cancel the collection.
+ if (!DNBProcessIsAlive(m_pid))
+ {
+ // We're outta here. This is the manner in which we
+ // stop collecting for a process.
+ StopTrackingCollector(shared_from_this());
+ return false;
+ }
+
+ LogMessageOsLog os_log_message(*this, *entry);
+ if (!m_filter_chain_sp ||
+ !m_filter_chain_sp->GetAcceptMessage(os_log_message))
+ {
+ // This log message was rejected by the filter,
+ // so stop processing it now.
+ return true;
+ }
+
+ // Copy over the relevant bits from the message.
+ const struct os_log_message_s &log_message =
+ entry->log_message;
+
+ DarwinLogEventSP message_sp(new DarwinLogEvent());
+ // Indicate this event is a log message event.
+ message_sp->AddStringItem("type", "log");
+
+ // Add the message contents (fully expanded).
+ // Consider expanding on the remote side.
+ // Then we don't pay for expansion until when it is
+ // used.
+ const char *message_text = os_log_message.GetMessage();
+ if (message_text)
+ message_sp->AddStringItem("message", message_text);
+
+ // Add some useful data fields.
+ message_sp->AddIntegerItem("timestamp",
+ log_message.timestamp);
+
+ // Do we want to do all activity name resolution on this
+ // side? Maybe. For now, send IDs and ID->name mappings
+ // and fix this up on that side. Later, when we add
+ // debugserver-side filtering, we'll want to get the
+ // activity names over here, so we should probably
+ // just send them as resolved strings.
+ message_sp->AddIntegerItem("activity_id",
+ entry->activity_id);
+ message_sp->AddIntegerItem("parent_id",
+ entry->parent_id);
+ message_sp->AddIntegerItem("thread_id",
+ log_message.thread);
+ if (log_message.subsystem && strlen(log_message.subsystem)
+ > 0)
+ message_sp->AddStringItem("subsystem",
+ log_message.subsystem);
+ if (log_message.category && strlen(log_message.category)
+ > 0)
+ message_sp->AddStringItem("category",
+ log_message.category);
+ if (entry->activity_id != 0)
+ {
+ std::string activity_chain =
+ GetActivityChainForID(entry->activity_id);
+ if (!activity_chain.empty())
+ message_sp->AddStringItem("activity-chain",
+ activity_chain);
+ }
+
+ // Add it to the list for later collection.
+ {
+ std::lock_guard<std::mutex> locker(m_events_mutex);
+ m_events.push_back(message_sp);
+ }
+ SignalDataAvailable();
+ }
+ break;
+ }
+ }
+ }
+ else
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "HandleStreamEntry: final call, "
+ "error %d", error);
+ }
+ return true;
+}
+
+DarwinLogEventVector
+DarwinLogCollector::RemoveEvents()
+{
+ DarwinLogEventVector returned_events;
+ {
+ std::lock_guard<std::mutex> locker(m_events_mutex);
+ returned_events.swap(m_events);
+ }
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLogCollector::%s(): removing %lu "
+ "queued log entries", __FUNCTION__,
+ returned_events.size());
+ return returned_events;
+}
+
+void
+DarwinLogCollector::CancelActivityStream()
+{
+ if (!m_activity_stream)
+ return;
+
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLogCollector::%s(): canceling "
+ "activity stream %p", __FUNCTION__,
+ m_activity_stream);
+ (*s_os_activity_stream_cancel)(m_activity_stream);
+ m_activity_stream = nullptr;
+}
--- /dev/null
+//===-- DarwinLogCollector.h ------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef DarwinLogCollector_h
+#define DarwinLogCollector_h
+
+#include <sys/types.h>
+
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#include "ActivityStore.h"
+#include "ActivityStreamSPI.h"
+#include "DarwinLogEvent.h"
+#include "DarwinLogInterfaces.h"
+#include "DNBDefs.h"
+#include "JSON.h"
+
+class DarwinLogCollector;
+typedef std::shared_ptr<DarwinLogCollector> DarwinLogCollectorSP;
+
+class DarwinLogCollector:
+ public std::enable_shared_from_this<DarwinLogCollector>,
+ public ActivityStore
+{
+public:
+
+ //------------------------------------------------------------------
+ /// Return whether the os_log and activity tracing SPI is available.
+ ///
+ /// @return \b true if the activity stream support is available,
+ /// \b false otherwise.
+ //------------------------------------------------------------------
+ static bool
+ IsSupported();
+
+ //------------------------------------------------------------------
+ /// Return a log function suitable for DNBLog to use as the internal
+ /// logging function.
+ ///
+ /// @return a DNBLog-style logging function if IsSupported() returns
+ /// true; otherwise, returns nullptr.
+ //------------------------------------------------------------------
+ static DNBCallbackLog
+ GetLogFunction();
+
+ static bool
+ StartCollectingForProcess(nub_process_t pid, const JSONObject &config);
+
+ static bool
+ CancelStreamForProcess(nub_process_t pid);
+
+ static DarwinLogEventVector
+ GetEventsForProcess(nub_process_t pid);
+
+ ~DarwinLogCollector();
+
+ pid_t
+ GetProcessID() const
+ {
+ return m_pid;
+ }
+
+ //------------------------------------------------------------------
+ // ActivityStore API
+ //------------------------------------------------------------------
+ const char*
+ GetActivityForID(os_activity_id_t activity_id) const override;
+
+ std::string
+ GetActivityChainForID(os_activity_id_t activity_id) const override;
+
+
+private:
+
+ DarwinLogCollector() = delete;
+ DarwinLogCollector(const DarwinLogCollector&) = delete;
+ DarwinLogCollector &operator=(const DarwinLogCollector&) = delete;
+
+ explicit
+ DarwinLogCollector(nub_process_t pid,
+ const LogFilterChainSP &filter_chain_sp);
+
+ void
+ SignalDataAvailable();
+
+ void
+ SetActivityStream(os_activity_stream_t activity_stream);
+
+ bool
+ HandleStreamEntry(os_activity_stream_entry_t entry, int error);
+
+ DarwinLogEventVector
+ RemoveEvents();
+
+ void
+ CancelActivityStream();
+
+ void
+ GetActivityChainForID_internal(os_activity_id_t activity_id,
+ std::string &result, size_t depth) const;
+
+ struct ActivityInfo
+ {
+ ActivityInfo(const char *name, os_activity_id_t activity_id,
+ os_activity_id_t parent_activity_id) :
+ m_name(name),
+ m_id(activity_id),
+ m_parent_id(parent_activity_id)
+ {
+ }
+
+ const std::string m_name;
+ const os_activity_id_t m_id;
+ const os_activity_id_t m_parent_id;
+ };
+
+ using ActivityMap = std::unordered_map<os_activity_id_t, ActivityInfo>;
+
+ const nub_process_t m_pid;
+ os_activity_stream_t m_activity_stream;
+ DarwinLogEventVector m_events;
+ std::mutex m_events_mutex;
+ LogFilterChainSP m_filter_chain_sp;
+
+ /// Mutex to protect activity info (activity name and parent structures)
+ mutable std::mutex m_activity_info_mutex;
+ /// Map of activity id to ActivityInfo
+ ActivityMap m_activity_map;
+};
+
+#endif /* LogStreamCollector_h */
--- /dev/null
+//===-- DarwinLogEvent.h ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef DarwinLogEvent_h
+#define DarwinLogEvent_h
+
+#include <memory>
+#include <vector>
+
+#include "JSONGenerator.h"
+
+// =============================================================================
+/// Each discrete unit of information is described as an event, such as
+/// the emission of a single log message.
+// =============================================================================
+
+using DarwinLogEvent = JSONGenerator::Dictionary;
+using DarwinLogEventSP = std::shared_ptr<DarwinLogEvent>;
+using DarwinLogEventVector = std::vector<DarwinLogEventSP>;
+
+#endif
--- /dev/null
+//===-- DarwinLogInterfaces.h -----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef DarwinLogInterfaces_h
+#define DarwinLogInterfaces_h
+
+#include <memory>
+
+class ActivityStore;
+
+class LogFilter;
+using LogFilterSP = std::shared_ptr<LogFilter>;
+
+class LogFilterChain;
+using LogFilterChainSP = std::shared_ptr<LogFilterChain>;
+
+class LogMessage;
+
+#endif /* DarwinLogInterfaces_h */
--- /dev/null
+//===-- DarwinLogTypes.h ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef DarwinLogTypes_h
+#define DarwinLogTypes_h
+
+enum FilterTarget
+{
+ eFilterTargetInvalid,
+ eFilterTargetActivity,
+ eFilterTargetActivityChain,
+ eFilterTargetCategory,
+ eFilterTargetMessage,
+ eFilterTargetSubsystem
+};
+
+#endif /* DarwinLogTypes_h */
--- /dev/null
+//===-- LogFilter.cpp -------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LogFilter.h"
+
+LogFilter::~LogFilter()
+{
+}
--- /dev/null
+//===-- LogFilter.h ---------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LogFilter_h
+#define LogFilter_h
+
+#include "DarwinLogInterfaces.h"
+
+class LogFilter
+{
+public:
+
+ virtual
+ ~LogFilter();
+
+ virtual bool
+ DoesMatch(const LogMessage &message) const = 0;
+
+ bool
+ MatchesAreAccepted() const
+ {
+ return m_matches_accept;
+ }
+
+protected:
+
+ LogFilter(bool matches_accept) :
+ m_matches_accept(matches_accept)
+ {
+ }
+
+private:
+
+ bool m_matches_accept;
+
+};
+
+#endif /* LogFilter_h */
--- /dev/null
+//===-- LogFilterChain.cpp --------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LogFilterChain.h"
+
+#include "LogFilter.h"
+
+LogFilterChain::LogFilterChain(bool default_accept) :
+ m_filters(),
+ m_default_accept(default_accept)
+{
+}
+
+void
+LogFilterChain::AppendFilter(const LogFilterSP &filter_sp)
+{
+ if (filter_sp)
+ m_filters.push_back(filter_sp);
+}
+
+void
+LogFilterChain::ClearFilterChain()
+{
+ m_filters.clear();
+}
+
+bool
+LogFilterChain::GetDefaultAccepts() const
+{
+ return m_default_accept;
+}
+
+void
+LogFilterChain::SetDefaultAccepts(bool default_accept)
+{
+ m_default_accept = default_accept;
+}
+
+bool
+LogFilterChain::GetAcceptMessage(const LogMessage &message) const
+{
+ for (auto filter_sp : m_filters)
+ {
+ if (filter_sp->DoesMatch(message))
+ {
+ // This message matches this filter. If the filter accepts matches,
+ // this message matches; otherwise, it rejects matches.
+ return filter_sp->MatchesAreAccepted();
+ }
+ }
+
+ // None of the filters matched. Therefore, we do whatever the
+ // default fall-through rule says.
+ return m_default_accept;
+}
--- /dev/null
+//===-- LogFilterChain.h ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef LogFilterChain_h
+#define LogFilterChain_h
+
+#include <vector>
+
+#include "DarwinLogInterfaces.h"
+
+class LogFilterChain
+{
+public:
+
+ LogFilterChain(bool default_accept);
+
+ void
+ AppendFilter(const LogFilterSP &filter_sp);
+
+ void
+ ClearFilterChain();
+
+ bool
+ GetDefaultAccepts() const;
+
+ void
+ SetDefaultAccepts(bool default_accepts);
+
+ bool
+ GetAcceptMessage(const LogMessage &message) const;
+
+private:
+
+ using FilterVector = std::vector<LogFilterSP>;
+
+ FilterVector m_filters;
+ bool m_default_accept;
+
+};
+
+#endif /* LogFilterChain_hpp */
--- /dev/null
+//===-- LogFilterExactMatch.cpp ---------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LogFilterExactMatch.h"
+#include "LogMessage.h"
+
+LogFilterExactMatch::LogFilterExactMatch(bool match_accepts,
+ FilterTarget filter_target,
+ const std::string &match_text) :
+ LogFilter(match_accepts),
+ m_filter_target(filter_target),
+ m_match_text(match_text)
+{
+}
+
+bool
+LogFilterExactMatch::DoesMatch(const LogMessage &message) const
+{
+ switch (m_filter_target)
+ {
+ case eFilterTargetActivity:
+ // Empty fields never match a condition.
+ if (!message.HasActivity())
+ return false;
+ return m_match_text == message.GetActivity();
+ case eFilterTargetActivityChain:
+ // Empty fields never match a condition.
+ if (!message.HasActivity())
+ return false;
+ return m_match_text == message.GetActivityChain();
+ case eFilterTargetCategory:
+ // Empty fields never match a condition.
+ if (!message.HasCategory())
+ return false;
+ return m_match_text == message.GetCategory();
+ case eFilterTargetMessage:
+ {
+ const char *message_text = message.GetMessage();
+ return (message_text != nullptr) &&
+ (m_match_text == message_text);
+ }
+ case eFilterTargetSubsystem:
+ // Empty fields never match a condition.
+ if (!message.HasSubsystem())
+ return false;
+ return m_match_text == message.GetSubsystem();
+ default:
+ // We don't know this type.
+ return false;
+ }
+}
--- /dev/null
+//===-- LogFilterExactMatch.h -----------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LogFilterExactMatch_h
+#define LogFilterExactMatch_h
+
+#include <string>
+
+#include "DarwinLogInterfaces.h"
+#include "DarwinLogTypes.h"
+#include "LogFilter.h"
+
+class LogFilterExactMatch : public LogFilter
+{
+public:
+
+ LogFilterExactMatch(bool match_accepts, FilterTarget filter_target,
+ const std::string &match_text);
+
+ bool
+ DoesMatch(const LogMessage &message) const override;
+
+private:
+
+ const FilterTarget m_filter_target;
+ const std::string m_match_text;
+
+};
+
+#endif
--- /dev/null
+//===-- LogFilterRegex.cpp --------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "LogFilterRegex.h"
+
+#include "DNBLog.h"
+#include "LogMessage.h"
+
+//----------------------------------------------------------------------
+// Enable enhanced mode if it is available. This allows for things like
+// \d for digit, \s for space, and many more, but it isn't available
+// everywhere.
+//----------------------------------------------------------------------
+#if defined(REG_ENHANCED)
+#define DEFAULT_COMPILE_FLAGS (REG_ENHANCED|REG_EXTENDED)
+#else
+#define DEFAULT_COMPILE_FLAGS (REG_EXTENDED)
+#endif
+
+LogFilterRegex::LogFilterRegex(bool match_accepts,
+ FilterTarget filter_target,
+ const std::string ®ex) :
+ LogFilter(match_accepts),
+ m_filter_target(filter_target),
+ m_regex_text(regex),
+ m_regex(),
+ m_is_valid(false),
+ m_error_text()
+{
+ // Clear it.
+ memset(&m_regex, 0, sizeof(m_regex));
+
+ // Compile it.
+ if (!regex.empty())
+ {
+ auto comp_err = ::regcomp(&m_regex, regex.c_str(),
+ DEFAULT_COMPILE_FLAGS);
+ m_is_valid = (comp_err == 0);
+ if (!m_is_valid)
+ {
+ char buffer[256];
+ buffer[0] = '\0';
+ ::regerror(comp_err, &m_regex, buffer, sizeof(buffer));
+ m_error_text = buffer;
+ }
+ }
+}
+
+LogFilterRegex::~LogFilterRegex()
+{
+ if (m_is_valid)
+ {
+ // Free the regex internals.
+ regfree(&m_regex);
+ }
+}
+
+bool
+LogFilterRegex::DoesMatch(const LogMessage &message) const
+{
+ switch (m_filter_target)
+ {
+ case eFilterTargetActivity:
+ // Empty fields never match a condition.
+ if (!message.HasActivity())
+ return false;
+ return ::regexec(&m_regex, message.GetActivity(), 0, nullptr, 0)
+ == 0;
+ case eFilterTargetActivityChain:
+ // Empty fields never match a condition.
+ if (!message.HasActivity())
+ return false;
+ return ::regexec(&m_regex, message.GetActivityChain().c_str(), 0,
+ nullptr, 0) == 0;
+ case eFilterTargetCategory:
+ // Empty fields never match a condition.
+ if (!message.HasCategory())
+ return false;
+ return ::regexec(&m_regex, message.GetCategory(), 0, nullptr,
+ 0) == 0;
+ case eFilterTargetMessage:
+ {
+ const char *message_text = message.GetMessage();
+ if (!message_text)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "LogFilterRegex: regex "
+ "\"%s\" no match due to nullptr message.",
+ m_regex_text.c_str());
+ return false;
+ }
+
+ bool match = ::regexec(&m_regex, message_text, 0,
+ nullptr, 0) == 0;
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "LogFilterRegex: regex "
+ "\"%s\" %s message \"%s\".",
+ m_regex_text.c_str(),
+ match ? "matches" : "does not match",
+ message_text);
+ return match;
+ }
+ case eFilterTargetSubsystem:
+ // Empty fields never match a condition.
+ if (!message.HasSubsystem())
+ return false;
+ return ::regexec(&m_regex, message.GetSubsystem(), 0, nullptr,
+ 0) == 0;
+ default:
+ // We don't know this type.
+ return false;
+ }
+}
--- /dev/null
+//===-- LogFilterRegex.h ----------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef LogFilterRegex_h
+#define LogFilterRegex_h
+
+// C includes
+#include <regex.h>
+
+// C++ includes
+#include <string>
+
+#include "DarwinLogInterfaces.h"
+#include "DarwinLogTypes.h"
+#include "LogFilter.h"
+
+class LogFilterRegex : public LogFilter
+{
+public:
+
+ LogFilterRegex(bool match_accepts, FilterTarget filter_target,
+ const std::string ®ex);
+
+ virtual
+ ~LogFilterRegex();
+
+ bool
+ IsValid() const
+ {
+ return m_is_valid;
+ }
+
+ const char*
+ GetErrorAsCString() const
+ {
+ return m_error_text.c_str();
+ }
+
+ bool
+ DoesMatch(const LogMessage &message) const override;
+
+private:
+
+ const FilterTarget m_filter_target;
+ const std::string m_regex_text;
+ regex_t m_regex;
+ bool m_is_valid;
+ std::string m_error_text;
+};
+
+#endif /* LogFilterSubsystemRegex_hpp */
--- /dev/null
+//===-- LogMessage.cpp ------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "LogMessage.h"
+
+LogMessage::LogMessage()
+{
+}
+
+LogMessage::~LogMessage()
+{
+}
--- /dev/null
+//===-- LogMessage.h --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LogMessage_h
+#define LogMessage_h
+
+#include <string>
+
+class LogMessage
+{
+public:
+
+ virtual
+ ~LogMessage();
+
+ virtual bool
+ HasActivity() const = 0;
+
+ virtual const char*
+ GetActivity() const = 0;
+
+ virtual std::string
+ GetActivityChain() const = 0;
+
+ virtual bool
+ HasCategory() const = 0;
+
+ virtual const char*
+ GetCategory() const = 0;
+
+ virtual bool
+ HasSubsystem() const = 0;
+
+ virtual const char*
+ GetSubsystem() const = 0;
+
+ // This can be expensive, so once we ask for it, we'll cache the result.
+ virtual const char*
+ GetMessage() const = 0;
+
+protected:
+
+ LogMessage();
+
+};
+
+#endif /* LogMessage_h */
--- /dev/null
+//===-- LogMessageOsLog.cpp -------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LogMessageOsLog.h"
+
+#include "ActivityStore.h"
+#include "ActivityStreamSPI.h"
+
+namespace
+{
+ static os_log_copy_formatted_message_t s_log_copy_formatted_message;
+}
+
+void
+LogMessageOsLog::SetFormatterFunction(os_log_copy_formatted_message_t
+ format_func)
+{
+ s_log_copy_formatted_message = format_func;
+}
+
+LogMessageOsLog::LogMessageOsLog(const ActivityStore &activity_store,
+ ActivityStreamEntry &entry) :
+ LogMessage(),
+ m_activity_store(activity_store),
+ m_entry(entry),
+ m_message()
+{
+}
+
+bool
+LogMessageOsLog::HasActivity() const
+{
+ return m_entry.activity_id != 0;
+}
+
+const char*
+LogMessageOsLog::GetActivity() const
+{
+ return m_activity_store.GetActivityForID(m_entry.activity_id);
+}
+
+std::string
+LogMessageOsLog::GetActivityChain() const
+{
+ return m_activity_store.GetActivityChainForID(m_entry.activity_id);
+}
+
+bool
+LogMessageOsLog::HasCategory() const
+{
+ return m_entry.log_message.category &&
+ (m_entry.log_message.category[0] != 0);
+}
+
+const char*
+LogMessageOsLog::GetCategory() const
+{
+ return m_entry.log_message.category;
+}
+
+bool
+LogMessageOsLog::HasSubsystem() const
+{
+ return m_entry.log_message.subsystem &&
+ (m_entry.log_message.subsystem[0] != 0);
+}
+
+const char*
+LogMessageOsLog::GetSubsystem() const
+{
+ return m_entry.log_message.subsystem;
+}
+
+const char*
+LogMessageOsLog::GetMessage() const
+{
+ if (m_message.empty())
+ {
+ std::unique_ptr<char[]> formatted_message(
+ s_log_copy_formatted_message(&m_entry.log_message));
+ if (formatted_message)
+ m_message = formatted_message.get();
+ // else
+ // TODO log
+ }
+
+ // This is safe to return as we're not modifying it once we've formatted it.
+ return m_message.c_str();
+}
--- /dev/null
+//===-- LogMessageOsLog.h ---------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef LogMessageOsLog_h
+#define LogMessageOsLog_h
+
+#include "DarwinLogInterfaces.h"
+
+#include "ActivityStreamSPI.h"
+#include "LogMessage.h"
+
+using ActivityStreamEntry = struct os_activity_stream_entry_s;
+
+// -----------------------------------------------------------------------------
+/// Provides a unified wrapper around os_log()-style log messages.
+///
+/// The lifetime of this class is intended to be very short. The caller
+/// must ensure that the passed in ActivityStore and ActivityStreamEntry
+/// outlive this LogMessageOsLog entry.
+// -----------------------------------------------------------------------------
+
+class LogMessageOsLog : public LogMessage
+{
+public:
+
+ static void
+ SetFormatterFunction(os_log_copy_formatted_message_t format_func);
+
+ LogMessageOsLog(const ActivityStore &activity_store,
+ ActivityStreamEntry &entry);
+
+ // API methods
+
+ bool
+ HasActivity() const override;
+
+ const char*
+ GetActivity() const override;
+
+ std::string
+ GetActivityChain() const override;
+
+ bool
+ HasCategory() const override;
+
+ const char*
+ GetCategory() const override;
+
+ bool
+ HasSubsystem() const override;
+
+ const char*
+ GetSubsystem() const override;
+
+ const char*
+ GetMessage() const override;
+
+private:
+
+ const ActivityStore &m_activity_store;
+ ActivityStreamEntry &m_entry;
+ mutable std::string m_message;
+
+};
+
+#endif /* LogMessageOsLog_h */
--- /dev/null
+//===-- OsLogger.cpp --------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "OsLogger.h"
+
+#if LLDB_USE_OS_LOG
+
+#include <os/log.h>
+
+#include "DNBDefs.h"
+#include "DNBLog.h"
+
+#define LLDB_OS_LOG_MAX_BUFFER_LENGTH 256
+
+namespace
+{
+ //----------------------------------------------------------------------
+ // Darwin os_log logging callback that can be registered with
+ // DNBLogSetLogCallback
+ //----------------------------------------------------------------------
+ void
+ DarwinLogCallback(void *baton, uint32_t flags, const char *format,
+ va_list args)
+ {
+ if (format == nullptr)
+ return;
+
+ static os_log_t g_logger;
+ if (!g_logger)
+ {
+ g_logger = os_log_create("com.apple.dt.lldb", "debugserver");
+ if (!g_logger)
+ return;
+ }
+
+ os_log_type_t log_type;
+ if (flags & DNBLOG_FLAG_FATAL) log_type = OS_LOG_TYPE_FAULT;
+ else if (flags & DNBLOG_FLAG_ERROR) log_type = OS_LOG_TYPE_ERROR;
+ else if (flags & DNBLOG_FLAG_WARNING) log_type = OS_LOG_TYPE_DEFAULT;
+ else if (flags & DNBLOG_FLAG_VERBOSE) log_type = OS_LOG_TYPE_DEBUG;
+ else log_type = OS_LOG_TYPE_DEFAULT;
+
+ // This code is unfortunate. os_log* only takes static strings, but
+ // our current log API isn't set up to make use of that style.
+ char buffer[LLDB_OS_LOG_MAX_BUFFER_LENGTH];
+ vsnprintf(buffer, sizeof(buffer), format, args);
+ os_log_with_type(g_logger, log_type, "%{public}s", buffer);
+ }
+}
+
+DNBCallbackLog
+OsLogger::GetLogFunction()
+{
+ return _os_log_impl ? DarwinLogCallback : nullptr;
+}
+
+#else
+
+DNBCallbackLog
+OsLogger::GetLogFunction()
+{
+ return nullptr;
+}
+
+#endif
--- /dev/null
+//===-- OsLogger.h ----------------------------------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef OsLogger_h
+#define OsLogger_h
+
+#include "DNBDefs.h"
+
+class OsLogger
+{
+public:
+
+ static DNBCallbackLog
+ GetLogFunction();
+
+};
+
+#endif /* OsLogger_h */
s += "proc_stdio_available ";
if (events & event_proc_profile_data)
s += "proc_profile_data ";
+ if (events & event_darwin_log_data_available)
+ s += "darwin_log_data_available ";
if (events & event_read_packet_available)
s += "read_packet_available ";
if (events & event_read_thread_running)
public:
enum
{
- event_proc_state_changed = 0x01,
- event_proc_thread_running = 0x02, // Sticky
- event_proc_thread_exiting = 0x04,
- event_proc_stdio_available = 0x08,
- event_proc_profile_data = 0x10,
- event_read_packet_available = 0x20,
- event_read_thread_running = 0x40, // Sticky
- event_read_thread_exiting = 0x80,
+ event_proc_state_changed = 0x001,
+ event_proc_thread_running = 0x002, // Sticky
+ event_proc_thread_exiting = 0x004,
+ event_proc_stdio_available = 0x008,
+ event_proc_profile_data = 0x010,
+ event_read_packet_available = 0x020,
+ event_read_thread_running = 0x040, // Sticky
+ event_read_thread_exiting = 0x080,
+ event_darwin_log_data_available = 0x100,
normal_event_bits = event_proc_state_changed |
event_proc_thread_exiting |
event_proc_stdio_available |
event_proc_profile_data |
event_read_packet_available |
- event_read_thread_exiting,
+ event_read_thread_exiting |
+ event_darwin_log_data_available,
sticky_event_bits = event_proc_thread_running |
event_read_thread_running,
#include <sched.h>
#endif
+#include "DarwinLogCollector.h"
+#include "DarwinLogEvent.h"
#include "DNB.h"
#include "DNBDataRef.h"
#include "DNBLog.h"
#include "DNBThreadResumeActions.h"
#include "JSONGenerator.h"
+#include "OsLogger.h"
#include "RNBContext.h"
#include "RNBServices.h"
#include "RNBSocket.h"
+#include "JSON.h"
#include "lldb/Utility/StringExtractor.h"
#include "MacOSX/Genealogy.h"
#include "JSONGenerator.h"
#include <TargetConditionals.h> // for endianness predefines
//----------------------------------------------------------------------
+// constants
+//----------------------------------------------------------------------
+
+static const std::string OS_LOG_EVENTS_KEY_NAME("events");
+static const std::string JSON_ASYNC_TYPE_KEY_NAME("type");
+static const DarwinLogEventVector::size_type
+ DARWIN_LOG_MAX_EVENTS_PER_PACKET = 10;
+
+//----------------------------------------------------------------------
// std::iostream formatting macros
//----------------------------------------------------------------------
#define RAW_HEXBASE std::setfill('0') << std::hex << std::right
#define INDENT_WITH_TABS(iword_idx) std::setfill('\t') << std::setw((iword_idx)) << ""
// Class to handle communications via gdb remote protocol.
+//----------------------------------------------------------------------
+// Prototypes
+//----------------------------------------------------------------------
+
+static std::string
+binary_encode_string (const std::string &s);
//----------------------------------------------------------------------
// Decode a single hex character and return the hex value as a number or
t.push_back (Packet (set_detach_on_error, &RNBRemote::HandlePacket_QSetDetachOnError, NULL, "QSetDetachOnError:", "Set whether debugserver will detach (1) or kill (0) from the process it is controlling if it loses connection to lldb."));
t.push_back (Packet (speed_test, &RNBRemote::HandlePacket_qSpeedTest, NULL, "qSpeedTest:", "Test the maximum speed at which packet can be sent/received."));
t.push_back (Packet (query_transfer, &RNBRemote::HandlePacket_qXfer, NULL, "qXfer:", "Support the qXfer packet."));
+ t.push_back (Packet (query_supported_async_json_packets, &RNBRemote::HandlePacket_qStructuredDataPlugins, NULL, "qStructuredDataPlugins", "Query for the structured data plugins supported by the remote."));
+ t.push_back (Packet (configure_darwin_log, &RNBRemote::HandlePacket_QConfigureDarwinLog, NULL, "QConfigureDarwinLog:", "Configure the DarwinLog structured data plugin support."));
}
-
void
RNBRemote::FlushSTDIO ()
{
}
}
+void
+RNBRemote::SendAsyncDarwinLogData ()
+{
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): enter",
+ __FUNCTION__);
+
+ if (!m_ctx.HasValidProcessID())
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): ignoring due to"
+ "invalid process id", __FUNCTION__);
+ return;
+ }
+
+ nub_process_t pid = m_ctx.ProcessID();
+ DarwinLogEventVector::size_type entry_count = 0;
+
+ // NOTE: the current looping structure here does nothing
+ // to guarantee that we can send off async packets faster
+ // than we generate them. It will keep sending as long
+ // as there's data to send.
+ do
+ {
+ DarwinLogEventVector events =
+ DNBProcessGetAvailableDarwinLogEvents(pid);
+ entry_count = events.size();
+
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): outer loop enter",
+ __FUNCTION__);
+
+ for (DarwinLogEventVector::size_type base_entry = 0;
+ base_entry < entry_count;
+ base_entry += DARWIN_LOG_MAX_EVENTS_PER_PACKET)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): inner loop enter",
+ __FUNCTION__);
+
+ // We limit the total number of entries we pack
+ // into a single JSON async packet just so it
+ // doesn't get too large.
+ JSONGenerator::Dictionary async_dictionary;
+
+ // Specify the type of the JSON async data we're sending.
+ async_dictionary.AddStringItem(
+ JSON_ASYNC_TYPE_KEY_NAME, "DarwinLog");
+
+ // Create an array entry in the dictionary to hold all
+ // the events going in this packet.
+ JSONGenerator::ArraySP events_array(new JSONGenerator::Array());
+ async_dictionary.AddItem(OS_LOG_EVENTS_KEY_NAME, events_array);
+
+ // We bundle up to DARWIN_LOG_MAX_EVENTS_PER_PACKET events in
+ // a single packet.
+ const auto inner_loop_bound =
+ std::min(base_entry + DARWIN_LOG_MAX_EVENTS_PER_PACKET,
+ entry_count);
+ for (DarwinLogEventVector::size_type i = base_entry;
+ i < inner_loop_bound; ++i)
+ {
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): adding "
+ "entry index %lu to the JSON packet",
+ __FUNCTION__, i);
+ events_array->AddItem(events[i]);
+ }
+
+ // Send off the packet.
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): sending JSON "
+ "packet, %lu entries remain", __FUNCTION__,
+ entry_count - inner_loop_bound);
+ SendAsyncJSONPacket(async_dictionary);
+ }
+
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): outer loop exit",
+ __FUNCTION__);
+
+ } while (entry_count > 0);
+
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "RNBRemote::%s(): exit",
+ __PRETTY_FUNCTION__);
+}
+
rnb_err_t
RNBRemote::SendHexEncodedBytePacket (const char *header, const void *buf, size_t buf_len, const char *footer)
{
return SendPacket(packet);
}
+rnb_err_t
+RNBRemote::SendAsyncJSONPacket(const JSONGenerator::Dictionary &dictionary)
+{
+ std::ostringstream stream;
+ // We're choosing something that is easy to spot if we somehow get one
+ // of these coming out at the wrong time (i.e. when the remote side
+ // is not waiting for a process control completion response).
+ stream << "JSON-async:";
+ dictionary.Dump(stream);
+ const std::string payload = binary_encode_string(stream.str());
+ return SendPacket(payload);
+}
+
// Given a std::string packet contents to send, possibly encode/compress it.
// If compression is enabled, the returned std::string will be in one of two
// forms:
while (len--)
{
- unsigned char c = *str;
+ unsigned char c = *str++;
if (c == 0x7d && len > 0)
{
len--;
- str++;
- c = *str ^ 0x20;
+ c = *str++ ^ 0x20;
}
bytes.push_back (c);
}
// Quote any meta characters in a std::string as per the binary
// packet convention in the gdb-remote protocol.
-std::string
+static std::string
binary_encode_string (const std::string &s)
{
std::string output;
p += sizeof ("LOG_RNB_DEFAULT") - 1;
bitmask |= LOG_RNB_DEFAULT;
}
+ else if (strncmp (p, "LOG_DARWIN_LOG", sizeof ("LOG_DARWIN_LOG") - 1) == 0)
+ {
+ p += sizeof ("LOG_DARWIN_LOG") - 1;
+ bitmask |= LOG_DARWIN_LOG;
+ }
else if (strncmp (p, "LOG_RNB_NONE", sizeof ("LOG_RNB_NONE") - 1) == 0)
{
p += sizeof ("LOG_RNB_NONE") - 1;
// Did we get a properly formatted logging bitmask?
if (p && *p == ';')
{
- // Enable DNB logging
- DNBLogSetLogCallback(ASLLogCallback, NULL);
+ // Enable DNB logging.
+ // Use the existing log callback if one was already configured.
+ if (!DNBLogGetLogCallback())
+ {
+ // Use the os_log()-based logger if available; otherwise,
+ // fallback to ASL.
+ auto log_callback = OsLogger::GetLogFunction();
+ if (log_callback)
+ DNBLogSetLogCallback(log_callback, nullptr);
+ else
+ DNBLogSetLogCallback(ASLLogCallback, nullptr);
+ }
+
+ // Update logging to use the configured log channel bitmask.
DNBLogSetLogMask (bitmask);
p++;
}
}
// We're not going to support logging to a file for now. All logging
- // goes through ASL.
+ // goes through ASL or the previously arranged log callback.
#if 0
else if (strncmp (p, "mode=", sizeof ("mode=") - 1) == 0)
{
}
rnb_err_t
+RNBRemote::HandlePacket_qStructuredDataPlugins(const char *p)
+{
+ // We'll return a JSON array of supported packet types.
+ // The type is significant. For each of the supported
+ // packet types that have been enabled, there will be a
+ // 'J' async packet sent to the client with payload data.
+ // This payload data will be a JSON dictionary, and the
+ // top level dictionary will contain a string field with
+ // its value set to the relevant packet type from this list.
+ JSONGenerator::Array supported_json_packets;
+
+ // Check for DarwinLog (libtrace os_log/activity support).
+ if (DarwinLogCollector::IsSupported())
+ supported_json_packets.AddItem(JSONGenerator::StringSP(
+ new JSONGenerator::String("DarwinLog")));
+
+ // Send back the array.
+ std::ostringstream stream;
+ supported_json_packets.Dump(stream);
+ return SendPacket(stream.str());
+}
+
+rnb_err_t
+RNBRemote::HandlePacket_QConfigureDarwinLog(const char *p)
+{
+ if (!DarwinLogCollector::IsSupported())
+ {
+ // We should never have been given this request.
+ return SendPacket ("E89");
+ }
+
+ // Ensure we have a process. We expect a separate configure request for
+ // each process launched/attached.
+ const nub_process_t pid = m_ctx.ProcessID();
+ if (pid == INVALID_NUB_PROCESS)
+ return SendPacket ("E94");
+
+ // Get the configuration dictionary.
+ p += strlen("QConfigureDarwinLog:");
+
+ // The configuration dictionary is binary encoded.
+ std::vector<uint8_t> unescaped_config_data = decode_binary_data(p, -1);
+ std::string unescaped_config_string((const char*)&unescaped_config_data[0],
+ unescaped_config_data.size());
+ DNBLogThreadedIf(LOG_DARWIN_LOG, "DarwinLog: received config data: \"%s\"",
+ unescaped_config_string.c_str());
+ auto configuration_sp =
+ JSONParser(unescaped_config_string.c_str()).ParseJSONValue();
+ if (!configuration_sp)
+ {
+ // Malformed request - we require configuration data
+ // indicating whether we're enabling or disabling.
+ return SendPacket("E90");
+ }
+
+ if (!JSONObject::classof(configuration_sp.get()))
+ {
+ // Configuration data is not of the right type.
+ return SendPacket("E91");
+ }
+ JSONObject &config_dict = *static_cast<JSONObject*>(configuration_sp.get());
+
+ // Check if we're enabling or disabling.
+ auto enabled_sp = config_dict.GetObject("enabled");
+ if (!enabled_sp)
+ {
+ // Missing required "enabled" field.
+ return SendPacket("E92");
+ }
+ if (!JSONTrue::classof(enabled_sp.get()) &&
+ !JSONFalse::classof(enabled_sp.get()))
+ {
+ // Should be a boolean type, but wasn't.
+ return SendPacket("E93");
+ }
+ const bool enabling = JSONTrue::classof(enabled_sp.get());
+
+ // TODO - handle other configuration parameters here.
+
+ // Shut down any active activity stream for the process.
+ DarwinLogCollector::CancelStreamForProcess(pid);
+
+ if (enabling)
+ {
+ // Look up the procecess.
+ if (!DarwinLogCollector::StartCollectingForProcess(pid, config_dict))
+ return SendPacket("E95");
+ }
+
+ return SendPacket("OK");
+}
+
+rnb_err_t
RNBRemote::HandlePacket_QListThreadsInStopReply (const char *p)
{
// If this packet is received, it allows us to send an extra key/value
if (need_vouchers_comma_sep)
json << ",";
need_vouchers_comma_sep = true;
- json << "\"process_infos\":[";
bool printed_one_process_info = false;
for (auto iter = process_info_indexes.begin(); iter != process_info_indexes.end(); ++iter)
{
if (printed_one_process_info)
json << ",";
- else
- printed_one_process_info = true;
Genealogy::ProcessExecutableInfoSP image_info_sp;
uint32_t idx = *iter;
image_info_sp = DNBGetGenealogyImageInfo (pid, idx);
- json << "{";
- char uuid_buf[37];
- uuid_unparse_upper (image_info_sp->image_uuid, uuid_buf);
- json << "\"process_info_index\":" << idx << ",";
- json << "\"image_path\":\"" << json_string_quote_metachars (image_info_sp->image_path) << "\",";
- json << "\"image_uuid\":\"" << uuid_buf <<"\"";
- json << "}";
+ if (image_info_sp)
+ {
+ if (!printed_one_process_info)
+ {
+ json << "\"process_infos\":[";
+ printed_one_process_info = true;
+ }
+
+ json << "{";
+ char uuid_buf[37];
+ uuid_unparse_upper (image_info_sp->image_uuid, uuid_buf);
+ json << "\"process_info_index\":" << idx << ",";
+ json << "\"image_path\":\"" << json_string_quote_metachars (image_info_sp->image_path) << "\",";
+ json << "\"image_uuid\":\"" << uuid_buf <<"\"";
+ json << "}";
+ }
}
- json << "]";
+ if (printed_one_process_info)
+ json << "]";
}
}
else
speed_test, // 'qSpeedTest:'
set_detach_on_error, // 'QSetDetachOnError:'
query_transfer, // 'qXfer:'
+ query_supported_async_json_packets, // 'QSupportedAsyncJSONPackets'
+ configure_darwin_log, // 'ConfigureDarwinLog:'
unknown_type
} PacketEnum;
rnb_err_t HandlePacket_qXfer (const char *p);
rnb_err_t HandlePacket_stop_process (const char *p);
rnb_err_t HandlePacket_QSetDetachOnError (const char *p);
+ rnb_err_t HandlePacket_qStructuredDataPlugins (const char *p);
+ rnb_err_t HandlePacket_QConfigureDarwinLog (const char *p);
rnb_err_t SendStopReplyPacketForThread (nub_thread_t tid);
rnb_err_t SendHexEncodedBytePacket (const char *header, const void *buf, size_t buf_len, const char *footer);
void FlushSTDIO ();
void SendAsyncProfileData ();
rnb_err_t SendAsyncProfileDataPacket (char *buf, nub_size_t buf_size);
+ void SendAsyncDarwinLogData ();
+ rnb_err_t SendAsyncJSONPacket (const JSONGenerator::Dictionary &dictionary);
RNBContext& Context() { return m_ctx; }
RNBSocket& Comm() { return m_comm; }
#include "DNB.h"
#include "DNBLog.h"
#include "DNBTimer.h"
+#include "OsLogger.h"
#include "PseudoTerminal.h"
#include "RNBContext.h"
#include "RNBServices.h"
// Clear some bits if we are not running so we don't send any async packets
event_mask &= ~RNBContext::event_proc_stdio_available;
event_mask &= ~RNBContext::event_proc_profile_data;
+ // When we enable async structured data packets over another logical channel,
+ // this can be relaxed.
+ event_mask &= ~RNBContext::event_darwin_log_data_available;
}
// We want to make sure we consume all process state changes and have
remote->SendAsyncProfileData();
}
+ if (set_events & RNBContext::event_darwin_log_data_available)
+ {
+ remote->SendAsyncDarwinLogData();
+ }
+
if (set_events & RNBContext::event_read_packet_available)
{
// handleReceivedPacket will take care of resetting the
else
{
// Enable DNB logging
- DNBLogSetLogCallback(ASLLogCallback, NULL);
+
+ // if os_log() support is available, log through that.
+ auto log_callback = OsLogger::GetLogFunction();
+ if (log_callback)
+ {
+ DNBLogSetLogCallback(log_callback, nullptr);
+ DNBLog("debugserver will use os_log for internal logging.");
+ }
+ else
+ {
+ // Fall back to ASL support.
+ DNBLogSetLogCallback(ASLLogCallback, NULL);
+ DNBLog("debugserver will use ASL for internal logging.");
+ }
DNBLogSetLogMask (log_flags);
}
bOk = bOk && RegisterForEvent(strDbgId, CMIUtilString(lldb::SBThread::GetBroadcasterClassName()), eventMask);
eventMask = lldb::SBProcess::eBroadcastBitStateChanged | lldb::SBProcess::eBroadcastBitInterrupt |
- lldb::SBProcess::eBroadcastBitSTDOUT | lldb::SBProcess::eBroadcastBitSTDERR | lldb::SBProcess::eBroadcastBitProfileData;
+ lldb::SBProcess::eBroadcastBitSTDOUT | lldb::SBProcess::eBroadcastBitSTDERR | lldb::SBProcess::eBroadcastBitProfileData |
+ lldb::SBProcess::eBroadcastBitStructuredData;
bOk = bOk && RegisterForEvent(strDbgId, CMIUtilString(lldb::SBProcess::GetBroadcasterClassName()), eventMask);
eventMask = lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived | lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit |
case lldb::SBProcess::eBroadcastBitProfileData:
pEventType = "eBroadcastBitProfileData";
break;
+ case lldb::SBProcess::eBroadcastBitStructuredData:
+ pEventType = "eBroadcastBitStructuredData";
+ break;
case lldb::SBProcess::eBroadcastBitStateChanged:
pEventType = "eBroadcastBitStateChanged";
bOk = HandleProcessEventBroadcastBitStateChanged(vEvent);