124c8b4054
We have a problem when some code on the private state thread needs to run an expression. The private state thread is the one that fetches "raw" events from the Process Plugin and decides how to handle them. But if the private state thread needs to fetch the processed events to drive running an expression, it can't also be the thread processing the raw events. We solve this by swapping in a modal private state thread just to handle the events from the expression evaluation. That worked until you could cause the expression evaluation to happen from Python, because then it wasn't just the fetching of events that matter, but also the state of the process and the state of the runlocks. The modal private state thread is really a modal version of the thread and its associated state. This patch gathers all the relevant control parameters into a structure which we can swap in and out when needed. It also adds a test using the new "was_hit" breakpoint resolver affordance, which, since it acts as an asynchronous breakpoint callback, gets run on the private state thread, showing that with the change we can call expressions in the `was_hit` callback without problems.
138 lines
4.4 KiB
C++
138 lines
4.4 KiB
C++
//===-- ProcessTrace.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/ProcessTrace.h"
|
|
|
|
#include <memory>
|
|
|
|
#include "lldb/Core/Module.h"
|
|
#include "lldb/Core/PluginManager.h"
|
|
#include "lldb/Core/Section.h"
|
|
#include "lldb/Target/ABI.h"
|
|
#include "lldb/Target/SectionLoadList.h"
|
|
#include "lldb/Target/Target.h"
|
|
#include "lldb/Utility/LLDBLog.h"
|
|
#include "lldb/Utility/Log.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
LLDB_PLUGIN_DEFINE(ProcessTrace)
|
|
|
|
llvm::StringRef ProcessTrace::GetPluginDescriptionStatic() {
|
|
return "Trace process plug-in.";
|
|
}
|
|
|
|
void ProcessTrace::Terminate() {
|
|
PluginManager::UnregisterPlugin(ProcessTrace::CreateInstance);
|
|
}
|
|
|
|
ProcessSP ProcessTrace::CreateInstance(TargetSP target_sp,
|
|
ListenerSP listener_sp,
|
|
const FileSpec *crash_file,
|
|
bool can_connect) {
|
|
if (can_connect)
|
|
return nullptr;
|
|
return std::make_shared<ProcessTrace>(target_sp, listener_sp,
|
|
crash_file ? *crash_file : FileSpec());
|
|
}
|
|
|
|
bool ProcessTrace::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) {
|
|
return plugin_specified_by_name;
|
|
}
|
|
|
|
ProcessTrace::ProcessTrace(TargetSP target_sp, ListenerSP listener_sp,
|
|
const FileSpec &core_file)
|
|
: PostMortemProcess(target_sp, listener_sp, core_file) {}
|
|
|
|
ProcessTrace::~ProcessTrace() {
|
|
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(true /* destructing */);
|
|
}
|
|
|
|
void ProcessTrace::DidAttach(ArchSpec &process_arch) {
|
|
ListenerSP listener_sp(
|
|
Listener::MakeListener("lldb.process_trace.did_attach_listener"));
|
|
HijackProcessEvents(listener_sp);
|
|
|
|
SetCanJIT(false);
|
|
StartPrivateStateThread(lldb::eStateStopped, false);
|
|
if (!m_current_private_state_thread) {
|
|
LLDB_LOG(GetLog(LLDBLog::Process), "ProcessTrace: failed to start private "
|
|
"state thread.");
|
|
return;
|
|
}
|
|
|
|
EventSP event_sp;
|
|
WaitForProcessToStop(std::nullopt, &event_sp, true, listener_sp);
|
|
|
|
RestoreProcessEvents();
|
|
|
|
Process::DidAttach(process_arch);
|
|
}
|
|
|
|
bool ProcessTrace::DoUpdateThreadList(ThreadList &old_thread_list,
|
|
ThreadList &new_thread_list) {
|
|
return false;
|
|
}
|
|
|
|
void ProcessTrace::RefreshStateAfterStop() {}
|
|
|
|
Status ProcessTrace::DoDestroy() { return Status(); }
|
|
|
|
size_t ProcessTrace::ReadMemory(addr_t addr, void *buf, size_t size,
|
|
Status &error) {
|
|
if (const ABISP &abi = GetABI())
|
|
addr = abi->FixAnyAddress(addr);
|
|
|
|
// Don't allow the caching that lldb_private::Process::ReadMemory does since
|
|
// we have it all cached in the trace files.
|
|
return DoReadMemory(addr, buf, size, error);
|
|
}
|
|
|
|
void ProcessTrace::Clear() { m_thread_list.Clear(); }
|
|
|
|
void ProcessTrace::Initialize() {
|
|
static llvm::once_flag g_once_flag;
|
|
|
|
llvm::call_once(g_once_flag, []() {
|
|
PluginManager::RegisterPlugin(GetPluginNameStatic(),
|
|
GetPluginDescriptionStatic(), CreateInstance);
|
|
});
|
|
}
|
|
|
|
ArchSpec ProcessTrace::GetArchitecture() {
|
|
return GetTarget().GetArchitecture();
|
|
}
|
|
|
|
bool ProcessTrace::GetProcessInfo(ProcessInstanceInfo &info) {
|
|
info.Clear();
|
|
info.SetProcessID(GetID());
|
|
info.SetArchitecture(GetArchitecture());
|
|
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;
|
|
}
|
|
|
|
size_t ProcessTrace::DoReadMemory(addr_t addr, void *buf, size_t size,
|
|
Status &error) {
|
|
Address resolved_address;
|
|
GetTarget().ResolveLoadAddress(addr, resolved_address);
|
|
|
|
return GetTarget().ReadMemoryFromFileCache(resolved_address, buf, size,
|
|
error);
|
|
}
|