1 //===-- ProcessGDBRemote.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 <spawn.h> 13 #include <sys/types.h> 14 #include <sys/stat.h> 15 16 // C++ Includes 17 #include <algorithm> 18 #include <map> 19 20 // Other libraries and framework includes 21 22 #include "lldb/Breakpoint/WatchpointLocation.h" 23 #include "lldb/Interpreter/Args.h" 24 #include "lldb/Core/ArchSpec.h" 25 #include "lldb/Core/Debugger.h" 26 #include "lldb/Core/ConnectionFileDescriptor.h" 27 #include "lldb/Core/FileSpec.h" 28 #include "lldb/Core/InputReader.h" 29 #include "lldb/Core/Module.h" 30 #include "lldb/Core/PluginManager.h" 31 #include "lldb/Core/State.h" 32 #include "lldb/Core/StreamString.h" 33 #include "lldb/Core/Timer.h" 34 #include "lldb/Host/TimeValue.h" 35 #include "lldb/Symbol/ObjectFile.h" 36 #include "lldb/Target/DynamicLoader.h" 37 #include "lldb/Target/Target.h" 38 #include "lldb/Target/TargetList.h" 39 #include "lldb/Utility/PseudoTerminal.h" 40 41 // Project includes 42 #include "lldb/Host/Host.h" 43 #include "Utility/StringExtractorGDBRemote.h" 44 #include "GDBRemoteRegisterContext.h" 45 #include "ProcessGDBRemote.h" 46 #include "ProcessGDBRemoteLog.h" 47 #include "ThreadGDBRemote.h" 48 #include "StopInfoMachException.h" 49 50 51 52 #define DEBUGSERVER_BASENAME "debugserver" 53 using namespace lldb; 54 using namespace lldb_private; 55 56 static inline uint16_t 57 get_random_port () 58 { 59 return (arc4random() % (UINT16_MAX - 1000u)) + 1000u; 60 } 61 62 63 const char * 64 ProcessGDBRemote::GetPluginNameStatic() 65 { 66 return "process.gdb-remote"; 67 } 68 69 const char * 70 ProcessGDBRemote::GetPluginDescriptionStatic() 71 { 72 return "GDB Remote protocol based debugging plug-in."; 73 } 74 75 void 76 ProcessGDBRemote::Terminate() 77 { 78 PluginManager::UnregisterPlugin (ProcessGDBRemote::CreateInstance); 79 } 80 81 82 Process* 83 ProcessGDBRemote::CreateInstance (Target &target, Listener &listener) 84 { 85 return new ProcessGDBRemote (target, listener); 86 } 87 88 bool 89 ProcessGDBRemote::CanDebug(Target &target) 90 { 91 // For now we are just making sure the file exists for a given module 92 ModuleSP exe_module_sp(target.GetExecutableModule()); 93 if (exe_module_sp.get()) 94 return exe_module_sp->GetFileSpec().Exists(); 95 // However, if there is no executable module, we return true since we might be preparing to attach. 96 return true; 97 } 98 99 //---------------------------------------------------------------------- 100 // ProcessGDBRemote constructor 101 //---------------------------------------------------------------------- 102 ProcessGDBRemote::ProcessGDBRemote(Target& target, Listener &listener) : 103 Process (target, listener), 104 m_dynamic_loader_ap (), 105 m_flags (0), 106 m_stdio_mutex (Mutex::eMutexTypeRecursive), 107 m_gdb_comm(), 108 m_debugserver_pid (LLDB_INVALID_PROCESS_ID), 109 m_debugserver_thread (LLDB_INVALID_HOST_THREAD), 110 m_last_stop_packet (), 111 m_register_info (), 112 m_async_broadcaster ("lldb.process.gdb-remote.async-broadcaster"), 113 m_async_thread (LLDB_INVALID_HOST_THREAD), 114 m_curr_tid (LLDB_INVALID_THREAD_ID), 115 m_curr_tid_run (LLDB_INVALID_THREAD_ID), 116 m_z0_supported (1), 117 m_continue_packet(), 118 m_dispatch_queue_offsets_addr (LLDB_INVALID_ADDRESS), 119 m_packet_timeout (1), 120 m_max_memory_size (512), 121 m_waiting_for_attach (false), 122 m_local_debugserver (true) 123 { 124 } 125 126 //---------------------------------------------------------------------- 127 // Destructor 128 //---------------------------------------------------------------------- 129 ProcessGDBRemote::~ProcessGDBRemote() 130 { 131 m_dynamic_loader_ap.reset(); 132 133 if (m_debugserver_thread != LLDB_INVALID_HOST_THREAD) 134 { 135 Host::ThreadCancel (m_debugserver_thread, NULL); 136 thread_result_t thread_result; 137 Host::ThreadJoin (m_debugserver_thread, &thread_result, NULL); 138 m_debugserver_thread = LLDB_INVALID_HOST_THREAD; 139 } 140 // m_mach_process.UnregisterNotificationCallbacks (this); 141 Clear(); 142 } 143 144 //---------------------------------------------------------------------- 145 // PluginInterface 146 //---------------------------------------------------------------------- 147 const char * 148 ProcessGDBRemote::GetPluginName() 149 { 150 return "Process debugging plug-in that uses the GDB remote protocol"; 151 } 152 153 const char * 154 ProcessGDBRemote::GetShortPluginName() 155 { 156 return GetPluginNameStatic(); 157 } 158 159 uint32_t 160 ProcessGDBRemote::GetPluginVersion() 161 { 162 return 1; 163 } 164 165 void 166 ProcessGDBRemote::GetPluginCommandHelp (const char *command, Stream *strm) 167 { 168 strm->Printf("TODO: fill this in\n"); 169 } 170 171 Error 172 ProcessGDBRemote::ExecutePluginCommand (Args &command, Stream *strm) 173 { 174 Error error; 175 error.SetErrorString("No plug-in commands are currently supported."); 176 return error; 177 } 178 179 Log * 180 ProcessGDBRemote::EnablePluginLogging (Stream *strm, Args &command) 181 { 182 return NULL; 183 } 184 185 void 186 ProcessGDBRemote::BuildDynamicRegisterInfo () 187 { 188 char register_info_command[64]; 189 m_register_info.Clear(); 190 StringExtractorGDBRemote::Type packet_type = StringExtractorGDBRemote::eResponse; 191 uint32_t reg_offset = 0; 192 uint32_t reg_num = 0; 193 for (; packet_type == StringExtractorGDBRemote::eResponse; ++reg_num) 194 { 195 ::snprintf (register_info_command, sizeof(register_info_command), "qRegisterInfo%x", reg_num); 196 StringExtractorGDBRemote response; 197 if (m_gdb_comm.SendPacketAndWaitForResponse(register_info_command, response, 2, false)) 198 { 199 packet_type = response.GetType(); 200 if (packet_type == StringExtractorGDBRemote::eResponse) 201 { 202 std::string name; 203 std::string value; 204 ConstString reg_name; 205 ConstString alt_name; 206 ConstString set_name; 207 RegisterInfo reg_info = { NULL, // Name 208 NULL, // Alt name 209 0, // byte size 210 reg_offset, // offset 211 eEncodingUint, // encoding 212 eFormatHex, // formate 213 { 214 LLDB_INVALID_REGNUM, // GCC reg num 215 LLDB_INVALID_REGNUM, // DWARF reg num 216 LLDB_INVALID_REGNUM, // generic reg num 217 reg_num, // GDB reg num 218 reg_num // native register number 219 } 220 }; 221 222 while (response.GetNameColonValue(name, value)) 223 { 224 if (name.compare("name") == 0) 225 { 226 reg_name.SetCString(value.c_str()); 227 } 228 else if (name.compare("alt-name") == 0) 229 { 230 alt_name.SetCString(value.c_str()); 231 } 232 else if (name.compare("bitsize") == 0) 233 { 234 reg_info.byte_size = Args::StringToUInt32(value.c_str(), 0, 0) / CHAR_BIT; 235 } 236 else if (name.compare("offset") == 0) 237 { 238 uint32_t offset = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0); 239 if (reg_offset != offset) 240 { 241 reg_offset = offset; 242 } 243 } 244 else if (name.compare("encoding") == 0) 245 { 246 if (value.compare("uint") == 0) 247 reg_info.encoding = eEncodingUint; 248 else if (value.compare("sint") == 0) 249 reg_info.encoding = eEncodingSint; 250 else if (value.compare("ieee754") == 0) 251 reg_info.encoding = eEncodingIEEE754; 252 else if (value.compare("vector") == 0) 253 reg_info.encoding = eEncodingVector; 254 } 255 else if (name.compare("format") == 0) 256 { 257 if (value.compare("binary") == 0) 258 reg_info.format = eFormatBinary; 259 else if (value.compare("decimal") == 0) 260 reg_info.format = eFormatDecimal; 261 else if (value.compare("hex") == 0) 262 reg_info.format = eFormatHex; 263 else if (value.compare("float") == 0) 264 reg_info.format = eFormatFloat; 265 else if (value.compare("vector-sint8") == 0) 266 reg_info.format = eFormatVectorOfSInt8; 267 else if (value.compare("vector-uint8") == 0) 268 reg_info.format = eFormatVectorOfUInt8; 269 else if (value.compare("vector-sint16") == 0) 270 reg_info.format = eFormatVectorOfSInt16; 271 else if (value.compare("vector-uint16") == 0) 272 reg_info.format = eFormatVectorOfUInt16; 273 else if (value.compare("vector-sint32") == 0) 274 reg_info.format = eFormatVectorOfSInt32; 275 else if (value.compare("vector-uint32") == 0) 276 reg_info.format = eFormatVectorOfUInt32; 277 else if (value.compare("vector-float32") == 0) 278 reg_info.format = eFormatVectorOfFloat32; 279 else if (value.compare("vector-uint128") == 0) 280 reg_info.format = eFormatVectorOfUInt128; 281 } 282 else if (name.compare("set") == 0) 283 { 284 set_name.SetCString(value.c_str()); 285 } 286 else if (name.compare("gcc") == 0) 287 { 288 reg_info.kinds[eRegisterKindGCC] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0); 289 } 290 else if (name.compare("dwarf") == 0) 291 { 292 reg_info.kinds[eRegisterKindDWARF] = Args::StringToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0); 293 } 294 else if (name.compare("generic") == 0) 295 { 296 if (value.compare("pc") == 0) 297 reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_PC; 298 else if (value.compare("sp") == 0) 299 reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_SP; 300 else if (value.compare("fp") == 0) 301 reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FP; 302 else if (value.compare("ra") == 0) 303 reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_RA; 304 else if (value.compare("flags") == 0) 305 reg_info.kinds[eRegisterKindGeneric] = LLDB_REGNUM_GENERIC_FLAGS; 306 } 307 } 308 309 reg_info.byte_offset = reg_offset; 310 assert (reg_info.byte_size != 0); 311 reg_offset += reg_info.byte_size; 312 m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name); 313 } 314 } 315 else 316 { 317 packet_type = StringExtractorGDBRemote::eError; 318 } 319 } 320 321 if (reg_num == 0) 322 { 323 // We didn't get anything. See if we are debugging ARM and fill with 324 // a hard coded register set until we can get an updated debugserver 325 // down on the devices. 326 ArchSpec arm_arch ("arm"); 327 if (GetTarget().GetArchitecture() == arm_arch) 328 m_register_info.HardcodeARMRegisters(); 329 } 330 m_register_info.Finalize (); 331 } 332 333 Error 334 ProcessGDBRemote::WillLaunch (Module* module) 335 { 336 return WillLaunchOrAttach (); 337 } 338 339 Error 340 ProcessGDBRemote::WillAttachToProcessWithID (lldb::pid_t pid) 341 { 342 return WillLaunchOrAttach (); 343 } 344 345 Error 346 ProcessGDBRemote::WillAttachToProcessWithName (const char *process_name, bool wait_for_launch) 347 { 348 return WillLaunchOrAttach (); 349 } 350 351 Error 352 ProcessGDBRemote::WillLaunchOrAttach () 353 { 354 Error error; 355 // TODO: this is hardcoded for macosx right now. We need this to be more dynamic 356 m_dynamic_loader_ap.reset(DynamicLoader::FindPlugin(this, "dynamic-loader.macosx-dyld")); 357 358 if (m_dynamic_loader_ap.get() == NULL) 359 error.SetErrorString("unable to find the dynamic loader named 'dynamic-loader.macosx-dyld'"); 360 m_stdio_communication.Clear (); 361 362 return error; 363 } 364 365 //---------------------------------------------------------------------- 366 // Process Control 367 //---------------------------------------------------------------------- 368 Error 369 ProcessGDBRemote::DoLaunch 370 ( 371 Module* module, 372 char const *argv[], 373 char const *envp[], 374 uint32_t launch_flags, 375 const char *stdin_path, 376 const char *stdout_path, 377 const char *stderr_path 378 ) 379 { 380 Error error; 381 // ::LogSetBitMask (GDBR_LOG_DEFAULT); 382 // ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD); 383 // ::LogSetLogFile ("/dev/stdout"); 384 385 ObjectFile * object_file = module->GetObjectFile(); 386 if (object_file) 387 { 388 ArchSpec inferior_arch(module->GetArchitecture()); 389 char host_port[128]; 390 snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ()); 391 392 const bool launch_process = true; 393 bool start_debugserver_with_inferior_args = false; 394 if (start_debugserver_with_inferior_args) 395 { 396 // We want to launch debugserver with the inferior program and its 397 // arguments on the command line. We should only do this if we 398 // the GDB server we are talking to doesn't support the 'A' packet. 399 error = StartDebugserverProcess (host_port, 400 argv, 401 envp, 402 NULL, //stdin_path, 403 launch_process, 404 LLDB_INVALID_PROCESS_ID, 405 NULL, false, 406 launch_flags, 407 inferior_arch); 408 if (error.Fail()) 409 return error; 410 411 error = ConnectToDebugserver (host_port); 412 if (error.Success()) 413 { 414 SetID (m_gdb_comm.GetCurrentProcessID (m_packet_timeout)); 415 } 416 } 417 else 418 { 419 error = StartDebugserverProcess (host_port, 420 NULL, 421 NULL, 422 NULL, //stdin_path 423 launch_process, 424 LLDB_INVALID_PROCESS_ID, 425 NULL, false, 426 launch_flags, 427 inferior_arch); 428 if (error.Fail()) 429 return error; 430 431 error = ConnectToDebugserver (host_port); 432 if (error.Success()) 433 { 434 // Send the environment and the program + arguments after we connect 435 if (envp) 436 { 437 const char *env_entry; 438 for (int i=0; (env_entry = envp[i]); ++i) 439 { 440 if (m_gdb_comm.SendEnvironmentPacket(env_entry, m_packet_timeout) != 0) 441 break; 442 } 443 } 444 445 // FIXME: convert this to use the new set/show variables when they are available 446 #if 0 447 if (::getenv ("LLDB_DEBUG_DEBUGSERVER")) 448 { 449 const uint32_t attach_debugserver_secs = 10; 450 ::printf ("attach to debugserver (pid = %i)\n", m_debugserver_pid); 451 for (uint32_t i=0; i<attach_debugserver_secs; ++i) 452 { 453 printf ("%i\n", attach_debugserver_secs - i); 454 sleep (1); 455 } 456 } 457 #endif 458 459 const uint32_t arg_timeout_seconds = 10; 460 int arg_packet_err = m_gdb_comm.SendArgumentsPacket (argv, arg_timeout_seconds); 461 if (arg_packet_err == 0) 462 { 463 std::string error_str; 464 if (m_gdb_comm.GetLaunchSuccess (m_packet_timeout, error_str)) 465 { 466 SetID (m_gdb_comm.GetCurrentProcessID (m_packet_timeout)); 467 } 468 else 469 { 470 error.SetErrorString (error_str.c_str()); 471 } 472 } 473 else 474 { 475 error.SetErrorStringWithFormat("'A' packet returned an error: %i.\n", arg_packet_err); 476 } 477 478 SetID (m_gdb_comm.GetCurrentProcessID (m_packet_timeout)); 479 } 480 } 481 482 if (GetID() == LLDB_INVALID_PROCESS_ID) 483 { 484 KillDebugserverProcess (); 485 return error; 486 } 487 488 StringExtractorGDBRemote response; 489 if (m_gdb_comm.SendPacketAndWaitForResponse("?", 1, response, m_packet_timeout, false)) 490 SetPrivateState (SetThreadStopInfo (response)); 491 492 } 493 else 494 { 495 // Set our user ID to an invalid process ID. 496 SetID(LLDB_INVALID_PROCESS_ID); 497 error.SetErrorStringWithFormat("Failed to get object file from '%s' for arch %s.\n", module->GetFileSpec().GetFilename().AsCString(), module->GetArchitecture().AsCString()); 498 } 499 return error; 500 501 } 502 503 504 Error 505 ProcessGDBRemote::ConnectToDebugserver (const char *host_port) 506 { 507 Error error; 508 // Sleep and wait a bit for debugserver to start to listen... 509 std::auto_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor()); 510 if (conn_ap.get()) 511 { 512 std::string connect_url("connect://"); 513 connect_url.append (host_port); 514 const uint32_t max_retry_count = 50; 515 uint32_t retry_count = 0; 516 while (!m_gdb_comm.IsConnected()) 517 { 518 if (conn_ap->Connect(connect_url.c_str(), &error) == eConnectionStatusSuccess) 519 { 520 m_gdb_comm.SetConnection (conn_ap.release()); 521 break; 522 } 523 retry_count++; 524 525 if (retry_count >= max_retry_count) 526 break; 527 528 usleep (100000); 529 } 530 } 531 532 if (!m_gdb_comm.IsConnected()) 533 { 534 if (error.Success()) 535 error.SetErrorString("not connected to remote gdb server"); 536 return error; 537 } 538 539 m_gdb_comm.SetAckMode (true); 540 if (m_gdb_comm.StartReadThread(&error)) 541 { 542 // Send an initial ack 543 m_gdb_comm.SendAck('+'); 544 545 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) 546 m_debugserver_thread = Host::StartMonitoringChildProcess (MonitorDebugserverProcess, 547 this, 548 m_debugserver_pid, 549 false); 550 551 StringExtractorGDBRemote response; 552 if (m_gdb_comm.SendPacketAndWaitForResponse("QStartNoAckMode", response, 1, false)) 553 { 554 if (response.IsOKPacket()) 555 m_gdb_comm.SetAckMode (false); 556 } 557 } 558 return error; 559 } 560 561 void 562 ProcessGDBRemote::DidLaunchOrAttach () 563 { 564 ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::DidLaunch()"); 565 if (GetID() == LLDB_INVALID_PROCESS_ID) 566 { 567 m_dynamic_loader_ap.reset(); 568 } 569 else 570 { 571 m_dispatch_queue_offsets_addr = LLDB_INVALID_ADDRESS; 572 573 BuildDynamicRegisterInfo (); 574 575 m_byte_order = m_gdb_comm.GetByteOrder(); 576 577 Module * exe_module = GetTarget().GetExecutableModule().get(); 578 assert(exe_module); 579 580 ObjectFile *exe_objfile = exe_module->GetObjectFile(); 581 assert(exe_objfile); 582 583 StreamString strm; 584 585 ArchSpec inferior_arch; 586 // See if the GDB server supports the qHostInfo information 587 const char *vendor = m_gdb_comm.GetVendorString().AsCString(); 588 const char *os_type = m_gdb_comm.GetOSString().AsCString(); 589 ArchSpec arch_spec (GetTarget().GetArchitecture()); 590 591 if (arch_spec.IsValid() && arch_spec == ArchSpec ("arm")) 592 { 593 // For ARM we can't trust the arch of the process as it could 594 // have an armv6 object file, but be running on armv7 kernel. 595 inferior_arch = m_gdb_comm.GetHostArchitecture(); 596 } 597 598 if (!inferior_arch.IsValid()) 599 inferior_arch = arch_spec; 600 601 if (vendor == NULL) 602 vendor = Host::GetVendorString().AsCString("apple"); 603 604 if (os_type == NULL) 605 os_type = Host::GetOSString().AsCString("darwin"); 606 607 strm.Printf ("%s-%s-%s", inferior_arch.AsCString(), vendor, os_type); 608 609 std::transform (strm.GetString().begin(), 610 strm.GetString().end(), 611 strm.GetString().begin(), 612 ::tolower); 613 614 m_target_triple.SetCString(strm.GetString().c_str()); 615 } 616 } 617 618 void 619 ProcessGDBRemote::DidLaunch () 620 { 621 DidLaunchOrAttach (); 622 if (m_dynamic_loader_ap.get()) 623 m_dynamic_loader_ap->DidLaunch(); 624 } 625 626 Error 627 ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid) 628 { 629 Error error; 630 // Clear out and clean up from any current state 631 Clear(); 632 ArchSpec arch_spec = GetTarget().GetArchitecture(); 633 634 //LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 635 636 637 if (attach_pid != LLDB_INVALID_PROCESS_ID) 638 { 639 char host_port[128]; 640 snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ()); 641 error = StartDebugserverProcess (host_port, // debugserver_url 642 NULL, // inferior_argv 643 NULL, // inferior_envp 644 NULL, // stdin_path 645 false, // launch_process == false (we are attaching) 646 LLDB_INVALID_PROCESS_ID, // Don't send any attach to pid options to debugserver 647 NULL, // Don't send any attach by process name option to debugserver 648 false, // Don't send any attach wait_for_launch flag as an option to debugserver 649 0, // launch_flags 650 arch_spec); 651 652 if (error.Fail()) 653 { 654 const char *error_string = error.AsCString(); 655 if (error_string == NULL) 656 error_string = "unable to launch " DEBUGSERVER_BASENAME; 657 658 SetExitStatus (-1, error_string); 659 } 660 else 661 { 662 error = ConnectToDebugserver (host_port); 663 if (error.Success()) 664 { 665 char packet[64]; 666 const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%x", attach_pid); 667 StringExtractorGDBRemote response; 668 StateType stop_state = m_gdb_comm.SendContinuePacketAndWaitForResponse (this, 669 packet, 670 packet_len, 671 response); 672 switch (stop_state) 673 { 674 case eStateStopped: 675 case eStateCrashed: 676 case eStateSuspended: 677 SetID (attach_pid); 678 m_last_stop_packet = response; 679 m_last_stop_packet.SetFilePos (0); 680 SetPrivateState (stop_state); 681 break; 682 683 case eStateExited: 684 m_last_stop_packet = response; 685 m_last_stop_packet.SetFilePos (0); 686 response.SetFilePos(1); 687 SetExitStatus(response.GetHexU8(), NULL); 688 break; 689 690 default: 691 SetExitStatus(-1, "unable to attach to process"); 692 break; 693 } 694 695 } 696 } 697 } 698 699 lldb::pid_t pid = GetID(); 700 if (pid == LLDB_INVALID_PROCESS_ID) 701 { 702 KillDebugserverProcess(); 703 } 704 return error; 705 } 706 707 size_t 708 ProcessGDBRemote::AttachInputReaderCallback 709 ( 710 void *baton, 711 InputReader *reader, 712 lldb::InputReaderAction notification, 713 const char *bytes, 714 size_t bytes_len 715 ) 716 { 717 if (notification == eInputReaderGotToken) 718 { 719 ProcessGDBRemote *gdb_process = (ProcessGDBRemote *)baton; 720 if (gdb_process->m_waiting_for_attach) 721 gdb_process->m_waiting_for_attach = false; 722 reader->SetIsDone(true); 723 return 1; 724 } 725 return 0; 726 } 727 728 Error 729 ProcessGDBRemote::DoAttachToProcessWithName (const char *process_name, bool wait_for_launch) 730 { 731 Error error; 732 // Clear out and clean up from any current state 733 Clear(); 734 // HACK: require arch be set correctly at the target level until we can 735 // figure out a good way to determine the arch of what we are attaching to 736 737 //LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 738 if (process_name && process_name[0]) 739 { 740 char host_port[128]; 741 ArchSpec arch_spec = GetTarget().GetArchitecture(); 742 snprintf (host_port, sizeof(host_port), "localhost:%u", get_random_port ()); 743 error = StartDebugserverProcess (host_port, // debugserver_url 744 NULL, // inferior_argv 745 NULL, // inferior_envp 746 NULL, // stdin_path 747 false, // launch_process == false (we are attaching) 748 LLDB_INVALID_PROCESS_ID, // Don't send any attach to pid options to debugserver 749 NULL, // Don't send any attach by process name option to debugserver 750 false, // Don't send any attach wait_for_launch flag as an option to debugserver 751 0, // launch_flags 752 arch_spec); 753 if (error.Fail()) 754 { 755 const char *error_string = error.AsCString(); 756 if (error_string == NULL) 757 error_string = "unable to launch " DEBUGSERVER_BASENAME; 758 759 SetExitStatus (-1, error_string); 760 } 761 else 762 { 763 error = ConnectToDebugserver (host_port); 764 if (error.Success()) 765 { 766 StreamString packet; 767 768 if (wait_for_launch) 769 packet.PutCString("vAttachWait"); 770 else 771 packet.PutCString("vAttachName"); 772 packet.PutChar(';'); 773 packet.PutBytesAsRawHex8(process_name, strlen(process_name), eByteOrderHost, eByteOrderHost); 774 StringExtractorGDBRemote response; 775 StateType stop_state = m_gdb_comm.SendContinuePacketAndWaitForResponse (this, 776 packet.GetData(), 777 packet.GetSize(), 778 response); 779 switch (stop_state) 780 { 781 case eStateStopped: 782 case eStateCrashed: 783 case eStateSuspended: 784 SetID (m_gdb_comm.GetCurrentProcessID(m_packet_timeout)); 785 m_last_stop_packet = response; 786 m_last_stop_packet.SetFilePos (0); 787 SetPrivateState (stop_state); 788 break; 789 790 case eStateExited: 791 m_last_stop_packet = response; 792 m_last_stop_packet.SetFilePos (0); 793 response.SetFilePos(1); 794 SetExitStatus(response.GetHexU8(), NULL); 795 break; 796 797 default: 798 SetExitStatus(-1, "unable to attach to process"); 799 break; 800 } 801 } 802 } 803 } 804 805 lldb::pid_t pid = GetID(); 806 if (pid == LLDB_INVALID_PROCESS_ID) 807 { 808 KillDebugserverProcess(); 809 810 if (error.Success()) 811 error.SetErrorStringWithFormat("unable to attach to process named '%s'", process_name); 812 } 813 814 return error; 815 } 816 817 // 818 // if (wait_for_launch) 819 // { 820 // InputReaderSP reader_sp (new InputReader()); 821 // StreamString instructions; 822 // instructions.Printf("Hit any key to cancel waiting for '%s' to launch...", process_name); 823 // error = reader_sp->Initialize (AttachInputReaderCallback, // callback 824 // this, // baton 825 // eInputReaderGranularityByte, 826 // NULL, // End token 827 // false); 828 // 829 // StringExtractorGDBRemote response; 830 // m_waiting_for_attach = true; 831 // FILE *reader_out_fh = reader_sp->GetOutputFileHandle(); 832 // while (m_waiting_for_attach) 833 // { 834 // // Wait for one second for the stop reply packet 835 // if (m_gdb_comm.WaitForPacket(response, 1)) 836 // { 837 // // Got some sort of packet, see if it is the stop reply packet? 838 // char ch = response.GetChar(0); 839 // if (ch == 'T') 840 // { 841 // m_waiting_for_attach = false; 842 // } 843 // } 844 // else 845 // { 846 // // Put a period character every second 847 // fputc('.', reader_out_fh); 848 // } 849 // } 850 // } 851 // } 852 // return GetID(); 853 //} 854 855 void 856 ProcessGDBRemote::DidAttach () 857 { 858 if (m_dynamic_loader_ap.get()) 859 m_dynamic_loader_ap->DidAttach(); 860 DidLaunchOrAttach (); 861 } 862 863 Error 864 ProcessGDBRemote::WillResume () 865 { 866 m_continue_packet.Clear(); 867 // Start the continue packet we will use to run the target. Each thread 868 // will append what it is supposed to be doing to this packet when the 869 // ThreadList::WillResume() is called. If a thread it supposed 870 // to stay stopped, then don't append anything to this string. 871 m_continue_packet.Printf("vCont"); 872 return Error(); 873 } 874 875 Error 876 ProcessGDBRemote::DoResume () 877 { 878 Error error; 879 ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::Resume()"); 880 881 Listener listener ("gdb-remote.resume-packet-sent"); 882 if (listener.StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent)) 883 { 884 EventSP event_sp; 885 TimeValue timeout; 886 timeout = TimeValue::Now(); 887 timeout.OffsetWithSeconds (5); 888 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (m_continue_packet.GetData(), m_continue_packet.GetSize())); 889 890 if (listener.WaitForEvent (&timeout, event_sp) == false) 891 error.SetErrorString("Resume timed out."); 892 } 893 894 return error; 895 } 896 897 size_t 898 ProcessGDBRemote::GetSoftwareBreakpointTrapOpcode (BreakpointSite* bp_site) 899 { 900 const uint8_t *trap_opcode = NULL; 901 uint32_t trap_opcode_size = 0; 902 903 static const uint8_t g_arm_breakpoint_opcode[] = { 0xFE, 0xDE, 0xFF, 0xE7 }; 904 //static const uint8_t g_thumb_breakpooint_opcode[] = { 0xFE, 0xDE }; 905 static const uint8_t g_ppc_breakpoint_opcode[] = { 0x7F, 0xC0, 0x00, 0x08 }; 906 static const uint8_t g_i386_breakpoint_opcode[] = { 0xCC }; 907 908 ArchSpec::CPU arch_cpu = GetTarget().GetArchitecture().GetGenericCPUType(); 909 switch (arch_cpu) 910 { 911 case ArchSpec::eCPU_i386: 912 case ArchSpec::eCPU_x86_64: 913 trap_opcode = g_i386_breakpoint_opcode; 914 trap_opcode_size = sizeof(g_i386_breakpoint_opcode); 915 break; 916 917 case ArchSpec::eCPU_arm: 918 // TODO: fill this in for ARM. We need to dig up the symbol for 919 // the address in the breakpoint locaiton and figure out if it is 920 // an ARM or Thumb breakpoint. 921 trap_opcode = g_arm_breakpoint_opcode; 922 trap_opcode_size = sizeof(g_arm_breakpoint_opcode); 923 break; 924 925 case ArchSpec::eCPU_ppc: 926 case ArchSpec::eCPU_ppc64: 927 trap_opcode = g_ppc_breakpoint_opcode; 928 trap_opcode_size = sizeof(g_ppc_breakpoint_opcode); 929 break; 930 931 default: 932 assert(!"Unhandled architecture in ProcessMacOSX::GetSoftwareBreakpointTrapOpcode()"); 933 break; 934 } 935 936 if (trap_opcode && trap_opcode_size) 937 { 938 if (bp_site->SetTrapOpcode(trap_opcode, trap_opcode_size)) 939 return trap_opcode_size; 940 } 941 return 0; 942 } 943 944 uint32_t 945 ProcessGDBRemote::UpdateThreadListIfNeeded () 946 { 947 // locker will keep a mutex locked until it goes out of scope 948 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_THREAD)); 949 if (log && log->GetMask().Test(GDBR_LOG_VERBOSE)) 950 log->Printf ("ProcessGDBRemote::%s (pid = %i)", __FUNCTION__, GetID()); 951 952 Mutex::Locker locker (m_thread_list.GetMutex ()); 953 const uint32_t stop_id = GetStopID(); 954 if (m_thread_list.GetSize(false) == 0 || stop_id != m_thread_list.GetStopID()) 955 { 956 // Update the thread list's stop id immediately so we don't recurse into this function. 957 ThreadList curr_thread_list (this); 958 curr_thread_list.SetStopID(stop_id); 959 960 Error err; 961 StringExtractorGDBRemote response; 962 for (m_gdb_comm.SendPacketAndWaitForResponse("qfThreadInfo", response, 1, false); 963 response.IsNormalPacket(); 964 m_gdb_comm.SendPacketAndWaitForResponse("qsThreadInfo", response, 1, false)) 965 { 966 char ch = response.GetChar(); 967 if (ch == 'l') 968 break; 969 if (ch == 'm') 970 { 971 do 972 { 973 tid_t tid = response.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID); 974 975 if (tid != LLDB_INVALID_THREAD_ID) 976 { 977 ThreadSP thread_sp (GetThreadList().FindThreadByID (tid, false)); 978 if (!thread_sp) 979 thread_sp.reset (new ThreadGDBRemote (*this, tid)); 980 curr_thread_list.AddThread(thread_sp); 981 } 982 983 ch = response.GetChar(); 984 } while (ch == ','); 985 } 986 } 987 988 m_thread_list = curr_thread_list; 989 990 SetThreadStopInfo (m_last_stop_packet); 991 } 992 return GetThreadList().GetSize(false); 993 } 994 995 996 StateType 997 ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet) 998 { 999 const char stop_type = stop_packet.GetChar(); 1000 switch (stop_type) 1001 { 1002 case 'T': 1003 case 'S': 1004 { 1005 // Stop with signal and thread info 1006 const uint8_t signo = stop_packet.GetHexU8(); 1007 std::string name; 1008 std::string value; 1009 std::string thread_name; 1010 uint32_t exc_type = 0; 1011 std::vector<addr_t> exc_data; 1012 uint32_t tid = LLDB_INVALID_THREAD_ID; 1013 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS; 1014 uint32_t exc_data_count = 0; 1015 ThreadSP thread_sp; 1016 1017 while (stop_packet.GetNameColonValue(name, value)) 1018 { 1019 if (name.compare("metype") == 0) 1020 { 1021 // exception type in big endian hex 1022 exc_type = Args::StringToUInt32 (value.c_str(), 0, 16); 1023 } 1024 else if (name.compare("mecount") == 0) 1025 { 1026 // exception count in big endian hex 1027 exc_data_count = Args::StringToUInt32 (value.c_str(), 0, 16); 1028 } 1029 else if (name.compare("medata") == 0) 1030 { 1031 // exception data in big endian hex 1032 exc_data.push_back(Args::StringToUInt64 (value.c_str(), 0, 16)); 1033 } 1034 else if (name.compare("thread") == 0) 1035 { 1036 // thread in big endian hex 1037 tid = Args::StringToUInt32 (value.c_str(), 0, 16); 1038 thread_sp = m_thread_list.FindThreadByID(tid, false); 1039 } 1040 else if (name.compare("hexname") == 0) 1041 { 1042 StringExtractor name_extractor; 1043 // Swap "value" over into "name_extractor" 1044 name_extractor.GetStringRef().swap(value); 1045 // Now convert the HEX bytes into a string value 1046 name_extractor.GetHexByteString (value); 1047 thread_name.swap (value); 1048 } 1049 else if (name.compare("name") == 0) 1050 { 1051 thread_name.swap (value); 1052 } 1053 else if (name.compare("qaddr") == 0) 1054 { 1055 thread_dispatch_qaddr = Args::StringToUInt64 (value.c_str(), 0, 16); 1056 } 1057 else if (name.size() == 2 && ::isxdigit(name[0]) && ::isxdigit(name[1])) 1058 { 1059 // We have a register number that contains an expedited 1060 // register value. Lets supply this register to our thread 1061 // so it won't have to go and read it. 1062 if (thread_sp) 1063 { 1064 uint32_t reg = Args::StringToUInt32 (name.c_str(), UINT32_MAX, 16); 1065 1066 if (reg != UINT32_MAX) 1067 { 1068 StringExtractor reg_value_extractor; 1069 // Swap "value" over into "reg_value_extractor" 1070 reg_value_extractor.GetStringRef().swap(value); 1071 static_cast<ThreadGDBRemote *> (thread_sp.get())->PrivateSetRegisterValue (reg, reg_value_extractor); 1072 } 1073 } 1074 } 1075 } 1076 1077 if (thread_sp) 1078 { 1079 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get()); 1080 1081 gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr); 1082 gdb_thread->SetName (thread_name.empty() ? thread_name.c_str() : NULL); 1083 if (exc_type != 0) 1084 { 1085 const size_t exc_data_count = exc_data.size(); 1086 1087 gdb_thread->SetStopInfo (StopInfoMachException::CreateStopReasonWithMachException (*thread_sp, 1088 exc_type, 1089 exc_data_count, 1090 exc_data_count >= 1 ? exc_data[0] : 0, 1091 exc_data_count >= 2 ? exc_data[1] : 0)); 1092 } 1093 else if (signo) 1094 { 1095 gdb_thread->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo)); 1096 } 1097 else 1098 { 1099 StopInfoSP invalid_stop_info_sp; 1100 gdb_thread->SetStopInfo (invalid_stop_info_sp); 1101 } 1102 } 1103 return eStateStopped; 1104 } 1105 break; 1106 1107 case 'W': 1108 // process exited 1109 return eStateExited; 1110 1111 default: 1112 break; 1113 } 1114 return eStateInvalid; 1115 } 1116 1117 void 1118 ProcessGDBRemote::RefreshStateAfterStop () 1119 { 1120 // FIXME - add a variable to tell that we're in the middle of attaching if we 1121 // need to know that. 1122 // We must be attaching if we don't already have a valid architecture 1123 // if (!GetTarget().GetArchitecture().IsValid()) 1124 // { 1125 // Module *exe_module = GetTarget().GetExecutableModule().get(); 1126 // if (exe_module) 1127 // m_arch_spec = exe_module->GetArchitecture(); 1128 // } 1129 1130 // Let all threads recover from stopping and do any clean up based 1131 // on the previous thread state (if any). 1132 m_thread_list.RefreshStateAfterStop(); 1133 1134 // Discover new threads: 1135 UpdateThreadListIfNeeded (); 1136 } 1137 1138 Error 1139 ProcessGDBRemote::DoHalt (bool &caused_stop) 1140 { 1141 Error error; 1142 1143 if (m_gdb_comm.IsRunning()) 1144 { 1145 caused_stop = true; 1146 bool timed_out = false; 1147 Mutex::Locker locker; 1148 1149 if (!m_gdb_comm.SendInterrupt (locker, 2, &timed_out)) 1150 { 1151 if (timed_out) 1152 error.SetErrorString("timed out sending interrupt packet"); 1153 else 1154 error.SetErrorString("unknown error sending interrupt packet"); 1155 } 1156 } 1157 else 1158 { 1159 caused_stop = false; 1160 } 1161 1162 return error; 1163 } 1164 1165 Error 1166 ProcessGDBRemote::WillDetach () 1167 { 1168 Error error; 1169 1170 if (m_gdb_comm.IsRunning()) 1171 { 1172 bool timed_out = false; 1173 Mutex::Locker locker; 1174 PausePrivateStateThread(); 1175 m_thread_list.DiscardThreadPlans(); 1176 m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 1177 if (!m_gdb_comm.SendInterrupt (locker, 2, &timed_out)) 1178 { 1179 if (timed_out) 1180 error.SetErrorString("timed out sending interrupt packet"); 1181 else 1182 error.SetErrorString("unknown error sending interrupt packet"); 1183 ResumePrivateStateThread(); 1184 } 1185 TimeValue timeout_time; 1186 timeout_time = TimeValue::Now(); 1187 timeout_time.OffsetWithSeconds(2); 1188 1189 EventSP event_sp; 1190 StateType state = WaitForStateChangedEventsPrivate (&timeout_time, event_sp); 1191 if (state != eStateStopped) 1192 error.SetErrorString("unable to stop target"); 1193 } 1194 return error; 1195 } 1196 1197 Error 1198 ProcessGDBRemote::DoDetach() 1199 { 1200 Error error; 1201 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 1202 if (log) 1203 log->Printf ("ProcessGDBRemote::DoDetach()"); 1204 1205 DisableAllBreakpointSites (); 1206 1207 m_thread_list.DiscardThreadPlans(); 1208 1209 size_t response_size = m_gdb_comm.SendPacket ("D", 1); 1210 if (log) 1211 { 1212 if (response_size) 1213 log->PutCString ("ProcessGDBRemote::DoDetach() detach packet sent successfully"); 1214 else 1215 log->PutCString ("ProcessGDBRemote::DoDetach() detach packet send failed"); 1216 } 1217 // Sleep for one second to let the process get all detached... 1218 StopAsyncThread (); 1219 1220 m_gdb_comm.StopReadThread(); 1221 m_gdb_comm.Disconnect(); // Disconnect from the debug server. 1222 1223 SetPrivateState (eStateDetached); 1224 ResumePrivateStateThread(); 1225 1226 //KillDebugserverProcess (); 1227 return error; 1228 } 1229 1230 Error 1231 ProcessGDBRemote::DoDestroy () 1232 { 1233 Error error; 1234 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 1235 if (log) 1236 log->Printf ("ProcessGDBRemote::DoDestroy()"); 1237 1238 // Interrupt if our inferior is running... 1239 Mutex::Locker locker; 1240 m_gdb_comm.SendInterrupt (locker, 1); 1241 DisableAllBreakpointSites (); 1242 SetExitStatus(-1, "process killed"); 1243 1244 StringExtractorGDBRemote response; 1245 if (m_gdb_comm.SendPacketAndWaitForResponse("k", response, 1, false)) 1246 { 1247 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS); 1248 if (log) 1249 { 1250 if (response.IsOKPacket()) 1251 log->Printf ("ProcessGDBRemote::DoDestroy() kill was successful"); 1252 else 1253 log->Printf ("ProcessGDBRemote::DoDestroy() kill failed: %s", response.GetStringRef().c_str()); 1254 } 1255 } 1256 1257 StopAsyncThread (); 1258 m_gdb_comm.StopReadThread(); 1259 KillDebugserverProcess (); 1260 m_gdb_comm.Disconnect(); // Disconnect from the debug server. 1261 return error; 1262 } 1263 1264 //------------------------------------------------------------------ 1265 // Process Queries 1266 //------------------------------------------------------------------ 1267 1268 bool 1269 ProcessGDBRemote::IsAlive () 1270 { 1271 return m_gdb_comm.IsConnected() && m_private_state.GetValue() != eStateExited; 1272 } 1273 1274 addr_t 1275 ProcessGDBRemote::GetImageInfoAddress() 1276 { 1277 if (!m_gdb_comm.IsRunning()) 1278 { 1279 StringExtractorGDBRemote response; 1280 if (m_gdb_comm.SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, 2, false)) 1281 { 1282 if (response.IsNormalPacket()) 1283 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 1284 } 1285 } 1286 return LLDB_INVALID_ADDRESS; 1287 } 1288 1289 DynamicLoader * 1290 ProcessGDBRemote::GetDynamicLoader() 1291 { 1292 return m_dynamic_loader_ap.get(); 1293 } 1294 1295 //------------------------------------------------------------------ 1296 // Process Memory 1297 //------------------------------------------------------------------ 1298 size_t 1299 ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &error) 1300 { 1301 if (size > m_max_memory_size) 1302 { 1303 // Keep memory read sizes down to a sane limit. This function will be 1304 // called multiple times in order to complete the task by 1305 // lldb_private::Process so it is ok to do this. 1306 size = m_max_memory_size; 1307 } 1308 1309 char packet[64]; 1310 const int packet_len = ::snprintf (packet, sizeof(packet), "m%llx,%zx", (uint64_t)addr, size); 1311 assert (packet_len + 1 < sizeof(packet)); 1312 StringExtractorGDBRemote response; 1313 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, true)) 1314 { 1315 if (response.IsNormalPacket()) 1316 { 1317 error.Clear(); 1318 return response.GetHexBytes(buf, size, '\xdd'); 1319 } 1320 else if (response.IsErrorPacket()) 1321 error.SetErrorStringWithFormat("gdb remote returned an error: %s", response.GetStringRef().c_str()); 1322 else if (response.IsUnsupportedPacket()) 1323 error.SetErrorStringWithFormat("'%s' packet unsupported", packet); 1324 else 1325 error.SetErrorStringWithFormat("unexpected response to '%s': '%s'", packet, response.GetStringRef().c_str()); 1326 } 1327 else 1328 { 1329 error.SetErrorStringWithFormat("failed to sent packet: '%s'", packet); 1330 } 1331 return 0; 1332 } 1333 1334 size_t 1335 ProcessGDBRemote::DoWriteMemory (addr_t addr, const void *buf, size_t size, Error &error) 1336 { 1337 StreamString packet; 1338 packet.Printf("M%llx,%zx:", addr, size); 1339 packet.PutBytesAsRawHex8(buf, size, eByteOrderHost, eByteOrderHost); 1340 StringExtractorGDBRemote response; 1341 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, 2, true)) 1342 { 1343 if (response.IsOKPacket()) 1344 { 1345 error.Clear(); 1346 return size; 1347 } 1348 else if (response.IsErrorPacket()) 1349 error.SetErrorStringWithFormat("gdb remote returned an error: %s", response.GetStringRef().c_str()); 1350 else if (response.IsUnsupportedPacket()) 1351 error.SetErrorStringWithFormat("'%s' packet unsupported", packet.GetString().c_str()); 1352 else 1353 error.SetErrorStringWithFormat("unexpected response to '%s': '%s'", packet.GetString().c_str(), response.GetStringRef().c_str()); 1354 } 1355 else 1356 { 1357 error.SetErrorStringWithFormat("failed to sent packet: '%s'", packet.GetString().c_str()); 1358 } 1359 return 0; 1360 } 1361 1362 lldb::addr_t 1363 ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &error) 1364 { 1365 addr_t allocated_addr = m_gdb_comm.AllocateMemory (size, permissions, m_packet_timeout); 1366 if (allocated_addr == LLDB_INVALID_ADDRESS) 1367 error.SetErrorStringWithFormat("unable to allocate %zu bytes of memory with permissions %u", size, permissions); 1368 else 1369 error.Clear(); 1370 return allocated_addr; 1371 } 1372 1373 Error 1374 ProcessGDBRemote::DoDeallocateMemory (lldb::addr_t addr) 1375 { 1376 Error error; 1377 if (!m_gdb_comm.DeallocateMemory (addr, m_packet_timeout)) 1378 error.SetErrorStringWithFormat("unable to deallocate memory at 0x%llx", addr); 1379 return error; 1380 } 1381 1382 1383 //------------------------------------------------------------------ 1384 // Process STDIO 1385 //------------------------------------------------------------------ 1386 1387 size_t 1388 ProcessGDBRemote::GetSTDOUT (char *buf, size_t buf_size, Error &error) 1389 { 1390 Mutex::Locker locker(m_stdio_mutex); 1391 size_t bytes_available = m_stdout_data.size(); 1392 if (bytes_available > 0) 1393 { 1394 ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::%s (&%p[%u]) ...", __FUNCTION__, buf, buf_size); 1395 if (bytes_available > buf_size) 1396 { 1397 memcpy(buf, m_stdout_data.c_str(), buf_size); 1398 m_stdout_data.erase(0, buf_size); 1399 bytes_available = buf_size; 1400 } 1401 else 1402 { 1403 memcpy(buf, m_stdout_data.c_str(), bytes_available); 1404 m_stdout_data.clear(); 1405 1406 //ResetEventBits(eBroadcastBitSTDOUT); 1407 } 1408 } 1409 return bytes_available; 1410 } 1411 1412 size_t 1413 ProcessGDBRemote::GetSTDERR (char *buf, size_t buf_size, Error &error) 1414 { 1415 // Can we get STDERR through the remote protocol? 1416 return 0; 1417 } 1418 1419 size_t 1420 ProcessGDBRemote::PutSTDIN (const char *src, size_t src_len, Error &error) 1421 { 1422 if (m_stdio_communication.IsConnected()) 1423 { 1424 ConnectionStatus status; 1425 m_stdio_communication.Write(src, src_len, status, NULL); 1426 } 1427 return 0; 1428 } 1429 1430 Error 1431 ProcessGDBRemote::EnableBreakpoint (BreakpointSite *bp_site) 1432 { 1433 Error error; 1434 assert (bp_site != NULL); 1435 1436 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS)); 1437 user_id_t site_id = bp_site->GetID(); 1438 const addr_t addr = bp_site->GetLoadAddress(); 1439 if (log) 1440 log->Printf ("ProcessGDBRemote::EnableBreakpoint (size_id = %d) address = 0x%llx", site_id, (uint64_t)addr); 1441 1442 if (bp_site->IsEnabled()) 1443 { 1444 if (log) 1445 log->Printf ("ProcessGDBRemote::EnableBreakpoint (size_id = %d) address = 0x%llx -- SUCCESS (already enabled)", site_id, (uint64_t)addr); 1446 return error; 1447 } 1448 else 1449 { 1450 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site); 1451 1452 if (bp_site->HardwarePreferred()) 1453 { 1454 // Try and set hardware breakpoint, and if that fails, fall through 1455 // and set a software breakpoint? 1456 } 1457 1458 if (m_z0_supported) 1459 { 1460 char packet[64]; 1461 const int packet_len = ::snprintf (packet, sizeof(packet), "Z0,%llx,%zx", addr, bp_op_size); 1462 assert (packet_len + 1 < sizeof(packet)); 1463 StringExtractorGDBRemote response; 1464 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, true)) 1465 { 1466 if (response.IsUnsupportedPacket()) 1467 { 1468 // Disable z packet support and try again 1469 m_z0_supported = 0; 1470 return EnableBreakpoint (bp_site); 1471 } 1472 else if (response.IsOKPacket()) 1473 { 1474 bp_site->SetEnabled(true); 1475 bp_site->SetType (BreakpointSite::eExternal); 1476 return error; 1477 } 1478 else 1479 { 1480 uint8_t error_byte = response.GetError(); 1481 if (error_byte) 1482 error.SetErrorStringWithFormat("%x packet failed with error: %i (0x%2.2x).\n", packet, error_byte, error_byte); 1483 } 1484 } 1485 } 1486 else 1487 { 1488 return EnableSoftwareBreakpoint (bp_site); 1489 } 1490 } 1491 1492 if (log) 1493 { 1494 const char *err_string = error.AsCString(); 1495 log->Printf ("ProcessGDBRemote::EnableBreakpoint() error for breakpoint at 0x%8.8llx: %s", 1496 bp_site->GetLoadAddress(), 1497 err_string ? err_string : "NULL"); 1498 } 1499 // We shouldn't reach here on a successful breakpoint enable... 1500 if (error.Success()) 1501 error.SetErrorToGenericError(); 1502 return error; 1503 } 1504 1505 Error 1506 ProcessGDBRemote::DisableBreakpoint (BreakpointSite *bp_site) 1507 { 1508 Error error; 1509 assert (bp_site != NULL); 1510 addr_t addr = bp_site->GetLoadAddress(); 1511 user_id_t site_id = bp_site->GetID(); 1512 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS)); 1513 if (log) 1514 log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx", site_id, (uint64_t)addr); 1515 1516 if (bp_site->IsEnabled()) 1517 { 1518 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site); 1519 1520 if (bp_site->IsHardware()) 1521 { 1522 // TODO: disable hardware breakpoint... 1523 } 1524 else 1525 { 1526 if (m_z0_supported) 1527 { 1528 char packet[64]; 1529 const int packet_len = ::snprintf (packet, sizeof(packet), "z0,%llx,%zx", addr, bp_op_size); 1530 assert (packet_len + 1 < sizeof(packet)); 1531 StringExtractorGDBRemote response; 1532 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, true)) 1533 { 1534 if (response.IsUnsupportedPacket()) 1535 { 1536 error.SetErrorString("Breakpoint site was set with Z packet, yet remote debugserver states z packets are not supported."); 1537 } 1538 else if (response.IsOKPacket()) 1539 { 1540 if (log) 1541 log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx -- SUCCESS", site_id, (uint64_t)addr); 1542 bp_site->SetEnabled(false); 1543 return error; 1544 } 1545 else 1546 { 1547 uint8_t error_byte = response.GetError(); 1548 if (error_byte) 1549 error.SetErrorStringWithFormat("%x packet failed with error: %i (0x%2.2x).\n", packet, error_byte, error_byte); 1550 } 1551 } 1552 } 1553 else 1554 { 1555 return DisableSoftwareBreakpoint (bp_site); 1556 } 1557 } 1558 } 1559 else 1560 { 1561 if (log) 1562 log->Printf ("ProcessGDBRemote::DisableBreakpoint (site_id = %d) addr = 0x%8.8llx -- SUCCESS (already disabled)", site_id, (uint64_t)addr); 1563 return error; 1564 } 1565 1566 if (error.Success()) 1567 error.SetErrorToGenericError(); 1568 return error; 1569 } 1570 1571 Error 1572 ProcessGDBRemote::EnableWatchpoint (WatchpointLocation *wp) 1573 { 1574 Error error; 1575 if (wp) 1576 { 1577 user_id_t watchID = wp->GetID(); 1578 addr_t addr = wp->GetLoadAddress(); 1579 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS)); 1580 if (log) 1581 log->Printf ("ProcessGDBRemote::EnableWatchpoint(watchID = %d)", watchID); 1582 if (wp->IsEnabled()) 1583 { 1584 if (log) 1585 log->Printf("ProcessGDBRemote::EnableWatchpoint(watchID = %d) addr = 0x%8.8llx: watchpoint already enabled.", watchID, (uint64_t)addr); 1586 return error; 1587 } 1588 else 1589 { 1590 // Pass down an appropriate z/Z packet... 1591 error.SetErrorString("watchpoints not supported"); 1592 } 1593 } 1594 else 1595 { 1596 error.SetErrorString("Watchpoint location argument was NULL."); 1597 } 1598 if (error.Success()) 1599 error.SetErrorToGenericError(); 1600 return error; 1601 } 1602 1603 Error 1604 ProcessGDBRemote::DisableWatchpoint (WatchpointLocation *wp) 1605 { 1606 Error error; 1607 if (wp) 1608 { 1609 user_id_t watchID = wp->GetID(); 1610 1611 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS)); 1612 1613 addr_t addr = wp->GetLoadAddress(); 1614 if (log) 1615 log->Printf ("ProcessGDBRemote::DisableWatchpoint (watchID = %d) addr = 0x%8.8llx", watchID, (uint64_t)addr); 1616 1617 if (wp->IsHardware()) 1618 { 1619 // Pass down an appropriate z/Z packet... 1620 error.SetErrorString("watchpoints not supported"); 1621 } 1622 // TODO: clear software watchpoints if we implement them 1623 } 1624 else 1625 { 1626 error.SetErrorString("Watchpoint location argument was NULL."); 1627 } 1628 if (error.Success()) 1629 error.SetErrorToGenericError(); 1630 return error; 1631 } 1632 1633 void 1634 ProcessGDBRemote::Clear() 1635 { 1636 m_flags = 0; 1637 m_thread_list.Clear(); 1638 { 1639 Mutex::Locker locker(m_stdio_mutex); 1640 m_stdout_data.clear(); 1641 } 1642 } 1643 1644 Error 1645 ProcessGDBRemote::DoSignal (int signo) 1646 { 1647 Error error; 1648 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 1649 if (log) 1650 log->Printf ("ProcessGDBRemote::DoSignal (signal = %d)", signo); 1651 1652 if (!m_gdb_comm.SendAsyncSignal (signo)) 1653 error.SetErrorStringWithFormat("failed to send signal %i", signo); 1654 return error; 1655 } 1656 1657 //void 1658 //ProcessGDBRemote::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len) 1659 //{ 1660 // ProcessGDBRemote *process = (ProcessGDBRemote *)baton; 1661 // process->AppendSTDOUT(static_cast<const char *>(src), src_len); 1662 //} 1663 1664 //void 1665 //ProcessGDBRemote::AppendSTDOUT (const char* s, size_t len) 1666 //{ 1667 // ProcessGDBRemoteLog::LogIf (GDBR_LOG_PROCESS, "ProcessGDBRemote::%s (<%d> %s) ...", __FUNCTION__, len, s); 1668 // Mutex::Locker locker(m_stdio_mutex); 1669 // m_stdout_data.append(s, len); 1670 // 1671 // // FIXME: Make a real data object for this and put it out. 1672 // BroadcastEventIfUnique (eBroadcastBitSTDOUT); 1673 //} 1674 1675 1676 Error 1677 ProcessGDBRemote::StartDebugserverProcess 1678 ( 1679 const char *debugserver_url, // The connection string to use in the spawned debugserver ("localhost:1234" or "/dev/tty...") 1680 char const *inferior_argv[], // Arguments for the inferior program including the path to the inferior itself as the first argument 1681 char const *inferior_envp[], // Environment to pass along to the inferior program 1682 char const *stdio_path, 1683 bool launch_process, // Set to true if we are going to be launching a the process 1684 lldb::pid_t attach_pid, // If inferior inferior_argv == NULL, and attach_pid != LLDB_INVALID_PROCESS_ID send this pid as an argument to debugserver 1685 const char *attach_name, // Wait for the next process to launch whose basename matches "attach_name" 1686 bool wait_for_launch, // Wait for the process named "attach_name" to launch 1687 uint32_t launch_flags, // Launch flags 1688 ArchSpec& inferior_arch // The arch of the inferior that we will launch 1689 ) 1690 { 1691 Error error; 1692 bool disable_aslr = (launch_flags & eLaunchFlagDisableASLR) != 0; 1693 bool no_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0; 1694 if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID) 1695 { 1696 // If we locate debugserver, keep that located version around 1697 static FileSpec g_debugserver_file_spec; 1698 1699 FileSpec debugserver_file_spec; 1700 char debugserver_path[PATH_MAX]; 1701 1702 // Always check to see if we have an environment override for the path 1703 // to the debugserver to use and use it if we do. 1704 const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH"); 1705 if (env_debugserver_path) 1706 debugserver_file_spec.SetFile (env_debugserver_path, false); 1707 else 1708 debugserver_file_spec = g_debugserver_file_spec; 1709 bool debugserver_exists = debugserver_file_spec.Exists(); 1710 if (!debugserver_exists) 1711 { 1712 // The debugserver binary is in the LLDB.framework/Resources 1713 // directory. 1714 if (Host::GetLLDBPath (ePathTypeSupportExecutableDir, debugserver_file_spec)) 1715 { 1716 debugserver_file_spec.GetFilename().SetCString(DEBUGSERVER_BASENAME); 1717 debugserver_exists = debugserver_file_spec.Exists(); 1718 if (debugserver_exists) 1719 { 1720 g_debugserver_file_spec = debugserver_file_spec; 1721 } 1722 else 1723 { 1724 g_debugserver_file_spec.Clear(); 1725 debugserver_file_spec.Clear(); 1726 } 1727 } 1728 } 1729 1730 if (debugserver_exists) 1731 { 1732 debugserver_file_spec.GetPath (debugserver_path, sizeof(debugserver_path)); 1733 1734 m_stdio_communication.Clear(); 1735 posix_spawnattr_t attr; 1736 1737 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 1738 1739 Error local_err; // Errors that don't affect the spawning. 1740 if (log) 1741 log->Printf ("%s ( path='%s', argv=%p, envp=%p, arch=%s )", __FUNCTION__, debugserver_path, inferior_argv, inferior_envp, inferior_arch.AsCString()); 1742 error.SetError( ::posix_spawnattr_init (&attr), eErrorTypePOSIX); 1743 if (error.Fail() || log) 1744 error.PutToLog(log.get(), "::posix_spawnattr_init ( &attr )"); 1745 if (error.Fail()) 1746 return error;; 1747 1748 #if !defined (__arm__) 1749 1750 // We don't need to do this for ARM, and we really shouldn't now 1751 // that we have multiple CPU subtypes and no posix_spawnattr call 1752 // that allows us to set which CPU subtype to launch... 1753 if (inferior_arch.GetType() == eArchTypeMachO) 1754 { 1755 cpu_type_t cpu = inferior_arch.GetCPUType(); 1756 if (cpu != 0 && cpu != UINT32_MAX && cpu != LLDB_INVALID_CPUTYPE) 1757 { 1758 size_t ocount = 0; 1759 error.SetError( ::posix_spawnattr_setbinpref_np (&attr, 1, &cpu, &ocount), eErrorTypePOSIX); 1760 if (error.Fail() || log) 1761 error.PutToLog(log.get(), "::posix_spawnattr_setbinpref_np ( &attr, 1, cpu_type = 0x%8.8x, count => %zu )", cpu, ocount); 1762 1763 if (error.Fail() != 0 || ocount != 1) 1764 return error; 1765 } 1766 } 1767 1768 #endif 1769 1770 Args debugserver_args; 1771 char arg_cstr[PATH_MAX]; 1772 1773 lldb_utility::PseudoTerminal pty; 1774 if (launch_process && stdio_path == NULL && m_local_debugserver && !no_stdio) 1775 { 1776 if (pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0)) 1777 stdio_path = pty.GetSlaveName (NULL, 0); 1778 } 1779 1780 // Start args with "debugserver /file/path -r --" 1781 debugserver_args.AppendArgument(debugserver_path); 1782 debugserver_args.AppendArgument(debugserver_url); 1783 // use native registers, not the GDB registers 1784 debugserver_args.AppendArgument("--native-regs"); 1785 // make debugserver run in its own session so signals generated by 1786 // special terminal key sequences (^C) don't affect debugserver 1787 debugserver_args.AppendArgument("--setsid"); 1788 1789 if (disable_aslr) 1790 debugserver_args.AppendArguments("--disable-aslr"); 1791 1792 // Only set the inferior 1793 if (launch_process && stdio_path) 1794 { 1795 debugserver_args.AppendArgument("--stdio-path"); 1796 debugserver_args.AppendArgument(stdio_path); 1797 } 1798 else if (launch_process && no_stdio) 1799 { 1800 debugserver_args.AppendArgument("--no-stdio"); 1801 } 1802 1803 const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE"); 1804 if (env_debugserver_log_file) 1805 { 1806 ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-file=%s", env_debugserver_log_file); 1807 debugserver_args.AppendArgument(arg_cstr); 1808 } 1809 1810 const char *env_debugserver_log_flags = getenv("LLDB_DEBUGSERVER_LOG_FLAGS"); 1811 if (env_debugserver_log_flags) 1812 { 1813 ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags); 1814 debugserver_args.AppendArgument(arg_cstr); 1815 } 1816 // debugserver_args.AppendArgument("--log-file=/tmp/debugserver.txt"); 1817 // debugserver_args.AppendArgument("--log-flags=0x800e0e"); 1818 1819 // Now append the program arguments 1820 if (launch_process) 1821 { 1822 if (inferior_argv) 1823 { 1824 // Terminate the debugserver args so we can now append the inferior args 1825 debugserver_args.AppendArgument("--"); 1826 1827 for (int i = 0; inferior_argv[i] != NULL; ++i) 1828 debugserver_args.AppendArgument (inferior_argv[i]); 1829 } 1830 else 1831 { 1832 // Will send environment entries with the 'QEnvironment:' packet 1833 // Will send arguments with the 'A' packet 1834 } 1835 } 1836 else if (attach_pid != LLDB_INVALID_PROCESS_ID) 1837 { 1838 ::snprintf (arg_cstr, sizeof(arg_cstr), "--attach=%u", attach_pid); 1839 debugserver_args.AppendArgument (arg_cstr); 1840 } 1841 else if (attach_name && attach_name[0]) 1842 { 1843 if (wait_for_launch) 1844 debugserver_args.AppendArgument ("--waitfor"); 1845 else 1846 debugserver_args.AppendArgument ("--attach"); 1847 debugserver_args.AppendArgument (attach_name); 1848 } 1849 1850 Error file_actions_err; 1851 posix_spawn_file_actions_t file_actions; 1852 #if DONT_CLOSE_DEBUGSERVER_STDIO 1853 file_actions_err.SetErrorString ("Remove this after uncommenting the code block below."); 1854 #else 1855 file_actions_err.SetError( ::posix_spawn_file_actions_init (&file_actions), eErrorTypePOSIX); 1856 if (file_actions_err.Success()) 1857 { 1858 ::posix_spawn_file_actions_addclose (&file_actions, STDIN_FILENO); 1859 ::posix_spawn_file_actions_addclose (&file_actions, STDOUT_FILENO); 1860 ::posix_spawn_file_actions_addclose (&file_actions, STDERR_FILENO); 1861 } 1862 #endif 1863 1864 if (log) 1865 { 1866 StreamString strm; 1867 debugserver_args.Dump (&strm); 1868 log->Printf("%s arguments:\n%s", debugserver_args.GetArgumentAtIndex(0), strm.GetData()); 1869 } 1870 1871 error.SetError(::posix_spawnp (&m_debugserver_pid, 1872 debugserver_path, 1873 file_actions_err.Success() ? &file_actions : NULL, 1874 &attr, 1875 debugserver_args.GetArgumentVector(), 1876 (char * const*)inferior_envp), 1877 eErrorTypePOSIX); 1878 1879 1880 ::posix_spawnattr_destroy (&attr); 1881 1882 if (file_actions_err.Success()) 1883 ::posix_spawn_file_actions_destroy (&file_actions); 1884 1885 // We have seen some cases where posix_spawnp was returning a valid 1886 // looking pid even when an error was returned, so clear it out 1887 if (error.Fail()) 1888 m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 1889 1890 if (error.Fail() || log) 1891 error.PutToLog(log.get(), "::posix_spawnp ( pid => %i, path = '%s', file_actions = %p, attr = %p, argv = %p, envp = %p )", m_debugserver_pid, debugserver_path, NULL, &attr, inferior_argv, inferior_envp); 1892 1893 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID && !no_stdio) 1894 { 1895 if (pty.GetMasterFileDescriptor() != lldb_utility::PseudoTerminal::invalid_fd) 1896 SetUpProcessInputReader (pty.ReleaseMasterFileDescriptor()); 1897 } 1898 } 1899 else 1900 { 1901 error.SetErrorStringWithFormat ("Unable to locate " DEBUGSERVER_BASENAME ".\n"); 1902 } 1903 1904 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) 1905 StartAsyncThread (); 1906 } 1907 return error; 1908 } 1909 1910 bool 1911 ProcessGDBRemote::MonitorDebugserverProcess 1912 ( 1913 void *callback_baton, 1914 lldb::pid_t debugserver_pid, 1915 int signo, // Zero for no signal 1916 int exit_status // Exit value of process if signal is zero 1917 ) 1918 { 1919 // We pass in the ProcessGDBRemote inferior process it and name it 1920 // "gdb_remote_pid". The process ID is passed in the "callback_baton" 1921 // pointer value itself, thus we need the double cast... 1922 1923 // "debugserver_pid" argument passed in is the process ID for 1924 // debugserver that we are tracking... 1925 1926 ProcessGDBRemote *process = (ProcessGDBRemote *)callback_baton; 1927 1928 if (process) 1929 { 1930 // Sleep for a half a second to make sure our inferior process has 1931 // time to set its exit status before we set it incorrectly when 1932 // both the debugserver and the inferior process shut down. 1933 usleep (500000); 1934 // If our process hasn't yet exited, debugserver might have died. 1935 // If the process did exit, the we are reaping it. 1936 const StateType state = process->GetState(); 1937 1938 if (process->m_debugserver_pid != LLDB_INVALID_PROCESS_ID && 1939 state != eStateInvalid && 1940 state != eStateUnloaded && 1941 state != eStateExited && 1942 state != eStateDetached) 1943 { 1944 char error_str[1024]; 1945 if (signo) 1946 { 1947 const char *signal_cstr = process->GetUnixSignals().GetSignalAsCString (signo); 1948 if (signal_cstr) 1949 ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %s", signal_cstr); 1950 else 1951 ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with signal %i", signo); 1952 } 1953 else 1954 { 1955 ::snprintf (error_str, sizeof (error_str), DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x", exit_status); 1956 } 1957 1958 process->SetExitStatus (-1, error_str); 1959 } 1960 // Debugserver has exited we need to let our ProcessGDBRemote 1961 // know that it no longer has a debugserver instance 1962 process->m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 1963 // We are returning true to this function below, so we can 1964 // forget about the monitor handle. 1965 process->m_debugserver_thread = LLDB_INVALID_HOST_THREAD; 1966 } 1967 return true; 1968 } 1969 1970 void 1971 ProcessGDBRemote::KillDebugserverProcess () 1972 { 1973 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) 1974 { 1975 ::kill (m_debugserver_pid, SIGINT); 1976 m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 1977 } 1978 } 1979 1980 void 1981 ProcessGDBRemote::Initialize() 1982 { 1983 static bool g_initialized = false; 1984 1985 if (g_initialized == false) 1986 { 1987 g_initialized = true; 1988 PluginManager::RegisterPlugin (GetPluginNameStatic(), 1989 GetPluginDescriptionStatic(), 1990 CreateInstance); 1991 1992 Log::Callbacks log_callbacks = { 1993 ProcessGDBRemoteLog::DisableLog, 1994 ProcessGDBRemoteLog::EnableLog, 1995 ProcessGDBRemoteLog::ListLogCategories 1996 }; 1997 1998 Log::RegisterLogChannel (ProcessGDBRemote::GetPluginNameStatic(), log_callbacks); 1999 } 2000 } 2001 2002 bool 2003 ProcessGDBRemote::SetCurrentGDBRemoteThread (int tid) 2004 { 2005 if (m_curr_tid == tid) 2006 return true; 2007 2008 char packet[32]; 2009 const int packet_len = ::snprintf (packet, sizeof(packet), "Hg%x", tid); 2010 assert (packet_len + 1 < sizeof(packet)); 2011 StringExtractorGDBRemote response; 2012 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, false)) 2013 { 2014 if (response.IsOKPacket()) 2015 { 2016 m_curr_tid = tid; 2017 return true; 2018 } 2019 } 2020 return false; 2021 } 2022 2023 bool 2024 ProcessGDBRemote::SetCurrentGDBRemoteThreadForRun (int tid) 2025 { 2026 if (m_curr_tid_run == tid) 2027 return true; 2028 2029 char packet[32]; 2030 const int packet_len = ::snprintf (packet, sizeof(packet), "Hg%x", tid); 2031 assert (packet_len + 1 < sizeof(packet)); 2032 StringExtractorGDBRemote response; 2033 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, 2, false)) 2034 { 2035 if (response.IsOKPacket()) 2036 { 2037 m_curr_tid_run = tid; 2038 return true; 2039 } 2040 } 2041 return false; 2042 } 2043 2044 void 2045 ProcessGDBRemote::ResetGDBRemoteState () 2046 { 2047 // Reset and GDB remote state 2048 m_curr_tid = LLDB_INVALID_THREAD_ID; 2049 m_curr_tid_run = LLDB_INVALID_THREAD_ID; 2050 m_z0_supported = 1; 2051 } 2052 2053 2054 bool 2055 ProcessGDBRemote::StartAsyncThread () 2056 { 2057 ResetGDBRemoteState (); 2058 2059 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 2060 2061 if (log) 2062 log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__); 2063 2064 // Create a thread that watches our internal state and controls which 2065 // events make it to clients (into the DCProcess event queue). 2066 m_async_thread = Host::ThreadCreate ("<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this, NULL); 2067 return m_async_thread != LLDB_INVALID_HOST_THREAD; 2068 } 2069 2070 void 2071 ProcessGDBRemote::StopAsyncThread () 2072 { 2073 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 2074 2075 if (log) 2076 log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__); 2077 2078 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit); 2079 2080 // Stop the stdio thread 2081 if (m_async_thread != LLDB_INVALID_HOST_THREAD) 2082 { 2083 Host::ThreadJoin (m_async_thread, NULL, NULL); 2084 } 2085 } 2086 2087 2088 void * 2089 ProcessGDBRemote::AsyncThread (void *arg) 2090 { 2091 ProcessGDBRemote *process = (ProcessGDBRemote*) arg; 2092 2093 LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 2094 if (log) 2095 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, arg, process->GetID()); 2096 2097 Listener listener ("ProcessGDBRemote::AsyncThread"); 2098 EventSP event_sp; 2099 const uint32_t desired_event_mask = eBroadcastBitAsyncContinue | 2100 eBroadcastBitAsyncThreadShouldExit; 2101 2102 if (listener.StartListeningForEvents (&process->m_async_broadcaster, desired_event_mask) == desired_event_mask) 2103 { 2104 bool done = false; 2105 while (!done) 2106 { 2107 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS); 2108 if (log) 2109 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg, process->GetID()); 2110 if (listener.WaitForEvent (NULL, event_sp)) 2111 { 2112 const uint32_t event_type = event_sp->GetType(); 2113 if (log) 2114 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) Got an event of type: %d...", __FUNCTION__, arg, process->GetID(), event_type); 2115 2116 switch (event_type) 2117 { 2118 case eBroadcastBitAsyncContinue: 2119 { 2120 const EventDataBytes *continue_packet = EventDataBytes::GetEventDataFromEvent(event_sp.get()); 2121 2122 if (continue_packet) 2123 { 2124 const char *continue_cstr = (const char *)continue_packet->GetBytes (); 2125 const size_t continue_cstr_len = continue_packet->GetByteSize (); 2126 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS); 2127 if (log) 2128 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got eBroadcastBitAsyncContinue: %s", __FUNCTION__, arg, process->GetID(), continue_cstr); 2129 2130 process->SetPrivateState(eStateRunning); 2131 StringExtractorGDBRemote response; 2132 StateType stop_state = process->GetGDBRemote().SendContinuePacketAndWaitForResponse (process, continue_cstr, continue_cstr_len, response); 2133 2134 switch (stop_state) 2135 { 2136 case eStateStopped: 2137 case eStateCrashed: 2138 case eStateSuspended: 2139 process->m_last_stop_packet = response; 2140 process->m_last_stop_packet.SetFilePos (0); 2141 process->SetPrivateState (stop_state); 2142 break; 2143 2144 case eStateExited: 2145 process->m_last_stop_packet = response; 2146 process->m_last_stop_packet.SetFilePos (0); 2147 response.SetFilePos(1); 2148 process->SetExitStatus(response.GetHexU8(), NULL); 2149 done = true; 2150 break; 2151 2152 case eStateInvalid: 2153 break; 2154 2155 default: 2156 process->SetPrivateState (stop_state); 2157 break; 2158 } 2159 } 2160 } 2161 break; 2162 2163 case eBroadcastBitAsyncThreadShouldExit: 2164 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS); 2165 if (log) 2166 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got eBroadcastBitAsyncThreadShouldExit...", __FUNCTION__, arg, process->GetID()); 2167 done = true; 2168 break; 2169 2170 default: 2171 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS); 2172 if (log) 2173 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) got unknown event 0x%8.8x", __FUNCTION__, arg, process->GetID(), event_type); 2174 done = true; 2175 break; 2176 } 2177 } 2178 else 2179 { 2180 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS); 2181 if (log) 2182 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) listener.WaitForEvent (NULL, event_sp) => false", __FUNCTION__, arg, process->GetID()); 2183 done = true; 2184 } 2185 } 2186 } 2187 2188 log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS); 2189 if (log) 2190 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, arg, process->GetID()); 2191 2192 process->m_async_thread = LLDB_INVALID_HOST_THREAD; 2193 return NULL; 2194 } 2195 2196 const char * 2197 ProcessGDBRemote::GetDispatchQueueNameForThread 2198 ( 2199 addr_t thread_dispatch_qaddr, 2200 std::string &dispatch_queue_name 2201 ) 2202 { 2203 dispatch_queue_name.clear(); 2204 if (thread_dispatch_qaddr != 0 && thread_dispatch_qaddr != LLDB_INVALID_ADDRESS) 2205 { 2206 // Cache the dispatch_queue_offsets_addr value so we don't always have 2207 // to look it up 2208 if (m_dispatch_queue_offsets_addr == LLDB_INVALID_ADDRESS) 2209 { 2210 static ConstString g_dispatch_queue_offsets_symbol_name ("dispatch_queue_offsets"); 2211 const Symbol *dispatch_queue_offsets_symbol = NULL; 2212 ModuleSP module_sp(GetTarget().GetImages().FindFirstModuleForFileSpec (FileSpec("libSystem.B.dylib", false))); 2213 if (module_sp) 2214 dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData); 2215 2216 if (dispatch_queue_offsets_symbol == NULL) 2217 { 2218 module_sp = GetTarget().GetImages().FindFirstModuleForFileSpec (FileSpec("libdispatch.dylib", false)); 2219 if (module_sp) 2220 dispatch_queue_offsets_symbol = module_sp->FindFirstSymbolWithNameAndType (g_dispatch_queue_offsets_symbol_name, eSymbolTypeData); 2221 } 2222 if (dispatch_queue_offsets_symbol) 2223 m_dispatch_queue_offsets_addr = dispatch_queue_offsets_symbol->GetValue().GetLoadAddress(&m_target); 2224 2225 if (m_dispatch_queue_offsets_addr == LLDB_INVALID_ADDRESS) 2226 return NULL; 2227 } 2228 2229 uint8_t memory_buffer[8]; 2230 DataExtractor data(memory_buffer, sizeof(memory_buffer), GetByteOrder(), GetAddressByteSize()); 2231 2232 // Excerpt from src/queue_private.h 2233 struct dispatch_queue_offsets_s 2234 { 2235 uint16_t dqo_version; 2236 uint16_t dqo_label; 2237 uint16_t dqo_label_size; 2238 } dispatch_queue_offsets; 2239 2240 2241 Error error; 2242 if (ReadMemory (m_dispatch_queue_offsets_addr, memory_buffer, sizeof(dispatch_queue_offsets), error) == sizeof(dispatch_queue_offsets)) 2243 { 2244 uint32_t data_offset = 0; 2245 if (data.GetU16(&data_offset, &dispatch_queue_offsets.dqo_version, sizeof(dispatch_queue_offsets)/sizeof(uint16_t))) 2246 { 2247 if (ReadMemory (thread_dispatch_qaddr, &memory_buffer, data.GetAddressByteSize(), error) == data.GetAddressByteSize()) 2248 { 2249 data_offset = 0; 2250 lldb::addr_t queue_addr = data.GetAddress(&data_offset); 2251 lldb::addr_t label_addr = queue_addr + dispatch_queue_offsets.dqo_label; 2252 dispatch_queue_name.resize(dispatch_queue_offsets.dqo_label_size, '\0'); 2253 size_t bytes_read = ReadMemory (label_addr, &dispatch_queue_name[0], dispatch_queue_offsets.dqo_label_size, error); 2254 if (bytes_read < dispatch_queue_offsets.dqo_label_size) 2255 dispatch_queue_name.erase (bytes_read); 2256 } 2257 } 2258 } 2259 } 2260 if (dispatch_queue_name.empty()) 2261 return NULL; 2262 return dispatch_queue_name.c_str(); 2263 } 2264 2265 uint32_t 2266 ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids) 2267 { 2268 // If we are planning to launch the debugserver remotely, then we need to fire up a debugserver 2269 // process and ask it for the list of processes. But if we are local, we can let the Host do it. 2270 if (m_local_debugserver) 2271 { 2272 return Host::ListProcessesMatchingName (name, matches, pids); 2273 } 2274 else 2275 { 2276 // FIXME: Implement talking to the remote debugserver. 2277 return 0; 2278 } 2279 2280 } 2281