1 //===-- GDBRemoteCommunicationClient.cpp ----------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "GDBRemoteCommunicationClient.h" 10 11 #include <cmath> 12 #include <sys/stat.h> 13 14 #include <numeric> 15 #include <optional> 16 #include <sstream> 17 18 #include "lldb/Core/ModuleSpec.h" 19 #include "lldb/Host/HostInfo.h" 20 #include "lldb/Host/XML.h" 21 #include "lldb/Symbol/Symbol.h" 22 #include "lldb/Target/MemoryRegionInfo.h" 23 #include "lldb/Target/Target.h" 24 #include "lldb/Target/UnixSignals.h" 25 #include "lldb/Utility/Args.h" 26 #include "lldb/Utility/DataBufferHeap.h" 27 #include "lldb/Utility/LLDBAssert.h" 28 #include "lldb/Utility/LLDBLog.h" 29 #include "lldb/Utility/Log.h" 30 #include "lldb/Utility/State.h" 31 #include "lldb/Utility/StreamString.h" 32 33 #include "ProcessGDBRemote.h" 34 #include "ProcessGDBRemoteLog.h" 35 #include "lldb/Host/Config.h" 36 #include "lldb/Utility/StringExtractorGDBRemote.h" 37 38 #include "llvm/ADT/STLExtras.h" 39 #include "llvm/ADT/StringSwitch.h" 40 #include "llvm/Support/JSON.h" 41 42 #if defined(HAVE_LIBCOMPRESSION) 43 #include <compression.h> 44 #endif 45 46 using namespace lldb; 47 using namespace lldb_private::process_gdb_remote; 48 using namespace lldb_private; 49 using namespace std::chrono; 50 51 llvm::raw_ostream &process_gdb_remote::operator<<(llvm::raw_ostream &os, 52 const QOffsets &offsets) { 53 return os << llvm::formatv( 54 "QOffsets({0}, [{1:@[x]}])", offsets.segments, 55 llvm::make_range(offsets.offsets.begin(), offsets.offsets.end())); 56 } 57 58 // GDBRemoteCommunicationClient constructor 59 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient() 60 : GDBRemoteClientBase("gdb-remote.client"), 61 62 m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true), 63 m_supports_qUserName(true), m_supports_qGroupName(true), 64 m_supports_qThreadStopInfo(true), m_supports_z0(true), 65 m_supports_z1(true), m_supports_z2(true), m_supports_z3(true), 66 m_supports_z4(true), m_supports_QEnvironment(true), 67 m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true), 68 m_qSymbol_requests_done(false), m_supports_qModuleInfo(true), 69 m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true), 70 m_supports_vFileSize(true), m_supports_vFileMode(true), 71 m_supports_vFileExists(true), m_supports_vRun(true), 72 73 m_host_arch(), m_host_distribution_id(), m_process_arch(), m_os_build(), 74 m_os_kernel(), m_hostname(), m_gdb_server_name(), 75 m_default_packet_timeout(0), m_qSupported_response(), 76 m_supported_async_json_packets_sp(), m_qXfer_memory_map() {} 77 78 // Destructor 79 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient() { 80 if (IsConnected()) 81 Disconnect(); 82 } 83 84 bool GDBRemoteCommunicationClient::HandshakeWithServer(Status *error_ptr) { 85 ResetDiscoverableSettings(false); 86 87 // Start the read thread after we send the handshake ack since if we fail to 88 // send the handshake ack, there is no reason to continue... 89 std::chrono::steady_clock::time_point start_of_handshake = 90 std::chrono::steady_clock::now(); 91 if (SendAck()) { 92 // The return value from QueryNoAckModeSupported() is true if the packet 93 // was sent and _any_ response (including UNIMPLEMENTED) was received), or 94 // false if no response was received. This quickly tells us if we have a 95 // live connection to a remote GDB server... 96 if (QueryNoAckModeSupported()) { 97 return true; 98 } else { 99 std::chrono::steady_clock::time_point end_of_handshake = 100 std::chrono::steady_clock::now(); 101 auto handshake_timeout = 102 std::chrono::duration<double>(end_of_handshake - start_of_handshake) 103 .count(); 104 if (error_ptr) { 105 if (!IsConnected()) 106 error_ptr->SetErrorString("Connection shut down by remote side " 107 "while waiting for reply to initial " 108 "handshake packet"); 109 else 110 error_ptr->SetErrorStringWithFormat( 111 "failed to get reply to handshake packet within timeout of " 112 "%.1f seconds", 113 handshake_timeout); 114 } 115 } 116 } else { 117 if (error_ptr) 118 error_ptr->SetErrorString("failed to send the handshake ack"); 119 } 120 return false; 121 } 122 123 bool GDBRemoteCommunicationClient::GetEchoSupported() { 124 if (m_supports_qEcho == eLazyBoolCalculate) { 125 GetRemoteQSupported(); 126 } 127 return m_supports_qEcho == eLazyBoolYes; 128 } 129 130 bool GDBRemoteCommunicationClient::GetQPassSignalsSupported() { 131 if (m_supports_QPassSignals == eLazyBoolCalculate) { 132 GetRemoteQSupported(); 133 } 134 return m_supports_QPassSignals == eLazyBoolYes; 135 } 136 137 bool GDBRemoteCommunicationClient::GetAugmentedLibrariesSVR4ReadSupported() { 138 if (m_supports_augmented_libraries_svr4_read == eLazyBoolCalculate) { 139 GetRemoteQSupported(); 140 } 141 return m_supports_augmented_libraries_svr4_read == eLazyBoolYes; 142 } 143 144 bool GDBRemoteCommunicationClient::GetQXferLibrariesSVR4ReadSupported() { 145 if (m_supports_qXfer_libraries_svr4_read == eLazyBoolCalculate) { 146 GetRemoteQSupported(); 147 } 148 return m_supports_qXfer_libraries_svr4_read == eLazyBoolYes; 149 } 150 151 bool GDBRemoteCommunicationClient::GetQXferLibrariesReadSupported() { 152 if (m_supports_qXfer_libraries_read == eLazyBoolCalculate) { 153 GetRemoteQSupported(); 154 } 155 return m_supports_qXfer_libraries_read == eLazyBoolYes; 156 } 157 158 bool GDBRemoteCommunicationClient::GetQXferAuxvReadSupported() { 159 if (m_supports_qXfer_auxv_read == eLazyBoolCalculate) { 160 GetRemoteQSupported(); 161 } 162 return m_supports_qXfer_auxv_read == eLazyBoolYes; 163 } 164 165 bool GDBRemoteCommunicationClient::GetQXferFeaturesReadSupported() { 166 if (m_supports_qXfer_features_read == eLazyBoolCalculate) { 167 GetRemoteQSupported(); 168 } 169 return m_supports_qXfer_features_read == eLazyBoolYes; 170 } 171 172 bool GDBRemoteCommunicationClient::GetQXferMemoryMapReadSupported() { 173 if (m_supports_qXfer_memory_map_read == eLazyBoolCalculate) { 174 GetRemoteQSupported(); 175 } 176 return m_supports_qXfer_memory_map_read == eLazyBoolYes; 177 } 178 179 bool GDBRemoteCommunicationClient::GetQXferSigInfoReadSupported() { 180 if (m_supports_qXfer_siginfo_read == eLazyBoolCalculate) { 181 GetRemoteQSupported(); 182 } 183 return m_supports_qXfer_siginfo_read == eLazyBoolYes; 184 } 185 186 bool GDBRemoteCommunicationClient::GetMultiprocessSupported() { 187 if (m_supports_memory_tagging == eLazyBoolCalculate) 188 GetRemoteQSupported(); 189 return m_supports_multiprocess == eLazyBoolYes; 190 } 191 192 uint64_t GDBRemoteCommunicationClient::GetRemoteMaxPacketSize() { 193 if (m_max_packet_size == 0) { 194 GetRemoteQSupported(); 195 } 196 return m_max_packet_size; 197 } 198 199 bool GDBRemoteCommunicationClient::QueryNoAckModeSupported() { 200 if (m_supports_not_sending_acks == eLazyBoolCalculate) { 201 m_send_acks = true; 202 m_supports_not_sending_acks = eLazyBoolNo; 203 204 // This is the first real packet that we'll send in a debug session and it 205 // may take a little longer than normal to receive a reply. Wait at least 206 // 6 seconds for a reply to this packet. 207 208 ScopedTimeout timeout(*this, std::max(GetPacketTimeout(), seconds(6))); 209 210 StringExtractorGDBRemote response; 211 if (SendPacketAndWaitForResponse("QStartNoAckMode", response) == 212 PacketResult::Success) { 213 if (response.IsOKResponse()) { 214 m_send_acks = false; 215 m_supports_not_sending_acks = eLazyBoolYes; 216 } 217 return true; 218 } 219 } 220 return false; 221 } 222 223 void GDBRemoteCommunicationClient::GetListThreadsInStopReplySupported() { 224 if (m_supports_threads_in_stop_reply == eLazyBoolCalculate) { 225 m_supports_threads_in_stop_reply = eLazyBoolNo; 226 227 StringExtractorGDBRemote response; 228 if (SendPacketAndWaitForResponse("QListThreadsInStopReply", response) == 229 PacketResult::Success) { 230 if (response.IsOKResponse()) 231 m_supports_threads_in_stop_reply = eLazyBoolYes; 232 } 233 } 234 } 235 236 bool GDBRemoteCommunicationClient::GetVAttachOrWaitSupported() { 237 if (m_attach_or_wait_reply == eLazyBoolCalculate) { 238 m_attach_or_wait_reply = eLazyBoolNo; 239 240 StringExtractorGDBRemote response; 241 if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response) == 242 PacketResult::Success) { 243 if (response.IsOKResponse()) 244 m_attach_or_wait_reply = eLazyBoolYes; 245 } 246 } 247 return m_attach_or_wait_reply == eLazyBoolYes; 248 } 249 250 bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() { 251 if (m_prepare_for_reg_writing_reply == eLazyBoolCalculate) { 252 m_prepare_for_reg_writing_reply = eLazyBoolNo; 253 254 StringExtractorGDBRemote response; 255 if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response) == 256 PacketResult::Success) { 257 if (response.IsOKResponse()) 258 m_prepare_for_reg_writing_reply = eLazyBoolYes; 259 } 260 } 261 return m_prepare_for_reg_writing_reply == eLazyBoolYes; 262 } 263 264 void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) { 265 if (!did_exec) { 266 // Hard reset everything, this is when we first connect to a GDB server 267 m_supports_not_sending_acks = eLazyBoolCalculate; 268 m_supports_thread_suffix = eLazyBoolCalculate; 269 m_supports_threads_in_stop_reply = eLazyBoolCalculate; 270 m_supports_vCont_c = eLazyBoolCalculate; 271 m_supports_vCont_C = eLazyBoolCalculate; 272 m_supports_vCont_s = eLazyBoolCalculate; 273 m_supports_vCont_S = eLazyBoolCalculate; 274 m_supports_p = eLazyBoolCalculate; 275 m_supports_x = eLazyBoolCalculate; 276 m_supports_QSaveRegisterState = eLazyBoolCalculate; 277 m_qHostInfo_is_valid = eLazyBoolCalculate; 278 m_curr_pid_is_valid = eLazyBoolCalculate; 279 m_qGDBServerVersion_is_valid = eLazyBoolCalculate; 280 m_supports_alloc_dealloc_memory = eLazyBoolCalculate; 281 m_supports_memory_region_info = eLazyBoolCalculate; 282 m_prepare_for_reg_writing_reply = eLazyBoolCalculate; 283 m_attach_or_wait_reply = eLazyBoolCalculate; 284 m_avoid_g_packets = eLazyBoolCalculate; 285 m_supports_multiprocess = eLazyBoolCalculate; 286 m_supports_qSaveCore = eLazyBoolCalculate; 287 m_supports_qXfer_auxv_read = eLazyBoolCalculate; 288 m_supports_qXfer_libraries_read = eLazyBoolCalculate; 289 m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate; 290 m_supports_qXfer_features_read = eLazyBoolCalculate; 291 m_supports_qXfer_memory_map_read = eLazyBoolCalculate; 292 m_supports_qXfer_siginfo_read = eLazyBoolCalculate; 293 m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate; 294 m_uses_native_signals = eLazyBoolCalculate; 295 m_supports_qProcessInfoPID = true; 296 m_supports_qfProcessInfo = true; 297 m_supports_qUserName = true; 298 m_supports_qGroupName = true; 299 m_supports_qThreadStopInfo = true; 300 m_supports_z0 = true; 301 m_supports_z1 = true; 302 m_supports_z2 = true; 303 m_supports_z3 = true; 304 m_supports_z4 = true; 305 m_supports_QEnvironment = true; 306 m_supports_QEnvironmentHexEncoded = true; 307 m_supports_qSymbol = true; 308 m_qSymbol_requests_done = false; 309 m_supports_qModuleInfo = true; 310 m_host_arch.Clear(); 311 m_host_distribution_id.clear(); 312 m_os_version = llvm::VersionTuple(); 313 m_os_build.clear(); 314 m_os_kernel.clear(); 315 m_hostname.clear(); 316 m_gdb_server_name.clear(); 317 m_gdb_server_version = UINT32_MAX; 318 m_default_packet_timeout = seconds(0); 319 m_target_vm_page_size = 0; 320 m_max_packet_size = 0; 321 m_qSupported_response.clear(); 322 m_supported_async_json_packets_is_valid = false; 323 m_supported_async_json_packets_sp.reset(); 324 m_supports_jModulesInfo = true; 325 } 326 327 // These flags should be reset when we first connect to a GDB server and when 328 // our inferior process execs 329 m_qProcessInfo_is_valid = eLazyBoolCalculate; 330 m_process_arch.Clear(); 331 } 332 333 void GDBRemoteCommunicationClient::GetRemoteQSupported() { 334 // Clear out any capabilities we expect to see in the qSupported response 335 m_supports_qXfer_auxv_read = eLazyBoolNo; 336 m_supports_qXfer_libraries_read = eLazyBoolNo; 337 m_supports_qXfer_libraries_svr4_read = eLazyBoolNo; 338 m_supports_augmented_libraries_svr4_read = eLazyBoolNo; 339 m_supports_qXfer_features_read = eLazyBoolNo; 340 m_supports_qXfer_memory_map_read = eLazyBoolNo; 341 m_supports_qXfer_siginfo_read = eLazyBoolNo; 342 m_supports_multiprocess = eLazyBoolNo; 343 m_supports_qEcho = eLazyBoolNo; 344 m_supports_QPassSignals = eLazyBoolNo; 345 m_supports_memory_tagging = eLazyBoolNo; 346 m_supports_qSaveCore = eLazyBoolNo; 347 m_uses_native_signals = eLazyBoolNo; 348 349 m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if 350 // not, we assume no limit 351 352 // build the qSupported packet 353 std::vector<std::string> features = {"xmlRegisters=i386,arm,mips,arc", 354 "multiprocess+", "fork-events+", 355 "vfork-events+"}; 356 StreamString packet; 357 packet.PutCString("qSupported"); 358 for (uint32_t i = 0; i < features.size(); ++i) { 359 packet.PutCString(i == 0 ? ":" : ";"); 360 packet.PutCString(features[i]); 361 } 362 363 StringExtractorGDBRemote response; 364 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 365 PacketResult::Success) { 366 // Hang on to the qSupported packet, so that platforms can do custom 367 // configuration of the transport before attaching/launching the process. 368 m_qSupported_response = response.GetStringRef().str(); 369 370 for (llvm::StringRef x : llvm::split(response.GetStringRef(), ';')) { 371 if (x == "qXfer:auxv:read+") 372 m_supports_qXfer_auxv_read = eLazyBoolYes; 373 else if (x == "qXfer:libraries-svr4:read+") 374 m_supports_qXfer_libraries_svr4_read = eLazyBoolYes; 375 else if (x == "augmented-libraries-svr4-read") { 376 m_supports_qXfer_libraries_svr4_read = eLazyBoolYes; // implied 377 m_supports_augmented_libraries_svr4_read = eLazyBoolYes; 378 } else if (x == "qXfer:libraries:read+") 379 m_supports_qXfer_libraries_read = eLazyBoolYes; 380 else if (x == "qXfer:features:read+") 381 m_supports_qXfer_features_read = eLazyBoolYes; 382 else if (x == "qXfer:memory-map:read+") 383 m_supports_qXfer_memory_map_read = eLazyBoolYes; 384 else if (x == "qXfer:siginfo:read+") 385 m_supports_qXfer_siginfo_read = eLazyBoolYes; 386 else if (x == "qEcho") 387 m_supports_qEcho = eLazyBoolYes; 388 else if (x == "QPassSignals+") 389 m_supports_QPassSignals = eLazyBoolYes; 390 else if (x == "multiprocess+") 391 m_supports_multiprocess = eLazyBoolYes; 392 else if (x == "memory-tagging+") 393 m_supports_memory_tagging = eLazyBoolYes; 394 else if (x == "qSaveCore+") 395 m_supports_qSaveCore = eLazyBoolYes; 396 else if (x == "native-signals+") 397 m_uses_native_signals = eLazyBoolYes; 398 // Look for a list of compressions in the features list e.g. 399 // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib- 400 // deflate,lzma 401 else if (x.consume_front("SupportedCompressions=")) { 402 llvm::SmallVector<llvm::StringRef, 4> compressions; 403 x.split(compressions, ','); 404 if (!compressions.empty()) 405 MaybeEnableCompression(compressions); 406 } else if (x.consume_front("PacketSize=")) { 407 StringExtractorGDBRemote packet_response(x); 408 m_max_packet_size = 409 packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX); 410 if (m_max_packet_size == 0) { 411 m_max_packet_size = UINT64_MAX; // Must have been a garbled response 412 Log *log(GetLog(GDBRLog::Process)); 413 LLDB_LOGF(log, "Garbled PacketSize spec in qSupported response"); 414 } 415 } 416 } 417 } 418 } 419 420 bool GDBRemoteCommunicationClient::GetThreadSuffixSupported() { 421 if (m_supports_thread_suffix == eLazyBoolCalculate) { 422 StringExtractorGDBRemote response; 423 m_supports_thread_suffix = eLazyBoolNo; 424 if (SendPacketAndWaitForResponse("QThreadSuffixSupported", response) == 425 PacketResult::Success) { 426 if (response.IsOKResponse()) 427 m_supports_thread_suffix = eLazyBoolYes; 428 } 429 } 430 return m_supports_thread_suffix; 431 } 432 bool GDBRemoteCommunicationClient::GetVContSupported(char flavor) { 433 if (m_supports_vCont_c == eLazyBoolCalculate) { 434 StringExtractorGDBRemote response; 435 m_supports_vCont_any = eLazyBoolNo; 436 m_supports_vCont_all = eLazyBoolNo; 437 m_supports_vCont_c = eLazyBoolNo; 438 m_supports_vCont_C = eLazyBoolNo; 439 m_supports_vCont_s = eLazyBoolNo; 440 m_supports_vCont_S = eLazyBoolNo; 441 if (SendPacketAndWaitForResponse("vCont?", response) == 442 PacketResult::Success) { 443 const char *response_cstr = response.GetStringRef().data(); 444 if (::strstr(response_cstr, ";c")) 445 m_supports_vCont_c = eLazyBoolYes; 446 447 if (::strstr(response_cstr, ";C")) 448 m_supports_vCont_C = eLazyBoolYes; 449 450 if (::strstr(response_cstr, ";s")) 451 m_supports_vCont_s = eLazyBoolYes; 452 453 if (::strstr(response_cstr, ";S")) 454 m_supports_vCont_S = eLazyBoolYes; 455 456 if (m_supports_vCont_c == eLazyBoolYes && 457 m_supports_vCont_C == eLazyBoolYes && 458 m_supports_vCont_s == eLazyBoolYes && 459 m_supports_vCont_S == eLazyBoolYes) { 460 m_supports_vCont_all = eLazyBoolYes; 461 } 462 463 if (m_supports_vCont_c == eLazyBoolYes || 464 m_supports_vCont_C == eLazyBoolYes || 465 m_supports_vCont_s == eLazyBoolYes || 466 m_supports_vCont_S == eLazyBoolYes) { 467 m_supports_vCont_any = eLazyBoolYes; 468 } 469 } 470 } 471 472 switch (flavor) { 473 case 'a': 474 return m_supports_vCont_any; 475 case 'A': 476 return m_supports_vCont_all; 477 case 'c': 478 return m_supports_vCont_c; 479 case 'C': 480 return m_supports_vCont_C; 481 case 's': 482 return m_supports_vCont_s; 483 case 'S': 484 return m_supports_vCont_S; 485 default: 486 break; 487 } 488 return false; 489 } 490 491 GDBRemoteCommunication::PacketResult 492 GDBRemoteCommunicationClient::SendThreadSpecificPacketAndWaitForResponse( 493 lldb::tid_t tid, StreamString &&payload, 494 StringExtractorGDBRemote &response) { 495 Lock lock(*this); 496 if (!lock) { 497 if (Log *log = GetLog(GDBRLog::Process | GDBRLog::Packets)) 498 LLDB_LOGF(log, 499 "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex " 500 "for %s packet.", 501 __FUNCTION__, payload.GetData()); 502 return PacketResult::ErrorNoSequenceLock; 503 } 504 505 if (GetThreadSuffixSupported()) 506 payload.Printf(";thread:%4.4" PRIx64 ";", tid); 507 else { 508 if (!SetCurrentThread(tid)) 509 return PacketResult::ErrorSendFailed; 510 } 511 512 return SendPacketAndWaitForResponseNoLock(payload.GetString(), response); 513 } 514 515 // Check if the target supports 'p' packet. It sends out a 'p' packet and 516 // checks the response. A normal packet will tell us that support is available. 517 // 518 // Takes a valid thread ID because p needs to apply to a thread. 519 bool GDBRemoteCommunicationClient::GetpPacketSupported(lldb::tid_t tid) { 520 if (m_supports_p == eLazyBoolCalculate) 521 m_supports_p = GetThreadPacketSupported(tid, "p0"); 522 return m_supports_p; 523 } 524 525 LazyBool GDBRemoteCommunicationClient::GetThreadPacketSupported( 526 lldb::tid_t tid, llvm::StringRef packetStr) { 527 StreamString payload; 528 payload.PutCString(packetStr); 529 StringExtractorGDBRemote response; 530 if (SendThreadSpecificPacketAndWaitForResponse( 531 tid, std::move(payload), response) == PacketResult::Success && 532 response.IsNormalResponse()) { 533 return eLazyBoolYes; 534 } 535 return eLazyBoolNo; 536 } 537 538 bool GDBRemoteCommunicationClient::GetSaveCoreSupported() const { 539 return m_supports_qSaveCore == eLazyBoolYes; 540 } 541 542 StructuredData::ObjectSP GDBRemoteCommunicationClient::GetThreadsInfo() { 543 // Get information on all threads at one using the "jThreadsInfo" packet 544 StructuredData::ObjectSP object_sp; 545 546 if (m_supports_jThreadsInfo) { 547 StringExtractorGDBRemote response; 548 response.SetResponseValidatorToJSON(); 549 if (SendPacketAndWaitForResponse("jThreadsInfo", response) == 550 PacketResult::Success) { 551 if (response.IsUnsupportedResponse()) { 552 m_supports_jThreadsInfo = false; 553 } else if (!response.Empty()) { 554 object_sp = StructuredData::ParseJSON(response.GetStringRef()); 555 } 556 } 557 } 558 return object_sp; 559 } 560 561 bool GDBRemoteCommunicationClient::GetThreadExtendedInfoSupported() { 562 if (m_supports_jThreadExtendedInfo == eLazyBoolCalculate) { 563 StringExtractorGDBRemote response; 564 m_supports_jThreadExtendedInfo = eLazyBoolNo; 565 if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response) == 566 PacketResult::Success) { 567 if (response.IsOKResponse()) { 568 m_supports_jThreadExtendedInfo = eLazyBoolYes; 569 } 570 } 571 } 572 return m_supports_jThreadExtendedInfo; 573 } 574 575 void GDBRemoteCommunicationClient::EnableErrorStringInPacket() { 576 if (m_supports_error_string_reply == eLazyBoolCalculate) { 577 StringExtractorGDBRemote response; 578 // We try to enable error strings in remote packets but if we fail, we just 579 // work in the older way. 580 m_supports_error_string_reply = eLazyBoolNo; 581 if (SendPacketAndWaitForResponse("QEnableErrorStrings", response) == 582 PacketResult::Success) { 583 if (response.IsOKResponse()) { 584 m_supports_error_string_reply = eLazyBoolYes; 585 } 586 } 587 } 588 } 589 590 bool GDBRemoteCommunicationClient::GetLoadedDynamicLibrariesInfosSupported() { 591 if (m_supports_jLoadedDynamicLibrariesInfos == eLazyBoolCalculate) { 592 StringExtractorGDBRemote response; 593 m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolNo; 594 if (SendPacketAndWaitForResponse("jGetLoadedDynamicLibrariesInfos:", 595 response) == PacketResult::Success) { 596 if (response.IsOKResponse()) { 597 m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolYes; 598 } 599 } 600 } 601 return m_supports_jLoadedDynamicLibrariesInfos; 602 } 603 604 bool GDBRemoteCommunicationClient::GetSharedCacheInfoSupported() { 605 if (m_supports_jGetSharedCacheInfo == eLazyBoolCalculate) { 606 StringExtractorGDBRemote response; 607 m_supports_jGetSharedCacheInfo = eLazyBoolNo; 608 if (SendPacketAndWaitForResponse("jGetSharedCacheInfo:", response) == 609 PacketResult::Success) { 610 if (response.IsOKResponse()) { 611 m_supports_jGetSharedCacheInfo = eLazyBoolYes; 612 } 613 } 614 } 615 return m_supports_jGetSharedCacheInfo; 616 } 617 618 bool GDBRemoteCommunicationClient::GetDynamicLoaderProcessStateSupported() { 619 if (m_supports_jGetDyldProcessState == eLazyBoolCalculate) { 620 StringExtractorGDBRemote response; 621 m_supports_jGetDyldProcessState = eLazyBoolNo; 622 if (SendPacketAndWaitForResponse("jGetDyldProcessState", response) == 623 PacketResult::Success) { 624 if (!response.IsUnsupportedResponse()) 625 m_supports_jGetDyldProcessState = eLazyBoolYes; 626 } 627 } 628 return m_supports_jGetDyldProcessState; 629 } 630 631 bool GDBRemoteCommunicationClient::GetMemoryTaggingSupported() { 632 if (m_supports_memory_tagging == eLazyBoolCalculate) { 633 GetRemoteQSupported(); 634 } 635 return m_supports_memory_tagging == eLazyBoolYes; 636 } 637 638 DataBufferSP GDBRemoteCommunicationClient::ReadMemoryTags(lldb::addr_t addr, 639 size_t len, 640 int32_t type) { 641 StreamString packet; 642 packet.Printf("qMemTags:%" PRIx64 ",%zx:%" PRIx32, addr, len, type); 643 StringExtractorGDBRemote response; 644 645 Log *log = GetLog(GDBRLog::Memory); 646 647 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 648 PacketResult::Success || 649 !response.IsNormalResponse()) { 650 LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s: qMemTags packet failed", 651 __FUNCTION__); 652 return nullptr; 653 } 654 655 // We are expecting 656 // m<hex encoded bytes> 657 658 if (response.GetChar() != 'm') { 659 LLDB_LOGF(log, 660 "GDBRemoteCommunicationClient::%s: qMemTags response did not " 661 "begin with \"m\"", 662 __FUNCTION__); 663 return nullptr; 664 } 665 666 size_t expected_bytes = response.GetBytesLeft() / 2; 667 WritableDataBufferSP buffer_sp(new DataBufferHeap(expected_bytes, 0)); 668 size_t got_bytes = response.GetHexBytesAvail(buffer_sp->GetData()); 669 // Check both because in some situations chars are consumed even 670 // if the decoding fails. 671 if (response.GetBytesLeft() || (expected_bytes != got_bytes)) { 672 LLDB_LOGF( 673 log, 674 "GDBRemoteCommunicationClient::%s: Invalid data in qMemTags response", 675 __FUNCTION__); 676 return nullptr; 677 } 678 679 return buffer_sp; 680 } 681 682 Status GDBRemoteCommunicationClient::WriteMemoryTags( 683 lldb::addr_t addr, size_t len, int32_t type, 684 const std::vector<uint8_t> &tags) { 685 // Format QMemTags:address,length:type:tags 686 StreamString packet; 687 packet.Printf("QMemTags:%" PRIx64 ",%zx:%" PRIx32 ":", addr, len, type); 688 packet.PutBytesAsRawHex8(tags.data(), tags.size()); 689 690 Status status; 691 StringExtractorGDBRemote response; 692 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 693 PacketResult::Success || 694 !response.IsOKResponse()) { 695 status.SetErrorString("QMemTags packet failed"); 696 } 697 return status; 698 } 699 700 bool GDBRemoteCommunicationClient::GetxPacketSupported() { 701 if (m_supports_x == eLazyBoolCalculate) { 702 StringExtractorGDBRemote response; 703 m_supports_x = eLazyBoolNo; 704 char packet[256]; 705 snprintf(packet, sizeof(packet), "x0,0"); 706 if (SendPacketAndWaitForResponse(packet, response) == 707 PacketResult::Success) { 708 if (response.IsOKResponse()) 709 m_supports_x = eLazyBoolYes; 710 } 711 } 712 return m_supports_x; 713 } 714 715 lldb::pid_t GDBRemoteCommunicationClient::GetCurrentProcessID(bool allow_lazy) { 716 if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes) 717 return m_curr_pid; 718 719 // First try to retrieve the pid via the qProcessInfo request. 720 GetCurrentProcessInfo(allow_lazy); 721 if (m_curr_pid_is_valid == eLazyBoolYes) { 722 // We really got it. 723 return m_curr_pid; 724 } else { 725 // If we don't get a response for qProcessInfo, check if $qC gives us a 726 // result. $qC only returns a real process id on older debugserver and 727 // lldb-platform stubs. The gdb remote protocol documents $qC as returning 728 // the thread id, which newer debugserver and lldb-gdbserver stubs return 729 // correctly. 730 StringExtractorGDBRemote response; 731 if (SendPacketAndWaitForResponse("qC", response) == PacketResult::Success) { 732 if (response.GetChar() == 'Q') { 733 if (response.GetChar() == 'C') { 734 m_curr_pid_run = m_curr_pid = 735 response.GetHexMaxU64(false, LLDB_INVALID_PROCESS_ID); 736 if (m_curr_pid != LLDB_INVALID_PROCESS_ID) { 737 m_curr_pid_is_valid = eLazyBoolYes; 738 return m_curr_pid; 739 } 740 } 741 } 742 } 743 744 // If we don't get a response for $qC, check if $qfThreadID gives us a 745 // result. 746 if (m_curr_pid == LLDB_INVALID_PROCESS_ID) { 747 bool sequence_mutex_unavailable; 748 auto ids = GetCurrentProcessAndThreadIDs(sequence_mutex_unavailable); 749 if (!ids.empty() && !sequence_mutex_unavailable) { 750 // If server returned an explicit PID, use that. 751 m_curr_pid_run = m_curr_pid = ids.front().first; 752 // Otherwise, use the TID of the first thread (Linux hack). 753 if (m_curr_pid == LLDB_INVALID_PROCESS_ID) 754 m_curr_pid_run = m_curr_pid = ids.front().second; 755 m_curr_pid_is_valid = eLazyBoolYes; 756 return m_curr_pid; 757 } 758 } 759 } 760 761 return LLDB_INVALID_PROCESS_ID; 762 } 763 764 llvm::Error GDBRemoteCommunicationClient::LaunchProcess(const Args &args) { 765 if (!args.GetArgumentAtIndex(0)) 766 return llvm::createStringError(llvm::inconvertibleErrorCode(), 767 "Nothing to launch"); 768 // try vRun first 769 if (m_supports_vRun) { 770 StreamString packet; 771 packet.PutCString("vRun"); 772 for (const Args::ArgEntry &arg : args) { 773 packet.PutChar(';'); 774 packet.PutStringAsRawHex8(arg.ref()); 775 } 776 777 StringExtractorGDBRemote response; 778 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 779 PacketResult::Success) 780 return llvm::createStringError(llvm::inconvertibleErrorCode(), 781 "Sending vRun packet failed"); 782 783 if (response.IsErrorResponse()) 784 return response.GetStatus().ToError(); 785 786 // vRun replies with a stop reason packet 787 // FIXME: right now we just discard the packet and LLDB queries 788 // for stop reason again 789 if (!response.IsUnsupportedResponse()) 790 return llvm::Error::success(); 791 792 m_supports_vRun = false; 793 } 794 795 // fallback to A 796 StreamString packet; 797 packet.PutChar('A'); 798 llvm::ListSeparator LS(","); 799 for (const auto &arg : llvm::enumerate(args)) { 800 packet << LS; 801 packet.Format("{0},{1},", arg.value().ref().size() * 2, arg.index()); 802 packet.PutStringAsRawHex8(arg.value().ref()); 803 } 804 805 StringExtractorGDBRemote response; 806 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 807 PacketResult::Success) { 808 return llvm::createStringError(llvm::inconvertibleErrorCode(), 809 "Sending A packet failed"); 810 } 811 if (!response.IsOKResponse()) 812 return response.GetStatus().ToError(); 813 814 if (SendPacketAndWaitForResponse("qLaunchSuccess", response) != 815 PacketResult::Success) { 816 return llvm::createStringError(llvm::inconvertibleErrorCode(), 817 "Sending qLaunchSuccess packet failed"); 818 } 819 if (response.IsOKResponse()) 820 return llvm::Error::success(); 821 if (response.GetChar() == 'E') { 822 return llvm::createStringError(llvm::inconvertibleErrorCode(), 823 response.GetStringRef().substr(1)); 824 } 825 return llvm::createStringError(llvm::inconvertibleErrorCode(), 826 "unknown error occurred launching process"); 827 } 828 829 int GDBRemoteCommunicationClient::SendEnvironment(const Environment &env) { 830 llvm::SmallVector<std::pair<llvm::StringRef, llvm::StringRef>, 0> vec; 831 for (const auto &kv : env) 832 vec.emplace_back(kv.first(), kv.second); 833 llvm::sort(vec, llvm::less_first()); 834 for (const auto &[k, v] : vec) { 835 int r = SendEnvironmentPacket((k + "=" + v).str().c_str()); 836 if (r != 0) 837 return r; 838 } 839 return 0; 840 } 841 842 int GDBRemoteCommunicationClient::SendEnvironmentPacket( 843 char const *name_equal_value) { 844 if (name_equal_value && name_equal_value[0]) { 845 bool send_hex_encoding = false; 846 for (const char *p = name_equal_value; *p != '\0' && !send_hex_encoding; 847 ++p) { 848 if (llvm::isPrint(*p)) { 849 switch (*p) { 850 case '$': 851 case '#': 852 case '*': 853 case '}': 854 send_hex_encoding = true; 855 break; 856 default: 857 break; 858 } 859 } else { 860 // We have non printable characters, lets hex encode this... 861 send_hex_encoding = true; 862 } 863 } 864 865 StringExtractorGDBRemote response; 866 // Prefer sending unencoded, if possible and the server supports it. 867 if (!send_hex_encoding && m_supports_QEnvironment) { 868 StreamString packet; 869 packet.Printf("QEnvironment:%s", name_equal_value); 870 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 871 PacketResult::Success) 872 return -1; 873 874 if (response.IsOKResponse()) 875 return 0; 876 if (response.IsUnsupportedResponse()) 877 m_supports_QEnvironment = false; 878 else { 879 uint8_t error = response.GetError(); 880 if (error) 881 return error; 882 return -1; 883 } 884 } 885 886 if (m_supports_QEnvironmentHexEncoded) { 887 StreamString packet; 888 packet.PutCString("QEnvironmentHexEncoded:"); 889 packet.PutBytesAsRawHex8(name_equal_value, strlen(name_equal_value)); 890 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 891 PacketResult::Success) 892 return -1; 893 894 if (response.IsOKResponse()) 895 return 0; 896 if (response.IsUnsupportedResponse()) 897 m_supports_QEnvironmentHexEncoded = false; 898 else { 899 uint8_t error = response.GetError(); 900 if (error) 901 return error; 902 return -1; 903 } 904 } 905 } 906 return -1; 907 } 908 909 int GDBRemoteCommunicationClient::SendLaunchArchPacket(char const *arch) { 910 if (arch && arch[0]) { 911 StreamString packet; 912 packet.Printf("QLaunchArch:%s", arch); 913 StringExtractorGDBRemote response; 914 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 915 PacketResult::Success) { 916 if (response.IsOKResponse()) 917 return 0; 918 uint8_t error = response.GetError(); 919 if (error) 920 return error; 921 } 922 } 923 return -1; 924 } 925 926 int GDBRemoteCommunicationClient::SendLaunchEventDataPacket( 927 char const *data, bool *was_supported) { 928 if (data && *data != '\0') { 929 StreamString packet; 930 packet.Printf("QSetProcessEvent:%s", data); 931 StringExtractorGDBRemote response; 932 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 933 PacketResult::Success) { 934 if (response.IsOKResponse()) { 935 if (was_supported) 936 *was_supported = true; 937 return 0; 938 } else if (response.IsUnsupportedResponse()) { 939 if (was_supported) 940 *was_supported = false; 941 return -1; 942 } else { 943 uint8_t error = response.GetError(); 944 if (was_supported) 945 *was_supported = true; 946 if (error) 947 return error; 948 } 949 } 950 } 951 return -1; 952 } 953 954 llvm::VersionTuple GDBRemoteCommunicationClient::GetOSVersion() { 955 GetHostInfo(); 956 return m_os_version; 957 } 958 959 llvm::VersionTuple GDBRemoteCommunicationClient::GetMacCatalystVersion() { 960 GetHostInfo(); 961 return m_maccatalyst_version; 962 } 963 964 std::optional<std::string> GDBRemoteCommunicationClient::GetOSBuildString() { 965 if (GetHostInfo()) { 966 if (!m_os_build.empty()) 967 return m_os_build; 968 } 969 return std::nullopt; 970 } 971 972 std::optional<std::string> 973 GDBRemoteCommunicationClient::GetOSKernelDescription() { 974 if (GetHostInfo()) { 975 if (!m_os_kernel.empty()) 976 return m_os_kernel; 977 } 978 return std::nullopt; 979 } 980 981 bool GDBRemoteCommunicationClient::GetHostname(std::string &s) { 982 if (GetHostInfo()) { 983 if (!m_hostname.empty()) { 984 s = m_hostname; 985 return true; 986 } 987 } 988 s.clear(); 989 return false; 990 } 991 992 ArchSpec GDBRemoteCommunicationClient::GetSystemArchitecture() { 993 if (GetHostInfo()) 994 return m_host_arch; 995 return ArchSpec(); 996 } 997 998 const lldb_private::ArchSpec & 999 GDBRemoteCommunicationClient::GetProcessArchitecture() { 1000 if (m_qProcessInfo_is_valid == eLazyBoolCalculate) 1001 GetCurrentProcessInfo(); 1002 return m_process_arch; 1003 } 1004 1005 bool GDBRemoteCommunicationClient::GetProcessStandaloneBinary( 1006 UUID &uuid, addr_t &value, bool &value_is_offset) { 1007 if (m_qProcessInfo_is_valid == eLazyBoolCalculate) 1008 GetCurrentProcessInfo(); 1009 1010 // Return true if we have a UUID or an address/offset of the 1011 // main standalone / firmware binary being used. 1012 if (!m_process_standalone_uuid.IsValid() && 1013 m_process_standalone_value == LLDB_INVALID_ADDRESS) 1014 return false; 1015 1016 uuid = m_process_standalone_uuid; 1017 value = m_process_standalone_value; 1018 value_is_offset = m_process_standalone_value_is_offset; 1019 return true; 1020 } 1021 1022 std::vector<addr_t> 1023 GDBRemoteCommunicationClient::GetProcessStandaloneBinaries() { 1024 if (m_qProcessInfo_is_valid == eLazyBoolCalculate) 1025 GetCurrentProcessInfo(); 1026 return m_binary_addresses; 1027 } 1028 1029 bool GDBRemoteCommunicationClient::GetGDBServerVersion() { 1030 if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate) { 1031 m_gdb_server_name.clear(); 1032 m_gdb_server_version = 0; 1033 m_qGDBServerVersion_is_valid = eLazyBoolNo; 1034 1035 StringExtractorGDBRemote response; 1036 if (SendPacketAndWaitForResponse("qGDBServerVersion", response) == 1037 PacketResult::Success) { 1038 if (response.IsNormalResponse()) { 1039 llvm::StringRef name, value; 1040 bool success = false; 1041 while (response.GetNameColonValue(name, value)) { 1042 if (name.equals("name")) { 1043 success = true; 1044 m_gdb_server_name = std::string(value); 1045 } else if (name.equals("version")) { 1046 llvm::StringRef major, minor; 1047 std::tie(major, minor) = value.split('.'); 1048 if (!major.getAsInteger(0, m_gdb_server_version)) 1049 success = true; 1050 } 1051 } 1052 if (success) 1053 m_qGDBServerVersion_is_valid = eLazyBoolYes; 1054 } 1055 } 1056 } 1057 return m_qGDBServerVersion_is_valid == eLazyBoolYes; 1058 } 1059 1060 void GDBRemoteCommunicationClient::MaybeEnableCompression( 1061 llvm::ArrayRef<llvm::StringRef> supported_compressions) { 1062 CompressionType avail_type = CompressionType::None; 1063 llvm::StringRef avail_name; 1064 1065 #if defined(HAVE_LIBCOMPRESSION) 1066 if (avail_type == CompressionType::None) { 1067 for (auto compression : supported_compressions) { 1068 if (compression == "lzfse") { 1069 avail_type = CompressionType::LZFSE; 1070 avail_name = compression; 1071 break; 1072 } 1073 } 1074 } 1075 #endif 1076 1077 #if defined(HAVE_LIBCOMPRESSION) 1078 if (avail_type == CompressionType::None) { 1079 for (auto compression : supported_compressions) { 1080 if (compression == "zlib-deflate") { 1081 avail_type = CompressionType::ZlibDeflate; 1082 avail_name = compression; 1083 break; 1084 } 1085 } 1086 } 1087 #endif 1088 1089 #if LLVM_ENABLE_ZLIB 1090 if (avail_type == CompressionType::None) { 1091 for (auto compression : supported_compressions) { 1092 if (compression == "zlib-deflate") { 1093 avail_type = CompressionType::ZlibDeflate; 1094 avail_name = compression; 1095 break; 1096 } 1097 } 1098 } 1099 #endif 1100 1101 #if defined(HAVE_LIBCOMPRESSION) 1102 if (avail_type == CompressionType::None) { 1103 for (auto compression : supported_compressions) { 1104 if (compression == "lz4") { 1105 avail_type = CompressionType::LZ4; 1106 avail_name = compression; 1107 break; 1108 } 1109 } 1110 } 1111 #endif 1112 1113 #if defined(HAVE_LIBCOMPRESSION) 1114 if (avail_type == CompressionType::None) { 1115 for (auto compression : supported_compressions) { 1116 if (compression == "lzma") { 1117 avail_type = CompressionType::LZMA; 1118 avail_name = compression; 1119 break; 1120 } 1121 } 1122 } 1123 #endif 1124 1125 if (avail_type != CompressionType::None) { 1126 StringExtractorGDBRemote response; 1127 std::string packet = "QEnableCompression:type:" + avail_name.str() + ";"; 1128 if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success) 1129 return; 1130 1131 if (response.IsOKResponse()) { 1132 m_compression_type = avail_type; 1133 } 1134 } 1135 } 1136 1137 const char *GDBRemoteCommunicationClient::GetGDBServerProgramName() { 1138 if (GetGDBServerVersion()) { 1139 if (!m_gdb_server_name.empty()) 1140 return m_gdb_server_name.c_str(); 1141 } 1142 return nullptr; 1143 } 1144 1145 uint32_t GDBRemoteCommunicationClient::GetGDBServerProgramVersion() { 1146 if (GetGDBServerVersion()) 1147 return m_gdb_server_version; 1148 return 0; 1149 } 1150 1151 bool GDBRemoteCommunicationClient::GetDefaultThreadId(lldb::tid_t &tid) { 1152 StringExtractorGDBRemote response; 1153 if (SendPacketAndWaitForResponse("qC", response) != PacketResult::Success) 1154 return false; 1155 1156 if (!response.IsNormalResponse()) 1157 return false; 1158 1159 if (response.GetChar() == 'Q' && response.GetChar() == 'C') { 1160 auto pid_tid = response.GetPidTid(0); 1161 if (!pid_tid) 1162 return false; 1163 1164 lldb::pid_t pid = pid_tid->first; 1165 // invalid 1166 if (pid == StringExtractorGDBRemote::AllProcesses) 1167 return false; 1168 1169 // if we get pid as well, update m_curr_pid 1170 if (pid != 0) { 1171 m_curr_pid_run = m_curr_pid = pid; 1172 m_curr_pid_is_valid = eLazyBoolYes; 1173 } 1174 tid = pid_tid->second; 1175 } 1176 1177 return true; 1178 } 1179 1180 static void ParseOSType(llvm::StringRef value, std::string &os_name, 1181 std::string &environment) { 1182 if (value.equals("iossimulator") || value.equals("tvossimulator") || 1183 value.equals("watchossimulator")) { 1184 environment = "simulator"; 1185 os_name = value.drop_back(environment.size()).str(); 1186 } else if (value.equals("maccatalyst")) { 1187 os_name = "ios"; 1188 environment = "macabi"; 1189 } else { 1190 os_name = value.str(); 1191 } 1192 } 1193 1194 bool GDBRemoteCommunicationClient::GetHostInfo(bool force) { 1195 Log *log = GetLog(GDBRLog::Process); 1196 1197 if (force || m_qHostInfo_is_valid == eLazyBoolCalculate) { 1198 // host info computation can require DNS traffic and shelling out to external processes. 1199 // Increase the timeout to account for that. 1200 ScopedTimeout timeout(*this, seconds(10)); 1201 m_qHostInfo_is_valid = eLazyBoolNo; 1202 StringExtractorGDBRemote response; 1203 if (SendPacketAndWaitForResponse("qHostInfo", response) == 1204 PacketResult::Success) { 1205 if (response.IsNormalResponse()) { 1206 llvm::StringRef name; 1207 llvm::StringRef value; 1208 uint32_t cpu = LLDB_INVALID_CPUTYPE; 1209 uint32_t sub = 0; 1210 std::string arch_name; 1211 std::string os_name; 1212 std::string environment; 1213 std::string vendor_name; 1214 std::string triple; 1215 uint32_t pointer_byte_size = 0; 1216 ByteOrder byte_order = eByteOrderInvalid; 1217 uint32_t num_keys_decoded = 0; 1218 while (response.GetNameColonValue(name, value)) { 1219 if (name.equals("cputype")) { 1220 // exception type in big endian hex 1221 if (!value.getAsInteger(0, cpu)) 1222 ++num_keys_decoded; 1223 } else if (name.equals("cpusubtype")) { 1224 // exception count in big endian hex 1225 if (!value.getAsInteger(0, sub)) 1226 ++num_keys_decoded; 1227 } else if (name.equals("arch")) { 1228 arch_name = std::string(value); 1229 ++num_keys_decoded; 1230 } else if (name.equals("triple")) { 1231 StringExtractor extractor(value); 1232 extractor.GetHexByteString(triple); 1233 ++num_keys_decoded; 1234 } else if (name.equals("distribution_id")) { 1235 StringExtractor extractor(value); 1236 extractor.GetHexByteString(m_host_distribution_id); 1237 ++num_keys_decoded; 1238 } else if (name.equals("os_build")) { 1239 StringExtractor extractor(value); 1240 extractor.GetHexByteString(m_os_build); 1241 ++num_keys_decoded; 1242 } else if (name.equals("hostname")) { 1243 StringExtractor extractor(value); 1244 extractor.GetHexByteString(m_hostname); 1245 ++num_keys_decoded; 1246 } else if (name.equals("os_kernel")) { 1247 StringExtractor extractor(value); 1248 extractor.GetHexByteString(m_os_kernel); 1249 ++num_keys_decoded; 1250 } else if (name.equals("ostype")) { 1251 ParseOSType(value, os_name, environment); 1252 ++num_keys_decoded; 1253 } else if (name.equals("vendor")) { 1254 vendor_name = std::string(value); 1255 ++num_keys_decoded; 1256 } else if (name.equals("endian")) { 1257 byte_order = llvm::StringSwitch<lldb::ByteOrder>(value) 1258 .Case("little", eByteOrderLittle) 1259 .Case("big", eByteOrderBig) 1260 .Case("pdp", eByteOrderPDP) 1261 .Default(eByteOrderInvalid); 1262 if (byte_order != eByteOrderInvalid) 1263 ++num_keys_decoded; 1264 } else if (name.equals("ptrsize")) { 1265 if (!value.getAsInteger(0, pointer_byte_size)) 1266 ++num_keys_decoded; 1267 } else if (name.equals("addressing_bits")) { 1268 if (!value.getAsInteger(0, m_low_mem_addressing_bits)) { 1269 ++num_keys_decoded; 1270 } 1271 } else if (name.equals("high_mem_addressing_bits")) { 1272 if (!value.getAsInteger(0, m_high_mem_addressing_bits)) 1273 ++num_keys_decoded; 1274 } else if (name.equals("low_mem_addressing_bits")) { 1275 if (!value.getAsInteger(0, m_low_mem_addressing_bits)) 1276 ++num_keys_decoded; 1277 } else if (name.equals("os_version") || 1278 name.equals("version")) // Older debugserver binaries used 1279 // the "version" key instead of 1280 // "os_version"... 1281 { 1282 if (!m_os_version.tryParse(value)) 1283 ++num_keys_decoded; 1284 } else if (name.equals("maccatalyst_version")) { 1285 if (!m_maccatalyst_version.tryParse(value)) 1286 ++num_keys_decoded; 1287 } else if (name.equals("watchpoint_exceptions_received")) { 1288 m_watchpoints_trigger_after_instruction = 1289 llvm::StringSwitch<LazyBool>(value) 1290 .Case("before", eLazyBoolNo) 1291 .Case("after", eLazyBoolYes) 1292 .Default(eLazyBoolCalculate); 1293 if (m_watchpoints_trigger_after_instruction != eLazyBoolCalculate) 1294 ++num_keys_decoded; 1295 } else if (name.equals("default_packet_timeout")) { 1296 uint32_t timeout_seconds; 1297 if (!value.getAsInteger(0, timeout_seconds)) { 1298 m_default_packet_timeout = seconds(timeout_seconds); 1299 SetPacketTimeout(m_default_packet_timeout); 1300 ++num_keys_decoded; 1301 } 1302 } else if (name.equals("vm-page-size")) { 1303 int page_size; 1304 if (!value.getAsInteger(0, page_size)) { 1305 m_target_vm_page_size = page_size; 1306 ++num_keys_decoded; 1307 } 1308 } 1309 } 1310 1311 if (num_keys_decoded > 0) 1312 m_qHostInfo_is_valid = eLazyBoolYes; 1313 1314 if (triple.empty()) { 1315 if (arch_name.empty()) { 1316 if (cpu != LLDB_INVALID_CPUTYPE) { 1317 m_host_arch.SetArchitecture(eArchTypeMachO, cpu, sub); 1318 if (pointer_byte_size) { 1319 assert(pointer_byte_size == m_host_arch.GetAddressByteSize()); 1320 } 1321 if (byte_order != eByteOrderInvalid) { 1322 assert(byte_order == m_host_arch.GetByteOrder()); 1323 } 1324 1325 if (!vendor_name.empty()) 1326 m_host_arch.GetTriple().setVendorName( 1327 llvm::StringRef(vendor_name)); 1328 if (!os_name.empty()) 1329 m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name)); 1330 if (!environment.empty()) 1331 m_host_arch.GetTriple().setEnvironmentName(environment); 1332 } 1333 } else { 1334 std::string triple; 1335 triple += arch_name; 1336 if (!vendor_name.empty() || !os_name.empty()) { 1337 triple += '-'; 1338 if (vendor_name.empty()) 1339 triple += "unknown"; 1340 else 1341 triple += vendor_name; 1342 triple += '-'; 1343 if (os_name.empty()) 1344 triple += "unknown"; 1345 else 1346 triple += os_name; 1347 } 1348 m_host_arch.SetTriple(triple.c_str()); 1349 1350 llvm::Triple &host_triple = m_host_arch.GetTriple(); 1351 if (host_triple.getVendor() == llvm::Triple::Apple && 1352 host_triple.getOS() == llvm::Triple::Darwin) { 1353 switch (m_host_arch.GetMachine()) { 1354 case llvm::Triple::aarch64: 1355 case llvm::Triple::aarch64_32: 1356 case llvm::Triple::arm: 1357 case llvm::Triple::thumb: 1358 host_triple.setOS(llvm::Triple::IOS); 1359 break; 1360 default: 1361 host_triple.setOS(llvm::Triple::MacOSX); 1362 break; 1363 } 1364 } 1365 if (pointer_byte_size) { 1366 assert(pointer_byte_size == m_host_arch.GetAddressByteSize()); 1367 } 1368 if (byte_order != eByteOrderInvalid) { 1369 assert(byte_order == m_host_arch.GetByteOrder()); 1370 } 1371 } 1372 } else { 1373 m_host_arch.SetTriple(triple.c_str()); 1374 if (pointer_byte_size) { 1375 assert(pointer_byte_size == m_host_arch.GetAddressByteSize()); 1376 } 1377 if (byte_order != eByteOrderInvalid) { 1378 assert(byte_order == m_host_arch.GetByteOrder()); 1379 } 1380 1381 LLDB_LOGF(log, 1382 "GDBRemoteCommunicationClient::%s parsed host " 1383 "architecture as %s, triple as %s from triple text %s", 1384 __FUNCTION__, 1385 m_host_arch.GetArchitectureName() 1386 ? m_host_arch.GetArchitectureName() 1387 : "<null-arch-name>", 1388 m_host_arch.GetTriple().getTriple().c_str(), 1389 triple.c_str()); 1390 } 1391 } 1392 } 1393 } 1394 return m_qHostInfo_is_valid == eLazyBoolYes; 1395 } 1396 1397 int GDBRemoteCommunicationClient::SendStdinNotification(const char *data, 1398 size_t data_len) { 1399 StreamString packet; 1400 packet.PutCString("I"); 1401 packet.PutBytesAsRawHex8(data, data_len); 1402 StringExtractorGDBRemote response; 1403 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1404 PacketResult::Success) { 1405 return 0; 1406 } 1407 return response.GetError(); 1408 } 1409 1410 const lldb_private::ArchSpec & 1411 GDBRemoteCommunicationClient::GetHostArchitecture() { 1412 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1413 GetHostInfo(); 1414 return m_host_arch; 1415 } 1416 1417 AddressableBits GDBRemoteCommunicationClient::GetAddressableBits() { 1418 AddressableBits addressable_bits; 1419 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1420 GetHostInfo(); 1421 1422 if (m_low_mem_addressing_bits == m_high_mem_addressing_bits) 1423 addressable_bits.SetAddressableBits(m_low_mem_addressing_bits); 1424 else 1425 addressable_bits.SetAddressableBits(m_low_mem_addressing_bits, 1426 m_high_mem_addressing_bits); 1427 return addressable_bits; 1428 } 1429 1430 seconds GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout() { 1431 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1432 GetHostInfo(); 1433 return m_default_packet_timeout; 1434 } 1435 1436 addr_t GDBRemoteCommunicationClient::AllocateMemory(size_t size, 1437 uint32_t permissions) { 1438 if (m_supports_alloc_dealloc_memory != eLazyBoolNo) { 1439 m_supports_alloc_dealloc_memory = eLazyBoolYes; 1440 char packet[64]; 1441 const int packet_len = ::snprintf( 1442 packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s", (uint64_t)size, 1443 permissions & lldb::ePermissionsReadable ? "r" : "", 1444 permissions & lldb::ePermissionsWritable ? "w" : "", 1445 permissions & lldb::ePermissionsExecutable ? "x" : ""); 1446 assert(packet_len < (int)sizeof(packet)); 1447 UNUSED_IF_ASSERT_DISABLED(packet_len); 1448 StringExtractorGDBRemote response; 1449 if (SendPacketAndWaitForResponse(packet, response) == 1450 PacketResult::Success) { 1451 if (response.IsUnsupportedResponse()) 1452 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1453 else if (!response.IsErrorResponse()) 1454 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 1455 } else { 1456 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1457 } 1458 } 1459 return LLDB_INVALID_ADDRESS; 1460 } 1461 1462 bool GDBRemoteCommunicationClient::DeallocateMemory(addr_t addr) { 1463 if (m_supports_alloc_dealloc_memory != eLazyBoolNo) { 1464 m_supports_alloc_dealloc_memory = eLazyBoolYes; 1465 char packet[64]; 1466 const int packet_len = 1467 ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr); 1468 assert(packet_len < (int)sizeof(packet)); 1469 UNUSED_IF_ASSERT_DISABLED(packet_len); 1470 StringExtractorGDBRemote response; 1471 if (SendPacketAndWaitForResponse(packet, response) == 1472 PacketResult::Success) { 1473 if (response.IsUnsupportedResponse()) 1474 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1475 else if (response.IsOKResponse()) 1476 return true; 1477 } else { 1478 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1479 } 1480 } 1481 return false; 1482 } 1483 1484 Status GDBRemoteCommunicationClient::Detach(bool keep_stopped, 1485 lldb::pid_t pid) { 1486 Status error; 1487 lldb_private::StreamString packet; 1488 1489 packet.PutChar('D'); 1490 if (keep_stopped) { 1491 if (m_supports_detach_stay_stopped == eLazyBoolCalculate) { 1492 char packet[64]; 1493 const int packet_len = 1494 ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:"); 1495 assert(packet_len < (int)sizeof(packet)); 1496 UNUSED_IF_ASSERT_DISABLED(packet_len); 1497 StringExtractorGDBRemote response; 1498 if (SendPacketAndWaitForResponse(packet, response) == 1499 PacketResult::Success && 1500 response.IsOKResponse()) { 1501 m_supports_detach_stay_stopped = eLazyBoolYes; 1502 } else { 1503 m_supports_detach_stay_stopped = eLazyBoolNo; 1504 } 1505 } 1506 1507 if (m_supports_detach_stay_stopped == eLazyBoolNo) { 1508 error.SetErrorString("Stays stopped not supported by this target."); 1509 return error; 1510 } else { 1511 packet.PutChar('1'); 1512 } 1513 } 1514 1515 if (GetMultiprocessSupported()) { 1516 // Some servers (e.g. qemu) require specifying the PID even if only a single 1517 // process is running. 1518 if (pid == LLDB_INVALID_PROCESS_ID) 1519 pid = GetCurrentProcessID(); 1520 packet.PutChar(';'); 1521 packet.PutHex64(pid); 1522 } else if (pid != LLDB_INVALID_PROCESS_ID) { 1523 error.SetErrorString("Multiprocess extension not supported by the server."); 1524 return error; 1525 } 1526 1527 StringExtractorGDBRemote response; 1528 PacketResult packet_result = 1529 SendPacketAndWaitForResponse(packet.GetString(), response); 1530 if (packet_result != PacketResult::Success) 1531 error.SetErrorString("Sending isconnect packet failed."); 1532 return error; 1533 } 1534 1535 Status GDBRemoteCommunicationClient::GetMemoryRegionInfo( 1536 lldb::addr_t addr, lldb_private::MemoryRegionInfo ®ion_info) { 1537 Status error; 1538 region_info.Clear(); 1539 1540 if (m_supports_memory_region_info != eLazyBoolNo) { 1541 m_supports_memory_region_info = eLazyBoolYes; 1542 char packet[64]; 1543 const int packet_len = ::snprintf( 1544 packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr); 1545 assert(packet_len < (int)sizeof(packet)); 1546 UNUSED_IF_ASSERT_DISABLED(packet_len); 1547 StringExtractorGDBRemote response; 1548 if (SendPacketAndWaitForResponse(packet, response) == 1549 PacketResult::Success && 1550 response.GetResponseType() == StringExtractorGDBRemote::eResponse) { 1551 llvm::StringRef name; 1552 llvm::StringRef value; 1553 addr_t addr_value = LLDB_INVALID_ADDRESS; 1554 bool success = true; 1555 bool saw_permissions = false; 1556 while (success && response.GetNameColonValue(name, value)) { 1557 if (name.equals("start")) { 1558 if (!value.getAsInteger(16, addr_value)) 1559 region_info.GetRange().SetRangeBase(addr_value); 1560 } else if (name.equals("size")) { 1561 if (!value.getAsInteger(16, addr_value)) { 1562 region_info.GetRange().SetByteSize(addr_value); 1563 if (region_info.GetRange().GetRangeEnd() < 1564 region_info.GetRange().GetRangeBase()) { 1565 // Range size overflowed, truncate it. 1566 region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS); 1567 } 1568 } 1569 } else if (name.equals("permissions") && 1570 region_info.GetRange().IsValid()) { 1571 saw_permissions = true; 1572 if (region_info.GetRange().Contains(addr)) { 1573 if (value.contains('r')) 1574 region_info.SetReadable(MemoryRegionInfo::eYes); 1575 else 1576 region_info.SetReadable(MemoryRegionInfo::eNo); 1577 1578 if (value.contains('w')) 1579 region_info.SetWritable(MemoryRegionInfo::eYes); 1580 else 1581 region_info.SetWritable(MemoryRegionInfo::eNo); 1582 1583 if (value.contains('x')) 1584 region_info.SetExecutable(MemoryRegionInfo::eYes); 1585 else 1586 region_info.SetExecutable(MemoryRegionInfo::eNo); 1587 1588 region_info.SetMapped(MemoryRegionInfo::eYes); 1589 } else { 1590 // The reported region does not contain this address -- we're 1591 // looking at an unmapped page 1592 region_info.SetReadable(MemoryRegionInfo::eNo); 1593 region_info.SetWritable(MemoryRegionInfo::eNo); 1594 region_info.SetExecutable(MemoryRegionInfo::eNo); 1595 region_info.SetMapped(MemoryRegionInfo::eNo); 1596 } 1597 } else if (name.equals("name")) { 1598 StringExtractorGDBRemote name_extractor(value); 1599 std::string name; 1600 name_extractor.GetHexByteString(name); 1601 region_info.SetName(name.c_str()); 1602 } else if (name.equals("flags")) { 1603 region_info.SetMemoryTagged(MemoryRegionInfo::eNo); 1604 1605 llvm::StringRef flags = value; 1606 llvm::StringRef flag; 1607 while (flags.size()) { 1608 flags = flags.ltrim(); 1609 std::tie(flag, flags) = flags.split(' '); 1610 // To account for trailing whitespace 1611 if (flag.size()) { 1612 if (flag == "mt") { 1613 region_info.SetMemoryTagged(MemoryRegionInfo::eYes); 1614 break; 1615 } 1616 } 1617 } 1618 } else if (name.equals("type")) { 1619 std::string comma_sep_str = value.str(); 1620 size_t comma_pos; 1621 while ((comma_pos = comma_sep_str.find(',')) != std::string::npos) { 1622 comma_sep_str[comma_pos] = '\0'; 1623 if (comma_sep_str == "stack") { 1624 region_info.SetIsStackMemory(MemoryRegionInfo::eYes); 1625 } 1626 } 1627 // handle final (or only) type of "stack" 1628 if (comma_sep_str == "stack") { 1629 region_info.SetIsStackMemory(MemoryRegionInfo::eYes); 1630 } 1631 } else if (name.equals("error")) { 1632 StringExtractorGDBRemote error_extractor(value); 1633 std::string error_string; 1634 // Now convert the HEX bytes into a string value 1635 error_extractor.GetHexByteString(error_string); 1636 error.SetErrorString(error_string.c_str()); 1637 } else if (name.equals("dirty-pages")) { 1638 std::vector<addr_t> dirty_page_list; 1639 for (llvm::StringRef x : llvm::split(value, ',')) { 1640 addr_t page; 1641 x.consume_front("0x"); 1642 if (llvm::to_integer(x, page, 16)) 1643 dirty_page_list.push_back(page); 1644 } 1645 region_info.SetDirtyPageList(dirty_page_list); 1646 } 1647 } 1648 1649 if (m_target_vm_page_size != 0) 1650 region_info.SetPageSize(m_target_vm_page_size); 1651 1652 if (region_info.GetRange().IsValid()) { 1653 // We got a valid address range back but no permissions -- which means 1654 // this is an unmapped page 1655 if (!saw_permissions) { 1656 region_info.SetReadable(MemoryRegionInfo::eNo); 1657 region_info.SetWritable(MemoryRegionInfo::eNo); 1658 region_info.SetExecutable(MemoryRegionInfo::eNo); 1659 region_info.SetMapped(MemoryRegionInfo::eNo); 1660 } 1661 } else { 1662 // We got an invalid address range back 1663 error.SetErrorString("Server returned invalid range"); 1664 } 1665 } else { 1666 m_supports_memory_region_info = eLazyBoolNo; 1667 } 1668 } 1669 1670 if (m_supports_memory_region_info == eLazyBoolNo) { 1671 error.SetErrorString("qMemoryRegionInfo is not supported"); 1672 } 1673 1674 // Try qXfer:memory-map:read to get region information not included in 1675 // qMemoryRegionInfo 1676 MemoryRegionInfo qXfer_region_info; 1677 Status qXfer_error = GetQXferMemoryMapRegionInfo(addr, qXfer_region_info); 1678 1679 if (error.Fail()) { 1680 // If qMemoryRegionInfo failed, but qXfer:memory-map:read succeeded, use 1681 // the qXfer result as a fallback 1682 if (qXfer_error.Success()) { 1683 region_info = qXfer_region_info; 1684 error.Clear(); 1685 } else { 1686 region_info.Clear(); 1687 } 1688 } else if (qXfer_error.Success()) { 1689 // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and if 1690 // both regions are the same range, update the result to include the flash- 1691 // memory information that is specific to the qXfer result. 1692 if (region_info.GetRange() == qXfer_region_info.GetRange()) { 1693 region_info.SetFlash(qXfer_region_info.GetFlash()); 1694 region_info.SetBlocksize(qXfer_region_info.GetBlocksize()); 1695 } 1696 } 1697 return error; 1698 } 1699 1700 Status GDBRemoteCommunicationClient::GetQXferMemoryMapRegionInfo( 1701 lldb::addr_t addr, MemoryRegionInfo ®ion) { 1702 Status error = LoadQXferMemoryMap(); 1703 if (!error.Success()) 1704 return error; 1705 for (const auto &map_region : m_qXfer_memory_map) { 1706 if (map_region.GetRange().Contains(addr)) { 1707 region = map_region; 1708 return error; 1709 } 1710 } 1711 error.SetErrorString("Region not found"); 1712 return error; 1713 } 1714 1715 Status GDBRemoteCommunicationClient::LoadQXferMemoryMap() { 1716 1717 Status error; 1718 1719 if (m_qXfer_memory_map_loaded) 1720 // Already loaded, return success 1721 return error; 1722 1723 if (!XMLDocument::XMLEnabled()) { 1724 error.SetErrorString("XML is not supported"); 1725 return error; 1726 } 1727 1728 if (!GetQXferMemoryMapReadSupported()) { 1729 error.SetErrorString("Memory map is not supported"); 1730 return error; 1731 } 1732 1733 llvm::Expected<std::string> xml = ReadExtFeature("memory-map", ""); 1734 if (!xml) 1735 return Status(xml.takeError()); 1736 1737 XMLDocument xml_document; 1738 1739 if (!xml_document.ParseMemory(xml->c_str(), xml->size())) { 1740 error.SetErrorString("Failed to parse memory map xml"); 1741 return error; 1742 } 1743 1744 XMLNode map_node = xml_document.GetRootElement("memory-map"); 1745 if (!map_node) { 1746 error.SetErrorString("Invalid root node in memory map xml"); 1747 return error; 1748 } 1749 1750 m_qXfer_memory_map.clear(); 1751 1752 map_node.ForEachChildElement([this](const XMLNode &memory_node) -> bool { 1753 if (!memory_node.IsElement()) 1754 return true; 1755 if (memory_node.GetName() != "memory") 1756 return true; 1757 auto type = memory_node.GetAttributeValue("type", ""); 1758 uint64_t start; 1759 uint64_t length; 1760 if (!memory_node.GetAttributeValueAsUnsigned("start", start)) 1761 return true; 1762 if (!memory_node.GetAttributeValueAsUnsigned("length", length)) 1763 return true; 1764 MemoryRegionInfo region; 1765 region.GetRange().SetRangeBase(start); 1766 region.GetRange().SetByteSize(length); 1767 if (type == "rom") { 1768 region.SetReadable(MemoryRegionInfo::eYes); 1769 this->m_qXfer_memory_map.push_back(region); 1770 } else if (type == "ram") { 1771 region.SetReadable(MemoryRegionInfo::eYes); 1772 region.SetWritable(MemoryRegionInfo::eYes); 1773 this->m_qXfer_memory_map.push_back(region); 1774 } else if (type == "flash") { 1775 region.SetFlash(MemoryRegionInfo::eYes); 1776 memory_node.ForEachChildElement( 1777 [®ion](const XMLNode &prop_node) -> bool { 1778 if (!prop_node.IsElement()) 1779 return true; 1780 if (prop_node.GetName() != "property") 1781 return true; 1782 auto propname = prop_node.GetAttributeValue("name", ""); 1783 if (propname == "blocksize") { 1784 uint64_t blocksize; 1785 if (prop_node.GetElementTextAsUnsigned(blocksize)) 1786 region.SetBlocksize(blocksize); 1787 } 1788 return true; 1789 }); 1790 this->m_qXfer_memory_map.push_back(region); 1791 } 1792 return true; 1793 }); 1794 1795 m_qXfer_memory_map_loaded = true; 1796 1797 return error; 1798 } 1799 1800 std::optional<uint32_t> GDBRemoteCommunicationClient::GetWatchpointSlotCount() { 1801 if (m_supports_watchpoint_support_info == eLazyBoolYes) { 1802 return m_num_supported_hardware_watchpoints; 1803 } 1804 1805 std::optional<uint32_t> num; 1806 if (m_supports_watchpoint_support_info != eLazyBoolNo) { 1807 StringExtractorGDBRemote response; 1808 if (SendPacketAndWaitForResponse("qWatchpointSupportInfo:", response) == 1809 PacketResult::Success) { 1810 m_supports_watchpoint_support_info = eLazyBoolYes; 1811 llvm::StringRef name; 1812 llvm::StringRef value; 1813 while (response.GetNameColonValue(name, value)) { 1814 if (name.equals("num")) { 1815 value.getAsInteger(0, m_num_supported_hardware_watchpoints); 1816 num = m_num_supported_hardware_watchpoints; 1817 } 1818 } 1819 if (!num) { 1820 m_supports_watchpoint_support_info = eLazyBoolNo; 1821 } 1822 } else { 1823 m_supports_watchpoint_support_info = eLazyBoolNo; 1824 } 1825 } 1826 1827 return num; 1828 } 1829 1830 std::optional<bool> GDBRemoteCommunicationClient::GetWatchpointReportedAfter() { 1831 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1832 GetHostInfo(); 1833 1834 // Process determines this by target CPU, but allow for the 1835 // remote stub to override it via the qHostInfo 1836 // watchpoint_exceptions_received key, if it is present. 1837 if (m_qHostInfo_is_valid == eLazyBoolYes) { 1838 if (m_watchpoints_trigger_after_instruction == eLazyBoolNo) 1839 return false; 1840 if (m_watchpoints_trigger_after_instruction == eLazyBoolYes) 1841 return true; 1842 } 1843 1844 return std::nullopt; 1845 } 1846 1847 int GDBRemoteCommunicationClient::SetSTDIN(const FileSpec &file_spec) { 1848 if (file_spec) { 1849 std::string path{file_spec.GetPath(false)}; 1850 StreamString packet; 1851 packet.PutCString("QSetSTDIN:"); 1852 packet.PutStringAsRawHex8(path); 1853 1854 StringExtractorGDBRemote response; 1855 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1856 PacketResult::Success) { 1857 if (response.IsOKResponse()) 1858 return 0; 1859 uint8_t error = response.GetError(); 1860 if (error) 1861 return error; 1862 } 1863 } 1864 return -1; 1865 } 1866 1867 int GDBRemoteCommunicationClient::SetSTDOUT(const FileSpec &file_spec) { 1868 if (file_spec) { 1869 std::string path{file_spec.GetPath(false)}; 1870 StreamString packet; 1871 packet.PutCString("QSetSTDOUT:"); 1872 packet.PutStringAsRawHex8(path); 1873 1874 StringExtractorGDBRemote response; 1875 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1876 PacketResult::Success) { 1877 if (response.IsOKResponse()) 1878 return 0; 1879 uint8_t error = response.GetError(); 1880 if (error) 1881 return error; 1882 } 1883 } 1884 return -1; 1885 } 1886 1887 int GDBRemoteCommunicationClient::SetSTDERR(const FileSpec &file_spec) { 1888 if (file_spec) { 1889 std::string path{file_spec.GetPath(false)}; 1890 StreamString packet; 1891 packet.PutCString("QSetSTDERR:"); 1892 packet.PutStringAsRawHex8(path); 1893 1894 StringExtractorGDBRemote response; 1895 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1896 PacketResult::Success) { 1897 if (response.IsOKResponse()) 1898 return 0; 1899 uint8_t error = response.GetError(); 1900 if (error) 1901 return error; 1902 } 1903 } 1904 return -1; 1905 } 1906 1907 bool GDBRemoteCommunicationClient::GetWorkingDir(FileSpec &working_dir) { 1908 StringExtractorGDBRemote response; 1909 if (SendPacketAndWaitForResponse("qGetWorkingDir", response) == 1910 PacketResult::Success) { 1911 if (response.IsUnsupportedResponse()) 1912 return false; 1913 if (response.IsErrorResponse()) 1914 return false; 1915 std::string cwd; 1916 response.GetHexByteString(cwd); 1917 working_dir.SetFile(cwd, GetHostArchitecture().GetTriple()); 1918 return !cwd.empty(); 1919 } 1920 return false; 1921 } 1922 1923 int GDBRemoteCommunicationClient::SetWorkingDir(const FileSpec &working_dir) { 1924 if (working_dir) { 1925 std::string path{working_dir.GetPath(false)}; 1926 StreamString packet; 1927 packet.PutCString("QSetWorkingDir:"); 1928 packet.PutStringAsRawHex8(path); 1929 1930 StringExtractorGDBRemote response; 1931 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1932 PacketResult::Success) { 1933 if (response.IsOKResponse()) 1934 return 0; 1935 uint8_t error = response.GetError(); 1936 if (error) 1937 return error; 1938 } 1939 } 1940 return -1; 1941 } 1942 1943 int GDBRemoteCommunicationClient::SetDisableASLR(bool enable) { 1944 char packet[32]; 1945 const int packet_len = 1946 ::snprintf(packet, sizeof(packet), "QSetDisableASLR:%i", enable ? 1 : 0); 1947 assert(packet_len < (int)sizeof(packet)); 1948 UNUSED_IF_ASSERT_DISABLED(packet_len); 1949 StringExtractorGDBRemote response; 1950 if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success) { 1951 if (response.IsOKResponse()) 1952 return 0; 1953 uint8_t error = response.GetError(); 1954 if (error) 1955 return error; 1956 } 1957 return -1; 1958 } 1959 1960 int GDBRemoteCommunicationClient::SetDetachOnError(bool enable) { 1961 char packet[32]; 1962 const int packet_len = ::snprintf(packet, sizeof(packet), 1963 "QSetDetachOnError:%i", enable ? 1 : 0); 1964 assert(packet_len < (int)sizeof(packet)); 1965 UNUSED_IF_ASSERT_DISABLED(packet_len); 1966 StringExtractorGDBRemote response; 1967 if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success) { 1968 if (response.IsOKResponse()) 1969 return 0; 1970 uint8_t error = response.GetError(); 1971 if (error) 1972 return error; 1973 } 1974 return -1; 1975 } 1976 1977 bool GDBRemoteCommunicationClient::DecodeProcessInfoResponse( 1978 StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info) { 1979 if (response.IsNormalResponse()) { 1980 llvm::StringRef name; 1981 llvm::StringRef value; 1982 StringExtractor extractor; 1983 1984 uint32_t cpu = LLDB_INVALID_CPUTYPE; 1985 uint32_t sub = 0; 1986 std::string vendor; 1987 std::string os_type; 1988 1989 while (response.GetNameColonValue(name, value)) { 1990 if (name.equals("pid")) { 1991 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 1992 value.getAsInteger(0, pid); 1993 process_info.SetProcessID(pid); 1994 } else if (name.equals("ppid")) { 1995 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 1996 value.getAsInteger(0, pid); 1997 process_info.SetParentProcessID(pid); 1998 } else if (name.equals("uid")) { 1999 uint32_t uid = UINT32_MAX; 2000 value.getAsInteger(0, uid); 2001 process_info.SetUserID(uid); 2002 } else if (name.equals("euid")) { 2003 uint32_t uid = UINT32_MAX; 2004 value.getAsInteger(0, uid); 2005 process_info.SetEffectiveUserID(uid); 2006 } else if (name.equals("gid")) { 2007 uint32_t gid = UINT32_MAX; 2008 value.getAsInteger(0, gid); 2009 process_info.SetGroupID(gid); 2010 } else if (name.equals("egid")) { 2011 uint32_t gid = UINT32_MAX; 2012 value.getAsInteger(0, gid); 2013 process_info.SetEffectiveGroupID(gid); 2014 } else if (name.equals("triple")) { 2015 StringExtractor extractor(value); 2016 std::string triple; 2017 extractor.GetHexByteString(triple); 2018 process_info.GetArchitecture().SetTriple(triple.c_str()); 2019 } else if (name.equals("name")) { 2020 StringExtractor extractor(value); 2021 // The process name from ASCII hex bytes since we can't control the 2022 // characters in a process name 2023 std::string name; 2024 extractor.GetHexByteString(name); 2025 process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native); 2026 } else if (name.equals("args")) { 2027 llvm::StringRef encoded_args(value), hex_arg; 2028 2029 bool is_arg0 = true; 2030 while (!encoded_args.empty()) { 2031 std::tie(hex_arg, encoded_args) = encoded_args.split('-'); 2032 std::string arg; 2033 StringExtractor extractor(hex_arg); 2034 if (extractor.GetHexByteString(arg) * 2 != hex_arg.size()) { 2035 // In case of wrong encoding, we discard all the arguments 2036 process_info.GetArguments().Clear(); 2037 process_info.SetArg0(""); 2038 break; 2039 } 2040 if (is_arg0) 2041 process_info.SetArg0(arg); 2042 else 2043 process_info.GetArguments().AppendArgument(arg); 2044 is_arg0 = false; 2045 } 2046 } else if (name.equals("cputype")) { 2047 value.getAsInteger(0, cpu); 2048 } else if (name.equals("cpusubtype")) { 2049 value.getAsInteger(0, sub); 2050 } else if (name.equals("vendor")) { 2051 vendor = std::string(value); 2052 } else if (name.equals("ostype")) { 2053 os_type = std::string(value); 2054 } 2055 } 2056 2057 if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty()) { 2058 if (vendor == "apple") { 2059 process_info.GetArchitecture().SetArchitecture(eArchTypeMachO, cpu, 2060 sub); 2061 process_info.GetArchitecture().GetTriple().setVendorName( 2062 llvm::StringRef(vendor)); 2063 process_info.GetArchitecture().GetTriple().setOSName( 2064 llvm::StringRef(os_type)); 2065 } 2066 } 2067 2068 if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) 2069 return true; 2070 } 2071 return false; 2072 } 2073 2074 bool GDBRemoteCommunicationClient::GetProcessInfo( 2075 lldb::pid_t pid, ProcessInstanceInfo &process_info) { 2076 process_info.Clear(); 2077 2078 if (m_supports_qProcessInfoPID) { 2079 char packet[32]; 2080 const int packet_len = 2081 ::snprintf(packet, sizeof(packet), "qProcessInfoPID:%" PRIu64, pid); 2082 assert(packet_len < (int)sizeof(packet)); 2083 UNUSED_IF_ASSERT_DISABLED(packet_len); 2084 StringExtractorGDBRemote response; 2085 if (SendPacketAndWaitForResponse(packet, response) == 2086 PacketResult::Success) { 2087 return DecodeProcessInfoResponse(response, process_info); 2088 } else { 2089 m_supports_qProcessInfoPID = false; 2090 return false; 2091 } 2092 } 2093 return false; 2094 } 2095 2096 bool GDBRemoteCommunicationClient::GetCurrentProcessInfo(bool allow_lazy) { 2097 Log *log(GetLog(GDBRLog::Process | GDBRLog::Packets)); 2098 2099 if (allow_lazy) { 2100 if (m_qProcessInfo_is_valid == eLazyBoolYes) 2101 return true; 2102 if (m_qProcessInfo_is_valid == eLazyBoolNo) 2103 return false; 2104 } 2105 2106 GetHostInfo(); 2107 2108 StringExtractorGDBRemote response; 2109 if (SendPacketAndWaitForResponse("qProcessInfo", response) == 2110 PacketResult::Success) { 2111 if (response.IsNormalResponse()) { 2112 llvm::StringRef name; 2113 llvm::StringRef value; 2114 uint32_t cpu = LLDB_INVALID_CPUTYPE; 2115 uint32_t sub = 0; 2116 std::string arch_name; 2117 std::string os_name; 2118 std::string environment; 2119 std::string vendor_name; 2120 std::string triple; 2121 std::string elf_abi; 2122 uint32_t pointer_byte_size = 0; 2123 StringExtractor extractor; 2124 ByteOrder byte_order = eByteOrderInvalid; 2125 uint32_t num_keys_decoded = 0; 2126 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 2127 while (response.GetNameColonValue(name, value)) { 2128 if (name.equals("cputype")) { 2129 if (!value.getAsInteger(16, cpu)) 2130 ++num_keys_decoded; 2131 } else if (name.equals("cpusubtype")) { 2132 if (!value.getAsInteger(16, sub)) 2133 ++num_keys_decoded; 2134 } else if (name.equals("triple")) { 2135 StringExtractor extractor(value); 2136 extractor.GetHexByteString(triple); 2137 ++num_keys_decoded; 2138 } else if (name.equals("ostype")) { 2139 ParseOSType(value, os_name, environment); 2140 ++num_keys_decoded; 2141 } else if (name.equals("vendor")) { 2142 vendor_name = std::string(value); 2143 ++num_keys_decoded; 2144 } else if (name.equals("endian")) { 2145 byte_order = llvm::StringSwitch<lldb::ByteOrder>(value) 2146 .Case("little", eByteOrderLittle) 2147 .Case("big", eByteOrderBig) 2148 .Case("pdp", eByteOrderPDP) 2149 .Default(eByteOrderInvalid); 2150 if (byte_order != eByteOrderInvalid) 2151 ++num_keys_decoded; 2152 } else if (name.equals("ptrsize")) { 2153 if (!value.getAsInteger(16, pointer_byte_size)) 2154 ++num_keys_decoded; 2155 } else if (name.equals("pid")) { 2156 if (!value.getAsInteger(16, pid)) 2157 ++num_keys_decoded; 2158 } else if (name.equals("elf_abi")) { 2159 elf_abi = std::string(value); 2160 ++num_keys_decoded; 2161 } else if (name.equals("main-binary-uuid")) { 2162 m_process_standalone_uuid.SetFromStringRef(value); 2163 ++num_keys_decoded; 2164 } else if (name.equals("main-binary-slide")) { 2165 StringExtractor extractor(value); 2166 m_process_standalone_value = 2167 extractor.GetU64(LLDB_INVALID_ADDRESS, 16); 2168 if (m_process_standalone_value != LLDB_INVALID_ADDRESS) { 2169 m_process_standalone_value_is_offset = true; 2170 ++num_keys_decoded; 2171 } 2172 } else if (name.equals("main-binary-address")) { 2173 StringExtractor extractor(value); 2174 m_process_standalone_value = 2175 extractor.GetU64(LLDB_INVALID_ADDRESS, 16); 2176 if (m_process_standalone_value != LLDB_INVALID_ADDRESS) { 2177 m_process_standalone_value_is_offset = false; 2178 ++num_keys_decoded; 2179 } 2180 } else if (name.equals("binary-addresses")) { 2181 m_binary_addresses.clear(); 2182 ++num_keys_decoded; 2183 for (llvm::StringRef x : llvm::split(value, ',')) { 2184 addr_t vmaddr; 2185 x.consume_front("0x"); 2186 if (llvm::to_integer(x, vmaddr, 16)) 2187 m_binary_addresses.push_back(vmaddr); 2188 } 2189 } 2190 } 2191 if (num_keys_decoded > 0) 2192 m_qProcessInfo_is_valid = eLazyBoolYes; 2193 if (pid != LLDB_INVALID_PROCESS_ID) { 2194 m_curr_pid_is_valid = eLazyBoolYes; 2195 m_curr_pid_run = m_curr_pid = pid; 2196 } 2197 2198 // Set the ArchSpec from the triple if we have it. 2199 if (!triple.empty()) { 2200 m_process_arch.SetTriple(triple.c_str()); 2201 m_process_arch.SetFlags(elf_abi); 2202 if (pointer_byte_size) { 2203 assert(pointer_byte_size == m_process_arch.GetAddressByteSize()); 2204 } 2205 } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && 2206 !vendor_name.empty()) { 2207 llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name); 2208 if (!environment.empty()) 2209 triple.setEnvironmentName(environment); 2210 2211 assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat); 2212 assert(triple.getObjectFormat() != llvm::Triple::Wasm); 2213 assert(triple.getObjectFormat() != llvm::Triple::XCOFF); 2214 switch (triple.getObjectFormat()) { 2215 case llvm::Triple::MachO: 2216 m_process_arch.SetArchitecture(eArchTypeMachO, cpu, sub); 2217 break; 2218 case llvm::Triple::ELF: 2219 m_process_arch.SetArchitecture(eArchTypeELF, cpu, sub); 2220 break; 2221 case llvm::Triple::COFF: 2222 m_process_arch.SetArchitecture(eArchTypeCOFF, cpu, sub); 2223 break; 2224 case llvm::Triple::GOFF: 2225 case llvm::Triple::SPIRV: 2226 case llvm::Triple::Wasm: 2227 case llvm::Triple::XCOFF: 2228 case llvm::Triple::DXContainer: 2229 LLDB_LOGF(log, "error: not supported target architecture"); 2230 return false; 2231 case llvm::Triple::UnknownObjectFormat: 2232 LLDB_LOGF(log, "error: failed to determine target architecture"); 2233 return false; 2234 } 2235 2236 if (pointer_byte_size) { 2237 assert(pointer_byte_size == m_process_arch.GetAddressByteSize()); 2238 } 2239 if (byte_order != eByteOrderInvalid) { 2240 assert(byte_order == m_process_arch.GetByteOrder()); 2241 } 2242 m_process_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name)); 2243 m_process_arch.GetTriple().setOSName(llvm::StringRef(os_name)); 2244 m_process_arch.GetTriple().setEnvironmentName(llvm::StringRef(environment)); 2245 } 2246 return true; 2247 } 2248 } else { 2249 m_qProcessInfo_is_valid = eLazyBoolNo; 2250 } 2251 2252 return false; 2253 } 2254 2255 uint32_t GDBRemoteCommunicationClient::FindProcesses( 2256 const ProcessInstanceInfoMatch &match_info, 2257 ProcessInstanceInfoList &process_infos) { 2258 process_infos.clear(); 2259 2260 if (m_supports_qfProcessInfo) { 2261 StreamString packet; 2262 packet.PutCString("qfProcessInfo"); 2263 if (!match_info.MatchAllProcesses()) { 2264 packet.PutChar(':'); 2265 const char *name = match_info.GetProcessInfo().GetName(); 2266 bool has_name_match = false; 2267 if (name && name[0]) { 2268 has_name_match = true; 2269 NameMatch name_match_type = match_info.GetNameMatchType(); 2270 switch (name_match_type) { 2271 case NameMatch::Ignore: 2272 has_name_match = false; 2273 break; 2274 2275 case NameMatch::Equals: 2276 packet.PutCString("name_match:equals;"); 2277 break; 2278 2279 case NameMatch::Contains: 2280 packet.PutCString("name_match:contains;"); 2281 break; 2282 2283 case NameMatch::StartsWith: 2284 packet.PutCString("name_match:starts_with;"); 2285 break; 2286 2287 case NameMatch::EndsWith: 2288 packet.PutCString("name_match:ends_with;"); 2289 break; 2290 2291 case NameMatch::RegularExpression: 2292 packet.PutCString("name_match:regex;"); 2293 break; 2294 } 2295 if (has_name_match) { 2296 packet.PutCString("name:"); 2297 packet.PutBytesAsRawHex8(name, ::strlen(name)); 2298 packet.PutChar(';'); 2299 } 2300 } 2301 2302 if (match_info.GetProcessInfo().ProcessIDIsValid()) 2303 packet.Printf("pid:%" PRIu64 ";", 2304 match_info.GetProcessInfo().GetProcessID()); 2305 if (match_info.GetProcessInfo().ParentProcessIDIsValid()) 2306 packet.Printf("parent_pid:%" PRIu64 ";", 2307 match_info.GetProcessInfo().GetParentProcessID()); 2308 if (match_info.GetProcessInfo().UserIDIsValid()) 2309 packet.Printf("uid:%u;", match_info.GetProcessInfo().GetUserID()); 2310 if (match_info.GetProcessInfo().GroupIDIsValid()) 2311 packet.Printf("gid:%u;", match_info.GetProcessInfo().GetGroupID()); 2312 if (match_info.GetProcessInfo().EffectiveUserIDIsValid()) 2313 packet.Printf("euid:%u;", 2314 match_info.GetProcessInfo().GetEffectiveUserID()); 2315 if (match_info.GetProcessInfo().EffectiveGroupIDIsValid()) 2316 packet.Printf("egid:%u;", 2317 match_info.GetProcessInfo().GetEffectiveGroupID()); 2318 packet.Printf("all_users:%u;", match_info.GetMatchAllUsers() ? 1 : 0); 2319 if (match_info.GetProcessInfo().GetArchitecture().IsValid()) { 2320 const ArchSpec &match_arch = 2321 match_info.GetProcessInfo().GetArchitecture(); 2322 const llvm::Triple &triple = match_arch.GetTriple(); 2323 packet.PutCString("triple:"); 2324 packet.PutCString(triple.getTriple()); 2325 packet.PutChar(';'); 2326 } 2327 } 2328 StringExtractorGDBRemote response; 2329 // Increase timeout as the first qfProcessInfo packet takes a long time on 2330 // Android. The value of 1min was arrived at empirically. 2331 ScopedTimeout timeout(*this, minutes(1)); 2332 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 2333 PacketResult::Success) { 2334 do { 2335 ProcessInstanceInfo process_info; 2336 if (!DecodeProcessInfoResponse(response, process_info)) 2337 break; 2338 process_infos.push_back(process_info); 2339 response = StringExtractorGDBRemote(); 2340 } while (SendPacketAndWaitForResponse("qsProcessInfo", response) == 2341 PacketResult::Success); 2342 } else { 2343 m_supports_qfProcessInfo = false; 2344 return 0; 2345 } 2346 } 2347 return process_infos.size(); 2348 } 2349 2350 bool GDBRemoteCommunicationClient::GetUserName(uint32_t uid, 2351 std::string &name) { 2352 if (m_supports_qUserName) { 2353 char packet[32]; 2354 const int packet_len = 2355 ::snprintf(packet, sizeof(packet), "qUserName:%i", uid); 2356 assert(packet_len < (int)sizeof(packet)); 2357 UNUSED_IF_ASSERT_DISABLED(packet_len); 2358 StringExtractorGDBRemote response; 2359 if (SendPacketAndWaitForResponse(packet, response) == 2360 PacketResult::Success) { 2361 if (response.IsNormalResponse()) { 2362 // Make sure we parsed the right number of characters. The response is 2363 // the hex encoded user name and should make up the entire packet. If 2364 // there are any non-hex ASCII bytes, the length won't match below.. 2365 if (response.GetHexByteString(name) * 2 == 2366 response.GetStringRef().size()) 2367 return true; 2368 } 2369 } else { 2370 m_supports_qUserName = false; 2371 return false; 2372 } 2373 } 2374 return false; 2375 } 2376 2377 bool GDBRemoteCommunicationClient::GetGroupName(uint32_t gid, 2378 std::string &name) { 2379 if (m_supports_qGroupName) { 2380 char packet[32]; 2381 const int packet_len = 2382 ::snprintf(packet, sizeof(packet), "qGroupName:%i", gid); 2383 assert(packet_len < (int)sizeof(packet)); 2384 UNUSED_IF_ASSERT_DISABLED(packet_len); 2385 StringExtractorGDBRemote response; 2386 if (SendPacketAndWaitForResponse(packet, response) == 2387 PacketResult::Success) { 2388 if (response.IsNormalResponse()) { 2389 // Make sure we parsed the right number of characters. The response is 2390 // the hex encoded group name and should make up the entire packet. If 2391 // there are any non-hex ASCII bytes, the length won't match below.. 2392 if (response.GetHexByteString(name) * 2 == 2393 response.GetStringRef().size()) 2394 return true; 2395 } 2396 } else { 2397 m_supports_qGroupName = false; 2398 return false; 2399 } 2400 } 2401 return false; 2402 } 2403 2404 static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size, 2405 uint32_t recv_size) { 2406 packet.Clear(); 2407 packet.Printf("qSpeedTest:response_size:%i;data:", recv_size); 2408 uint32_t bytes_left = send_size; 2409 while (bytes_left > 0) { 2410 if (bytes_left >= 26) { 2411 packet.PutCString("abcdefghijklmnopqrstuvwxyz"); 2412 bytes_left -= 26; 2413 } else { 2414 packet.Printf("%*.*s;", bytes_left, bytes_left, 2415 "abcdefghijklmnopqrstuvwxyz"); 2416 bytes_left = 0; 2417 } 2418 } 2419 } 2420 2421 duration<float> 2422 calculate_standard_deviation(const std::vector<duration<float>> &v) { 2423 if (v.size() == 0) 2424 return duration<float>::zero(); 2425 using Dur = duration<float>; 2426 Dur sum = std::accumulate(std::begin(v), std::end(v), Dur()); 2427 Dur mean = sum / v.size(); 2428 float accum = 0; 2429 for (auto d : v) { 2430 float delta = (d - mean).count(); 2431 accum += delta * delta; 2432 }; 2433 2434 return Dur(sqrtf(accum / (v.size() - 1))); 2435 } 2436 2437 void GDBRemoteCommunicationClient::TestPacketSpeed(const uint32_t num_packets, 2438 uint32_t max_send, 2439 uint32_t max_recv, 2440 uint64_t recv_amount, 2441 bool json, Stream &strm) { 2442 2443 if (SendSpeedTestPacket(0, 0)) { 2444 StreamString packet; 2445 if (json) 2446 strm.Printf("{ \"packet_speeds\" : {\n \"num_packets\" : %u,\n " 2447 "\"results\" : [", 2448 num_packets); 2449 else 2450 strm.Printf("Testing sending %u packets of various sizes:\n", 2451 num_packets); 2452 strm.Flush(); 2453 2454 uint32_t result_idx = 0; 2455 uint32_t send_size; 2456 std::vector<duration<float>> packet_times; 2457 2458 for (send_size = 0; send_size <= max_send; 2459 send_size ? send_size *= 2 : send_size = 4) { 2460 for (uint32_t recv_size = 0; recv_size <= max_recv; 2461 recv_size ? recv_size *= 2 : recv_size = 4) { 2462 MakeSpeedTestPacket(packet, send_size, recv_size); 2463 2464 packet_times.clear(); 2465 // Test how long it takes to send 'num_packets' packets 2466 const auto start_time = steady_clock::now(); 2467 for (uint32_t i = 0; i < num_packets; ++i) { 2468 const auto packet_start_time = steady_clock::now(); 2469 StringExtractorGDBRemote response; 2470 SendPacketAndWaitForResponse(packet.GetString(), response); 2471 const auto packet_end_time = steady_clock::now(); 2472 packet_times.push_back(packet_end_time - packet_start_time); 2473 } 2474 const auto end_time = steady_clock::now(); 2475 const auto total_time = end_time - start_time; 2476 2477 float packets_per_second = 2478 ((float)num_packets) / duration<float>(total_time).count(); 2479 auto average_per_packet = num_packets > 0 ? total_time / num_packets 2480 : duration<float>::zero(); 2481 const duration<float> standard_deviation = 2482 calculate_standard_deviation(packet_times); 2483 if (json) { 2484 strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : " 2485 "{2,6}, \"total_time_nsec\" : {3,12:ns-}, " 2486 "\"standard_deviation_nsec\" : {4,9:ns-f0}}", 2487 result_idx > 0 ? "," : "", send_size, recv_size, 2488 total_time, standard_deviation); 2489 ++result_idx; 2490 } else { 2491 strm.Format("qSpeedTest(send={0,7}, recv={1,7}) in {2:s+f9} for " 2492 "{3,9:f2} packets/s ({4,10:ms+f6} per packet) with " 2493 "standard deviation of {5,10:ms+f6}\n", 2494 send_size, recv_size, duration<float>(total_time), 2495 packets_per_second, duration<float>(average_per_packet), 2496 standard_deviation); 2497 } 2498 strm.Flush(); 2499 } 2500 } 2501 2502 const float k_recv_amount_mb = (float)recv_amount / (1024.0f * 1024.0f); 2503 if (json) 2504 strm.Printf("\n ]\n },\n \"download_speed\" : {\n \"byte_size\" " 2505 ": %" PRIu64 ",\n \"results\" : [", 2506 recv_amount); 2507 else 2508 strm.Printf("Testing receiving %2.1fMB of data using varying receive " 2509 "packet sizes:\n", 2510 k_recv_amount_mb); 2511 strm.Flush(); 2512 send_size = 0; 2513 result_idx = 0; 2514 for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) { 2515 MakeSpeedTestPacket(packet, send_size, recv_size); 2516 2517 // If we have a receive size, test how long it takes to receive 4MB of 2518 // data 2519 if (recv_size > 0) { 2520 const auto start_time = steady_clock::now(); 2521 uint32_t bytes_read = 0; 2522 uint32_t packet_count = 0; 2523 while (bytes_read < recv_amount) { 2524 StringExtractorGDBRemote response; 2525 SendPacketAndWaitForResponse(packet.GetString(), response); 2526 bytes_read += recv_size; 2527 ++packet_count; 2528 } 2529 const auto end_time = steady_clock::now(); 2530 const auto total_time = end_time - start_time; 2531 float mb_second = ((float)recv_amount) / 2532 duration<float>(total_time).count() / 2533 (1024.0 * 1024.0); 2534 float packets_per_second = 2535 ((float)packet_count) / duration<float>(total_time).count(); 2536 const auto average_per_packet = packet_count > 0 2537 ? total_time / packet_count 2538 : duration<float>::zero(); 2539 2540 if (json) { 2541 strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : " 2542 "{2,6}, \"total_time_nsec\" : {3,12:ns-}}", 2543 result_idx > 0 ? "," : "", send_size, recv_size, 2544 total_time); 2545 ++result_idx; 2546 } else { 2547 strm.Format("qSpeedTest(send={0,7}, recv={1,7}) {2,6} packets needed " 2548 "to receive {3:f1}MB in {4:s+f9} for {5} MB/sec for " 2549 "{6,9:f2} packets/sec ({7,10:ms+f6} per packet)\n", 2550 send_size, recv_size, packet_count, k_recv_amount_mb, 2551 duration<float>(total_time), mb_second, 2552 packets_per_second, duration<float>(average_per_packet)); 2553 } 2554 strm.Flush(); 2555 } 2556 } 2557 if (json) 2558 strm.Printf("\n ]\n }\n}\n"); 2559 else 2560 strm.EOL(); 2561 } 2562 } 2563 2564 bool GDBRemoteCommunicationClient::SendSpeedTestPacket(uint32_t send_size, 2565 uint32_t recv_size) { 2566 StreamString packet; 2567 packet.Printf("qSpeedTest:response_size:%i;data:", recv_size); 2568 uint32_t bytes_left = send_size; 2569 while (bytes_left > 0) { 2570 if (bytes_left >= 26) { 2571 packet.PutCString("abcdefghijklmnopqrstuvwxyz"); 2572 bytes_left -= 26; 2573 } else { 2574 packet.Printf("%*.*s;", bytes_left, bytes_left, 2575 "abcdefghijklmnopqrstuvwxyz"); 2576 bytes_left = 0; 2577 } 2578 } 2579 2580 StringExtractorGDBRemote response; 2581 return SendPacketAndWaitForResponse(packet.GetString(), response) == 2582 PacketResult::Success; 2583 } 2584 2585 bool GDBRemoteCommunicationClient::LaunchGDBServer( 2586 const char *remote_accept_hostname, lldb::pid_t &pid, uint16_t &port, 2587 std::string &socket_name) { 2588 pid = LLDB_INVALID_PROCESS_ID; 2589 port = 0; 2590 socket_name.clear(); 2591 2592 StringExtractorGDBRemote response; 2593 StreamString stream; 2594 stream.PutCString("qLaunchGDBServer;"); 2595 std::string hostname; 2596 if (remote_accept_hostname && remote_accept_hostname[0]) 2597 hostname = remote_accept_hostname; 2598 else { 2599 if (HostInfo::GetHostname(hostname)) { 2600 // Make the GDB server we launch only accept connections from this host 2601 stream.Printf("host:%s;", hostname.c_str()); 2602 } else { 2603 // Make the GDB server we launch accept connections from any host since 2604 // we can't figure out the hostname 2605 stream.Printf("host:*;"); 2606 } 2607 } 2608 // give the process a few seconds to startup 2609 ScopedTimeout timeout(*this, seconds(10)); 2610 2611 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 2612 PacketResult::Success) { 2613 if (response.IsErrorResponse()) 2614 return false; 2615 2616 llvm::StringRef name; 2617 llvm::StringRef value; 2618 while (response.GetNameColonValue(name, value)) { 2619 if (name.equals("port")) 2620 value.getAsInteger(0, port); 2621 else if (name.equals("pid")) 2622 value.getAsInteger(0, pid); 2623 else if (name.compare("socket_name") == 0) { 2624 StringExtractor extractor(value); 2625 extractor.GetHexByteString(socket_name); 2626 } 2627 } 2628 return true; 2629 } 2630 return false; 2631 } 2632 2633 size_t GDBRemoteCommunicationClient::QueryGDBServer( 2634 std::vector<std::pair<uint16_t, std::string>> &connection_urls) { 2635 connection_urls.clear(); 2636 2637 StringExtractorGDBRemote response; 2638 if (SendPacketAndWaitForResponse("qQueryGDBServer", response) != 2639 PacketResult::Success) 2640 return 0; 2641 2642 StructuredData::ObjectSP data = 2643 StructuredData::ParseJSON(response.GetStringRef()); 2644 if (!data) 2645 return 0; 2646 2647 StructuredData::Array *array = data->GetAsArray(); 2648 if (!array) 2649 return 0; 2650 2651 for (size_t i = 0, count = array->GetSize(); i < count; ++i) { 2652 std::optional<StructuredData::Dictionary *> maybe_element = 2653 array->GetItemAtIndexAsDictionary(i); 2654 if (!maybe_element) 2655 continue; 2656 2657 StructuredData::Dictionary *element = *maybe_element; 2658 uint16_t port = 0; 2659 if (StructuredData::ObjectSP port_osp = 2660 element->GetValueForKey(llvm::StringRef("port"))) 2661 port = port_osp->GetUnsignedIntegerValue(0); 2662 2663 std::string socket_name; 2664 if (StructuredData::ObjectSP socket_name_osp = 2665 element->GetValueForKey(llvm::StringRef("socket_name"))) 2666 socket_name = std::string(socket_name_osp->GetStringValue()); 2667 2668 if (port != 0 || !socket_name.empty()) 2669 connection_urls.emplace_back(port, socket_name); 2670 } 2671 return connection_urls.size(); 2672 } 2673 2674 bool GDBRemoteCommunicationClient::KillSpawnedProcess(lldb::pid_t pid) { 2675 StreamString stream; 2676 stream.Printf("qKillSpawnedProcess:%" PRId64, pid); 2677 2678 StringExtractorGDBRemote response; 2679 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 2680 PacketResult::Success) { 2681 if (response.IsOKResponse()) 2682 return true; 2683 } 2684 return false; 2685 } 2686 2687 std::optional<PidTid> GDBRemoteCommunicationClient::SendSetCurrentThreadPacket( 2688 uint64_t tid, uint64_t pid, char op) { 2689 lldb_private::StreamString packet; 2690 packet.PutChar('H'); 2691 packet.PutChar(op); 2692 2693 if (pid != LLDB_INVALID_PROCESS_ID) 2694 packet.Printf("p%" PRIx64 ".", pid); 2695 2696 if (tid == UINT64_MAX) 2697 packet.PutCString("-1"); 2698 else 2699 packet.Printf("%" PRIx64, tid); 2700 2701 StringExtractorGDBRemote response; 2702 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 2703 PacketResult::Success) { 2704 if (response.IsOKResponse()) 2705 return {{pid, tid}}; 2706 2707 /* 2708 * Connected bare-iron target (like YAMON gdb-stub) may not have support for 2709 * Hg packet. 2710 * The reply from '?' packet could be as simple as 'S05'. There is no packet 2711 * which can 2712 * give us pid and/or tid. Assume pid=tid=1 in such cases. 2713 */ 2714 if (response.IsUnsupportedResponse() && IsConnected()) 2715 return {{1, 1}}; 2716 } 2717 return std::nullopt; 2718 } 2719 2720 bool GDBRemoteCommunicationClient::SetCurrentThread(uint64_t tid, 2721 uint64_t pid) { 2722 if (m_curr_tid == tid && 2723 (m_curr_pid == pid || LLDB_INVALID_PROCESS_ID == pid)) 2724 return true; 2725 2726 std::optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'g'); 2727 if (ret) { 2728 if (ret->pid != LLDB_INVALID_PROCESS_ID) 2729 m_curr_pid = ret->pid; 2730 m_curr_tid = ret->tid; 2731 } 2732 return ret.has_value(); 2733 } 2734 2735 bool GDBRemoteCommunicationClient::SetCurrentThreadForRun(uint64_t tid, 2736 uint64_t pid) { 2737 if (m_curr_tid_run == tid && 2738 (m_curr_pid_run == pid || LLDB_INVALID_PROCESS_ID == pid)) 2739 return true; 2740 2741 std::optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'c'); 2742 if (ret) { 2743 if (ret->pid != LLDB_INVALID_PROCESS_ID) 2744 m_curr_pid_run = ret->pid; 2745 m_curr_tid_run = ret->tid; 2746 } 2747 return ret.has_value(); 2748 } 2749 2750 bool GDBRemoteCommunicationClient::GetStopReply( 2751 StringExtractorGDBRemote &response) { 2752 if (SendPacketAndWaitForResponse("?", response) == PacketResult::Success) 2753 return response.IsNormalResponse(); 2754 return false; 2755 } 2756 2757 bool GDBRemoteCommunicationClient::GetThreadStopInfo( 2758 lldb::tid_t tid, StringExtractorGDBRemote &response) { 2759 if (m_supports_qThreadStopInfo) { 2760 char packet[256]; 2761 int packet_len = 2762 ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid); 2763 assert(packet_len < (int)sizeof(packet)); 2764 UNUSED_IF_ASSERT_DISABLED(packet_len); 2765 if (SendPacketAndWaitForResponse(packet, response) == 2766 PacketResult::Success) { 2767 if (response.IsUnsupportedResponse()) 2768 m_supports_qThreadStopInfo = false; 2769 else if (response.IsNormalResponse()) 2770 return true; 2771 else 2772 return false; 2773 } else { 2774 m_supports_qThreadStopInfo = false; 2775 } 2776 } 2777 return false; 2778 } 2779 2780 uint8_t GDBRemoteCommunicationClient::SendGDBStoppointTypePacket( 2781 GDBStoppointType type, bool insert, addr_t addr, uint32_t length, 2782 std::chrono::seconds timeout) { 2783 Log *log = GetLog(LLDBLog::Breakpoints); 2784 LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64, 2785 __FUNCTION__, insert ? "add" : "remove", addr); 2786 2787 // Check if the stub is known not to support this breakpoint type 2788 if (!SupportsGDBStoppointPacket(type)) 2789 return UINT8_MAX; 2790 // Construct the breakpoint packet 2791 char packet[64]; 2792 const int packet_len = 2793 ::snprintf(packet, sizeof(packet), "%c%i,%" PRIx64 ",%x", 2794 insert ? 'Z' : 'z', type, addr, length); 2795 // Check we haven't overwritten the end of the packet buffer 2796 assert(packet_len + 1 < (int)sizeof(packet)); 2797 UNUSED_IF_ASSERT_DISABLED(packet_len); 2798 StringExtractorGDBRemote response; 2799 // Make sure the response is either "OK", "EXX" where XX are two hex digits, 2800 // or "" (unsupported) 2801 response.SetResponseValidatorToOKErrorNotSupported(); 2802 // Try to send the breakpoint packet, and check that it was correctly sent 2803 if (SendPacketAndWaitForResponse(packet, response, timeout) == 2804 PacketResult::Success) { 2805 // Receive and OK packet when the breakpoint successfully placed 2806 if (response.IsOKResponse()) 2807 return 0; 2808 2809 // Status while setting breakpoint, send back specific error 2810 if (response.IsErrorResponse()) 2811 return response.GetError(); 2812 2813 // Empty packet informs us that breakpoint is not supported 2814 if (response.IsUnsupportedResponse()) { 2815 // Disable this breakpoint type since it is unsupported 2816 switch (type) { 2817 case eBreakpointSoftware: 2818 m_supports_z0 = false; 2819 break; 2820 case eBreakpointHardware: 2821 m_supports_z1 = false; 2822 break; 2823 case eWatchpointWrite: 2824 m_supports_z2 = false; 2825 break; 2826 case eWatchpointRead: 2827 m_supports_z3 = false; 2828 break; 2829 case eWatchpointReadWrite: 2830 m_supports_z4 = false; 2831 break; 2832 case eStoppointInvalid: 2833 return UINT8_MAX; 2834 } 2835 } 2836 } 2837 // Signal generic failure 2838 return UINT8_MAX; 2839 } 2840 2841 std::vector<std::pair<lldb::pid_t, lldb::tid_t>> 2842 GDBRemoteCommunicationClient::GetCurrentProcessAndThreadIDs( 2843 bool &sequence_mutex_unavailable) { 2844 std::vector<std::pair<lldb::pid_t, lldb::tid_t>> ids; 2845 2846 Lock lock(*this); 2847 if (lock) { 2848 sequence_mutex_unavailable = false; 2849 StringExtractorGDBRemote response; 2850 2851 PacketResult packet_result; 2852 for (packet_result = 2853 SendPacketAndWaitForResponseNoLock("qfThreadInfo", response); 2854 packet_result == PacketResult::Success && response.IsNormalResponse(); 2855 packet_result = 2856 SendPacketAndWaitForResponseNoLock("qsThreadInfo", response)) { 2857 char ch = response.GetChar(); 2858 if (ch == 'l') 2859 break; 2860 if (ch == 'm') { 2861 do { 2862 auto pid_tid = response.GetPidTid(LLDB_INVALID_PROCESS_ID); 2863 // If we get an invalid response, break out of the loop. 2864 // If there are valid tids, they have been added to ids. 2865 // If there are no valid tids, we'll fall through to the 2866 // bare-iron target handling below. 2867 if (!pid_tid) 2868 break; 2869 2870 ids.push_back(*pid_tid); 2871 ch = response.GetChar(); // Skip the command separator 2872 } while (ch == ','); // Make sure we got a comma separator 2873 } 2874 } 2875 2876 /* 2877 * Connected bare-iron target (like YAMON gdb-stub) may not have support for 2878 * qProcessInfo, qC and qfThreadInfo packets. The reply from '?' packet 2879 * could 2880 * be as simple as 'S05'. There is no packet which can give us pid and/or 2881 * tid. 2882 * Assume pid=tid=1 in such cases. 2883 */ 2884 if ((response.IsUnsupportedResponse() || response.IsNormalResponse()) && 2885 ids.size() == 0 && IsConnected()) { 2886 ids.emplace_back(1, 1); 2887 } 2888 } else { 2889 Log *log(GetLog(GDBRLog::Process | GDBRLog::Packets)); 2890 LLDB_LOG(log, "error: failed to get packet sequence mutex, not sending " 2891 "packet 'qfThreadInfo'"); 2892 sequence_mutex_unavailable = true; 2893 } 2894 2895 return ids; 2896 } 2897 2898 size_t GDBRemoteCommunicationClient::GetCurrentThreadIDs( 2899 std::vector<lldb::tid_t> &thread_ids, bool &sequence_mutex_unavailable) { 2900 lldb::pid_t pid = GetCurrentProcessID(); 2901 thread_ids.clear(); 2902 2903 auto ids = GetCurrentProcessAndThreadIDs(sequence_mutex_unavailable); 2904 if (ids.empty() || sequence_mutex_unavailable) 2905 return 0; 2906 2907 for (auto id : ids) { 2908 // skip threads that do not belong to the current process 2909 if (id.first != LLDB_INVALID_PROCESS_ID && id.first != pid) 2910 continue; 2911 if (id.second != LLDB_INVALID_THREAD_ID && 2912 id.second != StringExtractorGDBRemote::AllThreads) 2913 thread_ids.push_back(id.second); 2914 } 2915 2916 return thread_ids.size(); 2917 } 2918 2919 lldb::addr_t GDBRemoteCommunicationClient::GetShlibInfoAddr() { 2920 StringExtractorGDBRemote response; 2921 if (SendPacketAndWaitForResponse("qShlibInfoAddr", response) != 2922 PacketResult::Success || 2923 !response.IsNormalResponse()) 2924 return LLDB_INVALID_ADDRESS; 2925 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 2926 } 2927 2928 lldb_private::Status GDBRemoteCommunicationClient::RunShellCommand( 2929 llvm::StringRef command, 2930 const FileSpec & 2931 working_dir, // Pass empty FileSpec to use the current working directory 2932 int *status_ptr, // Pass NULL if you don't want the process exit status 2933 int *signo_ptr, // Pass NULL if you don't want the signal that caused the 2934 // process to exit 2935 std::string 2936 *command_output, // Pass NULL if you don't want the command output 2937 const Timeout<std::micro> &timeout) { 2938 lldb_private::StreamString stream; 2939 stream.PutCString("qPlatform_shell:"); 2940 stream.PutBytesAsRawHex8(command.data(), command.size()); 2941 stream.PutChar(','); 2942 uint32_t timeout_sec = UINT32_MAX; 2943 if (timeout) { 2944 // TODO: Use chrono version of std::ceil once c++17 is available. 2945 timeout_sec = std::ceil(std::chrono::duration<double>(*timeout).count()); 2946 } 2947 stream.PutHex32(timeout_sec); 2948 if (working_dir) { 2949 std::string path{working_dir.GetPath(false)}; 2950 stream.PutChar(','); 2951 stream.PutStringAsRawHex8(path); 2952 } 2953 StringExtractorGDBRemote response; 2954 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 2955 PacketResult::Success) { 2956 if (response.GetChar() != 'F') 2957 return Status("malformed reply"); 2958 if (response.GetChar() != ',') 2959 return Status("malformed reply"); 2960 uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX); 2961 if (exitcode == UINT32_MAX) 2962 return Status("unable to run remote process"); 2963 else if (status_ptr) 2964 *status_ptr = exitcode; 2965 if (response.GetChar() != ',') 2966 return Status("malformed reply"); 2967 uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX); 2968 if (signo_ptr) 2969 *signo_ptr = signo; 2970 if (response.GetChar() != ',') 2971 return Status("malformed reply"); 2972 std::string output; 2973 response.GetEscapedBinaryData(output); 2974 if (command_output) 2975 command_output->assign(output); 2976 return Status(); 2977 } 2978 return Status("unable to send packet"); 2979 } 2980 2981 Status GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec, 2982 uint32_t file_permissions) { 2983 std::string path{file_spec.GetPath(false)}; 2984 lldb_private::StreamString stream; 2985 stream.PutCString("qPlatform_mkdir:"); 2986 stream.PutHex32(file_permissions); 2987 stream.PutChar(','); 2988 stream.PutStringAsRawHex8(path); 2989 llvm::StringRef packet = stream.GetString(); 2990 StringExtractorGDBRemote response; 2991 2992 if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success) 2993 return Status("failed to send '%s' packet", packet.str().c_str()); 2994 2995 if (response.GetChar() != 'F') 2996 return Status("invalid response to '%s' packet", packet.str().c_str()); 2997 2998 return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX); 2999 } 3000 3001 Status 3002 GDBRemoteCommunicationClient::SetFilePermissions(const FileSpec &file_spec, 3003 uint32_t file_permissions) { 3004 std::string path{file_spec.GetPath(false)}; 3005 lldb_private::StreamString stream; 3006 stream.PutCString("qPlatform_chmod:"); 3007 stream.PutHex32(file_permissions); 3008 stream.PutChar(','); 3009 stream.PutStringAsRawHex8(path); 3010 llvm::StringRef packet = stream.GetString(); 3011 StringExtractorGDBRemote response; 3012 3013 if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success) 3014 return Status("failed to send '%s' packet", stream.GetData()); 3015 3016 if (response.GetChar() != 'F') 3017 return Status("invalid response to '%s' packet", stream.GetData()); 3018 3019 return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX); 3020 } 3021 3022 static int gdb_errno_to_system(int err) { 3023 switch (err) { 3024 #define HANDLE_ERRNO(name, value) \ 3025 case GDB_##name: \ 3026 return name; 3027 #include "Plugins/Process/gdb-remote/GDBRemoteErrno.def" 3028 default: 3029 return -1; 3030 } 3031 } 3032 3033 static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response, 3034 uint64_t fail_result, Status &error) { 3035 response.SetFilePos(0); 3036 if (response.GetChar() != 'F') 3037 return fail_result; 3038 int32_t result = response.GetS32(-2, 16); 3039 if (result == -2) 3040 return fail_result; 3041 if (response.GetChar() == ',') { 3042 int result_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3043 if (result_errno != -1) 3044 error.SetError(result_errno, eErrorTypePOSIX); 3045 else 3046 error.SetError(-1, eErrorTypeGeneric); 3047 } else 3048 error.Clear(); 3049 return result; 3050 } 3051 lldb::user_id_t 3052 GDBRemoteCommunicationClient::OpenFile(const lldb_private::FileSpec &file_spec, 3053 File::OpenOptions flags, mode_t mode, 3054 Status &error) { 3055 std::string path(file_spec.GetPath(false)); 3056 lldb_private::StreamString stream; 3057 stream.PutCString("vFile:open:"); 3058 if (path.empty()) 3059 return UINT64_MAX; 3060 stream.PutStringAsRawHex8(path); 3061 stream.PutChar(','); 3062 stream.PutHex32(flags); 3063 stream.PutChar(','); 3064 stream.PutHex32(mode); 3065 StringExtractorGDBRemote response; 3066 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3067 PacketResult::Success) { 3068 return ParseHostIOPacketResponse(response, UINT64_MAX, error); 3069 } 3070 return UINT64_MAX; 3071 } 3072 3073 bool GDBRemoteCommunicationClient::CloseFile(lldb::user_id_t fd, 3074 Status &error) { 3075 lldb_private::StreamString stream; 3076 stream.Printf("vFile:close:%x", (int)fd); 3077 StringExtractorGDBRemote response; 3078 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3079 PacketResult::Success) { 3080 return ParseHostIOPacketResponse(response, -1, error) == 0; 3081 } 3082 return false; 3083 } 3084 3085 std::optional<GDBRemoteFStatData> 3086 GDBRemoteCommunicationClient::FStat(lldb::user_id_t fd) { 3087 lldb_private::StreamString stream; 3088 stream.Printf("vFile:fstat:%" PRIx64, fd); 3089 StringExtractorGDBRemote response; 3090 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3091 PacketResult::Success) { 3092 if (response.GetChar() != 'F') 3093 return std::nullopt; 3094 int64_t size = response.GetS64(-1, 16); 3095 if (size > 0 && response.GetChar() == ';') { 3096 std::string buffer; 3097 if (response.GetEscapedBinaryData(buffer)) { 3098 GDBRemoteFStatData out; 3099 if (buffer.size() != sizeof(out)) 3100 return std::nullopt; 3101 memcpy(&out, buffer.data(), sizeof(out)); 3102 return out; 3103 } 3104 } 3105 } 3106 return std::nullopt; 3107 } 3108 3109 std::optional<GDBRemoteFStatData> 3110 GDBRemoteCommunicationClient::Stat(const lldb_private::FileSpec &file_spec) { 3111 Status error; 3112 lldb::user_id_t fd = OpenFile(file_spec, File::eOpenOptionReadOnly, 0, error); 3113 if (fd == UINT64_MAX) 3114 return std::nullopt; 3115 std::optional<GDBRemoteFStatData> st = FStat(fd); 3116 CloseFile(fd, error); 3117 return st; 3118 } 3119 3120 // Extension of host I/O packets to get the file size. 3121 lldb::user_id_t GDBRemoteCommunicationClient::GetFileSize( 3122 const lldb_private::FileSpec &file_spec) { 3123 if (m_supports_vFileSize) { 3124 std::string path(file_spec.GetPath(false)); 3125 lldb_private::StreamString stream; 3126 stream.PutCString("vFile:size:"); 3127 stream.PutStringAsRawHex8(path); 3128 StringExtractorGDBRemote response; 3129 if (SendPacketAndWaitForResponse(stream.GetString(), response) != 3130 PacketResult::Success) 3131 return UINT64_MAX; 3132 3133 if (!response.IsUnsupportedResponse()) { 3134 if (response.GetChar() != 'F') 3135 return UINT64_MAX; 3136 uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX); 3137 return retcode; 3138 } 3139 m_supports_vFileSize = false; 3140 } 3141 3142 // Fallback to fstat. 3143 std::optional<GDBRemoteFStatData> st = Stat(file_spec); 3144 return st ? st->gdb_st_size : UINT64_MAX; 3145 } 3146 3147 void GDBRemoteCommunicationClient::AutoCompleteDiskFileOrDirectory( 3148 CompletionRequest &request, bool only_dir) { 3149 lldb_private::StreamString stream; 3150 stream.PutCString("qPathComplete:"); 3151 stream.PutHex32(only_dir ? 1 : 0); 3152 stream.PutChar(','); 3153 stream.PutStringAsRawHex8(request.GetCursorArgumentPrefix()); 3154 StringExtractorGDBRemote response; 3155 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3156 PacketResult::Success) { 3157 StreamString strm; 3158 char ch = response.GetChar(); 3159 if (ch != 'M') 3160 return; 3161 while (response.Peek()) { 3162 strm.Clear(); 3163 while ((ch = response.GetHexU8(0, false)) != '\0') 3164 strm.PutChar(ch); 3165 request.AddCompletion(strm.GetString()); 3166 if (response.GetChar() != ',') 3167 break; 3168 } 3169 } 3170 } 3171 3172 Status 3173 GDBRemoteCommunicationClient::GetFilePermissions(const FileSpec &file_spec, 3174 uint32_t &file_permissions) { 3175 if (m_supports_vFileMode) { 3176 std::string path{file_spec.GetPath(false)}; 3177 Status error; 3178 lldb_private::StreamString stream; 3179 stream.PutCString("vFile:mode:"); 3180 stream.PutStringAsRawHex8(path); 3181 StringExtractorGDBRemote response; 3182 if (SendPacketAndWaitForResponse(stream.GetString(), response) != 3183 PacketResult::Success) { 3184 error.SetErrorStringWithFormat("failed to send '%s' packet", 3185 stream.GetData()); 3186 return error; 3187 } 3188 if (!response.IsUnsupportedResponse()) { 3189 if (response.GetChar() != 'F') { 3190 error.SetErrorStringWithFormat("invalid response to '%s' packet", 3191 stream.GetData()); 3192 } else { 3193 const uint32_t mode = response.GetS32(-1, 16); 3194 if (static_cast<int32_t>(mode) == -1) { 3195 if (response.GetChar() == ',') { 3196 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3197 if (response_errno > 0) 3198 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3199 else 3200 error.SetErrorToGenericError(); 3201 } else 3202 error.SetErrorToGenericError(); 3203 } else { 3204 file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO); 3205 } 3206 } 3207 return error; 3208 } else { // response.IsUnsupportedResponse() 3209 m_supports_vFileMode = false; 3210 } 3211 } 3212 3213 // Fallback to fstat. 3214 if (std::optional<GDBRemoteFStatData> st = Stat(file_spec)) { 3215 file_permissions = st->gdb_st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); 3216 return Status(); 3217 } 3218 return Status("fstat failed"); 3219 } 3220 3221 uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd, 3222 uint64_t offset, void *dst, 3223 uint64_t dst_len, 3224 Status &error) { 3225 lldb_private::StreamString stream; 3226 stream.Printf("vFile:pread:%x,%" PRIx64 ",%" PRIx64, (int)fd, dst_len, 3227 offset); 3228 StringExtractorGDBRemote response; 3229 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3230 PacketResult::Success) { 3231 if (response.GetChar() != 'F') 3232 return 0; 3233 int64_t retcode = response.GetS64(-1, 16); 3234 if (retcode == -1) { 3235 error.SetErrorToGenericError(); 3236 if (response.GetChar() == ',') { 3237 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3238 if (response_errno > 0) 3239 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3240 } 3241 return -1; 3242 } 3243 const char next = (response.Peek() ? *response.Peek() : 0); 3244 if (next == ',') 3245 return 0; 3246 if (next == ';') { 3247 response.GetChar(); // skip the semicolon 3248 std::string buffer; 3249 if (response.GetEscapedBinaryData(buffer)) { 3250 const uint64_t data_to_write = 3251 std::min<uint64_t>(dst_len, buffer.size()); 3252 if (data_to_write > 0) 3253 memcpy(dst, &buffer[0], data_to_write); 3254 return data_to_write; 3255 } 3256 } 3257 } 3258 return 0; 3259 } 3260 3261 uint64_t GDBRemoteCommunicationClient::WriteFile(lldb::user_id_t fd, 3262 uint64_t offset, 3263 const void *src, 3264 uint64_t src_len, 3265 Status &error) { 3266 lldb_private::StreamGDBRemote stream; 3267 stream.Printf("vFile:pwrite:%x,%" PRIx64 ",", (int)fd, offset); 3268 stream.PutEscapedBytes(src, src_len); 3269 StringExtractorGDBRemote response; 3270 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3271 PacketResult::Success) { 3272 if (response.GetChar() != 'F') { 3273 error.SetErrorStringWithFormat("write file failed"); 3274 return 0; 3275 } 3276 int64_t bytes_written = response.GetS64(-1, 16); 3277 if (bytes_written == -1) { 3278 error.SetErrorToGenericError(); 3279 if (response.GetChar() == ',') { 3280 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3281 if (response_errno > 0) 3282 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3283 } 3284 return -1; 3285 } 3286 return bytes_written; 3287 } else { 3288 error.SetErrorString("failed to send vFile:pwrite packet"); 3289 } 3290 return 0; 3291 } 3292 3293 Status GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src, 3294 const FileSpec &dst) { 3295 std::string src_path{src.GetPath(false)}, dst_path{dst.GetPath(false)}; 3296 Status error; 3297 lldb_private::StreamGDBRemote stream; 3298 stream.PutCString("vFile:symlink:"); 3299 // the unix symlink() command reverses its parameters where the dst if first, 3300 // so we follow suit here 3301 stream.PutStringAsRawHex8(dst_path); 3302 stream.PutChar(','); 3303 stream.PutStringAsRawHex8(src_path); 3304 StringExtractorGDBRemote response; 3305 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3306 PacketResult::Success) { 3307 if (response.GetChar() == 'F') { 3308 uint32_t result = response.GetHexMaxU32(false, UINT32_MAX); 3309 if (result != 0) { 3310 error.SetErrorToGenericError(); 3311 if (response.GetChar() == ',') { 3312 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3313 if (response_errno > 0) 3314 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3315 } 3316 } 3317 } else { 3318 // Should have returned with 'F<result>[,<errno>]' 3319 error.SetErrorStringWithFormat("symlink failed"); 3320 } 3321 } else { 3322 error.SetErrorString("failed to send vFile:symlink packet"); 3323 } 3324 return error; 3325 } 3326 3327 Status GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec) { 3328 std::string path{file_spec.GetPath(false)}; 3329 Status error; 3330 lldb_private::StreamGDBRemote stream; 3331 stream.PutCString("vFile:unlink:"); 3332 // the unix symlink() command reverses its parameters where the dst if first, 3333 // so we follow suit here 3334 stream.PutStringAsRawHex8(path); 3335 StringExtractorGDBRemote response; 3336 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3337 PacketResult::Success) { 3338 if (response.GetChar() == 'F') { 3339 uint32_t result = response.GetHexMaxU32(false, UINT32_MAX); 3340 if (result != 0) { 3341 error.SetErrorToGenericError(); 3342 if (response.GetChar() == ',') { 3343 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3344 if (response_errno > 0) 3345 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3346 } 3347 } 3348 } else { 3349 // Should have returned with 'F<result>[,<errno>]' 3350 error.SetErrorStringWithFormat("unlink failed"); 3351 } 3352 } else { 3353 error.SetErrorString("failed to send vFile:unlink packet"); 3354 } 3355 return error; 3356 } 3357 3358 // Extension of host I/O packets to get whether a file exists. 3359 bool GDBRemoteCommunicationClient::GetFileExists( 3360 const lldb_private::FileSpec &file_spec) { 3361 if (m_supports_vFileExists) { 3362 std::string path(file_spec.GetPath(false)); 3363 lldb_private::StreamString stream; 3364 stream.PutCString("vFile:exists:"); 3365 stream.PutStringAsRawHex8(path); 3366 StringExtractorGDBRemote response; 3367 if (SendPacketAndWaitForResponse(stream.GetString(), response) != 3368 PacketResult::Success) 3369 return false; 3370 if (!response.IsUnsupportedResponse()) { 3371 if (response.GetChar() != 'F') 3372 return false; 3373 if (response.GetChar() != ',') 3374 return false; 3375 bool retcode = (response.GetChar() != '0'); 3376 return retcode; 3377 } else 3378 m_supports_vFileExists = false; 3379 } 3380 3381 // Fallback to open. 3382 Status error; 3383 lldb::user_id_t fd = OpenFile(file_spec, File::eOpenOptionReadOnly, 0, error); 3384 if (fd == UINT64_MAX) 3385 return false; 3386 CloseFile(fd, error); 3387 return true; 3388 } 3389 3390 bool GDBRemoteCommunicationClient::CalculateMD5( 3391 const lldb_private::FileSpec &file_spec, uint64_t &high, uint64_t &low) { 3392 std::string path(file_spec.GetPath(false)); 3393 lldb_private::StreamString stream; 3394 stream.PutCString("vFile:MD5:"); 3395 stream.PutStringAsRawHex8(path); 3396 StringExtractorGDBRemote response; 3397 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3398 PacketResult::Success) { 3399 if (response.GetChar() != 'F') 3400 return false; 3401 if (response.GetChar() != ',') 3402 return false; 3403 if (response.Peek() && *response.Peek() == 'x') 3404 return false; 3405 low = response.GetHexMaxU64(false, UINT64_MAX); 3406 high = response.GetHexMaxU64(false, UINT64_MAX); 3407 return true; 3408 } 3409 return false; 3410 } 3411 3412 bool GDBRemoteCommunicationClient::AvoidGPackets(ProcessGDBRemote *process) { 3413 // Some targets have issues with g/G packets and we need to avoid using them 3414 if (m_avoid_g_packets == eLazyBoolCalculate) { 3415 if (process) { 3416 m_avoid_g_packets = eLazyBoolNo; 3417 const ArchSpec &arch = process->GetTarget().GetArchitecture(); 3418 if (arch.IsValid() && 3419 arch.GetTriple().getVendor() == llvm::Triple::Apple && 3420 arch.GetTriple().getOS() == llvm::Triple::IOS && 3421 (arch.GetTriple().getArch() == llvm::Triple::aarch64 || 3422 arch.GetTriple().getArch() == llvm::Triple::aarch64_32)) { 3423 m_avoid_g_packets = eLazyBoolYes; 3424 uint32_t gdb_server_version = GetGDBServerProgramVersion(); 3425 if (gdb_server_version != 0) { 3426 const char *gdb_server_name = GetGDBServerProgramName(); 3427 if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0) { 3428 if (gdb_server_version >= 310) 3429 m_avoid_g_packets = eLazyBoolNo; 3430 } 3431 } 3432 } 3433 } 3434 } 3435 return m_avoid_g_packets == eLazyBoolYes; 3436 } 3437 3438 DataBufferSP GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, 3439 uint32_t reg) { 3440 StreamString payload; 3441 payload.Printf("p%x", reg); 3442 StringExtractorGDBRemote response; 3443 if (SendThreadSpecificPacketAndWaitForResponse( 3444 tid, std::move(payload), response) != PacketResult::Success || 3445 !response.IsNormalResponse()) 3446 return nullptr; 3447 3448 WritableDataBufferSP buffer_sp( 3449 new DataBufferHeap(response.GetStringRef().size() / 2, 0)); 3450 response.GetHexBytes(buffer_sp->GetData(), '\xcc'); 3451 return buffer_sp; 3452 } 3453 3454 DataBufferSP GDBRemoteCommunicationClient::ReadAllRegisters(lldb::tid_t tid) { 3455 StreamString payload; 3456 payload.PutChar('g'); 3457 StringExtractorGDBRemote response; 3458 if (SendThreadSpecificPacketAndWaitForResponse( 3459 tid, std::move(payload), response) != PacketResult::Success || 3460 !response.IsNormalResponse()) 3461 return nullptr; 3462 3463 WritableDataBufferSP buffer_sp( 3464 new DataBufferHeap(response.GetStringRef().size() / 2, 0)); 3465 response.GetHexBytes(buffer_sp->GetData(), '\xcc'); 3466 return buffer_sp; 3467 } 3468 3469 bool GDBRemoteCommunicationClient::WriteRegister(lldb::tid_t tid, 3470 uint32_t reg_num, 3471 llvm::ArrayRef<uint8_t> data) { 3472 StreamString payload; 3473 payload.Printf("P%x=", reg_num); 3474 payload.PutBytesAsRawHex8(data.data(), data.size(), 3475 endian::InlHostByteOrder(), 3476 endian::InlHostByteOrder()); 3477 StringExtractorGDBRemote response; 3478 return SendThreadSpecificPacketAndWaitForResponse( 3479 tid, std::move(payload), response) == PacketResult::Success && 3480 response.IsOKResponse(); 3481 } 3482 3483 bool GDBRemoteCommunicationClient::WriteAllRegisters( 3484 lldb::tid_t tid, llvm::ArrayRef<uint8_t> data) { 3485 StreamString payload; 3486 payload.PutChar('G'); 3487 payload.PutBytesAsRawHex8(data.data(), data.size(), 3488 endian::InlHostByteOrder(), 3489 endian::InlHostByteOrder()); 3490 StringExtractorGDBRemote response; 3491 return SendThreadSpecificPacketAndWaitForResponse( 3492 tid, std::move(payload), response) == PacketResult::Success && 3493 response.IsOKResponse(); 3494 } 3495 3496 bool GDBRemoteCommunicationClient::SaveRegisterState(lldb::tid_t tid, 3497 uint32_t &save_id) { 3498 save_id = 0; // Set to invalid save ID 3499 if (m_supports_QSaveRegisterState == eLazyBoolNo) 3500 return false; 3501 3502 m_supports_QSaveRegisterState = eLazyBoolYes; 3503 StreamString payload; 3504 payload.PutCString("QSaveRegisterState"); 3505 StringExtractorGDBRemote response; 3506 if (SendThreadSpecificPacketAndWaitForResponse( 3507 tid, std::move(payload), response) != PacketResult::Success) 3508 return false; 3509 3510 if (response.IsUnsupportedResponse()) 3511 m_supports_QSaveRegisterState = eLazyBoolNo; 3512 3513 const uint32_t response_save_id = response.GetU32(0); 3514 if (response_save_id == 0) 3515 return false; 3516 3517 save_id = response_save_id; 3518 return true; 3519 } 3520 3521 bool GDBRemoteCommunicationClient::RestoreRegisterState(lldb::tid_t tid, 3522 uint32_t save_id) { 3523 // We use the "m_supports_QSaveRegisterState" variable here because the 3524 // QSaveRegisterState and QRestoreRegisterState packets must both be 3525 // supported in order to be useful 3526 if (m_supports_QSaveRegisterState == eLazyBoolNo) 3527 return false; 3528 3529 StreamString payload; 3530 payload.Printf("QRestoreRegisterState:%u", save_id); 3531 StringExtractorGDBRemote response; 3532 if (SendThreadSpecificPacketAndWaitForResponse( 3533 tid, std::move(payload), response) != PacketResult::Success) 3534 return false; 3535 3536 if (response.IsOKResponse()) 3537 return true; 3538 3539 if (response.IsUnsupportedResponse()) 3540 m_supports_QSaveRegisterState = eLazyBoolNo; 3541 return false; 3542 } 3543 3544 bool GDBRemoteCommunicationClient::SyncThreadState(lldb::tid_t tid) { 3545 if (!GetSyncThreadStateSupported()) 3546 return false; 3547 3548 StreamString packet; 3549 StringExtractorGDBRemote response; 3550 packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid); 3551 return SendPacketAndWaitForResponse(packet.GetString(), response) == 3552 GDBRemoteCommunication::PacketResult::Success && 3553 response.IsOKResponse(); 3554 } 3555 3556 llvm::Expected<TraceSupportedResponse> 3557 GDBRemoteCommunicationClient::SendTraceSupported(std::chrono::seconds timeout) { 3558 Log *log = GetLog(GDBRLog::Process); 3559 3560 StreamGDBRemote escaped_packet; 3561 escaped_packet.PutCString("jLLDBTraceSupported"); 3562 3563 StringExtractorGDBRemote response; 3564 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3565 timeout) == 3566 GDBRemoteCommunication::PacketResult::Success) { 3567 if (response.IsErrorResponse()) 3568 return response.GetStatus().ToError(); 3569 if (response.IsUnsupportedResponse()) 3570 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3571 "jLLDBTraceSupported is unsupported"); 3572 3573 return llvm::json::parse<TraceSupportedResponse>(response.Peek(), 3574 "TraceSupportedResponse"); 3575 } 3576 LLDB_LOG(log, "failed to send packet: jLLDBTraceSupported"); 3577 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3578 "failed to send packet: jLLDBTraceSupported"); 3579 } 3580 3581 llvm::Error 3582 GDBRemoteCommunicationClient::SendTraceStop(const TraceStopRequest &request, 3583 std::chrono::seconds timeout) { 3584 Log *log = GetLog(GDBRLog::Process); 3585 3586 StreamGDBRemote escaped_packet; 3587 escaped_packet.PutCString("jLLDBTraceStop:"); 3588 3589 std::string json_string; 3590 llvm::raw_string_ostream os(json_string); 3591 os << toJSON(request); 3592 os.flush(); 3593 3594 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3595 3596 StringExtractorGDBRemote response; 3597 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3598 timeout) == 3599 GDBRemoteCommunication::PacketResult::Success) { 3600 if (response.IsErrorResponse()) 3601 return response.GetStatus().ToError(); 3602 if (response.IsUnsupportedResponse()) 3603 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3604 "jLLDBTraceStop is unsupported"); 3605 if (response.IsOKResponse()) 3606 return llvm::Error::success(); 3607 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3608 "Invalid jLLDBTraceStart response"); 3609 } 3610 LLDB_LOG(log, "failed to send packet: jLLDBTraceStop"); 3611 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3612 "failed to send packet: jLLDBTraceStop '%s'", 3613 escaped_packet.GetData()); 3614 } 3615 3616 llvm::Error 3617 GDBRemoteCommunicationClient::SendTraceStart(const llvm::json::Value ¶ms, 3618 std::chrono::seconds timeout) { 3619 Log *log = GetLog(GDBRLog::Process); 3620 3621 StreamGDBRemote escaped_packet; 3622 escaped_packet.PutCString("jLLDBTraceStart:"); 3623 3624 std::string json_string; 3625 llvm::raw_string_ostream os(json_string); 3626 os << params; 3627 os.flush(); 3628 3629 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3630 3631 StringExtractorGDBRemote response; 3632 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3633 timeout) == 3634 GDBRemoteCommunication::PacketResult::Success) { 3635 if (response.IsErrorResponse()) 3636 return response.GetStatus().ToError(); 3637 if (response.IsUnsupportedResponse()) 3638 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3639 "jLLDBTraceStart is unsupported"); 3640 if (response.IsOKResponse()) 3641 return llvm::Error::success(); 3642 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3643 "Invalid jLLDBTraceStart response"); 3644 } 3645 LLDB_LOG(log, "failed to send packet: jLLDBTraceStart"); 3646 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3647 "failed to send packet: jLLDBTraceStart '%s'", 3648 escaped_packet.GetData()); 3649 } 3650 3651 llvm::Expected<std::string> 3652 GDBRemoteCommunicationClient::SendTraceGetState(llvm::StringRef type, 3653 std::chrono::seconds timeout) { 3654 Log *log = GetLog(GDBRLog::Process); 3655 3656 StreamGDBRemote escaped_packet; 3657 escaped_packet.PutCString("jLLDBTraceGetState:"); 3658 3659 std::string json_string; 3660 llvm::raw_string_ostream os(json_string); 3661 os << toJSON(TraceGetStateRequest{type.str()}); 3662 os.flush(); 3663 3664 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3665 3666 StringExtractorGDBRemote response; 3667 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3668 timeout) == 3669 GDBRemoteCommunication::PacketResult::Success) { 3670 if (response.IsErrorResponse()) 3671 return response.GetStatus().ToError(); 3672 if (response.IsUnsupportedResponse()) 3673 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3674 "jLLDBTraceGetState is unsupported"); 3675 return std::string(response.Peek()); 3676 } 3677 3678 LLDB_LOG(log, "failed to send packet: jLLDBTraceGetState"); 3679 return llvm::createStringError( 3680 llvm::inconvertibleErrorCode(), 3681 "failed to send packet: jLLDBTraceGetState '%s'", 3682 escaped_packet.GetData()); 3683 } 3684 3685 llvm::Expected<std::vector<uint8_t>> 3686 GDBRemoteCommunicationClient::SendTraceGetBinaryData( 3687 const TraceGetBinaryDataRequest &request, std::chrono::seconds timeout) { 3688 Log *log = GetLog(GDBRLog::Process); 3689 3690 StreamGDBRemote escaped_packet; 3691 escaped_packet.PutCString("jLLDBTraceGetBinaryData:"); 3692 3693 std::string json_string; 3694 llvm::raw_string_ostream os(json_string); 3695 os << toJSON(request); 3696 os.flush(); 3697 3698 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3699 3700 StringExtractorGDBRemote response; 3701 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3702 timeout) == 3703 GDBRemoteCommunication::PacketResult::Success) { 3704 if (response.IsErrorResponse()) 3705 return response.GetStatus().ToError(); 3706 std::string data; 3707 response.GetEscapedBinaryData(data); 3708 return std::vector<uint8_t>(data.begin(), data.end()); 3709 } 3710 LLDB_LOG(log, "failed to send packet: jLLDBTraceGetBinaryData"); 3711 return llvm::createStringError( 3712 llvm::inconvertibleErrorCode(), 3713 "failed to send packet: jLLDBTraceGetBinaryData '%s'", 3714 escaped_packet.GetData()); 3715 } 3716 3717 std::optional<QOffsets> GDBRemoteCommunicationClient::GetQOffsets() { 3718 StringExtractorGDBRemote response; 3719 if (SendPacketAndWaitForResponse("qOffsets", response) != 3720 PacketResult::Success) 3721 return std::nullopt; 3722 if (!response.IsNormalResponse()) 3723 return std::nullopt; 3724 3725 QOffsets result; 3726 llvm::StringRef ref = response.GetStringRef(); 3727 const auto &GetOffset = [&] { 3728 addr_t offset; 3729 if (ref.consumeInteger(16, offset)) 3730 return false; 3731 result.offsets.push_back(offset); 3732 return true; 3733 }; 3734 3735 if (ref.consume_front("Text=")) { 3736 result.segments = false; 3737 if (!GetOffset()) 3738 return std::nullopt; 3739 if (!ref.consume_front(";Data=") || !GetOffset()) 3740 return std::nullopt; 3741 if (ref.empty()) 3742 return result; 3743 if (ref.consume_front(";Bss=") && GetOffset() && ref.empty()) 3744 return result; 3745 } else if (ref.consume_front("TextSeg=")) { 3746 result.segments = true; 3747 if (!GetOffset()) 3748 return std::nullopt; 3749 if (ref.empty()) 3750 return result; 3751 if (ref.consume_front(";DataSeg=") && GetOffset() && ref.empty()) 3752 return result; 3753 } 3754 return std::nullopt; 3755 } 3756 3757 bool GDBRemoteCommunicationClient::GetModuleInfo( 3758 const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec, 3759 ModuleSpec &module_spec) { 3760 if (!m_supports_qModuleInfo) 3761 return false; 3762 3763 std::string module_path = module_file_spec.GetPath(false); 3764 if (module_path.empty()) 3765 return false; 3766 3767 StreamString packet; 3768 packet.PutCString("qModuleInfo:"); 3769 packet.PutStringAsRawHex8(module_path); 3770 packet.PutCString(";"); 3771 const auto &triple = arch_spec.GetTriple().getTriple(); 3772 packet.PutStringAsRawHex8(triple); 3773 3774 StringExtractorGDBRemote response; 3775 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 3776 PacketResult::Success) 3777 return false; 3778 3779 if (response.IsErrorResponse()) 3780 return false; 3781 3782 if (response.IsUnsupportedResponse()) { 3783 m_supports_qModuleInfo = false; 3784 return false; 3785 } 3786 3787 llvm::StringRef name; 3788 llvm::StringRef value; 3789 3790 module_spec.Clear(); 3791 module_spec.GetFileSpec() = module_file_spec; 3792 3793 while (response.GetNameColonValue(name, value)) { 3794 if (name == "uuid" || name == "md5") { 3795 StringExtractor extractor(value); 3796 std::string uuid; 3797 extractor.GetHexByteString(uuid); 3798 module_spec.GetUUID().SetFromStringRef(uuid); 3799 } else if (name == "triple") { 3800 StringExtractor extractor(value); 3801 std::string triple; 3802 extractor.GetHexByteString(triple); 3803 module_spec.GetArchitecture().SetTriple(triple.c_str()); 3804 } else if (name == "file_offset") { 3805 uint64_t ival = 0; 3806 if (!value.getAsInteger(16, ival)) 3807 module_spec.SetObjectOffset(ival); 3808 } else if (name == "file_size") { 3809 uint64_t ival = 0; 3810 if (!value.getAsInteger(16, ival)) 3811 module_spec.SetObjectSize(ival); 3812 } else if (name == "file_path") { 3813 StringExtractor extractor(value); 3814 std::string path; 3815 extractor.GetHexByteString(path); 3816 module_spec.GetFileSpec() = FileSpec(path, arch_spec.GetTriple()); 3817 } 3818 } 3819 3820 return true; 3821 } 3822 3823 static std::optional<ModuleSpec> 3824 ParseModuleSpec(StructuredData::Dictionary *dict) { 3825 ModuleSpec result; 3826 if (!dict) 3827 return std::nullopt; 3828 3829 llvm::StringRef string; 3830 uint64_t integer; 3831 3832 if (!dict->GetValueForKeyAsString("uuid", string)) 3833 return std::nullopt; 3834 if (!result.GetUUID().SetFromStringRef(string)) 3835 return std::nullopt; 3836 3837 if (!dict->GetValueForKeyAsInteger("file_offset", integer)) 3838 return std::nullopt; 3839 result.SetObjectOffset(integer); 3840 3841 if (!dict->GetValueForKeyAsInteger("file_size", integer)) 3842 return std::nullopt; 3843 result.SetObjectSize(integer); 3844 3845 if (!dict->GetValueForKeyAsString("triple", string)) 3846 return std::nullopt; 3847 result.GetArchitecture().SetTriple(string); 3848 3849 if (!dict->GetValueForKeyAsString("file_path", string)) 3850 return std::nullopt; 3851 result.GetFileSpec() = FileSpec(string, result.GetArchitecture().GetTriple()); 3852 3853 return result; 3854 } 3855 3856 std::optional<std::vector<ModuleSpec>> 3857 GDBRemoteCommunicationClient::GetModulesInfo( 3858 llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) { 3859 namespace json = llvm::json; 3860 3861 if (!m_supports_jModulesInfo) 3862 return std::nullopt; 3863 3864 json::Array module_array; 3865 for (const FileSpec &module_file_spec : module_file_specs) { 3866 module_array.push_back( 3867 json::Object{{"file", module_file_spec.GetPath(false)}, 3868 {"triple", triple.getTriple()}}); 3869 } 3870 StreamString unescaped_payload; 3871 unescaped_payload.PutCString("jModulesInfo:"); 3872 unescaped_payload.AsRawOstream() << std::move(module_array); 3873 3874 StreamGDBRemote payload; 3875 payload.PutEscapedBytes(unescaped_payload.GetString().data(), 3876 unescaped_payload.GetSize()); 3877 3878 // Increase the timeout for jModulesInfo since this packet can take longer. 3879 ScopedTimeout timeout(*this, std::chrono::seconds(10)); 3880 3881 StringExtractorGDBRemote response; 3882 if (SendPacketAndWaitForResponse(payload.GetString(), response) != 3883 PacketResult::Success || 3884 response.IsErrorResponse()) 3885 return std::nullopt; 3886 3887 if (response.IsUnsupportedResponse()) { 3888 m_supports_jModulesInfo = false; 3889 return std::nullopt; 3890 } 3891 3892 StructuredData::ObjectSP response_object_sp = 3893 StructuredData::ParseJSON(response.GetStringRef()); 3894 if (!response_object_sp) 3895 return std::nullopt; 3896 3897 StructuredData::Array *response_array = response_object_sp->GetAsArray(); 3898 if (!response_array) 3899 return std::nullopt; 3900 3901 std::vector<ModuleSpec> result; 3902 for (size_t i = 0; i < response_array->GetSize(); ++i) { 3903 if (std::optional<ModuleSpec> module_spec = ParseModuleSpec( 3904 response_array->GetItemAtIndex(i)->GetAsDictionary())) 3905 result.push_back(*module_spec); 3906 } 3907 3908 return result; 3909 } 3910 3911 // query the target remote for extended information using the qXfer packet 3912 // 3913 // example: object='features', annex='target.xml' 3914 // return: <xml output> or error 3915 llvm::Expected<std::string> 3916 GDBRemoteCommunicationClient::ReadExtFeature(llvm::StringRef object, 3917 llvm::StringRef annex) { 3918 3919 std::string output; 3920 llvm::raw_string_ostream output_stream(output); 3921 StringExtractorGDBRemote chunk; 3922 3923 uint64_t size = GetRemoteMaxPacketSize(); 3924 if (size == 0) 3925 size = 0x1000; 3926 size = size - 1; // Leave space for the 'm' or 'l' character in the response 3927 int offset = 0; 3928 bool active = true; 3929 3930 // loop until all data has been read 3931 while (active) { 3932 3933 // send query extended feature packet 3934 std::string packet = 3935 ("qXfer:" + object + ":read:" + annex + ":" + 3936 llvm::Twine::utohexstr(offset) + "," + llvm::Twine::utohexstr(size)) 3937 .str(); 3938 3939 GDBRemoteCommunication::PacketResult res = 3940 SendPacketAndWaitForResponse(packet, chunk); 3941 3942 if (res != GDBRemoteCommunication::PacketResult::Success || 3943 chunk.GetStringRef().empty()) { 3944 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3945 "Error sending $qXfer packet"); 3946 } 3947 3948 // check packet code 3949 switch (chunk.GetStringRef()[0]) { 3950 // last chunk 3951 case ('l'): 3952 active = false; 3953 [[fallthrough]]; 3954 3955 // more chunks 3956 case ('m'): 3957 output_stream << chunk.GetStringRef().drop_front(); 3958 offset += chunk.GetStringRef().size() - 1; 3959 break; 3960 3961 // unknown chunk 3962 default: 3963 return llvm::createStringError( 3964 llvm::inconvertibleErrorCode(), 3965 "Invalid continuation code from $qXfer packet"); 3966 } 3967 } 3968 3969 return output_stream.str(); 3970 } 3971 3972 // Notify the target that gdb is prepared to serve symbol lookup requests. 3973 // packet: "qSymbol::" 3974 // reply: 3975 // OK The target does not need to look up any (more) symbols. 3976 // qSymbol:<sym_name> The target requests the value of symbol sym_name (hex 3977 // encoded). 3978 // LLDB may provide the value by sending another qSymbol 3979 // packet 3980 // in the form of"qSymbol:<sym_value>:<sym_name>". 3981 // 3982 // Three examples: 3983 // 3984 // lldb sends: qSymbol:: 3985 // lldb receives: OK 3986 // Remote gdb stub does not need to know the addresses of any symbols, lldb 3987 // does not 3988 // need to ask again in this session. 3989 // 3990 // lldb sends: qSymbol:: 3991 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473 3992 // lldb sends: qSymbol::64697370617463685f71756575655f6f666673657473 3993 // lldb receives: OK 3994 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb does 3995 // not know 3996 // the address at this time. lldb needs to send qSymbol:: again when it has 3997 // more 3998 // solibs loaded. 3999 // 4000 // lldb sends: qSymbol:: 4001 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473 4002 // lldb sends: qSymbol:2bc97554:64697370617463685f71756575655f6f666673657473 4003 // lldb receives: OK 4004 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb says 4005 // that it 4006 // is at address 0x2bc97554. Remote gdb stub sends 'OK' indicating that it 4007 // does not 4008 // need any more symbols. lldb does not need to ask again in this session. 4009 4010 void GDBRemoteCommunicationClient::ServeSymbolLookups( 4011 lldb_private::Process *process) { 4012 // Set to true once we've resolved a symbol to an address for the remote 4013 // stub. If we get an 'OK' response after this, the remote stub doesn't need 4014 // any more symbols and we can stop asking. 4015 bool symbol_response_provided = false; 4016 4017 // Is this the initial qSymbol:: packet? 4018 bool first_qsymbol_query = true; 4019 4020 if (m_supports_qSymbol && !m_qSymbol_requests_done) { 4021 Lock lock(*this); 4022 if (lock) { 4023 StreamString packet; 4024 packet.PutCString("qSymbol::"); 4025 StringExtractorGDBRemote response; 4026 while (SendPacketAndWaitForResponseNoLock(packet.GetString(), response) == 4027 PacketResult::Success) { 4028 if (response.IsOKResponse()) { 4029 if (symbol_response_provided || first_qsymbol_query) { 4030 m_qSymbol_requests_done = true; 4031 } 4032 4033 // We are done serving symbols requests 4034 return; 4035 } 4036 first_qsymbol_query = false; 4037 4038 if (response.IsUnsupportedResponse()) { 4039 // qSymbol is not supported by the current GDB server we are 4040 // connected to 4041 m_supports_qSymbol = false; 4042 return; 4043 } else { 4044 llvm::StringRef response_str(response.GetStringRef()); 4045 if (response_str.starts_with("qSymbol:")) { 4046 response.SetFilePos(strlen("qSymbol:")); 4047 std::string symbol_name; 4048 if (response.GetHexByteString(symbol_name)) { 4049 if (symbol_name.empty()) 4050 return; 4051 4052 addr_t symbol_load_addr = LLDB_INVALID_ADDRESS; 4053 lldb_private::SymbolContextList sc_list; 4054 process->GetTarget().GetImages().FindSymbolsWithNameAndType( 4055 ConstString(symbol_name), eSymbolTypeAny, sc_list); 4056 for (const SymbolContext &sc : sc_list) { 4057 if (symbol_load_addr != LLDB_INVALID_ADDRESS) 4058 break; 4059 if (sc.symbol) { 4060 switch (sc.symbol->GetType()) { 4061 case eSymbolTypeInvalid: 4062 case eSymbolTypeAbsolute: 4063 case eSymbolTypeUndefined: 4064 case eSymbolTypeSourceFile: 4065 case eSymbolTypeHeaderFile: 4066 case eSymbolTypeObjectFile: 4067 case eSymbolTypeCommonBlock: 4068 case eSymbolTypeBlock: 4069 case eSymbolTypeLocal: 4070 case eSymbolTypeParam: 4071 case eSymbolTypeVariable: 4072 case eSymbolTypeVariableType: 4073 case eSymbolTypeLineEntry: 4074 case eSymbolTypeLineHeader: 4075 case eSymbolTypeScopeBegin: 4076 case eSymbolTypeScopeEnd: 4077 case eSymbolTypeAdditional: 4078 case eSymbolTypeCompiler: 4079 case eSymbolTypeInstrumentation: 4080 case eSymbolTypeTrampoline: 4081 break; 4082 4083 case eSymbolTypeCode: 4084 case eSymbolTypeResolver: 4085 case eSymbolTypeData: 4086 case eSymbolTypeRuntime: 4087 case eSymbolTypeException: 4088 case eSymbolTypeObjCClass: 4089 case eSymbolTypeObjCMetaClass: 4090 case eSymbolTypeObjCIVar: 4091 case eSymbolTypeReExported: 4092 symbol_load_addr = 4093 sc.symbol->GetLoadAddress(&process->GetTarget()); 4094 break; 4095 } 4096 } 4097 } 4098 // This is the normal path where our symbol lookup was successful 4099 // and we want to send a packet with the new symbol value and see 4100 // if another lookup needs to be done. 4101 4102 // Change "packet" to contain the requested symbol value and name 4103 packet.Clear(); 4104 packet.PutCString("qSymbol:"); 4105 if (symbol_load_addr != LLDB_INVALID_ADDRESS) { 4106 packet.Printf("%" PRIx64, symbol_load_addr); 4107 symbol_response_provided = true; 4108 } else { 4109 symbol_response_provided = false; 4110 } 4111 packet.PutCString(":"); 4112 packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size()); 4113 continue; // go back to the while loop and send "packet" and wait 4114 // for another response 4115 } 4116 } 4117 } 4118 } 4119 // If we make it here, the symbol request packet response wasn't valid or 4120 // our symbol lookup failed so we must abort 4121 return; 4122 4123 } else if (Log *log = GetLog(GDBRLog::Process | GDBRLog::Packets)) { 4124 LLDB_LOGF(log, 4125 "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.", 4126 __FUNCTION__); 4127 } 4128 } 4129 } 4130 4131 StructuredData::Array * 4132 GDBRemoteCommunicationClient::GetSupportedStructuredDataPlugins() { 4133 if (!m_supported_async_json_packets_is_valid) { 4134 // Query the server for the array of supported asynchronous JSON packets. 4135 m_supported_async_json_packets_is_valid = true; 4136 4137 Log *log = GetLog(GDBRLog::Process); 4138 4139 // Poll it now. 4140 StringExtractorGDBRemote response; 4141 if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response) == 4142 PacketResult::Success) { 4143 m_supported_async_json_packets_sp = 4144 StructuredData::ParseJSON(response.GetStringRef()); 4145 if (m_supported_async_json_packets_sp && 4146 !m_supported_async_json_packets_sp->GetAsArray()) { 4147 // We were returned something other than a JSON array. This is 4148 // invalid. Clear it out. 4149 LLDB_LOGF(log, 4150 "GDBRemoteCommunicationClient::%s(): " 4151 "QSupportedAsyncJSONPackets returned invalid " 4152 "result: %s", 4153 __FUNCTION__, response.GetStringRef().data()); 4154 m_supported_async_json_packets_sp.reset(); 4155 } 4156 } else { 4157 LLDB_LOGF(log, 4158 "GDBRemoteCommunicationClient::%s(): " 4159 "QSupportedAsyncJSONPackets unsupported", 4160 __FUNCTION__); 4161 } 4162 4163 if (log && m_supported_async_json_packets_sp) { 4164 StreamString stream; 4165 m_supported_async_json_packets_sp->Dump(stream); 4166 LLDB_LOGF(log, 4167 "GDBRemoteCommunicationClient::%s(): supported async " 4168 "JSON packets: %s", 4169 __FUNCTION__, stream.GetData()); 4170 } 4171 } 4172 4173 return m_supported_async_json_packets_sp 4174 ? m_supported_async_json_packets_sp->GetAsArray() 4175 : nullptr; 4176 } 4177 4178 Status GDBRemoteCommunicationClient::SendSignalsToIgnore( 4179 llvm::ArrayRef<int32_t> signals) { 4180 // Format packet: 4181 // QPassSignals:<hex_sig1>;<hex_sig2>...;<hex_sigN> 4182 auto range = llvm::make_range(signals.begin(), signals.end()); 4183 std::string packet = formatv("QPassSignals:{0:$[;]@(x-2)}", range).str(); 4184 4185 StringExtractorGDBRemote response; 4186 auto send_status = SendPacketAndWaitForResponse(packet, response); 4187 4188 if (send_status != GDBRemoteCommunication::PacketResult::Success) 4189 return Status("Sending QPassSignals packet failed"); 4190 4191 if (response.IsOKResponse()) { 4192 return Status(); 4193 } else { 4194 return Status("Unknown error happened during sending QPassSignals packet."); 4195 } 4196 } 4197 4198 Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData( 4199 llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp) { 4200 Status error; 4201 4202 if (type_name.empty()) { 4203 error.SetErrorString("invalid type_name argument"); 4204 return error; 4205 } 4206 4207 // Build command: Configure{type_name}: serialized config data. 4208 StreamGDBRemote stream; 4209 stream.PutCString("QConfigure"); 4210 stream.PutCString(type_name); 4211 stream.PutChar(':'); 4212 if (config_sp) { 4213 // Gather the plain-text version of the configuration data. 4214 StreamString unescaped_stream; 4215 config_sp->Dump(unescaped_stream); 4216 unescaped_stream.Flush(); 4217 4218 // Add it to the stream in escaped fashion. 4219 stream.PutEscapedBytes(unescaped_stream.GetString().data(), 4220 unescaped_stream.GetSize()); 4221 } 4222 stream.Flush(); 4223 4224 // Send the packet. 4225 StringExtractorGDBRemote response; 4226 auto result = SendPacketAndWaitForResponse(stream.GetString(), response); 4227 if (result == PacketResult::Success) { 4228 // We failed if the config result comes back other than OK. 4229 if (response.GetStringRef() == "OK") { 4230 // Okay! 4231 error.Clear(); 4232 } else { 4233 error.SetErrorStringWithFormatv( 4234 "configuring StructuredData feature {0} failed with error {1}", 4235 type_name, response.GetStringRef()); 4236 } 4237 } else { 4238 // Can we get more data here on the failure? 4239 error.SetErrorStringWithFormatv( 4240 "configuring StructuredData feature {0} failed when sending packet: " 4241 "PacketResult={1}", 4242 type_name, (int)result); 4243 } 4244 return error; 4245 } 4246 4247 void GDBRemoteCommunicationClient::OnRunPacketSent(bool first) { 4248 GDBRemoteClientBase::OnRunPacketSent(first); 4249 m_curr_tid = LLDB_INVALID_THREAD_ID; 4250 } 4251 4252 bool GDBRemoteCommunicationClient::UsesNativeSignals() { 4253 if (m_uses_native_signals == eLazyBoolCalculate) 4254 GetRemoteQSupported(); 4255 if (m_uses_native_signals == eLazyBoolYes) 4256 return true; 4257 4258 // If the remote didn't indicate native-signal support explicitly, 4259 // check whether it is an old version of lldb-server. 4260 return GetThreadSuffixSupported(); 4261 } 4262 4263 llvm::Expected<int> GDBRemoteCommunicationClient::KillProcess(lldb::pid_t pid) { 4264 StringExtractorGDBRemote response; 4265 GDBRemoteCommunication::ScopedTimeout(*this, seconds(3)); 4266 4267 if (SendPacketAndWaitForResponse("k", response, GetPacketTimeout()) != 4268 PacketResult::Success) 4269 return llvm::createStringError(llvm::inconvertibleErrorCode(), 4270 "failed to send k packet"); 4271 4272 char packet_cmd = response.GetChar(0); 4273 if (packet_cmd == 'W' || packet_cmd == 'X') 4274 return response.GetHexU8(); 4275 4276 return llvm::createStringError(llvm::inconvertibleErrorCode(), 4277 "unexpected response to k packet: %s", 4278 response.GetStringRef().str().c_str()); 4279 } 4280