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