//===-- Platform.h ----------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_Platform_h_
#define liblldb_Platform_h_
// C Includes
// C++ Includes
#include <map>
#include <string>
#include <vector>
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-public.h"
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/ConstString.h"
#include "lldb/Core/PluginInterface.h"
#include "lldb/Interpreter/Options.h"
#include "lldb/Host/Mutex.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Platform Platform.h "lldb/Target/Platform.h"
/// @brief A plug-in interface definition class for debug platform that
/// includes many platform abilities such as:
/// @li getting platform information such as supported architectures,
/// supported binary file formats and more
/// @li launching new processes
/// @li attaching to existing processes
/// @li download/upload files
/// @li execute shell commands
/// @li listing and getting info for existing processes
/// @li attaching and possibly debugging the platform's kernel
//----------------------------------------------------------------------
class Platform :
public PluginInterface
{
public:
//------------------------------------------------------------------
/// Get the native host platform plug-in.
///
/// There should only be one of these for each host that LLDB runs
/// upon that should be statically compiled in and registered using
/// preprocessor macros or other similar build mechanisms in a
/// PlatformSubclass::Initialize() function.
///
/// This platform will be used as the default platform when launching
/// or attaching to processes unless another platform is specified.
//------------------------------------------------------------------
static lldb::PlatformSP
GetDefaultPlatform ();
static lldb::PlatformSP
GetPlatformForArchitecture (const ArchSpec &arch,
ArchSpec *platform_arch_ptr);
static const char *
GetHostPlatformName ();
static void
SetDefaultPlatform (const lldb::PlatformSP &platform_sp);
static lldb::PlatformSP
Create (const char *platform_name, Error &error);
static lldb::PlatformSP
Create (const ArchSpec &arch, ArchSpec *platform_arch_ptr, Error &error);
static uint32_t
GetNumConnectedRemotePlatforms ();
static lldb::PlatformSP
GetConnectedRemotePlatformAtIndex (uint32_t idx);
//------------------------------------------------------------------
/// Default Constructor
//------------------------------------------------------------------
Platform (bool is_host_platform);
//------------------------------------------------------------------
/// Destructor.
///
/// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance.
//------------------------------------------------------------------
virtual
~Platform();
//------------------------------------------------------------------
/// Find a platform plugin for a given process.
///
/// Scans the installed Platform plug-ins and tries to find
/// an instance that can be used for \a process
///
/// @param[in] process
/// The process for which to try and locate a platform
/// plug-in instance.
///
/// @param[in] plugin_name
/// An optional name of a specific platform plug-in that
/// should be used. If NULL, pick the best plug-in.
//------------------------------------------------------------------
static Platform*
FindPlugin (Process *process, const ConstString &plugin_name);
//------------------------------------------------------------------
/// Set the target's executable based off of the existing
/// architecture information in \a target given a path to an
/// executable \a exe_file.
///
/// Each platform knows the architectures that it supports and can
/// select the correct architecture slice within \a exe_file by
/// inspecting the architecture in \a target. If the target had an
/// architecture specified, then in can try and obey that request
/// and optionally fail if the architecture doesn't match up.
/// If no architecture is specified, the platform should select the
/// default architecture from \a exe_file. Any application bundles
/// or executable wrappers can also be inspected for the actual
/// application binary within the bundle that should be used.
///
/// @return
/// Returns \b true if this Platform plug-in was able to find
/// a suitable executable, \b false otherwise.
//------------------------------------------------------------------
virtual Error
ResolveExecutable (const FileSpec &exe_file,
const ArchSpec &arch,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr);
//------------------------------------------------------------------
/// Find a symbol file given a symbol file module specification.
///
/// Each platform might have tricks to find symbol files for an
/// executable given information in a symbol file ModuleSpec. Some
/// platforms might also support symbol files that are bundles and
/// know how to extract the right symbol file given a bundle.
///
/// @param[in] target
/// The target in which we are trying to resolve the symbol file.
/// The target has a list of modules that we might be able to
/// use in order to help find the right symbol file. If the
/// "m_file" or "m_platform_file" entries in the \a sym_spec
/// are filled in, then we might be able to locate a module in
/// the target, extract its UUID and locate a symbol file.
/// If just the "m_uuid" is specified, then we might be able
/// to find the module in the target that matches that UUID
/// and pair the symbol file along with it. If just "m_symbol_file"
/// is specified, we can use a variety of tricks to locate the
/// symbols in an SDK, PDK, or other development kit location.
///
/// @param[in] sym_spec
/// A module spec that describes some information about the
/// symbol file we are trying to resolve. The ModuleSpec might
/// contain the following:
/// m_file - A full or partial path to an executable from the
/// target (might be empty).
/// m_platform_file - Another executable hint that contains
/// the path to the file as known on the
/// local/remote platform.
/// m_symbol_file - A full or partial path to a symbol file
/// or symbol bundle that should be used when
/// trying to resolve the symbol file.
/// m_arch - The architecture we are looking for when resolving
/// the symbol file.
/// m_uuid - The UUID of the executable and symbol file. This
/// can often be used to match up an exectuable with
/// a symbol file, or resolve an symbol file in a
/// symbol file bundle.
///
/// @param[out] sym_file
/// The resolved symbol file spec if the returned error
/// indicates succes.
///
/// @return
/// Returns an error that describes success or failure.
//------------------------------------------------------------------
virtual Error
ResolveSymbolFile (Target &target,
const ModuleSpec &sym_spec,
FileSpec &sym_file);
//------------------------------------------------------------------
/// Resolves the FileSpec to a (possibly) remote path. Remote
/// platforms must override this to resolve to a path on the remote
/// side.
//------------------------------------------------------------------
virtual bool
ResolveRemotePath (const FileSpec &platform_path,
FileSpec &resolved_platform_path);
bool
GetOSVersion (uint32_t &major,
uint32_t &minor,
uint32_t &update);
bool
SetOSVersion (uint32_t major,
uint32_t minor,
uint32_t update);
bool
GetOSBuildString (std::string &s);
bool
GetOSKernelDescription (std::string &s);
// Returns the the name of the platform
ConstString
GetName ();
virtual const char *
GetHostname ();
virtual const char *
GetDescription () = 0;
//------------------------------------------------------------------
/// Report the current status for this platform.
///
/// The returned string usually involves returning the OS version
/// (if available), and any SDK directory that might be being used
/// for local file caching, and if connected a quick blurb about
/// what this platform is connected to.
//------------------------------------------------------------------
virtual void
GetStatus (Stream &strm);
//------------------------------------------------------------------
// Subclasses must be able to fetch the current OS version
//
// Remote classes must be connected for this to succeed. Local
// subclasses don't need to override this function as it will just
// call the Host::GetOSVersion().
//------------------------------------------------------------------
virtual bool
GetRemoteOSVersion ()
{
return false;
}
virtual bool
GetRemoteOSBuildString (std::string &s)
{
s.clear();
return false;
}
virtual bool
GetRemoteOSKernelDescription (std::string &s)
{
s.clear();
return false;
}
// Remote Platform subclasses need to override this function
virtual ArchSpec
GetRemoteSystemArchitecture ()
{
return ArchSpec(); // Return an invalid architecture
}
virtual ConstString
GetRemoteWorkingDirectory()
{
return m_working_dir;
}
virtual bool
SetRemoteWorkingDirectory(const ConstString &path);
virtual const char *
GetUserName (uint32_t uid);
virtual const char *
GetGroupName (uint32_t gid);
//------------------------------------------------------------------
/// Locate a file for a platform.
///
/// The default implementation of this function will return the same
/// file patch in \a local_file as was in \a platform_file.
///
/// @param[in] platform_file
/// The platform file path to locate and cache locally.
///
/// @param[in] uuid_ptr
/// If we know the exact UUID of the file we are looking for, it
/// can be specified. If it is not specified, we might now know
/// the exact file. The UUID is usually some sort of MD5 checksum
/// for the file and is sometimes known by dynamic linkers/loaders.
/// If the UUID is known, it is best to supply it to platform
/// file queries to ensure we are finding the correct file, not
/// just a file at the correct path.
///
/// @param[out] local_file
/// A locally cached version of the platform file. For platforms
/// that describe the current host computer, this will just be
/// the same file. For remote platforms, this file might come from
/// and SDK directory, or might need to be sync'ed over to the
/// current machine for efficient debugging access.
///
/// @return
/// An error object.
//------------------------------------------------------------------
virtual Error
GetFileWithUUID (const FileSpec &platform_file,
const UUID *uuid_ptr,
FileSpec &local_file);
//----------------------------------------------------------------------
// Locate the scripting resource given a module specification.
//
// Locating the file should happen only on the local computer or using
// the current computers global settings.
//----------------------------------------------------------------------
virtual FileSpecList
LocateExecutableScriptingResources (Target *target,
Module &module);
virtual Error
GetSharedModule (const ModuleSpec &module_spec,
lldb::ModuleSP &module_sp,
const FileSpecList *module_search_paths_ptr,
lldb::ModuleSP *old_module_sp_ptr,
bool *did_create_ptr);
virtual Error
ConnectRemote (Args& args);
virtual Error
DisconnectRemote ();
//------------------------------------------------------------------
/// Get the platform's supported architectures in the order in which
/// they should be searched.
///
/// @param[in] idx
/// A zero based architecture index
///
/// @param[out] arch
/// A copy of the archgitecture at index if the return value is
/// \b true.
///
/// @return
/// \b true if \a arch was filled in and is valid, \b false
/// otherwise.
//------------------------------------------------------------------
virtual bool
GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch) = 0;
virtual size_t
GetSoftwareBreakpointTrapOpcode (Target &target,
BreakpointSite *bp_site) = 0;
//------------------------------------------------------------------
/// Launch a new process on a platform, not necessarily for
/// debugging, it could be just for running the process.
//------------------------------------------------------------------
virtual Error
LaunchProcess (ProcessLaunchInfo &launch_info);
//------------------------------------------------------------------
/// Lets a platform answer if it is compatible with a given
/// architecture and the target triple contained within.
//------------------------------------------------------------------
virtual bool
IsCompatibleArchitecture (const ArchSpec &arch,
bool exact_arch_match,
ArchSpec *compatible_arch_ptr);
//------------------------------------------------------------------
/// Not all platforms will support debugging a process by spawning
/// somehow halted for a debugger (specified using the
/// "eLaunchFlagDebug" launch flag) and then attaching. If your
/// platform doesn't support this, override this function and return
/// false.
//------------------------------------------------------------------
virtual bool
CanDebugProcess ()
{
return true;
}
//------------------------------------------------------------------
/// Subclasses do not need to implement this function as it uses
/// the Platform::LaunchProcess() followed by Platform::Attach ().
/// Remote platforms will want to subclass this function in order
/// to be able to intercept STDIO and possibly launch a separate
/// process that will debug the debuggee.
//------------------------------------------------------------------
virtual lldb::ProcessSP
DebugProcess (ProcessLaunchInfo &launch_info,
Debugger &debugger,
Target *target, // Can be NULL, if NULL create a new target, else use existing one
Listener &listener,
Error &error);
//------------------------------------------------------------------
/// Attach to an existing process using a process ID.
///
/// Each platform subclass needs to implement this function and
/// attempt to attach to the process with the process ID of \a pid.
/// The platform subclass should return an appropriate ProcessSP
/// subclass that is attached to the process, or an empty shared
/// pointer with an appriopriate error.
///
/// @param[in] pid
/// The process ID that we should attempt to attach to.
///
/// @return
/// An appropriate ProcessSP containing a valid shared pointer
/// to the default Process subclass for the platform that is
/// attached to the process, or an empty shared pointer with an
/// appriopriate error fill into the \a error object.
//------------------------------------------------------------------
virtual lldb::ProcessSP
Attach (ProcessAttachInfo &attach_info,
Debugger &debugger,
Target *target, // Can be NULL, if NULL create a new target, else use existing one
Listener &listener,
Error &error) = 0;
//------------------------------------------------------------------
/// Attach to an existing process by process name.
///
/// This function is not meant to be overridden by Process
/// subclasses. It will first call
/// Process::WillAttach (const char *) and if that returns \b
/// true, Process::DoAttach (const char *) will be called to
/// actually do the attach. If DoAttach returns \b true, then
/// Process::DidAttach() will be called.
///
/// @param[in] process_name
/// A process name to match against the current process list.
///
/// @return
/// Returns \a pid if attaching was successful, or
/// LLDB_INVALID_PROCESS_ID if attaching fails.
//------------------------------------------------------------------
// virtual lldb::ProcessSP
// Attach (const char *process_name,
// bool wait_for_launch,
// Error &error) = 0;
//------------------------------------------------------------------
// The base class Platform will take care of the host platform.
// Subclasses will need to fill in the remote case.
//------------------------------------------------------------------
virtual uint32_t
FindProcesses (const ProcessInstanceInfoMatch &match_info,
ProcessInstanceInfoList &proc_infos);
virtual bool
GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &proc_info);
//------------------------------------------------------------------
// Set a breakpoint on all functions that can end up creating a thread
// for this platform. This is needed when running expressions and
// also for process control.
//------------------------------------------------------------------
virtual lldb::BreakpointSP
SetThreadCreationBreakpoint (Target &target);
//------------------------------------------------------------------
// Given a target, find the local SDK directory if one exists on the
// current host.
//------------------------------------------------------------------
virtual lldb_private::ConstString
GetSDKDirectory (lldb_private::Target &target)
{
return lldb_private::ConstString();
}
const std::string &
GetRemoteURL () const
{
return m_remote_url;
}
bool
IsHost () const
{
return m_is_host; // Is this the default host platform?
}
bool
IsRemote () const
{
return !m_is_host;
}
virtual bool
IsConnected () const
{
// Remote subclasses should override this function
return IsHost();
}
const ArchSpec &
GetSystemArchitecture();
void
SetSystemArchitecture (const ArchSpec &arch)
{
m_system_arch = arch;
if (IsHost())
m_os_version_set_while_connected = m_system_arch.IsValid();
}
// Used for column widths
size_t
GetMaxUserIDNameLength() const
{
return m_max_uid_name_len;
}
// Used for column widths
size_t
GetMaxGroupIDNameLength() const
{
return m_max_gid_name_len;
}
const ConstString &
GetSDKRootDirectory () const
{
return m_sdk_sysroot;
}
void
SetSDKRootDirectory (const ConstString &dir)
{
m_sdk_sysroot = dir;
}
const ConstString &
GetSDKBuild () const
{
return m_sdk_build;
}
void
SetSDKBuild (const ConstString &sdk_build)
{
m_sdk_build = sdk_build;
}
ConstString
GetWorkingDirectory ();
bool
SetWorkingDirectory (const ConstString &path);
// There may be modules that we don't want to find by default for operations like "setting breakpoint by name".
// The platform will return "true" from this call if the passed in module happens to be one of these.
virtual bool
ModuleIsExcludedForNonModuleSpecificSearches (Target &target, const lldb::ModuleSP &module_sp)
{
return false;
}
virtual Error
MakeDirectory (const char *path, uint32_t permissions);
virtual Error
GetFilePermissions (const char *path, uint32_t &file_permissions);
virtual Error
SetFilePermissions (const char *path, uint32_t file_permissions);
virtual lldb::user_id_t
OpenFile (const FileSpec& file_spec,
uint32_t flags,
uint32_t mode,
Error &error)
{
return UINT64_MAX;
}
virtual bool
CloseFile (lldb::user_id_t fd,
Error &error)
{
return false;
}
virtual lldb::user_id_t
GetFileSize (const FileSpec& file_spec)
{
return UINT64_MAX;
}
virtual uint64_t
ReadFile (lldb::user_id_t fd,
uint64_t offset,
void *dst,
uint64_t dst_len,
Error &error)
{
error.SetErrorStringWithFormat ("Platform::ReadFile() is not supported in the %s platform", GetName().GetCString());
return -1;
}
virtual uint64_t
WriteFile (lldb::user_id_t fd,
uint64_t offset,
const void* src,
uint64_t src_len,
Error &error)
{
error.SetErrorStringWithFormat ("Platform::ReadFile() is not supported in the %s platform", GetName().GetCString());
return -1;
}
virtual Error
GetFile (const FileSpec& source,
const FileSpec& destination);
virtual Error
PutFile (const FileSpec& source,
const FileSpec& destination,
uint32_t uid = UINT32_MAX,
uint32_t gid = UINT32_MAX);
virtual Error
CreateSymlink (const char *src, // The name of the link is in src
const char *dst);// The symlink points to dst
//----------------------------------------------------------------------
/// Install a file or directory to the remote system.
///
/// Install is similar to Platform::PutFile(), but it differs in that if
/// an application/framework/shared library is installed on a remote
/// platform and the remote platform requires something to be done to
/// register the application/framework/shared library, then this extra
/// registration can be done.
///
/// @param[in] src
/// The source file/directory to install on the remote system.
///
/// @param[in] dst
/// The destination file/directory where \a src will be installed.
/// If \a dst has no filename specified, then its filename will
/// be set from \a src. It \a dst has no directory specified, it
/// will use the platform working directory. If \a dst has a
/// directory specified, but the directory path is relative, the
/// platform working directory will be prepended to the relative
/// directory.
///
/// @return
/// An error object that describes anything that went wrong.
//----------------------------------------------------------------------
virtual Error
Install (const FileSpec& src, const FileSpec& dst);
virtual size_t
GetEnvironment (StringList &environment);
virtual bool
GetFileExists (const lldb_private::FileSpec& file_spec);
virtual Error
Unlink (const char *path);
virtual bool
GetSupportsRSync ()
{
return m_supports_rsync;
}
virtual void
SetSupportsRSync(bool flag)
{
m_supports_rsync = flag;
}
virtual const char*
GetRSyncOpts ()
{
return m_rsync_opts.c_str();
}
virtual void
SetRSyncOpts (const char* opts)
{
m_rsync_opts.assign(opts);
}
virtual const char*
GetRSyncPrefix ()
{
return m_rsync_prefix.c_str();
}
virtual void
SetRSyncPrefix (const char* prefix)
{
m_rsync_prefix.assign(prefix);
}
virtual bool
GetSupportsSSH ()
{
return m_supports_ssh;
}
virtual void
SetSupportsSSH(bool flag)
{
m_supports_ssh = flag;
}
virtual const char*
GetSSHOpts ()
{
return m_ssh_opts.c_str();
}
virtual void
SetSSHOpts (const char* opts)
{
m_ssh_opts.assign(opts);
}
virtual bool
GetIgnoresRemoteHostname ()
{
return m_ignores_remote_hostname;
}
virtual void
SetIgnoresRemoteHostname(bool flag)
{
m_ignores_remote_hostname = flag;
}
virtual lldb_private::OptionGroupOptions *
GetConnectionOptions (CommandInterpreter& interpreter)
{
return NULL;
}
virtual lldb_private::Error
RunShellCommand (const char *command, // Shouldn't be NULL
const char *working_dir, // Pass NULL to use the current working directory
int *status_ptr, // Pass NULL if you don't want the process exit status
int *signo_ptr, // Pass NULL if you don't want the signal that caused the process to exit
std::string *command_output, // Pass NULL if you don't want the command output
uint32_t timeout_sec); // Timeout in seconds to wait for shell program to finish
virtual void
SetLocalCacheDirectory (const char* local);
virtual const char*
GetLocalCacheDirectory ();
virtual std::string
GetPlatformSpecificConnectionInformation()
{
return "";
}
virtual bool
CalculateMD5 (const FileSpec& file_spec,
uint64_t &low,
uint64_t &high);
virtual int32_t
GetResumeCountForLaunchInfo (ProcessLaunchInfo &launch_info)
{
return 1;
}
//------------------------------------------------------------------
/// Locate a queue name given a thread's qaddr
///
/// On a system using libdispatch ("Grand Central Dispatch") style
/// queues, a thread may be associated with a GCD queue or not,
/// and a queue may be associated with multiple threads.
/// The process/thread must provide a way to find the "dispatch_qaddr"
/// for each thread, and from that dispatch_qaddr this Platform method
/// will locate the queue name and provide that.
///
/// @param[in] process
/// A process is required for reading memory.
///
/// @param[in] dispatch_qaddr
/// The dispatch_qaddr for this thread.
///
/// @return
/// The name of the queue, if there is one. An empty string
/// means that this thread is not associated with a dispatch
/// queue.
//------------------------------------------------------------------
virtual std::string
GetQueueNameForThreadQAddress (Process *process, lldb::addr_t dispatch_qaddr)
{
return "";
}
//------------------------------------------------------------------
/// Locate a queue ID given a thread's qaddr
///
/// On a system using libdispatch ("Grand Central Dispatch") style
/// queues, a thread may be associated with a GCD queue or not,
/// and a queue may be associated with multiple threads.
/// The process/thread must provide a way to find the "dispatch_qaddr"
/// for each thread, and from that dispatch_qaddr this Platform method
/// will locate the queue ID and provide that.
///
/// @param[in] process
/// A process is required for reading memory.
///
/// @param[in] dispatch_qaddr
/// The dispatch_qaddr for this thread.
///
/// @return
/// The queue_id for this thread, if this thread is associated
/// with a dispatch queue. Else LLDB_INVALID_QUEUE_ID is returned.
//------------------------------------------------------------------
virtual lldb::queue_id_t
GetQueueIDForThreadQAddress (Process *process, lldb::addr_t dispatch_qaddr)
{
return LLDB_INVALID_QUEUE_ID;
}
//------------------------------------------------------------------
/// Provide a list of trap handler function names for this platform
///
/// The unwinder needs to treat trap handlers specially -- the stack
/// frame may not be aligned correctly for a trap handler (the kernel
/// often won't perturb the stack pointer, or won't re-align it properly,
/// in the process of calling the handler) and the frame above the handler
/// needs to be treated by the unwinder's "frame 0" rules instead of its
/// "middle of the stack frame" rules.
///
/// In a user process debugging scenario, the list of trap handlers is
/// typically just "_sigtramp".
///
/// The Platform base class provides the m_trap_handlers ivar but it does
/// not populate it. Subclasses should add the names of the asynchronous
/// signal handler routines as needed. For most Unix platforms, add _sigtramp.
///
/// @return
/// A list of symbol names. The list may be empty.
//------------------------------------------------------------------
virtual const std::vector<ConstString> &
GetTrapHandlerSymbolNames ();
protected:
bool m_is_host;
// Set to true when we are able to actually set the OS version while
// being connected. For remote platforms, we might set the version ahead
// of time before we actually connect and this version might change when
// we actually connect to a remote platform. For the host platform this
// will be set to the once we call Host::GetOSVersion().
bool m_os_version_set_while_connected;
bool m_system_arch_set_while_connected;
ConstString m_sdk_sysroot; // the root location of where the SDK files are all located
ConstString m_sdk_build;
ConstString m_working_dir; // The working directory which is used when installing modules that have no install path set
std::string m_remote_url;
std::string m_name;
uint32_t m_major_os_version;
uint32_t m_minor_os_version;
uint32_t m_update_os_version;
ArchSpec m_system_arch; // The architecture of the kernel or the remote platform
typedef std::map<uint32_t, ConstString> IDToNameMap;
Mutex m_uid_map_mutex;
Mutex m_gid_map_mutex;
IDToNameMap m_uid_map;
IDToNameMap m_gid_map;
size_t m_max_uid_name_len;
size_t m_max_gid_name_len;
bool m_supports_rsync;
std::string m_rsync_opts;
std::string m_rsync_prefix;
bool m_supports_ssh;
std::string m_ssh_opts;
bool m_ignores_remote_hostname;
std::string m_local_cache_directory;
std::vector<ConstString> m_trap_handlers;
bool m_calculated_trap_handlers;
//------------------------------------------------------------------
/// Ask the Platform subclass to fill in the list of trap handler names
///
/// For most Unix user process environments, this will be a single
/// function name, _sigtramp. More specialized environments may have
/// additional handler names. The unwinder code needs to know when a
/// trap handler is on the stack because the unwind rules for the frame
/// that caused the trap are different.
///
/// The base class Platform ivar m_trap_handlers should be updated by
/// the Platform subclass when this method is called. If there are no
/// predefined trap handlers, this method may be a no-op.
//------------------------------------------------------------------
virtual void
CalculateTrapHandlerSymbolNames () = 0;
const char *
GetCachedUserName (uint32_t uid)
{
Mutex::Locker locker (m_uid_map_mutex);
IDToNameMap::iterator pos = m_uid_map.find (uid);
if (pos != m_uid_map.end())
{
// return the empty string if our string is NULL
// so we can tell when things were in the negative
// cached (didn't find a valid user name, don't keep
// trying)
return pos->second.AsCString("");
}
return NULL;
}
const char *
SetCachedUserName (uint32_t uid, const char *name, size_t name_len)
{
Mutex::Locker locker (m_uid_map_mutex);
ConstString const_name (name);
m_uid_map[uid] = const_name;
if (m_max_uid_name_len < name_len)
m_max_uid_name_len = name_len;
// Const strings lives forever in our const string pool, so we can return the const char *
return const_name.GetCString();
}
void
SetUserNameNotFound (uint32_t uid)
{
Mutex::Locker locker (m_uid_map_mutex);
m_uid_map[uid] = ConstString();
}
void
ClearCachedUserNames ()
{
Mutex::Locker locker (m_uid_map_mutex);
m_uid_map.clear();
}
const char *
GetCachedGroupName (uint32_t gid)
{
Mutex::Locker locker (m_gid_map_mutex);
IDToNameMap::iterator pos = m_gid_map.find (gid);
if (pos != m_gid_map.end())
{
// return the empty string if our string is NULL
// so we can tell when things were in the negative
// cached (didn't find a valid group name, don't keep
// trying)
return pos->second.AsCString("");
}
return NULL;
}
const char *
SetCachedGroupName (uint32_t gid, const char *name, size_t name_len)
{
Mutex::Locker locker (m_gid_map_mutex);
ConstString const_name (name);
m_gid_map[gid] = const_name;
if (m_max_gid_name_len < name_len)
m_max_gid_name_len = name_len;
// Const strings lives forever in our const string pool, so we can return the const char *
return const_name.GetCString();
}
void
SetGroupNameNotFound (uint32_t gid)
{
Mutex::Locker locker (m_gid_map_mutex);
m_gid_map[gid] = ConstString();
}
void
ClearCachedGroupNames ()
{
Mutex::Locker locker (m_gid_map_mutex);
m_gid_map.clear();
}
private:
DISALLOW_COPY_AND_ASSIGN (Platform);
};
class PlatformList
{
public:
PlatformList() :
m_mutex (Mutex::eMutexTypeRecursive),
m_platforms (),
m_selected_platform_sp()
{
}
~PlatformList()
{
}
void
Append (const lldb::PlatformSP &platform_sp, bool set_selected)
{
Mutex::Locker locker (m_mutex);
m_platforms.push_back (platform_sp);
if (set_selected)
m_selected_platform_sp = m_platforms.back();
}
size_t
GetSize()
{
Mutex::Locker locker (m_mutex);
return m_platforms.size();
}
lldb::PlatformSP
GetAtIndex (uint32_t idx)
{
lldb::PlatformSP platform_sp;
{
Mutex::Locker locker (m_mutex);
if (idx < m_platforms.size())
platform_sp = m_platforms[idx];
}
return platform_sp;
}
//------------------------------------------------------------------
/// Select the active platform.
///
/// In order to debug remotely, other platform's can be remotely
/// connected to and set as the selected platform for any subsequent
/// debugging. This allows connection to remote targets and allows
/// the ability to discover process info, launch and attach to remote
/// processes.
//------------------------------------------------------------------
lldb::PlatformSP
GetSelectedPlatform ()
{
Mutex::Locker locker (m_mutex);
if (!m_selected_platform_sp && !m_platforms.empty())
m_selected_platform_sp = m_platforms.front();
return m_selected_platform_sp;
}
void
SetSelectedPlatform (const lldb::PlatformSP &platform_sp)
{
if (platform_sp)
{
Mutex::Locker locker (m_mutex);
const size_t num_platforms = m_platforms.size();
for (size_t idx=0; idx<num_platforms; ++idx)
{
if (m_platforms[idx].get() == platform_sp.get())
{
m_selected_platform_sp = m_platforms[idx];
return;
}
}
m_platforms.push_back (platform_sp);
m_selected_platform_sp = m_platforms.back();
}
}
protected:
typedef std::vector<lldb::PlatformSP> collection;
mutable Mutex m_mutex;
collection m_platforms;
lldb::PlatformSP m_selected_platform_sp;
private:
DISALLOW_COPY_AND_ASSIGN (PlatformList);
};
class OptionGroupPlatformRSync : public lldb_private::OptionGroup
{
public:
OptionGroupPlatformRSync ();
virtual
~OptionGroupPlatformRSync ();
virtual lldb_private::Error
SetOptionValue (CommandInterpreter &interpreter,
uint32_t option_idx,
const char *option_value);
void
OptionParsingStarting (CommandInterpreter &interpreter);
const lldb_private::OptionDefinition*
GetDefinitions ();
virtual uint32_t
GetNumDefinitions ();
// Options table: Required for subclasses of Options.
static lldb_private::OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
bool m_rsync;
std::string m_rsync_opts;
std::string m_rsync_prefix;
bool m_ignores_remote_hostname;
private:
DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformRSync);
};
class OptionGroupPlatformSSH : public lldb_private::OptionGroup
{
public:
OptionGroupPlatformSSH ();
virtual
~OptionGroupPlatformSSH ();
virtual lldb_private::Error
SetOptionValue (CommandInterpreter &interpreter,
uint32_t option_idx,
const char *option_value);
void
OptionParsingStarting (CommandInterpreter &interpreter);
virtual uint32_t
GetNumDefinitions ();
const lldb_private::OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb_private::OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
bool m_ssh;
std::string m_ssh_opts;
private:
DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformSSH);
};
class OptionGroupPlatformCaching : public lldb_private::OptionGroup
{
public:
OptionGroupPlatformCaching ();
virtual
~OptionGroupPlatformCaching ();
virtual lldb_private::Error
SetOptionValue (CommandInterpreter &interpreter,
uint32_t option_idx,
const char *option_value);
void
OptionParsingStarting (CommandInterpreter &interpreter);
virtual uint32_t
GetNumDefinitions ();
const lldb_private::OptionDefinition*
GetDefinitions ();
// Options table: Required for subclasses of Options.
static lldb_private::OptionDefinition g_option_table[];
// Instance variables to hold the values for command options.
std::string m_cache_dir;
private:
DISALLOW_COPY_AND_ASSIGN(OptionGroupPlatformCaching);
};
} // namespace lldb_private
#endif // liblldb_Platform_h_
