1 //===-- ScriptedProcess.cpp -----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "ScriptedProcess.h"
10
11 #include "lldb/Core/Debugger.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/PluginManager.h"
14
15 #include "lldb/Host/OptionParser.h"
16 #include "lldb/Host/ThreadLauncher.h"
17 #include "lldb/Interpreter/CommandInterpreter.h"
18 #include "lldb/Interpreter/OptionArgParser.h"
19 #include "lldb/Interpreter/OptionGroupBoolean.h"
20 #include "lldb/Interpreter/ScriptInterpreter.h"
21 #include "lldb/Target/MemoryRegionInfo.h"
22 #include "lldb/Target/RegisterContext.h"
23
24 #include "lldb/Utility/Log.h"
25 #include "lldb/Utility/Logging.h"
26 #include "lldb/Utility/State.h"
27
28 #include <mutex>
29
30 LLDB_PLUGIN_DEFINE(ScriptedProcess)
31
32 using namespace lldb;
33 using namespace lldb_private;
34
GetPluginNameStatic()35 ConstString ScriptedProcess::GetPluginNameStatic() {
36 static ConstString g_name("ScriptedProcess");
37 return g_name;
38 }
39
GetPluginDescriptionStatic()40 const char *ScriptedProcess::GetPluginDescriptionStatic() {
41 return "Scripted Process plug-in.";
42 }
43
44 static constexpr lldb::ScriptLanguage g_supported_script_languages[] = {
45 ScriptLanguage::eScriptLanguagePython,
46 };
47
IsScriptLanguageSupported(lldb::ScriptLanguage language)48 bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) {
49 llvm::ArrayRef<lldb::ScriptLanguage> supported_languages =
50 llvm::makeArrayRef(g_supported_script_languages);
51
52 return llvm::is_contained(supported_languages, language);
53 }
54
CheckInterpreterAndScriptObject() const55 void ScriptedProcess::CheckInterpreterAndScriptObject() const {
56 lldbassert(m_interpreter && "Invalid Script Interpreter.");
57 lldbassert(m_script_object_sp && "Invalid Script Object.");
58 }
59
CreateInstance(lldb::TargetSP target_sp,lldb::ListenerSP listener_sp,const FileSpec * file,bool can_connect)60 lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp,
61 lldb::ListenerSP listener_sp,
62 const FileSpec *file,
63 bool can_connect) {
64 if (!target_sp ||
65 !IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage()))
66 return nullptr;
67
68 Status error;
69 ScriptedProcess::ScriptedProcessInfo scripted_process_info(
70 target_sp->GetProcessLaunchInfo());
71
72 auto process_sp = std::make_shared<ScriptedProcess>(
73 target_sp, listener_sp, scripted_process_info, error);
74
75 if (error.Fail() || !process_sp || !process_sp->m_script_object_sp ||
76 !process_sp->m_script_object_sp->IsValid()) {
77 LLDB_LOGF(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS), "%s",
78 error.AsCString());
79 return nullptr;
80 }
81
82 return process_sp;
83 }
84
CanDebug(lldb::TargetSP target_sp,bool plugin_specified_by_name)85 bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp,
86 bool plugin_specified_by_name) {
87 return true;
88 }
89
ScriptedProcess(lldb::TargetSP target_sp,lldb::ListenerSP listener_sp,const ScriptedProcess::ScriptedProcessInfo & scripted_process_info,Status & error)90 ScriptedProcess::ScriptedProcess(
91 lldb::TargetSP target_sp, lldb::ListenerSP listener_sp,
92 const ScriptedProcess::ScriptedProcessInfo &scripted_process_info,
93 Status &error)
94 : Process(target_sp, listener_sp),
95 m_scripted_process_info(scripted_process_info) {
96
97 if (!target_sp) {
98 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
99 __FUNCTION__, "Invalid target");
100 return;
101 }
102
103 m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
104
105 if (!m_interpreter) {
106 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
107 __FUNCTION__,
108 "Debugger has no Script Interpreter");
109 return;
110 }
111
112 StructuredData::ObjectSP object_sp = GetInterface().CreatePluginObject(
113 m_scripted_process_info.GetClassName().c_str(), target_sp,
114 m_scripted_process_info.GetDictionarySP());
115
116 if (!object_sp || !object_sp->IsValid()) {
117 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s",
118 __FUNCTION__,
119 "Failed to create valid script object");
120 return;
121 }
122
123 m_script_object_sp = object_sp;
124 }
125
~ScriptedProcess()126 ScriptedProcess::~ScriptedProcess() {
127 Clear();
128 // We need to call finalize on the process before destroying ourselves to
129 // make sure all of the broadcaster cleanup goes as planned. If we destruct
130 // this class, then Process::~Process() might have problems trying to fully
131 // destroy the broadcaster.
132 Finalize();
133 }
134
Initialize()135 void ScriptedProcess::Initialize() {
136 static llvm::once_flag g_once_flag;
137
138 llvm::call_once(g_once_flag, []() {
139 PluginManager::RegisterPlugin(GetPluginNameStatic(),
140 GetPluginDescriptionStatic(), CreateInstance);
141 });
142 }
143
Terminate()144 void ScriptedProcess::Terminate() {
145 PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance);
146 }
147
GetPluginName()148 ConstString ScriptedProcess::GetPluginName() { return GetPluginNameStatic(); }
149
GetPluginVersion()150 uint32_t ScriptedProcess::GetPluginVersion() { return 1; }
151
DoLoadCore()152 Status ScriptedProcess::DoLoadCore() {
153 ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo();
154
155 return DoLaunch(nullptr, launch_info);
156 }
157
DoLaunch(Module * exe_module,ProcessLaunchInfo & launch_info)158 Status ScriptedProcess::DoLaunch(Module *exe_module,
159 ProcessLaunchInfo &launch_info) {
160 CheckInterpreterAndScriptObject();
161
162 /* FIXME: This doesn't reflect how lldb actually launches a process.
163 In reality, it attaches to debugserver, then resume the process. */
164 Status error = GetInterface().Launch();
165 SetPrivateState(eStateRunning);
166
167 if (error.Fail())
168 return error;
169
170 // TODO: Fetch next state from stopped event queue then send stop event
171 // const StateType state = SetThreadStopInfo(response);
172 // if (state != eStateInvalid) {
173 // SetPrivateState(state);
174
175 SetPrivateState(eStateStopped);
176
177 UpdateThreadListIfNeeded();
178 GetThreadList();
179
180 return {};
181 }
182
DidLaunch()183 void ScriptedProcess::DidLaunch() {
184 CheckInterpreterAndScriptObject();
185 m_pid = GetInterface().GetProcessID();
186 }
187
DoResume()188 Status ScriptedProcess::DoResume() {
189 CheckInterpreterAndScriptObject();
190
191 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
192 // FIXME: Fetch data from thread.
193 const StateType thread_resume_state = eStateRunning;
194 LLDB_LOGF(log, "ScriptedProcess::%s thread_resume_state = %s", __FUNCTION__,
195 StateAsCString(thread_resume_state));
196
197 bool resume = (thread_resume_state == eStateRunning);
198 assert(thread_resume_state == eStateRunning && "invalid thread resume state");
199
200 Status error;
201 if (resume) {
202 LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__);
203
204 SetPrivateState(eStateRunning);
205 SetPrivateState(eStateStopped);
206 error = GetInterface().Resume();
207 }
208
209 return error;
210 }
211
DoStop()212 Status ScriptedProcess::DoStop() {
213 CheckInterpreterAndScriptObject();
214
215 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
216
217 if (GetInterface().ShouldStop()) {
218 SetPrivateState(eStateStopped);
219 LLDB_LOGF(log, "ScriptedProcess::%s Immediate stop", __FUNCTION__);
220 return {};
221 }
222
223 LLDB_LOGF(log, "ScriptedProcess::%s Delayed stop", __FUNCTION__);
224 return GetInterface().Stop();
225 }
226
DoDestroy()227 Status ScriptedProcess::DoDestroy() { return Status(); }
228
IsAlive()229 bool ScriptedProcess::IsAlive() {
230 if (m_interpreter && m_script_object_sp)
231 return GetInterface().IsAlive();
232 return false;
233 }
234
DoReadMemory(lldb::addr_t addr,void * buf,size_t size,Status & error)235 size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
236 Status &error) {
237
238 auto error_with_message = [&error](llvm::StringRef message) {
239 error.SetErrorString(message);
240 return 0;
241 };
242
243 if (!m_interpreter)
244 return error_with_message("No interpreter.");
245
246 lldb::DataExtractorSP data_extractor_sp =
247 GetInterface().ReadMemoryAtAddress(addr, size, error);
248
249 if (!data_extractor_sp || error.Fail())
250 return 0;
251
252 offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData(
253 0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder());
254
255 if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET)
256 return error_with_message("Failed to copy read memory to buffer.");
257
258 return size;
259 }
260
GetArchitecture()261 ArchSpec ScriptedProcess::GetArchitecture() {
262 return GetTarget().GetArchitecture();
263 }
264
GetMemoryRegionInfo(lldb::addr_t load_addr,MemoryRegionInfo & region)265 Status ScriptedProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
266 MemoryRegionInfo ®ion) {
267 // TODO: Implement
268 return Status();
269 }
270
GetMemoryRegions(MemoryRegionInfos & region_list)271 Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos ®ion_list) {
272 CheckInterpreterAndScriptObject();
273
274 lldb::addr_t address = 0;
275 lldb::MemoryRegionInfoSP mem_region_sp = nullptr;
276
277 while ((mem_region_sp =
278 GetInterface().GetMemoryRegionContainingAddress(address))) {
279 auto range = mem_region_sp->GetRange();
280 address += range.GetRangeBase() + range.GetByteSize();
281 region_list.push_back(*mem_region_sp.get());
282 }
283
284 return {};
285 }
286
Clear()287 void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); }
288
DoUpdateThreadList(ThreadList & old_thread_list,ThreadList & new_thread_list)289 bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list,
290 ThreadList &new_thread_list) {
291 // TODO: Implement
292 // This is supposed to get the current set of threads, if any of them are in
293 // old_thread_list then they get copied to new_thread_list, and then any
294 // actually new threads will get added to new_thread_list.
295 return new_thread_list.GetSize(false) > 0;
296 }
297
GetProcessInfo(ProcessInstanceInfo & info)298 bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) {
299 info.Clear();
300 info.SetProcessID(GetID());
301 info.SetArchitecture(GetArchitecture());
302 lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
303 if (module_sp) {
304 const bool add_exe_file_as_first_arg = false;
305 info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
306 add_exe_file_as_first_arg);
307 }
308 return true;
309 }
310
GetInterface() const311 ScriptedProcessInterface &ScriptedProcess::GetInterface() const {
312 return m_interpreter->GetScriptedProcessInterface();
313 }
314