1 //===-- ProcessKDP.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 <cerrno> 10 #include <cstdlib> 11 12 #include <memory> 13 #include <mutex> 14 15 #include "lldb/Core/Debugger.h" 16 #include "lldb/Core/Module.h" 17 #include "lldb/Core/ModuleSpec.h" 18 #include "lldb/Core/PluginManager.h" 19 #include "lldb/Host/ConnectionFileDescriptor.h" 20 #include "lldb/Host/Host.h" 21 #include "lldb/Host/ThreadLauncher.h" 22 #include "lldb/Host/common/TCPSocket.h" 23 #include "lldb/Interpreter/CommandInterpreter.h" 24 #include "lldb/Interpreter/CommandObject.h" 25 #include "lldb/Interpreter/CommandObjectMultiword.h" 26 #include "lldb/Interpreter/CommandReturnObject.h" 27 #include "lldb/Interpreter/OptionGroupString.h" 28 #include "lldb/Interpreter/OptionGroupUInt64.h" 29 #include "lldb/Interpreter/OptionValueProperties.h" 30 #include "lldb/Symbol/LocateSymbolFile.h" 31 #include "lldb/Symbol/ObjectFile.h" 32 #include "lldb/Target/RegisterContext.h" 33 #include "lldb/Target/Target.h" 34 #include "lldb/Target/Thread.h" 35 #include "lldb/Utility/Log.h" 36 #include "lldb/Utility/State.h" 37 #include "lldb/Utility/StringExtractor.h" 38 #include "lldb/Utility/UUID.h" 39 40 #include "llvm/Support/Threading.h" 41 42 #define USEC_PER_SEC 1000000 43 44 #include "Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h" 45 #include "Plugins/DynamicLoader/Static/DynamicLoaderStatic.h" 46 #include "ProcessKDP.h" 47 #include "ProcessKDPLog.h" 48 #include "ThreadKDP.h" 49 50 using namespace lldb; 51 using namespace lldb_private; 52 53 LLDB_PLUGIN_DEFINE_ADV(ProcessKDP, ProcessMacOSXKernel) 54 55 namespace { 56 57 #define LLDB_PROPERTIES_processkdp 58 #include "ProcessKDPProperties.inc" 59 60 enum { 61 #define LLDB_PROPERTIES_processkdp 62 #include "ProcessKDPPropertiesEnum.inc" 63 }; 64 65 class PluginProperties : public Properties { 66 public: 67 static ConstString GetSettingName() { 68 return ProcessKDP::GetPluginNameStatic(); 69 } 70 71 PluginProperties() : Properties() { 72 m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); 73 m_collection_sp->Initialize(g_processkdp_properties); 74 } 75 76 virtual ~PluginProperties() = default; 77 78 uint64_t GetPacketTimeout() { 79 const uint32_t idx = ePropertyKDPPacketTimeout; 80 return m_collection_sp->GetPropertyAtIndexAsUInt64( 81 NULL, idx, g_processkdp_properties[idx].default_uint_value); 82 } 83 }; 84 85 typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP; 86 87 static const ProcessKDPPropertiesSP &GetGlobalPluginProperties() { 88 static ProcessKDPPropertiesSP g_settings_sp; 89 if (!g_settings_sp) 90 g_settings_sp = std::make_shared<PluginProperties>(); 91 return g_settings_sp; 92 } 93 94 } // anonymous namespace end 95 96 static const lldb::tid_t g_kernel_tid = 1; 97 98 ConstString ProcessKDP::GetPluginNameStatic() { 99 static ConstString g_name("kdp-remote"); 100 return g_name; 101 } 102 103 const char *ProcessKDP::GetPluginDescriptionStatic() { 104 return "KDP Remote protocol based debugging plug-in for darwin kernel " 105 "debugging."; 106 } 107 108 void ProcessKDP::Terminate() { 109 PluginManager::UnregisterPlugin(ProcessKDP::CreateInstance); 110 } 111 112 lldb::ProcessSP ProcessKDP::CreateInstance(TargetSP target_sp, 113 ListenerSP listener_sp, 114 const FileSpec *crash_file_path, 115 bool can_connect) { 116 lldb::ProcessSP process_sp; 117 if (crash_file_path == NULL) 118 process_sp = std::make_shared<ProcessKDP>(target_sp, listener_sp); 119 return process_sp; 120 } 121 122 bool ProcessKDP::CanDebug(TargetSP target_sp, bool plugin_specified_by_name) { 123 if (plugin_specified_by_name) 124 return true; 125 126 // For now we are just making sure the file exists for a given module 127 Module *exe_module = target_sp->GetExecutableModulePointer(); 128 if (exe_module) { 129 const llvm::Triple &triple_ref = target_sp->GetArchitecture().GetTriple(); 130 switch (triple_ref.getOS()) { 131 case llvm::Triple::Darwin: // Should use "macosx" for desktop and "ios" for 132 // iOS, but accept darwin just in case 133 case llvm::Triple::MacOSX: // For desktop targets 134 case llvm::Triple::IOS: // For arm targets 135 case llvm::Triple::TvOS: 136 case llvm::Triple::WatchOS: 137 if (triple_ref.getVendor() == llvm::Triple::Apple) { 138 ObjectFile *exe_objfile = exe_module->GetObjectFile(); 139 if (exe_objfile->GetType() == ObjectFile::eTypeExecutable && 140 exe_objfile->GetStrata() == ObjectFile::eStrataKernel) 141 return true; 142 } 143 break; 144 145 default: 146 break; 147 } 148 } 149 return false; 150 } 151 152 // ProcessKDP constructor 153 ProcessKDP::ProcessKDP(TargetSP target_sp, ListenerSP listener_sp) 154 : Process(target_sp, listener_sp), 155 m_comm("lldb.process.kdp-remote.communication"), 156 m_async_broadcaster(NULL, "lldb.process.kdp-remote.async-broadcaster"), 157 m_dyld_plugin_name(), m_kernel_load_addr(LLDB_INVALID_ADDRESS), 158 m_command_sp(), m_kernel_thread_wp() { 159 m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit, 160 "async thread should exit"); 161 m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue, 162 "async thread continue"); 163 const uint64_t timeout_seconds = 164 GetGlobalPluginProperties()->GetPacketTimeout(); 165 if (timeout_seconds > 0) 166 m_comm.SetPacketTimeout(std::chrono::seconds(timeout_seconds)); 167 } 168 169 // Destructor 170 ProcessKDP::~ProcessKDP() { 171 Clear(); 172 // We need to call finalize on the process before destroying ourselves to 173 // make sure all of the broadcaster cleanup goes as planned. If we destruct 174 // this class, then Process::~Process() might have problems trying to fully 175 // destroy the broadcaster. 176 Finalize(); 177 } 178 179 // PluginInterface 180 lldb_private::ConstString ProcessKDP::GetPluginName() { 181 return GetPluginNameStatic(); 182 } 183 184 Status ProcessKDP::WillLaunch(Module *module) { 185 Status error; 186 error.SetErrorString("launching not supported in kdp-remote plug-in"); 187 return error; 188 } 189 190 Status ProcessKDP::WillAttachToProcessWithID(lldb::pid_t pid) { 191 Status error; 192 error.SetErrorString( 193 "attaching to a by process ID not supported in kdp-remote plug-in"); 194 return error; 195 } 196 197 Status ProcessKDP::WillAttachToProcessWithName(const char *process_name, 198 bool wait_for_launch) { 199 Status error; 200 error.SetErrorString( 201 "attaching to a by process name not supported in kdp-remote plug-in"); 202 return error; 203 } 204 205 bool ProcessKDP::GetHostArchitecture(ArchSpec &arch) { 206 uint32_t cpu = m_comm.GetCPUType(); 207 if (cpu) { 208 uint32_t sub = m_comm.GetCPUSubtype(); 209 arch.SetArchitecture(eArchTypeMachO, cpu, sub); 210 // Leave architecture vendor as unspecified unknown 211 arch.GetTriple().setVendor(llvm::Triple::UnknownVendor); 212 arch.GetTriple().setVendorName(llvm::StringRef()); 213 return true; 214 } 215 arch.Clear(); 216 return false; 217 } 218 219 Status ProcessKDP::DoConnectRemote(llvm::StringRef remote_url) { 220 Status error; 221 222 // Don't let any JIT happen when doing KDP as we can't allocate memory and we 223 // don't want to be mucking with threads that might already be handling 224 // exceptions 225 SetCanJIT(false); 226 227 if (remote_url.empty()) { 228 error.SetErrorStringWithFormat("empty connection URL"); 229 return error; 230 } 231 232 std::unique_ptr<ConnectionFileDescriptor> conn_up( 233 new ConnectionFileDescriptor()); 234 if (conn_up) { 235 // Only try once for now. 236 // TODO: check if we should be retrying? 237 const uint32_t max_retry_count = 1; 238 for (uint32_t retry_count = 0; retry_count < max_retry_count; 239 ++retry_count) { 240 if (conn_up->Connect(remote_url, &error) == eConnectionStatusSuccess) 241 break; 242 usleep(100000); 243 } 244 } 245 246 if (conn_up->IsConnected()) { 247 const TCPSocket &socket = 248 static_cast<const TCPSocket &>(*conn_up->GetReadObject()); 249 const uint16_t reply_port = socket.GetLocalPortNumber(); 250 251 if (reply_port != 0) { 252 m_comm.SetConnection(std::move(conn_up)); 253 254 if (m_comm.SendRequestReattach(reply_port)) { 255 if (m_comm.SendRequestConnect(reply_port, reply_port, 256 "Greetings from LLDB...")) { 257 m_comm.GetVersion(); 258 259 Target &target = GetTarget(); 260 ArchSpec kernel_arch; 261 // The host architecture 262 GetHostArchitecture(kernel_arch); 263 ArchSpec target_arch = target.GetArchitecture(); 264 // Merge in any unspecified stuff into the target architecture in 265 // case the target arch isn't set at all or incompletely. 266 target_arch.MergeFrom(kernel_arch); 267 target.SetArchitecture(target_arch); 268 269 /* Get the kernel's UUID and load address via KDP_KERNELVERSION 270 * packet. */ 271 /* An EFI kdp session has neither UUID nor load address. */ 272 273 UUID kernel_uuid = m_comm.GetUUID(); 274 addr_t kernel_load_addr = m_comm.GetLoadAddress(); 275 276 if (m_comm.RemoteIsEFI()) { 277 // Select an invalid plugin name for the dynamic loader so one 278 // doesn't get used since EFI does its own manual loading via 279 // python scripting 280 static ConstString g_none_dynamic_loader("none"); 281 m_dyld_plugin_name = g_none_dynamic_loader; 282 283 if (kernel_uuid.IsValid()) { 284 // If EFI passed in a UUID= try to lookup UUID The slide will not 285 // be provided. But the UUID lookup will be used to launch EFI 286 // debug scripts from the dSYM, that can load all of the symbols. 287 ModuleSpec module_spec; 288 module_spec.GetUUID() = kernel_uuid; 289 module_spec.GetArchitecture() = target.GetArchitecture(); 290 291 // Lookup UUID locally, before attempting dsymForUUID like action 292 FileSpecList search_paths = 293 Target::GetDefaultDebugFileSearchPaths(); 294 module_spec.GetSymbolFileSpec() = 295 Symbols::LocateExecutableSymbolFile(module_spec, 296 search_paths); 297 if (module_spec.GetSymbolFileSpec()) { 298 ModuleSpec executable_module_spec = 299 Symbols::LocateExecutableObjectFile(module_spec); 300 if (FileSystem::Instance().Exists( 301 executable_module_spec.GetFileSpec())) { 302 module_spec.GetFileSpec() = 303 executable_module_spec.GetFileSpec(); 304 } 305 } 306 if (!module_spec.GetSymbolFileSpec() || 307 !module_spec.GetSymbolFileSpec()) 308 Symbols::DownloadObjectAndSymbolFile(module_spec, true); 309 310 if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) { 311 ModuleSP module_sp(new Module(module_spec)); 312 if (module_sp.get() && module_sp->GetObjectFile()) { 313 // Get the current target executable 314 ModuleSP exe_module_sp(target.GetExecutableModule()); 315 316 // Make sure you don't already have the right module loaded 317 // and they will be uniqued 318 if (exe_module_sp.get() != module_sp.get()) 319 target.SetExecutableModule(module_sp, eLoadDependentsNo); 320 } 321 } 322 } 323 } else if (m_comm.RemoteIsDarwinKernel()) { 324 m_dyld_plugin_name = 325 DynamicLoaderDarwinKernel::GetPluginNameStatic(); 326 if (kernel_load_addr != LLDB_INVALID_ADDRESS) { 327 m_kernel_load_addr = kernel_load_addr; 328 } 329 } 330 331 // Set the thread ID 332 UpdateThreadListIfNeeded(); 333 SetID(1); 334 GetThreadList(); 335 SetPrivateState(eStateStopped); 336 StreamSP async_strm_sp(target.GetDebugger().GetAsyncOutputStream()); 337 if (async_strm_sp) { 338 const char *cstr; 339 if ((cstr = m_comm.GetKernelVersion()) != NULL) { 340 async_strm_sp->Printf("Version: %s\n", cstr); 341 async_strm_sp->Flush(); 342 } 343 // if ((cstr = m_comm.GetImagePath ()) != NULL) 344 // { 345 // async_strm_sp->Printf ("Image Path: 346 // %s\n", cstr); 347 // async_strm_sp->Flush(); 348 // } 349 } 350 } else { 351 error.SetErrorString("KDP_REATTACH failed"); 352 } 353 } else { 354 error.SetErrorString("KDP_REATTACH failed"); 355 } 356 } else { 357 error.SetErrorString("invalid reply port from UDP connection"); 358 } 359 } else { 360 if (error.Success()) 361 error.SetErrorStringWithFormat("failed to connect to '%s'", 362 remote_url.str().c_str()); 363 } 364 if (error.Fail()) 365 m_comm.Disconnect(); 366 367 return error; 368 } 369 370 // Process Control 371 Status ProcessKDP::DoLaunch(Module *exe_module, 372 ProcessLaunchInfo &launch_info) { 373 Status error; 374 error.SetErrorString("launching not supported in kdp-remote plug-in"); 375 return error; 376 } 377 378 Status 379 ProcessKDP::DoAttachToProcessWithID(lldb::pid_t attach_pid, 380 const ProcessAttachInfo &attach_info) { 381 Status error; 382 error.SetErrorString( 383 "attach to process by ID is not supported in kdp remote debugging"); 384 return error; 385 } 386 387 Status 388 ProcessKDP::DoAttachToProcessWithName(const char *process_name, 389 const ProcessAttachInfo &attach_info) { 390 Status error; 391 error.SetErrorString( 392 "attach to process by name is not supported in kdp remote debugging"); 393 return error; 394 } 395 396 void ProcessKDP::DidAttach(ArchSpec &process_arch) { 397 Process::DidAttach(process_arch); 398 399 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS)); 400 LLDB_LOGF(log, "ProcessKDP::DidAttach()"); 401 if (GetID() != LLDB_INVALID_PROCESS_ID) { 402 GetHostArchitecture(process_arch); 403 } 404 } 405 406 addr_t ProcessKDP::GetImageInfoAddress() { return m_kernel_load_addr; } 407 408 lldb_private::DynamicLoader *ProcessKDP::GetDynamicLoader() { 409 if (m_dyld_up.get() == NULL) 410 m_dyld_up.reset(DynamicLoader::FindPlugin( 411 this, 412 m_dyld_plugin_name.IsEmpty() ? NULL : m_dyld_plugin_name.GetCString())); 413 return m_dyld_up.get(); 414 } 415 416 Status ProcessKDP::WillResume() { return Status(); } 417 418 Status ProcessKDP::DoResume() { 419 Status error; 420 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS)); 421 // Only start the async thread if we try to do any process control 422 if (!m_async_thread.IsJoinable()) 423 StartAsyncThread(); 424 425 bool resume = false; 426 427 // With KDP there is only one thread we can tell what to do 428 ThreadSP kernel_thread_sp(m_thread_list.FindThreadByProtocolID(g_kernel_tid)); 429 430 if (kernel_thread_sp) { 431 const StateType thread_resume_state = 432 kernel_thread_sp->GetTemporaryResumeState(); 433 434 LLDB_LOGF(log, "ProcessKDP::DoResume() thread_resume_state = %s", 435 StateAsCString(thread_resume_state)); 436 switch (thread_resume_state) { 437 case eStateSuspended: 438 // Nothing to do here when a thread will stay suspended we just leave the 439 // CPU mask bit set to zero for the thread 440 LLDB_LOGF(log, "ProcessKDP::DoResume() = suspended???"); 441 break; 442 443 case eStateStepping: { 444 lldb::RegisterContextSP reg_ctx_sp( 445 kernel_thread_sp->GetRegisterContext()); 446 447 if (reg_ctx_sp) { 448 LLDB_LOGF( 449 log, 450 "ProcessKDP::DoResume () reg_ctx_sp->HardwareSingleStep (true);"); 451 reg_ctx_sp->HardwareSingleStep(true); 452 resume = true; 453 } else { 454 error.SetErrorStringWithFormat( 455 "KDP thread 0x%llx has no register context", 456 kernel_thread_sp->GetID()); 457 } 458 } break; 459 460 case eStateRunning: { 461 lldb::RegisterContextSP reg_ctx_sp( 462 kernel_thread_sp->GetRegisterContext()); 463 464 if (reg_ctx_sp) { 465 LLDB_LOGF(log, "ProcessKDP::DoResume () reg_ctx_sp->HardwareSingleStep " 466 "(false);"); 467 reg_ctx_sp->HardwareSingleStep(false); 468 resume = true; 469 } else { 470 error.SetErrorStringWithFormat( 471 "KDP thread 0x%llx has no register context", 472 kernel_thread_sp->GetID()); 473 } 474 } break; 475 476 default: 477 // The only valid thread resume states are listed above 478 llvm_unreachable("invalid thread resume state"); 479 } 480 } 481 482 if (resume) { 483 LLDB_LOGF(log, "ProcessKDP::DoResume () sending resume"); 484 485 if (m_comm.SendRequestResume()) { 486 m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncContinue); 487 SetPrivateState(eStateRunning); 488 } else 489 error.SetErrorString("KDP resume failed"); 490 } else { 491 error.SetErrorString("kernel thread is suspended"); 492 } 493 494 return error; 495 } 496 497 lldb::ThreadSP ProcessKDP::GetKernelThread() { 498 // KDP only tells us about one thread/core. Any other threads will usually 499 // be the ones that are read from memory by the OS plug-ins. 500 501 ThreadSP thread_sp(m_kernel_thread_wp.lock()); 502 if (!thread_sp) { 503 thread_sp = std::make_shared<ThreadKDP>(*this, g_kernel_tid); 504 m_kernel_thread_wp = thread_sp; 505 } 506 return thread_sp; 507 } 508 509 bool ProcessKDP::DoUpdateThreadList(ThreadList &old_thread_list, 510 ThreadList &new_thread_list) { 511 // locker will keep a mutex locked until it goes out of scope 512 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_THREAD)); 513 LLDB_LOGV(log, "pid = {0}", GetID()); 514 515 // Even though there is a CPU mask, it doesn't mean we can see each CPU 516 // individually, there is really only one. Lets call this thread 1. 517 ThreadSP thread_sp( 518 old_thread_list.FindThreadByProtocolID(g_kernel_tid, false)); 519 if (!thread_sp) 520 thread_sp = GetKernelThread(); 521 new_thread_list.AddThread(thread_sp); 522 523 return new_thread_list.GetSize(false) > 0; 524 } 525 526 void ProcessKDP::RefreshStateAfterStop() { 527 // Let all threads recover from stopping and do any clean up based on the 528 // previous thread state (if any). 529 m_thread_list.RefreshStateAfterStop(); 530 } 531 532 Status ProcessKDP::DoHalt(bool &caused_stop) { 533 Status error; 534 535 if (m_comm.IsRunning()) { 536 if (m_destroy_in_process) { 537 // If we are attempting to destroy, we need to not return an error to Halt 538 // or DoDestroy won't get called. We are also currently running, so send 539 // a process stopped event 540 SetPrivateState(eStateStopped); 541 } else { 542 error.SetErrorString("KDP cannot interrupt a running kernel"); 543 } 544 } 545 return error; 546 } 547 548 Status ProcessKDP::DoDetach(bool keep_stopped) { 549 Status error; 550 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS)); 551 LLDB_LOGF(log, "ProcessKDP::DoDetach(keep_stopped = %i)", keep_stopped); 552 553 if (m_comm.IsRunning()) { 554 // We are running and we can't interrupt a running kernel, so we need to 555 // just close the connection to the kernel and hope for the best 556 } else { 557 // If we are going to keep the target stopped, then don't send the 558 // disconnect message. 559 if (!keep_stopped && m_comm.IsConnected()) { 560 const bool success = m_comm.SendRequestDisconnect(); 561 if (log) { 562 if (success) 563 log->PutCString( 564 "ProcessKDP::DoDetach() detach packet sent successfully"); 565 else 566 log->PutCString( 567 "ProcessKDP::DoDetach() connection channel shutdown failed"); 568 } 569 m_comm.Disconnect(); 570 } 571 } 572 StopAsyncThread(); 573 m_comm.Clear(); 574 575 SetPrivateState(eStateDetached); 576 ResumePrivateStateThread(); 577 578 // KillDebugserverProcess (); 579 return error; 580 } 581 582 Status ProcessKDP::DoDestroy() { 583 // For KDP there really is no difference between destroy and detach 584 bool keep_stopped = false; 585 return DoDetach(keep_stopped); 586 } 587 588 // Process Queries 589 590 bool ProcessKDP::IsAlive() { 591 return m_comm.IsConnected() && Process::IsAlive(); 592 } 593 594 // Process Memory 595 size_t ProcessKDP::DoReadMemory(addr_t addr, void *buf, size_t size, 596 Status &error) { 597 uint8_t *data_buffer = (uint8_t *)buf; 598 if (m_comm.IsConnected()) { 599 const size_t max_read_size = 512; 600 size_t total_bytes_read = 0; 601 602 // Read the requested amount of memory in 512 byte chunks 603 while (total_bytes_read < size) { 604 size_t bytes_to_read_this_request = size - total_bytes_read; 605 if (bytes_to_read_this_request > max_read_size) { 606 bytes_to_read_this_request = max_read_size; 607 } 608 size_t bytes_read = m_comm.SendRequestReadMemory( 609 addr + total_bytes_read, data_buffer + total_bytes_read, 610 bytes_to_read_this_request, error); 611 total_bytes_read += bytes_read; 612 if (error.Fail() || bytes_read == 0) { 613 return total_bytes_read; 614 } 615 } 616 617 return total_bytes_read; 618 } 619 error.SetErrorString("not connected"); 620 return 0; 621 } 622 623 size_t ProcessKDP::DoWriteMemory(addr_t addr, const void *buf, size_t size, 624 Status &error) { 625 if (m_comm.IsConnected()) 626 return m_comm.SendRequestWriteMemory(addr, buf, size, error); 627 error.SetErrorString("not connected"); 628 return 0; 629 } 630 631 lldb::addr_t ProcessKDP::DoAllocateMemory(size_t size, uint32_t permissions, 632 Status &error) { 633 error.SetErrorString( 634 "memory allocation not supported in kdp remote debugging"); 635 return LLDB_INVALID_ADDRESS; 636 } 637 638 Status ProcessKDP::DoDeallocateMemory(lldb::addr_t addr) { 639 Status error; 640 error.SetErrorString( 641 "memory deallocation not supported in kdp remote debugging"); 642 return error; 643 } 644 645 Status ProcessKDP::EnableBreakpointSite(BreakpointSite *bp_site) { 646 if (bp_site->HardwareRequired()) 647 return Status("Hardware breakpoints are not supported."); 648 649 if (m_comm.LocalBreakpointsAreSupported()) { 650 Status error; 651 if (!bp_site->IsEnabled()) { 652 if (m_comm.SendRequestBreakpoint(true, bp_site->GetLoadAddress())) { 653 bp_site->SetEnabled(true); 654 bp_site->SetType(BreakpointSite::eExternal); 655 } else { 656 error.SetErrorString("KDP set breakpoint failed"); 657 } 658 } 659 return error; 660 } 661 return EnableSoftwareBreakpoint(bp_site); 662 } 663 664 Status ProcessKDP::DisableBreakpointSite(BreakpointSite *bp_site) { 665 if (m_comm.LocalBreakpointsAreSupported()) { 666 Status error; 667 if (bp_site->IsEnabled()) { 668 BreakpointSite::Type bp_type = bp_site->GetType(); 669 if (bp_type == BreakpointSite::eExternal) { 670 if (m_destroy_in_process && m_comm.IsRunning()) { 671 // We are trying to destroy our connection and we are running 672 bp_site->SetEnabled(false); 673 } else { 674 if (m_comm.SendRequestBreakpoint(false, bp_site->GetLoadAddress())) 675 bp_site->SetEnabled(false); 676 else 677 error.SetErrorString("KDP remove breakpoint failed"); 678 } 679 } else { 680 error = DisableSoftwareBreakpoint(bp_site); 681 } 682 } 683 return error; 684 } 685 return DisableSoftwareBreakpoint(bp_site); 686 } 687 688 Status ProcessKDP::EnableWatchpoint(Watchpoint *wp, bool notify) { 689 Status error; 690 error.SetErrorString( 691 "watchpoints are not supported in kdp remote debugging"); 692 return error; 693 } 694 695 Status ProcessKDP::DisableWatchpoint(Watchpoint *wp, bool notify) { 696 Status error; 697 error.SetErrorString( 698 "watchpoints are not supported in kdp remote debugging"); 699 return error; 700 } 701 702 void ProcessKDP::Clear() { m_thread_list.Clear(); } 703 704 Status ProcessKDP::DoSignal(int signo) { 705 Status error; 706 error.SetErrorString( 707 "sending signals is not supported in kdp remote debugging"); 708 return error; 709 } 710 711 void ProcessKDP::Initialize() { 712 static llvm::once_flag g_once_flag; 713 714 llvm::call_once(g_once_flag, []() { 715 PluginManager::RegisterPlugin(GetPluginNameStatic(), 716 GetPluginDescriptionStatic(), CreateInstance, 717 DebuggerInitialize); 718 719 ProcessKDPLog::Initialize(); 720 }); 721 } 722 723 void ProcessKDP::DebuggerInitialize(lldb_private::Debugger &debugger) { 724 if (!PluginManager::GetSettingForProcessPlugin( 725 debugger, PluginProperties::GetSettingName())) { 726 const bool is_global_setting = true; 727 PluginManager::CreateSettingForProcessPlugin( 728 debugger, GetGlobalPluginProperties()->GetValueProperties(), 729 ConstString("Properties for the kdp-remote process plug-in."), 730 is_global_setting); 731 } 732 } 733 734 bool ProcessKDP::StartAsyncThread() { 735 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS)); 736 737 LLDB_LOGF(log, "ProcessKDP::StartAsyncThread ()"); 738 739 if (m_async_thread.IsJoinable()) 740 return true; 741 742 llvm::Expected<HostThread> async_thread = ThreadLauncher::LaunchThread( 743 "<lldb.process.kdp-remote.async>", ProcessKDP::AsyncThread, this); 744 if (!async_thread) { 745 LLDB_LOG(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST), 746 "failed to launch host thread: {}", 747 llvm::toString(async_thread.takeError())); 748 return false; 749 } 750 m_async_thread = *async_thread; 751 return m_async_thread.IsJoinable(); 752 } 753 754 void ProcessKDP::StopAsyncThread() { 755 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS)); 756 757 LLDB_LOGF(log, "ProcessKDP::StopAsyncThread ()"); 758 759 m_async_broadcaster.BroadcastEvent(eBroadcastBitAsyncThreadShouldExit); 760 761 // Stop the stdio thread 762 if (m_async_thread.IsJoinable()) 763 m_async_thread.Join(nullptr); 764 } 765 766 void *ProcessKDP::AsyncThread(void *arg) { 767 ProcessKDP *process = (ProcessKDP *)arg; 768 769 const lldb::pid_t pid = process->GetID(); 770 771 Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS)); 772 LLDB_LOGF(log, 773 "ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 774 ") thread starting...", 775 arg, pid); 776 777 ListenerSP listener_sp(Listener::MakeListener("ProcessKDP::AsyncThread")); 778 EventSP event_sp; 779 const uint32_t desired_event_mask = 780 eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit; 781 782 if (listener_sp->StartListeningForEvents(&process->m_async_broadcaster, 783 desired_event_mask) == 784 desired_event_mask) { 785 bool done = false; 786 while (!done) { 787 LLDB_LOGF(log, 788 "ProcessKDP::AsyncThread (pid = %" PRIu64 789 ") listener.WaitForEvent (NULL, event_sp)...", 790 pid); 791 if (listener_sp->GetEvent(event_sp, llvm::None)) { 792 uint32_t event_type = event_sp->GetType(); 793 LLDB_LOGF(log, 794 "ProcessKDP::AsyncThread (pid = %" PRIu64 795 ") Got an event of type: %d...", 796 pid, event_type); 797 798 // When we are running, poll for 1 second to try and get an exception 799 // to indicate the process has stopped. If we don't get one, check to 800 // make sure no one asked us to exit 801 bool is_running = false; 802 DataExtractor exc_reply_packet; 803 do { 804 switch (event_type) { 805 case eBroadcastBitAsyncContinue: { 806 is_running = true; 807 if (process->m_comm.WaitForPacketWithTimeoutMicroSeconds( 808 exc_reply_packet, 1 * USEC_PER_SEC)) { 809 ThreadSP thread_sp(process->GetKernelThread()); 810 if (thread_sp) { 811 lldb::RegisterContextSP reg_ctx_sp( 812 thread_sp->GetRegisterContext()); 813 if (reg_ctx_sp) 814 reg_ctx_sp->InvalidateAllRegisters(); 815 static_cast<ThreadKDP *>(thread_sp.get()) 816 ->SetStopInfoFrom_KDP_EXCEPTION(exc_reply_packet); 817 } 818 819 // TODO: parse the stop reply packet 820 is_running = false; 821 process->SetPrivateState(eStateStopped); 822 } else { 823 // Check to see if we are supposed to exit. There is no way to 824 // interrupt a running kernel, so all we can do is wait for an 825 // exception or detach... 826 if (listener_sp->GetEvent(event_sp, 827 std::chrono::microseconds(0))) { 828 // We got an event, go through the loop again 829 event_type = event_sp->GetType(); 830 } 831 } 832 } break; 833 834 case eBroadcastBitAsyncThreadShouldExit: 835 LLDB_LOGF(log, 836 "ProcessKDP::AsyncThread (pid = %" PRIu64 837 ") got eBroadcastBitAsyncThreadShouldExit...", 838 pid); 839 done = true; 840 is_running = false; 841 break; 842 843 default: 844 LLDB_LOGF(log, 845 "ProcessKDP::AsyncThread (pid = %" PRIu64 846 ") got unknown event 0x%8.8x", 847 pid, event_type); 848 done = true; 849 is_running = false; 850 break; 851 } 852 } while (is_running); 853 } else { 854 LLDB_LOGF(log, 855 "ProcessKDP::AsyncThread (pid = %" PRIu64 856 ") listener.WaitForEvent (NULL, event_sp) => false", 857 pid); 858 done = true; 859 } 860 } 861 } 862 863 LLDB_LOGF(log, 864 "ProcessKDP::AsyncThread (arg = %p, pid = %" PRIu64 865 ") thread exiting...", 866 arg, pid); 867 868 process->m_async_thread.Reset(); 869 return NULL; 870 } 871 872 class CommandObjectProcessKDPPacketSend : public CommandObjectParsed { 873 private: 874 OptionGroupOptions m_option_group; 875 OptionGroupUInt64 m_command_byte; 876 OptionGroupString m_packet_data; 877 878 Options *GetOptions() override { return &m_option_group; } 879 880 public: 881 CommandObjectProcessKDPPacketSend(CommandInterpreter &interpreter) 882 : CommandObjectParsed(interpreter, "process plugin packet send", 883 "Send a custom packet through the KDP protocol by " 884 "specifying the command byte and the packet " 885 "payload data. A packet will be sent with a " 886 "correct header and payload, and the raw result " 887 "bytes will be displayed as a string value. ", 888 NULL), 889 m_option_group(), 890 m_command_byte(LLDB_OPT_SET_1, true, "command", 'c', 0, eArgTypeNone, 891 "Specify the command byte to use when sending the KDP " 892 "request packet.", 893 0), 894 m_packet_data(LLDB_OPT_SET_1, false, "payload", 'p', 0, eArgTypeNone, 895 "Specify packet payload bytes as a hex ASCII string with " 896 "no spaces or hex prefixes.", 897 NULL) { 898 m_option_group.Append(&m_command_byte, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 899 m_option_group.Append(&m_packet_data, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 900 m_option_group.Finalize(); 901 } 902 903 ~CommandObjectProcessKDPPacketSend() = default; 904 905 bool DoExecute(Args &command, CommandReturnObject &result) override { 906 const size_t argc = command.GetArgumentCount(); 907 if (argc == 0) { 908 if (!m_command_byte.GetOptionValue().OptionWasSet()) { 909 result.AppendError( 910 "the --command option must be set to a valid command byte"); 911 } else { 912 const uint64_t command_byte = 913 m_command_byte.GetOptionValue().GetUInt64Value(0); 914 if (command_byte > 0 && command_byte <= UINT8_MAX) { 915 ProcessKDP *process = 916 (ProcessKDP *)m_interpreter.GetExecutionContext().GetProcessPtr(); 917 if (process) { 918 const StateType state = process->GetState(); 919 920 if (StateIsStoppedState(state, true)) { 921 std::vector<uint8_t> payload_bytes; 922 const char *ascii_hex_bytes_cstr = 923 m_packet_data.GetOptionValue().GetCurrentValue(); 924 if (ascii_hex_bytes_cstr && ascii_hex_bytes_cstr[0]) { 925 StringExtractor extractor(ascii_hex_bytes_cstr); 926 const size_t ascii_hex_bytes_cstr_len = 927 extractor.GetStringRef().size(); 928 if (ascii_hex_bytes_cstr_len & 1) { 929 result.AppendErrorWithFormat("payload data must contain an " 930 "even number of ASCII hex " 931 "characters: '%s'", 932 ascii_hex_bytes_cstr); 933 return false; 934 } 935 payload_bytes.resize(ascii_hex_bytes_cstr_len / 2); 936 if (extractor.GetHexBytes(payload_bytes, '\xdd') != 937 payload_bytes.size()) { 938 result.AppendErrorWithFormat("payload data must only contain " 939 "ASCII hex characters (no " 940 "spaces or hex prefixes): '%s'", 941 ascii_hex_bytes_cstr); 942 return false; 943 } 944 } 945 Status error; 946 DataExtractor reply; 947 process->GetCommunication().SendRawRequest( 948 command_byte, 949 payload_bytes.empty() ? NULL : payload_bytes.data(), 950 payload_bytes.size(), reply, error); 951 952 if (error.Success()) { 953 // Copy the binary bytes into a hex ASCII string for the result 954 StreamString packet; 955 packet.PutBytesAsRawHex8( 956 reply.GetDataStart(), reply.GetByteSize(), 957 endian::InlHostByteOrder(), endian::InlHostByteOrder()); 958 result.AppendMessage(packet.GetString()); 959 result.SetStatus(eReturnStatusSuccessFinishResult); 960 return true; 961 } else { 962 const char *error_cstr = error.AsCString(); 963 if (error_cstr && error_cstr[0]) 964 result.AppendError(error_cstr); 965 else 966 result.AppendErrorWithFormat("unknown error 0x%8.8x", 967 error.GetError()); 968 return false; 969 } 970 } else { 971 result.AppendErrorWithFormat("process must be stopped in order " 972 "to send KDP packets, state is %s", 973 StateAsCString(state)); 974 } 975 } else { 976 result.AppendError("invalid process"); 977 } 978 } else { 979 result.AppendErrorWithFormat("invalid command byte 0x%" PRIx64 980 ", valid values are 1 - 255", 981 command_byte); 982 } 983 } 984 } else { 985 result.AppendErrorWithFormat("'%s' takes no arguments, only options.", 986 m_cmd_name.c_str()); 987 } 988 return false; 989 } 990 }; 991 992 class CommandObjectProcessKDPPacket : public CommandObjectMultiword { 993 private: 994 public: 995 CommandObjectProcessKDPPacket(CommandInterpreter &interpreter) 996 : CommandObjectMultiword(interpreter, "process plugin packet", 997 "Commands that deal with KDP remote packets.", 998 NULL) { 999 LoadSubCommand( 1000 "send", 1001 CommandObjectSP(new CommandObjectProcessKDPPacketSend(interpreter))); 1002 } 1003 1004 ~CommandObjectProcessKDPPacket() = default; 1005 }; 1006 1007 class CommandObjectMultiwordProcessKDP : public CommandObjectMultiword { 1008 public: 1009 CommandObjectMultiwordProcessKDP(CommandInterpreter &interpreter) 1010 : CommandObjectMultiword( 1011 interpreter, "process plugin", 1012 "Commands for operating on a ProcessKDP process.", 1013 "process plugin <subcommand> [<subcommand-options>]") { 1014 LoadSubCommand("packet", CommandObjectSP(new CommandObjectProcessKDPPacket( 1015 interpreter))); 1016 } 1017 1018 ~CommandObjectMultiwordProcessKDP() = default; 1019 }; 1020 1021 CommandObject *ProcessKDP::GetPluginCommandObject() { 1022 if (!m_command_sp) 1023 m_command_sp = std::make_shared<CommandObjectMultiwordProcessKDP>( 1024 GetTarget().GetDebugger().GetCommandInterpreter()); 1025 return m_command_sp.get(); 1026 } 1027