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_addressing_bits)) 1269 ++num_keys_decoded; 1270 } else if (name.equals("os_version") || 1271 name.equals("version")) // Older debugserver binaries used 1272 // the "version" key instead of 1273 // "os_version"... 1274 { 1275 if (!m_os_version.tryParse(value)) 1276 ++num_keys_decoded; 1277 } else if (name.equals("maccatalyst_version")) { 1278 if (!m_maccatalyst_version.tryParse(value)) 1279 ++num_keys_decoded; 1280 } else if (name.equals("watchpoint_exceptions_received")) { 1281 m_watchpoints_trigger_after_instruction = 1282 llvm::StringSwitch<LazyBool>(value) 1283 .Case("before", eLazyBoolNo) 1284 .Case("after", eLazyBoolYes) 1285 .Default(eLazyBoolCalculate); 1286 if (m_watchpoints_trigger_after_instruction != eLazyBoolCalculate) 1287 ++num_keys_decoded; 1288 } else if (name.equals("default_packet_timeout")) { 1289 uint32_t timeout_seconds; 1290 if (!value.getAsInteger(0, timeout_seconds)) { 1291 m_default_packet_timeout = seconds(timeout_seconds); 1292 SetPacketTimeout(m_default_packet_timeout); 1293 ++num_keys_decoded; 1294 } 1295 } else if (name.equals("vm-page-size")) { 1296 int page_size; 1297 if (!value.getAsInteger(0, page_size)) { 1298 m_target_vm_page_size = page_size; 1299 ++num_keys_decoded; 1300 } 1301 } 1302 } 1303 1304 if (num_keys_decoded > 0) 1305 m_qHostInfo_is_valid = eLazyBoolYes; 1306 1307 if (triple.empty()) { 1308 if (arch_name.empty()) { 1309 if (cpu != LLDB_INVALID_CPUTYPE) { 1310 m_host_arch.SetArchitecture(eArchTypeMachO, cpu, sub); 1311 if (pointer_byte_size) { 1312 assert(pointer_byte_size == m_host_arch.GetAddressByteSize()); 1313 } 1314 if (byte_order != eByteOrderInvalid) { 1315 assert(byte_order == m_host_arch.GetByteOrder()); 1316 } 1317 1318 if (!vendor_name.empty()) 1319 m_host_arch.GetTriple().setVendorName( 1320 llvm::StringRef(vendor_name)); 1321 if (!os_name.empty()) 1322 m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name)); 1323 if (!environment.empty()) 1324 m_host_arch.GetTriple().setEnvironmentName(environment); 1325 } 1326 } else { 1327 std::string triple; 1328 triple += arch_name; 1329 if (!vendor_name.empty() || !os_name.empty()) { 1330 triple += '-'; 1331 if (vendor_name.empty()) 1332 triple += "unknown"; 1333 else 1334 triple += vendor_name; 1335 triple += '-'; 1336 if (os_name.empty()) 1337 triple += "unknown"; 1338 else 1339 triple += os_name; 1340 } 1341 m_host_arch.SetTriple(triple.c_str()); 1342 1343 llvm::Triple &host_triple = m_host_arch.GetTriple(); 1344 if (host_triple.getVendor() == llvm::Triple::Apple && 1345 host_triple.getOS() == llvm::Triple::Darwin) { 1346 switch (m_host_arch.GetMachine()) { 1347 case llvm::Triple::aarch64: 1348 case llvm::Triple::aarch64_32: 1349 case llvm::Triple::arm: 1350 case llvm::Triple::thumb: 1351 host_triple.setOS(llvm::Triple::IOS); 1352 break; 1353 default: 1354 host_triple.setOS(llvm::Triple::MacOSX); 1355 break; 1356 } 1357 } 1358 if (pointer_byte_size) { 1359 assert(pointer_byte_size == m_host_arch.GetAddressByteSize()); 1360 } 1361 if (byte_order != eByteOrderInvalid) { 1362 assert(byte_order == m_host_arch.GetByteOrder()); 1363 } 1364 } 1365 } else { 1366 m_host_arch.SetTriple(triple.c_str()); 1367 if (pointer_byte_size) { 1368 assert(pointer_byte_size == m_host_arch.GetAddressByteSize()); 1369 } 1370 if (byte_order != eByteOrderInvalid) { 1371 assert(byte_order == m_host_arch.GetByteOrder()); 1372 } 1373 1374 LLDB_LOGF(log, 1375 "GDBRemoteCommunicationClient::%s parsed host " 1376 "architecture as %s, triple as %s from triple text %s", 1377 __FUNCTION__, 1378 m_host_arch.GetArchitectureName() 1379 ? m_host_arch.GetArchitectureName() 1380 : "<null-arch-name>", 1381 m_host_arch.GetTriple().getTriple().c_str(), 1382 triple.c_str()); 1383 } 1384 } 1385 } 1386 } 1387 return m_qHostInfo_is_valid == eLazyBoolYes; 1388 } 1389 1390 int GDBRemoteCommunicationClient::SendStdinNotification(const char *data, 1391 size_t data_len) { 1392 StreamString packet; 1393 packet.PutCString("I"); 1394 packet.PutBytesAsRawHex8(data, data_len); 1395 StringExtractorGDBRemote response; 1396 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1397 PacketResult::Success) { 1398 return 0; 1399 } 1400 return response.GetError(); 1401 } 1402 1403 const lldb_private::ArchSpec & 1404 GDBRemoteCommunicationClient::GetHostArchitecture() { 1405 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1406 GetHostInfo(); 1407 return m_host_arch; 1408 } 1409 1410 uint32_t GDBRemoteCommunicationClient::GetAddressingBits() { 1411 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1412 GetHostInfo(); 1413 return m_addressing_bits; 1414 } 1415 seconds GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout() { 1416 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1417 GetHostInfo(); 1418 return m_default_packet_timeout; 1419 } 1420 1421 addr_t GDBRemoteCommunicationClient::AllocateMemory(size_t size, 1422 uint32_t permissions) { 1423 if (m_supports_alloc_dealloc_memory != eLazyBoolNo) { 1424 m_supports_alloc_dealloc_memory = eLazyBoolYes; 1425 char packet[64]; 1426 const int packet_len = ::snprintf( 1427 packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s", (uint64_t)size, 1428 permissions & lldb::ePermissionsReadable ? "r" : "", 1429 permissions & lldb::ePermissionsWritable ? "w" : "", 1430 permissions & lldb::ePermissionsExecutable ? "x" : ""); 1431 assert(packet_len < (int)sizeof(packet)); 1432 UNUSED_IF_ASSERT_DISABLED(packet_len); 1433 StringExtractorGDBRemote response; 1434 if (SendPacketAndWaitForResponse(packet, response) == 1435 PacketResult::Success) { 1436 if (response.IsUnsupportedResponse()) 1437 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1438 else if (!response.IsErrorResponse()) 1439 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 1440 } else { 1441 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1442 } 1443 } 1444 return LLDB_INVALID_ADDRESS; 1445 } 1446 1447 bool GDBRemoteCommunicationClient::DeallocateMemory(addr_t addr) { 1448 if (m_supports_alloc_dealloc_memory != eLazyBoolNo) { 1449 m_supports_alloc_dealloc_memory = eLazyBoolYes; 1450 char packet[64]; 1451 const int packet_len = 1452 ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr); 1453 assert(packet_len < (int)sizeof(packet)); 1454 UNUSED_IF_ASSERT_DISABLED(packet_len); 1455 StringExtractorGDBRemote response; 1456 if (SendPacketAndWaitForResponse(packet, response) == 1457 PacketResult::Success) { 1458 if (response.IsUnsupportedResponse()) 1459 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1460 else if (response.IsOKResponse()) 1461 return true; 1462 } else { 1463 m_supports_alloc_dealloc_memory = eLazyBoolNo; 1464 } 1465 } 1466 return false; 1467 } 1468 1469 Status GDBRemoteCommunicationClient::Detach(bool keep_stopped, 1470 lldb::pid_t pid) { 1471 Status error; 1472 lldb_private::StreamString packet; 1473 1474 packet.PutChar('D'); 1475 if (keep_stopped) { 1476 if (m_supports_detach_stay_stopped == eLazyBoolCalculate) { 1477 char packet[64]; 1478 const int packet_len = 1479 ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:"); 1480 assert(packet_len < (int)sizeof(packet)); 1481 UNUSED_IF_ASSERT_DISABLED(packet_len); 1482 StringExtractorGDBRemote response; 1483 if (SendPacketAndWaitForResponse(packet, response) == 1484 PacketResult::Success && 1485 response.IsOKResponse()) { 1486 m_supports_detach_stay_stopped = eLazyBoolYes; 1487 } else { 1488 m_supports_detach_stay_stopped = eLazyBoolNo; 1489 } 1490 } 1491 1492 if (m_supports_detach_stay_stopped == eLazyBoolNo) { 1493 error.SetErrorString("Stays stopped not supported by this target."); 1494 return error; 1495 } else { 1496 packet.PutChar('1'); 1497 } 1498 } 1499 1500 if (GetMultiprocessSupported()) { 1501 // Some servers (e.g. qemu) require specifying the PID even if only a single 1502 // process is running. 1503 if (pid == LLDB_INVALID_PROCESS_ID) 1504 pid = GetCurrentProcessID(); 1505 packet.PutChar(';'); 1506 packet.PutHex64(pid); 1507 } else if (pid != LLDB_INVALID_PROCESS_ID) { 1508 error.SetErrorString("Multiprocess extension not supported by the server."); 1509 return error; 1510 } 1511 1512 StringExtractorGDBRemote response; 1513 PacketResult packet_result = 1514 SendPacketAndWaitForResponse(packet.GetString(), response); 1515 if (packet_result != PacketResult::Success) 1516 error.SetErrorString("Sending isconnect packet failed."); 1517 return error; 1518 } 1519 1520 Status GDBRemoteCommunicationClient::GetMemoryRegionInfo( 1521 lldb::addr_t addr, lldb_private::MemoryRegionInfo ®ion_info) { 1522 Status error; 1523 region_info.Clear(); 1524 1525 if (m_supports_memory_region_info != eLazyBoolNo) { 1526 m_supports_memory_region_info = eLazyBoolYes; 1527 char packet[64]; 1528 const int packet_len = ::snprintf( 1529 packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr); 1530 assert(packet_len < (int)sizeof(packet)); 1531 UNUSED_IF_ASSERT_DISABLED(packet_len); 1532 StringExtractorGDBRemote response; 1533 if (SendPacketAndWaitForResponse(packet, response) == 1534 PacketResult::Success && 1535 response.GetResponseType() == StringExtractorGDBRemote::eResponse) { 1536 llvm::StringRef name; 1537 llvm::StringRef value; 1538 addr_t addr_value = LLDB_INVALID_ADDRESS; 1539 bool success = true; 1540 bool saw_permissions = false; 1541 while (success && response.GetNameColonValue(name, value)) { 1542 if (name.equals("start")) { 1543 if (!value.getAsInteger(16, addr_value)) 1544 region_info.GetRange().SetRangeBase(addr_value); 1545 } else if (name.equals("size")) { 1546 if (!value.getAsInteger(16, addr_value)) { 1547 region_info.GetRange().SetByteSize(addr_value); 1548 if (region_info.GetRange().GetRangeEnd() < 1549 region_info.GetRange().GetRangeBase()) { 1550 // Range size overflowed, truncate it. 1551 region_info.GetRange().SetRangeEnd(LLDB_INVALID_ADDRESS); 1552 } 1553 } 1554 } else if (name.equals("permissions") && 1555 region_info.GetRange().IsValid()) { 1556 saw_permissions = true; 1557 if (region_info.GetRange().Contains(addr)) { 1558 if (value.contains('r')) 1559 region_info.SetReadable(MemoryRegionInfo::eYes); 1560 else 1561 region_info.SetReadable(MemoryRegionInfo::eNo); 1562 1563 if (value.contains('w')) 1564 region_info.SetWritable(MemoryRegionInfo::eYes); 1565 else 1566 region_info.SetWritable(MemoryRegionInfo::eNo); 1567 1568 if (value.contains('x')) 1569 region_info.SetExecutable(MemoryRegionInfo::eYes); 1570 else 1571 region_info.SetExecutable(MemoryRegionInfo::eNo); 1572 1573 region_info.SetMapped(MemoryRegionInfo::eYes); 1574 } else { 1575 // The reported region does not contain this address -- we're 1576 // looking at an unmapped page 1577 region_info.SetReadable(MemoryRegionInfo::eNo); 1578 region_info.SetWritable(MemoryRegionInfo::eNo); 1579 region_info.SetExecutable(MemoryRegionInfo::eNo); 1580 region_info.SetMapped(MemoryRegionInfo::eNo); 1581 } 1582 } else if (name.equals("name")) { 1583 StringExtractorGDBRemote name_extractor(value); 1584 std::string name; 1585 name_extractor.GetHexByteString(name); 1586 region_info.SetName(name.c_str()); 1587 } else if (name.equals("flags")) { 1588 region_info.SetMemoryTagged(MemoryRegionInfo::eNo); 1589 1590 llvm::StringRef flags = value; 1591 llvm::StringRef flag; 1592 while (flags.size()) { 1593 flags = flags.ltrim(); 1594 std::tie(flag, flags) = flags.split(' '); 1595 // To account for trailing whitespace 1596 if (flag.size()) { 1597 if (flag == "mt") { 1598 region_info.SetMemoryTagged(MemoryRegionInfo::eYes); 1599 break; 1600 } 1601 } 1602 } 1603 } else if (name.equals("type")) { 1604 std::string comma_sep_str = value.str(); 1605 size_t comma_pos; 1606 while ((comma_pos = comma_sep_str.find(',')) != std::string::npos) { 1607 comma_sep_str[comma_pos] = '\0'; 1608 if (comma_sep_str == "stack") { 1609 region_info.SetIsStackMemory(MemoryRegionInfo::eYes); 1610 } 1611 } 1612 // handle final (or only) type of "stack" 1613 if (comma_sep_str == "stack") { 1614 region_info.SetIsStackMemory(MemoryRegionInfo::eYes); 1615 } 1616 } else if (name.equals("error")) { 1617 StringExtractorGDBRemote error_extractor(value); 1618 std::string error_string; 1619 // Now convert the HEX bytes into a string value 1620 error_extractor.GetHexByteString(error_string); 1621 error.SetErrorString(error_string.c_str()); 1622 } else if (name.equals("dirty-pages")) { 1623 std::vector<addr_t> dirty_page_list; 1624 for (llvm::StringRef x : llvm::split(value, ',')) { 1625 addr_t page; 1626 x.consume_front("0x"); 1627 if (llvm::to_integer(x, page, 16)) 1628 dirty_page_list.push_back(page); 1629 } 1630 region_info.SetDirtyPageList(dirty_page_list); 1631 } 1632 } 1633 1634 if (m_target_vm_page_size != 0) 1635 region_info.SetPageSize(m_target_vm_page_size); 1636 1637 if (region_info.GetRange().IsValid()) { 1638 // We got a valid address range back but no permissions -- which means 1639 // this is an unmapped page 1640 if (!saw_permissions) { 1641 region_info.SetReadable(MemoryRegionInfo::eNo); 1642 region_info.SetWritable(MemoryRegionInfo::eNo); 1643 region_info.SetExecutable(MemoryRegionInfo::eNo); 1644 region_info.SetMapped(MemoryRegionInfo::eNo); 1645 } 1646 } else { 1647 // We got an invalid address range back 1648 error.SetErrorString("Server returned invalid range"); 1649 } 1650 } else { 1651 m_supports_memory_region_info = eLazyBoolNo; 1652 } 1653 } 1654 1655 if (m_supports_memory_region_info == eLazyBoolNo) { 1656 error.SetErrorString("qMemoryRegionInfo is not supported"); 1657 } 1658 1659 // Try qXfer:memory-map:read to get region information not included in 1660 // qMemoryRegionInfo 1661 MemoryRegionInfo qXfer_region_info; 1662 Status qXfer_error = GetQXferMemoryMapRegionInfo(addr, qXfer_region_info); 1663 1664 if (error.Fail()) { 1665 // If qMemoryRegionInfo failed, but qXfer:memory-map:read succeeded, use 1666 // the qXfer result as a fallback 1667 if (qXfer_error.Success()) { 1668 region_info = qXfer_region_info; 1669 error.Clear(); 1670 } else { 1671 region_info.Clear(); 1672 } 1673 } else if (qXfer_error.Success()) { 1674 // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and if 1675 // both regions are the same range, update the result to include the flash- 1676 // memory information that is specific to the qXfer result. 1677 if (region_info.GetRange() == qXfer_region_info.GetRange()) { 1678 region_info.SetFlash(qXfer_region_info.GetFlash()); 1679 region_info.SetBlocksize(qXfer_region_info.GetBlocksize()); 1680 } 1681 } 1682 return error; 1683 } 1684 1685 Status GDBRemoteCommunicationClient::GetQXferMemoryMapRegionInfo( 1686 lldb::addr_t addr, MemoryRegionInfo ®ion) { 1687 Status error = LoadQXferMemoryMap(); 1688 if (!error.Success()) 1689 return error; 1690 for (const auto &map_region : m_qXfer_memory_map) { 1691 if (map_region.GetRange().Contains(addr)) { 1692 region = map_region; 1693 return error; 1694 } 1695 } 1696 error.SetErrorString("Region not found"); 1697 return error; 1698 } 1699 1700 Status GDBRemoteCommunicationClient::LoadQXferMemoryMap() { 1701 1702 Status error; 1703 1704 if (m_qXfer_memory_map_loaded) 1705 // Already loaded, return success 1706 return error; 1707 1708 if (!XMLDocument::XMLEnabled()) { 1709 error.SetErrorString("XML is not supported"); 1710 return error; 1711 } 1712 1713 if (!GetQXferMemoryMapReadSupported()) { 1714 error.SetErrorString("Memory map is not supported"); 1715 return error; 1716 } 1717 1718 llvm::Expected<std::string> xml = ReadExtFeature("memory-map", ""); 1719 if (!xml) 1720 return Status(xml.takeError()); 1721 1722 XMLDocument xml_document; 1723 1724 if (!xml_document.ParseMemory(xml->c_str(), xml->size())) { 1725 error.SetErrorString("Failed to parse memory map xml"); 1726 return error; 1727 } 1728 1729 XMLNode map_node = xml_document.GetRootElement("memory-map"); 1730 if (!map_node) { 1731 error.SetErrorString("Invalid root node in memory map xml"); 1732 return error; 1733 } 1734 1735 m_qXfer_memory_map.clear(); 1736 1737 map_node.ForEachChildElement([this](const XMLNode &memory_node) -> bool { 1738 if (!memory_node.IsElement()) 1739 return true; 1740 if (memory_node.GetName() != "memory") 1741 return true; 1742 auto type = memory_node.GetAttributeValue("type", ""); 1743 uint64_t start; 1744 uint64_t length; 1745 if (!memory_node.GetAttributeValueAsUnsigned("start", start)) 1746 return true; 1747 if (!memory_node.GetAttributeValueAsUnsigned("length", length)) 1748 return true; 1749 MemoryRegionInfo region; 1750 region.GetRange().SetRangeBase(start); 1751 region.GetRange().SetByteSize(length); 1752 if (type == "rom") { 1753 region.SetReadable(MemoryRegionInfo::eYes); 1754 this->m_qXfer_memory_map.push_back(region); 1755 } else if (type == "ram") { 1756 region.SetReadable(MemoryRegionInfo::eYes); 1757 region.SetWritable(MemoryRegionInfo::eYes); 1758 this->m_qXfer_memory_map.push_back(region); 1759 } else if (type == "flash") { 1760 region.SetFlash(MemoryRegionInfo::eYes); 1761 memory_node.ForEachChildElement( 1762 [®ion](const XMLNode &prop_node) -> bool { 1763 if (!prop_node.IsElement()) 1764 return true; 1765 if (prop_node.GetName() != "property") 1766 return true; 1767 auto propname = prop_node.GetAttributeValue("name", ""); 1768 if (propname == "blocksize") { 1769 uint64_t blocksize; 1770 if (prop_node.GetElementTextAsUnsigned(blocksize)) 1771 region.SetBlocksize(blocksize); 1772 } 1773 return true; 1774 }); 1775 this->m_qXfer_memory_map.push_back(region); 1776 } 1777 return true; 1778 }); 1779 1780 m_qXfer_memory_map_loaded = true; 1781 1782 return error; 1783 } 1784 1785 std::optional<uint32_t> GDBRemoteCommunicationClient::GetWatchpointSlotCount() { 1786 if (m_supports_watchpoint_support_info == eLazyBoolYes) { 1787 return m_num_supported_hardware_watchpoints; 1788 } 1789 1790 std::optional<uint32_t> num; 1791 if (m_supports_watchpoint_support_info != eLazyBoolNo) { 1792 StringExtractorGDBRemote response; 1793 if (SendPacketAndWaitForResponse("qWatchpointSupportInfo:", response) == 1794 PacketResult::Success) { 1795 m_supports_watchpoint_support_info = eLazyBoolYes; 1796 llvm::StringRef name; 1797 llvm::StringRef value; 1798 while (response.GetNameColonValue(name, value)) { 1799 if (name.equals("num")) { 1800 value.getAsInteger(0, m_num_supported_hardware_watchpoints); 1801 num = m_num_supported_hardware_watchpoints; 1802 } 1803 } 1804 if (!num) { 1805 m_supports_watchpoint_support_info = eLazyBoolNo; 1806 } 1807 } else { 1808 m_supports_watchpoint_support_info = eLazyBoolNo; 1809 } 1810 } 1811 1812 return num; 1813 } 1814 1815 std::optional<bool> GDBRemoteCommunicationClient::GetWatchpointReportedAfter() { 1816 if (m_qHostInfo_is_valid == eLazyBoolCalculate) 1817 GetHostInfo(); 1818 1819 // Process determines this by target CPU, but allow for the 1820 // remote stub to override it via the qHostInfo 1821 // watchpoint_exceptions_received key, if it is present. 1822 if (m_qHostInfo_is_valid == eLazyBoolYes) { 1823 if (m_watchpoints_trigger_after_instruction == eLazyBoolNo) 1824 return false; 1825 if (m_watchpoints_trigger_after_instruction == eLazyBoolYes) 1826 return true; 1827 } 1828 1829 return std::nullopt; 1830 } 1831 1832 int GDBRemoteCommunicationClient::SetSTDIN(const FileSpec &file_spec) { 1833 if (file_spec) { 1834 std::string path{file_spec.GetPath(false)}; 1835 StreamString packet; 1836 packet.PutCString("QSetSTDIN:"); 1837 packet.PutStringAsRawHex8(path); 1838 1839 StringExtractorGDBRemote response; 1840 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1841 PacketResult::Success) { 1842 if (response.IsOKResponse()) 1843 return 0; 1844 uint8_t error = response.GetError(); 1845 if (error) 1846 return error; 1847 } 1848 } 1849 return -1; 1850 } 1851 1852 int GDBRemoteCommunicationClient::SetSTDOUT(const FileSpec &file_spec) { 1853 if (file_spec) { 1854 std::string path{file_spec.GetPath(false)}; 1855 StreamString packet; 1856 packet.PutCString("QSetSTDOUT:"); 1857 packet.PutStringAsRawHex8(path); 1858 1859 StringExtractorGDBRemote response; 1860 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1861 PacketResult::Success) { 1862 if (response.IsOKResponse()) 1863 return 0; 1864 uint8_t error = response.GetError(); 1865 if (error) 1866 return error; 1867 } 1868 } 1869 return -1; 1870 } 1871 1872 int GDBRemoteCommunicationClient::SetSTDERR(const FileSpec &file_spec) { 1873 if (file_spec) { 1874 std::string path{file_spec.GetPath(false)}; 1875 StreamString packet; 1876 packet.PutCString("QSetSTDERR:"); 1877 packet.PutStringAsRawHex8(path); 1878 1879 StringExtractorGDBRemote response; 1880 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1881 PacketResult::Success) { 1882 if (response.IsOKResponse()) 1883 return 0; 1884 uint8_t error = response.GetError(); 1885 if (error) 1886 return error; 1887 } 1888 } 1889 return -1; 1890 } 1891 1892 bool GDBRemoteCommunicationClient::GetWorkingDir(FileSpec &working_dir) { 1893 StringExtractorGDBRemote response; 1894 if (SendPacketAndWaitForResponse("qGetWorkingDir", response) == 1895 PacketResult::Success) { 1896 if (response.IsUnsupportedResponse()) 1897 return false; 1898 if (response.IsErrorResponse()) 1899 return false; 1900 std::string cwd; 1901 response.GetHexByteString(cwd); 1902 working_dir.SetFile(cwd, GetHostArchitecture().GetTriple()); 1903 return !cwd.empty(); 1904 } 1905 return false; 1906 } 1907 1908 int GDBRemoteCommunicationClient::SetWorkingDir(const FileSpec &working_dir) { 1909 if (working_dir) { 1910 std::string path{working_dir.GetPath(false)}; 1911 StreamString packet; 1912 packet.PutCString("QSetWorkingDir:"); 1913 packet.PutStringAsRawHex8(path); 1914 1915 StringExtractorGDBRemote response; 1916 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 1917 PacketResult::Success) { 1918 if (response.IsOKResponse()) 1919 return 0; 1920 uint8_t error = response.GetError(); 1921 if (error) 1922 return error; 1923 } 1924 } 1925 return -1; 1926 } 1927 1928 int GDBRemoteCommunicationClient::SetDisableASLR(bool enable) { 1929 char packet[32]; 1930 const int packet_len = 1931 ::snprintf(packet, sizeof(packet), "QSetDisableASLR:%i", enable ? 1 : 0); 1932 assert(packet_len < (int)sizeof(packet)); 1933 UNUSED_IF_ASSERT_DISABLED(packet_len); 1934 StringExtractorGDBRemote response; 1935 if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success) { 1936 if (response.IsOKResponse()) 1937 return 0; 1938 uint8_t error = response.GetError(); 1939 if (error) 1940 return error; 1941 } 1942 return -1; 1943 } 1944 1945 int GDBRemoteCommunicationClient::SetDetachOnError(bool enable) { 1946 char packet[32]; 1947 const int packet_len = ::snprintf(packet, sizeof(packet), 1948 "QSetDetachOnError:%i", enable ? 1 : 0); 1949 assert(packet_len < (int)sizeof(packet)); 1950 UNUSED_IF_ASSERT_DISABLED(packet_len); 1951 StringExtractorGDBRemote response; 1952 if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success) { 1953 if (response.IsOKResponse()) 1954 return 0; 1955 uint8_t error = response.GetError(); 1956 if (error) 1957 return error; 1958 } 1959 return -1; 1960 } 1961 1962 bool GDBRemoteCommunicationClient::DecodeProcessInfoResponse( 1963 StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info) { 1964 if (response.IsNormalResponse()) { 1965 llvm::StringRef name; 1966 llvm::StringRef value; 1967 StringExtractor extractor; 1968 1969 uint32_t cpu = LLDB_INVALID_CPUTYPE; 1970 uint32_t sub = 0; 1971 std::string vendor; 1972 std::string os_type; 1973 1974 while (response.GetNameColonValue(name, value)) { 1975 if (name.equals("pid")) { 1976 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 1977 value.getAsInteger(0, pid); 1978 process_info.SetProcessID(pid); 1979 } else if (name.equals("ppid")) { 1980 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 1981 value.getAsInteger(0, pid); 1982 process_info.SetParentProcessID(pid); 1983 } else if (name.equals("uid")) { 1984 uint32_t uid = UINT32_MAX; 1985 value.getAsInteger(0, uid); 1986 process_info.SetUserID(uid); 1987 } else if (name.equals("euid")) { 1988 uint32_t uid = UINT32_MAX; 1989 value.getAsInteger(0, uid); 1990 process_info.SetEffectiveUserID(uid); 1991 } else if (name.equals("gid")) { 1992 uint32_t gid = UINT32_MAX; 1993 value.getAsInteger(0, gid); 1994 process_info.SetGroupID(gid); 1995 } else if (name.equals("egid")) { 1996 uint32_t gid = UINT32_MAX; 1997 value.getAsInteger(0, gid); 1998 process_info.SetEffectiveGroupID(gid); 1999 } else if (name.equals("triple")) { 2000 StringExtractor extractor(value); 2001 std::string triple; 2002 extractor.GetHexByteString(triple); 2003 process_info.GetArchitecture().SetTriple(triple.c_str()); 2004 } else if (name.equals("name")) { 2005 StringExtractor extractor(value); 2006 // The process name from ASCII hex bytes since we can't control the 2007 // characters in a process name 2008 std::string name; 2009 extractor.GetHexByteString(name); 2010 process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native); 2011 } else if (name.equals("args")) { 2012 llvm::StringRef encoded_args(value), hex_arg; 2013 2014 bool is_arg0 = true; 2015 while (!encoded_args.empty()) { 2016 std::tie(hex_arg, encoded_args) = encoded_args.split('-'); 2017 std::string arg; 2018 StringExtractor extractor(hex_arg); 2019 if (extractor.GetHexByteString(arg) * 2 != hex_arg.size()) { 2020 // In case of wrong encoding, we discard all the arguments 2021 process_info.GetArguments().Clear(); 2022 process_info.SetArg0(""); 2023 break; 2024 } 2025 if (is_arg0) 2026 process_info.SetArg0(arg); 2027 else 2028 process_info.GetArguments().AppendArgument(arg); 2029 is_arg0 = false; 2030 } 2031 } else if (name.equals("cputype")) { 2032 value.getAsInteger(0, cpu); 2033 } else if (name.equals("cpusubtype")) { 2034 value.getAsInteger(0, sub); 2035 } else if (name.equals("vendor")) { 2036 vendor = std::string(value); 2037 } else if (name.equals("ostype")) { 2038 os_type = std::string(value); 2039 } 2040 } 2041 2042 if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty()) { 2043 if (vendor == "apple") { 2044 process_info.GetArchitecture().SetArchitecture(eArchTypeMachO, cpu, 2045 sub); 2046 process_info.GetArchitecture().GetTriple().setVendorName( 2047 llvm::StringRef(vendor)); 2048 process_info.GetArchitecture().GetTriple().setOSName( 2049 llvm::StringRef(os_type)); 2050 } 2051 } 2052 2053 if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID) 2054 return true; 2055 } 2056 return false; 2057 } 2058 2059 bool GDBRemoteCommunicationClient::GetProcessInfo( 2060 lldb::pid_t pid, ProcessInstanceInfo &process_info) { 2061 process_info.Clear(); 2062 2063 if (m_supports_qProcessInfoPID) { 2064 char packet[32]; 2065 const int packet_len = 2066 ::snprintf(packet, sizeof(packet), "qProcessInfoPID:%" PRIu64, pid); 2067 assert(packet_len < (int)sizeof(packet)); 2068 UNUSED_IF_ASSERT_DISABLED(packet_len); 2069 StringExtractorGDBRemote response; 2070 if (SendPacketAndWaitForResponse(packet, response) == 2071 PacketResult::Success) { 2072 return DecodeProcessInfoResponse(response, process_info); 2073 } else { 2074 m_supports_qProcessInfoPID = false; 2075 return false; 2076 } 2077 } 2078 return false; 2079 } 2080 2081 bool GDBRemoteCommunicationClient::GetCurrentProcessInfo(bool allow_lazy) { 2082 Log *log(GetLog(GDBRLog::Process | GDBRLog::Packets)); 2083 2084 if (allow_lazy) { 2085 if (m_qProcessInfo_is_valid == eLazyBoolYes) 2086 return true; 2087 if (m_qProcessInfo_is_valid == eLazyBoolNo) 2088 return false; 2089 } 2090 2091 GetHostInfo(); 2092 2093 StringExtractorGDBRemote response; 2094 if (SendPacketAndWaitForResponse("qProcessInfo", response) == 2095 PacketResult::Success) { 2096 if (response.IsNormalResponse()) { 2097 llvm::StringRef name; 2098 llvm::StringRef value; 2099 uint32_t cpu = LLDB_INVALID_CPUTYPE; 2100 uint32_t sub = 0; 2101 std::string arch_name; 2102 std::string os_name; 2103 std::string environment; 2104 std::string vendor_name; 2105 std::string triple; 2106 std::string elf_abi; 2107 uint32_t pointer_byte_size = 0; 2108 StringExtractor extractor; 2109 ByteOrder byte_order = eByteOrderInvalid; 2110 uint32_t num_keys_decoded = 0; 2111 lldb::pid_t pid = LLDB_INVALID_PROCESS_ID; 2112 while (response.GetNameColonValue(name, value)) { 2113 if (name.equals("cputype")) { 2114 if (!value.getAsInteger(16, cpu)) 2115 ++num_keys_decoded; 2116 } else if (name.equals("cpusubtype")) { 2117 if (!value.getAsInteger(16, sub)) 2118 ++num_keys_decoded; 2119 } else if (name.equals("triple")) { 2120 StringExtractor extractor(value); 2121 extractor.GetHexByteString(triple); 2122 ++num_keys_decoded; 2123 } else if (name.equals("ostype")) { 2124 ParseOSType(value, os_name, environment); 2125 ++num_keys_decoded; 2126 } else if (name.equals("vendor")) { 2127 vendor_name = std::string(value); 2128 ++num_keys_decoded; 2129 } else if (name.equals("endian")) { 2130 byte_order = llvm::StringSwitch<lldb::ByteOrder>(value) 2131 .Case("little", eByteOrderLittle) 2132 .Case("big", eByteOrderBig) 2133 .Case("pdp", eByteOrderPDP) 2134 .Default(eByteOrderInvalid); 2135 if (byte_order != eByteOrderInvalid) 2136 ++num_keys_decoded; 2137 } else if (name.equals("ptrsize")) { 2138 if (!value.getAsInteger(16, pointer_byte_size)) 2139 ++num_keys_decoded; 2140 } else if (name.equals("pid")) { 2141 if (!value.getAsInteger(16, pid)) 2142 ++num_keys_decoded; 2143 } else if (name.equals("elf_abi")) { 2144 elf_abi = std::string(value); 2145 ++num_keys_decoded; 2146 } else if (name.equals("main-binary-uuid")) { 2147 m_process_standalone_uuid.SetFromStringRef(value); 2148 ++num_keys_decoded; 2149 } else if (name.equals("main-binary-slide")) { 2150 StringExtractor extractor(value); 2151 m_process_standalone_value = 2152 extractor.GetU64(LLDB_INVALID_ADDRESS, 16); 2153 if (m_process_standalone_value != LLDB_INVALID_ADDRESS) { 2154 m_process_standalone_value_is_offset = true; 2155 ++num_keys_decoded; 2156 } 2157 } else if (name.equals("main-binary-address")) { 2158 StringExtractor extractor(value); 2159 m_process_standalone_value = 2160 extractor.GetU64(LLDB_INVALID_ADDRESS, 16); 2161 if (m_process_standalone_value != LLDB_INVALID_ADDRESS) { 2162 m_process_standalone_value_is_offset = false; 2163 ++num_keys_decoded; 2164 } 2165 } else if (name.equals("binary-addresses")) { 2166 m_binary_addresses.clear(); 2167 ++num_keys_decoded; 2168 for (llvm::StringRef x : llvm::split(value, ',')) { 2169 addr_t vmaddr; 2170 x.consume_front("0x"); 2171 if (llvm::to_integer(x, vmaddr, 16)) 2172 m_binary_addresses.push_back(vmaddr); 2173 } 2174 } 2175 } 2176 if (num_keys_decoded > 0) 2177 m_qProcessInfo_is_valid = eLazyBoolYes; 2178 if (pid != LLDB_INVALID_PROCESS_ID) { 2179 m_curr_pid_is_valid = eLazyBoolYes; 2180 m_curr_pid_run = m_curr_pid = pid; 2181 } 2182 2183 // Set the ArchSpec from the triple if we have it. 2184 if (!triple.empty()) { 2185 m_process_arch.SetTriple(triple.c_str()); 2186 m_process_arch.SetFlags(elf_abi); 2187 if (pointer_byte_size) { 2188 assert(pointer_byte_size == m_process_arch.GetAddressByteSize()); 2189 } 2190 } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && 2191 !vendor_name.empty()) { 2192 llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name); 2193 if (!environment.empty()) 2194 triple.setEnvironmentName(environment); 2195 2196 assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat); 2197 assert(triple.getObjectFormat() != llvm::Triple::Wasm); 2198 assert(triple.getObjectFormat() != llvm::Triple::XCOFF); 2199 switch (triple.getObjectFormat()) { 2200 case llvm::Triple::MachO: 2201 m_process_arch.SetArchitecture(eArchTypeMachO, cpu, sub); 2202 break; 2203 case llvm::Triple::ELF: 2204 m_process_arch.SetArchitecture(eArchTypeELF, cpu, sub); 2205 break; 2206 case llvm::Triple::COFF: 2207 m_process_arch.SetArchitecture(eArchTypeCOFF, cpu, sub); 2208 break; 2209 case llvm::Triple::GOFF: 2210 case llvm::Triple::SPIRV: 2211 case llvm::Triple::Wasm: 2212 case llvm::Triple::XCOFF: 2213 case llvm::Triple::DXContainer: 2214 LLDB_LOGF(log, "error: not supported target architecture"); 2215 return false; 2216 case llvm::Triple::UnknownObjectFormat: 2217 LLDB_LOGF(log, "error: failed to determine target architecture"); 2218 return false; 2219 } 2220 2221 if (pointer_byte_size) { 2222 assert(pointer_byte_size == m_process_arch.GetAddressByteSize()); 2223 } 2224 if (byte_order != eByteOrderInvalid) { 2225 assert(byte_order == m_process_arch.GetByteOrder()); 2226 } 2227 m_process_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name)); 2228 m_process_arch.GetTriple().setOSName(llvm::StringRef(os_name)); 2229 m_process_arch.GetTriple().setEnvironmentName(llvm::StringRef(environment)); 2230 } 2231 return true; 2232 } 2233 } else { 2234 m_qProcessInfo_is_valid = eLazyBoolNo; 2235 } 2236 2237 return false; 2238 } 2239 2240 uint32_t GDBRemoteCommunicationClient::FindProcesses( 2241 const ProcessInstanceInfoMatch &match_info, 2242 ProcessInstanceInfoList &process_infos) { 2243 process_infos.clear(); 2244 2245 if (m_supports_qfProcessInfo) { 2246 StreamString packet; 2247 packet.PutCString("qfProcessInfo"); 2248 if (!match_info.MatchAllProcesses()) { 2249 packet.PutChar(':'); 2250 const char *name = match_info.GetProcessInfo().GetName(); 2251 bool has_name_match = false; 2252 if (name && name[0]) { 2253 has_name_match = true; 2254 NameMatch name_match_type = match_info.GetNameMatchType(); 2255 switch (name_match_type) { 2256 case NameMatch::Ignore: 2257 has_name_match = false; 2258 break; 2259 2260 case NameMatch::Equals: 2261 packet.PutCString("name_match:equals;"); 2262 break; 2263 2264 case NameMatch::Contains: 2265 packet.PutCString("name_match:contains;"); 2266 break; 2267 2268 case NameMatch::StartsWith: 2269 packet.PutCString("name_match:starts_with;"); 2270 break; 2271 2272 case NameMatch::EndsWith: 2273 packet.PutCString("name_match:ends_with;"); 2274 break; 2275 2276 case NameMatch::RegularExpression: 2277 packet.PutCString("name_match:regex;"); 2278 break; 2279 } 2280 if (has_name_match) { 2281 packet.PutCString("name:"); 2282 packet.PutBytesAsRawHex8(name, ::strlen(name)); 2283 packet.PutChar(';'); 2284 } 2285 } 2286 2287 if (match_info.GetProcessInfo().ProcessIDIsValid()) 2288 packet.Printf("pid:%" PRIu64 ";", 2289 match_info.GetProcessInfo().GetProcessID()); 2290 if (match_info.GetProcessInfo().ParentProcessIDIsValid()) 2291 packet.Printf("parent_pid:%" PRIu64 ";", 2292 match_info.GetProcessInfo().GetParentProcessID()); 2293 if (match_info.GetProcessInfo().UserIDIsValid()) 2294 packet.Printf("uid:%u;", match_info.GetProcessInfo().GetUserID()); 2295 if (match_info.GetProcessInfo().GroupIDIsValid()) 2296 packet.Printf("gid:%u;", match_info.GetProcessInfo().GetGroupID()); 2297 if (match_info.GetProcessInfo().EffectiveUserIDIsValid()) 2298 packet.Printf("euid:%u;", 2299 match_info.GetProcessInfo().GetEffectiveUserID()); 2300 if (match_info.GetProcessInfo().EffectiveGroupIDIsValid()) 2301 packet.Printf("egid:%u;", 2302 match_info.GetProcessInfo().GetEffectiveGroupID()); 2303 packet.Printf("all_users:%u;", match_info.GetMatchAllUsers() ? 1 : 0); 2304 if (match_info.GetProcessInfo().GetArchitecture().IsValid()) { 2305 const ArchSpec &match_arch = 2306 match_info.GetProcessInfo().GetArchitecture(); 2307 const llvm::Triple &triple = match_arch.GetTriple(); 2308 packet.PutCString("triple:"); 2309 packet.PutCString(triple.getTriple()); 2310 packet.PutChar(';'); 2311 } 2312 } 2313 StringExtractorGDBRemote response; 2314 // Increase timeout as the first qfProcessInfo packet takes a long time on 2315 // Android. The value of 1min was arrived at empirically. 2316 ScopedTimeout timeout(*this, minutes(1)); 2317 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 2318 PacketResult::Success) { 2319 do { 2320 ProcessInstanceInfo process_info; 2321 if (!DecodeProcessInfoResponse(response, process_info)) 2322 break; 2323 process_infos.push_back(process_info); 2324 response = StringExtractorGDBRemote(); 2325 } while (SendPacketAndWaitForResponse("qsProcessInfo", response) == 2326 PacketResult::Success); 2327 } else { 2328 m_supports_qfProcessInfo = false; 2329 return 0; 2330 } 2331 } 2332 return process_infos.size(); 2333 } 2334 2335 bool GDBRemoteCommunicationClient::GetUserName(uint32_t uid, 2336 std::string &name) { 2337 if (m_supports_qUserName) { 2338 char packet[32]; 2339 const int packet_len = 2340 ::snprintf(packet, sizeof(packet), "qUserName:%i", uid); 2341 assert(packet_len < (int)sizeof(packet)); 2342 UNUSED_IF_ASSERT_DISABLED(packet_len); 2343 StringExtractorGDBRemote response; 2344 if (SendPacketAndWaitForResponse(packet, response) == 2345 PacketResult::Success) { 2346 if (response.IsNormalResponse()) { 2347 // Make sure we parsed the right number of characters. The response is 2348 // the hex encoded user name and should make up the entire packet. If 2349 // there are any non-hex ASCII bytes, the length won't match below.. 2350 if (response.GetHexByteString(name) * 2 == 2351 response.GetStringRef().size()) 2352 return true; 2353 } 2354 } else { 2355 m_supports_qUserName = false; 2356 return false; 2357 } 2358 } 2359 return false; 2360 } 2361 2362 bool GDBRemoteCommunicationClient::GetGroupName(uint32_t gid, 2363 std::string &name) { 2364 if (m_supports_qGroupName) { 2365 char packet[32]; 2366 const int packet_len = 2367 ::snprintf(packet, sizeof(packet), "qGroupName:%i", gid); 2368 assert(packet_len < (int)sizeof(packet)); 2369 UNUSED_IF_ASSERT_DISABLED(packet_len); 2370 StringExtractorGDBRemote response; 2371 if (SendPacketAndWaitForResponse(packet, response) == 2372 PacketResult::Success) { 2373 if (response.IsNormalResponse()) { 2374 // Make sure we parsed the right number of characters. The response is 2375 // the hex encoded group name and should make up the entire packet. If 2376 // there are any non-hex ASCII bytes, the length won't match below.. 2377 if (response.GetHexByteString(name) * 2 == 2378 response.GetStringRef().size()) 2379 return true; 2380 } 2381 } else { 2382 m_supports_qGroupName = false; 2383 return false; 2384 } 2385 } 2386 return false; 2387 } 2388 2389 static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size, 2390 uint32_t recv_size) { 2391 packet.Clear(); 2392 packet.Printf("qSpeedTest:response_size:%i;data:", recv_size); 2393 uint32_t bytes_left = send_size; 2394 while (bytes_left > 0) { 2395 if (bytes_left >= 26) { 2396 packet.PutCString("abcdefghijklmnopqrstuvwxyz"); 2397 bytes_left -= 26; 2398 } else { 2399 packet.Printf("%*.*s;", bytes_left, bytes_left, 2400 "abcdefghijklmnopqrstuvwxyz"); 2401 bytes_left = 0; 2402 } 2403 } 2404 } 2405 2406 duration<float> 2407 calculate_standard_deviation(const std::vector<duration<float>> &v) { 2408 if (v.size() == 0) 2409 return duration<float>::zero(); 2410 using Dur = duration<float>; 2411 Dur sum = std::accumulate(std::begin(v), std::end(v), Dur()); 2412 Dur mean = sum / v.size(); 2413 float accum = 0; 2414 for (auto d : v) { 2415 float delta = (d - mean).count(); 2416 accum += delta * delta; 2417 }; 2418 2419 return Dur(sqrtf(accum / (v.size() - 1))); 2420 } 2421 2422 void GDBRemoteCommunicationClient::TestPacketSpeed(const uint32_t num_packets, 2423 uint32_t max_send, 2424 uint32_t max_recv, 2425 uint64_t recv_amount, 2426 bool json, Stream &strm) { 2427 2428 if (SendSpeedTestPacket(0, 0)) { 2429 StreamString packet; 2430 if (json) 2431 strm.Printf("{ \"packet_speeds\" : {\n \"num_packets\" : %u,\n " 2432 "\"results\" : [", 2433 num_packets); 2434 else 2435 strm.Printf("Testing sending %u packets of various sizes:\n", 2436 num_packets); 2437 strm.Flush(); 2438 2439 uint32_t result_idx = 0; 2440 uint32_t send_size; 2441 std::vector<duration<float>> packet_times; 2442 2443 for (send_size = 0; send_size <= max_send; 2444 send_size ? send_size *= 2 : send_size = 4) { 2445 for (uint32_t recv_size = 0; recv_size <= max_recv; 2446 recv_size ? recv_size *= 2 : recv_size = 4) { 2447 MakeSpeedTestPacket(packet, send_size, recv_size); 2448 2449 packet_times.clear(); 2450 // Test how long it takes to send 'num_packets' packets 2451 const auto start_time = steady_clock::now(); 2452 for (uint32_t i = 0; i < num_packets; ++i) { 2453 const auto packet_start_time = steady_clock::now(); 2454 StringExtractorGDBRemote response; 2455 SendPacketAndWaitForResponse(packet.GetString(), response); 2456 const auto packet_end_time = steady_clock::now(); 2457 packet_times.push_back(packet_end_time - packet_start_time); 2458 } 2459 const auto end_time = steady_clock::now(); 2460 const auto total_time = end_time - start_time; 2461 2462 float packets_per_second = 2463 ((float)num_packets) / duration<float>(total_time).count(); 2464 auto average_per_packet = num_packets > 0 ? total_time / num_packets 2465 : duration<float>::zero(); 2466 const duration<float> standard_deviation = 2467 calculate_standard_deviation(packet_times); 2468 if (json) { 2469 strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : " 2470 "{2,6}, \"total_time_nsec\" : {3,12:ns-}, " 2471 "\"standard_deviation_nsec\" : {4,9:ns-f0}}", 2472 result_idx > 0 ? "," : "", send_size, recv_size, 2473 total_time, standard_deviation); 2474 ++result_idx; 2475 } else { 2476 strm.Format("qSpeedTest(send={0,7}, recv={1,7}) in {2:s+f9} for " 2477 "{3,9:f2} packets/s ({4,10:ms+f6} per packet) with " 2478 "standard deviation of {5,10:ms+f6}\n", 2479 send_size, recv_size, duration<float>(total_time), 2480 packets_per_second, duration<float>(average_per_packet), 2481 standard_deviation); 2482 } 2483 strm.Flush(); 2484 } 2485 } 2486 2487 const float k_recv_amount_mb = (float)recv_amount / (1024.0f * 1024.0f); 2488 if (json) 2489 strm.Printf("\n ]\n },\n \"download_speed\" : {\n \"byte_size\" " 2490 ": %" PRIu64 ",\n \"results\" : [", 2491 recv_amount); 2492 else 2493 strm.Printf("Testing receiving %2.1fMB of data using varying receive " 2494 "packet sizes:\n", 2495 k_recv_amount_mb); 2496 strm.Flush(); 2497 send_size = 0; 2498 result_idx = 0; 2499 for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) { 2500 MakeSpeedTestPacket(packet, send_size, recv_size); 2501 2502 // If we have a receive size, test how long it takes to receive 4MB of 2503 // data 2504 if (recv_size > 0) { 2505 const auto start_time = steady_clock::now(); 2506 uint32_t bytes_read = 0; 2507 uint32_t packet_count = 0; 2508 while (bytes_read < recv_amount) { 2509 StringExtractorGDBRemote response; 2510 SendPacketAndWaitForResponse(packet.GetString(), response); 2511 bytes_read += recv_size; 2512 ++packet_count; 2513 } 2514 const auto end_time = steady_clock::now(); 2515 const auto total_time = end_time - start_time; 2516 float mb_second = ((float)recv_amount) / 2517 duration<float>(total_time).count() / 2518 (1024.0 * 1024.0); 2519 float packets_per_second = 2520 ((float)packet_count) / duration<float>(total_time).count(); 2521 const auto average_per_packet = packet_count > 0 2522 ? total_time / packet_count 2523 : duration<float>::zero(); 2524 2525 if (json) { 2526 strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : " 2527 "{2,6}, \"total_time_nsec\" : {3,12:ns-}}", 2528 result_idx > 0 ? "," : "", send_size, recv_size, 2529 total_time); 2530 ++result_idx; 2531 } else { 2532 strm.Format("qSpeedTest(send={0,7}, recv={1,7}) {2,6} packets needed " 2533 "to receive {3:f1}MB in {4:s+f9} for {5} MB/sec for " 2534 "{6,9:f2} packets/sec ({7,10:ms+f6} per packet)\n", 2535 send_size, recv_size, packet_count, k_recv_amount_mb, 2536 duration<float>(total_time), mb_second, 2537 packets_per_second, duration<float>(average_per_packet)); 2538 } 2539 strm.Flush(); 2540 } 2541 } 2542 if (json) 2543 strm.Printf("\n ]\n }\n}\n"); 2544 else 2545 strm.EOL(); 2546 } 2547 } 2548 2549 bool GDBRemoteCommunicationClient::SendSpeedTestPacket(uint32_t send_size, 2550 uint32_t recv_size) { 2551 StreamString packet; 2552 packet.Printf("qSpeedTest:response_size:%i;data:", recv_size); 2553 uint32_t bytes_left = send_size; 2554 while (bytes_left > 0) { 2555 if (bytes_left >= 26) { 2556 packet.PutCString("abcdefghijklmnopqrstuvwxyz"); 2557 bytes_left -= 26; 2558 } else { 2559 packet.Printf("%*.*s;", bytes_left, bytes_left, 2560 "abcdefghijklmnopqrstuvwxyz"); 2561 bytes_left = 0; 2562 } 2563 } 2564 2565 StringExtractorGDBRemote response; 2566 return SendPacketAndWaitForResponse(packet.GetString(), response) == 2567 PacketResult::Success; 2568 } 2569 2570 bool GDBRemoteCommunicationClient::LaunchGDBServer( 2571 const char *remote_accept_hostname, lldb::pid_t &pid, uint16_t &port, 2572 std::string &socket_name) { 2573 pid = LLDB_INVALID_PROCESS_ID; 2574 port = 0; 2575 socket_name.clear(); 2576 2577 StringExtractorGDBRemote response; 2578 StreamString stream; 2579 stream.PutCString("qLaunchGDBServer;"); 2580 std::string hostname; 2581 if (remote_accept_hostname && remote_accept_hostname[0]) 2582 hostname = remote_accept_hostname; 2583 else { 2584 if (HostInfo::GetHostname(hostname)) { 2585 // Make the GDB server we launch only accept connections from this host 2586 stream.Printf("host:%s;", hostname.c_str()); 2587 } else { 2588 // Make the GDB server we launch accept connections from any host since 2589 // we can't figure out the hostname 2590 stream.Printf("host:*;"); 2591 } 2592 } 2593 // give the process a few seconds to startup 2594 ScopedTimeout timeout(*this, seconds(10)); 2595 2596 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 2597 PacketResult::Success) { 2598 if (response.IsErrorResponse()) 2599 return false; 2600 2601 llvm::StringRef name; 2602 llvm::StringRef value; 2603 while (response.GetNameColonValue(name, value)) { 2604 if (name.equals("port")) 2605 value.getAsInteger(0, port); 2606 else if (name.equals("pid")) 2607 value.getAsInteger(0, pid); 2608 else if (name.compare("socket_name") == 0) { 2609 StringExtractor extractor(value); 2610 extractor.GetHexByteString(socket_name); 2611 } 2612 } 2613 return true; 2614 } 2615 return false; 2616 } 2617 2618 size_t GDBRemoteCommunicationClient::QueryGDBServer( 2619 std::vector<std::pair<uint16_t, std::string>> &connection_urls) { 2620 connection_urls.clear(); 2621 2622 StringExtractorGDBRemote response; 2623 if (SendPacketAndWaitForResponse("qQueryGDBServer", response) != 2624 PacketResult::Success) 2625 return 0; 2626 2627 StructuredData::ObjectSP data = 2628 StructuredData::ParseJSON(response.GetStringRef()); 2629 if (!data) 2630 return 0; 2631 2632 StructuredData::Array *array = data->GetAsArray(); 2633 if (!array) 2634 return 0; 2635 2636 for (size_t i = 0, count = array->GetSize(); i < count; ++i) { 2637 StructuredData::Dictionary *element = nullptr; 2638 if (!array->GetItemAtIndexAsDictionary(i, element)) 2639 continue; 2640 2641 uint16_t port = 0; 2642 if (StructuredData::ObjectSP port_osp = 2643 element->GetValueForKey(llvm::StringRef("port"))) 2644 port = port_osp->GetUnsignedIntegerValue(0); 2645 2646 std::string socket_name; 2647 if (StructuredData::ObjectSP socket_name_osp = 2648 element->GetValueForKey(llvm::StringRef("socket_name"))) 2649 socket_name = std::string(socket_name_osp->GetStringValue()); 2650 2651 if (port != 0 || !socket_name.empty()) 2652 connection_urls.emplace_back(port, socket_name); 2653 } 2654 return connection_urls.size(); 2655 } 2656 2657 bool GDBRemoteCommunicationClient::KillSpawnedProcess(lldb::pid_t pid) { 2658 StreamString stream; 2659 stream.Printf("qKillSpawnedProcess:%" PRId64, pid); 2660 2661 StringExtractorGDBRemote response; 2662 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 2663 PacketResult::Success) { 2664 if (response.IsOKResponse()) 2665 return true; 2666 } 2667 return false; 2668 } 2669 2670 std::optional<PidTid> GDBRemoteCommunicationClient::SendSetCurrentThreadPacket( 2671 uint64_t tid, uint64_t pid, char op) { 2672 lldb_private::StreamString packet; 2673 packet.PutChar('H'); 2674 packet.PutChar(op); 2675 2676 if (pid != LLDB_INVALID_PROCESS_ID) 2677 packet.Printf("p%" PRIx64 ".", pid); 2678 2679 if (tid == UINT64_MAX) 2680 packet.PutCString("-1"); 2681 else 2682 packet.Printf("%" PRIx64, tid); 2683 2684 StringExtractorGDBRemote response; 2685 if (SendPacketAndWaitForResponse(packet.GetString(), response) == 2686 PacketResult::Success) { 2687 if (response.IsOKResponse()) 2688 return {{pid, tid}}; 2689 2690 /* 2691 * Connected bare-iron target (like YAMON gdb-stub) may not have support for 2692 * Hg packet. 2693 * The reply from '?' packet could be as simple as 'S05'. There is no packet 2694 * which can 2695 * give us pid and/or tid. Assume pid=tid=1 in such cases. 2696 */ 2697 if (response.IsUnsupportedResponse() && IsConnected()) 2698 return {{1, 1}}; 2699 } 2700 return std::nullopt; 2701 } 2702 2703 bool GDBRemoteCommunicationClient::SetCurrentThread(uint64_t tid, 2704 uint64_t pid) { 2705 if (m_curr_tid == tid && 2706 (m_curr_pid == pid || LLDB_INVALID_PROCESS_ID == pid)) 2707 return true; 2708 2709 std::optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'g'); 2710 if (ret) { 2711 if (ret->pid != LLDB_INVALID_PROCESS_ID) 2712 m_curr_pid = ret->pid; 2713 m_curr_tid = ret->tid; 2714 } 2715 return ret.has_value(); 2716 } 2717 2718 bool GDBRemoteCommunicationClient::SetCurrentThreadForRun(uint64_t tid, 2719 uint64_t pid) { 2720 if (m_curr_tid_run == tid && 2721 (m_curr_pid_run == pid || LLDB_INVALID_PROCESS_ID == pid)) 2722 return true; 2723 2724 std::optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'c'); 2725 if (ret) { 2726 if (ret->pid != LLDB_INVALID_PROCESS_ID) 2727 m_curr_pid_run = ret->pid; 2728 m_curr_tid_run = ret->tid; 2729 } 2730 return ret.has_value(); 2731 } 2732 2733 bool GDBRemoteCommunicationClient::GetStopReply( 2734 StringExtractorGDBRemote &response) { 2735 if (SendPacketAndWaitForResponse("?", response) == PacketResult::Success) 2736 return response.IsNormalResponse(); 2737 return false; 2738 } 2739 2740 bool GDBRemoteCommunicationClient::GetThreadStopInfo( 2741 lldb::tid_t tid, StringExtractorGDBRemote &response) { 2742 if (m_supports_qThreadStopInfo) { 2743 char packet[256]; 2744 int packet_len = 2745 ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid); 2746 assert(packet_len < (int)sizeof(packet)); 2747 UNUSED_IF_ASSERT_DISABLED(packet_len); 2748 if (SendPacketAndWaitForResponse(packet, response) == 2749 PacketResult::Success) { 2750 if (response.IsUnsupportedResponse()) 2751 m_supports_qThreadStopInfo = false; 2752 else if (response.IsNormalResponse()) 2753 return true; 2754 else 2755 return false; 2756 } else { 2757 m_supports_qThreadStopInfo = false; 2758 } 2759 } 2760 return false; 2761 } 2762 2763 uint8_t GDBRemoteCommunicationClient::SendGDBStoppointTypePacket( 2764 GDBStoppointType type, bool insert, addr_t addr, uint32_t length, 2765 std::chrono::seconds timeout) { 2766 Log *log = GetLog(LLDBLog::Breakpoints); 2767 LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64, 2768 __FUNCTION__, insert ? "add" : "remove", addr); 2769 2770 // Check if the stub is known not to support this breakpoint type 2771 if (!SupportsGDBStoppointPacket(type)) 2772 return UINT8_MAX; 2773 // Construct the breakpoint packet 2774 char packet[64]; 2775 const int packet_len = 2776 ::snprintf(packet, sizeof(packet), "%c%i,%" PRIx64 ",%x", 2777 insert ? 'Z' : 'z', type, addr, length); 2778 // Check we haven't overwritten the end of the packet buffer 2779 assert(packet_len + 1 < (int)sizeof(packet)); 2780 UNUSED_IF_ASSERT_DISABLED(packet_len); 2781 StringExtractorGDBRemote response; 2782 // Make sure the response is either "OK", "EXX" where XX are two hex digits, 2783 // or "" (unsupported) 2784 response.SetResponseValidatorToOKErrorNotSupported(); 2785 // Try to send the breakpoint packet, and check that it was correctly sent 2786 if (SendPacketAndWaitForResponse(packet, response, timeout) == 2787 PacketResult::Success) { 2788 // Receive and OK packet when the breakpoint successfully placed 2789 if (response.IsOKResponse()) 2790 return 0; 2791 2792 // Status while setting breakpoint, send back specific error 2793 if (response.IsErrorResponse()) 2794 return response.GetError(); 2795 2796 // Empty packet informs us that breakpoint is not supported 2797 if (response.IsUnsupportedResponse()) { 2798 // Disable this breakpoint type since it is unsupported 2799 switch (type) { 2800 case eBreakpointSoftware: 2801 m_supports_z0 = false; 2802 break; 2803 case eBreakpointHardware: 2804 m_supports_z1 = false; 2805 break; 2806 case eWatchpointWrite: 2807 m_supports_z2 = false; 2808 break; 2809 case eWatchpointRead: 2810 m_supports_z3 = false; 2811 break; 2812 case eWatchpointReadWrite: 2813 m_supports_z4 = false; 2814 break; 2815 case eStoppointInvalid: 2816 return UINT8_MAX; 2817 } 2818 } 2819 } 2820 // Signal generic failure 2821 return UINT8_MAX; 2822 } 2823 2824 std::vector<std::pair<lldb::pid_t, lldb::tid_t>> 2825 GDBRemoteCommunicationClient::GetCurrentProcessAndThreadIDs( 2826 bool &sequence_mutex_unavailable) { 2827 std::vector<std::pair<lldb::pid_t, lldb::tid_t>> ids; 2828 2829 Lock lock(*this); 2830 if (lock) { 2831 sequence_mutex_unavailable = false; 2832 StringExtractorGDBRemote response; 2833 2834 PacketResult packet_result; 2835 for (packet_result = 2836 SendPacketAndWaitForResponseNoLock("qfThreadInfo", response); 2837 packet_result == PacketResult::Success && response.IsNormalResponse(); 2838 packet_result = 2839 SendPacketAndWaitForResponseNoLock("qsThreadInfo", response)) { 2840 char ch = response.GetChar(); 2841 if (ch == 'l') 2842 break; 2843 if (ch == 'm') { 2844 do { 2845 auto pid_tid = response.GetPidTid(LLDB_INVALID_PROCESS_ID); 2846 // If we get an invalid response, break out of the loop. 2847 // If there are valid tids, they have been added to ids. 2848 // If there are no valid tids, we'll fall through to the 2849 // bare-iron target handling below. 2850 if (!pid_tid) 2851 break; 2852 2853 ids.push_back(*pid_tid); 2854 ch = response.GetChar(); // Skip the command separator 2855 } while (ch == ','); // Make sure we got a comma separator 2856 } 2857 } 2858 2859 /* 2860 * Connected bare-iron target (like YAMON gdb-stub) may not have support for 2861 * qProcessInfo, qC and qfThreadInfo packets. The reply from '?' packet 2862 * could 2863 * be as simple as 'S05'. There is no packet which can give us pid and/or 2864 * tid. 2865 * Assume pid=tid=1 in such cases. 2866 */ 2867 if ((response.IsUnsupportedResponse() || response.IsNormalResponse()) && 2868 ids.size() == 0 && IsConnected()) { 2869 ids.emplace_back(1, 1); 2870 } 2871 } else { 2872 Log *log(GetLog(GDBRLog::Process | GDBRLog::Packets)); 2873 LLDB_LOG(log, "error: failed to get packet sequence mutex, not sending " 2874 "packet 'qfThreadInfo'"); 2875 sequence_mutex_unavailable = true; 2876 } 2877 2878 return ids; 2879 } 2880 2881 size_t GDBRemoteCommunicationClient::GetCurrentThreadIDs( 2882 std::vector<lldb::tid_t> &thread_ids, bool &sequence_mutex_unavailable) { 2883 lldb::pid_t pid = GetCurrentProcessID(); 2884 thread_ids.clear(); 2885 2886 auto ids = GetCurrentProcessAndThreadIDs(sequence_mutex_unavailable); 2887 if (ids.empty() || sequence_mutex_unavailable) 2888 return 0; 2889 2890 for (auto id : ids) { 2891 // skip threads that do not belong to the current process 2892 if (id.first != LLDB_INVALID_PROCESS_ID && id.first != pid) 2893 continue; 2894 if (id.second != LLDB_INVALID_THREAD_ID && 2895 id.second != StringExtractorGDBRemote::AllThreads) 2896 thread_ids.push_back(id.second); 2897 } 2898 2899 return thread_ids.size(); 2900 } 2901 2902 lldb::addr_t GDBRemoteCommunicationClient::GetShlibInfoAddr() { 2903 StringExtractorGDBRemote response; 2904 if (SendPacketAndWaitForResponse("qShlibInfoAddr", response) != 2905 PacketResult::Success || 2906 !response.IsNormalResponse()) 2907 return LLDB_INVALID_ADDRESS; 2908 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS); 2909 } 2910 2911 lldb_private::Status GDBRemoteCommunicationClient::RunShellCommand( 2912 llvm::StringRef command, 2913 const FileSpec & 2914 working_dir, // Pass empty FileSpec to use the current working directory 2915 int *status_ptr, // Pass NULL if you don't want the process exit status 2916 int *signo_ptr, // Pass NULL if you don't want the signal that caused the 2917 // process to exit 2918 std::string 2919 *command_output, // Pass NULL if you don't want the command output 2920 const Timeout<std::micro> &timeout) { 2921 lldb_private::StreamString stream; 2922 stream.PutCString("qPlatform_shell:"); 2923 stream.PutBytesAsRawHex8(command.data(), command.size()); 2924 stream.PutChar(','); 2925 uint32_t timeout_sec = UINT32_MAX; 2926 if (timeout) { 2927 // TODO: Use chrono version of std::ceil once c++17 is available. 2928 timeout_sec = std::ceil(std::chrono::duration<double>(*timeout).count()); 2929 } 2930 stream.PutHex32(timeout_sec); 2931 if (working_dir) { 2932 std::string path{working_dir.GetPath(false)}; 2933 stream.PutChar(','); 2934 stream.PutStringAsRawHex8(path); 2935 } 2936 StringExtractorGDBRemote response; 2937 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 2938 PacketResult::Success) { 2939 if (response.GetChar() != 'F') 2940 return Status("malformed reply"); 2941 if (response.GetChar() != ',') 2942 return Status("malformed reply"); 2943 uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX); 2944 if (exitcode == UINT32_MAX) 2945 return Status("unable to run remote process"); 2946 else if (status_ptr) 2947 *status_ptr = exitcode; 2948 if (response.GetChar() != ',') 2949 return Status("malformed reply"); 2950 uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX); 2951 if (signo_ptr) 2952 *signo_ptr = signo; 2953 if (response.GetChar() != ',') 2954 return Status("malformed reply"); 2955 std::string output; 2956 response.GetEscapedBinaryData(output); 2957 if (command_output) 2958 command_output->assign(output); 2959 return Status(); 2960 } 2961 return Status("unable to send packet"); 2962 } 2963 2964 Status GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec, 2965 uint32_t file_permissions) { 2966 std::string path{file_spec.GetPath(false)}; 2967 lldb_private::StreamString stream; 2968 stream.PutCString("qPlatform_mkdir:"); 2969 stream.PutHex32(file_permissions); 2970 stream.PutChar(','); 2971 stream.PutStringAsRawHex8(path); 2972 llvm::StringRef packet = stream.GetString(); 2973 StringExtractorGDBRemote response; 2974 2975 if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success) 2976 return Status("failed to send '%s' packet", packet.str().c_str()); 2977 2978 if (response.GetChar() != 'F') 2979 return Status("invalid response to '%s' packet", packet.str().c_str()); 2980 2981 return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX); 2982 } 2983 2984 Status 2985 GDBRemoteCommunicationClient::SetFilePermissions(const FileSpec &file_spec, 2986 uint32_t file_permissions) { 2987 std::string path{file_spec.GetPath(false)}; 2988 lldb_private::StreamString stream; 2989 stream.PutCString("qPlatform_chmod:"); 2990 stream.PutHex32(file_permissions); 2991 stream.PutChar(','); 2992 stream.PutStringAsRawHex8(path); 2993 llvm::StringRef packet = stream.GetString(); 2994 StringExtractorGDBRemote response; 2995 2996 if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success) 2997 return Status("failed to send '%s' packet", stream.GetData()); 2998 2999 if (response.GetChar() != 'F') 3000 return Status("invalid response to '%s' packet", stream.GetData()); 3001 3002 return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX); 3003 } 3004 3005 static int gdb_errno_to_system(int err) { 3006 switch (err) { 3007 #define HANDLE_ERRNO(name, value) \ 3008 case GDB_##name: \ 3009 return name; 3010 #include "Plugins/Process/gdb-remote/GDBRemoteErrno.def" 3011 default: 3012 return -1; 3013 } 3014 } 3015 3016 static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response, 3017 uint64_t fail_result, Status &error) { 3018 response.SetFilePos(0); 3019 if (response.GetChar() != 'F') 3020 return fail_result; 3021 int32_t result = response.GetS32(-2, 16); 3022 if (result == -2) 3023 return fail_result; 3024 if (response.GetChar() == ',') { 3025 int result_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3026 if (result_errno != -1) 3027 error.SetError(result_errno, eErrorTypePOSIX); 3028 else 3029 error.SetError(-1, eErrorTypeGeneric); 3030 } else 3031 error.Clear(); 3032 return result; 3033 } 3034 lldb::user_id_t 3035 GDBRemoteCommunicationClient::OpenFile(const lldb_private::FileSpec &file_spec, 3036 File::OpenOptions flags, mode_t mode, 3037 Status &error) { 3038 std::string path(file_spec.GetPath(false)); 3039 lldb_private::StreamString stream; 3040 stream.PutCString("vFile:open:"); 3041 if (path.empty()) 3042 return UINT64_MAX; 3043 stream.PutStringAsRawHex8(path); 3044 stream.PutChar(','); 3045 stream.PutHex32(flags); 3046 stream.PutChar(','); 3047 stream.PutHex32(mode); 3048 StringExtractorGDBRemote response; 3049 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3050 PacketResult::Success) { 3051 return ParseHostIOPacketResponse(response, UINT64_MAX, error); 3052 } 3053 return UINT64_MAX; 3054 } 3055 3056 bool GDBRemoteCommunicationClient::CloseFile(lldb::user_id_t fd, 3057 Status &error) { 3058 lldb_private::StreamString stream; 3059 stream.Printf("vFile:close:%x", (int)fd); 3060 StringExtractorGDBRemote response; 3061 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3062 PacketResult::Success) { 3063 return ParseHostIOPacketResponse(response, -1, error) == 0; 3064 } 3065 return false; 3066 } 3067 3068 std::optional<GDBRemoteFStatData> 3069 GDBRemoteCommunicationClient::FStat(lldb::user_id_t fd) { 3070 lldb_private::StreamString stream; 3071 stream.Printf("vFile:fstat:%" PRIx64, fd); 3072 StringExtractorGDBRemote response; 3073 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3074 PacketResult::Success) { 3075 if (response.GetChar() != 'F') 3076 return std::nullopt; 3077 int64_t size = response.GetS64(-1, 16); 3078 if (size > 0 && response.GetChar() == ';') { 3079 std::string buffer; 3080 if (response.GetEscapedBinaryData(buffer)) { 3081 GDBRemoteFStatData out; 3082 if (buffer.size() != sizeof(out)) 3083 return std::nullopt; 3084 memcpy(&out, buffer.data(), sizeof(out)); 3085 return out; 3086 } 3087 } 3088 } 3089 return std::nullopt; 3090 } 3091 3092 std::optional<GDBRemoteFStatData> 3093 GDBRemoteCommunicationClient::Stat(const lldb_private::FileSpec &file_spec) { 3094 Status error; 3095 lldb::user_id_t fd = OpenFile(file_spec, File::eOpenOptionReadOnly, 0, error); 3096 if (fd == UINT64_MAX) 3097 return std::nullopt; 3098 std::optional<GDBRemoteFStatData> st = FStat(fd); 3099 CloseFile(fd, error); 3100 return st; 3101 } 3102 3103 // Extension of host I/O packets to get the file size. 3104 lldb::user_id_t GDBRemoteCommunicationClient::GetFileSize( 3105 const lldb_private::FileSpec &file_spec) { 3106 if (m_supports_vFileSize) { 3107 std::string path(file_spec.GetPath(false)); 3108 lldb_private::StreamString stream; 3109 stream.PutCString("vFile:size:"); 3110 stream.PutStringAsRawHex8(path); 3111 StringExtractorGDBRemote response; 3112 if (SendPacketAndWaitForResponse(stream.GetString(), response) != 3113 PacketResult::Success) 3114 return UINT64_MAX; 3115 3116 if (!response.IsUnsupportedResponse()) { 3117 if (response.GetChar() != 'F') 3118 return UINT64_MAX; 3119 uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX); 3120 return retcode; 3121 } 3122 m_supports_vFileSize = false; 3123 } 3124 3125 // Fallback to fstat. 3126 std::optional<GDBRemoteFStatData> st = Stat(file_spec); 3127 return st ? st->gdb_st_size : UINT64_MAX; 3128 } 3129 3130 void GDBRemoteCommunicationClient::AutoCompleteDiskFileOrDirectory( 3131 CompletionRequest &request, bool only_dir) { 3132 lldb_private::StreamString stream; 3133 stream.PutCString("qPathComplete:"); 3134 stream.PutHex32(only_dir ? 1 : 0); 3135 stream.PutChar(','); 3136 stream.PutStringAsRawHex8(request.GetCursorArgumentPrefix()); 3137 StringExtractorGDBRemote response; 3138 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3139 PacketResult::Success) { 3140 StreamString strm; 3141 char ch = response.GetChar(); 3142 if (ch != 'M') 3143 return; 3144 while (response.Peek()) { 3145 strm.Clear(); 3146 while ((ch = response.GetHexU8(0, false)) != '\0') 3147 strm.PutChar(ch); 3148 request.AddCompletion(strm.GetString()); 3149 if (response.GetChar() != ',') 3150 break; 3151 } 3152 } 3153 } 3154 3155 Status 3156 GDBRemoteCommunicationClient::GetFilePermissions(const FileSpec &file_spec, 3157 uint32_t &file_permissions) { 3158 if (m_supports_vFileMode) { 3159 std::string path{file_spec.GetPath(false)}; 3160 Status error; 3161 lldb_private::StreamString stream; 3162 stream.PutCString("vFile:mode:"); 3163 stream.PutStringAsRawHex8(path); 3164 StringExtractorGDBRemote response; 3165 if (SendPacketAndWaitForResponse(stream.GetString(), response) != 3166 PacketResult::Success) { 3167 error.SetErrorStringWithFormat("failed to send '%s' packet", 3168 stream.GetData()); 3169 return error; 3170 } 3171 if (!response.IsUnsupportedResponse()) { 3172 if (response.GetChar() != 'F') { 3173 error.SetErrorStringWithFormat("invalid response to '%s' packet", 3174 stream.GetData()); 3175 } else { 3176 const uint32_t mode = response.GetS32(-1, 16); 3177 if (static_cast<int32_t>(mode) == -1) { 3178 if (response.GetChar() == ',') { 3179 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3180 if (response_errno > 0) 3181 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3182 else 3183 error.SetErrorToGenericError(); 3184 } else 3185 error.SetErrorToGenericError(); 3186 } else { 3187 file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO); 3188 } 3189 } 3190 return error; 3191 } else { // response.IsUnsupportedResponse() 3192 m_supports_vFileMode = false; 3193 } 3194 } 3195 3196 // Fallback to fstat. 3197 if (std::optional<GDBRemoteFStatData> st = Stat(file_spec)) { 3198 file_permissions = st->gdb_st_mode & (S_IRWXU | S_IRWXG | S_IRWXO); 3199 return Status(); 3200 } 3201 return Status("fstat failed"); 3202 } 3203 3204 uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd, 3205 uint64_t offset, void *dst, 3206 uint64_t dst_len, 3207 Status &error) { 3208 lldb_private::StreamString stream; 3209 stream.Printf("vFile:pread:%x,%" PRIx64 ",%" PRIx64, (int)fd, dst_len, 3210 offset); 3211 StringExtractorGDBRemote response; 3212 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3213 PacketResult::Success) { 3214 if (response.GetChar() != 'F') 3215 return 0; 3216 int64_t retcode = response.GetS64(-1, 16); 3217 if (retcode == -1) { 3218 error.SetErrorToGenericError(); 3219 if (response.GetChar() == ',') { 3220 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3221 if (response_errno > 0) 3222 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3223 } 3224 return -1; 3225 } 3226 const char next = (response.Peek() ? *response.Peek() : 0); 3227 if (next == ',') 3228 return 0; 3229 if (next == ';') { 3230 response.GetChar(); // skip the semicolon 3231 std::string buffer; 3232 if (response.GetEscapedBinaryData(buffer)) { 3233 const uint64_t data_to_write = 3234 std::min<uint64_t>(dst_len, buffer.size()); 3235 if (data_to_write > 0) 3236 memcpy(dst, &buffer[0], data_to_write); 3237 return data_to_write; 3238 } 3239 } 3240 } 3241 return 0; 3242 } 3243 3244 uint64_t GDBRemoteCommunicationClient::WriteFile(lldb::user_id_t fd, 3245 uint64_t offset, 3246 const void *src, 3247 uint64_t src_len, 3248 Status &error) { 3249 lldb_private::StreamGDBRemote stream; 3250 stream.Printf("vFile:pwrite:%x,%" PRIx64 ",", (int)fd, offset); 3251 stream.PutEscapedBytes(src, src_len); 3252 StringExtractorGDBRemote response; 3253 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3254 PacketResult::Success) { 3255 if (response.GetChar() != 'F') { 3256 error.SetErrorStringWithFormat("write file failed"); 3257 return 0; 3258 } 3259 int64_t bytes_written = response.GetS64(-1, 16); 3260 if (bytes_written == -1) { 3261 error.SetErrorToGenericError(); 3262 if (response.GetChar() == ',') { 3263 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3264 if (response_errno > 0) 3265 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3266 } 3267 return -1; 3268 } 3269 return bytes_written; 3270 } else { 3271 error.SetErrorString("failed to send vFile:pwrite packet"); 3272 } 3273 return 0; 3274 } 3275 3276 Status GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src, 3277 const FileSpec &dst) { 3278 std::string src_path{src.GetPath(false)}, dst_path{dst.GetPath(false)}; 3279 Status error; 3280 lldb_private::StreamGDBRemote stream; 3281 stream.PutCString("vFile:symlink:"); 3282 // the unix symlink() command reverses its parameters where the dst if first, 3283 // so we follow suit here 3284 stream.PutStringAsRawHex8(dst_path); 3285 stream.PutChar(','); 3286 stream.PutStringAsRawHex8(src_path); 3287 StringExtractorGDBRemote response; 3288 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3289 PacketResult::Success) { 3290 if (response.GetChar() == 'F') { 3291 uint32_t result = response.GetHexMaxU32(false, UINT32_MAX); 3292 if (result != 0) { 3293 error.SetErrorToGenericError(); 3294 if (response.GetChar() == ',') { 3295 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3296 if (response_errno > 0) 3297 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3298 } 3299 } 3300 } else { 3301 // Should have returned with 'F<result>[,<errno>]' 3302 error.SetErrorStringWithFormat("symlink failed"); 3303 } 3304 } else { 3305 error.SetErrorString("failed to send vFile:symlink packet"); 3306 } 3307 return error; 3308 } 3309 3310 Status GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec) { 3311 std::string path{file_spec.GetPath(false)}; 3312 Status error; 3313 lldb_private::StreamGDBRemote stream; 3314 stream.PutCString("vFile:unlink:"); 3315 // the unix symlink() command reverses its parameters where the dst if first, 3316 // so we follow suit here 3317 stream.PutStringAsRawHex8(path); 3318 StringExtractorGDBRemote response; 3319 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3320 PacketResult::Success) { 3321 if (response.GetChar() == 'F') { 3322 uint32_t result = response.GetHexMaxU32(false, UINT32_MAX); 3323 if (result != 0) { 3324 error.SetErrorToGenericError(); 3325 if (response.GetChar() == ',') { 3326 int response_errno = gdb_errno_to_system(response.GetS32(-1, 16)); 3327 if (response_errno > 0) 3328 error.SetError(response_errno, lldb::eErrorTypePOSIX); 3329 } 3330 } 3331 } else { 3332 // Should have returned with 'F<result>[,<errno>]' 3333 error.SetErrorStringWithFormat("unlink failed"); 3334 } 3335 } else { 3336 error.SetErrorString("failed to send vFile:unlink packet"); 3337 } 3338 return error; 3339 } 3340 3341 // Extension of host I/O packets to get whether a file exists. 3342 bool GDBRemoteCommunicationClient::GetFileExists( 3343 const lldb_private::FileSpec &file_spec) { 3344 if (m_supports_vFileExists) { 3345 std::string path(file_spec.GetPath(false)); 3346 lldb_private::StreamString stream; 3347 stream.PutCString("vFile:exists:"); 3348 stream.PutStringAsRawHex8(path); 3349 StringExtractorGDBRemote response; 3350 if (SendPacketAndWaitForResponse(stream.GetString(), response) != 3351 PacketResult::Success) 3352 return false; 3353 if (!response.IsUnsupportedResponse()) { 3354 if (response.GetChar() != 'F') 3355 return false; 3356 if (response.GetChar() != ',') 3357 return false; 3358 bool retcode = (response.GetChar() != '0'); 3359 return retcode; 3360 } else 3361 m_supports_vFileExists = false; 3362 } 3363 3364 // Fallback to open. 3365 Status error; 3366 lldb::user_id_t fd = OpenFile(file_spec, File::eOpenOptionReadOnly, 0, error); 3367 if (fd == UINT64_MAX) 3368 return false; 3369 CloseFile(fd, error); 3370 return true; 3371 } 3372 3373 bool GDBRemoteCommunicationClient::CalculateMD5( 3374 const lldb_private::FileSpec &file_spec, uint64_t &high, uint64_t &low) { 3375 std::string path(file_spec.GetPath(false)); 3376 lldb_private::StreamString stream; 3377 stream.PutCString("vFile:MD5:"); 3378 stream.PutStringAsRawHex8(path); 3379 StringExtractorGDBRemote response; 3380 if (SendPacketAndWaitForResponse(stream.GetString(), response) == 3381 PacketResult::Success) { 3382 if (response.GetChar() != 'F') 3383 return false; 3384 if (response.GetChar() != ',') 3385 return false; 3386 if (response.Peek() && *response.Peek() == 'x') 3387 return false; 3388 low = response.GetHexMaxU64(false, UINT64_MAX); 3389 high = response.GetHexMaxU64(false, UINT64_MAX); 3390 return true; 3391 } 3392 return false; 3393 } 3394 3395 bool GDBRemoteCommunicationClient::AvoidGPackets(ProcessGDBRemote *process) { 3396 // Some targets have issues with g/G packets and we need to avoid using them 3397 if (m_avoid_g_packets == eLazyBoolCalculate) { 3398 if (process) { 3399 m_avoid_g_packets = eLazyBoolNo; 3400 const ArchSpec &arch = process->GetTarget().GetArchitecture(); 3401 if (arch.IsValid() && 3402 arch.GetTriple().getVendor() == llvm::Triple::Apple && 3403 arch.GetTriple().getOS() == llvm::Triple::IOS && 3404 (arch.GetTriple().getArch() == llvm::Triple::aarch64 || 3405 arch.GetTriple().getArch() == llvm::Triple::aarch64_32)) { 3406 m_avoid_g_packets = eLazyBoolYes; 3407 uint32_t gdb_server_version = GetGDBServerProgramVersion(); 3408 if (gdb_server_version != 0) { 3409 const char *gdb_server_name = GetGDBServerProgramName(); 3410 if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0) { 3411 if (gdb_server_version >= 310) 3412 m_avoid_g_packets = eLazyBoolNo; 3413 } 3414 } 3415 } 3416 } 3417 } 3418 return m_avoid_g_packets == eLazyBoolYes; 3419 } 3420 3421 DataBufferSP GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, 3422 uint32_t reg) { 3423 StreamString payload; 3424 payload.Printf("p%x", reg); 3425 StringExtractorGDBRemote response; 3426 if (SendThreadSpecificPacketAndWaitForResponse( 3427 tid, std::move(payload), response) != PacketResult::Success || 3428 !response.IsNormalResponse()) 3429 return nullptr; 3430 3431 WritableDataBufferSP buffer_sp( 3432 new DataBufferHeap(response.GetStringRef().size() / 2, 0)); 3433 response.GetHexBytes(buffer_sp->GetData(), '\xcc'); 3434 return buffer_sp; 3435 } 3436 3437 DataBufferSP GDBRemoteCommunicationClient::ReadAllRegisters(lldb::tid_t tid) { 3438 StreamString payload; 3439 payload.PutChar('g'); 3440 StringExtractorGDBRemote response; 3441 if (SendThreadSpecificPacketAndWaitForResponse( 3442 tid, std::move(payload), response) != PacketResult::Success || 3443 !response.IsNormalResponse()) 3444 return nullptr; 3445 3446 WritableDataBufferSP buffer_sp( 3447 new DataBufferHeap(response.GetStringRef().size() / 2, 0)); 3448 response.GetHexBytes(buffer_sp->GetData(), '\xcc'); 3449 return buffer_sp; 3450 } 3451 3452 bool GDBRemoteCommunicationClient::WriteRegister(lldb::tid_t tid, 3453 uint32_t reg_num, 3454 llvm::ArrayRef<uint8_t> data) { 3455 StreamString payload; 3456 payload.Printf("P%x=", reg_num); 3457 payload.PutBytesAsRawHex8(data.data(), data.size(), 3458 endian::InlHostByteOrder(), 3459 endian::InlHostByteOrder()); 3460 StringExtractorGDBRemote response; 3461 return SendThreadSpecificPacketAndWaitForResponse( 3462 tid, std::move(payload), response) == PacketResult::Success && 3463 response.IsOKResponse(); 3464 } 3465 3466 bool GDBRemoteCommunicationClient::WriteAllRegisters( 3467 lldb::tid_t tid, llvm::ArrayRef<uint8_t> data) { 3468 StreamString payload; 3469 payload.PutChar('G'); 3470 payload.PutBytesAsRawHex8(data.data(), data.size(), 3471 endian::InlHostByteOrder(), 3472 endian::InlHostByteOrder()); 3473 StringExtractorGDBRemote response; 3474 return SendThreadSpecificPacketAndWaitForResponse( 3475 tid, std::move(payload), response) == PacketResult::Success && 3476 response.IsOKResponse(); 3477 } 3478 3479 bool GDBRemoteCommunicationClient::SaveRegisterState(lldb::tid_t tid, 3480 uint32_t &save_id) { 3481 save_id = 0; // Set to invalid save ID 3482 if (m_supports_QSaveRegisterState == eLazyBoolNo) 3483 return false; 3484 3485 m_supports_QSaveRegisterState = eLazyBoolYes; 3486 StreamString payload; 3487 payload.PutCString("QSaveRegisterState"); 3488 StringExtractorGDBRemote response; 3489 if (SendThreadSpecificPacketAndWaitForResponse( 3490 tid, std::move(payload), response) != PacketResult::Success) 3491 return false; 3492 3493 if (response.IsUnsupportedResponse()) 3494 m_supports_QSaveRegisterState = eLazyBoolNo; 3495 3496 const uint32_t response_save_id = response.GetU32(0); 3497 if (response_save_id == 0) 3498 return false; 3499 3500 save_id = response_save_id; 3501 return true; 3502 } 3503 3504 bool GDBRemoteCommunicationClient::RestoreRegisterState(lldb::tid_t tid, 3505 uint32_t save_id) { 3506 // We use the "m_supports_QSaveRegisterState" variable here because the 3507 // QSaveRegisterState and QRestoreRegisterState packets must both be 3508 // supported in order to be useful 3509 if (m_supports_QSaveRegisterState == eLazyBoolNo) 3510 return false; 3511 3512 StreamString payload; 3513 payload.Printf("QRestoreRegisterState:%u", save_id); 3514 StringExtractorGDBRemote response; 3515 if (SendThreadSpecificPacketAndWaitForResponse( 3516 tid, std::move(payload), response) != PacketResult::Success) 3517 return false; 3518 3519 if (response.IsOKResponse()) 3520 return true; 3521 3522 if (response.IsUnsupportedResponse()) 3523 m_supports_QSaveRegisterState = eLazyBoolNo; 3524 return false; 3525 } 3526 3527 bool GDBRemoteCommunicationClient::SyncThreadState(lldb::tid_t tid) { 3528 if (!GetSyncThreadStateSupported()) 3529 return false; 3530 3531 StreamString packet; 3532 StringExtractorGDBRemote response; 3533 packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid); 3534 return SendPacketAndWaitForResponse(packet.GetString(), response) == 3535 GDBRemoteCommunication::PacketResult::Success && 3536 response.IsOKResponse(); 3537 } 3538 3539 llvm::Expected<TraceSupportedResponse> 3540 GDBRemoteCommunicationClient::SendTraceSupported(std::chrono::seconds timeout) { 3541 Log *log = GetLog(GDBRLog::Process); 3542 3543 StreamGDBRemote escaped_packet; 3544 escaped_packet.PutCString("jLLDBTraceSupported"); 3545 3546 StringExtractorGDBRemote response; 3547 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3548 timeout) == 3549 GDBRemoteCommunication::PacketResult::Success) { 3550 if (response.IsErrorResponse()) 3551 return response.GetStatus().ToError(); 3552 if (response.IsUnsupportedResponse()) 3553 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3554 "jLLDBTraceSupported is unsupported"); 3555 3556 return llvm::json::parse<TraceSupportedResponse>(response.Peek(), 3557 "TraceSupportedResponse"); 3558 } 3559 LLDB_LOG(log, "failed to send packet: jLLDBTraceSupported"); 3560 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3561 "failed to send packet: jLLDBTraceSupported"); 3562 } 3563 3564 llvm::Error 3565 GDBRemoteCommunicationClient::SendTraceStop(const TraceStopRequest &request, 3566 std::chrono::seconds timeout) { 3567 Log *log = GetLog(GDBRLog::Process); 3568 3569 StreamGDBRemote escaped_packet; 3570 escaped_packet.PutCString("jLLDBTraceStop:"); 3571 3572 std::string json_string; 3573 llvm::raw_string_ostream os(json_string); 3574 os << toJSON(request); 3575 os.flush(); 3576 3577 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3578 3579 StringExtractorGDBRemote response; 3580 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3581 timeout) == 3582 GDBRemoteCommunication::PacketResult::Success) { 3583 if (response.IsErrorResponse()) 3584 return response.GetStatus().ToError(); 3585 if (response.IsUnsupportedResponse()) 3586 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3587 "jLLDBTraceStop is unsupported"); 3588 if (response.IsOKResponse()) 3589 return llvm::Error::success(); 3590 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3591 "Invalid jLLDBTraceStart response"); 3592 } 3593 LLDB_LOG(log, "failed to send packet: jLLDBTraceStop"); 3594 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3595 "failed to send packet: jLLDBTraceStop '%s'", 3596 escaped_packet.GetData()); 3597 } 3598 3599 llvm::Error 3600 GDBRemoteCommunicationClient::SendTraceStart(const llvm::json::Value ¶ms, 3601 std::chrono::seconds timeout) { 3602 Log *log = GetLog(GDBRLog::Process); 3603 3604 StreamGDBRemote escaped_packet; 3605 escaped_packet.PutCString("jLLDBTraceStart:"); 3606 3607 std::string json_string; 3608 llvm::raw_string_ostream os(json_string); 3609 os << params; 3610 os.flush(); 3611 3612 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3613 3614 StringExtractorGDBRemote response; 3615 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3616 timeout) == 3617 GDBRemoteCommunication::PacketResult::Success) { 3618 if (response.IsErrorResponse()) 3619 return response.GetStatus().ToError(); 3620 if (response.IsUnsupportedResponse()) 3621 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3622 "jLLDBTraceStart is unsupported"); 3623 if (response.IsOKResponse()) 3624 return llvm::Error::success(); 3625 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3626 "Invalid jLLDBTraceStart response"); 3627 } 3628 LLDB_LOG(log, "failed to send packet: jLLDBTraceStart"); 3629 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3630 "failed to send packet: jLLDBTraceStart '%s'", 3631 escaped_packet.GetData()); 3632 } 3633 3634 llvm::Expected<std::string> 3635 GDBRemoteCommunicationClient::SendTraceGetState(llvm::StringRef type, 3636 std::chrono::seconds timeout) { 3637 Log *log = GetLog(GDBRLog::Process); 3638 3639 StreamGDBRemote escaped_packet; 3640 escaped_packet.PutCString("jLLDBTraceGetState:"); 3641 3642 std::string json_string; 3643 llvm::raw_string_ostream os(json_string); 3644 os << toJSON(TraceGetStateRequest{type.str()}); 3645 os.flush(); 3646 3647 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3648 3649 StringExtractorGDBRemote response; 3650 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3651 timeout) == 3652 GDBRemoteCommunication::PacketResult::Success) { 3653 if (response.IsErrorResponse()) 3654 return response.GetStatus().ToError(); 3655 if (response.IsUnsupportedResponse()) 3656 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3657 "jLLDBTraceGetState is unsupported"); 3658 return std::string(response.Peek()); 3659 } 3660 3661 LLDB_LOG(log, "failed to send packet: jLLDBTraceGetState"); 3662 return llvm::createStringError( 3663 llvm::inconvertibleErrorCode(), 3664 "failed to send packet: jLLDBTraceGetState '%s'", 3665 escaped_packet.GetData()); 3666 } 3667 3668 llvm::Expected<std::vector<uint8_t>> 3669 GDBRemoteCommunicationClient::SendTraceGetBinaryData( 3670 const TraceGetBinaryDataRequest &request, std::chrono::seconds timeout) { 3671 Log *log = GetLog(GDBRLog::Process); 3672 3673 StreamGDBRemote escaped_packet; 3674 escaped_packet.PutCString("jLLDBTraceGetBinaryData:"); 3675 3676 std::string json_string; 3677 llvm::raw_string_ostream os(json_string); 3678 os << toJSON(request); 3679 os.flush(); 3680 3681 escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size()); 3682 3683 StringExtractorGDBRemote response; 3684 if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response, 3685 timeout) == 3686 GDBRemoteCommunication::PacketResult::Success) { 3687 if (response.IsErrorResponse()) 3688 return response.GetStatus().ToError(); 3689 std::string data; 3690 response.GetEscapedBinaryData(data); 3691 return std::vector<uint8_t>(data.begin(), data.end()); 3692 } 3693 LLDB_LOG(log, "failed to send packet: jLLDBTraceGetBinaryData"); 3694 return llvm::createStringError( 3695 llvm::inconvertibleErrorCode(), 3696 "failed to send packet: jLLDBTraceGetBinaryData '%s'", 3697 escaped_packet.GetData()); 3698 } 3699 3700 std::optional<QOffsets> GDBRemoteCommunicationClient::GetQOffsets() { 3701 StringExtractorGDBRemote response; 3702 if (SendPacketAndWaitForResponse("qOffsets", response) != 3703 PacketResult::Success) 3704 return std::nullopt; 3705 if (!response.IsNormalResponse()) 3706 return std::nullopt; 3707 3708 QOffsets result; 3709 llvm::StringRef ref = response.GetStringRef(); 3710 const auto &GetOffset = [&] { 3711 addr_t offset; 3712 if (ref.consumeInteger(16, offset)) 3713 return false; 3714 result.offsets.push_back(offset); 3715 return true; 3716 }; 3717 3718 if (ref.consume_front("Text=")) { 3719 result.segments = false; 3720 if (!GetOffset()) 3721 return std::nullopt; 3722 if (!ref.consume_front(";Data=") || !GetOffset()) 3723 return std::nullopt; 3724 if (ref.empty()) 3725 return result; 3726 if (ref.consume_front(";Bss=") && GetOffset() && ref.empty()) 3727 return result; 3728 } else if (ref.consume_front("TextSeg=")) { 3729 result.segments = true; 3730 if (!GetOffset()) 3731 return std::nullopt; 3732 if (ref.empty()) 3733 return result; 3734 if (ref.consume_front(";DataSeg=") && GetOffset() && ref.empty()) 3735 return result; 3736 } 3737 return std::nullopt; 3738 } 3739 3740 bool GDBRemoteCommunicationClient::GetModuleInfo( 3741 const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec, 3742 ModuleSpec &module_spec) { 3743 if (!m_supports_qModuleInfo) 3744 return false; 3745 3746 std::string module_path = module_file_spec.GetPath(false); 3747 if (module_path.empty()) 3748 return false; 3749 3750 StreamString packet; 3751 packet.PutCString("qModuleInfo:"); 3752 packet.PutStringAsRawHex8(module_path); 3753 packet.PutCString(";"); 3754 const auto &triple = arch_spec.GetTriple().getTriple(); 3755 packet.PutStringAsRawHex8(triple); 3756 3757 StringExtractorGDBRemote response; 3758 if (SendPacketAndWaitForResponse(packet.GetString(), response) != 3759 PacketResult::Success) 3760 return false; 3761 3762 if (response.IsErrorResponse()) 3763 return false; 3764 3765 if (response.IsUnsupportedResponse()) { 3766 m_supports_qModuleInfo = false; 3767 return false; 3768 } 3769 3770 llvm::StringRef name; 3771 llvm::StringRef value; 3772 3773 module_spec.Clear(); 3774 module_spec.GetFileSpec() = module_file_spec; 3775 3776 while (response.GetNameColonValue(name, value)) { 3777 if (name == "uuid" || name == "md5") { 3778 StringExtractor extractor(value); 3779 std::string uuid; 3780 extractor.GetHexByteString(uuid); 3781 module_spec.GetUUID().SetFromStringRef(uuid); 3782 } else if (name == "triple") { 3783 StringExtractor extractor(value); 3784 std::string triple; 3785 extractor.GetHexByteString(triple); 3786 module_spec.GetArchitecture().SetTriple(triple.c_str()); 3787 } else if (name == "file_offset") { 3788 uint64_t ival = 0; 3789 if (!value.getAsInteger(16, ival)) 3790 module_spec.SetObjectOffset(ival); 3791 } else if (name == "file_size") { 3792 uint64_t ival = 0; 3793 if (!value.getAsInteger(16, ival)) 3794 module_spec.SetObjectSize(ival); 3795 } else if (name == "file_path") { 3796 StringExtractor extractor(value); 3797 std::string path; 3798 extractor.GetHexByteString(path); 3799 module_spec.GetFileSpec() = FileSpec(path, arch_spec.GetTriple()); 3800 } 3801 } 3802 3803 return true; 3804 } 3805 3806 static std::optional<ModuleSpec> 3807 ParseModuleSpec(StructuredData::Dictionary *dict) { 3808 ModuleSpec result; 3809 if (!dict) 3810 return std::nullopt; 3811 3812 llvm::StringRef string; 3813 uint64_t integer; 3814 3815 if (!dict->GetValueForKeyAsString("uuid", string)) 3816 return std::nullopt; 3817 if (!result.GetUUID().SetFromStringRef(string)) 3818 return std::nullopt; 3819 3820 if (!dict->GetValueForKeyAsInteger("file_offset", integer)) 3821 return std::nullopt; 3822 result.SetObjectOffset(integer); 3823 3824 if (!dict->GetValueForKeyAsInteger("file_size", integer)) 3825 return std::nullopt; 3826 result.SetObjectSize(integer); 3827 3828 if (!dict->GetValueForKeyAsString("triple", string)) 3829 return std::nullopt; 3830 result.GetArchitecture().SetTriple(string); 3831 3832 if (!dict->GetValueForKeyAsString("file_path", string)) 3833 return std::nullopt; 3834 result.GetFileSpec() = FileSpec(string, result.GetArchitecture().GetTriple()); 3835 3836 return result; 3837 } 3838 3839 std::optional<std::vector<ModuleSpec>> 3840 GDBRemoteCommunicationClient::GetModulesInfo( 3841 llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) { 3842 namespace json = llvm::json; 3843 3844 if (!m_supports_jModulesInfo) 3845 return std::nullopt; 3846 3847 json::Array module_array; 3848 for (const FileSpec &module_file_spec : module_file_specs) { 3849 module_array.push_back( 3850 json::Object{{"file", module_file_spec.GetPath(false)}, 3851 {"triple", triple.getTriple()}}); 3852 } 3853 StreamString unescaped_payload; 3854 unescaped_payload.PutCString("jModulesInfo:"); 3855 unescaped_payload.AsRawOstream() << std::move(module_array); 3856 3857 StreamGDBRemote payload; 3858 payload.PutEscapedBytes(unescaped_payload.GetString().data(), 3859 unescaped_payload.GetSize()); 3860 3861 // Increase the timeout for jModulesInfo since this packet can take longer. 3862 ScopedTimeout timeout(*this, std::chrono::seconds(10)); 3863 3864 StringExtractorGDBRemote response; 3865 if (SendPacketAndWaitForResponse(payload.GetString(), response) != 3866 PacketResult::Success || 3867 response.IsErrorResponse()) 3868 return std::nullopt; 3869 3870 if (response.IsUnsupportedResponse()) { 3871 m_supports_jModulesInfo = false; 3872 return std::nullopt; 3873 } 3874 3875 StructuredData::ObjectSP response_object_sp = 3876 StructuredData::ParseJSON(response.GetStringRef()); 3877 if (!response_object_sp) 3878 return std::nullopt; 3879 3880 StructuredData::Array *response_array = response_object_sp->GetAsArray(); 3881 if (!response_array) 3882 return std::nullopt; 3883 3884 std::vector<ModuleSpec> result; 3885 for (size_t i = 0; i < response_array->GetSize(); ++i) { 3886 if (std::optional<ModuleSpec> module_spec = ParseModuleSpec( 3887 response_array->GetItemAtIndex(i)->GetAsDictionary())) 3888 result.push_back(*module_spec); 3889 } 3890 3891 return result; 3892 } 3893 3894 // query the target remote for extended information using the qXfer packet 3895 // 3896 // example: object='features', annex='target.xml' 3897 // return: <xml output> or error 3898 llvm::Expected<std::string> 3899 GDBRemoteCommunicationClient::ReadExtFeature(llvm::StringRef object, 3900 llvm::StringRef annex) { 3901 3902 std::string output; 3903 llvm::raw_string_ostream output_stream(output); 3904 StringExtractorGDBRemote chunk; 3905 3906 uint64_t size = GetRemoteMaxPacketSize(); 3907 if (size == 0) 3908 size = 0x1000; 3909 size = size - 1; // Leave space for the 'm' or 'l' character in the response 3910 int offset = 0; 3911 bool active = true; 3912 3913 // loop until all data has been read 3914 while (active) { 3915 3916 // send query extended feature packet 3917 std::string packet = 3918 ("qXfer:" + object + ":read:" + annex + ":" + 3919 llvm::Twine::utohexstr(offset) + "," + llvm::Twine::utohexstr(size)) 3920 .str(); 3921 3922 GDBRemoteCommunication::PacketResult res = 3923 SendPacketAndWaitForResponse(packet, chunk); 3924 3925 if (res != GDBRemoteCommunication::PacketResult::Success || 3926 chunk.GetStringRef().empty()) { 3927 return llvm::createStringError(llvm::inconvertibleErrorCode(), 3928 "Error sending $qXfer packet"); 3929 } 3930 3931 // check packet code 3932 switch (chunk.GetStringRef()[0]) { 3933 // last chunk 3934 case ('l'): 3935 active = false; 3936 [[fallthrough]]; 3937 3938 // more chunks 3939 case ('m'): 3940 output_stream << chunk.GetStringRef().drop_front(); 3941 offset += chunk.GetStringRef().size() - 1; 3942 break; 3943 3944 // unknown chunk 3945 default: 3946 return llvm::createStringError( 3947 llvm::inconvertibleErrorCode(), 3948 "Invalid continuation code from $qXfer packet"); 3949 } 3950 } 3951 3952 return output_stream.str(); 3953 } 3954 3955 // Notify the target that gdb is prepared to serve symbol lookup requests. 3956 // packet: "qSymbol::" 3957 // reply: 3958 // OK The target does not need to look up any (more) symbols. 3959 // qSymbol:<sym_name> The target requests the value of symbol sym_name (hex 3960 // encoded). 3961 // LLDB may provide the value by sending another qSymbol 3962 // packet 3963 // in the form of"qSymbol:<sym_value>:<sym_name>". 3964 // 3965 // Three examples: 3966 // 3967 // lldb sends: qSymbol:: 3968 // lldb receives: OK 3969 // Remote gdb stub does not need to know the addresses of any symbols, lldb 3970 // does not 3971 // need to ask again in this session. 3972 // 3973 // lldb sends: qSymbol:: 3974 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473 3975 // lldb sends: qSymbol::64697370617463685f71756575655f6f666673657473 3976 // lldb receives: OK 3977 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb does 3978 // not know 3979 // the address at this time. lldb needs to send qSymbol:: again when it has 3980 // more 3981 // solibs loaded. 3982 // 3983 // lldb sends: qSymbol:: 3984 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473 3985 // lldb sends: qSymbol:2bc97554:64697370617463685f71756575655f6f666673657473 3986 // lldb receives: OK 3987 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb says 3988 // that it 3989 // is at address 0x2bc97554. Remote gdb stub sends 'OK' indicating that it 3990 // does not 3991 // need any more symbols. lldb does not need to ask again in this session. 3992 3993 void GDBRemoteCommunicationClient::ServeSymbolLookups( 3994 lldb_private::Process *process) { 3995 // Set to true once we've resolved a symbol to an address for the remote 3996 // stub. If we get an 'OK' response after this, the remote stub doesn't need 3997 // any more symbols and we can stop asking. 3998 bool symbol_response_provided = false; 3999 4000 // Is this the initial qSymbol:: packet? 4001 bool first_qsymbol_query = true; 4002 4003 if (m_supports_qSymbol && !m_qSymbol_requests_done) { 4004 Lock lock(*this); 4005 if (lock) { 4006 StreamString packet; 4007 packet.PutCString("qSymbol::"); 4008 StringExtractorGDBRemote response; 4009 while (SendPacketAndWaitForResponseNoLock(packet.GetString(), response) == 4010 PacketResult::Success) { 4011 if (response.IsOKResponse()) { 4012 if (symbol_response_provided || first_qsymbol_query) { 4013 m_qSymbol_requests_done = true; 4014 } 4015 4016 // We are done serving symbols requests 4017 return; 4018 } 4019 first_qsymbol_query = false; 4020 4021 if (response.IsUnsupportedResponse()) { 4022 // qSymbol is not supported by the current GDB server we are 4023 // connected to 4024 m_supports_qSymbol = false; 4025 return; 4026 } else { 4027 llvm::StringRef response_str(response.GetStringRef()); 4028 if (response_str.startswith("qSymbol:")) { 4029 response.SetFilePos(strlen("qSymbol:")); 4030 std::string symbol_name; 4031 if (response.GetHexByteString(symbol_name)) { 4032 if (symbol_name.empty()) 4033 return; 4034 4035 addr_t symbol_load_addr = LLDB_INVALID_ADDRESS; 4036 lldb_private::SymbolContextList sc_list; 4037 process->GetTarget().GetImages().FindSymbolsWithNameAndType( 4038 ConstString(symbol_name), eSymbolTypeAny, sc_list); 4039 for (const SymbolContext &sc : sc_list) { 4040 if (symbol_load_addr != LLDB_INVALID_ADDRESS) 4041 break; 4042 if (sc.symbol) { 4043 switch (sc.symbol->GetType()) { 4044 case eSymbolTypeInvalid: 4045 case eSymbolTypeAbsolute: 4046 case eSymbolTypeUndefined: 4047 case eSymbolTypeSourceFile: 4048 case eSymbolTypeHeaderFile: 4049 case eSymbolTypeObjectFile: 4050 case eSymbolTypeCommonBlock: 4051 case eSymbolTypeBlock: 4052 case eSymbolTypeLocal: 4053 case eSymbolTypeParam: 4054 case eSymbolTypeVariable: 4055 case eSymbolTypeVariableType: 4056 case eSymbolTypeLineEntry: 4057 case eSymbolTypeLineHeader: 4058 case eSymbolTypeScopeBegin: 4059 case eSymbolTypeScopeEnd: 4060 case eSymbolTypeAdditional: 4061 case eSymbolTypeCompiler: 4062 case eSymbolTypeInstrumentation: 4063 case eSymbolTypeTrampoline: 4064 break; 4065 4066 case eSymbolTypeCode: 4067 case eSymbolTypeResolver: 4068 case eSymbolTypeData: 4069 case eSymbolTypeRuntime: 4070 case eSymbolTypeException: 4071 case eSymbolTypeObjCClass: 4072 case eSymbolTypeObjCMetaClass: 4073 case eSymbolTypeObjCIVar: 4074 case eSymbolTypeReExported: 4075 symbol_load_addr = 4076 sc.symbol->GetLoadAddress(&process->GetTarget()); 4077 break; 4078 } 4079 } 4080 } 4081 // This is the normal path where our symbol lookup was successful 4082 // and we want to send a packet with the new symbol value and see 4083 // if another lookup needs to be done. 4084 4085 // Change "packet" to contain the requested symbol value and name 4086 packet.Clear(); 4087 packet.PutCString("qSymbol:"); 4088 if (symbol_load_addr != LLDB_INVALID_ADDRESS) { 4089 packet.Printf("%" PRIx64, symbol_load_addr); 4090 symbol_response_provided = true; 4091 } else { 4092 symbol_response_provided = false; 4093 } 4094 packet.PutCString(":"); 4095 packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size()); 4096 continue; // go back to the while loop and send "packet" and wait 4097 // for another response 4098 } 4099 } 4100 } 4101 } 4102 // If we make it here, the symbol request packet response wasn't valid or 4103 // our symbol lookup failed so we must abort 4104 return; 4105 4106 } else if (Log *log = GetLog(GDBRLog::Process | GDBRLog::Packets)) { 4107 LLDB_LOGF(log, 4108 "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.", 4109 __FUNCTION__); 4110 } 4111 } 4112 } 4113 4114 StructuredData::Array * 4115 GDBRemoteCommunicationClient::GetSupportedStructuredDataPlugins() { 4116 if (!m_supported_async_json_packets_is_valid) { 4117 // Query the server for the array of supported asynchronous JSON packets. 4118 m_supported_async_json_packets_is_valid = true; 4119 4120 Log *log = GetLog(GDBRLog::Process); 4121 4122 // Poll it now. 4123 StringExtractorGDBRemote response; 4124 if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response) == 4125 PacketResult::Success) { 4126 m_supported_async_json_packets_sp = 4127 StructuredData::ParseJSON(response.GetStringRef()); 4128 if (m_supported_async_json_packets_sp && 4129 !m_supported_async_json_packets_sp->GetAsArray()) { 4130 // We were returned something other than a JSON array. This is 4131 // invalid. Clear it out. 4132 LLDB_LOGF(log, 4133 "GDBRemoteCommunicationClient::%s(): " 4134 "QSupportedAsyncJSONPackets returned invalid " 4135 "result: %s", 4136 __FUNCTION__, response.GetStringRef().data()); 4137 m_supported_async_json_packets_sp.reset(); 4138 } 4139 } else { 4140 LLDB_LOGF(log, 4141 "GDBRemoteCommunicationClient::%s(): " 4142 "QSupportedAsyncJSONPackets unsupported", 4143 __FUNCTION__); 4144 } 4145 4146 if (log && m_supported_async_json_packets_sp) { 4147 StreamString stream; 4148 m_supported_async_json_packets_sp->Dump(stream); 4149 LLDB_LOGF(log, 4150 "GDBRemoteCommunicationClient::%s(): supported async " 4151 "JSON packets: %s", 4152 __FUNCTION__, stream.GetData()); 4153 } 4154 } 4155 4156 return m_supported_async_json_packets_sp 4157 ? m_supported_async_json_packets_sp->GetAsArray() 4158 : nullptr; 4159 } 4160 4161 Status GDBRemoteCommunicationClient::SendSignalsToIgnore( 4162 llvm::ArrayRef<int32_t> signals) { 4163 // Format packet: 4164 // QPassSignals:<hex_sig1>;<hex_sig2>...;<hex_sigN> 4165 auto range = llvm::make_range(signals.begin(), signals.end()); 4166 std::string packet = formatv("QPassSignals:{0:$[;]@(x-2)}", range).str(); 4167 4168 StringExtractorGDBRemote response; 4169 auto send_status = SendPacketAndWaitForResponse(packet, response); 4170 4171 if (send_status != GDBRemoteCommunication::PacketResult::Success) 4172 return Status("Sending QPassSignals packet failed"); 4173 4174 if (response.IsOKResponse()) { 4175 return Status(); 4176 } else { 4177 return Status("Unknown error happened during sending QPassSignals packet."); 4178 } 4179 } 4180 4181 Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData( 4182 llvm::StringRef type_name, const StructuredData::ObjectSP &config_sp) { 4183 Status error; 4184 4185 if (type_name.empty()) { 4186 error.SetErrorString("invalid type_name argument"); 4187 return error; 4188 } 4189 4190 // Build command: Configure{type_name}: serialized config data. 4191 StreamGDBRemote stream; 4192 stream.PutCString("QConfigure"); 4193 stream.PutCString(type_name); 4194 stream.PutChar(':'); 4195 if (config_sp) { 4196 // Gather the plain-text version of the configuration data. 4197 StreamString unescaped_stream; 4198 config_sp->Dump(unescaped_stream); 4199 unescaped_stream.Flush(); 4200 4201 // Add it to the stream in escaped fashion. 4202 stream.PutEscapedBytes(unescaped_stream.GetString().data(), 4203 unescaped_stream.GetSize()); 4204 } 4205 stream.Flush(); 4206 4207 // Send the packet. 4208 StringExtractorGDBRemote response; 4209 auto result = SendPacketAndWaitForResponse(stream.GetString(), response); 4210 if (result == PacketResult::Success) { 4211 // We failed if the config result comes back other than OK. 4212 if (response.GetStringRef() == "OK") { 4213 // Okay! 4214 error.Clear(); 4215 } else { 4216 error.SetErrorStringWithFormatv( 4217 "configuring StructuredData feature {0} failed with error {1}", 4218 type_name, response.GetStringRef()); 4219 } 4220 } else { 4221 // Can we get more data here on the failure? 4222 error.SetErrorStringWithFormatv( 4223 "configuring StructuredData feature {0} failed when sending packet: " 4224 "PacketResult={1}", 4225 type_name, (int)result); 4226 } 4227 return error; 4228 } 4229 4230 void GDBRemoteCommunicationClient::OnRunPacketSent(bool first) { 4231 GDBRemoteClientBase::OnRunPacketSent(first); 4232 m_curr_tid = LLDB_INVALID_THREAD_ID; 4233 } 4234 4235 bool GDBRemoteCommunicationClient::UsesNativeSignals() { 4236 if (m_uses_native_signals == eLazyBoolCalculate) 4237 GetRemoteQSupported(); 4238 if (m_uses_native_signals == eLazyBoolYes) 4239 return true; 4240 4241 // If the remote didn't indicate native-signal support explicitly, 4242 // check whether it is an old version of lldb-server. 4243 return GetThreadSuffixSupported(); 4244 } 4245 4246 llvm::Expected<int> GDBRemoteCommunicationClient::KillProcess(lldb::pid_t pid) { 4247 StringExtractorGDBRemote response; 4248 GDBRemoteCommunication::ScopedTimeout(*this, seconds(3)); 4249 4250 if (SendPacketAndWaitForResponse("k", response, GetPacketTimeout()) != 4251 PacketResult::Success) 4252 return llvm::createStringError(llvm::inconvertibleErrorCode(), 4253 "failed to send k packet"); 4254 4255 char packet_cmd = response.GetChar(0); 4256 if (packet_cmd == 'W' || packet_cmd == 'X') 4257 return response.GetHexU8(); 4258 4259 return llvm::createStringError(llvm::inconvertibleErrorCode(), 4260 "unexpected response to k packet: %s", 4261 response.GetStringRef().str().c_str()); 4262 } 4263