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.
440 lines
16 KiB
440 lines
16 KiB
//===-- RemoteAwarePlatform.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 "lldb/Target/RemoteAwarePlatform.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/ModuleList.h"
|
|
#include "lldb/Core/ModuleSpec.h"
|
|
#include "lldb/Host/FileCache.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
|
|
using namespace lldb_private;
|
|
using namespace lldb;
|
|
|
|
bool RemoteAwarePlatform::GetModuleSpec(const FileSpec &module_file_spec,
|
|
const ArchSpec &arch,
|
|
ModuleSpec &module_spec) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetModuleSpec(module_file_spec, arch,
|
|
module_spec);
|
|
|
|
return false;
|
|
}
|
|
|
|
Status RemoteAwarePlatform::ResolveExecutable(
|
|
const ModuleSpec &module_spec, ModuleSP &exe_module_sp,
|
|
const FileSpecList *module_search_paths_ptr) {
|
|
Status error;
|
|
// Nothing special to do here, just use the actual file and architecture
|
|
|
|
char exe_path[PATH_MAX];
|
|
ModuleSpec resolved_module_spec(module_spec);
|
|
|
|
if (IsHost()) {
|
|
// If we have "ls" as the exe_file, resolve the executable location based
|
|
// on the current path variables
|
|
if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec())) {
|
|
resolved_module_spec.GetFileSpec().GetPath(exe_path, sizeof(exe_path));
|
|
resolved_module_spec.GetFileSpec().SetFile(exe_path,
|
|
FileSpec::Style::native);
|
|
FileSystem::Instance().Resolve(resolved_module_spec.GetFileSpec());
|
|
}
|
|
|
|
if (!FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
|
|
FileSystem::Instance().ResolveExecutableLocation(
|
|
resolved_module_spec.GetFileSpec());
|
|
|
|
// Resolve any executable within a bundle on MacOSX
|
|
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
|
|
|
|
if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
|
|
error.Clear();
|
|
else {
|
|
const uint32_t permissions = FileSystem::Instance().GetPermissions(
|
|
resolved_module_spec.GetFileSpec());
|
|
if (permissions && (permissions & eFilePermissionsEveryoneR) == 0)
|
|
error.SetErrorStringWithFormat(
|
|
"executable '%s' is not readable",
|
|
resolved_module_spec.GetFileSpec().GetPath().c_str());
|
|
else
|
|
error.SetErrorStringWithFormat(
|
|
"unable to find executable for '%s'",
|
|
resolved_module_spec.GetFileSpec().GetPath().c_str());
|
|
}
|
|
} else {
|
|
if (m_remote_platform_sp) {
|
|
return GetCachedExecutable(resolved_module_spec, exe_module_sp,
|
|
module_search_paths_ptr,
|
|
*m_remote_platform_sp);
|
|
}
|
|
|
|
// We may connect to a process and use the provided executable (Don't use
|
|
// local $PATH).
|
|
|
|
// Resolve any executable within a bundle on MacOSX
|
|
Host::ResolveExecutableInBundle(resolved_module_spec.GetFileSpec());
|
|
|
|
if (FileSystem::Instance().Exists(resolved_module_spec.GetFileSpec()))
|
|
error.Clear();
|
|
else
|
|
error.SetErrorStringWithFormat("the platform is not currently "
|
|
"connected, and '%s' doesn't exist in "
|
|
"the system root.",
|
|
exe_path);
|
|
}
|
|
|
|
if (error.Success()) {
|
|
if (resolved_module_spec.GetArchitecture().IsValid()) {
|
|
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
|
|
module_search_paths_ptr, nullptr, nullptr);
|
|
if (error.Fail()) {
|
|
// If we failed, it may be because the vendor and os aren't known. If
|
|
// that is the case, try setting them to the host architecture and give
|
|
// it another try.
|
|
llvm::Triple &module_triple =
|
|
resolved_module_spec.GetArchitecture().GetTriple();
|
|
bool is_vendor_specified =
|
|
(module_triple.getVendor() != llvm::Triple::UnknownVendor);
|
|
bool is_os_specified =
|
|
(module_triple.getOS() != llvm::Triple::UnknownOS);
|
|
if (!is_vendor_specified || !is_os_specified) {
|
|
const llvm::Triple &host_triple =
|
|
HostInfo::GetArchitecture(HostInfo::eArchKindDefault).GetTriple();
|
|
|
|
if (!is_vendor_specified)
|
|
module_triple.setVendorName(host_triple.getVendorName());
|
|
if (!is_os_specified)
|
|
module_triple.setOSName(host_triple.getOSName());
|
|
|
|
error = ModuleList::GetSharedModule(resolved_module_spec,
|
|
exe_module_sp, module_search_paths_ptr, nullptr, nullptr);
|
|
}
|
|
}
|
|
|
|
// TODO find out why exe_module_sp might be NULL
|
|
if (error.Fail() || !exe_module_sp || !exe_module_sp->GetObjectFile()) {
|
|
exe_module_sp.reset();
|
|
error.SetErrorStringWithFormat(
|
|
"'%s' doesn't contain the architecture %s",
|
|
resolved_module_spec.GetFileSpec().GetPath().c_str(),
|
|
resolved_module_spec.GetArchitecture().GetArchitectureName());
|
|
}
|
|
} 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
|
|
StreamString arch_names;
|
|
for (uint32_t idx = 0; GetSupportedArchitectureAtIndex(
|
|
idx, resolved_module_spec.GetArchitecture());
|
|
++idx) {
|
|
error = ModuleList::GetSharedModule(resolved_module_spec, exe_module_sp,
|
|
module_search_paths_ptr, nullptr, nullptr);
|
|
// Did we find an executable using one of the
|
|
if (error.Success()) {
|
|
if (exe_module_sp && exe_module_sp->GetObjectFile())
|
|
break;
|
|
else
|
|
error.SetErrorToGenericError();
|
|
}
|
|
|
|
if (idx > 0)
|
|
arch_names.PutCString(", ");
|
|
arch_names.PutCString(
|
|
resolved_module_spec.GetArchitecture().GetArchitectureName());
|
|
}
|
|
|
|
if (error.Fail() || !exe_module_sp) {
|
|
if (FileSystem::Instance().Readable(
|
|
resolved_module_spec.GetFileSpec())) {
|
|
error.SetErrorStringWithFormat(
|
|
"'%s' doesn't contain any '%s' platform architectures: %s",
|
|
resolved_module_spec.GetFileSpec().GetPath().c_str(),
|
|
GetPluginName().GetCString(), arch_names.GetData());
|
|
} else {
|
|
error.SetErrorStringWithFormat(
|
|
"'%s' is not readable",
|
|
resolved_module_spec.GetFileSpec().GetPath().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
Status RemoteAwarePlatform::RunShellCommand(
|
|
llvm::StringRef command, const FileSpec &working_dir, int *status_ptr,
|
|
int *signo_ptr, std::string *command_output,
|
|
const Timeout<std::micro> &timeout) {
|
|
return RunShellCommand(llvm::StringRef(), command, working_dir, status_ptr,
|
|
signo_ptr, command_output, timeout);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::RunShellCommand(
|
|
llvm::StringRef shell, llvm::StringRef command, const FileSpec &working_dir,
|
|
int *status_ptr, int *signo_ptr, std::string *command_output,
|
|
const Timeout<std::micro> &timeout) {
|
|
if (IsHost())
|
|
return Host::RunShellCommand(shell, command, working_dir, status_ptr,
|
|
signo_ptr, command_output, timeout);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->RunShellCommand(shell, command, working_dir,
|
|
status_ptr, signo_ptr,
|
|
command_output, timeout);
|
|
return Status("unable to run a remote command without a platform");
|
|
}
|
|
|
|
Status RemoteAwarePlatform::MakeDirectory(const FileSpec &file_spec,
|
|
uint32_t file_permissions) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->MakeDirectory(file_spec, file_permissions);
|
|
return Platform::MakeDirectory(file_spec, file_permissions);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::GetFilePermissions(const FileSpec &file_spec,
|
|
uint32_t &file_permissions) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetFilePermissions(file_spec,
|
|
file_permissions);
|
|
return Platform::GetFilePermissions(file_spec, file_permissions);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::SetFilePermissions(const FileSpec &file_spec,
|
|
uint32_t file_permissions) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->SetFilePermissions(file_spec,
|
|
file_permissions);
|
|
return Platform::SetFilePermissions(file_spec, file_permissions);
|
|
}
|
|
|
|
lldb::user_id_t RemoteAwarePlatform::OpenFile(const FileSpec &file_spec,
|
|
File::OpenOptions flags,
|
|
uint32_t mode, Status &error) {
|
|
if (IsHost())
|
|
return FileCache::GetInstance().OpenFile(file_spec, flags, mode, error);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->OpenFile(file_spec, flags, mode, error);
|
|
return Platform::OpenFile(file_spec, flags, mode, error);
|
|
}
|
|
|
|
bool RemoteAwarePlatform::CloseFile(lldb::user_id_t fd, Status &error) {
|
|
if (IsHost())
|
|
return FileCache::GetInstance().CloseFile(fd, error);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->CloseFile(fd, error);
|
|
return Platform::CloseFile(fd, error);
|
|
}
|
|
|
|
uint64_t RemoteAwarePlatform::ReadFile(lldb::user_id_t fd, uint64_t offset,
|
|
void *dst, uint64_t dst_len,
|
|
Status &error) {
|
|
if (IsHost())
|
|
return FileCache::GetInstance().ReadFile(fd, offset, dst, dst_len, error);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->ReadFile(fd, offset, dst, dst_len, error);
|
|
return Platform::ReadFile(fd, offset, dst, dst_len, error);
|
|
}
|
|
|
|
uint64_t RemoteAwarePlatform::WriteFile(lldb::user_id_t fd, uint64_t offset,
|
|
const void *src, uint64_t src_len,
|
|
Status &error) {
|
|
if (IsHost())
|
|
return FileCache::GetInstance().WriteFile(fd, offset, src, src_len, error);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->WriteFile(fd, offset, src, src_len, error);
|
|
return Platform::WriteFile(fd, offset, src, src_len, error);
|
|
}
|
|
|
|
lldb::user_id_t RemoteAwarePlatform::GetFileSize(const FileSpec &file_spec) {
|
|
if (IsHost()) {
|
|
uint64_t Size;
|
|
if (llvm::sys::fs::file_size(file_spec.GetPath(), Size))
|
|
return 0;
|
|
return Size;
|
|
}
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetFileSize(file_spec);
|
|
return Platform::GetFileSize(file_spec);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::CreateSymlink(const FileSpec &src,
|
|
const FileSpec &dst) {
|
|
if (IsHost())
|
|
return FileSystem::Instance().Symlink(src, dst);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->CreateSymlink(src, dst);
|
|
return Platform::CreateSymlink(src, dst);
|
|
}
|
|
|
|
bool RemoteAwarePlatform::GetFileExists(const FileSpec &file_spec) {
|
|
if (IsHost())
|
|
return FileSystem::Instance().Exists(file_spec);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetFileExists(file_spec);
|
|
return Platform::GetFileExists(file_spec);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::Unlink(const FileSpec &file_spec) {
|
|
if (IsHost())
|
|
return llvm::sys::fs::remove(file_spec.GetPath());
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->Unlink(file_spec);
|
|
return Platform::Unlink(file_spec);
|
|
}
|
|
|
|
bool RemoteAwarePlatform::CalculateMD5(const FileSpec &file_spec, uint64_t &low,
|
|
uint64_t &high) {
|
|
if (IsHost())
|
|
return Platform::CalculateMD5(file_spec, low, high);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->CalculateMD5(file_spec, low, high);
|
|
return false;
|
|
}
|
|
|
|
FileSpec RemoteAwarePlatform::GetRemoteWorkingDirectory() {
|
|
if (IsRemote() && m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetRemoteWorkingDirectory();
|
|
return Platform::GetRemoteWorkingDirectory();
|
|
}
|
|
|
|
bool RemoteAwarePlatform::SetRemoteWorkingDirectory(
|
|
const FileSpec &working_dir) {
|
|
if (IsRemote() && m_remote_platform_sp)
|
|
return m_remote_platform_sp->SetRemoteWorkingDirectory(working_dir);
|
|
return Platform::SetRemoteWorkingDirectory(working_dir);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::GetFileWithUUID(const FileSpec &platform_file,
|
|
const UUID *uuid_ptr,
|
|
FileSpec &local_file) {
|
|
if (IsRemote() && m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetFileWithUUID(platform_file, uuid_ptr,
|
|
local_file);
|
|
|
|
// Default to the local case
|
|
local_file = platform_file;
|
|
return Status();
|
|
}
|
|
|
|
bool RemoteAwarePlatform::GetRemoteOSVersion() {
|
|
if (m_remote_platform_sp) {
|
|
m_os_version = m_remote_platform_sp->GetOSVersion();
|
|
return !m_os_version.empty();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool RemoteAwarePlatform::GetRemoteOSBuildString(std::string &s) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetRemoteOSBuildString(s);
|
|
s.clear();
|
|
return false;
|
|
}
|
|
|
|
bool RemoteAwarePlatform::GetRemoteOSKernelDescription(std::string &s) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetRemoteOSKernelDescription(s);
|
|
s.clear();
|
|
return false;
|
|
}
|
|
|
|
ArchSpec RemoteAwarePlatform::GetRemoteSystemArchitecture() {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetRemoteSystemArchitecture();
|
|
return ArchSpec();
|
|
}
|
|
|
|
const char *RemoteAwarePlatform::GetHostname() {
|
|
if (IsHost())
|
|
return Platform::GetHostname();
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetHostname();
|
|
return nullptr;
|
|
}
|
|
|
|
UserIDResolver &RemoteAwarePlatform::GetUserIDResolver() {
|
|
if (IsHost())
|
|
return HostInfo::GetUserIDResolver();
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetUserIDResolver();
|
|
return UserIDResolver::GetNoopResolver();
|
|
}
|
|
|
|
Environment RemoteAwarePlatform::GetEnvironment() {
|
|
if (IsRemote()) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetEnvironment();
|
|
return Environment();
|
|
}
|
|
return Host::GetEnvironment();
|
|
}
|
|
|
|
bool RemoteAwarePlatform::IsConnected() const {
|
|
if (IsHost())
|
|
return true;
|
|
else if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->IsConnected();
|
|
return false;
|
|
}
|
|
|
|
bool RemoteAwarePlatform::GetProcessInfo(lldb::pid_t pid,
|
|
ProcessInstanceInfo &process_info) {
|
|
if (IsHost())
|
|
return Platform::GetProcessInfo(pid, process_info);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->GetProcessInfo(pid, process_info);
|
|
return false;
|
|
}
|
|
|
|
uint32_t
|
|
RemoteAwarePlatform::FindProcesses(const ProcessInstanceInfoMatch &match_info,
|
|
ProcessInstanceInfoList &process_infos) {
|
|
if (IsHost())
|
|
return Platform::FindProcesses(match_info, process_infos);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->FindProcesses(match_info, process_infos);
|
|
return 0;
|
|
}
|
|
|
|
lldb::ProcessSP RemoteAwarePlatform::ConnectProcess(llvm::StringRef connect_url,
|
|
llvm::StringRef plugin_name,
|
|
Debugger &debugger,
|
|
Target *target,
|
|
Status &error) {
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->ConnectProcess(connect_url, plugin_name,
|
|
debugger, target, error);
|
|
return Platform::ConnectProcess(connect_url, plugin_name, debugger, target,
|
|
error);
|
|
}
|
|
|
|
Status RemoteAwarePlatform::LaunchProcess(ProcessLaunchInfo &launch_info) {
|
|
Status error;
|
|
|
|
if (IsHost()) {
|
|
error = Platform::LaunchProcess(launch_info);
|
|
} else {
|
|
if (m_remote_platform_sp)
|
|
error = m_remote_platform_sp->LaunchProcess(launch_info);
|
|
else
|
|
error.SetErrorString("the platform is not currently connected");
|
|
}
|
|
return error;
|
|
}
|
|
|
|
Status RemoteAwarePlatform::KillProcess(const lldb::pid_t pid) {
|
|
if (IsHost())
|
|
return Platform::KillProcess(pid);
|
|
if (m_remote_platform_sp)
|
|
return m_remote_platform_sp->KillProcess(pid);
|
|
return Status("the platform is not currently connected");
|
|
}
|