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