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