source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

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