150db43e41
With Scripted Processes, in order to create scripted threads, the blueprint
provides a dictionary that have each thread index as the key with the respective
thread instance as the pair value.
In Python, this is fine because a dictionary key can be of any type including
integer types:
```
>>> {1: "one", 2: "two", 10: "ten"}
{1: 'one', 2: 'two', 10: 'ten'}
```
However, when the python dictionary gets bridged to C++ we convert it to a
`StructuredData::Dictionary` that uses a `std::map<ConstString, ObjectSP>`
for storage.
Because `std::map` is an ordered container and ours uses the `ConstString`
type for keys, the thread indices gets converted to strings which makes the
dictionary sorted alphabetically, instead of numerically.
If the ScriptedProcess has 10 threads or more, it causes thread “10”
(and higher) to be after thread “1”, but before thread “2”.
In order to solve this, this sorts the thread info dictionary keys
numerically, before iterating over them to create ScriptedThreads.
rdar://90327854
Differential Revision: https://reviews.llvm.org/D122429
Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>
491 lines
16 KiB
C++
491 lines
16 KiB
C++
//===-- ScriptedProcess.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 "ScriptedProcess.h"
|
|
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
|
|
#include "lldb/Host/OptionParser.h"
|
|
#include "lldb/Host/ThreadLauncher.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/OptionArgParser.h"
|
|
#include "lldb/Interpreter/OptionGroupBoolean.h"
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
|
#include "lldb/Target/MemoryRegionInfo.h"
|
|
#include "lldb/Target/RegisterContext.h"
|
|
#include "lldb/Utility/LLDBLog.h"
|
|
#include "lldb/Utility/State.h"
|
|
|
|
#include <mutex>
|
|
|
|
LLDB_PLUGIN_DEFINE(ScriptedProcess)
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
llvm::StringRef ScriptedProcess::GetPluginDescriptionStatic() {
|
|
return "Scripted Process plug-in.";
|
|
}
|
|
|
|
static constexpr lldb::ScriptLanguage g_supported_script_languages[] = {
|
|
ScriptLanguage::eScriptLanguagePython,
|
|
};
|
|
|
|
bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) {
|
|
llvm::ArrayRef<lldb::ScriptLanguage> supported_languages =
|
|
llvm::makeArrayRef(g_supported_script_languages);
|
|
|
|
return llvm::is_contained(supported_languages, language);
|
|
}
|
|
|
|
void ScriptedProcess::CheckInterpreterAndScriptObject() const {
|
|
lldbassert(m_interpreter && "Invalid Script Interpreter.");
|
|
lldbassert(m_script_object_sp && "Invalid Script Object.");
|
|
}
|
|
|
|
lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
|
|
lldb::ListenerSP listener_sp,
|
|
const FileSpec *file,
|
|
bool can_connect) {
|
|
if (!target_sp ||
|
|
!IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage()))
|
|
return nullptr;
|
|
|
|
Status error;
|
|
ScriptedProcess::ScriptedProcessInfo scripted_process_info(
|
|
target_sp->GetProcessLaunchInfo());
|
|
|
|
auto process_sp = std::make_shared<ScriptedProcess>(
|
|
target_sp, listener_sp, scripted_process_info, error);
|
|
|
|
if (error.Fail() || !process_sp || !process_sp->m_script_object_sp ||
|
|
!process_sp->m_script_object_sp->IsValid()) {
|
|
LLDB_LOGF(GetLog(LLDBLog::Process), "%s", error.AsCString());
|
|
return nullptr;
|
|
}
|
|
|
|
return process_sp;
|
|
}
|
|
|
|
bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
|
|
bool plugin_specified_by_name) {
|
|
return true;
|
|
}
|
|
|
|
ScriptedProcess::ScriptedProcess(
|
|
lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
|
|
const ScriptedProcess::ScriptedProcessInfo &scripted_process_info,
|
|
Status &error)
|
|
: Process(target_sp, listener_sp),
|
|
m_scripted_process_info(scripted_process_info) {
|
|
|
|
if (!target_sp) {
|
|
error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
|
|
__FUNCTION__, "Invalid target");
|
|
return;
|
|
}
|
|
|
|
m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
|
|
|
|
if (!m_interpreter) {
|
|
error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
|
|
__FUNCTION__,
|
|
"Debugger has no Script Interpreter");
|
|
return;
|
|
}
|
|
|
|
ExecutionContext exe_ctx(target_sp, /*get_process=*/false);
|
|
|
|
StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject(
|
|
m_scripted_process_info.GetClassName().c_str(), exe_ctx,
|
|
m_scripted_process_info.GetArgsSP());
|
|
|
|
if (!object_sp || !object_sp->IsValid()) {
|
|
error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
|
|
__FUNCTION__,
|
|
"Failed to create valid script object");
|
|
return;
|
|
}
|
|
|
|
m_script_object_sp = object_sp;
|
|
}
|
|
|
|
ScriptedProcess::~ScriptedProcess() {
|
|
Clear();
|
|
// We need to call finalize on the process before destroying ourselves to
|
|
// make sure all of the broadcaster cleanup goes as planned. If we destruct
|
|
// this class, then Process::~Process() might have problems trying to fully
|
|
// destroy the broadcaster.
|
|
Finalize();
|
|
}
|
|
|
|
void ScriptedProcess::Initialize() {
|
|
static llvm::once_flag g_once_flag;
|
|
|
|
llvm::call_once(g_once_flag, []() {
|
|
PluginManager::RegisterPlugin(GetPluginNameStatic(),
|
|
GetPluginDescriptionStatic(), CreateInstance);
|
|
});
|
|
}
|
|
|
|
void ScriptedProcess::Terminate() {
|
|
PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance);
|
|
}
|
|
|
|
Status ScriptedProcess::DoLoadCore() {
|
|
ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
|
|
|
|
return DoLaunch(nullptr, launch_info);
|
|
}
|
|
|
|
Status ScriptedProcess::DoLaunch(Module *exe_module,
|
|
ProcessLaunchInfo &launch_info) {
|
|
CheckInterpreterAndScriptObject();
|
|
|
|
/* FIXME: This doesn't reflect how lldb actually launches a process.
|
|
In reality, it attaches to debugserver, then resume the process. */
|
|
Status error = GetInterface().Launch();
|
|
SetPrivateState(eStateRunning);
|
|
|
|
if (error.Fail())
|
|
return error;
|
|
|
|
// TODO: Fetch next state from stopped event queue then send stop event
|
|
// const StateType state = SetThreadStopInfo(response);
|
|
// if (state != eStateInvalid) {
|
|
// SetPrivateState(state);
|
|
|
|
SetPrivateState(eStateStopped);
|
|
|
|
return {};
|
|
}
|
|
|
|
void ScriptedProcess::DidLaunch() {
|
|
CheckInterpreterAndScriptObject();
|
|
m_pid = GetInterface().GetProcessID();
|
|
GetLoadedDynamicLibrariesInfos();
|
|
}
|
|
|
|
Status ScriptedProcess::DoResume() {
|
|
CheckInterpreterAndScriptObject();
|
|
|
|
Log *log = GetLog(LLDBLog::Process);
|
|
// FIXME: Fetch data from thread.
|
|
const StateType thread_resume_state = eStateRunning;
|
|
LLDB_LOGF(log, "ScriptedProcess::%s thread_resume_state = %s", __FUNCTION__,
|
|
StateAsCString(thread_resume_state));
|
|
|
|
bool resume = (thread_resume_state == eStateRunning);
|
|
assert(thread_resume_state == eStateRunning && "invalid thread resume state");
|
|
|
|
Status error;
|
|
if (resume) {
|
|
LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__);
|
|
|
|
SetPrivateState(eStateRunning);
|
|
SetPrivateState(eStateStopped);
|
|
error = GetInterface().Resume();
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
Status ScriptedProcess::DoStop() {
|
|
CheckInterpreterAndScriptObject();
|
|
|
|
Log *log = GetLog(LLDBLog::Process);
|
|
|
|
if (GetInterface().ShouldStop()) {
|
|
SetPrivateState(eStateStopped);
|
|
LLDB_LOGF(log, "ScriptedProcess::%s Immediate stop", __FUNCTION__);
|
|
return {};
|
|
}
|
|
|
|
LLDB_LOGF(log, "ScriptedProcess::%s Delayed stop", __FUNCTION__);
|
|
return GetInterface().Stop();
|
|
}
|
|
|
|
Status ScriptedProcess::DoDestroy() { return Status(); }
|
|
|
|
bool ScriptedProcess::IsAlive() {
|
|
if (m_interpreter && m_script_object_sp)
|
|
return GetInterface().IsAlive();
|
|
return false;
|
|
}
|
|
|
|
size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
|
|
Status &error) {
|
|
if (!m_interpreter)
|
|
return ScriptedInterface::ErrorWithMessage<size_t>(
|
|
LLVM_PRETTY_FUNCTION, "No interpreter.", error);
|
|
|
|
lldb::DataExtractorSP data_extractor_sp =
|
|
GetInterface().ReadMemoryAtAddress(addr, size, error);
|
|
|
|
if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail())
|
|
return 0;
|
|
|
|
offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
|
|
0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
|
|
|
|
if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
|
|
return ScriptedInterface::ErrorWithMessage<size_t>(
|
|
LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error);
|
|
|
|
return size;
|
|
}
|
|
|
|
ArchSpec ScriptedProcess::GetArchitecture() {
|
|
return GetTarget().GetArchitecture();
|
|
}
|
|
|
|
Status ScriptedProcess::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
|
|
MemoryRegionInfo ®ion) {
|
|
CheckInterpreterAndScriptObject();
|
|
|
|
Status error;
|
|
if (auto region_or_err =
|
|
GetInterface().GetMemoryRegionContainingAddress(load_addr, error))
|
|
region = *region_or_err;
|
|
|
|
return error;
|
|
}
|
|
|
|
Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos ®ion_list) {
|
|
CheckInterpreterAndScriptObject();
|
|
|
|
Status error;
|
|
lldb::addr_t address = 0;
|
|
|
|
while (auto region_or_err =
|
|
GetInterface().GetMemoryRegionContainingAddress(address, error)) {
|
|
if (error.Fail())
|
|
break;
|
|
|
|
MemoryRegionInfo &mem_region = *region_or_err;
|
|
auto range = mem_region.GetRange();
|
|
address += range.GetRangeBase() + range.GetByteSize();
|
|
region_list.push_back(mem_region);
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); }
|
|
|
|
bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
|
|
ThreadList &new_thread_list) {
|
|
// TODO: Implement
|
|
// This is supposed to get the current set of threads, if any of them are in
|
|
// old_thread_list then they get copied to new_thread_list, and then any
|
|
// actually new threads will get added to new_thread_list.
|
|
|
|
CheckInterpreterAndScriptObject();
|
|
m_thread_plans.ClearThreadCache();
|
|
|
|
Status error;
|
|
ScriptLanguage language = m_interpreter->GetLanguage();
|
|
|
|
if (language != eScriptLanguagePython)
|
|
return ScriptedInterface::ErrorWithMessage<bool>(
|
|
LLVM_PRETTY_FUNCTION,
|
|
llvm::Twine("ScriptInterpreter language (" +
|
|
llvm::Twine(m_interpreter->LanguageToString(language)) +
|
|
llvm::Twine(") not supported."))
|
|
.str(),
|
|
error);
|
|
|
|
StructuredData::DictionarySP thread_info_sp = GetInterface().GetThreadsInfo();
|
|
|
|
if (!thread_info_sp)
|
|
return ScriptedInterface::ErrorWithMessage<bool>(
|
|
LLVM_PRETTY_FUNCTION,
|
|
"Couldn't fetch thread list from Scripted Process.", error);
|
|
|
|
// Because `StructuredData::Dictionary` uses a `std::map<ConstString,
|
|
// ObjectSP>` for storage, each item is sorted based on the key alphabetical
|
|
// order. Since `GetThreadsInfo` provides thread indices as the key element,
|
|
// thread info comes ordered alphabetically, instead of numerically, so we
|
|
// need to sort the thread indices before creating thread.
|
|
|
|
StructuredData::ArraySP keys = thread_info_sp->GetKeys();
|
|
|
|
std::map<size_t, StructuredData::ObjectSP> sorted_threads;
|
|
auto sort_keys = [&sorted_threads,
|
|
&thread_info_sp](StructuredData::Object *item) -> bool {
|
|
if (!item)
|
|
return false;
|
|
|
|
llvm::StringRef key = item->GetStringValue();
|
|
size_t idx = 0;
|
|
|
|
// Make sure the provided index is actually an integer
|
|
if (!llvm::to_integer(key, idx))
|
|
return false;
|
|
|
|
sorted_threads[idx] = thread_info_sp->GetValueForKey(key);
|
|
return true;
|
|
};
|
|
|
|
size_t thread_count = thread_info_sp->GetSize();
|
|
|
|
if (!keys->ForEach(sort_keys) || sorted_threads.size() != thread_count)
|
|
// Might be worth showing the unsorted thread list instead of return early.
|
|
return ScriptedInterface::ErrorWithMessage<bool>(
|
|
LLVM_PRETTY_FUNCTION, "Couldn't sort thread list.", error);
|
|
|
|
auto create_scripted_thread =
|
|
[this, &error, &new_thread_list](
|
|
const std::pair<size_t, StructuredData::ObjectSP> pair) -> bool {
|
|
size_t idx = pair.first;
|
|
StructuredData::ObjectSP object_sp = pair.second;
|
|
|
|
if (!object_sp)
|
|
return ScriptedInterface::ErrorWithMessage<bool>(
|
|
LLVM_PRETTY_FUNCTION, "Invalid thread info object", error);
|
|
|
|
auto thread_or_error =
|
|
ScriptedThread::Create(*this, object_sp->GetAsGeneric());
|
|
|
|
if (!thread_or_error)
|
|
return ScriptedInterface::ErrorWithMessage<bool>(
|
|
LLVM_PRETTY_FUNCTION, toString(thread_or_error.takeError()), error);
|
|
|
|
ThreadSP thread_sp = thread_or_error.get();
|
|
lldbassert(thread_sp && "Couldn't initialize scripted thread.");
|
|
|
|
RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
|
|
if (!reg_ctx_sp)
|
|
return ScriptedInterface::ErrorWithMessage<bool>(
|
|
LLVM_PRETTY_FUNCTION,
|
|
llvm::Twine("Invalid Register Context for thread " + llvm::Twine(idx))
|
|
.str(),
|
|
error);
|
|
|
|
new_thread_list.AddThread(thread_sp);
|
|
|
|
return true;
|
|
};
|
|
|
|
llvm::for_each(sorted_threads, create_scripted_thread);
|
|
|
|
return new_thread_list.GetSize(false) > 0;
|
|
}
|
|
|
|
void ScriptedProcess::RefreshStateAfterStop() {
|
|
// Let all threads recover from stopping and do any clean up based on the
|
|
// previous thread state (if any).
|
|
m_thread_list.RefreshStateAfterStop();
|
|
}
|
|
|
|
bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) {
|
|
info.Clear();
|
|
info.SetProcessID(GetID());
|
|
info.SetArchitecture(GetArchitecture());
|
|
lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
|
|
if (module_sp) {
|
|
const bool add_exe_file_as_first_arg = false;
|
|
info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
|
|
add_exe_file_as_first_arg);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
lldb_private::StructuredData::ObjectSP
|
|
ScriptedProcess::GetLoadedDynamicLibrariesInfos() {
|
|
CheckInterpreterAndScriptObject();
|
|
|
|
Status error;
|
|
auto error_with_message = [&error](llvm::StringRef message) {
|
|
return ScriptedInterface::ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION,
|
|
message.data(), error);
|
|
};
|
|
|
|
StructuredData::ArraySP loaded_images_sp = GetInterface().GetLoadedImages();
|
|
|
|
if (!loaded_images_sp || !loaded_images_sp->GetSize())
|
|
return GetInterface().ErrorWithMessage<StructuredData::ObjectSP>(
|
|
LLVM_PRETTY_FUNCTION, "No loaded images.", error);
|
|
|
|
ModuleList module_list;
|
|
Target &target = GetTarget();
|
|
|
|
auto reload_image = [&target, &module_list, &error_with_message](
|
|
StructuredData::Object *obj) -> bool {
|
|
StructuredData::Dictionary *dict = obj->GetAsDictionary();
|
|
|
|
if (!dict)
|
|
return error_with_message("Couldn't cast image object into dictionary.");
|
|
|
|
ModuleSpec module_spec;
|
|
llvm::StringRef value;
|
|
|
|
bool has_path = dict->HasKey("path");
|
|
bool has_uuid = dict->HasKey("uuid");
|
|
if (!has_path && !has_uuid)
|
|
return error_with_message("Dictionary should have key 'path' or 'uuid'");
|
|
if (!dict->HasKey("load_addr"))
|
|
return error_with_message("Dictionary is missing key 'load_addr'");
|
|
|
|
if (has_path) {
|
|
dict->GetValueForKeyAsString("path", value);
|
|
module_spec.GetFileSpec().SetPath(value);
|
|
}
|
|
|
|
if (has_uuid) {
|
|
dict->GetValueForKeyAsString("uuid", value);
|
|
module_spec.GetUUID().SetFromStringRef(value);
|
|
}
|
|
module_spec.GetArchitecture() = target.GetArchitecture();
|
|
|
|
ModuleSP module_sp =
|
|
target.GetOrCreateModule(module_spec, true /* notify */);
|
|
|
|
if (!module_sp)
|
|
return error_with_message("Couldn't create or get module.");
|
|
|
|
lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
|
|
lldb::addr_t slide = LLDB_INVALID_OFFSET;
|
|
dict->GetValueForKeyAsInteger("load_addr", load_addr);
|
|
dict->GetValueForKeyAsInteger("slide", slide);
|
|
if (load_addr == LLDB_INVALID_ADDRESS)
|
|
return error_with_message(
|
|
"Couldn't get valid load address or slide offset.");
|
|
|
|
if (slide != LLDB_INVALID_OFFSET)
|
|
load_addr += slide;
|
|
|
|
bool changed = false;
|
|
module_sp->SetLoadAddress(target, load_addr, false /*=value_is_offset*/,
|
|
changed);
|
|
|
|
if (!changed && !module_sp->GetObjectFile())
|
|
return error_with_message("Couldn't set the load address for module.");
|
|
|
|
dict->GetValueForKeyAsString("path", value);
|
|
FileSpec objfile(value);
|
|
module_sp->SetFileSpecAndObjectName(objfile, objfile.GetFilename());
|
|
|
|
return module_list.AppendIfNeeded(module_sp);
|
|
};
|
|
|
|
if (!loaded_images_sp->ForEach(reload_image))
|
|
return GetInterface().ErrorWithMessage<StructuredData::ObjectSP>(
|
|
LLVM_PRETTY_FUNCTION, "Couldn't reload all images.", error);
|
|
|
|
target.ModulesDidLoad(module_list);
|
|
|
|
return loaded_images_sp;
|
|
}
|
|
|
|
ScriptedProcessInterface &ScriptedProcess::GetInterface() const {
|
|
return m_interpreter->GetScriptedProcessInterface();
|
|
}
|