You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1985 lines
68 KiB
1985 lines
68 KiB
//===-- Platform.cpp ------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <algorithm>
|
|
#include <csignal>
|
|
#include <fstream>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "lldb/Breakpoint/BreakpointIDList.h"
|
|
#include "lldb/Breakpoint/BreakpointLocation.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/StreamFile.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Host/OptionParser.h"
|
|
#include "lldb/Interpreter/OptionValueFileSpec.h"
|
|
#include "lldb/Interpreter/OptionValueProperties.h"
|
|
#include "lldb/Interpreter/Property.h"
|
|
#include "lldb/Symbol/ObjectFile.h"
|
|
#include "lldb/Target/ModuleCache.h"
|
|
#include "lldb/Target/Platform.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Target/UnixSignals.h"
|
|
#include "lldb/Utility/DataBufferHeap.h"
|
|
#include "lldb/Utility/FileSpec.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Status.h"
|
|
#include "lldb/Utility/StructuredData.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/Path.h"
|
|
|
|
// Define these constants from POSIX mman.h rather than include the file so
|
|
// that they will be correct even when compiled on Linux.
|
|
#define MAP_PRIVATE 2
|
|
#define MAP_ANON 0x1000
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
static uint32_t g_initialize_count = 0;
|
|
|
|
// Use a singleton function for g_local_platform_sp to avoid init constructors
|
|
// since LLDB is often part of a shared library
|
|
static PlatformSP &GetHostPlatformSP() {
|
|
static PlatformSP g_platform_sp;
|
|
return g_platform_sp;
|
|
}
|
|
|
|
const char *Platform::GetHostPlatformName() { return "host"; }
|
|
|
|
namespace {
|
|
|
|
#define LLDB_PROPERTIES_platform
|
|
#include "TargetProperties.inc"
|
|
|
|
enum {
|
|
#define LLDB_PROPERTIES_platform
|
|
#include "TargetPropertiesEnum.inc"
|
|
};
|
|
|
|
} // namespace
|
|
|
|
ConstString PlatformProperties::GetSettingName() {
|
|
static ConstString g_setting_name("platform");
|
|
return g_setting_name;
|
|
}
|
|
|
|
PlatformProperties::PlatformProperties() {
|
|
m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
|
|
m_collection_sp->Initialize(g_platform_properties);
|
|
|
|
auto module_cache_dir = GetModuleCacheDirectory();
|
|
if (module_cache_dir)
|
|
return;
|
|
|
|
llvm::SmallString<64> user_home_dir;
|
|
if (!FileSystem::Instance().GetHomeDirectory(user_home_dir))
|
|
return;
|
|
|
|
module_cache_dir = FileSpec(user_home_dir.c_str());
|
|
module_cache_dir.AppendPathComponent(".lldb");
|
|
module_cache_dir.AppendPathComponent("module_cache");
|
|
SetDefaultModuleCacheDirectory(module_cache_dir);
|
|
SetModuleCacheDirectory(module_cache_dir);
|
|
}
|
|
|
|
bool PlatformProperties::GetUseModuleCache() const {
|
|
const auto idx = ePropertyUseModuleCache;
|
|
return m_collection_sp->GetPropertyAtIndexAsBoolean(
|
|
nullptr, idx, g_platform_properties[idx].default_uint_value != 0);
|
|
}
|
|
|
|
bool PlatformProperties::SetUseModuleCache(bool use_module_cache) {
|
|
return m_collection_sp->SetPropertyAtIndexAsBoolean(
|
|
nullptr, ePropertyUseModuleCache, use_module_cache);
|
|
}
|
|
|
|
FileSpec PlatformProperties::GetModuleCacheDirectory() const {
|
|
return m_collection_sp->GetPropertyAtIndexAsFileSpec(
|
|
nullptr, ePropertyModuleCacheDirectory);
|
|
}
|
|
|
|
bool PlatformProperties::SetModuleCacheDirectory(const FileSpec &dir_spec) {
|
|
return m_collection_sp->SetPropertyAtIndexAsFileSpec(
|
|
nullptr, ePropertyModuleCacheDirectory, dir_spec);
|
|
}
|
|
|
|
void PlatformProperties::SetDefaultModuleCacheDirectory(
|
|
const FileSpec &dir_spec) {
|
|
auto f_spec_opt = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(
|
|
nullptr, false, ePropertyModuleCacheDirectory);
|
|
assert(f_spec_opt);
|
|
f_spec_opt->SetDefaultValue(dir_spec);
|
|
}
|
|
|
|
/// 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.
|
|
///
|
|
/// This platform will be used as the default platform when launching
|
|
/// or attaching to processes unless another platform is specified.
|
|
PlatformSP Platform::GetHostPlatform() { return GetHostPlatformSP(); }
|
|
|
|
static std::vector<PlatformSP> &GetPlatformList() {
|
|
static std::vector<PlatformSP> g_platform_list;
|
|
return g_platform_list;
|
|
}
|
|
|
|
static std::recursive_mutex &GetPlatformListMutex() {
|
|
static std::recursive_mutex g_mutex;
|
|
return g_mutex;
|
|
}
|
|
|
|
void Platform::Initialize() { g_initialize_count++; }
|
|
|
|
void Platform::Terminate() {
|
|
if (g_initialize_count > 0) {
|
|
if (--g_initialize_count == 0) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
GetPlatformList().clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
const PlatformPropertiesSP &Platform::GetGlobalPlatformProperties() {
|
|
static const auto g_settings_sp(std::make_shared<PlatformProperties>());
|
|
return g_settings_sp;
|
|
}
|
|
|
|
void Platform::SetHostPlatform(const lldb::PlatformSP &platform_sp) {
|
|
// The native platform should use its static void Platform::Initialize()
|
|
// function to register itself as the native platform.
|
|
GetHostPlatformSP() = platform_sp;
|
|
|
|
if (platform_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
GetPlatformList().push_back(platform_sp);
|
|
}
|
|
}
|
|
|
|
Status Platform::GetFileWithUUID(const FileSpec &platform_file,
|
|
const UUID *uuid_ptr, FileSpec &local_file) {
|
|
// Default to the local case
|
|
local_file = platform_file;
|
|
return Status();
|
|
}
|
|
|
|
FileSpecList
|
|
Platform::LocateExecutableScriptingResources(Target *target, Module &module,
|
|
Stream *feedback_stream) {
|
|
return FileSpecList();
|
|
}
|
|
|
|
// PlatformSP
|
|
// Platform::FindPlugin (Process *process, ConstString plugin_name)
|
|
//{
|
|
// PlatformCreateInstance create_callback = nullptr;
|
|
// if (plugin_name)
|
|
// {
|
|
// create_callback =
|
|
// PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
|
|
// if (create_callback)
|
|
// {
|
|
// ArchSpec arch;
|
|
// if (process)
|
|
// {
|
|
// arch = process->GetTarget().GetArchitecture();
|
|
// }
|
|
// PlatformSP platform_sp(create_callback(process, &arch));
|
|
// if (platform_sp)
|
|
// return platform_sp;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// for (uint32_t idx = 0; (create_callback =
|
|
// PluginManager::GetPlatformCreateCallbackAtIndex(idx)) != nullptr;
|
|
// ++idx)
|
|
// {
|
|
// PlatformSP platform_sp(create_callback(process, nullptr));
|
|
// if (platform_sp)
|
|
// return platform_sp;
|
|
// }
|
|
// }
|
|
// return PlatformSP();
|
|
//}
|
|
|
|
Status Platform::GetSharedModule(
|
|
const ModuleSpec &module_spec, Process *process, ModuleSP &module_sp,
|
|
const FileSpecList *module_search_paths_ptr,
|
|
llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr) {
|
|
if (IsHost())
|
|
return ModuleList::GetSharedModule(module_spec, module_sp,
|
|
module_search_paths_ptr, old_modules,
|
|
did_create_ptr, false);
|
|
|
|
// Module resolver lambda.
|
|
auto resolver = [&](const ModuleSpec &spec) {
|
|
Status error(eErrorTypeGeneric);
|
|
ModuleSpec resolved_spec;
|
|
// Check if we have sysroot set.
|
|
if (m_sdk_sysroot) {
|
|
// Prepend sysroot to module spec.
|
|
resolved_spec = spec;
|
|
resolved_spec.GetFileSpec().PrependPathComponent(
|
|
m_sdk_sysroot.GetStringRef());
|
|
// Try to get shared module with resolved spec.
|
|
error = ModuleList::GetSharedModule(resolved_spec, module_sp,
|
|
module_search_paths_ptr, old_modules,
|
|
did_create_ptr, false);
|
|
}
|
|
// If we don't have sysroot or it didn't work then
|
|
// try original module spec.
|
|
if (!error.Success()) {
|
|
resolved_spec = spec;
|
|
error = ModuleList::GetSharedModule(resolved_spec, module_sp,
|
|
module_search_paths_ptr, old_modules,
|
|
did_create_ptr, false);
|
|
}
|
|
if (error.Success() && module_sp)
|
|
module_sp->SetPlatformFileSpec(resolved_spec.GetFileSpec());
|
|
return error;
|
|
};
|
|
|
|
return GetRemoteSharedModule(module_spec, process, module_sp, resolver,
|
|
did_create_ptr);
|
|
}
|
|
|
|
bool Platform::GetModuleSpec(const FileSpec &module_file_spec,
|
|
const ArchSpec &arch, ModuleSpec &module_spec) {
|
|
ModuleSpecList module_specs;
|
|
if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
|
|
module_specs) == 0)
|
|
return false;
|
|
|
|
ModuleSpec matched_module_spec;
|
|
return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
|
|
module_spec);
|
|
}
|
|
|
|
PlatformSP Platform::Find(ConstString name) {
|
|
if (name) {
|
|
static ConstString g_host_platform_name("host");
|
|
if (name == g_host_platform_name)
|
|
return GetHostPlatform();
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
for (const auto &platform_sp : GetPlatformList()) {
|
|
if (platform_sp->GetName() == name)
|
|
return platform_sp;
|
|
}
|
|
}
|
|
return PlatformSP();
|
|
}
|
|
|
|
PlatformSP Platform::Create(ConstString name, Status &error) {
|
|
PlatformCreateInstance create_callback = nullptr;
|
|
lldb::PlatformSP platform_sp;
|
|
if (name) {
|
|
static ConstString g_host_platform_name("host");
|
|
if (name == g_host_platform_name)
|
|
return GetHostPlatform();
|
|
|
|
create_callback =
|
|
PluginManager::GetPlatformCreateCallbackForPluginName(name);
|
|
if (create_callback)
|
|
platform_sp = create_callback(true, nullptr);
|
|
else
|
|
error.SetErrorStringWithFormat(
|
|
"unable to find a plug-in for the platform named \"%s\"",
|
|
name.GetCString());
|
|
} else
|
|
error.SetErrorString("invalid platform name");
|
|
|
|
if (platform_sp) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
GetPlatformList().push_back(platform_sp);
|
|
}
|
|
|
|
return platform_sp;
|
|
}
|
|
|
|
PlatformSP Platform::Create(const ArchSpec &arch, ArchSpec *platform_arch_ptr,
|
|
Status &error) {
|
|
lldb::PlatformSP platform_sp;
|
|
if (arch.IsValid()) {
|
|
// Scope for locker
|
|
{
|
|
// First try exact arch matches across all platforms already created
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
for (const auto &platform_sp : GetPlatformList()) {
|
|
if (platform_sp->IsCompatibleArchitecture(arch, true,
|
|
platform_arch_ptr))
|
|
return platform_sp;
|
|
}
|
|
|
|
// Next try compatible arch matches across all platforms already created
|
|
for (const auto &platform_sp : GetPlatformList()) {
|
|
if (platform_sp->IsCompatibleArchitecture(arch, false,
|
|
platform_arch_ptr))
|
|
return platform_sp;
|
|
}
|
|
}
|
|
|
|
PlatformCreateInstance create_callback;
|
|
// First try exact arch matches across all platform plug-ins
|
|
uint32_t idx;
|
|
for (idx = 0; (create_callback =
|
|
PluginManager::GetPlatformCreateCallbackAtIndex(idx));
|
|
++idx) {
|
|
if (create_callback) {
|
|
platform_sp = create_callback(false, &arch);
|
|
if (platform_sp &&
|
|
platform_sp->IsCompatibleArchitecture(arch, true,
|
|
platform_arch_ptr)) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
GetPlatformList().push_back(platform_sp);
|
|
return platform_sp;
|
|
}
|
|
}
|
|
}
|
|
// Next try compatible arch matches across all platform plug-ins
|
|
for (idx = 0; (create_callback =
|
|
PluginManager::GetPlatformCreateCallbackAtIndex(idx));
|
|
++idx) {
|
|
if (create_callback) {
|
|
platform_sp = create_callback(false, &arch);
|
|
if (platform_sp &&
|
|
platform_sp->IsCompatibleArchitecture(arch, false,
|
|
platform_arch_ptr)) {
|
|
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
|
|
GetPlatformList().push_back(platform_sp);
|
|
return platform_sp;
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
error.SetErrorString("invalid platform name");
|
|
if (platform_arch_ptr)
|
|
platform_arch_ptr->Clear();
|
|
platform_sp.reset();
|
|
return platform_sp;
|
|
}
|
|
|
|
ArchSpec Platform::GetAugmentedArchSpec(Platform *platform, llvm::StringRef triple) {
|
|
if (platform)
|
|
return platform->GetAugmentedArchSpec(triple);
|
|
return HostInfo::GetAugmentedArchSpec(triple);
|
|
}
|
|
|
|
/// Default Constructor
|
|
Platform::Platform(bool is_host)
|
|
: m_is_host(is_host), m_os_version_set_while_connected(false),
|
|
m_system_arch_set_while_connected(false), m_sdk_sysroot(), m_sdk_build(),
|
|
m_working_dir(), m_remote_url(), m_name(), m_system_arch(), m_mutex(),
|
|
m_max_uid_name_len(0), m_max_gid_name_len(0), m_supports_rsync(false),
|
|
m_rsync_opts(), m_rsync_prefix(), m_supports_ssh(false), m_ssh_opts(),
|
|
m_ignores_remote_hostname(false), m_trap_handlers(),
|
|
m_calculated_trap_handlers(false),
|
|
m_module_cache(std::make_unique<ModuleCache>()) {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
|
|
LLDB_LOGF(log, "%p Platform::Platform()", static_cast<void *>(this));
|
|
}
|
|
|
|
/// Destructor.
|
|
///
|
|
/// The destructor is virtual since this class is designed to be
|
|
/// inherited from by the plug-in instance.
|
|
Platform::~Platform() {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OBJECT));
|
|
LLDB_LOGF(log, "%p Platform::~Platform()", static_cast<void *>(this));
|
|
}
|
|
|
|
void Platform::GetStatus(Stream &strm) {
|
|
std::string s;
|
|
strm.Printf(" Platform: %s\n", GetPluginName().GetCString());
|
|
|
|
ArchSpec arch(GetSystemArchitecture());
|
|
if (arch.IsValid()) {
|
|
if (!arch.GetTriple().str().empty()) {
|
|
strm.Printf(" Triple: ");
|
|
arch.DumpTriple(strm.AsRawOstream());
|
|
strm.EOL();
|
|
}
|
|
}
|
|
|
|
llvm::VersionTuple os_version = GetOSVersion();
|
|
if (!os_version.empty()) {
|
|
strm.Format("OS Version: {0}", os_version.getAsString());
|
|
|
|
if (GetOSBuildString(s))
|
|
strm.Printf(" (%s)", s.c_str());
|
|
|
|
strm.EOL();
|
|
}
|
|
|
|
if (IsHost()) {
|
|
strm.Printf(" Hostname: %s\n", GetHostname());
|
|
} else {
|
|
const bool is_connected = IsConnected();
|
|
if (is_connected)
|
|
strm.Printf(" Hostname: %s\n", GetHostname());
|
|
strm.Printf(" Connected: %s\n", is_connected ? "yes" : "no");
|
|
}
|
|
|
|
if (GetWorkingDirectory()) {
|
|
strm.Printf("WorkingDir: %s\n", GetWorkingDirectory().GetCString());
|
|
}
|
|
if (!IsConnected())
|
|
return;
|
|
|
|
std::string specific_info(GetPlatformSpecificConnectionInformation());
|
|
|
|
if (!specific_info.empty())
|
|
strm.Printf("Platform-specific connection: %s\n", specific_info.c_str());
|
|
|
|
if (GetOSKernelDescription(s))
|
|
strm.Printf(" Kernel: %s\n", s.c_str());
|
|
}
|
|
|
|
llvm::VersionTuple Platform::GetOSVersion(Process *process) {
|
|
std::lock_guard<std::mutex> guard(m_mutex);
|
|
|
|
if (IsHost()) {
|
|
if (m_os_version.empty()) {
|
|
// We have a local host platform
|
|
m_os_version = HostInfo::GetOSVersion();
|
|
m_os_version_set_while_connected = !m_os_version.empty();
|
|
}
|
|
} else {
|
|
// We have a remote platform. We can only fetch the remote
|
|
// OS version if we are connected, and we don't want to do it
|
|
// more than once.
|
|
|
|
const bool is_connected = IsConnected();
|
|
|
|
bool fetch = false;
|
|
if (!m_os_version.empty()) {
|
|
// We have valid OS version info, check to make sure it wasn't manually
|
|
// set prior to connecting. If it was manually set prior to connecting,
|
|
// then lets fetch the actual OS version info if we are now connected.
|
|
if (is_connected && !m_os_version_set_while_connected)
|
|
fetch = true;
|
|
} else {
|
|
// We don't have valid OS version info, fetch it if we are connected
|
|
fetch = is_connected;
|
|
}
|
|
|
|
if (fetch)
|
|
m_os_version_set_while_connected = GetRemoteOSVersion();
|
|
}
|
|
|
|
if (!m_os_version.empty())
|
|
return m_os_version;
|
|
if (process) {
|
|
// Check with the process in case it can answer the question if a process
|
|
// was provided
|
|
return process->GetHostOSVersion();
|
|
}
|
|
return llvm::VersionTuple();
|
|
}
|
|
|
|
bool Platform::GetOSBuildString(std::string &s) {
|
|
s.clear();
|
|
|
|
if (IsHost())
|
|
#if !defined(__linux__)
|
|
return HostInfo::GetOSBuildString(s);
|
|
#else
|
|
return false;
|
|
#endif
|
|
else
|
|
return GetRemoteOSBuildString(s);
|
|
}
|
|
|
|
bool Platform::GetOSKernelDescription(std::string &s) {
|
|
if (IsHost())
|
|
#if !defined(__linux__)
|
|
return HostInfo::GetOSKernelDescription(s);
|
|
#else
|
|
return false;
|
|
#endif
|
|
else
|
|
return GetRemoteOSKernelDescription(s);
|
|
}
|
|
|
|
void Platform::AddClangModuleCompilationOptions(
|
|
Target *target, std::vector<std::string> &options) {
|
|
std::vector<std::string> default_compilation_options = {
|
|
"-x", "c++", "-Xclang", "-nostdsysteminc", "-Xclang", "-nostdsysteminc"};
|
|
|
|
options.insert(options.end(), default_compilation_options.begin(),
|
|
default_compilation_options.end());
|
|
}
|
|
|
|
FileSpec Platform::GetWorkingDirectory() {
|
|
if (IsHost()) {
|
|
llvm::SmallString<64> cwd;
|
|
if (llvm::sys::fs::current_path(cwd))
|
|
return {};
|
|
else {
|
|
FileSpec file_spec(cwd);
|
|
FileSystem::Instance().Resolve(file_spec);
|
|
return file_spec;
|
|
}
|
|
} else {
|
|
if (!m_working_dir)
|
|
m_working_dir = GetRemoteWorkingDirectory();
|
|
return m_working_dir;
|
|
}
|
|
}
|
|
|
|
struct RecurseCopyBaton {
|
|
const FileSpec &dst;
|
|
Platform *platform_ptr;
|
|
Status error;
|
|
};
|
|
|
|
static FileSystem::EnumerateDirectoryResult
|
|
RecurseCopy_Callback(void *baton, llvm::sys::fs::file_type ft,
|
|
llvm::StringRef path) {
|
|
RecurseCopyBaton *rc_baton = (RecurseCopyBaton *)baton;
|
|
FileSpec src(path);
|
|
namespace fs = llvm::sys::fs;
|
|
switch (ft) {
|
|
case fs::file_type::fifo_file:
|
|
case fs::file_type::socket_file:
|
|
// we have no way to copy pipes and sockets - ignore them and continue
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
break;
|
|
|
|
case fs::file_type::directory_file: {
|
|
// make the new directory and get in there
|
|
FileSpec dst_dir = rc_baton->dst;
|
|
if (!dst_dir.GetFilename())
|
|
dst_dir.GetFilename() = src.GetLastPathComponent();
|
|
Status error = rc_baton->platform_ptr->MakeDirectory(
|
|
dst_dir, lldb::eFilePermissionsDirectoryDefault);
|
|
if (error.Fail()) {
|
|
rc_baton->error.SetErrorStringWithFormat(
|
|
"unable to setup directory %s on remote end", dst_dir.GetCString());
|
|
return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
|
|
}
|
|
|
|
// now recurse
|
|
std::string src_dir_path(src.GetPath());
|
|
|
|
// Make a filespec that only fills in the directory of a FileSpec so when
|
|
// we enumerate we can quickly fill in the filename for dst copies
|
|
FileSpec recurse_dst;
|
|
recurse_dst.GetDirectory().SetCString(dst_dir.GetPath().c_str());
|
|
RecurseCopyBaton rc_baton2 = {recurse_dst, rc_baton->platform_ptr,
|
|
Status()};
|
|
FileSystem::Instance().EnumerateDirectory(src_dir_path, true, true, true,
|
|
RecurseCopy_Callback, &rc_baton2);
|
|
if (rc_baton2.error.Fail()) {
|
|
rc_baton->error.SetErrorString(rc_baton2.error.AsCString());
|
|
return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
|
|
}
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
} break;
|
|
|
|
case fs::file_type::symlink_file: {
|
|
// copy the file and keep going
|
|
FileSpec dst_file = rc_baton->dst;
|
|
if (!dst_file.GetFilename())
|
|
dst_file.GetFilename() = src.GetFilename();
|
|
|
|
FileSpec src_resolved;
|
|
|
|
rc_baton->error = FileSystem::Instance().Readlink(src, src_resolved);
|
|
|
|
if (rc_baton->error.Fail())
|
|
return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
|
|
|
|
rc_baton->error =
|
|
rc_baton->platform_ptr->CreateSymlink(dst_file, src_resolved);
|
|
|
|
if (rc_baton->error.Fail())
|
|
return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
|
|
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
} break;
|
|
|
|
case fs::file_type::regular_file: {
|
|
// copy the file and keep going
|
|
FileSpec dst_file = rc_baton->dst;
|
|
if (!dst_file.GetFilename())
|
|
dst_file.GetFilename() = src.GetFilename();
|
|
Status err = rc_baton->platform_ptr->PutFile(src, dst_file);
|
|
if (err.Fail()) {
|
|
rc_baton->error.SetErrorString(err.AsCString());
|
|
return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
|
|
}
|
|
return FileSystem::eEnumerateDirectoryResultNext;
|
|
} break;
|
|
|
|
default:
|
|
rc_baton->error.SetErrorStringWithFormat(
|
|
"invalid file detected during copy: %s", src.GetPath().c_str());
|
|
return FileSystem::eEnumerateDirectoryResultQuit; // got an error, bail out
|
|
break;
|
|
}
|
|
llvm_unreachable("Unhandled file_type!");
|
|
}
|
|
|
|
Status Platform::Install(const FileSpec &src, const FileSpec &dst) {
|
|
Status error;
|
|
|
|
Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
|
|
LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s')",
|
|
src.GetPath().c_str(), dst.GetPath().c_str());
|
|
FileSpec fixed_dst(dst);
|
|
|
|
if (!fixed_dst.GetFilename())
|
|
fixed_dst.GetFilename() = src.GetFilename();
|
|
|
|
FileSpec working_dir = GetWorkingDirectory();
|
|
|
|
if (dst) {
|
|
if (dst.GetDirectory()) {
|
|
const char first_dst_dir_char = dst.GetDirectory().GetCString()[0];
|
|
if (first_dst_dir_char == '/' || first_dst_dir_char == '\\') {
|
|
fixed_dst.GetDirectory() = dst.GetDirectory();
|
|
}
|
|
// If the fixed destination file doesn't have a directory yet, then we
|
|
// must have a relative path. We will resolve this relative path against
|
|
// the platform's working directory
|
|
if (!fixed_dst.GetDirectory()) {
|
|
FileSpec relative_spec;
|
|
std::string path;
|
|
if (working_dir) {
|
|
relative_spec = working_dir;
|
|
relative_spec.AppendPathComponent(dst.GetPath());
|
|
fixed_dst.GetDirectory() = relative_spec.GetDirectory();
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"platform working directory must be valid for relative path '%s'",
|
|
dst.GetPath().c_str());
|
|
return error;
|
|
}
|
|
}
|
|
} else {
|
|
if (working_dir) {
|
|
fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"platform working directory must be valid for relative path '%s'",
|
|
dst.GetPath().c_str());
|
|
return error;
|
|
}
|
|
}
|
|
} else {
|
|
if (working_dir) {
|
|
fixed_dst.GetDirectory().SetCString(working_dir.GetCString());
|
|
} else {
|
|
error.SetErrorStringWithFormat("platform working directory must be valid "
|
|
"when destination directory is empty");
|
|
return error;
|
|
}
|
|
}
|
|
|
|
LLDB_LOGF(log, "Platform::Install (src='%s', dst='%s') fixed_dst='%s'",
|
|
src.GetPath().c_str(), dst.GetPath().c_str(),
|
|
fixed_dst.GetPath().c_str());
|
|
|
|
if (GetSupportsRSync()) {
|
|
error = PutFile(src, dst);
|
|
} else {
|
|
namespace fs = llvm::sys::fs;
|
|
switch (fs::get_file_type(src.GetPath(), false)) {
|
|
case fs::file_type::directory_file: {
|
|
llvm::sys::fs::remove(fixed_dst.GetPath());
|
|
uint32_t permissions = FileSystem::Instance().GetPermissions(src);
|
|
if (permissions == 0)
|
|
permissions = eFilePermissionsDirectoryDefault;
|
|
error = MakeDirectory(fixed_dst, permissions);
|
|
if (error.Success()) {
|
|
// Make a filespec that only fills in the directory of a FileSpec so
|
|
// when we enumerate we can quickly fill in the filename for dst copies
|
|
FileSpec recurse_dst;
|
|
recurse_dst.GetDirectory().SetCString(fixed_dst.GetCString());
|
|
std::string src_dir_path(src.GetPath());
|
|
RecurseCopyBaton baton = {recurse_dst, this, Status()};
|
|
FileSystem::Instance().EnumerateDirectory(
|
|
src_dir_path, true, true, true, RecurseCopy_Callback, &baton);
|
|
return baton.error;
|
|
}
|
|
} break;
|
|
|
|
case fs::file_type::regular_file:
|
|
llvm::sys::fs::remove(fixed_dst.GetPath());
|
|
error = PutFile(src, fixed_dst);
|
|
break;
|
|
|
|
case fs::file_type::symlink_file: {
|
|
llvm::sys::fs::remove(fixed_dst.GetPath());
|
|
FileSpec src_resolved;
|
|
error = FileSystem::Instance().Readlink(src, src_resolved);
|
|
if (error.Success())
|
|
error = CreateSymlink(dst, src_resolved);
|
|
} break;
|
|
case fs::file_type::fifo_file:
|
|
error.SetErrorString("platform install doesn't handle pipes");
|
|
break;
|
|
case fs::file_type::socket_file:
|
|
error.SetErrorString("platform install doesn't handle sockets");
|
|
break;
|
|
default:
|
|
error.SetErrorString(
|
|
"platform install doesn't handle non file or directory items");
|
|
break;
|
|
}
|
|
}
|
|
return error;
|
|
}
|
|
|
|
bool Platform::SetWorkingDirectory(const FileSpec &file_spec) {
|
|
if (IsHost()) {
|
|
Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
|
|
LLDB_LOG(log, "{0}", file_spec);
|
|
if (std::error_code ec = llvm::sys::fs::set_current_path(file_spec.GetPath())) {
|
|
LLDB_LOG(log, "error: {0}", ec.message());
|
|
return false;
|
|
}
|
|
return true;
|
|
} else {
|
|
m_working_dir.Clear();
|
|
return SetRemoteWorkingDirectory(file_spec);
|
|
}
|
|
}
|
|
|
|
Status Platform::MakeDirectory(const FileSpec &file_spec,
|
|
uint32_t permissions) {
|
|
if (IsHost())
|
|
return llvm::sys::fs::create_directory(file_spec.GetPath(), permissions);
|
|
else {
|
|
Status error;
|
|
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
|
|
GetPluginName().GetCString(),
|
|
LLVM_PRETTY_FUNCTION);
|
|
return error;
|
|
}
|
|
}
|
|
|
|
Status Platform::GetFilePermissions(const FileSpec &file_spec,
|
|
uint32_t &file_permissions) {
|
|
if (IsHost()) {
|
|
auto Value = llvm::sys::fs::getPermissions(file_spec.GetPath());
|
|
if (Value)
|
|
file_permissions = Value.get();
|
|
return Status(Value.getError());
|
|
} else {
|
|
Status error;
|
|
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
|
|
GetPluginName().GetCString(),
|
|
LLVM_PRETTY_FUNCTION);
|
|
return error;
|
|
}
|
|
}
|
|
|
|
Status Platform::SetFilePermissions(const FileSpec &file_spec,
|
|
uint32_t file_permissions) {
|
|
if (IsHost()) {
|
|
auto Perms = static_cast<llvm::sys::fs::perms>(file_permissions);
|
|
return llvm::sys::fs::setPermissions(file_spec.GetPath(), Perms);
|
|
} else {
|
|
Status error;
|
|
error.SetErrorStringWithFormat("remote platform %s doesn't support %s",
|
|
GetPluginName().GetCString(),
|
|
LLVM_PRETTY_FUNCTION);
|
|
return error;
|
|
}
|
|
}
|
|
|
|
ConstString Platform::GetName() { return GetPluginName(); }
|
|
|
|
const char *Platform::GetHostname() {
|
|
if (IsHost())
|
|
return "127.0.0.1";
|
|
|
|
if (m_name.empty())
|
|
return nullptr;
|
|
return m_name.c_str();
|
|
}
|
|
|
|
ConstString Platform::GetFullNameForDylib(ConstString basename) {
|
|
return basename;
|
|
}
|
|
|
|
bool Platform::SetRemoteWorkingDirectory(const FileSpec &working_dir) {
|
|
Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
|
|
LLDB_LOGF(log, "Platform::SetRemoteWorkingDirectory('%s')",
|
|
working_dir.GetCString());
|
|
m_working_dir = working_dir;
|
|
return true;
|
|
}
|
|
|
|
bool Platform::SetOSVersion(llvm::VersionTuple version) {
|
|
if (IsHost()) {
|
|
// We don't need anyone setting the OS version for the host platform, we
|
|
// should be able to figure it out by calling HostInfo::GetOSVersion(...).
|
|
return false;
|
|
} else {
|
|
// We have a remote platform, allow setting the target OS version if we
|
|
// aren't connected, since if we are connected, we should be able to
|
|
// request the remote OS version from the connected platform.
|
|
if (IsConnected())
|
|
return false;
|
|
else {
|
|
// We aren't connected and we might want to set the OS version ahead of
|
|
// time before we connect so we can peruse files and use a local SDK or
|
|
// PDK cache of support files to disassemble or do other things.
|
|
m_os_version = version;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
Status
|
|
Platform::ResolveExecutable(const ModuleSpec &module_spec,
|
|
lldb::ModuleSP &exe_module_sp,
|
|
const FileSpecList *module_search_paths_ptr) {
|
|
Status error;
|
|
if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
|
|
if (module_spec.GetArchitecture().IsValid()) {
|
|
error = ModuleList::GetSharedModule(module_spec, exe_module_sp,
|
|
module_search_paths_ptr, nullptr,
|
|
nullptr);
|
|
} else {
|
|
// No valid architecture was specified, ask the platform for the
|
|
// architectures that we should be using (in the correct order) and see
|
|
// if we can find a match that way
|
|
ModuleSpec arch_module_spec(module_spec);
|
|
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
|
|
idx, arch_module_spec.GetArchitecture());
|
|
++idx) {
|
|
error = ModuleList::GetSharedModule(arch_module_spec, exe_module_sp,
|
|
module_search_paths_ptr, nullptr,
|
|
nullptr);
|
|
// Did we find an executable using one of the
|
|
if (error.Success() && exe_module_sp)
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
error.SetErrorStringWithFormat("'%s' does not exist",
|
|
module_spec.GetFileSpec().GetPath().c_str());
|
|
}
|
|
return error;
|
|
}
|
|
|
|
Status Platform::ResolveSymbolFile(Target &target, const ModuleSpec &sym_spec,
|
|
FileSpec &sym_file) {
|
|
Status error;
|
|
if (FileSystem::Instance().Exists(sym_spec.GetSymbolFileSpec()))
|
|
sym_file = sym_spec.GetSymbolFileSpec();
|
|
else
|
|
error.SetErrorString("unable to resolve symbol file");
|
|
return error;
|
|
}
|
|
|
|
bool Platform::ResolveRemotePath(const FileSpec &platform_path,
|
|
FileSpec &resolved_platform_path) {
|
|
resolved_platform_path = platform_path;
|
|
FileSystem::Instance().Resolve(resolved_platform_path);
|
|
return true;
|
|
}
|
|
|
|
const ArchSpec &Platform::GetSystemArchitecture() {
|
|
if (IsHost()) {
|
|
if (!m_system_arch.IsValid()) {
|
|
// We have a local host platform
|
|
m_system_arch = HostInfo::GetArchitecture();
|
|
m_system_arch_set_while_connected = m_system_arch.IsValid();
|
|
}
|
|
} else {
|
|
// We have a remote platform. We can only fetch the remote system
|
|
// architecture if we are connected, and we don't want to do it more than
|
|
// once.
|
|
|
|
const bool is_connected = IsConnected();
|
|
|
|
bool fetch = false;
|
|
if (m_system_arch.IsValid()) {
|
|
// We have valid OS version info, check to make sure it wasn't manually
|
|
// set prior to connecting. If it was manually set prior to connecting,
|
|
// then lets fetch the actual OS version info if we are now connected.
|
|
if (is_connected && !m_system_arch_set_while_connected)
|
|
fetch = true;
|
|
} else {
|
|
// We don't have valid OS version info, fetch it if we are connected
|
|
fetch = is_connected;
|
|
}
|
|
|
|
if (fetch) {
|
|
m_system_arch = GetRemoteSystemArchitecture();
|
|
m_system_arch_set_while_connected = m_system_arch.IsValid();
|
|
}
|
|
}
|
|
return m_system_arch;
|
|
}
|
|
|
|
ArchSpec Platform::GetAugmentedArchSpec(llvm::StringRef triple) {
|
|
if (triple.empty())
|
|
return ArchSpec();
|
|
llvm::Triple normalized_triple(llvm::Triple::normalize(triple));
|
|
if (!ArchSpec::ContainsOnlyArch(normalized_triple))
|
|
return ArchSpec(triple);
|
|
|
|
if (auto kind = HostInfo::ParseArchitectureKind(triple))
|
|
return HostInfo::GetArchitecture(*kind);
|
|
|
|
ArchSpec compatible_arch;
|
|
ArchSpec raw_arch(triple);
|
|
if (!IsCompatibleArchitecture(raw_arch, false, &compatible_arch))
|
|
return raw_arch;
|
|
|
|
if (!compatible_arch.IsValid())
|
|
return ArchSpec(normalized_triple);
|
|
|
|
const llvm::Triple &compatible_triple = compatible_arch.GetTriple();
|
|
if (normalized_triple.getVendorName().empty())
|
|
normalized_triple.setVendor(compatible_triple.getVendor());
|
|
if (normalized_triple.getOSName().empty())
|
|
normalized_triple.setOS(compatible_triple.getOS());
|
|
if (normalized_triple.getEnvironmentName().empty())
|
|
normalized_triple.setEnvironment(compatible_triple.getEnvironment());
|
|
return ArchSpec(normalized_triple);
|
|
}
|
|
|
|
Status Platform::ConnectRemote(Args &args) {
|
|
Status error;
|
|
if (IsHost())
|
|
error.SetErrorStringWithFormat("The currently selected platform (%s) is "
|
|
"the host platform and is always connected.",
|
|
GetPluginName().GetCString());
|
|
else
|
|
error.SetErrorStringWithFormat(
|
|
"Platform::ConnectRemote() is not supported by %s",
|
|
GetPluginName().GetCString());
|
|
return error;
|
|
}
|
|
|
|
Status Platform::DisconnectRemote() {
|
|
Status error;
|
|
if (IsHost())
|
|
error.SetErrorStringWithFormat("The currently selected platform (%s) is "
|
|
"the host platform and is always connected.",
|
|
GetPluginName().GetCString());
|
|
else
|
|
error.SetErrorStringWithFormat(
|
|
"Platform::DisconnectRemote() is not supported by %s",
|
|
GetPluginName().GetCString());
|
|
return error;
|
|
}
|
|
|
|
bool Platform::GetProcessInfo(lldb::pid_t pid,
|
|
ProcessInstanceInfo &process_info) {
|
|
// Take care of the host case so that each subclass can just call this
|
|
// function to get the host functionality.
|
|
if (IsHost())
|
|
return Host::GetProcessInfo(pid, process_info);
|
|
return false;
|
|
}
|
|
|
|
uint32_t Platform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
|
|
ProcessInstanceInfoList &process_infos) {
|
|
// Take care of the host case so that each subclass can just call this
|
|
// function to get the host functionality.
|
|
uint32_t match_count = 0;
|
|
if (IsHost())
|
|
match_count = Host::FindProcesses(match_info, process_infos);
|
|
return match_count;
|
|
}
|
|
|
|
Status Platform::LaunchProcess(ProcessLaunchInfo &launch_info) {
|
|
Status error;
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
|
|
LLDB_LOGF(log, "Platform::%s()", __FUNCTION__);
|
|
|
|
// Take care of the host case so that each subclass can just call this
|
|
// function to get the host functionality.
|
|
if (IsHost()) {
|
|
if (::getenv("LLDB_LAUNCH_FLAG_LAUNCH_IN_TTY"))
|
|
launch_info.GetFlags().Set(eLaunchFlagLaunchInTTY);
|
|
|
|
if (launch_info.GetFlags().Test(eLaunchFlagLaunchInShell)) {
|
|
const bool will_debug = launch_info.GetFlags().Test(eLaunchFlagDebug);
|
|
const bool first_arg_is_full_shell_command = false;
|
|
uint32_t num_resumes = GetResumeCountForLaunchInfo(launch_info);
|
|
if (log) {
|
|
const FileSpec &shell = launch_info.GetShell();
|
|
std::string shell_str = (shell) ? shell.GetPath() : "<null>";
|
|
LLDB_LOGF(log,
|
|
"Platform::%s GetResumeCountForLaunchInfo() returned %" PRIu32
|
|
", shell is '%s'",
|
|
__FUNCTION__, num_resumes, shell_str.c_str());
|
|
}
|
|
|
|
if (!launch_info.ConvertArgumentsForLaunchingInShell(
|
|
error, will_debug, first_arg_is_full_shell_command, num_resumes))
|
|
return error;
|
|
} else if (launch_info.GetFlags().Test(eLaunchFlagShellExpandArguments)) {
|
|
error = ShellExpandArguments(launch_info);
|
|
if (error.Fail()) {
|
|
error.SetErrorStringWithFormat("shell expansion failed (reason: %s). "
|
|
"consider launching with 'process "
|
|
"launch'.",
|
|
error.AsCString("unknown"));
|
|
return error;
|
|
}
|
|
}
|
|
|
|
LLDB_LOGF(log, "Platform::%s final launch_info resume count: %" PRIu32,
|
|
__FUNCTION__, launch_info.GetResumeCount());
|
|
|
|
error = Host::LaunchProcess(launch_info);
|
|
} else
|
|
error.SetErrorString(
|
|
"base lldb_private::Platform class can't launch remote processes");
|
|
return error;
|
|
}
|
|
|
|
Status Platform::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
|
|
if (IsHost())
|
|
return Host::ShellExpandArguments(launch_info);
|
|
return Status("base lldb_private::Platform class can't expand arguments");
|
|
}
|
|
|
|
Status Platform::KillProcess(const lldb::pid_t pid) {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
|
|
LLDB_LOGF(log, "Platform::%s, pid %" PRIu64, __FUNCTION__, pid);
|
|
|
|
// Try to find a process plugin to handle this Kill request. If we can't,
|
|
// fall back to the default OS implementation.
|
|
size_t num_debuggers = Debugger::GetNumDebuggers();
|
|
for (size_t didx = 0; didx < num_debuggers; ++didx) {
|
|
DebuggerSP debugger = Debugger::GetDebuggerAtIndex(didx);
|
|
lldb_private::TargetList &targets = debugger->GetTargetList();
|
|
for (int tidx = 0; tidx < targets.GetNumTargets(); ++tidx) {
|
|
ProcessSP process = targets.GetTargetAtIndex(tidx)->GetProcessSP();
|
|
if (process->GetID() == pid)
|
|
return process->Destroy(true);
|
|
}
|
|
}
|
|
|
|
if (!IsHost()) {
|
|
return Status(
|
|
"base lldb_private::Platform class can't kill remote processes unless "
|
|
"they are controlled by a process plugin");
|
|
}
|
|
Host::Kill(pid, SIGTERM);
|
|
return Status();
|
|
}
|
|
|
|
lldb::ProcessSP
|
|
Platform::DebugProcess(ProcessLaunchInfo &launch_info, Debugger &debugger,
|
|
Target *target, // Can be nullptr, if nullptr create a
|
|
// new target, else use existing one
|
|
Status &error) {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
|
|
LLDB_LOGF(log, "Platform::%s entered (target %p)", __FUNCTION__,
|
|
static_cast<void *>(target));
|
|
|
|
ProcessSP process_sp;
|
|
// Make sure we stop at the entry point
|
|
launch_info.GetFlags().Set(eLaunchFlagDebug);
|
|
// We always launch the process we are going to debug in a separate process
|
|
// 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()) {
|
|
LLDB_LOGF(log,
|
|
"Platform::%s() StructuredDataPlugin launch "
|
|
"filter failed.",
|
|
__FUNCTION__);
|
|
return process_sp;
|
|
}
|
|
}
|
|
}
|
|
|
|
error = LaunchProcess(launch_info);
|
|
if (error.Success()) {
|
|
LLDB_LOGF(log,
|
|
"Platform::%s LaunchProcess() call succeeded (pid=%" PRIu64 ")",
|
|
__FUNCTION__, launch_info.GetProcessID());
|
|
if (launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) {
|
|
ProcessAttachInfo attach_info(launch_info);
|
|
process_sp = Attach(attach_info, debugger, target, error);
|
|
if (process_sp) {
|
|
LLDB_LOGF(log, "Platform::%s Attach() succeeded, Process plugin: %s",
|
|
__FUNCTION__, process_sp->GetPluginName().AsCString());
|
|
launch_info.SetHijackListener(attach_info.GetHijackListener());
|
|
|
|
// Since we attached to the process, it will think it needs to detach
|
|
// if the process object just goes away without an explicit call to
|
|
// Process::Kill() or Process::Detach(), so let it know to kill the
|
|
// process if this happens.
|
|
process_sp->SetShouldDetach(false);
|
|
|
|
// If we didn't have any file actions, the pseudo terminal might have
|
|
// been used where the secondary side was given as the file to open for
|
|
// stdin/out/err after we have already opened the master so we can
|
|
// read/write stdin/out/err.
|
|
int pty_fd = launch_info.GetPTY().ReleasePrimaryFileDescriptor();
|
|
if (pty_fd != PseudoTerminal::invalid_fd) {
|
|
process_sp->SetSTDIOFileDescriptor(pty_fd);
|
|
}
|
|
} else {
|
|
LLDB_LOGF(log, "Platform::%s Attach() failed: %s", __FUNCTION__,
|
|
error.AsCString());
|
|
}
|
|
} else {
|
|
LLDB_LOGF(log,
|
|
"Platform::%s LaunchProcess() returned launch_info with "
|
|
"invalid process id",
|
|
__FUNCTION__);
|
|
}
|
|
} else {
|
|
LLDB_LOGF(log, "Platform::%s LaunchProcess() failed: %s", __FUNCTION__,
|
|
error.AsCString());
|
|
}
|
|
|
|
return process_sp;
|
|
}
|
|
|
|
lldb::PlatformSP
|
|
Platform::GetPlatformForArchitecture(const ArchSpec &arch,
|
|
ArchSpec *platform_arch_ptr) {
|
|
lldb::PlatformSP platform_sp;
|
|
Status error;
|
|
if (arch.IsValid())
|
|
platform_sp = Platform::Create(arch, platform_arch_ptr, error);
|
|
return platform_sp;
|
|
}
|
|
|
|
/// Lets a platform answer if it is compatible with a given
|
|
/// architecture and the target triple contained within.
|
|
bool Platform::IsCompatibleArchitecture(const ArchSpec &arch,
|
|
bool exact_arch_match,
|
|
ArchSpec *compatible_arch_ptr) {
|
|
// If the architecture is invalid, we must answer true...
|
|
if (arch.IsValid()) {
|
|
ArchSpec platform_arch;
|
|
// Try for an exact architecture match first.
|
|
if (exact_arch_match) {
|
|
for (uint32_t arch_idx = 0;
|
|
GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
|
|
++arch_idx) {
|
|
if (arch.IsExactMatch(platform_arch)) {
|
|
if (compatible_arch_ptr)
|
|
*compatible_arch_ptr = platform_arch;
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
for (uint32_t arch_idx = 0;
|
|
GetSupportedArchitectureAtIndex(arch_idx, platform_arch);
|
|
++arch_idx) {
|
|
if (arch.IsCompatibleMatch(platform_arch)) {
|
|
if (compatible_arch_ptr)
|
|
*compatible_arch_ptr = platform_arch;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (compatible_arch_ptr)
|
|
compatible_arch_ptr->Clear();
|
|
return false;
|
|
}
|
|
|
|
Status Platform::PutFile(const FileSpec &source, const FileSpec &destination,
|
|
uint32_t uid, uint32_t gid) {
|
|
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PLATFORM));
|
|
LLDB_LOGF(log, "[PutFile] Using block by block transfer....\n");
|
|
|
|
auto source_open_options =
|
|
File::eOpenOptionRead | File::eOpenOptionCloseOnExec;
|
|
namespace fs = llvm::sys::fs;
|
|
if (fs::is_symlink_file(source.GetPath()))
|
|
source_open_options |= File::eOpenOptionDontFollowSymlinks;
|
|
|
|
auto source_file = FileSystem::Instance().Open(source, source_open_options,
|
|
lldb::eFilePermissionsUserRW);
|
|
if (!source_file)
|
|
return Status(source_file.takeError());
|
|
Status error;
|
|
uint32_t permissions = source_file.get()->GetPermissions(error);
|
|
if (permissions == 0)
|
|
permissions = lldb::eFilePermissionsFileDefault;
|
|
|
|
lldb::user_id_t dest_file = OpenFile(
|
|
destination, File::eOpenOptionCanCreate | File::eOpenOptionWrite |
|
|
File::eOpenOptionTruncate | File::eOpenOptionCloseOnExec,
|
|
permissions, error);
|
|
LLDB_LOGF(log, "dest_file = %" PRIu64 "\n", dest_file);
|
|
|
|
if (error.Fail())
|
|
return error;
|
|
if (dest_file == UINT64_MAX)
|
|
return Status("unable to open target file");
|
|
lldb::DataBufferSP buffer_sp(new DataBufferHeap(1024 * 16, 0));
|
|
uint64_t offset = 0;
|
|
for (;;) {
|
|
size_t bytes_read = buffer_sp->GetByteSize();
|
|
error = source_file.get()->Read(buffer_sp->GetBytes(), bytes_read);
|
|
if (error.Fail() || bytes_read == 0)
|
|
break;
|
|
|
|
const uint64_t bytes_written =
|
|
WriteFile(dest_file, offset, buffer_sp->GetBytes(), bytes_read, error);
|
|
if (error.Fail())
|
|
break;
|
|
|
|
offset += bytes_written;
|
|
if (bytes_written != bytes_read) {
|
|
// We didn't write the correct number of bytes, so adjust the file
|
|
// position in the source file we are reading from...
|
|
source_file.get()->SeekFromStart(offset);
|
|
}
|
|
}
|
|
CloseFile(dest_file, error);
|
|
|
|
if (uid == UINT32_MAX && gid == UINT32_MAX)
|
|
return error;
|
|
|
|
// TODO: ChownFile?
|
|
|
|
return error;
|
|
}
|
|
|
|
Status Platform::GetFile(const FileSpec &source, const FileSpec &destination) {
|
|
Status error("unimplemented");
|
|
return error;
|
|
}
|
|
|
|
Status
|
|
Platform::CreateSymlink(const FileSpec &src, // The name of the link is in src
|
|
const FileSpec &dst) // The symlink points to dst
|
|
{
|
|
Status error("unimplemented");
|
|
return error;
|
|
}
|
|
|
|
bool Platform::GetFileExists(const lldb_private::FileSpec &file_spec) {
|
|
return false;
|
|
}
|
|
|
|
Status Platform::Unlink(const FileSpec &path) {
|
|
Status error("unimplemented");
|
|
return error;
|
|
}
|
|
|
|
MmapArgList Platform::GetMmapArgumentList(const ArchSpec &arch, addr_t addr,
|
|
addr_t length, unsigned prot,
|
|
unsigned flags, addr_t fd,
|
|
addr_t offset) {
|
|
uint64_t flags_platform = 0;
|
|
if (flags & eMmapFlagsPrivate)
|
|
flags_platform |= MAP_PRIVATE;
|
|
if (flags & eMmapFlagsAnon)
|
|
flags_platform |= MAP_ANON;
|
|
|
|
MmapArgList args({addr, length, prot, flags_platform, fd, offset});
|
|
return args;
|
|
}
|
|
|
|
lldb_private::Status Platform::RunShellCommand(
|
|
llvm::StringRef command,
|
|
const FileSpec &
|
|
working_dir, // Pass empty FileSpec to use the current working directory
|
|
int *status_ptr, // Pass nullptr if you don't want the process exit status
|
|
int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
|
|
// process to exit
|
|
std::string
|
|
*command_output, // Pass nullptr if you don't want the command output
|
|
const Timeout<std::micro> &timeout) {
|
|
return RunShellCommand(llvm::StringRef(), command, working_dir, status_ptr,
|
|
signo_ptr, command_output, timeout);
|
|
}
|
|
|
|
lldb_private::Status Platform::RunShellCommand(
|
|
llvm::StringRef shell, // Pass empty if you want to use the default
|
|
// shell interpreter
|
|
llvm::StringRef command, // Shouldn't be empty
|
|
const FileSpec &
|
|
working_dir, // Pass empty FileSpec to use the current working directory
|
|
int *status_ptr, // Pass nullptr if you don't want the process exit status
|
|
int *signo_ptr, // Pass nullptr if you don't want the signal that caused the
|
|
// process to exit
|
|
std::string
|
|
*command_output, // Pass nullptr if you don't want the command output
|
|
const Timeout<std::micro> &timeout) {
|
|
if (IsHost())
|
|
return Host::RunShellCommand(shell, command, working_dir, status_ptr,
|
|
signo_ptr, command_output, timeout);
|
|
else
|
|
return Status("unimplemented");
|
|
}
|
|
|
|
bool Platform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
|
|
uint64_t &high) {
|
|
if (!IsHost())
|
|
return false;
|
|
auto Result = llvm::sys::fs::md5_contents(file_spec.GetPath());
|
|
if (!Result)
|
|
return false;
|
|
std::tie(high, low) = Result->words();
|
|
return true;
|
|
}
|
|
|
|
void Platform::SetLocalCacheDirectory(const char *local) {
|
|
m_local_cache_directory.assign(local);
|
|
}
|
|
|
|
const char *Platform::GetLocalCacheDirectory() {
|
|
return m_local_cache_directory.c_str();
|
|
}
|
|
|
|
static constexpr OptionDefinition g_rsync_option_table[] = {
|
|
{LLDB_OPT_SET_ALL, false, "rsync", 'r', OptionParser::eNoArgument, nullptr,
|
|
{}, 0, eArgTypeNone, "Enable rsync."},
|
|
{LLDB_OPT_SET_ALL, false, "rsync-opts", 'R',
|
|
OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
|
|
"Platform-specific options required for rsync to work."},
|
|
{LLDB_OPT_SET_ALL, false, "rsync-prefix", 'P',
|
|
OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCommandName,
|
|
"Platform-specific rsync prefix put before the remote path."},
|
|
{LLDB_OPT_SET_ALL, false, "ignore-remote-hostname", 'i',
|
|
OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone,
|
|
"Do not automatically fill in the remote hostname when composing the "
|
|
"rsync command."},
|
|
};
|
|
|
|
static constexpr OptionDefinition g_ssh_option_table[] = {
|
|
{LLDB_OPT_SET_ALL, false, "ssh", 's', OptionParser::eNoArgument, nullptr,
|
|
{}, 0, eArgTypeNone, "Enable SSH."},
|
|
{LLDB_OPT_SET_ALL, false, "ssh-opts", 'S', OptionParser::eRequiredArgument,
|
|
nullptr, {}, 0, eArgTypeCommandName,
|
|
"Platform-specific options required for SSH to work."},
|
|
};
|
|
|
|
static constexpr OptionDefinition g_caching_option_table[] = {
|
|
{LLDB_OPT_SET_ALL, false, "local-cache-dir", 'c',
|
|
OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypePath,
|
|
"Path in which to store local copies of files."},
|
|
};
|
|
|
|
llvm::ArrayRef<OptionDefinition> OptionGroupPlatformRSync::GetDefinitions() {
|
|
return llvm::makeArrayRef(g_rsync_option_table);
|
|
}
|
|
|
|
void OptionGroupPlatformRSync::OptionParsingStarting(
|
|
ExecutionContext *execution_context) {
|
|
m_rsync = false;
|
|
m_rsync_opts.clear();
|
|
m_rsync_prefix.clear();
|
|
m_ignores_remote_hostname = false;
|
|
}
|
|
|
|
lldb_private::Status
|
|
OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
|
|
llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) {
|
|
Status error;
|
|
char short_option = (char)GetDefinitions()[option_idx].short_option;
|
|
switch (short_option) {
|
|
case 'r':
|
|
m_rsync = true;
|
|
break;
|
|
|
|
case 'R':
|
|
m_rsync_opts.assign(std::string(option_arg));
|
|
break;
|
|
|
|
case 'P':
|
|
m_rsync_prefix.assign(std::string(option_arg));
|
|
break;
|
|
|
|
case 'i':
|
|
m_ignores_remote_hostname = true;
|
|
break;
|
|
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
lldb::BreakpointSP
|
|
Platform::SetThreadCreationBreakpoint(lldb_private::Target &target) {
|
|
return lldb::BreakpointSP();
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> OptionGroupPlatformSSH::GetDefinitions() {
|
|
return llvm::makeArrayRef(g_ssh_option_table);
|
|
}
|
|
|
|
void OptionGroupPlatformSSH::OptionParsingStarting(
|
|
ExecutionContext *execution_context) {
|
|
m_ssh = false;
|
|
m_ssh_opts.clear();
|
|
}
|
|
|
|
lldb_private::Status
|
|
OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
|
|
llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) {
|
|
Status error;
|
|
char short_option = (char)GetDefinitions()[option_idx].short_option;
|
|
switch (short_option) {
|
|
case 's':
|
|
m_ssh = true;
|
|
break;
|
|
|
|
case 'S':
|
|
m_ssh_opts.assign(std::string(option_arg));
|
|
break;
|
|
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> OptionGroupPlatformCaching::GetDefinitions() {
|
|
return llvm::makeArrayRef(g_caching_option_table);
|
|
}
|
|
|
|
void OptionGroupPlatformCaching::OptionParsingStarting(
|
|
ExecutionContext *execution_context) {
|
|
m_cache_dir.clear();
|
|
}
|
|
|
|
lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
|
|
uint32_t option_idx, llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) {
|
|
Status error;
|
|
char short_option = (char)GetDefinitions()[option_idx].short_option;
|
|
switch (short_option) {
|
|
case 'c':
|
|
m_cache_dir.assign(std::string(option_arg));
|
|
break;
|
|
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
Environment Platform::GetEnvironment() { return Environment(); }
|
|
|
|
const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
|
|
if (!m_calculated_trap_handlers) {
|
|
std::lock_guard<std::mutex> guard(m_mutex);
|
|
if (!m_calculated_trap_handlers) {
|
|
CalculateTrapHandlerSymbolNames();
|
|
m_calculated_trap_handlers = true;
|
|
}
|
|
}
|
|
return m_trap_handlers;
|
|
}
|
|
|
|
Status Platform::GetCachedExecutable(
|
|
ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
|
|
const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
|
|
const auto platform_spec = module_spec.GetFileSpec();
|
|
const auto error = LoadCachedExecutable(
|
|
module_spec, module_sp, module_search_paths_ptr, remote_platform);
|
|
if (error.Success()) {
|
|
module_spec.GetFileSpec() = module_sp->GetFileSpec();
|
|
module_spec.GetPlatformFileSpec() = platform_spec;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
Status Platform::LoadCachedExecutable(
|
|
const ModuleSpec &module_spec, lldb::ModuleSP &module_sp,
|
|
const FileSpecList *module_search_paths_ptr, Platform &remote_platform) {
|
|
return GetRemoteSharedModule(module_spec, nullptr, module_sp,
|
|
[&](const ModuleSpec &spec) {
|
|
return remote_platform.ResolveExecutable(
|
|
spec, module_sp, module_search_paths_ptr);
|
|
},
|
|
nullptr);
|
|
}
|
|
|
|
Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
|
|
Process *process,
|
|
lldb::ModuleSP &module_sp,
|
|
const ModuleResolver &module_resolver,
|
|
bool *did_create_ptr) {
|
|
// Get module information from a target.
|
|
ModuleSpec resolved_module_spec;
|
|
bool got_module_spec = false;
|
|
if (process) {
|
|
// Try to get module information from the process
|
|
if (process->GetModuleSpec(module_spec.GetFileSpec(),
|
|
module_spec.GetArchitecture(),
|
|
resolved_module_spec)) {
|
|
if (!module_spec.GetUUID().IsValid() ||
|
|
module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
|
|
got_module_spec = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!module_spec.GetArchitecture().IsValid()) {
|
|
Status error;
|
|
// No valid architecture was specified, ask the platform for the
|
|
// architectures that we should be using (in the correct order) and see if
|
|
// we can find a match that way
|
|
ModuleSpec arch_module_spec(module_spec);
|
|
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
|
|
idx, arch_module_spec.GetArchitecture());
|
|
++idx) {
|
|
error = ModuleList::GetSharedModule(arch_module_spec, module_sp, nullptr,
|
|
nullptr, nullptr);
|
|
// Did we find an executable using one of the
|
|
if (error.Success() && module_sp)
|
|
break;
|
|
}
|
|
if (module_sp) {
|
|
resolved_module_spec = arch_module_spec;
|
|
got_module_spec = true;
|
|
}
|
|
}
|
|
|
|
if (!got_module_spec) {
|
|
// Get module information from a target.
|
|
if (GetModuleSpec(module_spec.GetFileSpec(), module_spec.GetArchitecture(),
|
|
resolved_module_spec)) {
|
|
if (!module_spec.GetUUID().IsValid() ||
|
|
module_spec.GetUUID() == resolved_module_spec.GetUUID()) {
|
|
got_module_spec = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!got_module_spec) {
|
|
// Fall back to the given module resolver, which may have its own
|
|
// search logic.
|
|
return module_resolver(module_spec);
|
|
}
|
|
|
|
// If we are looking for a specific UUID, make sure resolved_module_spec has
|
|
// the same one before we search.
|
|
if (module_spec.GetUUID().IsValid()) {
|
|
resolved_module_spec.GetUUID() = module_spec.GetUUID();
|
|
}
|
|
|
|
// Trying to find a module by UUID on local file system.
|
|
const auto error = module_resolver(resolved_module_spec);
|
|
if (error.Fail()) {
|
|
if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
|
|
return Status();
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
|
|
lldb::ModuleSP &module_sp,
|
|
bool *did_create_ptr) {
|
|
if (IsHost() || !GetGlobalPlatformProperties()->GetUseModuleCache() ||
|
|
!GetGlobalPlatformProperties()->GetModuleCacheDirectory())
|
|
return false;
|
|
|
|
Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
|
|
|
|
// Check local cache for a module.
|
|
auto error = m_module_cache->GetAndPut(
|
|
GetModuleCacheRoot(), GetCacheHostname(), module_spec,
|
|
[this](const ModuleSpec &module_spec,
|
|
const FileSpec &tmp_download_file_spec) {
|
|
return DownloadModuleSlice(
|
|
module_spec.GetFileSpec(), module_spec.GetObjectOffset(),
|
|
module_spec.GetObjectSize(), tmp_download_file_spec);
|
|
|
|
},
|
|
[this](const ModuleSP &module_sp,
|
|
const FileSpec &tmp_download_file_spec) {
|
|
return DownloadSymbolFile(module_sp, tmp_download_file_spec);
|
|
},
|
|
module_sp, did_create_ptr);
|
|
if (error.Success())
|
|
return true;
|
|
|
|
LLDB_LOGF(log, "Platform::%s - module %s not found in local cache: %s",
|
|
__FUNCTION__, module_spec.GetUUID().GetAsString().c_str(),
|
|
error.AsCString());
|
|
return false;
|
|
}
|
|
|
|
Status Platform::DownloadModuleSlice(const FileSpec &src_file_spec,
|
|
const uint64_t src_offset,
|
|
const uint64_t src_size,
|
|
const FileSpec &dst_file_spec) {
|
|
Status error;
|
|
|
|
std::error_code EC;
|
|
llvm::raw_fd_ostream dst(dst_file_spec.GetPath(), EC, llvm::sys::fs::OF_None);
|
|
if (EC) {
|
|
error.SetErrorStringWithFormat("unable to open destination file: %s",
|
|
dst_file_spec.GetPath().c_str());
|
|
return error;
|
|
}
|
|
|
|
auto src_fd = OpenFile(src_file_spec, File::eOpenOptionRead,
|
|
lldb::eFilePermissionsFileDefault, error);
|
|
|
|
if (error.Fail()) {
|
|
error.SetErrorStringWithFormat("unable to open source file: %s",
|
|
error.AsCString());
|
|
return error;
|
|
}
|
|
|
|
std::vector<char> buffer(1024);
|
|
auto offset = src_offset;
|
|
uint64_t total_bytes_read = 0;
|
|
while (total_bytes_read < src_size) {
|
|
const auto to_read = std::min(static_cast<uint64_t>(buffer.size()),
|
|
src_size - total_bytes_read);
|
|
const uint64_t n_read =
|
|
ReadFile(src_fd, offset, &buffer[0], to_read, error);
|
|
if (error.Fail())
|
|
break;
|
|
if (n_read == 0) {
|
|
error.SetErrorString("read 0 bytes");
|
|
break;
|
|
}
|
|
offset += n_read;
|
|
total_bytes_read += n_read;
|
|
dst.write(&buffer[0], n_read);
|
|
}
|
|
|
|
Status close_error;
|
|
CloseFile(src_fd, close_error); // Ignoring close error.
|
|
|
|
return error;
|
|
}
|
|
|
|
Status Platform::DownloadSymbolFile(const lldb::ModuleSP &module_sp,
|
|
const FileSpec &dst_file_spec) {
|
|
return Status(
|
|
"Symbol file downloading not supported by the default platform.");
|
|
}
|
|
|
|
FileSpec Platform::GetModuleCacheRoot() {
|
|
auto dir_spec = GetGlobalPlatformProperties()->GetModuleCacheDirectory();
|
|
dir_spec.AppendPathComponent(GetName().AsCString());
|
|
return dir_spec;
|
|
}
|
|
|
|
const char *Platform::GetCacheHostname() { return GetHostname(); }
|
|
|
|
const UnixSignalsSP &Platform::GetRemoteUnixSignals() {
|
|
static const auto s_default_unix_signals_sp = std::make_shared<UnixSignals>();
|
|
return s_default_unix_signals_sp;
|
|
}
|
|
|
|
UnixSignalsSP Platform::GetUnixSignals() {
|
|
if (IsHost())
|
|
return UnixSignals::CreateForHost();
|
|
return GetRemoteUnixSignals();
|
|
}
|
|
|
|
uint32_t Platform::LoadImage(lldb_private::Process *process,
|
|
const lldb_private::FileSpec &local_file,
|
|
const lldb_private::FileSpec &remote_file,
|
|
lldb_private::Status &error) {
|
|
if (local_file && remote_file) {
|
|
// Both local and remote file was specified. Install the local file to the
|
|
// given location.
|
|
if (IsRemote() || local_file != remote_file) {
|
|
error = Install(local_file, remote_file);
|
|
if (error.Fail())
|
|
return LLDB_INVALID_IMAGE_TOKEN;
|
|
}
|
|
return DoLoadImage(process, remote_file, nullptr, error);
|
|
}
|
|
|
|
if (local_file) {
|
|
// Only local file was specified. Install it to the current working
|
|
// directory.
|
|
FileSpec target_file = GetWorkingDirectory();
|
|
target_file.AppendPathComponent(local_file.GetFilename().AsCString());
|
|
if (IsRemote() || local_file != target_file) {
|
|
error = Install(local_file, target_file);
|
|
if (error.Fail())
|
|
return LLDB_INVALID_IMAGE_TOKEN;
|
|
}
|
|
return DoLoadImage(process, target_file, nullptr, error);
|
|
}
|
|
|
|
if (remote_file) {
|
|
// Only remote file was specified so we don't have to do any copying
|
|
return DoLoadImage(process, remote_file, nullptr, error);
|
|
}
|
|
|
|
error.SetErrorString("Neither local nor remote file was specified");
|
|
return LLDB_INVALID_IMAGE_TOKEN;
|
|
}
|
|
|
|
uint32_t Platform::DoLoadImage(lldb_private::Process *process,
|
|
const lldb_private::FileSpec &remote_file,
|
|
const std::vector<std::string> *paths,
|
|
lldb_private::Status &error,
|
|
lldb_private::FileSpec *loaded_image) {
|
|
error.SetErrorString("LoadImage is not supported on the current platform");
|
|
return LLDB_INVALID_IMAGE_TOKEN;
|
|
}
|
|
|
|
uint32_t Platform::LoadImageUsingPaths(lldb_private::Process *process,
|
|
const lldb_private::FileSpec &remote_filename,
|
|
const std::vector<std::string> &paths,
|
|
lldb_private::Status &error,
|
|
lldb_private::FileSpec *loaded_path)
|
|
{
|
|
FileSpec file_to_use;
|
|
if (remote_filename.IsAbsolute())
|
|
file_to_use = FileSpec(remote_filename.GetFilename().GetStringRef(),
|
|
|
|
remote_filename.GetPathStyle());
|
|
else
|
|
file_to_use = remote_filename;
|
|
|
|
return DoLoadImage(process, file_to_use, &paths, error, loaded_path);
|
|
}
|
|
|
|
Status Platform::UnloadImage(lldb_private::Process *process,
|
|
uint32_t image_token) {
|
|
return Status("UnloadImage is not supported on the current platform");
|
|
}
|
|
|
|
lldb::ProcessSP Platform::ConnectProcess(llvm::StringRef connect_url,
|
|
llvm::StringRef plugin_name,
|
|
Debugger &debugger, Target *target,
|
|
Status &error) {
|
|
return DoConnectProcess(connect_url, plugin_name, debugger, nullptr, target,
|
|
error);
|
|
}
|
|
|
|
lldb::ProcessSP Platform::ConnectProcessSynchronous(
|
|
llvm::StringRef connect_url, llvm::StringRef plugin_name,
|
|
Debugger &debugger, Stream &stream, Target *target, Status &error) {
|
|
return DoConnectProcess(connect_url, plugin_name, debugger, &stream, target,
|
|
error);
|
|
}
|
|
|
|
lldb::ProcessSP Platform::DoConnectProcess(llvm::StringRef connect_url,
|
|
llvm::StringRef plugin_name,
|
|
Debugger &debugger, Stream *stream,
|
|
Target *target, Status &error) {
|
|
error.Clear();
|
|
|
|
if (!target) {
|
|
ArchSpec arch;
|
|
if (target && target->GetArchitecture().IsValid())
|
|
arch = target->GetArchitecture();
|
|
else
|
|
arch = Target::GetDefaultArchitecture();
|
|
|
|
const char *triple = "";
|
|
if (arch.IsValid())
|
|
triple = arch.GetTriple().getTriple().c_str();
|
|
|
|
TargetSP new_target_sp;
|
|
error = debugger.GetTargetList().CreateTarget(
|
|
debugger, "", triple, eLoadDependentsNo, nullptr, new_target_sp);
|
|
target = new_target_sp.get();
|
|
}
|
|
|
|
if (!target || error.Fail())
|
|
return nullptr;
|
|
|
|
debugger.GetTargetList().SetSelectedTarget(target);
|
|
|
|
lldb::ProcessSP process_sp =
|
|
target->CreateProcess(debugger.GetListener(), plugin_name, nullptr, true);
|
|
|
|
if (!process_sp)
|
|
return nullptr;
|
|
|
|
// If this private method is called with a stream we are synchronous.
|
|
const bool synchronous = stream != nullptr;
|
|
|
|
ListenerSP listener_sp(
|
|
Listener::MakeListener("lldb.Process.ConnectProcess.hijack"));
|
|
if (synchronous)
|
|
process_sp->HijackProcessEvents(listener_sp);
|
|
|
|
error = process_sp->ConnectRemote(connect_url);
|
|
if (error.Fail()) {
|
|
if (synchronous)
|
|
process_sp->RestoreProcessEvents();
|
|
return nullptr;
|
|
}
|
|
|
|
if (synchronous) {
|
|
EventSP event_sp;
|
|
process_sp->WaitForProcessToStop(llvm::None, &event_sp, true, listener_sp,
|
|
nullptr);
|
|
process_sp->RestoreProcessEvents();
|
|
bool pop_process_io_handler = false;
|
|
Process::HandleProcessStateChangedEvent(event_sp, stream,
|
|
pop_process_io_handler);
|
|
}
|
|
|
|
return process_sp;
|
|
}
|
|
|
|
size_t Platform::ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
|
|
lldb_private::Status &error) {
|
|
error.Clear();
|
|
return 0;
|
|
}
|
|
|
|
size_t Platform::GetSoftwareBreakpointTrapOpcode(Target &target,
|
|
BreakpointSite *bp_site) {
|
|
ArchSpec arch = target.GetArchitecture();
|
|
assert(arch.IsValid());
|
|
const uint8_t *trap_opcode = nullptr;
|
|
size_t trap_opcode_size = 0;
|
|
|
|
switch (arch.GetMachine()) {
|
|
case llvm::Triple::aarch64_32:
|
|
case llvm::Triple::aarch64: {
|
|
static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
|
|
trap_opcode = g_aarch64_opcode;
|
|
trap_opcode_size = sizeof(g_aarch64_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::arc: {
|
|
static const uint8_t g_hex_opcode[] = { 0xff, 0x7f };
|
|
trap_opcode = g_hex_opcode;
|
|
trap_opcode_size = sizeof(g_hex_opcode);
|
|
} break;
|
|
|
|
// TODO: support big-endian arm and thumb trap codes.
|
|
case llvm::Triple::arm: {
|
|
// The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
|
|
// linux kernel does otherwise.
|
|
static const uint8_t g_arm_breakpoint_opcode[] = {0xf0, 0x01, 0xf0, 0xe7};
|
|
static const uint8_t g_thumb_breakpoint_opcode[] = {0x01, 0xde};
|
|
|
|
lldb::BreakpointLocationSP bp_loc_sp(bp_site->GetOwnerAtIndex(0));
|
|
AddressClass addr_class = AddressClass::eUnknown;
|
|
|
|
if (bp_loc_sp) {
|
|
addr_class = bp_loc_sp->GetAddress().GetAddressClass();
|
|
if (addr_class == AddressClass::eUnknown &&
|
|
(bp_loc_sp->GetAddress().GetFileAddress() & 1))
|
|
addr_class = AddressClass::eCodeAlternateISA;
|
|
}
|
|
|
|
if (addr_class == AddressClass::eCodeAlternateISA) {
|
|
trap_opcode = g_thumb_breakpoint_opcode;
|
|
trap_opcode_size = sizeof(g_thumb_breakpoint_opcode);
|
|
} else {
|
|
trap_opcode = g_arm_breakpoint_opcode;
|
|
trap_opcode_size = sizeof(g_arm_breakpoint_opcode);
|
|
}
|
|
} break;
|
|
|
|
case llvm::Triple::avr: {
|
|
static const uint8_t g_hex_opcode[] = {0x98, 0x95};
|
|
trap_opcode = g_hex_opcode;
|
|
trap_opcode_size = sizeof(g_hex_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::mips:
|
|
case llvm::Triple::mips64: {
|
|
static const uint8_t g_hex_opcode[] = {0x00, 0x00, 0x00, 0x0d};
|
|
trap_opcode = g_hex_opcode;
|
|
trap_opcode_size = sizeof(g_hex_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::mipsel:
|
|
case llvm::Triple::mips64el: {
|
|
static const uint8_t g_hex_opcode[] = {0x0d, 0x00, 0x00, 0x00};
|
|
trap_opcode = g_hex_opcode;
|
|
trap_opcode_size = sizeof(g_hex_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::systemz: {
|
|
static const uint8_t g_hex_opcode[] = {0x00, 0x01};
|
|
trap_opcode = g_hex_opcode;
|
|
trap_opcode_size = sizeof(g_hex_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::hexagon: {
|
|
static const uint8_t g_hex_opcode[] = {0x0c, 0xdb, 0x00, 0x54};
|
|
trap_opcode = g_hex_opcode;
|
|
trap_opcode_size = sizeof(g_hex_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::ppc:
|
|
case llvm::Triple::ppc64: {
|
|
static const uint8_t g_ppc_opcode[] = {0x7f, 0xe0, 0x00, 0x08};
|
|
trap_opcode = g_ppc_opcode;
|
|
trap_opcode_size = sizeof(g_ppc_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::ppc64le: {
|
|
static const uint8_t g_ppc64le_opcode[] = {0x08, 0x00, 0xe0, 0x7f}; // trap
|
|
trap_opcode = g_ppc64le_opcode;
|
|
trap_opcode_size = sizeof(g_ppc64le_opcode);
|
|
} break;
|
|
|
|
case llvm::Triple::x86:
|
|
case llvm::Triple::x86_64: {
|
|
static const uint8_t g_i386_opcode[] = {0xCC};
|
|
trap_opcode = g_i386_opcode;
|
|
trap_opcode_size = sizeof(g_i386_opcode);
|
|
} break;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
assert(bp_site);
|
|
if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size))
|
|
return trap_opcode_size;
|
|
|
|
return 0;
|
|
}
|