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/Queue.h" 23 #include "lldb/Target/RegisterContext.h" 24 #include "lldb/Utility/LLDBLog.h" 25 #include "lldb/Utility/ScriptedMetadata.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 Status ScriptedProcess::EnableBreakpointSite(BreakpointSite *bp_site) { 271 assert(bp_site != nullptr); 272 273 if (bp_site->IsEnabled()) { 274 return {}; 275 } 276 277 if (bp_site->HardwareRequired()) { 278 return Status("Scripted Processes don't support hardware breakpoints"); 279 } 280 281 return EnableSoftwareBreakpoint(bp_site); 282 } 283 284 ArchSpec ScriptedProcess::GetArchitecture() { 285 return GetTarget().GetArchitecture(); 286 } 287 288 Status ScriptedProcess::DoGetMemoryRegionInfo(lldb::addr_t load_addr, 289 MemoryRegionInfo ®ion) { 290 Status error; 291 if (auto region_or_err = 292 GetInterface().GetMemoryRegionContainingAddress(load_addr, error)) 293 region = *region_or_err; 294 295 return error; 296 } 297 298 Status ScriptedProcess::GetMemoryRegions(MemoryRegionInfos ®ion_list) { 299 Status error; 300 lldb::addr_t address = 0; 301 302 while (auto region_or_err = 303 GetInterface().GetMemoryRegionContainingAddress(address, error)) { 304 if (error.Fail()) 305 break; 306 307 MemoryRegionInfo &mem_region = *region_or_err; 308 auto range = mem_region.GetRange(); 309 address += range.GetRangeBase() + range.GetByteSize(); 310 region_list.push_back(mem_region); 311 } 312 313 return error; 314 } 315 316 void ScriptedProcess::Clear() { Process::m_thread_list.Clear(); } 317 318 bool ScriptedProcess::DoUpdateThreadList(ThreadList &old_thread_list, 319 ThreadList &new_thread_list) { 320 // TODO: Implement 321 // This is supposed to get the current set of threads, if any of them are in 322 // old_thread_list then they get copied to new_thread_list, and then any 323 // actually new threads will get added to new_thread_list. 324 m_thread_plans.ClearThreadCache(); 325 326 Status error; 327 StructuredData::DictionarySP thread_info_sp = GetInterface().GetThreadsInfo(); 328 329 if (!thread_info_sp) 330 return ScriptedInterface::ErrorWithMessage<bool>( 331 LLVM_PRETTY_FUNCTION, 332 "Couldn't fetch thread list from Scripted Process.", error); 333 334 // Because `StructuredData::Dictionary` uses a `std::map<ConstString, 335 // ObjectSP>` for storage, each item is sorted based on the key alphabetical 336 // order. Since `GetThreadsInfo` provides thread indices as the key element, 337 // thread info comes ordered alphabetically, instead of numerically, so we 338 // need to sort the thread indices before creating thread. 339 340 StructuredData::ArraySP keys = thread_info_sp->GetKeys(); 341 342 std::map<size_t, StructuredData::ObjectSP> sorted_threads; 343 auto sort_keys = [&sorted_threads, 344 &thread_info_sp](StructuredData::Object *item) -> bool { 345 if (!item) 346 return false; 347 348 llvm::StringRef key = item->GetStringValue(); 349 size_t idx = 0; 350 351 // Make sure the provided index is actually an integer 352 if (!llvm::to_integer(key, idx)) 353 return false; 354 355 sorted_threads[idx] = thread_info_sp->GetValueForKey(key); 356 return true; 357 }; 358 359 size_t thread_count = thread_info_sp->GetSize(); 360 361 if (!keys->ForEach(sort_keys) || sorted_threads.size() != thread_count) 362 // Might be worth showing the unsorted thread list instead of return early. 363 return ScriptedInterface::ErrorWithMessage<bool>( 364 LLVM_PRETTY_FUNCTION, "Couldn't sort thread list.", error); 365 366 auto create_scripted_thread = 367 [this, &error, &new_thread_list]( 368 const std::pair<size_t, StructuredData::ObjectSP> pair) -> bool { 369 size_t idx = pair.first; 370 StructuredData::ObjectSP object_sp = pair.second; 371 372 if (!object_sp) 373 return ScriptedInterface::ErrorWithMessage<bool>( 374 LLVM_PRETTY_FUNCTION, "Invalid thread info object", error); 375 376 auto thread_or_error = 377 ScriptedThread::Create(*this, object_sp->GetAsGeneric()); 378 379 if (!thread_or_error) 380 return ScriptedInterface::ErrorWithMessage<bool>( 381 LLVM_PRETTY_FUNCTION, toString(thread_or_error.takeError()), error); 382 383 ThreadSP thread_sp = thread_or_error.get(); 384 lldbassert(thread_sp && "Couldn't initialize scripted thread."); 385 386 RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext(); 387 if (!reg_ctx_sp) 388 return ScriptedInterface::ErrorWithMessage<bool>( 389 LLVM_PRETTY_FUNCTION, 390 llvm::Twine("Invalid Register Context for thread " + llvm::Twine(idx)) 391 .str(), 392 error); 393 394 new_thread_list.AddThread(thread_sp); 395 396 return true; 397 }; 398 399 llvm::for_each(sorted_threads, create_scripted_thread); 400 401 return new_thread_list.GetSize(false) > 0; 402 } 403 404 void ScriptedProcess::RefreshStateAfterStop() { 405 // Let all threads recover from stopping and do any clean up based on the 406 // previous thread state (if any). 407 m_thread_list.RefreshStateAfterStop(); 408 } 409 410 bool ScriptedProcess::GetProcessInfo(ProcessInstanceInfo &info) { 411 info.Clear(); 412 info.SetProcessID(GetID()); 413 info.SetArchitecture(GetArchitecture()); 414 lldb::ModuleSP module_sp = GetTarget().GetExecutableModule(); 415 if (module_sp) { 416 const bool add_exe_file_as_first_arg = false; 417 info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(), 418 add_exe_file_as_first_arg); 419 } 420 return true; 421 } 422 423 lldb_private::StructuredData::ObjectSP 424 ScriptedProcess::GetLoadedDynamicLibrariesInfos() { 425 Status error; 426 auto error_with_message = [&error](llvm::StringRef message) { 427 return ScriptedInterface::ErrorWithMessage<bool>(LLVM_PRETTY_FUNCTION, 428 message.data(), error); 429 }; 430 431 StructuredData::ArraySP loaded_images_sp = GetInterface().GetLoadedImages(); 432 433 if (!loaded_images_sp || !loaded_images_sp->GetSize()) 434 return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>( 435 LLVM_PRETTY_FUNCTION, "No loaded images.", error); 436 437 ModuleList module_list; 438 Target &target = GetTarget(); 439 440 auto reload_image = [&target, &module_list, &error_with_message]( 441 StructuredData::Object *obj) -> bool { 442 StructuredData::Dictionary *dict = obj->GetAsDictionary(); 443 444 if (!dict) 445 return error_with_message("Couldn't cast image object into dictionary."); 446 447 ModuleSpec module_spec; 448 llvm::StringRef value; 449 450 bool has_path = dict->HasKey("path"); 451 bool has_uuid = dict->HasKey("uuid"); 452 if (!has_path && !has_uuid) 453 return error_with_message("Dictionary should have key 'path' or 'uuid'"); 454 if (!dict->HasKey("load_addr")) 455 return error_with_message("Dictionary is missing key 'load_addr'"); 456 457 if (has_path) { 458 dict->GetValueForKeyAsString("path", value); 459 module_spec.GetFileSpec().SetPath(value); 460 } 461 462 if (has_uuid) { 463 dict->GetValueForKeyAsString("uuid", value); 464 module_spec.GetUUID().SetFromStringRef(value); 465 } 466 module_spec.GetArchitecture() = target.GetArchitecture(); 467 468 ModuleSP module_sp = 469 target.GetOrCreateModule(module_spec, true /* notify */); 470 471 if (!module_sp) 472 return error_with_message("Couldn't create or get module."); 473 474 lldb::addr_t load_addr = LLDB_INVALID_ADDRESS; 475 lldb::addr_t slide = LLDB_INVALID_OFFSET; 476 dict->GetValueForKeyAsInteger("load_addr", load_addr); 477 dict->GetValueForKeyAsInteger("slide", slide); 478 if (load_addr == LLDB_INVALID_ADDRESS) 479 return error_with_message( 480 "Couldn't get valid load address or slide offset."); 481 482 if (slide != LLDB_INVALID_OFFSET) 483 load_addr += slide; 484 485 bool changed = false; 486 module_sp->SetLoadAddress(target, load_addr, false /*=value_is_offset*/, 487 changed); 488 489 if (!changed && !module_sp->GetObjectFile()) 490 return error_with_message("Couldn't set the load address for module."); 491 492 dict->GetValueForKeyAsString("path", value); 493 FileSpec objfile(value); 494 module_sp->SetFileSpecAndObjectName(objfile, objfile.GetFilename()); 495 496 return module_list.AppendIfNeeded(module_sp); 497 }; 498 499 if (!loaded_images_sp->ForEach(reload_image)) 500 return ScriptedInterface::ErrorWithMessage<StructuredData::ObjectSP>( 501 LLVM_PRETTY_FUNCTION, "Couldn't reload all images.", error); 502 503 target.ModulesDidLoad(module_list); 504 505 return loaded_images_sp; 506 } 507 508 lldb_private::StructuredData::DictionarySP ScriptedProcess::GetMetadata() { 509 StructuredData::DictionarySP metadata_sp = GetInterface().GetMetadata(); 510 511 Status error; 512 if (!metadata_sp || !metadata_sp->GetSize()) 513 return ScriptedInterface::ErrorWithMessage<StructuredData::DictionarySP>( 514 LLVM_PRETTY_FUNCTION, "No metadata.", error); 515 516 return metadata_sp; 517 } 518 519 void ScriptedProcess::UpdateQueueListIfNeeded() { 520 CheckScriptedInterface(); 521 for (ThreadSP thread_sp : Threads()) { 522 if (const char *queue_name = thread_sp->GetQueueName()) { 523 QueueSP queue_sp = std::make_shared<Queue>( 524 m_process->shared_from_this(), thread_sp->GetQueueID(), queue_name); 525 m_queue_list.AddQueue(queue_sp); 526 } 527 } 528 } 529 530 ScriptedProcessInterface &ScriptedProcess::GetInterface() const { 531 CheckScriptedInterface(); 532 return *m_interface_up; 533 } 534 535 void *ScriptedProcess::GetImplementation() { 536 StructuredData::GenericSP object_instance_sp = 537 GetInterface().GetScriptObjectInstance(); 538 if (object_instance_sp && 539 object_instance_sp->GetType() == eStructuredDataTypeGeneric) 540 return object_instance_sp->GetAsGeneric()->GetValue(); 541 return nullptr; 542 } 543