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 #include "lldb/Host/Config.h" 11 12 // C Includes 13 #include <errno.h> 14 #include <stdlib.h> 15 #ifndef LLDB_DISABLE_POSIX 16 #include <netinet/in.h> 17 #include <sys/mman.h> // for mmap 18 #endif 19 #include <sys/stat.h> 20 #include <sys/types.h> 21 #include <time.h> 22 23 // C++ Includes 24 #include <algorithm> 25 #include <map> 26 #include <mutex> 27 28 #include "lldb/Breakpoint/Watchpoint.h" 29 #include "lldb/Interpreter/Args.h" 30 #include "lldb/Core/ArchSpec.h" 31 #include "lldb/Core/Debugger.h" 32 #include "lldb/Host/ConnectionFileDescriptor.h" 33 #include "lldb/Host/FileSpec.h" 34 #include "lldb/Core/Module.h" 35 #include "lldb/Core/ModuleSpec.h" 36 #include "lldb/Core/PluginManager.h" 37 #include "lldb/Core/State.h" 38 #include "lldb/Core/StreamFile.h" 39 #include "lldb/Core/StreamString.h" 40 #include "lldb/Core/Timer.h" 41 #include "lldb/Core/Value.h" 42 #include "lldb/DataFormatters/FormatManager.h" 43 #include "lldb/Host/FileSystem.h" 44 #include "lldb/Host/HostThread.h" 45 #include "lldb/Host/StringConvert.h" 46 #include "lldb/Host/Symbols.h" 47 #include "lldb/Host/ThreadLauncher.h" 48 #include "lldb/Host/TimeValue.h" 49 #include "lldb/Host/XML.h" 50 #include "lldb/Interpreter/CommandInterpreter.h" 51 #include "lldb/Interpreter/CommandObject.h" 52 #include "lldb/Interpreter/CommandObjectMultiword.h" 53 #include "lldb/Interpreter/CommandReturnObject.h" 54 #include "lldb/Interpreter/OptionValueProperties.h" 55 #include "lldb/Interpreter/Options.h" 56 #include "lldb/Interpreter/OptionGroupBoolean.h" 57 #include "lldb/Interpreter/OptionGroupUInt64.h" 58 #include "lldb/Interpreter/Property.h" 59 #include "lldb/Symbol/ObjectFile.h" 60 #include "lldb/Target/ABI.h" 61 #include "lldb/Target/DynamicLoader.h" 62 #include "lldb/Target/Target.h" 63 #include "lldb/Target/TargetList.h" 64 #include "lldb/Target/ThreadPlanCallFunction.h" 65 #include "lldb/Target/SystemRuntime.h" 66 #include "lldb/Utility/PseudoTerminal.h" 67 68 // Project includes 69 #include "lldb/Host/Host.h" 70 #include "Plugins/Process/Utility/GDBRemoteSignals.h" 71 #include "Plugins/Process/Utility/InferiorCallPOSIX.h" 72 #include "Plugins/Process/Utility/StopInfoMachException.h" 73 #include "Plugins/Platform/MacOSX/PlatformRemoteiOS.h" 74 #include "Utility/StringExtractorGDBRemote.h" 75 #include "GDBRemoteRegisterContext.h" 76 #include "ProcessGDBRemote.h" 77 #include "ProcessGDBRemoteLog.h" 78 #include "ThreadGDBRemote.h" 79 80 #define DEBUGSERVER_BASENAME "debugserver" 81 using namespace lldb; 82 using namespace lldb_private; 83 using namespace lldb_private::process_gdb_remote; 84 85 namespace lldb 86 { 87 // Provide a function that can easily dump the packet history if we know a 88 // ProcessGDBRemote * value (which we can get from logs or from debugging). 89 // We need the function in the lldb namespace so it makes it into the final 90 // executable since the LLDB shared library only exports stuff in the lldb 91 // namespace. This allows you to attach with a debugger and call this 92 // function and get the packet history dumped to a file. 93 void 94 DumpProcessGDBRemotePacketHistory (void *p, const char *path) 95 { 96 StreamFile strm; 97 Error error (strm.GetFile().Open(path, File::eOpenOptionWrite | File::eOpenOptionCanCreate)); 98 if (error.Success()) 99 ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory (strm); 100 } 101 } 102 103 namespace { 104 105 static PropertyDefinition 106 g_properties[] = 107 { 108 { "packet-timeout" , OptionValue::eTypeUInt64 , true , 1, NULL, NULL, "Specify the default packet timeout in seconds." }, 109 { "target-definition-file" , OptionValue::eTypeFileSpec , true, 0 , NULL, NULL, "The file that provides the description for remote target registers." }, 110 { NULL , OptionValue::eTypeInvalid, false, 0, NULL, NULL, NULL } 111 }; 112 113 enum 114 { 115 ePropertyPacketTimeout, 116 ePropertyTargetDefinitionFile 117 }; 118 119 class PluginProperties : public Properties 120 { 121 public: 122 123 static ConstString 124 GetSettingName () 125 { 126 return ProcessGDBRemote::GetPluginNameStatic(); 127 } 128 129 PluginProperties() : 130 Properties () 131 { 132 m_collection_sp.reset (new OptionValueProperties(GetSettingName())); 133 m_collection_sp->Initialize(g_properties); 134 } 135 136 virtual 137 ~PluginProperties() 138 { 139 } 140 141 uint64_t 142 GetPacketTimeout() 143 { 144 const uint32_t idx = ePropertyPacketTimeout; 145 return m_collection_sp->GetPropertyAtIndexAsUInt64(NULL, idx, g_properties[idx].default_uint_value); 146 } 147 148 bool 149 SetPacketTimeout(uint64_t timeout) 150 { 151 const uint32_t idx = ePropertyPacketTimeout; 152 return m_collection_sp->SetPropertyAtIndexAsUInt64(NULL, idx, timeout); 153 } 154 155 FileSpec 156 GetTargetDefinitionFile () const 157 { 158 const uint32_t idx = ePropertyTargetDefinitionFile; 159 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx); 160 } 161 }; 162 163 typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP; 164 165 static const ProcessKDPPropertiesSP & 166 GetGlobalPluginProperties() 167 { 168 static ProcessKDPPropertiesSP g_settings_sp; 169 if (!g_settings_sp) 170 g_settings_sp.reset (new PluginProperties ()); 171 return g_settings_sp; 172 } 173 174 } // anonymous namespace end 175 176 // TODO Randomly assigning a port is unsafe. We should get an unused 177 // ephemeral port from the kernel and make sure we reserve it before passing 178 // it to debugserver. 179 180 #if defined (__APPLE__) 181 #define LOW_PORT (IPPORT_RESERVED) 182 #define HIGH_PORT (IPPORT_HIFIRSTAUTO) 183 #else 184 #define LOW_PORT (1024u) 185 #define HIGH_PORT (49151u) 186 #endif 187 188 #if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__) || defined(__aarch64__)) 189 static bool rand_initialized = false; 190 191 static inline uint16_t 192 get_random_port () 193 { 194 if (!rand_initialized) 195 { 196 time_t seed = time(NULL); 197 198 rand_initialized = true; 199 srand(seed); 200 } 201 return (rand() % (HIGH_PORT - LOW_PORT)) + LOW_PORT; 202 } 203 #endif 204 205 ConstString 206 ProcessGDBRemote::GetPluginNameStatic() 207 { 208 static ConstString g_name("gdb-remote"); 209 return g_name; 210 } 211 212 const char * 213 ProcessGDBRemote::GetPluginDescriptionStatic() 214 { 215 return "GDB Remote protocol based debugging plug-in."; 216 } 217 218 void 219 ProcessGDBRemote::Terminate() 220 { 221 PluginManager::UnregisterPlugin (ProcessGDBRemote::CreateInstance); 222 } 223 224 225 lldb::ProcessSP 226 ProcessGDBRemote::CreateInstance (lldb::TargetSP target_sp, ListenerSP listener_sp, const FileSpec *crash_file_path) 227 { 228 lldb::ProcessSP process_sp; 229 if (crash_file_path == NULL) 230 process_sp.reset (new ProcessGDBRemote (target_sp, listener_sp)); 231 return process_sp; 232 } 233 234 bool 235 ProcessGDBRemote::CanDebug (lldb::TargetSP target_sp, bool plugin_specified_by_name) 236 { 237 if (plugin_specified_by_name) 238 return true; 239 240 // For now we are just making sure the file exists for a given module 241 Module *exe_module = target_sp->GetExecutableModulePointer(); 242 if (exe_module) 243 { 244 ObjectFile *exe_objfile = exe_module->GetObjectFile(); 245 // We can't debug core files... 246 switch (exe_objfile->GetType()) 247 { 248 case ObjectFile::eTypeInvalid: 249 case ObjectFile::eTypeCoreFile: 250 case ObjectFile::eTypeDebugInfo: 251 case ObjectFile::eTypeObjectFile: 252 case ObjectFile::eTypeSharedLibrary: 253 case ObjectFile::eTypeStubLibrary: 254 case ObjectFile::eTypeJIT: 255 return false; 256 case ObjectFile::eTypeExecutable: 257 case ObjectFile::eTypeDynamicLinker: 258 case ObjectFile::eTypeUnknown: 259 break; 260 } 261 return exe_module->GetFileSpec().Exists(); 262 } 263 // However, if there is no executable module, we return true since we might be preparing to attach. 264 return true; 265 } 266 267 //---------------------------------------------------------------------- 268 // ProcessGDBRemote constructor 269 //---------------------------------------------------------------------- 270 ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp, ListenerSP listener_sp) 271 : Process(target_sp, listener_sp), 272 m_flags(0), 273 m_gdb_comm(), 274 m_debugserver_pid(LLDB_INVALID_PROCESS_ID), 275 m_last_stop_packet_mutex(), 276 m_register_info(), 277 m_async_broadcaster(NULL, "lldb.process.gdb-remote.async-broadcaster"), 278 m_async_listener_sp(Listener::MakeListener("lldb.process.gdb-remote.async-listener")), 279 m_async_thread_state_mutex(), 280 m_thread_ids(), 281 m_thread_pcs(), 282 m_jstopinfo_sp(), 283 m_jthreadsinfo_sp(), 284 m_continue_c_tids(), 285 m_continue_C_tids(), 286 m_continue_s_tids(), 287 m_continue_S_tids(), 288 m_max_memory_size(0), 289 m_remote_stub_max_memory_size(0), 290 m_addr_to_mmap_size(), 291 m_thread_create_bp_sp(), 292 m_waiting_for_attach(false), 293 m_destroy_tried_resuming(false), 294 m_command_sp(), 295 m_breakpoint_pc_offset(0), 296 m_initial_tid(LLDB_INVALID_THREAD_ID) 297 { 298 m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadShouldExit, "async thread should exit"); 299 m_async_broadcaster.SetEventName(eBroadcastBitAsyncContinue, "async thread continue"); 300 m_async_broadcaster.SetEventName(eBroadcastBitAsyncThreadDidExit, "async thread did exit"); 301 302 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_ASYNC)); 303 304 const uint32_t async_event_mask = eBroadcastBitAsyncContinue | eBroadcastBitAsyncThreadShouldExit; 305 306 if (m_async_listener_sp->StartListeningForEvents(&m_async_broadcaster, async_event_mask) != async_event_mask) 307 { 308 if (log) 309 log->Printf("ProcessGDBRemote::%s failed to listen for m_async_broadcaster events", __FUNCTION__); 310 } 311 312 const uint32_t gdb_event_mask = 313 Communication::eBroadcastBitReadThreadDidExit | GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify; 314 if (m_async_listener_sp->StartListeningForEvents(&m_gdb_comm, gdb_event_mask) != gdb_event_mask) 315 { 316 if (log) 317 log->Printf("ProcessGDBRemote::%s failed to listen for m_gdb_comm events", __FUNCTION__); 318 } 319 320 const uint64_t timeout_seconds = GetGlobalPluginProperties()->GetPacketTimeout(); 321 if (timeout_seconds > 0) 322 m_gdb_comm.SetPacketTimeout(timeout_seconds); 323 } 324 325 //---------------------------------------------------------------------- 326 // Destructor 327 //---------------------------------------------------------------------- 328 ProcessGDBRemote::~ProcessGDBRemote() 329 { 330 // m_mach_process.UnregisterNotificationCallbacks (this); 331 Clear(); 332 // We need to call finalize on the process before destroying ourselves 333 // to make sure all of the broadcaster cleanup goes as planned. If we 334 // destruct this class, then Process::~Process() might have problems 335 // trying to fully destroy the broadcaster. 336 Finalize(); 337 338 // The general Finalize is going to try to destroy the process and that SHOULD 339 // shut down the async thread. However, if we don't kill it it will get stranded and 340 // its connection will go away so when it wakes up it will crash. So kill it for sure here. 341 StopAsyncThread(); 342 KillDebugserverProcess(); 343 } 344 345 //---------------------------------------------------------------------- 346 // PluginInterface 347 //---------------------------------------------------------------------- 348 ConstString 349 ProcessGDBRemote::GetPluginName() 350 { 351 return GetPluginNameStatic(); 352 } 353 354 uint32_t 355 ProcessGDBRemote::GetPluginVersion() 356 { 357 return 1; 358 } 359 360 bool 361 ProcessGDBRemote::ParsePythonTargetDefinition(const FileSpec &target_definition_fspec) 362 { 363 ScriptInterpreter *interpreter = GetTarget().GetDebugger().GetCommandInterpreter().GetScriptInterpreter(); 364 Error error; 365 StructuredData::ObjectSP module_object_sp(interpreter->LoadPluginModule(target_definition_fspec, error)); 366 if (module_object_sp) 367 { 368 StructuredData::DictionarySP target_definition_sp( 369 interpreter->GetDynamicSettings(module_object_sp, &GetTarget(), "gdb-server-target-definition", error)); 370 371 if (target_definition_sp) 372 { 373 StructuredData::ObjectSP target_object(target_definition_sp->GetValueForKey("host-info")); 374 if (target_object) 375 { 376 if (auto host_info_dict = target_object->GetAsDictionary()) 377 { 378 StructuredData::ObjectSP triple_value = host_info_dict->GetValueForKey("triple"); 379 if (auto triple_string_value = triple_value->GetAsString()) 380 { 381 std::string triple_string = triple_string_value->GetValue(); 382 ArchSpec host_arch(triple_string.c_str()); 383 if (!host_arch.IsCompatibleMatch(GetTarget().GetArchitecture())) 384 { 385 GetTarget().SetArchitecture(host_arch); 386 } 387 } 388 } 389 } 390 m_breakpoint_pc_offset = 0; 391 StructuredData::ObjectSP breakpoint_pc_offset_value = target_definition_sp->GetValueForKey("breakpoint-pc-offset"); 392 if (breakpoint_pc_offset_value) 393 { 394 if (auto breakpoint_pc_int_value = breakpoint_pc_offset_value->GetAsInteger()) 395 m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue(); 396 } 397 398 if (m_register_info.SetRegisterInfo(*target_definition_sp, GetTarget().GetArchitecture()) > 0) 399 { 400 return true; 401 } 402 } 403 } 404 return false; 405 } 406 407 // If the remote stub didn't give us eh_frame or DWARF register numbers for a register, 408 // see if the ABI can provide them. 409 // DWARF and eh_frame register numbers are defined as a part of the ABI. 410 static void 411 AugmentRegisterInfoViaABI (RegisterInfo ®_info, ConstString reg_name, ABISP abi_sp) 412 { 413 if (reg_info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM 414 || reg_info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM) 415 { 416 if (abi_sp) 417 { 418 RegisterInfo abi_reg_info; 419 if (abi_sp->GetRegisterInfoByName (reg_name, abi_reg_info)) 420 { 421 if (reg_info.kinds[eRegisterKindEHFrame] == LLDB_INVALID_REGNUM && 422 abi_reg_info.kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM) 423 { 424 reg_info.kinds[eRegisterKindEHFrame] = abi_reg_info.kinds[eRegisterKindEHFrame]; 425 } 426 if (reg_info.kinds[eRegisterKindDWARF] == LLDB_INVALID_REGNUM && 427 abi_reg_info.kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM) 428 { 429 reg_info.kinds[eRegisterKindDWARF] = abi_reg_info.kinds[eRegisterKindDWARF]; 430 } 431 if (reg_info.kinds[eRegisterKindGeneric] == LLDB_INVALID_REGNUM && 432 abi_reg_info.kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM) 433 { 434 reg_info.kinds[eRegisterKindGeneric] = abi_reg_info.kinds[eRegisterKindGeneric]; 435 } 436 } 437 } 438 } 439 } 440 441 static size_t 442 SplitCommaSeparatedRegisterNumberString(const llvm::StringRef &comma_separated_regiter_numbers, std::vector<uint32_t> ®nums, int base) 443 { 444 regnums.clear(); 445 std::pair<llvm::StringRef, llvm::StringRef> value_pair; 446 value_pair.second = comma_separated_regiter_numbers; 447 do 448 { 449 value_pair = value_pair.second.split(','); 450 if (!value_pair.first.empty()) 451 { 452 uint32_t reg = StringConvert::ToUInt32 (value_pair.first.str().c_str(), LLDB_INVALID_REGNUM, base); 453 if (reg != LLDB_INVALID_REGNUM) 454 regnums.push_back (reg); 455 } 456 } while (!value_pair.second.empty()); 457 return regnums.size(); 458 } 459 460 461 void 462 ProcessGDBRemote::BuildDynamicRegisterInfo (bool force) 463 { 464 if (!force && m_register_info.GetNumRegisters() > 0) 465 return; 466 467 m_register_info.Clear(); 468 469 // Check if qHostInfo specified a specific packet timeout for this connection. 470 // If so then lets update our setting so the user knows what the timeout is 471 // and can see it. 472 const uint32_t host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout(); 473 if (host_packet_timeout) 474 { 475 GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout); 476 } 477 478 // Register info search order: 479 // 1 - Use the target definition python file if one is specified. 480 // 2 - If the target definition doesn't have any of the info from the target.xml (registers) then proceed to read the target.xml. 481 // 3 - Fall back on the qRegisterInfo packets. 482 483 FileSpec target_definition_fspec = GetGlobalPluginProperties()->GetTargetDefinitionFile (); 484 if (!target_definition_fspec.Exists()) 485 { 486 // If the filename doesn't exist, it may be a ~ not having been expanded - try to resolve it. 487 target_definition_fspec.ResolvePath(); 488 } 489 if (target_definition_fspec) 490 { 491 // See if we can get register definitions from a python file 492 if (ParsePythonTargetDefinition (target_definition_fspec)) 493 { 494 return; 495 } 496 else 497 { 498 StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream(); 499 stream_sp->Printf ("ERROR: target description file %s failed to parse.\n", target_definition_fspec.GetPath().c_str()); 500 } 501 } 502 503 const ArchSpec &target_arch = GetTarget().GetArchitecture(); 504 const ArchSpec &remote_host_arch = m_gdb_comm.GetHostArchitecture(); 505 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture(); 506 507 // Use the process' architecture instead of the host arch, if available 508 ArchSpec arch_to_use; 509 if (remote_process_arch.IsValid ()) 510 arch_to_use = remote_process_arch; 511 else 512 arch_to_use = remote_host_arch; 513 514 if (!arch_to_use.IsValid()) 515 arch_to_use = target_arch; 516 517 if (GetGDBServerRegisterInfo (arch_to_use)) 518 return; 519 520 char packet[128]; 521 uint32_t reg_offset = 0; 522 uint32_t reg_num = 0; 523 for (StringExtractorGDBRemote::ResponseType response_type = StringExtractorGDBRemote::eResponse; 524 response_type == StringExtractorGDBRemote::eResponse; 525 ++reg_num) 526 { 527 const int packet_len = ::snprintf (packet, sizeof(packet), "qRegisterInfo%x", reg_num); 528 assert (packet_len < (int)sizeof(packet)); 529 StringExtractorGDBRemote response; 530 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, false) == GDBRemoteCommunication::PacketResult::Success) 531 { 532 response_type = response.GetResponseType(); 533 if (response_type == StringExtractorGDBRemote::eResponse) 534 { 535 std::string name; 536 std::string value; 537 ConstString reg_name; 538 ConstString alt_name; 539 ConstString set_name; 540 std::vector<uint32_t> value_regs; 541 std::vector<uint32_t> invalidate_regs; 542 RegisterInfo reg_info = { NULL, // Name 543 NULL, // Alt name 544 0, // byte size 545 reg_offset, // offset 546 eEncodingUint, // encoding 547 eFormatHex, // format 548 { 549 LLDB_INVALID_REGNUM, // eh_frame reg num 550 LLDB_INVALID_REGNUM, // DWARF reg num 551 LLDB_INVALID_REGNUM, // generic reg num 552 reg_num, // process plugin reg num 553 reg_num // native register number 554 }, 555 NULL, 556 NULL 557 }; 558 559 while (response.GetNameColonValue(name, value)) 560 { 561 if (name.compare("name") == 0) 562 { 563 reg_name.SetCString(value.c_str()); 564 } 565 else if (name.compare("alt-name") == 0) 566 { 567 alt_name.SetCString(value.c_str()); 568 } 569 else if (name.compare("bitsize") == 0) 570 { 571 reg_info.byte_size = StringConvert::ToUInt32(value.c_str(), 0, 0) / CHAR_BIT; 572 } 573 else if (name.compare("offset") == 0) 574 { 575 uint32_t offset = StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0); 576 if (reg_offset != offset) 577 { 578 reg_offset = offset; 579 } 580 } 581 else if (name.compare("encoding") == 0) 582 { 583 const Encoding encoding = Args::StringToEncoding (value.c_str()); 584 if (encoding != eEncodingInvalid) 585 reg_info.encoding = encoding; 586 } 587 else if (name.compare("format") == 0) 588 { 589 Format format = eFormatInvalid; 590 if (Args::StringToFormat (value.c_str(), format, NULL).Success()) 591 reg_info.format = format; 592 else if (value.compare("binary") == 0) 593 reg_info.format = eFormatBinary; 594 else if (value.compare("decimal") == 0) 595 reg_info.format = eFormatDecimal; 596 else if (value.compare("hex") == 0) 597 reg_info.format = eFormatHex; 598 else if (value.compare("float") == 0) 599 reg_info.format = eFormatFloat; 600 else if (value.compare("vector-sint8") == 0) 601 reg_info.format = eFormatVectorOfSInt8; 602 else if (value.compare("vector-uint8") == 0) 603 reg_info.format = eFormatVectorOfUInt8; 604 else if (value.compare("vector-sint16") == 0) 605 reg_info.format = eFormatVectorOfSInt16; 606 else if (value.compare("vector-uint16") == 0) 607 reg_info.format = eFormatVectorOfUInt16; 608 else if (value.compare("vector-sint32") == 0) 609 reg_info.format = eFormatVectorOfSInt32; 610 else if (value.compare("vector-uint32") == 0) 611 reg_info.format = eFormatVectorOfUInt32; 612 else if (value.compare("vector-float32") == 0) 613 reg_info.format = eFormatVectorOfFloat32; 614 else if (value.compare("vector-uint128") == 0) 615 reg_info.format = eFormatVectorOfUInt128; 616 } 617 else if (name.compare("set") == 0) 618 { 619 set_name.SetCString(value.c_str()); 620 } 621 else if (name.compare("gcc") == 0 || name.compare("ehframe") == 0) 622 { 623 reg_info.kinds[eRegisterKindEHFrame] = StringConvert::ToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0); 624 } 625 else if (name.compare("dwarf") == 0) 626 { 627 reg_info.kinds[eRegisterKindDWARF] = StringConvert::ToUInt32(value.c_str(), LLDB_INVALID_REGNUM, 0); 628 } 629 else if (name.compare("generic") == 0) 630 { 631 reg_info.kinds[eRegisterKindGeneric] = Args::StringToGenericRegister (value.c_str()); 632 } 633 else if (name.compare("container-regs") == 0) 634 { 635 SplitCommaSeparatedRegisterNumberString(value, value_regs, 16); 636 } 637 else if (name.compare("invalidate-regs") == 0) 638 { 639 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 16); 640 } 641 } 642 643 reg_info.byte_offset = reg_offset; 644 assert (reg_info.byte_size != 0); 645 reg_offset += reg_info.byte_size; 646 if (!value_regs.empty()) 647 { 648 value_regs.push_back(LLDB_INVALID_REGNUM); 649 reg_info.value_regs = value_regs.data(); 650 } 651 if (!invalidate_regs.empty()) 652 { 653 invalidate_regs.push_back(LLDB_INVALID_REGNUM); 654 reg_info.invalidate_regs = invalidate_regs.data(); 655 } 656 657 // We have to make a temporary ABI here, and not use the GetABI because this code 658 // gets called in DidAttach, when the target architecture (and consequently the ABI we'll get from 659 // the process) may be wrong. 660 ABISP abi_to_use = ABI::FindPlugin(arch_to_use); 661 662 AugmentRegisterInfoViaABI (reg_info, reg_name, abi_to_use); 663 664 m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name); 665 } 666 else 667 { 668 break; // ensure exit before reg_num is incremented 669 } 670 } 671 else 672 { 673 break; 674 } 675 } 676 677 if (m_register_info.GetNumRegisters() > 0) 678 { 679 m_register_info.Finalize(GetTarget().GetArchitecture()); 680 return; 681 } 682 683 // We didn't get anything if the accumulated reg_num is zero. See if we are 684 // debugging ARM and fill with a hard coded register set until we can get an 685 // updated debugserver down on the devices. 686 // On the other hand, if the accumulated reg_num is positive, see if we can 687 // add composite registers to the existing primordial ones. 688 bool from_scratch = (m_register_info.GetNumRegisters() == 0); 689 690 if (!target_arch.IsValid()) 691 { 692 if (arch_to_use.IsValid() 693 && (arch_to_use.GetMachine() == llvm::Triple::arm || arch_to_use.GetMachine() == llvm::Triple::thumb) 694 && arch_to_use.GetTriple().getVendor() == llvm::Triple::Apple) 695 m_register_info.HardcodeARMRegisters(from_scratch); 696 } 697 else if (target_arch.GetMachine() == llvm::Triple::arm 698 || target_arch.GetMachine() == llvm::Triple::thumb) 699 { 700 m_register_info.HardcodeARMRegisters(from_scratch); 701 } 702 703 // At this point, we can finalize our register info. 704 m_register_info.Finalize (GetTarget().GetArchitecture()); 705 } 706 707 Error 708 ProcessGDBRemote::WillLaunch (Module* module) 709 { 710 return WillLaunchOrAttach (); 711 } 712 713 Error 714 ProcessGDBRemote::WillAttachToProcessWithID (lldb::pid_t pid) 715 { 716 return WillLaunchOrAttach (); 717 } 718 719 Error 720 ProcessGDBRemote::WillAttachToProcessWithName (const char *process_name, bool wait_for_launch) 721 { 722 return WillLaunchOrAttach (); 723 } 724 725 Error 726 ProcessGDBRemote::DoConnectRemote (Stream *strm, const char *remote_url) 727 { 728 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 729 Error error (WillLaunchOrAttach ()); 730 731 if (error.Fail()) 732 return error; 733 734 error = ConnectToDebugserver (remote_url); 735 736 if (error.Fail()) 737 return error; 738 StartAsyncThread (); 739 740 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID (); 741 if (pid == LLDB_INVALID_PROCESS_ID) 742 { 743 // We don't have a valid process ID, so note that we are connected 744 // and could now request to launch or attach, or get remote process 745 // listings... 746 SetPrivateState (eStateConnected); 747 } 748 else 749 { 750 // We have a valid process 751 SetID (pid); 752 GetThreadList(); 753 StringExtractorGDBRemote response; 754 if (m_gdb_comm.GetStopReply(response)) 755 { 756 SetLastStopPacket(response); 757 758 // '?' Packets must be handled differently in non-stop mode 759 if (GetTarget().GetNonStopModeEnabled()) 760 HandleStopReplySequence(); 761 762 Target &target = GetTarget(); 763 if (!target.GetArchitecture().IsValid()) 764 { 765 if (m_gdb_comm.GetProcessArchitecture().IsValid()) 766 { 767 target.SetArchitecture(m_gdb_comm.GetProcessArchitecture()); 768 } 769 else 770 { 771 target.SetArchitecture(m_gdb_comm.GetHostArchitecture()); 772 } 773 } 774 775 const StateType state = SetThreadStopInfo (response); 776 if (state != eStateInvalid) 777 { 778 SetPrivateState (state); 779 } 780 else 781 error.SetErrorStringWithFormat ("Process %" PRIu64 " was reported after connecting to '%s', but state was not stopped: %s", pid, remote_url, StateAsCString (state)); 782 } 783 else 784 error.SetErrorStringWithFormat ("Process %" PRIu64 " was reported after connecting to '%s', but no stop reply packet was received", pid, remote_url); 785 } 786 787 if (log) 788 log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": normalizing target architecture initial triple: %s (GetTarget().GetArchitecture().IsValid() %s, m_gdb_comm.GetHostArchitecture().IsValid(): %s)", __FUNCTION__, GetID (), GetTarget ().GetArchitecture ().GetTriple ().getTriple ().c_str (), GetTarget ().GetArchitecture ().IsValid () ? "true" : "false", m_gdb_comm.GetHostArchitecture ().IsValid () ? "true" : "false"); 789 790 791 if (error.Success() 792 && !GetTarget().GetArchitecture().IsValid() 793 && m_gdb_comm.GetHostArchitecture().IsValid()) 794 { 795 // Prefer the *process'* architecture over that of the *host*, if available. 796 if (m_gdb_comm.GetProcessArchitecture().IsValid()) 797 GetTarget().SetArchitecture(m_gdb_comm.GetProcessArchitecture()); 798 else 799 GetTarget().SetArchitecture(m_gdb_comm.GetHostArchitecture()); 800 } 801 802 if (log) 803 log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": normalized target architecture triple: %s", __FUNCTION__, GetID (), GetTarget ().GetArchitecture ().GetTriple ().getTriple ().c_str ()); 804 805 if (error.Success()) 806 { 807 PlatformSP platform_sp = GetTarget().GetPlatform(); 808 if (platform_sp && platform_sp->IsConnected()) 809 SetUnixSignals(platform_sp->GetUnixSignals()); 810 else 811 SetUnixSignals(UnixSignals::Create(GetTarget().GetArchitecture())); 812 } 813 814 return error; 815 } 816 817 Error 818 ProcessGDBRemote::WillLaunchOrAttach () 819 { 820 Error error; 821 m_stdio_communication.Clear (); 822 return error; 823 } 824 825 //---------------------------------------------------------------------- 826 // Process Control 827 //---------------------------------------------------------------------- 828 Error 829 ProcessGDBRemote::DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info) 830 { 831 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 832 Error error; 833 834 if (log) 835 log->Printf ("ProcessGDBRemote::%s() entered", __FUNCTION__); 836 837 uint32_t launch_flags = launch_info.GetFlags().Get(); 838 FileSpec stdin_file_spec{}; 839 FileSpec stdout_file_spec{}; 840 FileSpec stderr_file_spec{}; 841 FileSpec working_dir = launch_info.GetWorkingDirectory(); 842 843 const FileAction *file_action; 844 file_action = launch_info.GetFileActionForFD (STDIN_FILENO); 845 if (file_action) 846 { 847 if (file_action->GetAction() == FileAction::eFileActionOpen) 848 stdin_file_spec = file_action->GetFileSpec(); 849 } 850 file_action = launch_info.GetFileActionForFD (STDOUT_FILENO); 851 if (file_action) 852 { 853 if (file_action->GetAction() == FileAction::eFileActionOpen) 854 stdout_file_spec = file_action->GetFileSpec(); 855 } 856 file_action = launch_info.GetFileActionForFD (STDERR_FILENO); 857 if (file_action) 858 { 859 if (file_action->GetAction() == FileAction::eFileActionOpen) 860 stderr_file_spec = file_action->GetFileSpec(); 861 } 862 863 if (log) 864 { 865 if (stdin_file_spec || stdout_file_spec || stderr_file_spec) 866 log->Printf ("ProcessGDBRemote::%s provided with STDIO paths via launch_info: stdin=%s, stdout=%s, stderr=%s", 867 __FUNCTION__, 868 stdin_file_spec ? stdin_file_spec.GetCString() : "<null>", 869 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>", 870 stderr_file_spec ? stderr_file_spec.GetCString() : "<null>"); 871 else 872 log->Printf ("ProcessGDBRemote::%s no STDIO paths given via launch_info", __FUNCTION__); 873 } 874 875 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0; 876 if (stdin_file_spec || disable_stdio) 877 { 878 // the inferior will be reading stdin from the specified file 879 // or stdio is completely disabled 880 m_stdin_forward = false; 881 } 882 else 883 { 884 m_stdin_forward = true; 885 } 886 887 // ::LogSetBitMask (GDBR_LOG_DEFAULT); 888 // ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD); 889 // ::LogSetLogFile ("/dev/stdout"); 890 891 ObjectFile * object_file = exe_module->GetObjectFile(); 892 if (object_file) 893 { 894 error = EstablishConnectionIfNeeded (launch_info); 895 if (error.Success()) 896 { 897 lldb_utility::PseudoTerminal pty; 898 const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0; 899 900 PlatformSP platform_sp (GetTarget().GetPlatform()); 901 if (disable_stdio) 902 { 903 // set to /dev/null unless redirected to a file above 904 if (!stdin_file_spec) 905 stdin_file_spec.SetFile(FileSystem::DEV_NULL, false); 906 if (!stdout_file_spec) 907 stdout_file_spec.SetFile(FileSystem::DEV_NULL, false); 908 if (!stderr_file_spec) 909 stderr_file_spec.SetFile(FileSystem::DEV_NULL, false); 910 } 911 else if (platform_sp && platform_sp->IsHost()) 912 { 913 // If the debugserver is local and we aren't disabling STDIO, lets use 914 // a pseudo terminal to instead of relying on the 'O' packets for stdio 915 // since 'O' packets can really slow down debugging if the inferior 916 // does a lot of output. 917 if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) && 918 pty.OpenFirstAvailableMaster(O_RDWR|O_NOCTTY, NULL, 0)) 919 { 920 FileSpec slave_name{pty.GetSlaveName(NULL, 0), false}; 921 922 if (!stdin_file_spec) 923 stdin_file_spec = slave_name; 924 925 if (!stdout_file_spec) 926 stdout_file_spec = slave_name; 927 928 if (!stderr_file_spec) 929 stderr_file_spec = slave_name; 930 } 931 if (log) 932 log->Printf ("ProcessGDBRemote::%s adjusted STDIO paths for local platform (IsHost() is true) using slave: stdin=%s, stdout=%s, stderr=%s", 933 __FUNCTION__, 934 stdin_file_spec ? stdin_file_spec.GetCString() : "<null>", 935 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>", 936 stderr_file_spec ? stderr_file_spec.GetCString() : "<null>"); 937 } 938 939 if (log) 940 log->Printf ("ProcessGDBRemote::%s final STDIO paths after all adjustments: stdin=%s, stdout=%s, stderr=%s", 941 __FUNCTION__, 942 stdin_file_spec ? stdin_file_spec.GetCString() : "<null>", 943 stdout_file_spec ? stdout_file_spec.GetCString() : "<null>", 944 stderr_file_spec ? stderr_file_spec.GetCString() : "<null>"); 945 946 if (stdin_file_spec) 947 m_gdb_comm.SetSTDIN(stdin_file_spec); 948 if (stdout_file_spec) 949 m_gdb_comm.SetSTDOUT(stdout_file_spec); 950 if (stderr_file_spec) 951 m_gdb_comm.SetSTDERR(stderr_file_spec); 952 953 m_gdb_comm.SetDisableASLR (launch_flags & eLaunchFlagDisableASLR); 954 m_gdb_comm.SetDetachOnError (launch_flags & eLaunchFlagDetachOnError); 955 956 m_gdb_comm.SendLaunchArchPacket (GetTarget().GetArchitecture().GetArchitectureName()); 957 958 const char * launch_event_data = launch_info.GetLaunchEventData(); 959 if (launch_event_data != NULL && *launch_event_data != '\0') 960 m_gdb_comm.SendLaunchEventDataPacket (launch_event_data); 961 962 if (working_dir) 963 { 964 m_gdb_comm.SetWorkingDir (working_dir); 965 } 966 967 // Send the environment and the program + arguments after we connect 968 const Args &environment = launch_info.GetEnvironmentEntries(); 969 if (environment.GetArgumentCount()) 970 { 971 size_t num_environment_entries = environment.GetArgumentCount(); 972 for (size_t i=0; i<num_environment_entries; ++i) 973 { 974 const char *env_entry = environment.GetArgumentAtIndex(i); 975 if (env_entry == NULL || m_gdb_comm.SendEnvironmentPacket(env_entry) != 0) 976 break; 977 } 978 } 979 980 { 981 // Scope for the scoped timeout object 982 GDBRemoteCommunication::ScopedTimeout timeout (m_gdb_comm, 10); 983 984 int arg_packet_err = m_gdb_comm.SendArgumentsPacket (launch_info); 985 if (arg_packet_err == 0) 986 { 987 std::string error_str; 988 if (m_gdb_comm.GetLaunchSuccess (error_str)) 989 { 990 SetID (m_gdb_comm.GetCurrentProcessID ()); 991 } 992 else 993 { 994 error.SetErrorString (error_str.c_str()); 995 } 996 } 997 else 998 { 999 error.SetErrorStringWithFormat("'A' packet returned an error: %i", arg_packet_err); 1000 } 1001 } 1002 1003 if (GetID() == LLDB_INVALID_PROCESS_ID) 1004 { 1005 if (log) 1006 log->Printf("failed to connect to debugserver: %s", error.AsCString()); 1007 KillDebugserverProcess (); 1008 return error; 1009 } 1010 1011 StringExtractorGDBRemote response; 1012 if (m_gdb_comm.GetStopReply(response)) 1013 { 1014 SetLastStopPacket(response); 1015 // '?' Packets must be handled differently in non-stop mode 1016 if (GetTarget().GetNonStopModeEnabled()) 1017 HandleStopReplySequence(); 1018 1019 const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture(); 1020 1021 if (process_arch.IsValid()) 1022 { 1023 GetTarget().MergeArchitecture(process_arch); 1024 } 1025 else 1026 { 1027 const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture(); 1028 if (host_arch.IsValid()) 1029 GetTarget().MergeArchitecture(host_arch); 1030 } 1031 1032 SetPrivateState (SetThreadStopInfo (response)); 1033 1034 if (!disable_stdio) 1035 { 1036 if (pty.GetMasterFileDescriptor() != lldb_utility::PseudoTerminal::invalid_fd) 1037 SetSTDIOFileDescriptor (pty.ReleaseMasterFileDescriptor()); 1038 } 1039 } 1040 } 1041 else 1042 { 1043 if (log) 1044 log->Printf("failed to connect to debugserver: %s", error.AsCString()); 1045 } 1046 } 1047 else 1048 { 1049 // Set our user ID to an invalid process ID. 1050 SetID(LLDB_INVALID_PROCESS_ID); 1051 error.SetErrorStringWithFormat ("failed to get object file from '%s' for arch %s", 1052 exe_module->GetFileSpec().GetFilename().AsCString(), 1053 exe_module->GetArchitecture().GetArchitectureName()); 1054 } 1055 return error; 1056 1057 } 1058 1059 1060 Error 1061 ProcessGDBRemote::ConnectToDebugserver (const char *connect_url) 1062 { 1063 Error error; 1064 // Only connect if we have a valid connect URL 1065 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 1066 1067 if (connect_url && connect_url[0]) 1068 { 1069 if (log) 1070 log->Printf("ProcessGDBRemote::%s Connecting to %s", __FUNCTION__, connect_url); 1071 std::unique_ptr<ConnectionFileDescriptor> conn_ap(new ConnectionFileDescriptor()); 1072 if (conn_ap.get()) 1073 { 1074 const uint32_t max_retry_count = 50; 1075 uint32_t retry_count = 0; 1076 while (!m_gdb_comm.IsConnected()) 1077 { 1078 if (conn_ap->Connect(connect_url, &error) == eConnectionStatusSuccess) 1079 { 1080 m_gdb_comm.SetConnection (conn_ap.release()); 1081 break; 1082 } 1083 else if (error.WasInterrupted()) 1084 { 1085 // If we were interrupted, don't keep retrying. 1086 break; 1087 } 1088 1089 retry_count++; 1090 1091 if (retry_count >= max_retry_count) 1092 break; 1093 1094 usleep (100000); 1095 } 1096 } 1097 } 1098 1099 if (!m_gdb_comm.IsConnected()) 1100 { 1101 if (error.Success()) 1102 error.SetErrorString("not connected to remote gdb server"); 1103 return error; 1104 } 1105 1106 1107 // Start the communications read thread so all incoming data can be 1108 // parsed into packets and queued as they arrive. 1109 if (GetTarget().GetNonStopModeEnabled()) 1110 m_gdb_comm.StartReadThread(); 1111 1112 // We always seem to be able to open a connection to a local port 1113 // so we need to make sure we can then send data to it. If we can't 1114 // then we aren't actually connected to anything, so try and do the 1115 // handshake with the remote GDB server and make sure that goes 1116 // alright. 1117 if (!m_gdb_comm.HandshakeWithServer (&error)) 1118 { 1119 m_gdb_comm.Disconnect(); 1120 if (error.Success()) 1121 error.SetErrorString("not connected to remote gdb server"); 1122 return error; 1123 } 1124 1125 // Send $QNonStop:1 packet on startup if required 1126 if (GetTarget().GetNonStopModeEnabled()) 1127 GetTarget().SetNonStopModeEnabled (m_gdb_comm.SetNonStopMode(true)); 1128 1129 m_gdb_comm.GetEchoSupported (); 1130 m_gdb_comm.GetThreadSuffixSupported (); 1131 m_gdb_comm.GetListThreadsInStopReplySupported (); 1132 m_gdb_comm.GetHostInfo (); 1133 m_gdb_comm.GetVContSupported ('c'); 1134 m_gdb_comm.GetVAttachOrWaitSupported(); 1135 1136 // Ask the remote server for the default thread id 1137 if (GetTarget().GetNonStopModeEnabled()) 1138 m_gdb_comm.GetDefaultThreadId(m_initial_tid); 1139 1140 1141 size_t num_cmds = GetExtraStartupCommands().GetArgumentCount(); 1142 for (size_t idx = 0; idx < num_cmds; idx++) 1143 { 1144 StringExtractorGDBRemote response; 1145 m_gdb_comm.SendPacketAndWaitForResponse (GetExtraStartupCommands().GetArgumentAtIndex(idx), response, false); 1146 } 1147 return error; 1148 } 1149 1150 void 1151 ProcessGDBRemote::DidLaunchOrAttach (ArchSpec& process_arch) 1152 { 1153 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 1154 if (log) 1155 log->Printf ("ProcessGDBRemote::DidLaunch()"); 1156 if (GetID() != LLDB_INVALID_PROCESS_ID) 1157 { 1158 BuildDynamicRegisterInfo (false); 1159 1160 // See if the GDB server supports the qHostInfo information 1161 1162 1163 // See if the GDB server supports the qProcessInfo packet, if so 1164 // prefer that over the Host information as it will be more specific 1165 // to our process. 1166 1167 const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture(); 1168 if (remote_process_arch.IsValid()) 1169 { 1170 process_arch = remote_process_arch; 1171 if (log) 1172 log->Printf ("ProcessGDBRemote::%s gdb-remote had process architecture, using %s %s", 1173 __FUNCTION__, 1174 process_arch.GetArchitectureName () ? process_arch.GetArchitectureName () : "<null>", 1175 process_arch.GetTriple().getTriple ().c_str() ? process_arch.GetTriple().getTriple ().c_str() : "<null>"); 1176 } 1177 else 1178 { 1179 process_arch = m_gdb_comm.GetHostArchitecture(); 1180 if (log) 1181 log->Printf ("ProcessGDBRemote::%s gdb-remote did not have process architecture, using gdb-remote host architecture %s %s", 1182 __FUNCTION__, 1183 process_arch.GetArchitectureName () ? process_arch.GetArchitectureName () : "<null>", 1184 process_arch.GetTriple().getTriple ().c_str() ? process_arch.GetTriple().getTriple ().c_str() : "<null>"); 1185 } 1186 1187 if (process_arch.IsValid()) 1188 { 1189 const ArchSpec &target_arch = GetTarget().GetArchitecture(); 1190 if (target_arch.IsValid()) 1191 { 1192 if (log) 1193 log->Printf ("ProcessGDBRemote::%s analyzing target arch, currently %s %s", 1194 __FUNCTION__, 1195 target_arch.GetArchitectureName () ? target_arch.GetArchitectureName () : "<null>", 1196 target_arch.GetTriple().getTriple ().c_str() ? target_arch.GetTriple().getTriple ().c_str() : "<null>"); 1197 1198 // If the remote host is ARM and we have apple as the vendor, then 1199 // ARM executables and shared libraries can have mixed ARM architectures. 1200 // You can have an armv6 executable, and if the host is armv7, then the 1201 // system will load the best possible architecture for all shared libraries 1202 // it has, so we really need to take the remote host architecture as our 1203 // defacto architecture in this case. 1204 1205 if ((process_arch.GetMachine() == llvm::Triple::arm || process_arch.GetMachine() == llvm::Triple::thumb) 1206 && process_arch.GetTriple().getVendor() == llvm::Triple::Apple) 1207 { 1208 GetTarget().SetArchitecture (process_arch); 1209 if (log) 1210 log->Printf ("ProcessGDBRemote::%s remote process is ARM/Apple, setting target arch to %s %s", 1211 __FUNCTION__, 1212 process_arch.GetArchitectureName () ? process_arch.GetArchitectureName () : "<null>", 1213 process_arch.GetTriple().getTriple ().c_str() ? process_arch.GetTriple().getTriple ().c_str() : "<null>"); 1214 } 1215 else 1216 { 1217 // Fill in what is missing in the triple 1218 const llvm::Triple &remote_triple = process_arch.GetTriple(); 1219 llvm::Triple new_target_triple = target_arch.GetTriple(); 1220 if (new_target_triple.getVendorName().size() == 0) 1221 { 1222 new_target_triple.setVendor (remote_triple.getVendor()); 1223 1224 if (new_target_triple.getOSName().size() == 0) 1225 { 1226 new_target_triple.setOS (remote_triple.getOS()); 1227 1228 if (new_target_triple.getEnvironmentName().size() == 0) 1229 new_target_triple.setEnvironment (remote_triple.getEnvironment()); 1230 } 1231 1232 ArchSpec new_target_arch = target_arch; 1233 new_target_arch.SetTriple(new_target_triple); 1234 GetTarget().SetArchitecture(new_target_arch); 1235 } 1236 } 1237 1238 if (log) 1239 log->Printf ("ProcessGDBRemote::%s final target arch after adjustments for remote architecture: %s %s", 1240 __FUNCTION__, 1241 target_arch.GetArchitectureName () ? target_arch.GetArchitectureName () : "<null>", 1242 target_arch.GetTriple().getTriple ().c_str() ? target_arch.GetTriple().getTriple ().c_str() : "<null>"); 1243 } 1244 else 1245 { 1246 // The target doesn't have a valid architecture yet, set it from 1247 // the architecture we got from the remote GDB server 1248 GetTarget().SetArchitecture (process_arch); 1249 } 1250 } 1251 } 1252 } 1253 1254 void 1255 ProcessGDBRemote::DidLaunch () 1256 { 1257 ArchSpec process_arch; 1258 DidLaunchOrAttach (process_arch); 1259 } 1260 1261 Error 1262 ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info) 1263 { 1264 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 1265 Error error; 1266 1267 if (log) 1268 log->Printf ("ProcessGDBRemote::%s()", __FUNCTION__); 1269 1270 // Clear out and clean up from any current state 1271 Clear(); 1272 if (attach_pid != LLDB_INVALID_PROCESS_ID) 1273 { 1274 error = EstablishConnectionIfNeeded (attach_info); 1275 if (error.Success()) 1276 { 1277 m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError()); 1278 1279 char packet[64]; 1280 const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%" PRIx64, attach_pid); 1281 SetID (attach_pid); 1282 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet, packet_len)); 1283 } 1284 else 1285 SetExitStatus (-1, error.AsCString()); 1286 } 1287 1288 return error; 1289 } 1290 1291 Error 1292 ProcessGDBRemote::DoAttachToProcessWithName (const char *process_name, const ProcessAttachInfo &attach_info) 1293 { 1294 Error error; 1295 // Clear out and clean up from any current state 1296 Clear(); 1297 1298 if (process_name && process_name[0]) 1299 { 1300 error = EstablishConnectionIfNeeded (attach_info); 1301 if (error.Success()) 1302 { 1303 StreamString packet; 1304 1305 m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError()); 1306 1307 if (attach_info.GetWaitForLaunch()) 1308 { 1309 if (!m_gdb_comm.GetVAttachOrWaitSupported()) 1310 { 1311 packet.PutCString ("vAttachWait"); 1312 } 1313 else 1314 { 1315 if (attach_info.GetIgnoreExisting()) 1316 packet.PutCString("vAttachWait"); 1317 else 1318 packet.PutCString ("vAttachOrWait"); 1319 } 1320 } 1321 else 1322 packet.PutCString("vAttachName"); 1323 packet.PutChar(';'); 1324 packet.PutBytesAsRawHex8(process_name, strlen(process_name), endian::InlHostByteOrder(), endian::InlHostByteOrder()); 1325 1326 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (packet.GetData(), packet.GetSize())); 1327 1328 } 1329 else 1330 SetExitStatus (-1, error.AsCString()); 1331 } 1332 return error; 1333 } 1334 1335 void 1336 ProcessGDBRemote::DidExit () 1337 { 1338 // When we exit, disconnect from the GDB server communications 1339 m_gdb_comm.Disconnect(); 1340 } 1341 1342 void 1343 ProcessGDBRemote::DidAttach (ArchSpec &process_arch) 1344 { 1345 // If you can figure out what the architecture is, fill it in here. 1346 process_arch.Clear(); 1347 DidLaunchOrAttach (process_arch); 1348 } 1349 1350 1351 Error 1352 ProcessGDBRemote::WillResume () 1353 { 1354 m_continue_c_tids.clear(); 1355 m_continue_C_tids.clear(); 1356 m_continue_s_tids.clear(); 1357 m_continue_S_tids.clear(); 1358 m_jstopinfo_sp.reset(); 1359 m_jthreadsinfo_sp.reset(); 1360 return Error(); 1361 } 1362 1363 Error 1364 ProcessGDBRemote::DoResume () 1365 { 1366 Error error; 1367 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 1368 if (log) 1369 log->Printf ("ProcessGDBRemote::Resume()"); 1370 1371 ListenerSP listener_sp (Listener::MakeListener("gdb-remote.resume-packet-sent")); 1372 if (listener_sp->StartListeningForEvents (&m_gdb_comm, GDBRemoteCommunication::eBroadcastBitRunPacketSent)) 1373 { 1374 listener_sp->StartListeningForEvents (&m_async_broadcaster, ProcessGDBRemote::eBroadcastBitAsyncThreadDidExit); 1375 1376 const size_t num_threads = GetThreadList().GetSize(); 1377 1378 StreamString continue_packet; 1379 bool continue_packet_error = false; 1380 if (m_gdb_comm.HasAnyVContSupport ()) 1381 { 1382 if (!GetTarget().GetNonStopModeEnabled() && 1383 (m_continue_c_tids.size() == num_threads || 1384 (m_continue_c_tids.empty() && 1385 m_continue_C_tids.empty() && 1386 m_continue_s_tids.empty() && 1387 m_continue_S_tids.empty()))) 1388 { 1389 // All threads are continuing, just send a "c" packet 1390 continue_packet.PutCString ("c"); 1391 } 1392 else 1393 { 1394 continue_packet.PutCString ("vCont"); 1395 1396 if (!m_continue_c_tids.empty()) 1397 { 1398 if (m_gdb_comm.GetVContSupported ('c')) 1399 { 1400 for (tid_collection::const_iterator t_pos = m_continue_c_tids.begin(), t_end = m_continue_c_tids.end(); t_pos != t_end; ++t_pos) 1401 continue_packet.Printf(";c:%4.4" PRIx64, *t_pos); 1402 } 1403 else 1404 continue_packet_error = true; 1405 } 1406 1407 if (!continue_packet_error && !m_continue_C_tids.empty()) 1408 { 1409 if (m_gdb_comm.GetVContSupported ('C')) 1410 { 1411 for (tid_sig_collection::const_iterator s_pos = m_continue_C_tids.begin(), s_end = m_continue_C_tids.end(); s_pos != s_end; ++s_pos) 1412 continue_packet.Printf(";C%2.2x:%4.4" PRIx64, s_pos->second, s_pos->first); 1413 } 1414 else 1415 continue_packet_error = true; 1416 } 1417 1418 if (!continue_packet_error && !m_continue_s_tids.empty()) 1419 { 1420 if (m_gdb_comm.GetVContSupported ('s')) 1421 { 1422 for (tid_collection::const_iterator t_pos = m_continue_s_tids.begin(), t_end = m_continue_s_tids.end(); t_pos != t_end; ++t_pos) 1423 continue_packet.Printf(";s:%4.4" PRIx64, *t_pos); 1424 } 1425 else 1426 continue_packet_error = true; 1427 } 1428 1429 if (!continue_packet_error && !m_continue_S_tids.empty()) 1430 { 1431 if (m_gdb_comm.GetVContSupported ('S')) 1432 { 1433 for (tid_sig_collection::const_iterator s_pos = m_continue_S_tids.begin(), s_end = m_continue_S_tids.end(); s_pos != s_end; ++s_pos) 1434 continue_packet.Printf(";S%2.2x:%4.4" PRIx64, s_pos->second, s_pos->first); 1435 } 1436 else 1437 continue_packet_error = true; 1438 } 1439 1440 if (continue_packet_error) 1441 continue_packet.GetString().clear(); 1442 } 1443 } 1444 else 1445 continue_packet_error = true; 1446 1447 if (continue_packet_error) 1448 { 1449 // Either no vCont support, or we tried to use part of the vCont 1450 // packet that wasn't supported by the remote GDB server. 1451 // We need to try and make a simple packet that can do our continue 1452 const size_t num_continue_c_tids = m_continue_c_tids.size(); 1453 const size_t num_continue_C_tids = m_continue_C_tids.size(); 1454 const size_t num_continue_s_tids = m_continue_s_tids.size(); 1455 const size_t num_continue_S_tids = m_continue_S_tids.size(); 1456 if (num_continue_c_tids > 0) 1457 { 1458 if (num_continue_c_tids == num_threads) 1459 { 1460 // All threads are resuming... 1461 m_gdb_comm.SetCurrentThreadForRun (-1); 1462 continue_packet.PutChar ('c'); 1463 continue_packet_error = false; 1464 } 1465 else if (num_continue_c_tids == 1 && 1466 num_continue_C_tids == 0 && 1467 num_continue_s_tids == 0 && 1468 num_continue_S_tids == 0 ) 1469 { 1470 // Only one thread is continuing 1471 m_gdb_comm.SetCurrentThreadForRun (m_continue_c_tids.front()); 1472 continue_packet.PutChar ('c'); 1473 continue_packet_error = false; 1474 } 1475 } 1476 1477 if (continue_packet_error && num_continue_C_tids > 0) 1478 { 1479 if ((num_continue_C_tids + num_continue_c_tids) == num_threads && 1480 num_continue_C_tids > 0 && 1481 num_continue_s_tids == 0 && 1482 num_continue_S_tids == 0 ) 1483 { 1484 const int continue_signo = m_continue_C_tids.front().second; 1485 // Only one thread is continuing 1486 if (num_continue_C_tids > 1) 1487 { 1488 // More that one thread with a signal, yet we don't have 1489 // vCont support and we are being asked to resume each 1490 // thread with a signal, we need to make sure they are 1491 // all the same signal, or we can't issue the continue 1492 // accurately with the current support... 1493 if (num_continue_C_tids > 1) 1494 { 1495 continue_packet_error = false; 1496 for (size_t i=1; i<m_continue_C_tids.size(); ++i) 1497 { 1498 if (m_continue_C_tids[i].second != continue_signo) 1499 continue_packet_error = true; 1500 } 1501 } 1502 if (!continue_packet_error) 1503 m_gdb_comm.SetCurrentThreadForRun (-1); 1504 } 1505 else 1506 { 1507 // Set the continue thread ID 1508 continue_packet_error = false; 1509 m_gdb_comm.SetCurrentThreadForRun (m_continue_C_tids.front().first); 1510 } 1511 if (!continue_packet_error) 1512 { 1513 // Add threads continuing with the same signo... 1514 continue_packet.Printf("C%2.2x", continue_signo); 1515 } 1516 } 1517 } 1518 1519 if (continue_packet_error && num_continue_s_tids > 0) 1520 { 1521 if (num_continue_s_tids == num_threads) 1522 { 1523 // All threads are resuming... 1524 m_gdb_comm.SetCurrentThreadForRun (-1); 1525 1526 // If in Non-Stop-Mode use vCont when stepping 1527 if (GetTarget().GetNonStopModeEnabled()) 1528 { 1529 if (m_gdb_comm.GetVContSupported('s')) 1530 continue_packet.PutCString("vCont;s"); 1531 else 1532 continue_packet.PutChar('s'); 1533 } 1534 else 1535 continue_packet.PutChar('s'); 1536 1537 continue_packet_error = false; 1538 } 1539 else if (num_continue_c_tids == 0 && 1540 num_continue_C_tids == 0 && 1541 num_continue_s_tids == 1 && 1542 num_continue_S_tids == 0 ) 1543 { 1544 // Only one thread is stepping 1545 m_gdb_comm.SetCurrentThreadForRun (m_continue_s_tids.front()); 1546 continue_packet.PutChar ('s'); 1547 continue_packet_error = false; 1548 } 1549 } 1550 1551 if (!continue_packet_error && num_continue_S_tids > 0) 1552 { 1553 if (num_continue_S_tids == num_threads) 1554 { 1555 const int step_signo = m_continue_S_tids.front().second; 1556 // Are all threads trying to step with the same signal? 1557 continue_packet_error = false; 1558 if (num_continue_S_tids > 1) 1559 { 1560 for (size_t i=1; i<num_threads; ++i) 1561 { 1562 if (m_continue_S_tids[i].second != step_signo) 1563 continue_packet_error = true; 1564 } 1565 } 1566 if (!continue_packet_error) 1567 { 1568 // Add threads stepping with the same signo... 1569 m_gdb_comm.SetCurrentThreadForRun (-1); 1570 continue_packet.Printf("S%2.2x", step_signo); 1571 } 1572 } 1573 else if (num_continue_c_tids == 0 && 1574 num_continue_C_tids == 0 && 1575 num_continue_s_tids == 0 && 1576 num_continue_S_tids == 1 ) 1577 { 1578 // Only one thread is stepping with signal 1579 m_gdb_comm.SetCurrentThreadForRun (m_continue_S_tids.front().first); 1580 continue_packet.Printf("S%2.2x", m_continue_S_tids.front().second); 1581 continue_packet_error = false; 1582 } 1583 } 1584 } 1585 1586 if (continue_packet_error) 1587 { 1588 error.SetErrorString ("can't make continue packet for this resume"); 1589 } 1590 else 1591 { 1592 EventSP event_sp; 1593 TimeValue timeout; 1594 timeout = TimeValue::Now(); 1595 timeout.OffsetWithSeconds (5); 1596 if (!m_async_thread.IsJoinable()) 1597 { 1598 error.SetErrorString ("Trying to resume but the async thread is dead."); 1599 if (log) 1600 log->Printf ("ProcessGDBRemote::DoResume: Trying to resume but the async thread is dead."); 1601 return error; 1602 } 1603 1604 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncContinue, new EventDataBytes (continue_packet.GetData(), continue_packet.GetSize())); 1605 1606 if (listener_sp->WaitForEvent (&timeout, event_sp) == false) 1607 { 1608 error.SetErrorString("Resume timed out."); 1609 if (log) 1610 log->Printf ("ProcessGDBRemote::DoResume: Resume timed out."); 1611 } 1612 else if (event_sp->BroadcasterIs (&m_async_broadcaster)) 1613 { 1614 error.SetErrorString ("Broadcast continue, but the async thread was killed before we got an ack back."); 1615 if (log) 1616 log->Printf ("ProcessGDBRemote::DoResume: Broadcast continue, but the async thread was killed before we got an ack back."); 1617 return error; 1618 } 1619 } 1620 } 1621 1622 return error; 1623 } 1624 1625 void 1626 ProcessGDBRemote::HandleStopReplySequence () 1627 { 1628 while(true) 1629 { 1630 // Send vStopped 1631 StringExtractorGDBRemote response; 1632 m_gdb_comm.SendPacketAndWaitForResponse("vStopped", response, false); 1633 1634 // OK represents end of signal list 1635 if (response.IsOKResponse()) 1636 break; 1637 1638 // If not OK or a normal packet we have a problem 1639 if (!response.IsNormalResponse()) 1640 break; 1641 1642 SetLastStopPacket(response); 1643 } 1644 } 1645 1646 void 1647 ProcessGDBRemote::ClearThreadIDList () 1648 { 1649 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex()); 1650 m_thread_ids.clear(); 1651 m_thread_pcs.clear(); 1652 } 1653 1654 size_t 1655 ProcessGDBRemote::UpdateThreadIDsFromStopReplyThreadsValue (std::string &value) 1656 { 1657 m_thread_ids.clear(); 1658 m_thread_pcs.clear(); 1659 size_t comma_pos; 1660 lldb::tid_t tid; 1661 while ((comma_pos = value.find(',')) != std::string::npos) 1662 { 1663 value[comma_pos] = '\0'; 1664 // thread in big endian hex 1665 tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16); 1666 if (tid != LLDB_INVALID_THREAD_ID) 1667 m_thread_ids.push_back (tid); 1668 value.erase(0, comma_pos + 1); 1669 } 1670 tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16); 1671 if (tid != LLDB_INVALID_THREAD_ID) 1672 m_thread_ids.push_back (tid); 1673 return m_thread_ids.size(); 1674 } 1675 1676 size_t 1677 ProcessGDBRemote::UpdateThreadPCsFromStopReplyThreadsValue (std::string &value) 1678 { 1679 m_thread_pcs.clear(); 1680 size_t comma_pos; 1681 lldb::addr_t pc; 1682 while ((comma_pos = value.find(',')) != std::string::npos) 1683 { 1684 value[comma_pos] = '\0'; 1685 pc = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16); 1686 if (pc != LLDB_INVALID_ADDRESS) 1687 m_thread_pcs.push_back (pc); 1688 value.erase(0, comma_pos + 1); 1689 } 1690 pc = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16); 1691 if (pc != LLDB_INVALID_THREAD_ID) 1692 m_thread_pcs.push_back (pc); 1693 return m_thread_pcs.size(); 1694 } 1695 1696 bool 1697 ProcessGDBRemote::UpdateThreadIDList () 1698 { 1699 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex()); 1700 1701 if (m_jthreadsinfo_sp) 1702 { 1703 // If we have the JSON threads info, we can get the thread list from that 1704 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray(); 1705 if (thread_infos && thread_infos->GetSize() > 0) 1706 { 1707 m_thread_ids.clear(); 1708 m_thread_pcs.clear(); 1709 thread_infos->ForEach([this](StructuredData::Object* object) -> bool { 1710 StructuredData::Dictionary *thread_dict = object->GetAsDictionary(); 1711 if (thread_dict) 1712 { 1713 // Set the thread stop info from the JSON dictionary 1714 SetThreadStopInfo (thread_dict); 1715 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 1716 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>("tid", tid)) 1717 m_thread_ids.push_back(tid); 1718 } 1719 return true; // Keep iterating through all thread_info objects 1720 }); 1721 } 1722 if (!m_thread_ids.empty()) 1723 return true; 1724 } 1725 else 1726 { 1727 // See if we can get the thread IDs from the current stop reply packets 1728 // that might contain a "threads" key/value pair 1729 1730 // Lock the thread stack while we access it 1731 //Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex); 1732 std::unique_lock<std::recursive_mutex> stop_stack_lock(m_last_stop_packet_mutex, std::defer_lock); 1733 if (stop_stack_lock.try_lock()) 1734 { 1735 // Get the number of stop packets on the stack 1736 int nItems = m_stop_packet_stack.size(); 1737 // Iterate over them 1738 for (int i = 0; i < nItems; i++) 1739 { 1740 // Get the thread stop info 1741 StringExtractorGDBRemote &stop_info = m_stop_packet_stack[i]; 1742 const std::string &stop_info_str = stop_info.GetStringRef(); 1743 1744 m_thread_pcs.clear(); 1745 const size_t thread_pcs_pos = stop_info_str.find(";thread-pcs:"); 1746 if (thread_pcs_pos != std::string::npos) 1747 { 1748 const size_t start = thread_pcs_pos + strlen(";thread-pcs:"); 1749 const size_t end = stop_info_str.find(';', start); 1750 if (end != std::string::npos) 1751 { 1752 std::string value = stop_info_str.substr(start, end - start); 1753 UpdateThreadPCsFromStopReplyThreadsValue(value); 1754 } 1755 } 1756 1757 const size_t threads_pos = stop_info_str.find(";threads:"); 1758 if (threads_pos != std::string::npos) 1759 { 1760 const size_t start = threads_pos + strlen(";threads:"); 1761 const size_t end = stop_info_str.find(';', start); 1762 if (end != std::string::npos) 1763 { 1764 std::string value = stop_info_str.substr(start, end - start); 1765 if (UpdateThreadIDsFromStopReplyThreadsValue(value)) 1766 return true; 1767 } 1768 } 1769 } 1770 } 1771 } 1772 1773 bool sequence_mutex_unavailable = false; 1774 m_gdb_comm.GetCurrentThreadIDs (m_thread_ids, sequence_mutex_unavailable); 1775 if (sequence_mutex_unavailable) 1776 { 1777 return false; // We just didn't get the list 1778 } 1779 return true; 1780 } 1781 1782 bool 1783 ProcessGDBRemote::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new_thread_list) 1784 { 1785 // locker will keep a mutex locked until it goes out of scope 1786 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_THREAD)); 1787 if (log && log->GetMask().Test(GDBR_LOG_VERBOSE)) 1788 log->Printf ("ProcessGDBRemote::%s (pid = %" PRIu64 ")", __FUNCTION__, GetID()); 1789 1790 size_t num_thread_ids = m_thread_ids.size(); 1791 // The "m_thread_ids" thread ID list should always be updated after each stop 1792 // reply packet, but in case it isn't, update it here. 1793 if (num_thread_ids == 0) 1794 { 1795 if (!UpdateThreadIDList ()) 1796 return false; 1797 num_thread_ids = m_thread_ids.size(); 1798 } 1799 1800 ThreadList old_thread_list_copy(old_thread_list); 1801 if (num_thread_ids > 0) 1802 { 1803 for (size_t i=0; i<num_thread_ids; ++i) 1804 { 1805 tid_t tid = m_thread_ids[i]; 1806 ThreadSP thread_sp (old_thread_list_copy.RemoveThreadByProtocolID(tid, false)); 1807 if (!thread_sp) 1808 { 1809 thread_sp.reset (new ThreadGDBRemote (*this, tid)); 1810 if (log && log->GetMask().Test(GDBR_LOG_VERBOSE)) 1811 log->Printf( 1812 "ProcessGDBRemote::%s Making new thread: %p for thread ID: 0x%" PRIx64 ".\n", 1813 __FUNCTION__, static_cast<void*>(thread_sp.get()), 1814 thread_sp->GetID()); 1815 } 1816 else 1817 { 1818 if (log && log->GetMask().Test(GDBR_LOG_VERBOSE)) 1819 log->Printf( 1820 "ProcessGDBRemote::%s Found old thread: %p for thread ID: 0x%" PRIx64 ".\n", 1821 __FUNCTION__, static_cast<void*>(thread_sp.get()), 1822 thread_sp->GetID()); 1823 } 1824 // The m_thread_pcs vector has pc values in big-endian order, not target-endian, unlike most 1825 // of the register read/write packets in gdb-remote protocol. 1826 // Early in the process startup, we may not yet have set the process ByteOrder so we ignore these; 1827 // they are a performance improvement over fetching thread register values individually, the 1828 // method we will fall back to if needed. 1829 if (m_thread_ids.size() == m_thread_pcs.size() && thread_sp.get() && GetByteOrder() != eByteOrderInvalid) 1830 { 1831 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get()); 1832 RegisterContextSP reg_ctx_sp (thread_sp->GetRegisterContext()); 1833 if (reg_ctx_sp) 1834 { 1835 uint32_t pc_regnum = reg_ctx_sp->ConvertRegisterKindToRegisterNumber 1836 (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC); 1837 if (pc_regnum != LLDB_INVALID_REGNUM) 1838 { 1839 gdb_thread->PrivateSetRegisterValue (pc_regnum, m_thread_pcs[i]); 1840 } 1841 } 1842 } 1843 new_thread_list.AddThreadSortedByIndexID (thread_sp); 1844 } 1845 } 1846 1847 // Whatever that is left in old_thread_list_copy are not 1848 // present in new_thread_list. Remove non-existent threads from internal id table. 1849 size_t old_num_thread_ids = old_thread_list_copy.GetSize(false); 1850 for (size_t i=0; i<old_num_thread_ids; i++) 1851 { 1852 ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex (i, false)); 1853 if (old_thread_sp) 1854 { 1855 lldb::tid_t old_thread_id = old_thread_sp->GetProtocolID(); 1856 m_thread_id_to_index_id_map.erase(old_thread_id); 1857 } 1858 } 1859 1860 return true; 1861 } 1862 1863 1864 bool 1865 ProcessGDBRemote::GetThreadStopInfoFromJSON (ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp) 1866 { 1867 // See if we got thread stop infos for all threads via the "jThreadsInfo" packet 1868 if (thread_infos_sp) 1869 { 1870 StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray(); 1871 if (thread_infos) 1872 { 1873 lldb::tid_t tid; 1874 const size_t n = thread_infos->GetSize(); 1875 for (size_t i=0; i<n; ++i) 1876 { 1877 StructuredData::Dictionary *thread_dict = thread_infos->GetItemAtIndex(i)->GetAsDictionary(); 1878 if (thread_dict) 1879 { 1880 if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>("tid", tid, LLDB_INVALID_THREAD_ID)) 1881 { 1882 if (tid == thread->GetID()) 1883 return (bool)SetThreadStopInfo(thread_dict); 1884 } 1885 } 1886 } 1887 } 1888 } 1889 return false; 1890 } 1891 1892 bool 1893 ProcessGDBRemote::CalculateThreadStopInfo (ThreadGDBRemote *thread) 1894 { 1895 // See if we got thread stop infos for all threads via the "jThreadsInfo" packet 1896 if (GetThreadStopInfoFromJSON (thread, m_jthreadsinfo_sp)) 1897 return true; 1898 1899 // See if we got thread stop info for any threads valid stop info reasons threads 1900 // via the "jstopinfo" packet stop reply packet key/value pair? 1901 if (m_jstopinfo_sp) 1902 { 1903 // If we have "jstopinfo" then we have stop descriptions for all threads 1904 // that have stop reasons, and if there is no entry for a thread, then 1905 // it has no stop reason. 1906 thread->GetRegisterContext()->InvalidateIfNeeded(true); 1907 if (!GetThreadStopInfoFromJSON (thread, m_jstopinfo_sp)) 1908 { 1909 thread->SetStopInfo (StopInfoSP()); 1910 } 1911 return true; 1912 } 1913 1914 // Fall back to using the qThreadStopInfo packet 1915 StringExtractorGDBRemote stop_packet; 1916 if (GetGDBRemote().GetThreadStopInfo(thread->GetProtocolID(), stop_packet)) 1917 return SetThreadStopInfo (stop_packet) == eStateStopped; 1918 return false; 1919 } 1920 1921 1922 ThreadSP 1923 ProcessGDBRemote::SetThreadStopInfo (lldb::tid_t tid, 1924 ExpeditedRegisterMap &expedited_register_map, 1925 uint8_t signo, 1926 const std::string &thread_name, 1927 const std::string &reason, 1928 const std::string &description, 1929 uint32_t exc_type, 1930 const std::vector<addr_t> &exc_data, 1931 addr_t thread_dispatch_qaddr, 1932 bool queue_vars_valid, // Set to true if queue_name, queue_kind and queue_serial are valid 1933 LazyBool associated_with_dispatch_queue, 1934 addr_t dispatch_queue_t, 1935 std::string &queue_name, 1936 QueueKind queue_kind, 1937 uint64_t queue_serial) 1938 { 1939 ThreadSP thread_sp; 1940 if (tid != LLDB_INVALID_THREAD_ID) 1941 { 1942 // Scope for "locker" below 1943 { 1944 // m_thread_list_real does have its own mutex, but we need to 1945 // hold onto the mutex between the call to m_thread_list_real.FindThreadByID(...) 1946 // and the m_thread_list_real.AddThread(...) so it doesn't change on us 1947 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex()); 1948 thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false); 1949 1950 if (!thread_sp) 1951 { 1952 // Create the thread if we need to 1953 thread_sp.reset (new ThreadGDBRemote (*this, tid)); 1954 m_thread_list_real.AddThread(thread_sp); 1955 } 1956 } 1957 1958 if (thread_sp) 1959 { 1960 ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get()); 1961 gdb_thread->GetRegisterContext()->InvalidateIfNeeded(true); 1962 1963 for (const auto &pair : expedited_register_map) 1964 { 1965 StringExtractor reg_value_extractor; 1966 reg_value_extractor.GetStringRef() = pair.second; 1967 gdb_thread->PrivateSetRegisterValue (pair.first, reg_value_extractor); 1968 } 1969 1970 thread_sp->SetName (thread_name.empty() ? NULL : thread_name.c_str()); 1971 1972 gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr); 1973 // Check if the GDB server was able to provide the queue name, kind and serial number 1974 if (queue_vars_valid) 1975 gdb_thread->SetQueueInfo(std::move(queue_name), queue_kind, queue_serial, dispatch_queue_t, associated_with_dispatch_queue); 1976 else 1977 gdb_thread->ClearQueueInfo(); 1978 1979 gdb_thread->SetAssociatedWithLibdispatchQueue (associated_with_dispatch_queue); 1980 1981 if (dispatch_queue_t != LLDB_INVALID_ADDRESS) 1982 gdb_thread->SetQueueLibdispatchQueueAddress (dispatch_queue_t); 1983 1984 // Make sure we update our thread stop reason just once 1985 if (!thread_sp->StopInfoIsUpToDate()) 1986 { 1987 thread_sp->SetStopInfo (StopInfoSP()); 1988 // If there's a memory thread backed by this thread, we need to use it to calcualte StopInfo. 1989 ThreadSP memory_thread_sp = m_thread_list.FindThreadByProtocolID(thread_sp->GetProtocolID()); 1990 if (memory_thread_sp) 1991 thread_sp = memory_thread_sp; 1992 1993 if (exc_type != 0) 1994 { 1995 const size_t exc_data_size = exc_data.size(); 1996 1997 thread_sp->SetStopInfo (StopInfoMachException::CreateStopReasonWithMachException (*thread_sp, 1998 exc_type, 1999 exc_data_size, 2000 exc_data_size >= 1 ? exc_data[0] : 0, 2001 exc_data_size >= 2 ? exc_data[1] : 0, 2002 exc_data_size >= 3 ? exc_data[2] : 0)); 2003 } 2004 else 2005 { 2006 bool handled = false; 2007 bool did_exec = false; 2008 if (!reason.empty()) 2009 { 2010 if (reason.compare("trace") == 0) 2011 { 2012 addr_t pc = thread_sp->GetRegisterContext()->GetPC(); 2013 lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc); 2014 2015 // If the current pc is a breakpoint site then the StopInfo should be set to Breakpoint 2016 // Otherwise, it will be set to Trace. 2017 if (bp_site_sp && bp_site_sp->ValidForThisThread(thread_sp.get())) 2018 { 2019 thread_sp->SetStopInfo( 2020 StopInfo::CreateStopReasonWithBreakpointSiteID(*thread_sp, bp_site_sp->GetID())); 2021 } 2022 else 2023 thread_sp->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp)); 2024 handled = true; 2025 } 2026 else if (reason.compare("breakpoint") == 0) 2027 { 2028 addr_t pc = thread_sp->GetRegisterContext()->GetPC(); 2029 lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc); 2030 if (bp_site_sp) 2031 { 2032 // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread, 2033 // we can just report no reason. We don't need to worry about stepping over the breakpoint here, that 2034 // will be taken care of when the thread resumes and notices that there's a breakpoint under the pc. 2035 handled = true; 2036 if (bp_site_sp->ValidForThisThread (thread_sp.get())) 2037 { 2038 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID (*thread_sp, bp_site_sp->GetID())); 2039 } 2040 else 2041 { 2042 StopInfoSP invalid_stop_info_sp; 2043 thread_sp->SetStopInfo (invalid_stop_info_sp); 2044 } 2045 } 2046 } 2047 else if (reason.compare("trap") == 0) 2048 { 2049 // Let the trap just use the standard signal stop reason below... 2050 } 2051 else if (reason.compare("watchpoint") == 0) 2052 { 2053 StringExtractor desc_extractor(description.c_str()); 2054 addr_t wp_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS); 2055 uint32_t wp_index = desc_extractor.GetU32(LLDB_INVALID_INDEX32); 2056 addr_t wp_hit_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS); 2057 watch_id_t watch_id = LLDB_INVALID_WATCH_ID; 2058 if (wp_addr != LLDB_INVALID_ADDRESS) 2059 { 2060 WatchpointSP wp_sp; 2061 ArchSpec::Core core = GetTarget().GetArchitecture().GetCore(); 2062 if ((core >= ArchSpec::kCore_mips_first && core <= ArchSpec::kCore_mips_last) || 2063 (core >= ArchSpec::eCore_arm_arm64 && core <= ArchSpec::eCore_arm_aarch64)) 2064 wp_sp = GetTarget().GetWatchpointList().FindByAddress(wp_hit_addr); 2065 if (!wp_sp) 2066 wp_sp = GetTarget().GetWatchpointList().FindByAddress(wp_addr); 2067 if (wp_sp) 2068 { 2069 wp_sp->SetHardwareIndex(wp_index); 2070 watch_id = wp_sp->GetID(); 2071 } 2072 } 2073 if (watch_id == LLDB_INVALID_WATCH_ID) 2074 { 2075 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_WATCHPOINTS)); 2076 if (log) log->Printf ("failed to find watchpoint"); 2077 } 2078 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithWatchpointID (*thread_sp, watch_id, wp_hit_addr)); 2079 handled = true; 2080 } 2081 else if (reason.compare("exception") == 0) 2082 { 2083 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithException(*thread_sp, description.c_str())); 2084 handled = true; 2085 } 2086 else if (reason.compare("exec") == 0) 2087 { 2088 did_exec = true; 2089 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithExec(*thread_sp)); 2090 handled = true; 2091 } 2092 } 2093 else if (!signo) 2094 { 2095 addr_t pc = thread_sp->GetRegisterContext()->GetPC(); 2096 lldb::BreakpointSiteSP bp_site_sp = 2097 thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc); 2098 2099 // If the current pc is a breakpoint site then the StopInfo should be set to Breakpoint 2100 // even though the remote stub did not set it as such. This can happen when 2101 // the thread is involuntarily interrupted (e.g. due to stops on other 2102 // threads) just as it is about to execute the breakpoint instruction. 2103 if (bp_site_sp && bp_site_sp->ValidForThisThread(thread_sp.get())) 2104 { 2105 thread_sp->SetStopInfo( 2106 StopInfo::CreateStopReasonWithBreakpointSiteID(*thread_sp, bp_site_sp->GetID())); 2107 handled = true; 2108 } 2109 } 2110 2111 if (!handled && signo && did_exec == false) 2112 { 2113 if (signo == SIGTRAP) 2114 { 2115 // Currently we are going to assume SIGTRAP means we are either 2116 // hitting a breakpoint or hardware single stepping. 2117 handled = true; 2118 addr_t pc = thread_sp->GetRegisterContext()->GetPC() + m_breakpoint_pc_offset; 2119 lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc); 2120 2121 if (bp_site_sp) 2122 { 2123 // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread, 2124 // we can just report no reason. We don't need to worry about stepping over the breakpoint here, that 2125 // will be taken care of when the thread resumes and notices that there's a breakpoint under the pc. 2126 if (bp_site_sp->ValidForThisThread (thread_sp.get())) 2127 { 2128 if(m_breakpoint_pc_offset != 0) 2129 thread_sp->GetRegisterContext()->SetPC(pc); 2130 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID (*thread_sp, bp_site_sp->GetID())); 2131 } 2132 else 2133 { 2134 StopInfoSP invalid_stop_info_sp; 2135 thread_sp->SetStopInfo (invalid_stop_info_sp); 2136 } 2137 } 2138 else 2139 { 2140 // If we were stepping then assume the stop was the result of the trace. If we were 2141 // not stepping then report the SIGTRAP. 2142 // FIXME: We are still missing the case where we single step over a trap instruction. 2143 if (thread_sp->GetTemporaryResumeState() == eStateStepping) 2144 thread_sp->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp)); 2145 else 2146 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal(*thread_sp, signo, description.c_str())); 2147 } 2148 } 2149 if (!handled) 2150 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo, description.c_str())); 2151 } 2152 2153 if (!description.empty()) 2154 { 2155 lldb::StopInfoSP stop_info_sp (thread_sp->GetStopInfo ()); 2156 if (stop_info_sp) 2157 { 2158 const char *stop_info_desc = stop_info_sp->GetDescription(); 2159 if (!stop_info_desc || !stop_info_desc[0]) 2160 stop_info_sp->SetDescription (description.c_str()); 2161 } 2162 else 2163 { 2164 thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithException (*thread_sp, description.c_str())); 2165 } 2166 } 2167 } 2168 } 2169 } 2170 } 2171 return thread_sp; 2172 } 2173 2174 lldb::ThreadSP 2175 ProcessGDBRemote::SetThreadStopInfo (StructuredData::Dictionary *thread_dict) 2176 { 2177 static ConstString g_key_tid("tid"); 2178 static ConstString g_key_name("name"); 2179 static ConstString g_key_reason("reason"); 2180 static ConstString g_key_metype("metype"); 2181 static ConstString g_key_medata("medata"); 2182 static ConstString g_key_qaddr("qaddr"); 2183 static ConstString g_key_dispatch_queue_t("dispatch_queue_t"); 2184 static ConstString g_key_associated_with_dispatch_queue("associated_with_dispatch_queue"); 2185 static ConstString g_key_queue_name("qname"); 2186 static ConstString g_key_queue_kind("qkind"); 2187 static ConstString g_key_queue_serial_number("qserialnum"); 2188 static ConstString g_key_registers("registers"); 2189 static ConstString g_key_memory("memory"); 2190 static ConstString g_key_address("address"); 2191 static ConstString g_key_bytes("bytes"); 2192 static ConstString g_key_description("description"); 2193 static ConstString g_key_signal("signal"); 2194 2195 // Stop with signal and thread info 2196 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 2197 uint8_t signo = 0; 2198 std::string value; 2199 std::string thread_name; 2200 std::string reason; 2201 std::string description; 2202 uint32_t exc_type = 0; 2203 std::vector<addr_t> exc_data; 2204 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS; 2205 ExpeditedRegisterMap expedited_register_map; 2206 bool queue_vars_valid = false; 2207 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS; 2208 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate; 2209 std::string queue_name; 2210 QueueKind queue_kind = eQueueKindUnknown; 2211 uint64_t queue_serial_number = 0; 2212 // Iterate through all of the thread dictionary key/value pairs from the structured data dictionary 2213 2214 thread_dict->ForEach([this, 2215 &tid, 2216 &expedited_register_map, 2217 &thread_name, 2218 &signo, 2219 &reason, 2220 &description, 2221 &exc_type, 2222 &exc_data, 2223 &thread_dispatch_qaddr, 2224 &queue_vars_valid, 2225 &associated_with_dispatch_queue, 2226 &dispatch_queue_t, 2227 &queue_name, 2228 &queue_kind, 2229 &queue_serial_number] 2230 (ConstString key, StructuredData::Object* object) -> bool 2231 { 2232 if (key == g_key_tid) 2233 { 2234 // thread in big endian hex 2235 tid = object->GetIntegerValue(LLDB_INVALID_THREAD_ID); 2236 } 2237 else if (key == g_key_metype) 2238 { 2239 // exception type in big endian hex 2240 exc_type = object->GetIntegerValue(0); 2241 } 2242 else if (key == g_key_medata) 2243 { 2244 // exception data in big endian hex 2245 StructuredData::Array *array = object->GetAsArray(); 2246 if (array) 2247 { 2248 array->ForEach([&exc_data](StructuredData::Object* object) -> bool { 2249 exc_data.push_back(object->GetIntegerValue()); 2250 return true; // Keep iterating through all array items 2251 }); 2252 } 2253 } 2254 else if (key == g_key_name) 2255 { 2256 thread_name = object->GetStringValue(); 2257 } 2258 else if (key == g_key_qaddr) 2259 { 2260 thread_dispatch_qaddr = object->GetIntegerValue(LLDB_INVALID_ADDRESS); 2261 } 2262 else if (key == g_key_queue_name) 2263 { 2264 queue_vars_valid = true; 2265 queue_name = object->GetStringValue(); 2266 } 2267 else if (key == g_key_queue_kind) 2268 { 2269 std::string queue_kind_str = object->GetStringValue(); 2270 if (queue_kind_str == "serial") 2271 { 2272 queue_vars_valid = true; 2273 queue_kind = eQueueKindSerial; 2274 } 2275 else if (queue_kind_str == "concurrent") 2276 { 2277 queue_vars_valid = true; 2278 queue_kind = eQueueKindConcurrent; 2279 } 2280 } 2281 else if (key == g_key_queue_serial_number) 2282 { 2283 queue_serial_number = object->GetIntegerValue(0); 2284 if (queue_serial_number != 0) 2285 queue_vars_valid = true; 2286 } 2287 else if (key == g_key_dispatch_queue_t) 2288 { 2289 dispatch_queue_t = object->GetIntegerValue(0); 2290 if (dispatch_queue_t != 0 && dispatch_queue_t != LLDB_INVALID_ADDRESS) 2291 queue_vars_valid = true; 2292 } 2293 else if (key == g_key_associated_with_dispatch_queue) 2294 { 2295 queue_vars_valid = true; 2296 bool associated = object->GetBooleanValue (); 2297 if (associated) 2298 associated_with_dispatch_queue = eLazyBoolYes; 2299 else 2300 associated_with_dispatch_queue = eLazyBoolNo; 2301 } 2302 else if (key == g_key_reason) 2303 { 2304 reason = object->GetStringValue(); 2305 } 2306 else if (key == g_key_description) 2307 { 2308 description = object->GetStringValue(); 2309 } 2310 else if (key == g_key_registers) 2311 { 2312 StructuredData::Dictionary *registers_dict = object->GetAsDictionary(); 2313 2314 if (registers_dict) 2315 { 2316 registers_dict->ForEach([&expedited_register_map](ConstString key, StructuredData::Object* object) -> bool { 2317 const uint32_t reg = StringConvert::ToUInt32 (key.GetCString(), UINT32_MAX, 10); 2318 if (reg != UINT32_MAX) 2319 expedited_register_map[reg] = object->GetStringValue(); 2320 return true; // Keep iterating through all array items 2321 }); 2322 } 2323 } 2324 else if (key == g_key_memory) 2325 { 2326 StructuredData::Array *array = object->GetAsArray(); 2327 if (array) 2328 { 2329 array->ForEach([this](StructuredData::Object* object) -> bool { 2330 StructuredData::Dictionary *mem_cache_dict = object->GetAsDictionary(); 2331 if (mem_cache_dict) 2332 { 2333 lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS; 2334 if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>("address", mem_cache_addr)) 2335 { 2336 if (mem_cache_addr != LLDB_INVALID_ADDRESS) 2337 { 2338 StringExtractor bytes; 2339 if (mem_cache_dict->GetValueForKeyAsString("bytes", bytes.GetStringRef())) 2340 { 2341 bytes.SetFilePos(0); 2342 2343 const size_t byte_size = bytes.GetStringRef().size()/2; 2344 DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0)); 2345 const size_t bytes_copied = bytes.GetHexBytes (data_buffer_sp->GetBytes(), byte_size, 0); 2346 if (bytes_copied == byte_size) 2347 m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp); 2348 } 2349 } 2350 } 2351 } 2352 return true; // Keep iterating through all array items 2353 }); 2354 } 2355 2356 } 2357 else if (key == g_key_signal) 2358 signo = object->GetIntegerValue(LLDB_INVALID_SIGNAL_NUMBER); 2359 return true; // Keep iterating through all dictionary key/value pairs 2360 }); 2361 2362 return SetThreadStopInfo (tid, 2363 expedited_register_map, 2364 signo, 2365 thread_name, 2366 reason, 2367 description, 2368 exc_type, 2369 exc_data, 2370 thread_dispatch_qaddr, 2371 queue_vars_valid, 2372 associated_with_dispatch_queue, 2373 dispatch_queue_t, 2374 queue_name, 2375 queue_kind, 2376 queue_serial_number); 2377 } 2378 2379 StateType 2380 ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet) 2381 { 2382 stop_packet.SetFilePos (0); 2383 const char stop_type = stop_packet.GetChar(); 2384 switch (stop_type) 2385 { 2386 case 'T': 2387 case 'S': 2388 { 2389 // This is a bit of a hack, but is is required. If we did exec, we 2390 // need to clear our thread lists and also know to rebuild our dynamic 2391 // register info before we lookup and threads and populate the expedited 2392 // register values so we need to know this right away so we can cleanup 2393 // and update our registers. 2394 const uint32_t stop_id = GetStopID(); 2395 if (stop_id == 0) 2396 { 2397 // Our first stop, make sure we have a process ID, and also make 2398 // sure we know about our registers 2399 if (GetID() == LLDB_INVALID_PROCESS_ID) 2400 { 2401 lldb::pid_t pid = m_gdb_comm.GetCurrentProcessID (); 2402 if (pid != LLDB_INVALID_PROCESS_ID) 2403 SetID (pid); 2404 } 2405 BuildDynamicRegisterInfo (true); 2406 } 2407 // Stop with signal and thread info 2408 lldb::tid_t tid = LLDB_INVALID_THREAD_ID; 2409 const uint8_t signo = stop_packet.GetHexU8(); 2410 std::string key; 2411 std::string value; 2412 std::string thread_name; 2413 std::string reason; 2414 std::string description; 2415 uint32_t exc_type = 0; 2416 std::vector<addr_t> exc_data; 2417 addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS; 2418 bool queue_vars_valid = false; // says if locals below that start with "queue_" are valid 2419 addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS; 2420 LazyBool associated_with_dispatch_queue = eLazyBoolCalculate; 2421 std::string queue_name; 2422 QueueKind queue_kind = eQueueKindUnknown; 2423 uint64_t queue_serial_number = 0; 2424 ExpeditedRegisterMap expedited_register_map; 2425 while (stop_packet.GetNameColonValue(key, value)) 2426 { 2427 if (key.compare("metype") == 0) 2428 { 2429 // exception type in big endian hex 2430 exc_type = StringConvert::ToUInt32 (value.c_str(), 0, 16); 2431 } 2432 else if (key.compare("medata") == 0) 2433 { 2434 // exception data in big endian hex 2435 exc_data.push_back(StringConvert::ToUInt64 (value.c_str(), 0, 16)); 2436 } 2437 else if (key.compare("thread") == 0) 2438 { 2439 // thread in big endian hex 2440 tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16); 2441 } 2442 else if (key.compare("threads") == 0) 2443 { 2444 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex()); 2445 2446 m_thread_ids.clear(); 2447 // A comma separated list of all threads in the current 2448 // process that includes the thread for this stop reply 2449 // packet 2450 size_t comma_pos; 2451 lldb::tid_t tid; 2452 while ((comma_pos = value.find(',')) != std::string::npos) 2453 { 2454 value[comma_pos] = '\0'; 2455 // thread in big endian hex 2456 tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16); 2457 if (tid != LLDB_INVALID_THREAD_ID) 2458 m_thread_ids.push_back (tid); 2459 value.erase(0, comma_pos + 1); 2460 } 2461 tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16); 2462 if (tid != LLDB_INVALID_THREAD_ID) 2463 m_thread_ids.push_back (tid); 2464 } 2465 else if (key.compare("thread-pcs") == 0) 2466 { 2467 m_thread_pcs.clear(); 2468 // A comma separated list of all threads in the current 2469 // process that includes the thread for this stop reply 2470 // packet 2471 size_t comma_pos; 2472 lldb::addr_t pc; 2473 while ((comma_pos = value.find(',')) != std::string::npos) 2474 { 2475 value[comma_pos] = '\0'; 2476 // thread in big endian hex 2477 pc = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16); 2478 if (pc != LLDB_INVALID_ADDRESS) 2479 m_thread_pcs.push_back (pc); 2480 value.erase(0, comma_pos + 1); 2481 } 2482 pc = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16); 2483 if (pc != LLDB_INVALID_ADDRESS) 2484 m_thread_pcs.push_back (pc); 2485 } 2486 else if (key.compare("jstopinfo") == 0) 2487 { 2488 StringExtractor json_extractor; 2489 // Swap "value" over into "name_extractor" 2490 json_extractor.GetStringRef().swap(value); 2491 // Now convert the HEX bytes into a string value 2492 json_extractor.GetHexByteString (value); 2493 2494 // This JSON contains thread IDs and thread stop info for all threads. 2495 // It doesn't contain expedited registers, memory or queue info. 2496 m_jstopinfo_sp = StructuredData::ParseJSON (value); 2497 } 2498 else if (key.compare("hexname") == 0) 2499 { 2500 StringExtractor name_extractor; 2501 // Swap "value" over into "name_extractor" 2502 name_extractor.GetStringRef().swap(value); 2503 // Now convert the HEX bytes into a string value 2504 name_extractor.GetHexByteString (value); 2505 thread_name.swap (value); 2506 } 2507 else if (key.compare("name") == 0) 2508 { 2509 thread_name.swap (value); 2510 } 2511 else if (key.compare("qaddr") == 0) 2512 { 2513 thread_dispatch_qaddr = StringConvert::ToUInt64 (value.c_str(), 0, 16); 2514 } 2515 else if (key.compare("dispatch_queue_t") == 0) 2516 { 2517 queue_vars_valid = true; 2518 dispatch_queue_t = StringConvert::ToUInt64 (value.c_str(), 0, 16); 2519 } 2520 else if (key.compare("qname") == 0) 2521 { 2522 queue_vars_valid = true; 2523 StringExtractor name_extractor; 2524 // Swap "value" over into "name_extractor" 2525 name_extractor.GetStringRef().swap(value); 2526 // Now convert the HEX bytes into a string value 2527 name_extractor.GetHexByteString (value); 2528 queue_name.swap (value); 2529 } 2530 else if (key.compare("qkind") == 0) 2531 { 2532 if (value == "serial") 2533 { 2534 queue_vars_valid = true; 2535 queue_kind = eQueueKindSerial; 2536 } 2537 else if (value == "concurrent") 2538 { 2539 queue_vars_valid = true; 2540 queue_kind = eQueueKindConcurrent; 2541 } 2542 } 2543 else if (key.compare("qserialnum") == 0) 2544 { 2545 queue_serial_number = StringConvert::ToUInt64 (value.c_str(), 0, 0); 2546 if (queue_serial_number != 0) 2547 queue_vars_valid = true; 2548 } 2549 else if (key.compare("reason") == 0) 2550 { 2551 reason.swap(value); 2552 } 2553 else if (key.compare("description") == 0) 2554 { 2555 StringExtractor desc_extractor; 2556 // Swap "value" over into "name_extractor" 2557 desc_extractor.GetStringRef().swap(value); 2558 // Now convert the HEX bytes into a string value 2559 desc_extractor.GetHexByteString (value); 2560 description.swap(value); 2561 } 2562 else if (key.compare("memory") == 0) 2563 { 2564 // Expedited memory. GDB servers can choose to send back expedited memory 2565 // that can populate the L1 memory cache in the process so that things like 2566 // the frame pointer backchain can be expedited. This will help stack 2567 // backtracing be more efficient by not having to send as many memory read 2568 // requests down the remote GDB server. 2569 2570 // Key/value pair format: memory:<addr>=<bytes>; 2571 // <addr> is a number whose base will be interpreted by the prefix: 2572 // "0x[0-9a-fA-F]+" for hex 2573 // "0[0-7]+" for octal 2574 // "[1-9]+" for decimal 2575 // <bytes> is native endian ASCII hex bytes just like the register values 2576 llvm::StringRef value_ref(value); 2577 std::pair<llvm::StringRef, llvm::StringRef> pair; 2578 pair = value_ref.split('='); 2579 if (!pair.first.empty() && !pair.second.empty()) 2580 { 2581 std::string addr_str(pair.first.str()); 2582 const lldb::addr_t mem_cache_addr = StringConvert::ToUInt64(addr_str.c_str(), LLDB_INVALID_ADDRESS, 0); 2583 if (mem_cache_addr != LLDB_INVALID_ADDRESS) 2584 { 2585 StringExtractor bytes; 2586 bytes.GetStringRef() = pair.second.str(); 2587 const size_t byte_size = bytes.GetStringRef().size()/2; 2588 DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0)); 2589 const size_t bytes_copied = bytes.GetHexBytes (data_buffer_sp->GetBytes(), byte_size, 0); 2590 if (bytes_copied == byte_size) 2591 m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp); 2592 } 2593 } 2594 } 2595 else if (key.compare("watch") == 0 || key.compare("rwatch") == 0 || key.compare("awatch") == 0) 2596 { 2597 // Support standard GDB remote stop reply packet 'TAAwatch:addr' 2598 lldb::addr_t wp_addr = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16); 2599 WatchpointSP wp_sp = GetTarget().GetWatchpointList().FindByAddress(wp_addr); 2600 uint32_t wp_index = LLDB_INVALID_INDEX32; 2601 2602 if (wp_sp) 2603 wp_index = wp_sp->GetHardwareIndex(); 2604 2605 reason = "watchpoint"; 2606 StreamString ostr; 2607 ostr.Printf("%" PRIu64 " %" PRIu32, wp_addr, wp_index); 2608 description = ostr.GetString().c_str(); 2609 } 2610 else if (key.compare("library") == 0) 2611 { 2612 LoadModules(); 2613 } 2614 else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) 2615 { 2616 uint32_t reg = StringConvert::ToUInt32 (key.c_str(), UINT32_MAX, 16); 2617 if (reg != UINT32_MAX) 2618 expedited_register_map[reg] = std::move(value); 2619 } 2620 } 2621 2622 if (tid == LLDB_INVALID_THREAD_ID) 2623 { 2624 // A thread id may be invalid if the response is old style 'S' packet which does not provide the 2625 // thread information. So update the thread list and choose the first one. 2626 UpdateThreadIDList (); 2627 2628 if (!m_thread_ids.empty ()) 2629 { 2630 tid = m_thread_ids.front (); 2631 } 2632 } 2633 2634 ThreadSP thread_sp = SetThreadStopInfo (tid, 2635 expedited_register_map, 2636 signo, 2637 thread_name, 2638 reason, 2639 description, 2640 exc_type, 2641 exc_data, 2642 thread_dispatch_qaddr, 2643 queue_vars_valid, 2644 associated_with_dispatch_queue, 2645 dispatch_queue_t, 2646 queue_name, 2647 queue_kind, 2648 queue_serial_number); 2649 2650 return eStateStopped; 2651 } 2652 break; 2653 2654 case 'W': 2655 case 'X': 2656 // process exited 2657 return eStateExited; 2658 2659 default: 2660 break; 2661 } 2662 return eStateInvalid; 2663 } 2664 2665 void 2666 ProcessGDBRemote::RefreshStateAfterStop () 2667 { 2668 std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex()); 2669 2670 m_thread_ids.clear(); 2671 m_thread_pcs.clear(); 2672 // Set the thread stop info. It might have a "threads" key whose value is 2673 // a list of all thread IDs in the current process, so m_thread_ids might 2674 // get set. 2675 2676 // Scope for the lock 2677 { 2678 // Lock the thread stack while we access it 2679 std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex); 2680 // Get the number of stop packets on the stack 2681 int nItems = m_stop_packet_stack.size(); 2682 // Iterate over them 2683 for (int i = 0; i < nItems; i++) 2684 { 2685 // Get the thread stop info 2686 StringExtractorGDBRemote stop_info = m_stop_packet_stack[i]; 2687 // Process thread stop info 2688 SetThreadStopInfo(stop_info); 2689 } 2690 // Clear the thread stop stack 2691 m_stop_packet_stack.clear(); 2692 } 2693 2694 // Check to see if SetThreadStopInfo() filled in m_thread_ids? 2695 if (m_thread_ids.empty()) 2696 { 2697 // No, we need to fetch the thread list manually 2698 UpdateThreadIDList(); 2699 } 2700 2701 // If we have queried for a default thread id 2702 if (m_initial_tid != LLDB_INVALID_THREAD_ID) 2703 { 2704 m_thread_list.SetSelectedThreadByID(m_initial_tid); 2705 m_initial_tid = LLDB_INVALID_THREAD_ID; 2706 } 2707 2708 // Let all threads recover from stopping and do any clean up based 2709 // on the previous thread state (if any). 2710 m_thread_list_real.RefreshStateAfterStop(); 2711 2712 } 2713 2714 Error 2715 ProcessGDBRemote::DoHalt (bool &caused_stop) 2716 { 2717 Error error; 2718 2719 bool timed_out = false; 2720 Mutex::Locker locker; 2721 2722 if (m_public_state.GetValue() == eStateAttaching) 2723 { 2724 // We are being asked to halt during an attach. We need to just close 2725 // our file handle and debugserver will go away, and we can be done... 2726 m_gdb_comm.Disconnect(); 2727 } 2728 else 2729 { 2730 if (!m_gdb_comm.SendInterrupt (locker, 2, timed_out)) 2731 { 2732 if (timed_out) 2733 error.SetErrorString("timed out sending interrupt packet"); 2734 else 2735 error.SetErrorString("unknown error sending interrupt packet"); 2736 } 2737 2738 caused_stop = m_gdb_comm.GetInterruptWasSent (); 2739 } 2740 return error; 2741 } 2742 2743 Error 2744 ProcessGDBRemote::DoDetach(bool keep_stopped) 2745 { 2746 Error error; 2747 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 2748 if (log) 2749 log->Printf ("ProcessGDBRemote::DoDetach(keep_stopped: %i)", keep_stopped); 2750 2751 error = m_gdb_comm.Detach (keep_stopped); 2752 if (log) 2753 { 2754 if (error.Success()) 2755 log->PutCString ("ProcessGDBRemote::DoDetach() detach packet sent successfully"); 2756 else 2757 log->Printf ("ProcessGDBRemote::DoDetach() detach packet send failed: %s", error.AsCString() ? error.AsCString() : "<unknown error>"); 2758 } 2759 2760 if (!error.Success()) 2761 return error; 2762 2763 // Sleep for one second to let the process get all detached... 2764 StopAsyncThread (); 2765 2766 SetPrivateState (eStateDetached); 2767 ResumePrivateStateThread(); 2768 2769 //KillDebugserverProcess (); 2770 return error; 2771 } 2772 2773 2774 Error 2775 ProcessGDBRemote::DoDestroy () 2776 { 2777 Error error; 2778 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 2779 if (log) 2780 log->Printf ("ProcessGDBRemote::DoDestroy()"); 2781 2782 // There is a bug in older iOS debugservers where they don't shut down the process 2783 // they are debugging properly. If the process is sitting at a breakpoint or an exception, 2784 // this can cause problems with restarting. So we check to see if any of our threads are stopped 2785 // at a breakpoint, and if so we remove all the breakpoints, resume the process, and THEN 2786 // destroy it again. 2787 // 2788 // Note, we don't have a good way to test the version of debugserver, but I happen to know that 2789 // the set of all the iOS debugservers which don't support GetThreadSuffixSupported() and that of 2790 // the debugservers with this bug are equal. There really should be a better way to test this! 2791 // 2792 // We also use m_destroy_tried_resuming to make sure we only do this once, if we resume and then halt and 2793 // get called here to destroy again and we're still at a breakpoint or exception, then we should 2794 // just do the straight-forward kill. 2795 // 2796 // And of course, if we weren't able to stop the process by the time we get here, it isn't 2797 // necessary (or helpful) to do any of this. 2798 2799 if (!m_gdb_comm.GetThreadSuffixSupported() && m_public_state.GetValue() != eStateRunning) 2800 { 2801 PlatformSP platform_sp = GetTarget().GetPlatform(); 2802 2803 // FIXME: These should be ConstStrings so we aren't doing strcmp'ing. 2804 if (platform_sp 2805 && platform_sp->GetName() 2806 && platform_sp->GetName() == PlatformRemoteiOS::GetPluginNameStatic()) 2807 { 2808 if (m_destroy_tried_resuming) 2809 { 2810 if (log) 2811 log->PutCString ("ProcessGDBRemote::DoDestroy() - Tried resuming to destroy once already, not doing it again."); 2812 } 2813 else 2814 { 2815 // At present, the plans are discarded and the breakpoints disabled Process::Destroy, 2816 // but we really need it to happen here and it doesn't matter if we do it twice. 2817 m_thread_list.DiscardThreadPlans(); 2818 DisableAllBreakpointSites(); 2819 2820 bool stop_looks_like_crash = false; 2821 ThreadList &threads = GetThreadList(); 2822 2823 { 2824 std::lock_guard<std::recursive_mutex> guard(threads.GetMutex()); 2825 2826 size_t num_threads = threads.GetSize(); 2827 for (size_t i = 0; i < num_threads; i++) 2828 { 2829 ThreadSP thread_sp = threads.GetThreadAtIndex(i); 2830 StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo(); 2831 StopReason reason = eStopReasonInvalid; 2832 if (stop_info_sp) 2833 reason = stop_info_sp->GetStopReason(); 2834 if (reason == eStopReasonBreakpoint 2835 || reason == eStopReasonException) 2836 { 2837 if (log) 2838 log->Printf ("ProcessGDBRemote::DoDestroy() - thread: 0x%4.4" PRIx64 " stopped with reason: %s.", 2839 thread_sp->GetProtocolID(), 2840 stop_info_sp->GetDescription()); 2841 stop_looks_like_crash = true; 2842 break; 2843 } 2844 } 2845 } 2846 2847 if (stop_looks_like_crash) 2848 { 2849 if (log) 2850 log->PutCString ("ProcessGDBRemote::DoDestroy() - Stopped at a breakpoint, continue and then kill."); 2851 m_destroy_tried_resuming = true; 2852 2853 // If we are going to run again before killing, it would be good to suspend all the threads 2854 // before resuming so they won't get into more trouble. Sadly, for the threads stopped with 2855 // the breakpoint or exception, the exception doesn't get cleared if it is suspended, so we do 2856 // have to run the risk of letting those threads proceed a bit. 2857 2858 { 2859 std::lock_guard<std::recursive_mutex> guard(threads.GetMutex()); 2860 2861 size_t num_threads = threads.GetSize(); 2862 for (size_t i = 0; i < num_threads; i++) 2863 { 2864 ThreadSP thread_sp = threads.GetThreadAtIndex(i); 2865 StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo(); 2866 StopReason reason = eStopReasonInvalid; 2867 if (stop_info_sp) 2868 reason = stop_info_sp->GetStopReason(); 2869 if (reason != eStopReasonBreakpoint 2870 && reason != eStopReasonException) 2871 { 2872 if (log) 2873 log->Printf ("ProcessGDBRemote::DoDestroy() - Suspending thread: 0x%4.4" PRIx64 " before running.", 2874 thread_sp->GetProtocolID()); 2875 thread_sp->SetResumeState(eStateSuspended); 2876 } 2877 } 2878 } 2879 Resume (); 2880 return Destroy(false); 2881 } 2882 } 2883 } 2884 } 2885 2886 // Interrupt if our inferior is running... 2887 int exit_status = SIGABRT; 2888 std::string exit_string; 2889 2890 if (m_gdb_comm.IsConnected()) 2891 { 2892 if (m_public_state.GetValue() != eStateAttaching) 2893 { 2894 StringExtractorGDBRemote response; 2895 bool send_async = true; 2896 GDBRemoteCommunication::ScopedTimeout (m_gdb_comm, 3); 2897 2898 if (m_gdb_comm.SendPacketAndWaitForResponse("k", 1, response, send_async) == GDBRemoteCommunication::PacketResult::Success) 2899 { 2900 char packet_cmd = response.GetChar(0); 2901 2902 if (packet_cmd == 'W' || packet_cmd == 'X') 2903 { 2904 #if defined(__APPLE__) 2905 // For Native processes on Mac OS X, we launch through the Host Platform, then hand the process off 2906 // to debugserver, which becomes the parent process through "PT_ATTACH". Then when we go to kill 2907 // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then we call waitpid which returns 2908 // with no error and the correct status. But amusingly enough that doesn't seem to actually reap 2909 // the process, but instead it is left around as a Zombie. Probably the kernel is in the process of 2910 // switching ownership back to lldb which was the original parent, and gets confused in the handoff. 2911 // Anyway, so call waitpid here to finally reap it. 2912 PlatformSP platform_sp(GetTarget().GetPlatform()); 2913 if (platform_sp && platform_sp->IsHost()) 2914 { 2915 int status; 2916 ::pid_t reap_pid; 2917 reap_pid = waitpid (GetID(), &status, WNOHANG); 2918 if (log) 2919 log->Printf ("Reaped pid: %d, status: %d.\n", reap_pid, status); 2920 } 2921 #endif 2922 SetLastStopPacket (response); 2923 ClearThreadIDList (); 2924 exit_status = response.GetHexU8(); 2925 } 2926 else 2927 { 2928 if (log) 2929 log->Printf ("ProcessGDBRemote::DoDestroy - got unexpected response to k packet: %s", response.GetStringRef().c_str()); 2930 exit_string.assign("got unexpected response to k packet: "); 2931 exit_string.append(response.GetStringRef()); 2932 } 2933 } 2934 else 2935 { 2936 if (log) 2937 log->Printf ("ProcessGDBRemote::DoDestroy - failed to send k packet"); 2938 exit_string.assign("failed to send the k packet"); 2939 } 2940 } 2941 else 2942 { 2943 if (log) 2944 log->Printf ("ProcessGDBRemote::DoDestroy - killed or interrupted while attaching"); 2945 exit_string.assign ("killed or interrupted while attaching."); 2946 } 2947 } 2948 else 2949 { 2950 // If we missed setting the exit status on the way out, do it here. 2951 // NB set exit status can be called multiple times, the first one sets the status. 2952 exit_string.assign("destroying when not connected to debugserver"); 2953 } 2954 2955 SetExitStatus(exit_status, exit_string.c_str()); 2956 2957 StopAsyncThread (); 2958 KillDebugserverProcess (); 2959 return error; 2960 } 2961 2962 void 2963 ProcessGDBRemote::SetLastStopPacket (const StringExtractorGDBRemote &response) 2964 { 2965 const bool did_exec = response.GetStringRef().find(";reason:exec;") != std::string::npos; 2966 if (did_exec) 2967 { 2968 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 2969 if (log) 2970 log->Printf ("ProcessGDBRemote::SetLastStopPacket () - detected exec"); 2971 2972 m_thread_list_real.Clear(); 2973 m_thread_list.Clear(); 2974 BuildDynamicRegisterInfo (true); 2975 m_gdb_comm.ResetDiscoverableSettings (did_exec); 2976 } 2977 2978 // Scope the lock 2979 { 2980 // Lock the thread stack while we access it 2981 std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex); 2982 2983 // We are are not using non-stop mode, there can only be one last stop 2984 // reply packet, so clear the list. 2985 if (GetTarget().GetNonStopModeEnabled() == false) 2986 m_stop_packet_stack.clear(); 2987 2988 // Add this stop packet to the stop packet stack 2989 // This stack will get popped and examined when we switch to the 2990 // Stopped state 2991 m_stop_packet_stack.push_back(response); 2992 } 2993 } 2994 2995 void 2996 ProcessGDBRemote::SetUnixSignals(const UnixSignalsSP &signals_sp) 2997 { 2998 Process::SetUnixSignals(std::make_shared<GDBRemoteSignals>(signals_sp)); 2999 } 3000 3001 //------------------------------------------------------------------ 3002 // Process Queries 3003 //------------------------------------------------------------------ 3004 3005 bool 3006 ProcessGDBRemote::IsAlive () 3007 { 3008 return m_gdb_comm.IsConnected() && Process::IsAlive(); 3009 } 3010 3011 addr_t 3012 ProcessGDBRemote::GetImageInfoAddress() 3013 { 3014 // request the link map address via the $qShlibInfoAddr packet 3015 lldb::addr_t addr = m_gdb_comm.GetShlibInfoAddr(); 3016 3017 // the loaded module list can also provides a link map address 3018 if (addr == LLDB_INVALID_ADDRESS) 3019 { 3020 LoadedModuleInfoList list; 3021 if (GetLoadedModuleList (list).Success()) 3022 addr = list.m_link_map; 3023 } 3024 3025 return addr; 3026 } 3027 3028 void 3029 ProcessGDBRemote::WillPublicStop () 3030 { 3031 // See if the GDB remote client supports the JSON threads info. 3032 // If so, we gather stop info for all threads, expedited registers, 3033 // expedited memory, runtime queue information (iOS and MacOSX only), 3034 // and more. Expediting memory will help stack backtracing be much 3035 // faster. Expediting registers will make sure we don't have to read 3036 // the thread registers for GPRs. 3037 m_jthreadsinfo_sp = m_gdb_comm.GetThreadsInfo(); 3038 3039 if (m_jthreadsinfo_sp) 3040 { 3041 // Now set the stop info for each thread and also expedite any registers 3042 // and memory that was in the jThreadsInfo response. 3043 StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray(); 3044 if (thread_infos) 3045 { 3046 const size_t n = thread_infos->GetSize(); 3047 for (size_t i=0; i<n; ++i) 3048 { 3049 StructuredData::Dictionary *thread_dict = thread_infos->GetItemAtIndex(i)->GetAsDictionary(); 3050 if (thread_dict) 3051 SetThreadStopInfo(thread_dict); 3052 } 3053 } 3054 } 3055 } 3056 3057 //------------------------------------------------------------------ 3058 // Process Memory 3059 //------------------------------------------------------------------ 3060 size_t 3061 ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &error) 3062 { 3063 GetMaxMemorySize (); 3064 if (size > m_max_memory_size) 3065 { 3066 // Keep memory read sizes down to a sane limit. This function will be 3067 // called multiple times in order to complete the task by 3068 // lldb_private::Process so it is ok to do this. 3069 size = m_max_memory_size; 3070 } 3071 3072 char packet[64]; 3073 int packet_len; 3074 bool binary_memory_read = m_gdb_comm.GetxPacketSupported(); 3075 packet_len = ::snprintf(packet, sizeof(packet), "%c%" PRIx64 ",%" PRIx64, 3076 binary_memory_read ? 'x' : 'm', (uint64_t)addr, (uint64_t)size); 3077 assert (packet_len + 1 < (int)sizeof(packet)); 3078 StringExtractorGDBRemote response; 3079 if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, true) == GDBRemoteCommunication::PacketResult::Success) 3080 { 3081 if (response.IsNormalResponse()) 3082 { 3083 error.Clear(); 3084 if (binary_memory_read) 3085 { 3086 // The lower level GDBRemoteCommunication packet receive layer has already de-quoted any 3087 // 0x7d character escaping that was present in the packet 3088 3089 size_t data_received_size = response.GetBytesLeft(); 3090 if (data_received_size > size) 3091 { 3092 // Don't write past the end of BUF if the remote debug server gave us too 3093 // much data for some reason. 3094 data_received_size = size; 3095 } 3096 memcpy (buf, response.GetStringRef().data(), data_received_size); 3097 return data_received_size; 3098 } 3099 else 3100 { 3101 return response.GetHexBytes(buf, size, '\xdd'); 3102 } 3103 } 3104 else if (response.IsErrorResponse()) 3105 error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr); 3106 else if (response.IsUnsupportedResponse()) 3107 error.SetErrorStringWithFormat("GDB server does not support reading memory"); 3108 else 3109 error.SetErrorStringWithFormat("unexpected response to GDB server memory read packet '%s': '%s'", packet, response.GetStringRef().c_str()); 3110 } 3111 else 3112 { 3113 error.SetErrorStringWithFormat("failed to send packet: '%s'", packet); 3114 } 3115 return 0; 3116 } 3117 3118 size_t 3119 ProcessGDBRemote::DoWriteMemory (addr_t addr, const void *buf, size_t size, Error &error) 3120 { 3121 GetMaxMemorySize (); 3122 if (size > m_max_memory_size) 3123 { 3124 // Keep memory read sizes down to a sane limit. This function will be 3125 // called multiple times in order to complete the task by 3126 // lldb_private::Process so it is ok to do this. 3127 size = m_max_memory_size; 3128 } 3129 3130 StreamString packet; 3131 packet.Printf("M%" PRIx64 ",%" PRIx64 ":", addr, (uint64_t)size); 3132 packet.PutBytesAsRawHex8(buf, size, endian::InlHostByteOrder(), endian::InlHostByteOrder()); 3133 StringExtractorGDBRemote response; 3134 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, true) == GDBRemoteCommunication::PacketResult::Success) 3135 { 3136 if (response.IsOKResponse()) 3137 { 3138 error.Clear(); 3139 return size; 3140 } 3141 else if (response.IsErrorResponse()) 3142 error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64, addr); 3143 else if (response.IsUnsupportedResponse()) 3144 error.SetErrorStringWithFormat("GDB server does not support writing memory"); 3145 else 3146 error.SetErrorStringWithFormat("unexpected response to GDB server memory write packet '%s': '%s'", packet.GetString().c_str(), response.GetStringRef().c_str()); 3147 } 3148 else 3149 { 3150 error.SetErrorStringWithFormat("failed to send packet: '%s'", packet.GetString().c_str()); 3151 } 3152 return 0; 3153 } 3154 3155 lldb::addr_t 3156 ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &error) 3157 { 3158 Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_EXPRESSIONS)); 3159 addr_t allocated_addr = LLDB_INVALID_ADDRESS; 3160 3161 if (m_gdb_comm.SupportsAllocDeallocMemory() != eLazyBoolNo) 3162 { 3163 allocated_addr = m_gdb_comm.AllocateMemory (size, permissions); 3164 if (allocated_addr != LLDB_INVALID_ADDRESS || m_gdb_comm.SupportsAllocDeallocMemory() == eLazyBoolYes) 3165 return allocated_addr; 3166 } 3167 3168 if (m_gdb_comm.SupportsAllocDeallocMemory() == eLazyBoolNo) 3169 { 3170 // Call mmap() to create memory in the inferior.. 3171 unsigned prot = 0; 3172 if (permissions & lldb::ePermissionsReadable) 3173 prot |= eMmapProtRead; 3174 if (permissions & lldb::ePermissionsWritable) 3175 prot |= eMmapProtWrite; 3176 if (permissions & lldb::ePermissionsExecutable) 3177 prot |= eMmapProtExec; 3178 3179 if (InferiorCallMmap(this, allocated_addr, 0, size, prot, 3180 eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0)) 3181 m_addr_to_mmap_size[allocated_addr] = size; 3182 else 3183 { 3184 allocated_addr = LLDB_INVALID_ADDRESS; 3185 if (log) 3186 log->Printf ("ProcessGDBRemote::%s no direct stub support for memory allocation, and InferiorCallMmap also failed - is stub missing register context save/restore capability?", __FUNCTION__); 3187 } 3188 } 3189 3190 if (allocated_addr == LLDB_INVALID_ADDRESS) 3191 error.SetErrorStringWithFormat("unable to allocate %" PRIu64 " bytes of memory with permissions %s", (uint64_t)size, GetPermissionsAsCString (permissions)); 3192 else 3193 error.Clear(); 3194 return allocated_addr; 3195 } 3196 3197 Error 3198 ProcessGDBRemote::GetMemoryRegionInfo (addr_t load_addr, 3199 MemoryRegionInfo ®ion_info) 3200 { 3201 3202 Error error (m_gdb_comm.GetMemoryRegionInfo (load_addr, region_info)); 3203 return error; 3204 } 3205 3206 Error 3207 ProcessGDBRemote::GetWatchpointSupportInfo (uint32_t &num) 3208 { 3209 3210 Error error (m_gdb_comm.GetWatchpointSupportInfo (num)); 3211 return error; 3212 } 3213 3214 Error 3215 ProcessGDBRemote::GetWatchpointSupportInfo (uint32_t &num, bool& after) 3216 { 3217 Error error (m_gdb_comm.GetWatchpointSupportInfo (num, after, GetTarget().GetArchitecture())); 3218 return error; 3219 } 3220 3221 Error 3222 ProcessGDBRemote::DoDeallocateMemory (lldb::addr_t addr) 3223 { 3224 Error error; 3225 LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory(); 3226 3227 switch (supported) 3228 { 3229 case eLazyBoolCalculate: 3230 // We should never be deallocating memory without allocating memory 3231 // first so we should never get eLazyBoolCalculate 3232 error.SetErrorString ("tried to deallocate memory without ever allocating memory"); 3233 break; 3234 3235 case eLazyBoolYes: 3236 if (!m_gdb_comm.DeallocateMemory (addr)) 3237 error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64, addr); 3238 break; 3239 3240 case eLazyBoolNo: 3241 // Call munmap() to deallocate memory in the inferior.. 3242 { 3243 MMapMap::iterator pos = m_addr_to_mmap_size.find(addr); 3244 if (pos != m_addr_to_mmap_size.end() && 3245 InferiorCallMunmap(this, addr, pos->second)) 3246 m_addr_to_mmap_size.erase (pos); 3247 else 3248 error.SetErrorStringWithFormat("unable to deallocate memory at 0x%" PRIx64, addr); 3249 } 3250 break; 3251 } 3252 3253 return error; 3254 } 3255 3256 3257 //------------------------------------------------------------------ 3258 // Process STDIO 3259 //------------------------------------------------------------------ 3260 size_t 3261 ProcessGDBRemote::PutSTDIN (const char *src, size_t src_len, Error &error) 3262 { 3263 if (m_stdio_communication.IsConnected()) 3264 { 3265 ConnectionStatus status; 3266 m_stdio_communication.Write(src, src_len, status, NULL); 3267 } 3268 else if (m_stdin_forward) 3269 { 3270 m_gdb_comm.SendStdinNotification(src, src_len); 3271 } 3272 return 0; 3273 } 3274 3275 Error 3276 ProcessGDBRemote::EnableBreakpointSite (BreakpointSite *bp_site) 3277 { 3278 Error error; 3279 assert(bp_site != NULL); 3280 3281 // Get logging info 3282 Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS)); 3283 user_id_t site_id = bp_site->GetID(); 3284 3285 // Get the breakpoint address 3286 const addr_t addr = bp_site->GetLoadAddress(); 3287 3288 // Log that a breakpoint was requested 3289 if (log) 3290 log->Printf("ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64 ") address = 0x%" PRIx64, site_id, (uint64_t)addr); 3291 3292 // Breakpoint already exists and is enabled 3293 if (bp_site->IsEnabled()) 3294 { 3295 if (log) 3296 log->Printf("ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64 ") address = 0x%" PRIx64 " -- SUCCESS (already enabled)", site_id, (uint64_t)addr); 3297 return error; 3298 } 3299 3300 // Get the software breakpoint trap opcode size 3301 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site); 3302 3303 // SupportsGDBStoppointPacket() simply checks a boolean, indicating if this breakpoint type 3304 // is supported by the remote stub. These are set to true by default, and later set to false 3305 // only after we receive an unimplemented response when sending a breakpoint packet. This means 3306 // initially that unless we were specifically instructed to use a hardware breakpoint, LLDB will 3307 // attempt to set a software breakpoint. HardwareRequired() also queries a boolean variable which 3308 // indicates if the user specifically asked for hardware breakpoints. If true then we will 3309 // skip over software breakpoints. 3310 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware) && (!bp_site->HardwareRequired())) 3311 { 3312 // Try to send off a software breakpoint packet ($Z0) 3313 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointSoftware, true, addr, bp_op_size); 3314 if (error_no == 0) 3315 { 3316 // The breakpoint was placed successfully 3317 bp_site->SetEnabled(true); 3318 bp_site->SetType(BreakpointSite::eExternal); 3319 return error; 3320 } 3321 3322 // SendGDBStoppointTypePacket() will return an error if it was unable to set this 3323 // breakpoint. We need to differentiate between a error specific to placing this breakpoint 3324 // or if we have learned that this breakpoint type is unsupported. To do this, we 3325 // must test the support boolean for this breakpoint type to see if it now indicates that 3326 // this breakpoint type is unsupported. If they are still supported then we should return 3327 // with the error code. If they are now unsupported, then we would like to fall through 3328 // and try another form of breakpoint. 3329 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointSoftware)) 3330 { 3331 if (error_no != UINT8_MAX) 3332 error.SetErrorStringWithFormat("error: %d sending the breakpoint request", errno); 3333 else 3334 error.SetErrorString("error sending the breakpoint request"); 3335 return error; 3336 } 3337 3338 // We reach here when software breakpoints have been found to be unsupported. For future 3339 // calls to set a breakpoint, we will not attempt to set a breakpoint with a type that is 3340 // known not to be supported. 3341 if (log) 3342 log->Printf("Software breakpoints are unsupported"); 3343 3344 // So we will fall through and try a hardware breakpoint 3345 } 3346 3347 // The process of setting a hardware breakpoint is much the same as above. We check the 3348 // supported boolean for this breakpoint type, and if it is thought to be supported then we 3349 // will try to set this breakpoint with a hardware breakpoint. 3350 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointHardware)) 3351 { 3352 // Try to send off a hardware breakpoint packet ($Z1) 3353 uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointHardware, true, addr, bp_op_size); 3354 if (error_no == 0) 3355 { 3356 // The breakpoint was placed successfully 3357 bp_site->SetEnabled(true); 3358 bp_site->SetType(BreakpointSite::eHardware); 3359 return error; 3360 } 3361 3362 // Check if the error was something other then an unsupported breakpoint type 3363 if (m_gdb_comm.SupportsGDBStoppointPacket(eBreakpointHardware)) 3364 { 3365 // Unable to set this hardware breakpoint 3366 if (error_no != UINT8_MAX) 3367 error.SetErrorStringWithFormat("error: %d sending the hardware breakpoint request " 3368 "(hardware breakpoint resources might be exhausted or unavailable)", 3369 error_no); 3370 else 3371 error.SetErrorString("error sending the hardware breakpoint request (hardware breakpoint resources " 3372 "might be exhausted or unavailable)"); 3373 return error; 3374 } 3375 3376 // We will reach here when the stub gives an unsupported response to a hardware breakpoint 3377 if (log) 3378 log->Printf("Hardware breakpoints are unsupported"); 3379 3380 // Finally we will falling through to a #trap style breakpoint 3381 } 3382 3383 // Don't fall through when hardware breakpoints were specifically requested 3384 if (bp_site->HardwareRequired()) 3385 { 3386 error.SetErrorString("hardware breakpoints are not supported"); 3387 return error; 3388 } 3389 3390 // As a last resort we want to place a manual breakpoint. An instruction 3391 // is placed into the process memory using memory write packets. 3392 return EnableSoftwareBreakpoint(bp_site); 3393 } 3394 3395 Error 3396 ProcessGDBRemote::DisableBreakpointSite (BreakpointSite *bp_site) 3397 { 3398 Error error; 3399 assert (bp_site != NULL); 3400 addr_t addr = bp_site->GetLoadAddress(); 3401 user_id_t site_id = bp_site->GetID(); 3402 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_BREAKPOINTS)); 3403 if (log) 3404 log->Printf ("ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64 ") addr = 0x%8.8" PRIx64, site_id, (uint64_t)addr); 3405 3406 if (bp_site->IsEnabled()) 3407 { 3408 const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode (bp_site); 3409 3410 BreakpointSite::Type bp_type = bp_site->GetType(); 3411 switch (bp_type) 3412 { 3413 case BreakpointSite::eSoftware: 3414 error = DisableSoftwareBreakpoint (bp_site); 3415 break; 3416 3417 case BreakpointSite::eHardware: 3418 if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointHardware, false, addr, bp_op_size)) 3419 error.SetErrorToGenericError(); 3420 break; 3421 3422 case BreakpointSite::eExternal: 3423 { 3424 GDBStoppointType stoppoint_type; 3425 if (bp_site->IsHardware()) 3426 stoppoint_type = eBreakpointHardware; 3427 else 3428 stoppoint_type = eBreakpointSoftware; 3429 3430 if (m_gdb_comm.SendGDBStoppointTypePacket(stoppoint_type, false, addr, bp_op_size)) 3431 error.SetErrorToGenericError(); 3432 } 3433 break; 3434 } 3435 if (error.Success()) 3436 bp_site->SetEnabled(false); 3437 } 3438 else 3439 { 3440 if (log) 3441 log->Printf ("ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64 ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)", site_id, (uint64_t)addr); 3442 return error; 3443 } 3444 3445 if (error.Success()) 3446 error.SetErrorToGenericError(); 3447 return error; 3448 } 3449 3450 // Pre-requisite: wp != NULL. 3451 static GDBStoppointType 3452 GetGDBStoppointType (Watchpoint *wp) 3453 { 3454 assert(wp); 3455 bool watch_read = wp->WatchpointRead(); 3456 bool watch_write = wp->WatchpointWrite(); 3457 3458 // watch_read and watch_write cannot both be false. 3459 assert(watch_read || watch_write); 3460 if (watch_read && watch_write) 3461 return eWatchpointReadWrite; 3462 else if (watch_read) 3463 return eWatchpointRead; 3464 else // Must be watch_write, then. 3465 return eWatchpointWrite; 3466 } 3467 3468 Error 3469 ProcessGDBRemote::EnableWatchpoint (Watchpoint *wp, bool notify) 3470 { 3471 Error error; 3472 if (wp) 3473 { 3474 user_id_t watchID = wp->GetID(); 3475 addr_t addr = wp->GetLoadAddress(); 3476 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS)); 3477 if (log) 3478 log->Printf ("ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64 ")", watchID); 3479 if (wp->IsEnabled()) 3480 { 3481 if (log) 3482 log->Printf("ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64 ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.", watchID, (uint64_t)addr); 3483 return error; 3484 } 3485 3486 GDBStoppointType type = GetGDBStoppointType(wp); 3487 // Pass down an appropriate z/Z packet... 3488 if (m_gdb_comm.SupportsGDBStoppointPacket (type)) 3489 { 3490 if (m_gdb_comm.SendGDBStoppointTypePacket(type, true, addr, wp->GetByteSize()) == 0) 3491 { 3492 wp->SetEnabled(true, notify); 3493 return error; 3494 } 3495 else 3496 error.SetErrorString("sending gdb watchpoint packet failed"); 3497 } 3498 else 3499 error.SetErrorString("watchpoints not supported"); 3500 } 3501 else 3502 { 3503 error.SetErrorString("Watchpoint argument was NULL."); 3504 } 3505 if (error.Success()) 3506 error.SetErrorToGenericError(); 3507 return error; 3508 } 3509 3510 Error 3511 ProcessGDBRemote::DisableWatchpoint (Watchpoint *wp, bool notify) 3512 { 3513 Error error; 3514 if (wp) 3515 { 3516 user_id_t watchID = wp->GetID(); 3517 3518 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_WATCHPOINTS)); 3519 3520 addr_t addr = wp->GetLoadAddress(); 3521 3522 if (log) 3523 log->Printf ("ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64 ") addr = 0x%8.8" PRIx64, watchID, (uint64_t)addr); 3524 3525 if (!wp->IsEnabled()) 3526 { 3527 if (log) 3528 log->Printf ("ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64 ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)", watchID, (uint64_t)addr); 3529 // See also 'class WatchpointSentry' within StopInfo.cpp. 3530 // This disabling attempt might come from the user-supplied actions, we'll route it in order for 3531 // the watchpoint object to intelligently process this action. 3532 wp->SetEnabled(false, notify); 3533 return error; 3534 } 3535 3536 if (wp->IsHardware()) 3537 { 3538 GDBStoppointType type = GetGDBStoppointType(wp); 3539 // Pass down an appropriate z/Z packet... 3540 if (m_gdb_comm.SendGDBStoppointTypePacket(type, false, addr, wp->GetByteSize()) == 0) 3541 { 3542 wp->SetEnabled(false, notify); 3543 return error; 3544 } 3545 else 3546 error.SetErrorString("sending gdb watchpoint packet failed"); 3547 } 3548 // TODO: clear software watchpoints if we implement them 3549 } 3550 else 3551 { 3552 error.SetErrorString("Watchpoint argument was NULL."); 3553 } 3554 if (error.Success()) 3555 error.SetErrorToGenericError(); 3556 return error; 3557 } 3558 3559 void 3560 ProcessGDBRemote::Clear() 3561 { 3562 m_flags = 0; 3563 m_thread_list_real.Clear(); 3564 m_thread_list.Clear(); 3565 } 3566 3567 Error 3568 ProcessGDBRemote::DoSignal (int signo) 3569 { 3570 Error error; 3571 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 3572 if (log) 3573 log->Printf ("ProcessGDBRemote::DoSignal (signal = %d)", signo); 3574 3575 if (!m_gdb_comm.SendAsyncSignal (signo)) 3576 error.SetErrorStringWithFormat("failed to send signal %i", signo); 3577 return error; 3578 } 3579 3580 Error 3581 ProcessGDBRemote::EstablishConnectionIfNeeded (const ProcessInfo &process_info) 3582 { 3583 // Make sure we aren't already connected? 3584 if (m_gdb_comm.IsConnected()) 3585 return Error(); 3586 3587 PlatformSP platform_sp (GetTarget ().GetPlatform ()); 3588 if (platform_sp && !platform_sp->IsHost ()) 3589 return Error("Lost debug server connection"); 3590 3591 auto error = LaunchAndConnectToDebugserver (process_info); 3592 if (error.Fail()) 3593 { 3594 const char *error_string = error.AsCString(); 3595 if (error_string == nullptr) 3596 error_string = "unable to launch " DEBUGSERVER_BASENAME; 3597 } 3598 return error; 3599 } 3600 3601 Error 3602 ProcessGDBRemote::LaunchAndConnectToDebugserver (const ProcessInfo &process_info) 3603 { 3604 using namespace std::placeholders; // For _1, _2, etc. 3605 3606 Error error; 3607 if (m_debugserver_pid == LLDB_INVALID_PROCESS_ID) 3608 { 3609 // If we locate debugserver, keep that located version around 3610 static FileSpec g_debugserver_file_spec; 3611 3612 ProcessLaunchInfo debugserver_launch_info; 3613 // Make debugserver run in its own session so signals generated by 3614 // special terminal key sequences (^C) don't affect debugserver. 3615 debugserver_launch_info.SetLaunchInSeparateProcessGroup(true); 3616 3617 const std::weak_ptr<ProcessGDBRemote> this_wp = std::static_pointer_cast<ProcessGDBRemote>(shared_from_this()); 3618 debugserver_launch_info.SetMonitorProcessCallback(std::bind(MonitorDebugserverProcess, this_wp, _1, _2, _3, _4), 3619 false); 3620 debugserver_launch_info.SetUserID(process_info.GetUserID()); 3621 3622 #if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__)) 3623 // On iOS, still do a local connection using a random port 3624 const char *hostname = "127.0.0.1"; 3625 uint16_t port = get_random_port (); 3626 #else 3627 // Set hostname being NULL to do the reverse connect where debugserver 3628 // will bind to port zero and it will communicate back to us the port 3629 // that we will connect to 3630 const char *hostname = nullptr; 3631 uint16_t port = 0; 3632 #endif 3633 3634 StreamString url_str; 3635 const char* url = nullptr; 3636 if (hostname != nullptr) 3637 { 3638 url_str.Printf("%s:%u", hostname, port); 3639 url = url_str.GetData(); 3640 } 3641 3642 error = m_gdb_comm.StartDebugserverProcess (url, 3643 GetTarget().GetPlatform().get(), 3644 debugserver_launch_info, 3645 &port); 3646 3647 if (error.Success ()) 3648 m_debugserver_pid = debugserver_launch_info.GetProcessID(); 3649 else 3650 m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 3651 3652 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) 3653 StartAsyncThread (); 3654 3655 if (error.Fail()) 3656 { 3657 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 3658 3659 if (log) 3660 log->Printf("failed to start debugserver process: %s", error.AsCString()); 3661 return error; 3662 } 3663 3664 if (m_gdb_comm.IsConnected()) 3665 { 3666 // Finish the connection process by doing the handshake without connecting (send NULL URL) 3667 ConnectToDebugserver (NULL); 3668 } 3669 else 3670 { 3671 StreamString connect_url; 3672 connect_url.Printf("connect://%s:%u", hostname, port); 3673 error = ConnectToDebugserver (connect_url.GetString().c_str()); 3674 } 3675 3676 } 3677 return error; 3678 } 3679 3680 bool 3681 ProcessGDBRemote::MonitorDebugserverProcess(std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid, 3682 bool exited, // True if the process did exit 3683 int signo, // Zero for no signal 3684 int exit_status // Exit value of process if signal is zero 3685 ) 3686 { 3687 // "debugserver_pid" argument passed in is the process ID for 3688 // debugserver that we are tracking... 3689 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 3690 const bool handled = true; 3691 3692 if (log) 3693 log->Printf("ProcessGDBRemote::%s(process_wp, pid=%" PRIu64 ", signo=%i (0x%x), exit_status=%i)", __FUNCTION__, 3694 debugserver_pid, signo, signo, exit_status); 3695 3696 std::shared_ptr<ProcessGDBRemote> process_sp = process_wp.lock(); 3697 if (log) 3698 log->Printf("ProcessGDBRemote::%s(process = %p)", __FUNCTION__, static_cast<void *>(process_sp.get())); 3699 if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid) 3700 return handled; 3701 3702 // Sleep for a half a second to make sure our inferior process has 3703 // time to set its exit status before we set it incorrectly when 3704 // both the debugserver and the inferior process shut down. 3705 usleep(500000); 3706 // If our process hasn't yet exited, debugserver might have died. 3707 // If the process did exit, then we are reaping it. 3708 const StateType state = process_sp->GetState(); 3709 3710 if (state != eStateInvalid && state != eStateUnloaded && state != eStateExited && state != eStateDetached) 3711 { 3712 char error_str[1024]; 3713 if (signo) 3714 { 3715 const char *signal_cstr = process_sp->GetUnixSignals()->GetSignalAsCString(signo); 3716 if (signal_cstr) 3717 ::snprintf(error_str, sizeof(error_str), DEBUGSERVER_BASENAME " died with signal %s", signal_cstr); 3718 else 3719 ::snprintf(error_str, sizeof(error_str), DEBUGSERVER_BASENAME " died with signal %i", signo); 3720 } 3721 else 3722 { 3723 ::snprintf(error_str, sizeof(error_str), DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x", 3724 exit_status); 3725 } 3726 3727 process_sp->SetExitStatus(-1, error_str); 3728 } 3729 // Debugserver has exited we need to let our ProcessGDBRemote 3730 // know that it no longer has a debugserver instance 3731 process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 3732 return handled; 3733 } 3734 3735 void 3736 ProcessGDBRemote::KillDebugserverProcess () 3737 { 3738 m_gdb_comm.Disconnect(); 3739 if (m_debugserver_pid != LLDB_INVALID_PROCESS_ID) 3740 { 3741 Host::Kill (m_debugserver_pid, SIGINT); 3742 m_debugserver_pid = LLDB_INVALID_PROCESS_ID; 3743 } 3744 } 3745 3746 void 3747 ProcessGDBRemote::Initialize() 3748 { 3749 static std::once_flag g_once_flag; 3750 3751 std::call_once(g_once_flag, []() 3752 { 3753 PluginManager::RegisterPlugin (GetPluginNameStatic(), 3754 GetPluginDescriptionStatic(), 3755 CreateInstance, 3756 DebuggerInitialize); 3757 }); 3758 } 3759 3760 void 3761 ProcessGDBRemote::DebuggerInitialize (Debugger &debugger) 3762 { 3763 if (!PluginManager::GetSettingForProcessPlugin(debugger, PluginProperties::GetSettingName())) 3764 { 3765 const bool is_global_setting = true; 3766 PluginManager::CreateSettingForProcessPlugin (debugger, 3767 GetGlobalPluginProperties()->GetValueProperties(), 3768 ConstString ("Properties for the gdb-remote process plug-in."), 3769 is_global_setting); 3770 } 3771 } 3772 3773 bool 3774 ProcessGDBRemote::StartAsyncThread () 3775 { 3776 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 3777 3778 if (log) 3779 log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__); 3780 3781 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex); 3782 if (!m_async_thread.IsJoinable()) 3783 { 3784 // Create a thread that watches our internal state and controls which 3785 // events make it to clients (into the DCProcess event queue). 3786 3787 m_async_thread = ThreadLauncher::LaunchThread("<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this, NULL); 3788 } 3789 else if (log) 3790 log->Printf("ProcessGDBRemote::%s () - Called when Async thread was already running.", __FUNCTION__); 3791 3792 return m_async_thread.IsJoinable(); 3793 } 3794 3795 void 3796 ProcessGDBRemote::StopAsyncThread () 3797 { 3798 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS)); 3799 3800 if (log) 3801 log->Printf ("ProcessGDBRemote::%s ()", __FUNCTION__); 3802 3803 std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex); 3804 if (m_async_thread.IsJoinable()) 3805 { 3806 m_async_broadcaster.BroadcastEvent (eBroadcastBitAsyncThreadShouldExit); 3807 3808 // This will shut down the async thread. 3809 m_gdb_comm.Disconnect(); // Disconnect from the debug server. 3810 3811 // Stop the stdio thread 3812 m_async_thread.Join(nullptr); 3813 m_async_thread.Reset(); 3814 } 3815 else if (log) 3816 log->Printf("ProcessGDBRemote::%s () - Called when Async thread was not running.", __FUNCTION__); 3817 } 3818 3819 bool 3820 ProcessGDBRemote::HandleNotifyPacket (StringExtractorGDBRemote &packet) 3821 { 3822 // get the packet at a string 3823 const std::string &pkt = packet.GetStringRef(); 3824 // skip %stop: 3825 StringExtractorGDBRemote stop_info(pkt.c_str() + 5); 3826 3827 // pass as a thread stop info packet 3828 SetLastStopPacket(stop_info); 3829 3830 // check for more stop reasons 3831 HandleStopReplySequence(); 3832 3833 // if the process is stopped then we need to fake a resume 3834 // so that we can stop properly with the new break. This 3835 // is possible due to SetPrivateState() broadcasting the 3836 // state change as a side effect. 3837 if (GetPrivateState() == lldb::StateType::eStateStopped) 3838 { 3839 SetPrivateState(lldb::StateType::eStateRunning); 3840 } 3841 3842 // since we have some stopped packets we can halt the process 3843 SetPrivateState(lldb::StateType::eStateStopped); 3844 3845 return true; 3846 } 3847 3848 thread_result_t 3849 ProcessGDBRemote::AsyncThread (void *arg) 3850 { 3851 ProcessGDBRemote *process = (ProcessGDBRemote*) arg; 3852 3853 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS)); 3854 if (log) 3855 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") thread starting...", __FUNCTION__, arg, process->GetID()); 3856 3857 EventSP event_sp; 3858 bool done = false; 3859 while (!done) 3860 { 3861 if (log) 3862 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp)...", __FUNCTION__, arg, process->GetID()); 3863 if (process->m_async_listener_sp->WaitForEvent (NULL, event_sp)) 3864 { 3865 const uint32_t event_type = event_sp->GetType(); 3866 if (event_sp->BroadcasterIs (&process->m_async_broadcaster)) 3867 { 3868 if (log) 3869 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") Got an event of type: %d...", __FUNCTION__, arg, process->GetID(), event_type); 3870 3871 switch (event_type) 3872 { 3873 case eBroadcastBitAsyncContinue: 3874 { 3875 const EventDataBytes *continue_packet = EventDataBytes::GetEventDataFromEvent(event_sp.get()); 3876 3877 if (continue_packet) 3878 { 3879 const char *continue_cstr = (const char *)continue_packet->GetBytes (); 3880 const size_t continue_cstr_len = continue_packet->GetByteSize (); 3881 if (log) 3882 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") got eBroadcastBitAsyncContinue: %s", __FUNCTION__, arg, process->GetID(), continue_cstr); 3883 3884 if (::strstr (continue_cstr, "vAttach") == NULL) 3885 process->SetPrivateState(eStateRunning); 3886 StringExtractorGDBRemote response; 3887 3888 // If in Non-Stop-Mode 3889 if (process->GetTarget().GetNonStopModeEnabled()) 3890 { 3891 // send the vCont packet 3892 if (!process->GetGDBRemote().SendvContPacket(process, continue_cstr, continue_cstr_len, response)) 3893 { 3894 // Something went wrong 3895 done = true; 3896 break; 3897 } 3898 } 3899 // If in All-Stop-Mode 3900 else 3901 { 3902 StateType stop_state = process->GetGDBRemote().SendContinuePacketAndWaitForResponse (process, continue_cstr, continue_cstr_len, response); 3903 3904 // We need to immediately clear the thread ID list so we are sure to get a valid list of threads. 3905 // The thread ID list might be contained within the "response", or the stop reply packet that 3906 // caused the stop. So clear it now before we give the stop reply packet to the process 3907 // using the process->SetLastStopPacket()... 3908 process->ClearThreadIDList (); 3909 3910 switch (stop_state) 3911 { 3912 case eStateStopped: 3913 case eStateCrashed: 3914 case eStateSuspended: 3915 process->SetLastStopPacket (response); 3916 process->SetPrivateState (stop_state); 3917 break; 3918 3919 case eStateExited: 3920 { 3921 process->SetLastStopPacket (response); 3922 process->ClearThreadIDList(); 3923 response.SetFilePos(1); 3924 3925 int exit_status = response.GetHexU8(); 3926 const char *desc_cstr = NULL; 3927 StringExtractor extractor; 3928 std::string desc_string; 3929 if (response.GetBytesLeft() > 0 && response.GetChar('-') == ';') 3930 { 3931 std::string desc_token; 3932 while (response.GetNameColonValue (desc_token, desc_string)) 3933 { 3934 if (desc_token == "description") 3935 { 3936 extractor.GetStringRef().swap(desc_string); 3937 extractor.SetFilePos(0); 3938 extractor.GetHexByteString (desc_string); 3939 desc_cstr = desc_string.c_str(); 3940 } 3941 } 3942 } 3943 process->SetExitStatus(exit_status, desc_cstr); 3944 done = true; 3945 break; 3946 } 3947 case eStateInvalid: 3948 { 3949 // Check to see if we were trying to attach and if we got back 3950 // the "E87" error code from debugserver -- this indicates that 3951 // the process is not debuggable. Return a slightly more helpful 3952 // error message about why the attach failed. 3953 if (::strstr (continue_cstr, "vAttach") != NULL 3954 && response.GetError() == 0x87) 3955 { 3956 process->SetExitStatus(-1, "cannot attach to process due to System Integrity Protection"); 3957 } 3958 // E01 code from vAttach means that the attach failed 3959 if (::strstr (continue_cstr, "vAttach") != NULL 3960 && response.GetError() == 0x1) 3961 { 3962 process->SetExitStatus(-1, "unable to attach"); 3963 } 3964 else 3965 { 3966 process->SetExitStatus(-1, "lost connection"); 3967 } 3968 break; 3969 } 3970 3971 default: 3972 process->SetPrivateState (stop_state); 3973 break; 3974 } // switch(stop_state) 3975 } // else // if in All-stop-mode 3976 } // if (continue_packet) 3977 } // case eBroadcastBitAysncContinue 3978 break; 3979 3980 case eBroadcastBitAsyncThreadShouldExit: 3981 if (log) 3982 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") got eBroadcastBitAsyncThreadShouldExit...", __FUNCTION__, arg, process->GetID()); 3983 done = true; 3984 break; 3985 3986 default: 3987 if (log) 3988 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") got unknown event 0x%8.8x", __FUNCTION__, arg, process->GetID(), event_type); 3989 done = true; 3990 break; 3991 } 3992 } 3993 else if (event_sp->BroadcasterIs (&process->m_gdb_comm)) 3994 { 3995 switch (event_type) 3996 { 3997 case Communication::eBroadcastBitReadThreadDidExit: 3998 process->SetExitStatus (-1, "lost connection"); 3999 done = true; 4000 break; 4001 4002 case GDBRemoteCommunication::eBroadcastBitGdbReadThreadGotNotify: 4003 { 4004 lldb_private::Event *event = event_sp.get(); 4005 const EventDataBytes *continue_packet = EventDataBytes::GetEventDataFromEvent(event); 4006 StringExtractorGDBRemote notify((const char*)continue_packet->GetBytes()); 4007 // Hand this over to the process to handle 4008 process->HandleNotifyPacket(notify); 4009 break; 4010 } 4011 4012 default: 4013 if (log) 4014 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") got unknown event 0x%8.8x", __FUNCTION__, arg, process->GetID(), event_type); 4015 done = true; 4016 break; 4017 } 4018 } 4019 } 4020 else 4021 { 4022 if (log) 4023 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") listener.WaitForEvent (NULL, event_sp) => false", __FUNCTION__, arg, process->GetID()); 4024 done = true; 4025 } 4026 } 4027 4028 if (log) 4029 log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64 ") thread exiting...", __FUNCTION__, arg, process->GetID()); 4030 4031 return NULL; 4032 } 4033 4034 //uint32_t 4035 //ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList &matches, std::vector<lldb::pid_t> &pids) 4036 //{ 4037 // // If we are planning to launch the debugserver remotely, then we need to fire up a debugserver 4038 // // process and ask it for the list of processes. But if we are local, we can let the Host do it. 4039 // if (m_local_debugserver) 4040 // { 4041 // return Host::ListProcessesMatchingName (name, matches, pids); 4042 // } 4043 // else 4044 // { 4045 // // FIXME: Implement talking to the remote debugserver. 4046 // return 0; 4047 // } 4048 // 4049 //} 4050 // 4051 bool 4052 ProcessGDBRemote::NewThreadNotifyBreakpointHit (void *baton, 4053 StoppointCallbackContext *context, 4054 lldb::user_id_t break_id, 4055 lldb::user_id_t break_loc_id) 4056 { 4057 // I don't think I have to do anything here, just make sure I notice the new thread when it starts to 4058 // run so I can stop it if that's what I want to do. 4059 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 4060 if (log) 4061 log->Printf("Hit New Thread Notification breakpoint."); 4062 return false; 4063 } 4064 4065 4066 bool 4067 ProcessGDBRemote::StartNoticingNewThreads() 4068 { 4069 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 4070 if (m_thread_create_bp_sp) 4071 { 4072 if (log && log->GetVerbose()) 4073 log->Printf("Enabled noticing new thread breakpoint."); 4074 m_thread_create_bp_sp->SetEnabled(true); 4075 } 4076 else 4077 { 4078 PlatformSP platform_sp (GetTarget().GetPlatform()); 4079 if (platform_sp) 4080 { 4081 m_thread_create_bp_sp = platform_sp->SetThreadCreationBreakpoint(GetTarget()); 4082 if (m_thread_create_bp_sp) 4083 { 4084 if (log && log->GetVerbose()) 4085 log->Printf("Successfully created new thread notification breakpoint %i", m_thread_create_bp_sp->GetID()); 4086 m_thread_create_bp_sp->SetCallback (ProcessGDBRemote::NewThreadNotifyBreakpointHit, this, true); 4087 } 4088 else 4089 { 4090 if (log) 4091 log->Printf("Failed to create new thread notification breakpoint."); 4092 } 4093 } 4094 } 4095 return m_thread_create_bp_sp.get() != NULL; 4096 } 4097 4098 bool 4099 ProcessGDBRemote::StopNoticingNewThreads() 4100 { 4101 Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_STEP)); 4102 if (log && log->GetVerbose()) 4103 log->Printf ("Disabling new thread notification breakpoint."); 4104 4105 if (m_thread_create_bp_sp) 4106 m_thread_create_bp_sp->SetEnabled(false); 4107 4108 return true; 4109 } 4110 4111 DynamicLoader * 4112 ProcessGDBRemote::GetDynamicLoader () 4113 { 4114 if (m_dyld_ap.get() == NULL) 4115 m_dyld_ap.reset (DynamicLoader::FindPlugin(this, NULL)); 4116 return m_dyld_ap.get(); 4117 } 4118 4119 Error 4120 ProcessGDBRemote::SendEventData(const char *data) 4121 { 4122 int return_value; 4123 bool was_supported; 4124 4125 Error error; 4126 4127 return_value = m_gdb_comm.SendLaunchEventDataPacket (data, &was_supported); 4128 if (return_value != 0) 4129 { 4130 if (!was_supported) 4131 error.SetErrorString("Sending events is not supported for this process."); 4132 else 4133 error.SetErrorStringWithFormat("Error sending event data: %d.", return_value); 4134 } 4135 return error; 4136 } 4137 4138 const DataBufferSP 4139 ProcessGDBRemote::GetAuxvData() 4140 { 4141 DataBufferSP buf; 4142 if (m_gdb_comm.GetQXferAuxvReadSupported()) 4143 { 4144 std::string response_string; 4145 if (m_gdb_comm.SendPacketsAndConcatenateResponses("qXfer:auxv:read::", response_string) == GDBRemoteCommunication::PacketResult::Success) 4146 buf.reset(new DataBufferHeap(response_string.c_str(), response_string.length())); 4147 } 4148 return buf; 4149 } 4150 4151 StructuredData::ObjectSP 4152 ProcessGDBRemote::GetExtendedInfoForThread (lldb::tid_t tid) 4153 { 4154 StructuredData::ObjectSP object_sp; 4155 4156 if (m_gdb_comm.GetThreadExtendedInfoSupported()) 4157 { 4158 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary()); 4159 SystemRuntime *runtime = GetSystemRuntime(); 4160 if (runtime) 4161 { 4162 runtime->AddThreadExtendedInfoPacketHints (args_dict); 4163 } 4164 args_dict->GetAsDictionary()->AddIntegerItem ("thread", tid); 4165 4166 StreamString packet; 4167 packet << "jThreadExtendedInfo:"; 4168 args_dict->Dump (packet); 4169 4170 // FIXME the final character of a JSON dictionary, '}', is the escape 4171 // character in gdb-remote binary mode. lldb currently doesn't escape 4172 // these characters in its packet output -- so we add the quoted version 4173 // of the } character here manually in case we talk to a debugserver which 4174 // un-escapes the characters at packet read time. 4175 packet << (char) (0x7d ^ 0x20); 4176 4177 StringExtractorGDBRemote response; 4178 response.SetResponseValidatorToJSON(); 4179 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success) 4180 { 4181 StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType(); 4182 if (response_type == StringExtractorGDBRemote::eResponse) 4183 { 4184 if (!response.Empty()) 4185 { 4186 object_sp = StructuredData::ParseJSON (response.GetStringRef()); 4187 } 4188 } 4189 } 4190 } 4191 return object_sp; 4192 } 4193 4194 StructuredData::ObjectSP 4195 ProcessGDBRemote::GetLoadedDynamicLibrariesInfos (lldb::addr_t image_list_address, lldb::addr_t image_count) 4196 { 4197 StructuredData::ObjectSP object_sp; 4198 4199 if (m_gdb_comm.GetLoadedDynamicLibrariesInfosSupported()) 4200 { 4201 // Scope for the scoped timeout object 4202 GDBRemoteCommunication::ScopedTimeout timeout (m_gdb_comm, 10); 4203 4204 StructuredData::ObjectSP args_dict(new StructuredData::Dictionary()); 4205 args_dict->GetAsDictionary()->AddIntegerItem ("image_list_address", image_list_address); 4206 args_dict->GetAsDictionary()->AddIntegerItem ("image_count", image_count); 4207 4208 StreamString packet; 4209 packet << "jGetLoadedDynamicLibrariesInfos:"; 4210 args_dict->Dump (packet); 4211 4212 // FIXME the final character of a JSON dictionary, '}', is the escape 4213 // character in gdb-remote binary mode. lldb currently doesn't escape 4214 // these characters in its packet output -- so we add the quoted version 4215 // of the } character here manually in case we talk to a debugserver which 4216 // un-escapes the characters at packet read time. 4217 packet << (char) (0x7d ^ 0x20); 4218 4219 StringExtractorGDBRemote response; 4220 response.SetResponseValidatorToJSON(); 4221 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success) 4222 { 4223 StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType(); 4224 if (response_type == StringExtractorGDBRemote::eResponse) 4225 { 4226 if (!response.Empty()) 4227 { 4228 object_sp = StructuredData::ParseJSON (response.GetStringRef()); 4229 } 4230 } 4231 } 4232 } 4233 return object_sp; 4234 } 4235 4236 // Establish the largest memory read/write payloads we should use. 4237 // If the remote stub has a max packet size, stay under that size. 4238 // 4239 // If the remote stub's max packet size is crazy large, use a 4240 // reasonable largeish default. 4241 // 4242 // If the remote stub doesn't advertise a max packet size, use a 4243 // conservative default. 4244 4245 void 4246 ProcessGDBRemote::GetMaxMemorySize() 4247 { 4248 const uint64_t reasonable_largeish_default = 128 * 1024; 4249 const uint64_t conservative_default = 512; 4250 4251 if (m_max_memory_size == 0) 4252 { 4253 uint64_t stub_max_size = m_gdb_comm.GetRemoteMaxPacketSize(); 4254 if (stub_max_size != UINT64_MAX && stub_max_size != 0) 4255 { 4256 // Save the stub's claimed maximum packet size 4257 m_remote_stub_max_memory_size = stub_max_size; 4258 4259 // Even if the stub says it can support ginormous packets, 4260 // don't exceed our reasonable largeish default packet size. 4261 if (stub_max_size > reasonable_largeish_default) 4262 { 4263 stub_max_size = reasonable_largeish_default; 4264 } 4265 4266 m_max_memory_size = stub_max_size; 4267 } 4268 else 4269 { 4270 m_max_memory_size = conservative_default; 4271 } 4272 } 4273 } 4274 4275 void 4276 ProcessGDBRemote::SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max) 4277 { 4278 if (user_specified_max != 0) 4279 { 4280 GetMaxMemorySize (); 4281 4282 if (m_remote_stub_max_memory_size != 0) 4283 { 4284 if (m_remote_stub_max_memory_size < user_specified_max) 4285 { 4286 m_max_memory_size = m_remote_stub_max_memory_size; // user specified a packet size too big, go as big 4287 // as the remote stub says we can go. 4288 } 4289 else 4290 { 4291 m_max_memory_size = user_specified_max; // user's packet size is good 4292 } 4293 } 4294 else 4295 { 4296 m_max_memory_size = user_specified_max; // user's packet size is probably fine 4297 } 4298 } 4299 } 4300 4301 bool 4302 ProcessGDBRemote::GetModuleSpec(const FileSpec& module_file_spec, 4303 const ArchSpec& arch, 4304 ModuleSpec &module_spec) 4305 { 4306 Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PLATFORM); 4307 4308 if (!m_gdb_comm.GetModuleInfo (module_file_spec, arch, module_spec)) 4309 { 4310 if (log) 4311 log->Printf ("ProcessGDBRemote::%s - failed to get module info for %s:%s", 4312 __FUNCTION__, module_file_spec.GetPath ().c_str (), 4313 arch.GetTriple ().getTriple ().c_str ()); 4314 return false; 4315 } 4316 4317 if (log) 4318 { 4319 StreamString stream; 4320 module_spec.Dump (stream); 4321 log->Printf ("ProcessGDBRemote::%s - got module info for (%s:%s) : %s", 4322 __FUNCTION__, module_file_spec.GetPath ().c_str (), 4323 arch.GetTriple ().getTriple ().c_str (), stream.GetString ().c_str ()); 4324 } 4325 4326 return true; 4327 } 4328 4329 bool 4330 ProcessGDBRemote::GetHostOSVersion(uint32_t &major, 4331 uint32_t &minor, 4332 uint32_t &update) 4333 { 4334 if (m_gdb_comm.GetOSVersion(major, minor, update)) 4335 return true; 4336 // We failed to get the host OS version, defer to the base 4337 // implementation to correctly invalidate the arguments. 4338 return Process::GetHostOSVersion(major, minor, update); 4339 } 4340 4341 namespace { 4342 4343 typedef std::vector<std::string> stringVec; 4344 4345 typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec; 4346 struct RegisterSetInfo 4347 { 4348 ConstString name; 4349 }; 4350 4351 typedef std::map<uint32_t, RegisterSetInfo> RegisterSetMap; 4352 4353 struct GdbServerTargetInfo 4354 { 4355 std::string arch; 4356 std::string osabi; 4357 stringVec includes; 4358 RegisterSetMap reg_set_map; 4359 XMLNode feature_node; 4360 }; 4361 4362 bool 4363 ParseRegisters (XMLNode feature_node, GdbServerTargetInfo &target_info, GDBRemoteDynamicRegisterInfo &dyn_reg_info, ABISP abi_sp, uint32_t &cur_reg_num, uint32_t ®_offset) 4364 { 4365 if (!feature_node) 4366 return false; 4367 4368 feature_node.ForEachChildElementWithName("reg", [&target_info, &dyn_reg_info, &cur_reg_num, ®_offset, &abi_sp](const XMLNode ®_node) -> bool { 4369 std::string gdb_group; 4370 std::string gdb_type; 4371 ConstString reg_name; 4372 ConstString alt_name; 4373 ConstString set_name; 4374 std::vector<uint32_t> value_regs; 4375 std::vector<uint32_t> invalidate_regs; 4376 bool encoding_set = false; 4377 bool format_set = false; 4378 RegisterInfo reg_info = { NULL, // Name 4379 NULL, // Alt name 4380 0, // byte size 4381 reg_offset, // offset 4382 eEncodingUint, // encoding 4383 eFormatHex, // format 4384 { 4385 LLDB_INVALID_REGNUM, // eh_frame reg num 4386 LLDB_INVALID_REGNUM, // DWARF reg num 4387 LLDB_INVALID_REGNUM, // generic reg num 4388 cur_reg_num, // process plugin reg num 4389 cur_reg_num // native register number 4390 }, 4391 NULL, 4392 NULL 4393 }; 4394 4395 reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type, ®_name, &alt_name, &set_name, &value_regs, &invalidate_regs, &encoding_set, &format_set, ®_info, &cur_reg_num, ®_offset](const llvm::StringRef &name, const llvm::StringRef &value) -> bool { 4396 if (name == "name") 4397 { 4398 reg_name.SetString(value); 4399 } 4400 else if (name == "bitsize") 4401 { 4402 reg_info.byte_size = StringConvert::ToUInt32(value.data(), 0, 0) / CHAR_BIT; 4403 } 4404 else if (name == "type") 4405 { 4406 gdb_type = value.str(); 4407 } 4408 else if (name == "group") 4409 { 4410 gdb_group = value.str(); 4411 } 4412 else if (name == "regnum") 4413 { 4414 const uint32_t regnum = StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0); 4415 if (regnum != LLDB_INVALID_REGNUM) 4416 { 4417 reg_info.kinds[eRegisterKindProcessPlugin] = regnum; 4418 } 4419 } 4420 else if (name == "offset") 4421 { 4422 reg_offset = StringConvert::ToUInt32(value.data(), UINT32_MAX, 0); 4423 } 4424 else if (name == "altname") 4425 { 4426 alt_name.SetString(value); 4427 } 4428 else if (name == "encoding") 4429 { 4430 encoding_set = true; 4431 reg_info.encoding = Args::StringToEncoding (value.data(), eEncodingUint); 4432 } 4433 else if (name == "format") 4434 { 4435 format_set = true; 4436 Format format = eFormatInvalid; 4437 if (Args::StringToFormat (value.data(), format, NULL).Success()) 4438 reg_info.format = format; 4439 else if (value == "vector-sint8") 4440 reg_info.format = eFormatVectorOfSInt8; 4441 else if (value == "vector-uint8") 4442 reg_info.format = eFormatVectorOfUInt8; 4443 else if (value == "vector-sint16") 4444 reg_info.format = eFormatVectorOfSInt16; 4445 else if (value == "vector-uint16") 4446 reg_info.format = eFormatVectorOfUInt16; 4447 else if (value == "vector-sint32") 4448 reg_info.format = eFormatVectorOfSInt32; 4449 else if (value == "vector-uint32") 4450 reg_info.format = eFormatVectorOfUInt32; 4451 else if (value == "vector-float32") 4452 reg_info.format = eFormatVectorOfFloat32; 4453 else if (value == "vector-uint128") 4454 reg_info.format = eFormatVectorOfUInt128; 4455 } 4456 else if (name == "group_id") 4457 { 4458 const uint32_t set_id = StringConvert::ToUInt32(value.data(), UINT32_MAX, 0); 4459 RegisterSetMap::const_iterator pos = target_info.reg_set_map.find(set_id); 4460 if (pos != target_info.reg_set_map.end()) 4461 set_name = pos->second.name; 4462 } 4463 else if (name == "gcc_regnum" || name == "ehframe_regnum") 4464 { 4465 reg_info.kinds[eRegisterKindEHFrame] = StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0); 4466 } 4467 else if (name == "dwarf_regnum") 4468 { 4469 reg_info.kinds[eRegisterKindDWARF] = StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0); 4470 } 4471 else if (name == "generic") 4472 { 4473 reg_info.kinds[eRegisterKindGeneric] = Args::StringToGenericRegister(value.data()); 4474 } 4475 else if (name == "value_regnums") 4476 { 4477 SplitCommaSeparatedRegisterNumberString(value, value_regs, 0); 4478 } 4479 else if (name == "invalidate_regnums") 4480 { 4481 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0); 4482 } 4483 else 4484 { 4485 printf("unhandled attribute %s = %s\n", name.data(), value.data()); 4486 } 4487 return true; // Keep iterating through all attributes 4488 }); 4489 4490 if (!gdb_type.empty() && !(encoding_set || format_set)) 4491 { 4492 if (gdb_type.find("int") == 0) 4493 { 4494 reg_info.format = eFormatHex; 4495 reg_info.encoding = eEncodingUint; 4496 } 4497 else if (gdb_type == "data_ptr" || gdb_type == "code_ptr") 4498 { 4499 reg_info.format = eFormatAddressInfo; 4500 reg_info.encoding = eEncodingUint; 4501 } 4502 else if (gdb_type == "i387_ext" || gdb_type == "float") 4503 { 4504 reg_info.format = eFormatFloat; 4505 reg_info.encoding = eEncodingIEEE754; 4506 } 4507 } 4508 4509 // Only update the register set name if we didn't get a "reg_set" attribute. 4510 // "set_name" will be empty if we didn't have a "reg_set" attribute. 4511 if (!set_name && !gdb_group.empty()) 4512 set_name.SetCString(gdb_group.c_str()); 4513 4514 reg_info.byte_offset = reg_offset; 4515 assert (reg_info.byte_size != 0); 4516 reg_offset += reg_info.byte_size; 4517 if (!value_regs.empty()) 4518 { 4519 value_regs.push_back(LLDB_INVALID_REGNUM); 4520 reg_info.value_regs = value_regs.data(); 4521 } 4522 if (!invalidate_regs.empty()) 4523 { 4524 invalidate_regs.push_back(LLDB_INVALID_REGNUM); 4525 reg_info.invalidate_regs = invalidate_regs.data(); 4526 } 4527 4528 ++cur_reg_num; 4529 AugmentRegisterInfoViaABI (reg_info, reg_name, abi_sp); 4530 dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name); 4531 4532 return true; // Keep iterating through all "reg" elements 4533 }); 4534 return true; 4535 } 4536 4537 } // namespace {} 4538 4539 4540 // query the target of gdb-remote for extended target information 4541 // return: 'true' on success 4542 // 'false' on failure 4543 bool 4544 ProcessGDBRemote::GetGDBServerRegisterInfo (ArchSpec &arch_to_use) 4545 { 4546 // Make sure LLDB has an XML parser it can use first 4547 if (!XMLDocument::XMLEnabled()) 4548 return false; 4549 4550 // redirect libxml2's error handler since the default prints to stdout 4551 4552 GDBRemoteCommunicationClient & comm = m_gdb_comm; 4553 4554 // check that we have extended feature read support 4555 if ( !comm.GetQXferFeaturesReadSupported( ) ) 4556 return false; 4557 4558 // request the target xml file 4559 std::string raw; 4560 lldb_private::Error lldberr; 4561 if (!comm.ReadExtFeature(ConstString("features"), 4562 ConstString("target.xml"), 4563 raw, 4564 lldberr)) 4565 { 4566 return false; 4567 } 4568 4569 4570 XMLDocument xml_document; 4571 4572 if (xml_document.ParseMemory(raw.c_str(), raw.size(), "target.xml")) 4573 { 4574 GdbServerTargetInfo target_info; 4575 4576 XMLNode target_node = xml_document.GetRootElement("target"); 4577 if (target_node) 4578 { 4579 XMLNode feature_node; 4580 target_node.ForEachChildElement([&target_info, this, &feature_node](const XMLNode &node) -> bool 4581 { 4582 llvm::StringRef name = node.GetName(); 4583 if (name == "architecture") 4584 { 4585 node.GetElementText(target_info.arch); 4586 } 4587 else if (name == "osabi") 4588 { 4589 node.GetElementText(target_info.osabi); 4590 } 4591 else if (name == "xi:include" || name == "include") 4592 { 4593 llvm::StringRef href = node.GetAttributeValue("href"); 4594 if (!href.empty()) 4595 target_info.includes.push_back(href.str()); 4596 } 4597 else if (name == "feature") 4598 { 4599 feature_node = node; 4600 } 4601 else if (name == "groups") 4602 { 4603 node.ForEachChildElementWithName("group", [&target_info](const XMLNode &node) -> bool { 4604 uint32_t set_id = UINT32_MAX; 4605 RegisterSetInfo set_info; 4606 4607 node.ForEachAttribute([&set_id, &set_info](const llvm::StringRef &name, const llvm::StringRef &value) -> bool { 4608 if (name == "id") 4609 set_id = StringConvert::ToUInt32(value.data(), UINT32_MAX, 0); 4610 if (name == "name") 4611 set_info.name = ConstString(value); 4612 return true; // Keep iterating through all attributes 4613 }); 4614 4615 if (set_id != UINT32_MAX) 4616 target_info.reg_set_map[set_id] = set_info; 4617 return true; // Keep iterating through all "group" elements 4618 }); 4619 } 4620 return true; // Keep iterating through all children of the target_node 4621 }); 4622 4623 // Initialize these outside of ParseRegisters, since they should not be reset inside each include feature 4624 uint32_t cur_reg_num = 0; 4625 uint32_t reg_offset = 0; 4626 4627 // Don't use Process::GetABI, this code gets called from DidAttach, and in that context we haven't 4628 // set the Target's architecture yet, so the ABI is also potentially incorrect. 4629 ABISP abi_to_use_sp = ABI::FindPlugin(arch_to_use); 4630 if (feature_node) 4631 { 4632 ParseRegisters(feature_node, target_info, this->m_register_info, abi_to_use_sp, cur_reg_num, reg_offset); 4633 } 4634 4635 for (const auto &include : target_info.includes) 4636 { 4637 // request register file 4638 std::string xml_data; 4639 if (!comm.ReadExtFeature(ConstString("features"), 4640 ConstString(include), 4641 xml_data, 4642 lldberr)) 4643 continue; 4644 4645 XMLDocument include_xml_document; 4646 include_xml_document.ParseMemory(xml_data.data(), xml_data.size(), include.c_str()); 4647 XMLNode include_feature_node = include_xml_document.GetRootElement("feature"); 4648 if (include_feature_node) 4649 { 4650 ParseRegisters(include_feature_node, target_info, this->m_register_info, abi_to_use_sp, cur_reg_num, reg_offset); 4651 } 4652 } 4653 this->m_register_info.Finalize(arch_to_use); 4654 } 4655 } 4656 4657 return m_register_info.GetNumRegisters() > 0; 4658 } 4659 4660 Error 4661 ProcessGDBRemote::GetLoadedModuleList (LoadedModuleInfoList & list) 4662 { 4663 // Make sure LLDB has an XML parser it can use first 4664 if (!XMLDocument::XMLEnabled()) 4665 return Error (0, ErrorType::eErrorTypeGeneric); 4666 4667 Log *log = GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS); 4668 if (log) 4669 log->Printf ("ProcessGDBRemote::%s", __FUNCTION__); 4670 4671 GDBRemoteCommunicationClient & comm = m_gdb_comm; 4672 4673 // check that we have extended feature read support 4674 if (comm.GetQXferLibrariesSVR4ReadSupported ()) { 4675 list.clear (); 4676 4677 // request the loaded library list 4678 std::string raw; 4679 lldb_private::Error lldberr; 4680 4681 if (!comm.ReadExtFeature (ConstString ("libraries-svr4"), ConstString (""), raw, lldberr)) 4682 return Error (0, ErrorType::eErrorTypeGeneric); 4683 4684 // parse the xml file in memory 4685 if (log) 4686 log->Printf ("parsing: %s", raw.c_str()); 4687 XMLDocument doc; 4688 4689 if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml")) 4690 return Error (0, ErrorType::eErrorTypeGeneric); 4691 4692 XMLNode root_element = doc.GetRootElement("library-list-svr4"); 4693 if (!root_element) 4694 return Error(); 4695 4696 // main link map structure 4697 llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm"); 4698 if (!main_lm.empty()) 4699 { 4700 list.m_link_map = StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0); 4701 } 4702 4703 root_element.ForEachChildElementWithName("library", [log, &list](const XMLNode &library) -> bool { 4704 4705 LoadedModuleInfoList::LoadedModuleInfo module; 4706 4707 library.ForEachAttribute([log, &module](const llvm::StringRef &name, const llvm::StringRef &value) -> bool { 4708 4709 if (name == "name") 4710 module.set_name (value.str()); 4711 else if (name == "lm") 4712 { 4713 // the address of the link_map struct. 4714 module.set_link_map(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0)); 4715 } 4716 else if (name == "l_addr") 4717 { 4718 // the displacement as read from the field 'l_addr' of the link_map struct. 4719 module.set_base(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0)); 4720 // base address is always a displacement, not an absolute value. 4721 module.set_base_is_offset(true); 4722 } 4723 else if (name == "l_ld") 4724 { 4725 // the memory address of the libraries PT_DYAMIC section. 4726 module.set_dynamic(StringConvert::ToUInt64(value.data(), LLDB_INVALID_ADDRESS, 0)); 4727 } 4728 4729 return true; // Keep iterating over all properties of "library" 4730 }); 4731 4732 if (log) 4733 { 4734 std::string name; 4735 lldb::addr_t lm=0, base=0, ld=0; 4736 bool base_is_offset; 4737 4738 module.get_name (name); 4739 module.get_link_map (lm); 4740 module.get_base (base); 4741 module.get_base_is_offset (base_is_offset); 4742 module.get_dynamic (ld); 4743 4744 log->Printf ("found (link_map:0x%08" PRIx64 ", base:0x%08" PRIx64 "[%s], ld:0x%08" PRIx64 ", name:'%s')", lm, base, (base_is_offset ? "offset" : "absolute"), ld, name.c_str()); 4745 } 4746 4747 list.add (module); 4748 return true; // Keep iterating over all "library" elements in the root node 4749 }); 4750 4751 if (log) 4752 log->Printf ("found %" PRId32 " modules in total", (int) list.m_list.size()); 4753 } else if (comm.GetQXferLibrariesReadSupported ()) { 4754 list.clear (); 4755 4756 // request the loaded library list 4757 std::string raw; 4758 lldb_private::Error lldberr; 4759 4760 if (!comm.ReadExtFeature (ConstString ("libraries"), ConstString (""), raw, lldberr)) 4761 return Error (0, ErrorType::eErrorTypeGeneric); 4762 4763 if (log) 4764 log->Printf ("parsing: %s", raw.c_str()); 4765 XMLDocument doc; 4766 4767 if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml")) 4768 return Error (0, ErrorType::eErrorTypeGeneric); 4769 4770 XMLNode root_element = doc.GetRootElement("library-list"); 4771 if (!root_element) 4772 return Error(); 4773 4774 root_element.ForEachChildElementWithName("library", [log, &list](const XMLNode &library) -> bool { 4775 LoadedModuleInfoList::LoadedModuleInfo module; 4776 4777 llvm::StringRef name = library.GetAttributeValue("name"); 4778 module.set_name(name.str()); 4779 4780 // The base address of a given library will be the address of its 4781 // first section. Most remotes send only one section for Windows 4782 // targets for example. 4783 const XMLNode §ion = library.FindFirstChildElementWithName("section"); 4784 llvm::StringRef address = section.GetAttributeValue("address"); 4785 module.set_base(StringConvert::ToUInt64(address.data(), LLDB_INVALID_ADDRESS, 0)); 4786 // These addresses are absolute values. 4787 module.set_base_is_offset(false); 4788 4789 if (log) 4790 { 4791 std::string name; 4792 lldb::addr_t base = 0; 4793 bool base_is_offset; 4794 module.get_name (name); 4795 module.get_base (base); 4796 module.get_base_is_offset (base_is_offset); 4797 4798 log->Printf ("found (base:0x%08" PRIx64 "[%s], name:'%s')", base, (base_is_offset ? "offset" : "absolute"), name.c_str()); 4799 } 4800 4801 list.add (module); 4802 return true; // Keep iterating over all "library" elements in the root node 4803 }); 4804 4805 if (log) 4806 log->Printf ("found %" PRId32 " modules in total", (int) list.m_list.size()); 4807 } else { 4808 return Error (0, ErrorType::eErrorTypeGeneric); 4809 } 4810 4811 return Error(); 4812 } 4813 4814 lldb::ModuleSP 4815 ProcessGDBRemote::LoadModuleAtAddress (const FileSpec &file, lldb::addr_t link_map, 4816 lldb::addr_t base_addr, bool value_is_offset) 4817 { 4818 DynamicLoader *loader = GetDynamicLoader(); 4819 if (!loader) 4820 return nullptr; 4821 4822 return loader->LoadModuleAtAddress(file, link_map, base_addr, value_is_offset); 4823 } 4824 4825 size_t 4826 ProcessGDBRemote::LoadModules (LoadedModuleInfoList &module_list) 4827 { 4828 using lldb_private::process_gdb_remote::ProcessGDBRemote; 4829 4830 // request a list of loaded libraries from GDBServer 4831 if (GetLoadedModuleList (module_list).Fail()) 4832 return 0; 4833 4834 // get a list of all the modules 4835 ModuleList new_modules; 4836 4837 for (LoadedModuleInfoList::LoadedModuleInfo & modInfo : module_list.m_list) 4838 { 4839 std::string mod_name; 4840 lldb::addr_t mod_base; 4841 lldb::addr_t link_map; 4842 bool mod_base_is_offset; 4843 4844 bool valid = true; 4845 valid &= modInfo.get_name (mod_name); 4846 valid &= modInfo.get_base (mod_base); 4847 valid &= modInfo.get_base_is_offset (mod_base_is_offset); 4848 if (!valid) 4849 continue; 4850 4851 if (!modInfo.get_link_map (link_map)) 4852 link_map = LLDB_INVALID_ADDRESS; 4853 4854 FileSpec file (mod_name.c_str(), true); 4855 lldb::ModuleSP module_sp = LoadModuleAtAddress (file, link_map, mod_base, 4856 mod_base_is_offset); 4857 4858 if (module_sp.get()) 4859 new_modules.Append (module_sp); 4860 } 4861 4862 if (new_modules.GetSize() > 0) 4863 { 4864 ModuleList removed_modules; 4865 Target &target = GetTarget(); 4866 ModuleList &loaded_modules = m_process->GetTarget().GetImages(); 4867 4868 for (size_t i = 0; i < loaded_modules.GetSize(); ++i) 4869 { 4870 const lldb::ModuleSP loaded_module = loaded_modules.GetModuleAtIndex(i); 4871 4872 bool found = false; 4873 for (size_t j = 0; j < new_modules.GetSize(); ++j) 4874 { 4875 if (new_modules.GetModuleAtIndex(j).get() == loaded_module.get()) 4876 found = true; 4877 } 4878 4879 // The main executable will never be included in libraries-svr4, don't remove it 4880 if (!found && loaded_module.get() != target.GetExecutableModulePointer()) 4881 { 4882 removed_modules.Append (loaded_module); 4883 } 4884 } 4885 4886 loaded_modules.Remove (removed_modules); 4887 m_process->GetTarget().ModulesDidUnload (removed_modules, false); 4888 4889 new_modules.ForEach ([&target](const lldb::ModuleSP module_sp) -> bool 4890 { 4891 lldb_private::ObjectFile * obj = module_sp->GetObjectFile (); 4892 if (!obj) 4893 return true; 4894 4895 if (obj->GetType () != ObjectFile::Type::eTypeExecutable) 4896 return true; 4897 4898 lldb::ModuleSP module_copy_sp = module_sp; 4899 target.SetExecutableModule (module_copy_sp, false); 4900 return false; 4901 }); 4902 4903 loaded_modules.AppendIfNeeded (new_modules); 4904 m_process->GetTarget().ModulesDidLoad (new_modules); 4905 } 4906 4907 return new_modules.GetSize(); 4908 } 4909 4910 size_t 4911 ProcessGDBRemote::LoadModules () 4912 { 4913 LoadedModuleInfoList module_list; 4914 return LoadModules (module_list); 4915 } 4916 4917 Error 4918 ProcessGDBRemote::GetFileLoadAddress(const FileSpec& file, bool& is_loaded, lldb::addr_t& load_addr) 4919 { 4920 is_loaded = false; 4921 load_addr = LLDB_INVALID_ADDRESS; 4922 4923 std::string file_path = file.GetPath(false); 4924 if (file_path.empty ()) 4925 return Error("Empty file name specified"); 4926 4927 StreamString packet; 4928 packet.PutCString("qFileLoadAddress:"); 4929 packet.PutCStringAsRawHex8(file_path.c_str()); 4930 4931 StringExtractorGDBRemote response; 4932 if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(), response, false) != GDBRemoteCommunication::PacketResult::Success) 4933 return Error("Sending qFileLoadAddress packet failed"); 4934 4935 if (response.IsErrorResponse()) 4936 { 4937 if (response.GetError() == 1) 4938 { 4939 // The file is not loaded into the inferior 4940 is_loaded = false; 4941 load_addr = LLDB_INVALID_ADDRESS; 4942 return Error(); 4943 } 4944 4945 return Error("Fetching file load address from remote server returned an error"); 4946 } 4947 4948 if (response.IsNormalResponse()) 4949 { 4950 is_loaded = true; 4951 load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 4952 return Error(); 4953 } 4954 4955 return Error("Unknown error happened during sending the load address packet"); 4956 } 4957 4958 4959 void 4960 ProcessGDBRemote::ModulesDidLoad (ModuleList &module_list) 4961 { 4962 // We must call the lldb_private::Process::ModulesDidLoad () first before we do anything 4963 Process::ModulesDidLoad (module_list); 4964 4965 // After loading shared libraries, we can ask our remote GDB server if 4966 // it needs any symbols. 4967 m_gdb_comm.ServeSymbolLookups(this); 4968 } 4969 4970 4971 class CommandObjectProcessGDBRemoteSpeedTest: public CommandObjectParsed 4972 { 4973 public: 4974 CommandObjectProcessGDBRemoteSpeedTest(CommandInterpreter &interpreter) : 4975 CommandObjectParsed (interpreter, 4976 "process plugin packet speed-test", 4977 "Tests packet speeds of various sizes to determine the performance characteristics of the GDB remote connection. ", 4978 NULL), 4979 m_option_group (interpreter), 4980 m_num_packets (LLDB_OPT_SET_1, false, "count", 'c', 0, eArgTypeCount, "The number of packets to send of each varying size (default is 1000).", 1000), 4981 m_max_send (LLDB_OPT_SET_1, false, "max-send", 's', 0, eArgTypeCount, "The maximum number of bytes to send in a packet. Sizes increase in powers of 2 while the size is less than or equal to this option value. (default 1024).", 1024), 4982 m_max_recv (LLDB_OPT_SET_1, false, "max-receive", 'r', 0, eArgTypeCount, "The maximum number of bytes to receive in a packet. Sizes increase in powers of 2 while the size is less than or equal to this option value. (default 1024).", 1024), 4983 m_json (LLDB_OPT_SET_1, false, "json", 'j', "Print the output as JSON data for easy parsing.", false, true) 4984 { 4985 m_option_group.Append (&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 4986 m_option_group.Append (&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 4987 m_option_group.Append (&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 4988 m_option_group.Append (&m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); 4989 m_option_group.Finalize(); 4990 } 4991 4992 ~CommandObjectProcessGDBRemoteSpeedTest () 4993 { 4994 } 4995 4996 4997 Options * 4998 GetOptions () override 4999 { 5000 return &m_option_group; 5001 } 5002 5003 bool 5004 DoExecute (Args& command, CommandReturnObject &result) override 5005 { 5006 const size_t argc = command.GetArgumentCount(); 5007 if (argc == 0) 5008 { 5009 ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr(); 5010 if (process) 5011 { 5012 StreamSP output_stream_sp (m_interpreter.GetDebugger().GetAsyncOutputStream()); 5013 result.SetImmediateOutputStream (output_stream_sp); 5014 5015 const uint32_t num_packets = (uint32_t)m_num_packets.GetOptionValue().GetCurrentValue(); 5016 const uint64_t max_send = m_max_send.GetOptionValue().GetCurrentValue(); 5017 const uint64_t max_recv = m_max_recv.GetOptionValue().GetCurrentValue(); 5018 const bool json = m_json.GetOptionValue().GetCurrentValue(); 5019 if (output_stream_sp) 5020 process->GetGDBRemote().TestPacketSpeed (num_packets, max_send, max_recv, json, *output_stream_sp); 5021 else 5022 { 5023 process->GetGDBRemote().TestPacketSpeed (num_packets, max_send, max_recv, json, result.GetOutputStream()); 5024 } 5025 result.SetStatus (eReturnStatusSuccessFinishResult); 5026 return true; 5027 } 5028 } 5029 else 5030 { 5031 result.AppendErrorWithFormat ("'%s' takes no arguments", m_cmd_name.c_str()); 5032 } 5033 result.SetStatus (eReturnStatusFailed); 5034 return false; 5035 } 5036 protected: 5037 OptionGroupOptions m_option_group; 5038 OptionGroupUInt64 m_num_packets; 5039 OptionGroupUInt64 m_max_send; 5040 OptionGroupUInt64 m_max_recv; 5041 OptionGroupBoolean m_json; 5042 5043 }; 5044 5045 class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed 5046 { 5047 private: 5048 5049 public: 5050 CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter) : 5051 CommandObjectParsed (interpreter, 5052 "process plugin packet history", 5053 "Dumps the packet history buffer. ", 5054 NULL) 5055 { 5056 } 5057 5058 ~CommandObjectProcessGDBRemotePacketHistory () 5059 { 5060 } 5061 5062 bool 5063 DoExecute (Args& command, CommandReturnObject &result) override 5064 { 5065 const size_t argc = command.GetArgumentCount(); 5066 if (argc == 0) 5067 { 5068 ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr(); 5069 if (process) 5070 { 5071 process->GetGDBRemote().DumpHistory(result.GetOutputStream()); 5072 result.SetStatus (eReturnStatusSuccessFinishResult); 5073 return true; 5074 } 5075 } 5076 else 5077 { 5078 result.AppendErrorWithFormat ("'%s' takes no arguments", m_cmd_name.c_str()); 5079 } 5080 result.SetStatus (eReturnStatusFailed); 5081 return false; 5082 } 5083 }; 5084 5085 class CommandObjectProcessGDBRemotePacketXferSize : public CommandObjectParsed 5086 { 5087 private: 5088 5089 public: 5090 CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter) : 5091 CommandObjectParsed (interpreter, 5092 "process plugin packet xfer-size", 5093 "Maximum size that lldb will try to read/write one one chunk.", 5094 NULL) 5095 { 5096 } 5097 5098 ~CommandObjectProcessGDBRemotePacketXferSize () 5099 { 5100 } 5101 5102 bool 5103 DoExecute (Args& command, CommandReturnObject &result) override 5104 { 5105 const size_t argc = command.GetArgumentCount(); 5106 if (argc == 0) 5107 { 5108 result.AppendErrorWithFormat ("'%s' takes an argument to specify the max amount to be transferred when reading/writing", m_cmd_name.c_str()); 5109 result.SetStatus (eReturnStatusFailed); 5110 return false; 5111 } 5112 5113 ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr(); 5114 if (process) 5115 { 5116 const char *packet_size = command.GetArgumentAtIndex(0); 5117 errno = 0; 5118 uint64_t user_specified_max = strtoul (packet_size, NULL, 10); 5119 if (errno == 0 && user_specified_max != 0) 5120 { 5121 process->SetUserSpecifiedMaxMemoryTransferSize (user_specified_max); 5122 result.SetStatus (eReturnStatusSuccessFinishResult); 5123 return true; 5124 } 5125 } 5126 result.SetStatus (eReturnStatusFailed); 5127 return false; 5128 } 5129 }; 5130 5131 5132 class CommandObjectProcessGDBRemotePacketSend : public CommandObjectParsed 5133 { 5134 private: 5135 5136 public: 5137 CommandObjectProcessGDBRemotePacketSend(CommandInterpreter &interpreter) : 5138 CommandObjectParsed (interpreter, 5139 "process plugin packet send", 5140 "Send a custom packet through the GDB remote protocol and print the answer. " 5141 "The packet header and footer will automatically be added to the packet prior to sending and stripped from the result.", 5142 NULL) 5143 { 5144 } 5145 5146 ~CommandObjectProcessGDBRemotePacketSend () 5147 { 5148 } 5149 5150 bool 5151 DoExecute (Args& command, CommandReturnObject &result) override 5152 { 5153 const size_t argc = command.GetArgumentCount(); 5154 if (argc == 0) 5155 { 5156 result.AppendErrorWithFormat ("'%s' takes a one or more packet content arguments", m_cmd_name.c_str()); 5157 result.SetStatus (eReturnStatusFailed); 5158 return false; 5159 } 5160 5161 ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr(); 5162 if (process) 5163 { 5164 for (size_t i=0; i<argc; ++ i) 5165 { 5166 const char *packet_cstr = command.GetArgumentAtIndex(0); 5167 bool send_async = true; 5168 StringExtractorGDBRemote response; 5169 process->GetGDBRemote().SendPacketAndWaitForResponse(packet_cstr, response, send_async); 5170 result.SetStatus (eReturnStatusSuccessFinishResult); 5171 Stream &output_strm = result.GetOutputStream(); 5172 output_strm.Printf (" packet: %s\n", packet_cstr); 5173 std::string &response_str = response.GetStringRef(); 5174 5175 if (strstr(packet_cstr, "qGetProfileData") != NULL) 5176 { 5177 response_str = process->GetGDBRemote().HarmonizeThreadIdsForProfileData(process, response); 5178 } 5179 5180 if (response_str.empty()) 5181 output_strm.PutCString ("response: \nerror: UNIMPLEMENTED\n"); 5182 else 5183 output_strm.Printf ("response: %s\n", response.GetStringRef().c_str()); 5184 } 5185 } 5186 return true; 5187 } 5188 }; 5189 5190 class CommandObjectProcessGDBRemotePacketMonitor : public CommandObjectRaw 5191 { 5192 private: 5193 5194 public: 5195 CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter) : 5196 CommandObjectRaw (interpreter, 5197 "process plugin packet monitor", 5198 "Send a qRcmd packet through the GDB remote protocol and print the response." 5199 "The argument passed to this command will be hex encoded into a valid 'qRcmd' packet, sent and the response will be printed.", 5200 NULL) 5201 { 5202 } 5203 5204 ~CommandObjectProcessGDBRemotePacketMonitor () 5205 { 5206 } 5207 5208 bool 5209 DoExecute (const char *command, CommandReturnObject &result) override 5210 { 5211 if (command == NULL || command[0] == '\0') 5212 { 5213 result.AppendErrorWithFormat ("'%s' takes a command string argument", m_cmd_name.c_str()); 5214 result.SetStatus (eReturnStatusFailed); 5215 return false; 5216 } 5217 5218 ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr(); 5219 if (process) 5220 { 5221 StreamString packet; 5222 packet.PutCString("qRcmd,"); 5223 packet.PutBytesAsRawHex8(command, strlen(command)); 5224 const char *packet_cstr = packet.GetString().c_str(); 5225 5226 bool send_async = true; 5227 StringExtractorGDBRemote response; 5228 process->GetGDBRemote().SendPacketAndWaitForResponse(packet_cstr, response, send_async); 5229 result.SetStatus (eReturnStatusSuccessFinishResult); 5230 Stream &output_strm = result.GetOutputStream(); 5231 output_strm.Printf (" packet: %s\n", packet_cstr); 5232 const std::string &response_str = response.GetStringRef(); 5233 5234 if (response_str.empty()) 5235 output_strm.PutCString ("response: \nerror: UNIMPLEMENTED\n"); 5236 else 5237 output_strm.Printf ("response: %s\n", response.GetStringRef().c_str()); 5238 } 5239 return true; 5240 } 5241 }; 5242 5243 class CommandObjectProcessGDBRemotePacket : public CommandObjectMultiword 5244 { 5245 private: 5246 5247 public: 5248 CommandObjectProcessGDBRemotePacket(CommandInterpreter &interpreter) : 5249 CommandObjectMultiword (interpreter, 5250 "process plugin packet", 5251 "Commands that deal with GDB remote packets.", 5252 NULL) 5253 { 5254 LoadSubCommand ("history", CommandObjectSP (new CommandObjectProcessGDBRemotePacketHistory (interpreter))); 5255 LoadSubCommand ("send", CommandObjectSP (new CommandObjectProcessGDBRemotePacketSend (interpreter))); 5256 LoadSubCommand ("monitor", CommandObjectSP (new CommandObjectProcessGDBRemotePacketMonitor (interpreter))); 5257 LoadSubCommand ("xfer-size", CommandObjectSP (new CommandObjectProcessGDBRemotePacketXferSize (interpreter))); 5258 LoadSubCommand ("speed-test", CommandObjectSP (new CommandObjectProcessGDBRemoteSpeedTest (interpreter))); 5259 } 5260 5261 ~CommandObjectProcessGDBRemotePacket () 5262 { 5263 } 5264 }; 5265 5266 class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword 5267 { 5268 public: 5269 CommandObjectMultiwordProcessGDBRemote (CommandInterpreter &interpreter) : 5270 CommandObjectMultiword (interpreter, 5271 "process plugin", 5272 "A set of commands for operating on a ProcessGDBRemote process.", 5273 "process plugin <subcommand> [<subcommand-options>]") 5274 { 5275 LoadSubCommand ("packet", CommandObjectSP (new CommandObjectProcessGDBRemotePacket (interpreter))); 5276 } 5277 5278 ~CommandObjectMultiwordProcessGDBRemote () 5279 { 5280 } 5281 }; 5282 5283 CommandObject * 5284 ProcessGDBRemote::GetPluginCommandObject() 5285 { 5286 if (!m_command_sp) 5287 m_command_sp.reset (new CommandObjectMultiwordProcessGDBRemote (GetTarget().GetDebugger().GetCommandInterpreter())); 5288 return m_command_sp.get(); 5289 } 5290