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