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/Interpreter/ScriptedMetadata.h" 22 #include "lldb/Target/MemoryRegionInfo.h" 23 #include "lldb/Target/Queue.h" 24 #include "lldb/Target/RegisterContext.h" 25 #include "lldb/Utility/LLDBLog.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 35 llvm::StringRef ScriptedProcess::GetPluginDescriptionStatic() { 36 return "Scripted Process plug-in."; 37 } 38 39 static constexpr lldb::ScriptLanguage g_supported_script_languages[] = { 40 ScriptLanguage::eScriptLanguagePython, 41 }; 42 43 bool ScriptedProcess::IsScriptLanguageSupported(lldb::ScriptLanguage language) { 44 llvm::ArrayRef<lldb::ScriptLanguage> supported_languages = 45 llvm::ArrayRef(g_supported_script_languages); 46 47 return llvm::is_contained(supported_languages, language); 48 } 49 50 lldb::ProcessSP ScriptedProcess::CreateInstance(lldb::TargetSP target_sp, 51 lldb::ListenerSP listener_sp, 52 const FileSpec *file, 53 bool can_connect) { 54 if (!target_sp || 55 !IsScriptLanguageSupported(target_sp->GetDebugger().GetScriptLanguage())) 56 return nullptr; 57 58 ScriptedMetadata scripted_metadata(target_sp->GetProcessLaunchInfo()); 59 60 Status error; 61 auto process_sp = std::shared_ptr<ScriptedProcess>( 62 new ScriptedProcess(target_sp, listener_sp, scripted_metadata, error)); 63 64 if (error.Fail() || !process_sp || !process_sp->m_interface_up) { 65 LLDB_LOGF(GetLog(LLDBLog::Process), "%s", error.AsCString()); 66 return nullptr; 67 } 68 69 return process_sp; 70 } 71 72 bool ScriptedProcess::CanDebug(lldb::TargetSP target_sp, 73 bool plugin_specified_by_name) { 74 return true; 75 } 76 77 ScriptedProcess::ScriptedProcess(lldb::TargetSP target_sp, 78 lldb::ListenerSP listener_sp, 79 const ScriptedMetadata &scripted_metadata, 80 Status &error) 81 : Process(target_sp, listener_sp), m_scripted_metadata(scripted_metadata) { 82 83 if (!target_sp) { 84 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s", 85 __FUNCTION__, "Invalid target"); 86 return; 87 } 88 89 ScriptInterpreter *interpreter = 90 target_sp->GetDebugger().GetScriptInterpreter(); 91 92 if (!interpreter) { 93 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s", 94 __FUNCTION__, 95 "Debugger has no Script Interpreter"); 96 return; 97 } 98 99 // Create process instance interface 100 m_interface_up = interpreter->CreateScriptedProcessInterface(); 101 if (!m_interface_up) { 102 error.SetErrorStringWithFormat( 103 "ScriptedProcess::%s () - ERROR: %s", __FUNCTION__, 104 "Script interpreter couldn't create Scripted Process Interface"); 105 return; 106 } 107 108 ExecutionContext exe_ctx(target_sp, /*get_process=*/false); 109 110 // Create process script object 111 StructuredData::GenericSP object_sp = GetInterface().CreatePluginObject( 112 m_scripted_metadata.GetClassName(), exe_ctx, 113 m_scripted_metadata.GetArgsSP()); 114 115 if (!object_sp || !object_sp->IsValid()) { 116 error.SetErrorStringWithFormat("ScriptedProcess::%s () - ERROR: %s", 117 __FUNCTION__, 118 "Failed to create valid script object"); 119 return; 120 } 121 } 122 123 ScriptedProcess::~ScriptedProcess() { 124 Clear(); 125 // We need to call finalize on the process before destroying ourselves to 126 // make sure all of the broadcaster cleanup goes as planned. If we destruct 127 // this class, then Process::~Process() might have problems trying to fully 128 // destroy the broadcaster. 129 Finalize(); 130 } 131 132 void ScriptedProcess::Initialize() { 133 static llvm::once_flag g_once_flag; 134 135 llvm::call_once(g_once_flag, []() { 136 PluginManager::RegisterPlugin(GetPluginNameStatic(), 137 GetPluginDescriptionStatic(), CreateInstance); 138 }); 139 } 140 141 void ScriptedProcess::Terminate() { 142 PluginManager::UnregisterPlugin(ScriptedProcess::CreateInstance); 143 } 144 145 Status ScriptedProcess::DoLoadCore() { 146 ProcessLaunchInfo launch_info = GetTarget().GetProcessLaunchInfo(); 147 148 return DoLaunch(nullptr, launch_info); 149 } 150 151 Status ScriptedProcess::DoLaunch(Module *exe_module, 152 ProcessLaunchInfo &launch_info) { 153 /* FIXME: This doesn't reflect how lldb actually launches a process. 154 In reality, it attaches to debugserver, then resume the process. */ 155 Status error = GetInterface().Launch(); 156 SetPrivateState(eStateRunning); 157 158 if (error.Fail()) 159 return error; 160 161 // TODO: Fetch next state from stopped event queue then send stop event 162 // const StateType state = SetThreadStopInfo(response); 163 // if (state != eStateInvalid) { 164 // SetPrivateState(state); 165 166 SetPrivateState(eStateStopped); 167 168 return {}; 169 } 170 171 void ScriptedProcess::DidLaunch() { 172 m_pid = GetInterface().GetProcessID(); 173 GetLoadedDynamicLibrariesInfos(); 174 } 175 176 Status ScriptedProcess::DoResume() { 177 Log *log = GetLog(LLDBLog::Process); 178 // FIXME: Fetch data from thread. 179 const StateType thread_resume_state = eStateRunning; 180 LLDB_LOGF(log, "ScriptedProcess::%s thread_resume_state = %s", __FUNCTION__, 181 StateAsCString(thread_resume_state)); 182 183 bool resume = (thread_resume_state == eStateRunning); 184 assert(thread_resume_state == eStateRunning && "invalid thread resume state"); 185 186 Status error; 187 if (resume) { 188 LLDB_LOGF(log, "ScriptedProcess::%s sending resume", __FUNCTION__); 189 190 error = GetInterface().Resume(); 191 } 192 193 return error; 194 } 195 196 Status ScriptedProcess::DoAttach(const ProcessAttachInfo &attach_info) { 197 Status error = GetInterface().Attach(attach_info); 198 SetPrivateState(eStateRunning); 199 SetPrivateState(eStateStopped); 200 if (error.Fail()) 201 return error; 202 // NOTE: We need to set the PID before finishing to attach otherwise we will 203 // hit an assert when calling the attach completion handler. 204 DidLaunch(); 205 206 return {}; 207 } 208 209 Status 210 ScriptedProcess::DoAttachToProcessWithID(lldb::pid_t pid, 211 const ProcessAttachInfo &attach_info) { 212 return DoAttach(attach_info); 213 } 214 215 Status ScriptedProcess::DoAttachToProcessWithName( 216 const char *process_name, const ProcessAttachInfo &attach_info) { 217 return DoAttach(attach_info); 218 } 219 220 void ScriptedProcess::DidAttach(ArchSpec &process_arch) { 221 process_arch = GetArchitecture(); 222 } 223 224 Status ScriptedProcess::DoDestroy() { return Status(); } 225 226 bool ScriptedProcess::IsAlive() { return GetInterface().IsAlive(); } 227 228 size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size, 229 Status &error) { 230 lldb::DataExtractorSP data_extractor_sp = 231 GetInterface().ReadMemoryAtAddress(addr, size, error); 232 233 if (!data_extractor_sp || !data_extractor_sp->GetByteSize() || error.Fail()) 234 return 0; 235 236 offset_t bytes_copied = data_extractor_sp->CopyByteOrderedData( 237 0, data_extractor_sp->GetByteSize(), buf, size, GetByteOrder()); 238 239 if (!bytes_copied || bytes_copied == LLDB_INVALID_OFFSET) 240 return ScriptedInterface::ErrorWithMessage<size_t>( 241 LLVM_PRETTY_FUNCTION, "Failed to copy read memory to buffer.", error); 242 243 // FIXME: We should use the diagnostic system to report a warning if the 244 // `bytes_copied` is different from `size`. 245 246 return bytes_copied; 247 } 248 249 size_t ScriptedProcess::DoWriteMemory(lldb::addr_t vm_addr, const void *buf, 250 size_t size, Status &error) { 251 lldb::DataExtractorSP data_extractor_sp = std::make_shared<DataExtractor>( 252 buf, size, GetByteOrder(), GetAddressByteSize()); 253 254 if (!data_extractor_sp || !data_extractor_sp->GetByteSize()) 255 return 0; 256 257 size_t bytes_written = 258 GetInterface().WriteMemoryAtAddress(vm_addr, data_extractor_sp, error); 259 260 if (!bytes_written || bytes_written == LLDB_INVALID_OFFSET) 261 return ScriptedInterface::ErrorWithMessage<size_t>( 262 LLVM_PRETTY_FUNCTION, "Failed to copy write buffer to memory.", error); 263 264 // FIXME: We should use the diagnostic system to report a warning if the 265 // `bytes_written` is different from `size`. 266 267 return bytes_written; 268 } 269 270 ArchSpec ScriptedProcess::GetArchitecture() { 271 return GetTarget().GetArchitecture(); 272 } 273 274 Status ScriptedProcess::DoGetMemoryRegionInfo(lldb::addr_t load_addr, 275 MemoryRegionInfo ®ion) { 276 Status error; 277 if (auto region_or_err = 278 GetInterface().GetMemoryRegionContainingAddress(load_addr, error)) 279 region = *region_or_err; 280 281 return error; 282 } 283 284 Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos ®ion_list) { 285 Status error; 286 lldb::addr_t address = 0; 287 288 while (auto region_or_err = 289 GetInterface().GetMemoryRegionContainingAddress(address, error)) { 290 if (error.Fail()) 291 break; 292 293 MemoryRegionInfo &mem_region = *region_or_err; 294 auto range = mem_region.GetRange(); 295 address += range.GetRangeBase() + range.GetByteSize(); 296 region_list.push_back(mem_region); 297 } 298 299 return error; 300 } 301 302 void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); } 303 304 bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list, 305 ThreadList &new_thread_list) { 306 // TODO: Implement 307 // This is supposed to get the current set of threads, if any of them are in 308 // old_thread_list then they get copied to new_thread_list, and then any 309 // actually new threads will get added to new_thread_list. 310 m_thread_plans.ClearThreadCache(); 311 312 Status error; 313 StructuredData::DictionarySP thread_info_sp = GetInterface().GetThreadsInfo(); 314 315 if (!thread_info_sp) 316 return ScriptedInterface::ErrorWithMessage<bool>( 317 LLVM_PRETTY_FUNCTION, 318 "Couldn't fetch thread list from Scripted Process.", error); 319 320 // Because `StructuredData::Dictionary` uses a `std::map<ConstString, 321 // ObjectSP>` for storage, each item is sorted based on the key alphabetical 322 // order. Since `GetThreadsInfo` provides thread indices as the key element, 323 // thread info comes ordered alphabetically, instead of numerically, so we 324 // need to sort the thread indices before creating thread. 325 326 StructuredData::ArraySP keys = thread_info_sp->GetKeys(); 327 328 std::map<size_t, StructuredData::ObjectSP> sorted_threads; 329 auto sort_keys = [&sorted_threads, 330 &thread_info_sp](StructuredData::Object *item) -> bool { 331 if (!item) 332 return false; 333 334 llvm::StringRef key = item->GetStringValue(); 335 size_t idx = 0; 336 337 // Make sure the provided index is actually an integer 338 if (!llvm::to_integer(key, idx)) 339 return false; 340 341 sorted_threads[idx] = thread_info_sp->GetValueForKey(key); 342 return true; 343 }; 344 345 size_t thread_count = thread_info_sp->GetSize(); 346 347 if (!keys->ForEach(sort_keys) || sorted_threads.size() != thread_count) 348 // Might be worth showing the unsorted thread list instead of return early. 349 return ScriptedInterface::ErrorWithMessage<bool>( 350 LLVM_PRETTY_FUNCTION, "Couldn't sort thread list.", error); 351 352 auto create_scripted_thread = 353 [this, &error, &new_thread_list]( 354 const std::pair<size_t, StructuredData::ObjectSP> pair) -> bool { 355 size_t idx = pair.first; 356 StructuredData::ObjectSP object_sp = pair.second; 357 358 if (!object_sp) 359 return ScriptedInterface::ErrorWithMessage<bool>( 360 LLVM_PRETTY_FUNCTION, "Invalid thread info object", error); 361 362 auto thread_or_error = 363 ScriptedThread::Create(*this, object_sp->GetAsGeneric()); 364 365 if (!thread_or_error) 366 return ScriptedInterface::ErrorWithMessage<bool>( 367 LLVM_PRETTY_FUNCTION, toString(thread_or_error.takeError()), error); 368 369 ThreadSP thread_sp = thread_or_error.get(); 370 lldbassert(thread_sp && "Couldn't initialize scripted thread."); 371 372 RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext(); 373 if (!reg_ctx_sp) 374 return ScriptedInterface::ErrorWithMessage<bool>( 375 LLVM_PRETTY_FUNCTION, 376 llvm::Twine("Invalid Register Context for thread " + llvm::Twine(idx)) 377 .str(), 378 error); 379 380 new_thread_list.AddThread(thread_sp); 381 382 return true; 383 }; 384 385 llvm::for_each(sorted_threads, create_scripted_thread); 386 387 return new_thread_list.GetSize(false) > 0; 388 } 389 390 void ScriptedProcess::RefreshStateAfterStop() { 391 // Let all threads recover from stopping and do any clean up based on the 392 // previous thread state (if any). 393 m_thread_list.RefreshStateAfterStop(); 394 } 395 396 bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) { 397 info.Clear(); 398 info.SetProcessID(GetID()); 399 info.SetArchitecture(GetArchitecture()); 400 lldb::ModuleSP module_sp = GetTarget().GetExecutableModule(); 401 if (module_sp) { 402 const bool add_exe_file_as_first_arg = false; 403 info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(), 404 add_exe_file_as_first_arg); 405 } 406 return true; 407 } 408 409 lldb_private::StructuredData::ObjectSP 410 ScriptedProcess::GetLoadedDynamicLibrariesInfos() { 411 Status error; 412 auto error_with_message = [&error](llvm::StringRef message) { 413 return ScriptedInterface::ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION, 414 message.data(), error); 415 }; 416 417 StructuredData::ArraySP loaded_images_sp = GetInterface().GetLoadedImages(); 418 419 if (!loaded_images_sp || !loaded_images_sp->GetSize()) 420 return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>( 421 LLVM_PRETTY_FUNCTION, "No loaded images.", error); 422 423 ModuleList module_list; 424 Target &target = GetTarget(); 425 426 auto reload_image = [&target, &module_list, &error_with_message]( 427 StructuredData::Object *obj) -> bool { 428 StructuredData::Dictionary *dict = obj->GetAsDictionary(); 429 430 if (!dict) 431 return error_with_message("Couldn't cast image object into dictionary."); 432 433 ModuleSpec module_spec; 434 llvm::StringRef value; 435 436 bool has_path = dict->HasKey("path"); 437 bool has_uuid = dict->HasKey("uuid"); 438 if (!has_path && !has_uuid) 439 return error_with_message("Dictionary should have key 'path' or 'uuid'"); 440 if (!dict->HasKey("load_addr")) 441 return error_with_message("Dictionary is missing key 'load_addr'"); 442 443 if (has_path) { 444 dict->GetValueForKeyAsString("path", value); 445 module_spec.GetFileSpec().SetPath(value); 446 } 447 448 if (has_uuid) { 449 dict->GetValueForKeyAsString("uuid", value); 450 module_spec.GetUUID().SetFromStringRef(value); 451 } 452 module_spec.GetArchitecture() = target.GetArchitecture(); 453 454 ModuleSP module_sp = 455 target.GetOrCreateModule(module_spec, true /* notify */); 456 457 if (!module_sp) 458 return error_with_message("Couldn't create or get module."); 459 460 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 461 lldb::addr_t slide = LLDB_INVALID_OFFSET; 462 dict->GetValueForKeyAsInteger("load_addr", load_addr); 463 dict->GetValueForKeyAsInteger("slide", slide); 464 if (load_addr == LLDB_INVALID_ADDRESS) 465 return error_with_message( 466 "Couldn't get valid load address or slide offset."); 467 468 if (slide != LLDB_INVALID_OFFSET) 469 load_addr += slide; 470 471 bool changed = false; 472 module_sp->SetLoadAddress(target, load_addr, false /*=value_is_offset*/, 473 changed); 474 475 if (!changed && !module_sp->GetObjectFile()) 476 return error_with_message("Couldn't set the load address for module."); 477 478 dict->GetValueForKeyAsString("path", value); 479 FileSpec objfile(value); 480 module_sp->SetFileSpecAndObjectName(objfile, objfile.GetFilename()); 481 482 return module_list.AppendIfNeeded(module_sp); 483 }; 484 485 if (!loaded_images_sp->ForEach(reload_image)) 486 return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>( 487 LLVM_PRETTY_FUNCTION, "Couldn't reload all images.", error); 488 489 target.ModulesDidLoad(module_list); 490 491 return loaded_images_sp; 492 } 493 494 lldb_private::StructuredData::DictionarySP ScriptedProcess::GetMetadata() { 495 StructuredData::DictionarySP metadata_sp = GetInterface().GetMetadata(); 496 497 Status error; 498 if (!metadata_sp || !metadata_sp->GetSize()) 499 return ScriptedInterface::ErrorWithMessage<StructuredData::DictionarySP>( 500 LLVM_PRETTY_FUNCTION, "No metadata.", error); 501 502 return metadata_sp; 503 } 504 505 void ScriptedProcess::UpdateQueueListIfNeeded() { 506 CheckScriptedInterface(); 507 for (ThreadSP thread_sp : Threads()) { 508 if (const char *queue_name = thread_sp->GetQueueName()) { 509 QueueSP queue_sp = std::make_shared<Queue>( 510 m_process->shared_from_this(), thread_sp->GetQueueID(), queue_name); 511 m_queue_list.AddQueue(queue_sp); 512 } 513 } 514 } 515 516 ScriptedProcessInterface &ScriptedProcess::GetInterface() const { 517 CheckScriptedInterface(); 518 return *m_interface_up; 519 } 520 521 void *ScriptedProcess::GetImplementation() { 522 StructuredData::GenericSP object_instance_sp = 523 GetInterface().GetScriptObjectInstance(); 524 if (object_instance_sp && 525 object_instance_sp->GetType() == eStructuredDataTypeGeneric) 526 return object_instance_sp->GetAsGeneric()->GetValue(); 527 return nullptr; 528 } 529