1 //===-- GDBRemoteCommunicationClient.h --------------------------*- 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 #ifndef liblldb_GDBRemoteCommunicationClient_h_ 11 #define liblldb_GDBRemoteCommunicationClient_h_ 12 13 // C Includes 14 // C++ Includes 15 #include <vector> 16 17 // Other libraries and framework includes 18 // Project includes 19 #include "lldb/Core/ArchSpec.h" 20 #include "lldb/Target/Process.h" 21 22 #include "GDBRemoteCommunication.h" 23 24 typedef enum 25 { 26 eBreakpointSoftware = 0, 27 eBreakpointHardware, 28 eWatchpointWrite, 29 eWatchpointRead, 30 eWatchpointReadWrite 31 } GDBStoppointType; 32 33 class GDBRemoteCommunicationClient : public GDBRemoteCommunication 34 { 35 public: 36 //------------------------------------------------------------------ 37 // Constructors and Destructors 38 //------------------------------------------------------------------ 39 GDBRemoteCommunicationClient(bool is_platform); 40 41 ~GDBRemoteCommunicationClient(); 42 43 //------------------------------------------------------------------ 44 // After connecting, send the handshake to the server to make sure 45 // we are communicating with it. 46 //------------------------------------------------------------------ 47 bool 48 HandshakeWithServer (lldb_private::Error *error_ptr); 49 50 PacketResult 51 SendPacketAndWaitForResponse (const char *send_payload, 52 StringExtractorGDBRemote &response, 53 bool send_async); 54 55 PacketResult 56 SendPacketAndWaitForResponse (const char *send_payload, 57 size_t send_length, 58 StringExtractorGDBRemote &response, 59 bool send_async); 60 61 // For packets which specify a range of output to be returned, 62 // return all of the output via a series of request packets of the form 63 // <prefix>0,<size> 64 // <prefix><size>,<size> 65 // <prefix><size>*2,<size> 66 // <prefix><size>*3,<size> 67 // ... 68 // until a "$l..." packet is received, indicating the end. 69 // (size is in hex; this format is used by a standard gdbserver to 70 // return the given portion of the output specified by <prefix>; 71 // for example, "qXfer:libraries-svr4:read::fff,1000" means 72 // "return a chunk of the xml description file for shared 73 // library load addresses, where the chunk starts at offset 0xfff 74 // and continues for 0x1000 bytes"). 75 // Concatenate the resulting server response packets together and 76 // return in response_string. If any packet fails, the return value 77 // indicates that failure and the returned string value is undefined. 78 PacketResult 79 SendPacketsAndConcatenateResponses (const char *send_payload_prefix, 80 std::string &response_string); 81 82 lldb::StateType 83 SendContinuePacketAndWaitForResponse (ProcessGDBRemote *process, 84 const char *packet_payload, 85 size_t packet_length, 86 StringExtractorGDBRemote &response); 87 88 bool 89 GetThreadSuffixSupported (); 90 91 // This packet is usually sent first and the boolean return value 92 // indicates if the packet was send and any response was received 93 // even in the response is UNIMPLEMENTED. If the packet failed to 94 // get a response, then false is returned. This quickly tells us 95 // if we were able to connect and communicate with the remote GDB 96 // server 97 bool 98 QueryNoAckModeSupported (); 99 100 void 101 GetListThreadsInStopReplySupported (); 102 103 bool 104 SendAsyncSignal (int signo); 105 106 bool 107 SendInterrupt (lldb_private::Mutex::Locker &locker, 108 uint32_t seconds_to_wait_for_stop, 109 bool &timed_out); 110 111 lldb::pid_t 112 GetCurrentProcessID (); 113 114 bool 115 GetLaunchSuccess (std::string &error_str); 116 117 uint16_t 118 LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname); 119 120 bool 121 KillSpawnedProcess (lldb::pid_t pid); 122 123 //------------------------------------------------------------------ 124 /// Sends a GDB remote protocol 'A' packet that delivers program 125 /// arguments to the remote server. 126 /// 127 /// @param[in] argv 128 /// A NULL terminated array of const C strings to use as the 129 /// arguments. 130 /// 131 /// @return 132 /// Zero if the response was "OK", a positive value if the 133 /// the response was "Exx" where xx are two hex digits, or 134 /// -1 if the call is unsupported or any other unexpected 135 /// response was received. 136 //------------------------------------------------------------------ 137 int 138 SendArgumentsPacket (const lldb_private::ProcessLaunchInfo &launch_info); 139 140 //------------------------------------------------------------------ 141 /// Sends a "QEnvironment:NAME=VALUE" packet that will build up the 142 /// environment that will get used when launching an application 143 /// in conjunction with the 'A' packet. This function can be called 144 /// multiple times in a row in order to pass on the desired 145 /// environment that the inferior should be launched with. 146 /// 147 /// @param[in] name_equal_value 148 /// A NULL terminated C string that contains a single environment 149 /// in the format "NAME=VALUE". 150 /// 151 /// @return 152 /// Zero if the response was "OK", a positive value if the 153 /// the response was "Exx" where xx are two hex digits, or 154 /// -1 if the call is unsupported or any other unexpected 155 /// response was received. 156 //------------------------------------------------------------------ 157 int 158 SendEnvironmentPacket (char const *name_equal_value); 159 160 int 161 SendLaunchArchPacket (const char *arch); 162 163 int 164 SendLaunchEventDataPacket (const char *data, bool *was_supported = NULL); 165 166 //------------------------------------------------------------------ 167 /// Sends a "vAttach:PID" where PID is in hex. 168 /// 169 /// @param[in] pid 170 /// A process ID for the remote gdb server to attach to. 171 /// 172 /// @param[out] response 173 /// The response received from the gdb server. If the return 174 /// value is zero, \a response will contain a stop reply 175 /// packet. 176 /// 177 /// @return 178 /// Zero if the attach was successful, or an error indicating 179 /// an error code. 180 //------------------------------------------------------------------ 181 int 182 SendAttach (lldb::pid_t pid, 183 StringExtractorGDBRemote& response); 184 185 186 //------------------------------------------------------------------ 187 /// Sets the path to use for stdin/out/err for a process 188 /// that will be launched with the 'A' packet. 189 /// 190 /// @param[in] path 191 /// The path to use for stdin/out/err 192 /// 193 /// @return 194 /// Zero if the for success, or an error code for failure. 195 //------------------------------------------------------------------ 196 int 197 SetSTDIN (char const *path); 198 int 199 SetSTDOUT (char const *path); 200 int 201 SetSTDERR (char const *path); 202 203 //------------------------------------------------------------------ 204 /// Sets the disable ASLR flag to \a enable for a process that will 205 /// be launched with the 'A' packet. 206 /// 207 /// @param[in] enable 208 /// A boolean value indicating whether to disable ASLR or not. 209 /// 210 /// @return 211 /// Zero if the for success, or an error code for failure. 212 //------------------------------------------------------------------ 213 int 214 SetDisableASLR (bool enable); 215 216 //------------------------------------------------------------------ 217 /// Sets the DetachOnError flag to \a enable for the process controlled by the stub. 218 /// 219 /// @param[in] enable 220 /// A boolean value indicating whether to detach on error or not. 221 /// 222 /// @return 223 /// Zero if the for success, or an error code for failure. 224 //------------------------------------------------------------------ 225 int 226 SetDetachOnError (bool enable); 227 228 //------------------------------------------------------------------ 229 /// Sets the working directory to \a path for a process that will 230 /// be launched with the 'A' packet for non platform based 231 /// connections. If this packet is sent to a GDB server that 232 /// implements the platform, it will change the current working 233 /// directory for the platform process. 234 /// 235 /// @param[in] path 236 /// The path to a directory to use when launching our process 237 /// 238 /// @return 239 /// Zero if the for success, or an error code for failure. 240 //------------------------------------------------------------------ 241 int 242 SetWorkingDir (char const *path); 243 244 //------------------------------------------------------------------ 245 /// Gets the current working directory of a remote platform GDB 246 /// server. 247 /// 248 /// @param[out] cwd 249 /// The current working directory on the remote platform. 250 /// 251 /// @return 252 /// Boolean for success 253 //------------------------------------------------------------------ 254 bool 255 GetWorkingDir (std::string &cwd); 256 257 lldb::addr_t 258 AllocateMemory (size_t size, uint32_t permissions); 259 260 bool 261 DeallocateMemory (lldb::addr_t addr); 262 263 lldb_private::Error 264 Detach (bool keep_stopped); 265 266 lldb_private::Error 267 GetMemoryRegionInfo (lldb::addr_t addr, 268 lldb_private::MemoryRegionInfo &range_info); 269 270 lldb_private::Error 271 GetWatchpointSupportInfo (uint32_t &num); 272 273 lldb_private::Error 274 GetWatchpointSupportInfo (uint32_t &num, bool& after); 275 276 lldb_private::Error 277 GetWatchpointsTriggerAfterInstruction (bool &after); 278 279 const lldb_private::ArchSpec & 280 GetHostArchitecture (); 281 282 uint32_t 283 GetHostDefaultPacketTimeout(); 284 285 const lldb_private::ArchSpec & 286 GetProcessArchitecture (); 287 288 void 289 GetRemoteQSupported(); 290 291 bool 292 GetVContSupported (char flavor); 293 294 bool 295 GetpPacketSupported (lldb::tid_t tid); 296 297 bool 298 GetxPacketSupported (); 299 300 bool 301 GetVAttachOrWaitSupported (); 302 303 bool 304 GetSyncThreadStateSupported(); 305 306 void 307 ResetDiscoverableSettings(); 308 309 bool 310 GetHostInfo (bool force = false); 311 312 bool 313 GetOSVersion (uint32_t &major, 314 uint32_t &minor, 315 uint32_t &update); 316 317 bool 318 GetOSBuildString (std::string &s); 319 320 bool 321 GetOSKernelDescription (std::string &s); 322 323 lldb_private::ArchSpec 324 GetSystemArchitecture (); 325 326 bool 327 GetHostname (std::string &s); 328 329 lldb::addr_t 330 GetShlibInfoAddr(); 331 332 bool 333 GetSupportsThreadSuffix (); 334 335 bool 336 GetProcessInfo (lldb::pid_t pid, 337 lldb_private::ProcessInstanceInfo &process_info); 338 339 uint32_t 340 FindProcesses (const lldb_private::ProcessInstanceInfoMatch &process_match_info, 341 lldb_private::ProcessInstanceInfoList &process_infos); 342 343 bool 344 GetUserName (uint32_t uid, std::string &name); 345 346 bool 347 GetGroupName (uint32_t gid, std::string &name); 348 349 bool 350 HasFullVContSupport () 351 { 352 return GetVContSupported ('A'); 353 } 354 355 bool 356 HasAnyVContSupport () 357 { 358 return GetVContSupported ('a'); 359 } 360 361 bool 362 GetStopReply (StringExtractorGDBRemote &response); 363 364 bool 365 GetThreadStopInfo (lldb::tid_t tid, 366 StringExtractorGDBRemote &response); 367 368 bool 369 SupportsGDBStoppointPacket (GDBStoppointType type) 370 { 371 switch (type) 372 { 373 case eBreakpointSoftware: return m_supports_z0; 374 case eBreakpointHardware: return m_supports_z1; 375 case eWatchpointWrite: return m_supports_z2; 376 case eWatchpointRead: return m_supports_z3; 377 case eWatchpointReadWrite: return m_supports_z4; 378 } 379 return false; 380 } 381 uint8_t 382 SendGDBStoppointTypePacket (GDBStoppointType type, // Type of breakpoint or watchpoint 383 bool insert, // Insert or remove? 384 lldb::addr_t addr, // Address of breakpoint or watchpoint 385 uint32_t length); // Byte Size of breakpoint or watchpoint 386 387 void 388 TestPacketSpeed (const uint32_t num_packets); 389 390 // This packet is for testing the speed of the interface only. Both 391 // the client and server need to support it, but this allows us to 392 // measure the packet speed without any other work being done on the 393 // other end and avoids any of that work affecting the packet send 394 // and response times. 395 bool 396 SendSpeedTestPacket (uint32_t send_size, 397 uint32_t recv_size); 398 399 bool 400 SetCurrentThread (uint64_t tid); 401 402 bool 403 SetCurrentThreadForRun (uint64_t tid); 404 405 bool 406 GetQXferAuxvReadSupported (); 407 408 bool 409 GetQXferLibrariesReadSupported (); 410 411 bool 412 GetQXferLibrariesSVR4ReadSupported (); 413 414 uint64_t 415 GetRemoteMaxPacketSize(); 416 417 bool 418 GetAugmentedLibrariesSVR4ReadSupported (); 419 420 lldb_private::LazyBool 421 SupportsAllocDeallocMemory () // const 422 { 423 // Uncomment this to have lldb pretend the debug server doesn't respond to alloc/dealloc memory packets. 424 // m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo; 425 return m_supports_alloc_dealloc_memory; 426 } 427 428 size_t 429 GetCurrentThreadIDs (std::vector<lldb::tid_t> &thread_ids, 430 bool &sequence_mutex_unavailable); 431 432 bool 433 GetInterruptWasSent () const 434 { 435 return m_interrupt_sent; 436 } 437 438 lldb::user_id_t 439 OpenFile (const lldb_private::FileSpec& file_spec, 440 uint32_t flags, 441 mode_t mode, 442 lldb_private::Error &error); 443 444 bool 445 CloseFile (lldb::user_id_t fd, 446 lldb_private::Error &error); 447 448 lldb::user_id_t 449 GetFileSize (const lldb_private::FileSpec& file_spec); 450 451 lldb_private::Error 452 GetFilePermissions(const char *path, uint32_t &file_permissions); 453 454 lldb_private::Error 455 SetFilePermissions(const char *path, uint32_t file_permissions); 456 457 uint64_t 458 ReadFile (lldb::user_id_t fd, 459 uint64_t offset, 460 void *dst, 461 uint64_t dst_len, 462 lldb_private::Error &error); 463 464 uint64_t 465 WriteFile (lldb::user_id_t fd, 466 uint64_t offset, 467 const void* src, 468 uint64_t src_len, 469 lldb_private::Error &error); 470 471 lldb_private::Error 472 CreateSymlink (const char *src, 473 const char *dst); 474 475 lldb_private::Error 476 Unlink (const char *path); 477 478 lldb_private::Error 479 MakeDirectory (const char *path, 480 uint32_t mode); 481 482 bool 483 GetFileExists (const lldb_private::FileSpec& file_spec); 484 485 lldb_private::Error 486 RunShellCommand (const char *command, // Shouldn't be NULL 487 const char *working_dir, // Pass NULL to use the current working directory 488 int *status_ptr, // Pass NULL if you don't want the process exit status 489 int *signo_ptr, // Pass NULL if you don't want the signal that caused the process to exit 490 std::string *command_output, // Pass NULL if you don't want the command output 491 uint32_t timeout_sec); // Timeout in seconds to wait for shell program to finish 492 493 bool 494 CalculateMD5 (const lldb_private::FileSpec& file_spec, 495 uint64_t &high, 496 uint64_t &low); 497 498 std::string 499 HarmonizeThreadIdsForProfileData (ProcessGDBRemote *process, 500 StringExtractorGDBRemote &inputStringExtractor); 501 502 bool 503 ReadRegister(lldb::tid_t tid, 504 uint32_t reg_num, 505 StringExtractorGDBRemote &response); 506 507 bool 508 ReadAllRegisters (lldb::tid_t tid, 509 StringExtractorGDBRemote &response); 510 511 bool 512 SaveRegisterState (lldb::tid_t tid, uint32_t &save_id); 513 514 bool 515 RestoreRegisterState (lldb::tid_t tid, uint32_t save_id); 516 517 const char * 518 GetGDBServerProgramName(); 519 520 uint32_t 521 GetGDBServerProgramVersion(); 522 523 bool 524 AvoidGPackets(ProcessGDBRemote *process); 525 526 bool 527 GetThreadExtendedInfoSupported(); 528 529 protected: 530 531 PacketResult 532 SendPacketAndWaitForResponseNoLock (const char *payload, 533 size_t payload_length, 534 StringExtractorGDBRemote &response); 535 536 bool 537 GetCurrentProcessInfo (); 538 539 bool 540 GetGDBServerVersion(); 541 542 //------------------------------------------------------------------ 543 // Classes that inherit from GDBRemoteCommunicationClient can see and modify these 544 //------------------------------------------------------------------ 545 lldb_private::LazyBool m_supports_not_sending_acks; 546 lldb_private::LazyBool m_supports_thread_suffix; 547 lldb_private::LazyBool m_supports_threads_in_stop_reply; 548 lldb_private::LazyBool m_supports_vCont_all; 549 lldb_private::LazyBool m_supports_vCont_any; 550 lldb_private::LazyBool m_supports_vCont_c; 551 lldb_private::LazyBool m_supports_vCont_C; 552 lldb_private::LazyBool m_supports_vCont_s; 553 lldb_private::LazyBool m_supports_vCont_S; 554 lldb_private::LazyBool m_qHostInfo_is_valid; 555 lldb_private::LazyBool m_curr_pid_is_valid; 556 lldb_private::LazyBool m_qProcessInfo_is_valid; 557 lldb_private::LazyBool m_qGDBServerVersion_is_valid; 558 lldb_private::LazyBool m_supports_alloc_dealloc_memory; 559 lldb_private::LazyBool m_supports_memory_region_info; 560 lldb_private::LazyBool m_supports_watchpoint_support_info; 561 lldb_private::LazyBool m_supports_detach_stay_stopped; 562 lldb_private::LazyBool m_watchpoints_trigger_after_instruction; 563 lldb_private::LazyBool m_attach_or_wait_reply; 564 lldb_private::LazyBool m_prepare_for_reg_writing_reply; 565 lldb_private::LazyBool m_supports_p; 566 lldb_private::LazyBool m_supports_x; 567 lldb_private::LazyBool m_avoid_g_packets; 568 lldb_private::LazyBool m_supports_QSaveRegisterState; 569 lldb_private::LazyBool m_supports_qXfer_auxv_read; 570 lldb_private::LazyBool m_supports_qXfer_libraries_read; 571 lldb_private::LazyBool m_supports_qXfer_libraries_svr4_read; 572 lldb_private::LazyBool m_supports_augmented_libraries_svr4_read; 573 lldb_private::LazyBool m_supports_jThreadExtendedInfo; 574 575 bool 576 m_supports_qProcessInfoPID:1, 577 m_supports_qfProcessInfo:1, 578 m_supports_qUserName:1, 579 m_supports_qGroupName:1, 580 m_supports_qThreadStopInfo:1, 581 m_supports_z0:1, 582 m_supports_z1:1, 583 m_supports_z2:1, 584 m_supports_z3:1, 585 m_supports_z4:1, 586 m_supports_QEnvironment:1, 587 m_supports_QEnvironmentHexEncoded:1; 588 589 lldb::pid_t m_curr_pid; 590 lldb::tid_t m_curr_tid; // Current gdb remote protocol thread index for all other operations 591 lldb::tid_t m_curr_tid_run; // Current gdb remote protocol thread index for continue, step, etc 592 593 594 uint32_t m_num_supported_hardware_watchpoints; 595 596 // If we need to send a packet while the target is running, the m_async_XXX 597 // member variables take care of making this happen. 598 lldb_private::Mutex m_async_mutex; 599 lldb_private::Predicate<bool> m_async_packet_predicate; 600 std::string m_async_packet; 601 PacketResult m_async_result; 602 StringExtractorGDBRemote m_async_response; 603 int m_async_signal; // We were asked to deliver a signal to the inferior process. 604 bool m_interrupt_sent; 605 std::string m_partial_profile_data; 606 std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map; 607 608 lldb_private::ArchSpec m_host_arch; 609 lldb_private::ArchSpec m_process_arch; 610 uint32_t m_os_version_major; 611 uint32_t m_os_version_minor; 612 uint32_t m_os_version_update; 613 std::string m_os_build; 614 std::string m_os_kernel; 615 std::string m_hostname; 616 std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if qGDBServerVersion is not supported 617 uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if qGDBServerVersion is not supported 618 uint32_t m_default_packet_timeout; 619 uint64_t m_max_packet_size; // as returned by qSupported 620 621 bool 622 DecodeProcessInfoResponse (StringExtractorGDBRemote &response, 623 lldb_private::ProcessInstanceInfo &process_info); 624 private: 625 //------------------------------------------------------------------ 626 // For GDBRemoteCommunicationClient only 627 //------------------------------------------------------------------ 628 DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunicationClient); 629 }; 630 631 #endif // liblldb_GDBRemoteCommunicationClient_h_ 632