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