lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.h

   1 //===-- GDBRemoteCommunicationServerLLGS.h ----------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H
  10 #define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H
  11
  12 #include <mutex>
  13 #include <unordered_map>
  14 #include <unordered_set>
  15
  16 #include "lldb/Core/Communication.h"
  17 #include "lldb/Host/MainLoop.h"
  18 #include "lldb/Host/common/NativeProcessProtocol.h"
  19 #include "lldb/Utility/RegisterValue.h"
  20 #include "lldb/lldb-private-forward.h"
  21
  22 #include "GDBRemoteCommunicationServerCommon.h"
  23
  24 class StringExtractorGDBRemote;
  25
  26 namespace lldb_private {
  27
  28 namespace process_gdb_remote {
  29
  30 class ProcessGDBRemote;
  31
  32 class GDBRemoteCommunicationServerLLGS
  33     : public GDBRemoteCommunicationServerCommon,
  34       public NativeProcessProtocol::NativeDelegate {
  35 public:
  36   // Constructors and Destructors
  37   GDBRemoteCommunicationServerLLGS(
  38       MainLoop &mainloop,
  39       NativeProcessProtocol::Manager &process_manager);
  40
  41   void SetLaunchInfo(const ProcessLaunchInfo &info);
  42
  43   /// Launch a process with the current launch settings.
  44   ///
  45   /// This method supports running an lldb-gdbserver or similar
  46   /// server in a situation where the startup code has been provided
  47   /// with all the information for a child process to be launched.
  48   ///
  49   /// \return
  50   ///     An Status object indicating the success or failure of the
  51   ///     launch.
  52   Status LaunchProcess() override;
  53
  54   /// Attach to a process.
  55   ///
  56   /// This method supports attaching llgs to a process accessible via the
  57   /// configured Platform.
  58   ///
  59   /// \return
  60   ///     An Status object indicating the success or failure of the
  61   ///     attach operation.
  62   Status AttachToProcess(lldb::pid_t pid);
  63
  64   /// Wait to attach to a process with a given name.
  65   ///
  66   /// This method supports waiting for the next instance of a process
  67   /// with a given name and attaching llgs to that via the configured
  68   /// Platform.
  69   ///
  70   /// \return
  71   ///     An Status object indicating the success or failure of the
  72   ///     attach operation.
  73   Status AttachWaitProcess(llvm::StringRef process_name, bool include_existing);
  74
  75   // NativeProcessProtocol::NativeDelegate overrides
  76   void InitializeDelegate(NativeProcessProtocol *process) override;
  77
  78   void ProcessStateChanged(NativeProcessProtocol *process,
  79                            lldb::StateType state) override;
  80
  81   void DidExec(NativeProcessProtocol *process) override;
  82
  83   void
  84   NewSubprocess(NativeProcessProtocol *parent_process,
  85                 std::unique_ptr<NativeProcessProtocol> child_process) override;
  86
  87   Status InitializeConnection(std::unique_ptr<Connection> connection);
  88
  89   struct DebuggedProcess {
  90     enum class Flag {
  91       vkilled = (1u << 0),
  92
  93       LLVM_MARK_AS_BITMASK_ENUM(vkilled)
  94     };
  95
  96     std::unique_ptr<NativeProcessProtocol> process_up;
  97     Flag flags;
  98   };
  99
 100 protected:
 101   MainLoop &m_mainloop;
 102   MainLoop::ReadHandleUP m_network_handle_up;
 103   NativeProcessProtocol::Manager &m_process_manager;
 104   lldb::tid_t m_current_tid = LLDB_INVALID_THREAD_ID;
 105   lldb::tid_t m_continue_tid = LLDB_INVALID_THREAD_ID;
 106   NativeProcessProtocol *m_current_process;
 107   NativeProcessProtocol *m_continue_process;
 108   std::recursive_mutex m_debugged_process_mutex;
 109   std::unordered_map<lldb::pid_t, DebuggedProcess> m_debugged_processes;
 110
 111   Communication m_stdio_communication;
 112   MainLoop::ReadHandleUP m_stdio_handle_up;
 113
 114   llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> m_xfer_buffer_map;
 115   std::mutex m_saved_registers_mutex;
 116   std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
 117   uint32_t m_next_saved_registers_id = 1;
 118   bool m_thread_suffix_supported = false;
 119   bool m_list_threads_in_stop_reply = false;
 120   bool m_non_stop = false;
 121   bool m_disabling_non_stop = false;
 122   std::deque<std::string> m_stdio_notification_queue;
 123   std::deque<std::string> m_stop_notification_queue;
 124
 125   NativeProcessProtocol::Extension m_extensions_supported = {};
 126
 127   // Typically we would use a SmallVector for this data but in this context we
 128   // don't know how much data we're recieving so we would have to heap allocate
 129   // a lot, or have a very large stack frame. So it's a member instead.
 130   uint8_t m_reg_bytes[RegisterValue::kMaxRegisterByteSize];
 131
 132   PacketResult SendONotification(const char *buffer, uint32_t len);
 133
 134   PacketResult SendWResponse(NativeProcessProtocol *process);
 135
 136   StreamString PrepareStopReplyPacketForThread(NativeThreadProtocol &thread);
 137
 138   PacketResult SendStopReplyPacketForThread(NativeProcessProtocol &process,
 139                                             lldb::tid_t tid,
 140                                             bool force_synchronous);
 141
 142   PacketResult SendStopReasonForState(NativeProcessProtocol &process,
 143                                       lldb::StateType process_state,
 144                                       bool force_synchronous);
 145
 146   void EnqueueStopReplyPackets(lldb::tid_t thread_to_skip);
 147
 148   PacketResult Handle_k(StringExtractorGDBRemote &packet);
 149
 150   PacketResult Handle_vKill(StringExtractorGDBRemote &packet);
 151
 152   PacketResult Handle_qProcessInfo(StringExtractorGDBRemote &packet);
 153
 154   PacketResult Handle_qC(StringExtractorGDBRemote &packet);
 155
 156   PacketResult Handle_QSetDisableASLR(StringExtractorGDBRemote &packet);
 157
 158   PacketResult Handle_QSetWorkingDir(StringExtractorGDBRemote &packet);
 159
 160   PacketResult Handle_qGetWorkingDir(StringExtractorGDBRemote &packet);
 161
 162   PacketResult Handle_QThreadSuffixSupported(StringExtractorGDBRemote &packet);
 163
 164   PacketResult Handle_QListThreadsInStopReply(StringExtractorGDBRemote &packet);
 165
 166   PacketResult ResumeProcess(NativeProcessProtocol &process,
 167                              const ResumeActionList &actions);
 168
 169   PacketResult Handle_C(StringExtractorGDBRemote &packet);
 170
 171   PacketResult Handle_c(StringExtractorGDBRemote &packet);
 172
 173   PacketResult Handle_vCont(StringExtractorGDBRemote &packet);
 174
 175   PacketResult Handle_vCont_actions(StringExtractorGDBRemote &packet);
 176
 177   PacketResult Handle_stop_reason(StringExtractorGDBRemote &packet);
 178
 179   PacketResult Handle_qRegisterInfo(StringExtractorGDBRemote &packet);
 180
 181   void AddProcessThreads(StreamGDBRemote &response,
 182                          NativeProcessProtocol &process, bool &had_any);
 183
 184   PacketResult Handle_qfThreadInfo(StringExtractorGDBRemote &packet);
 185
 186   PacketResult Handle_qsThreadInfo(StringExtractorGDBRemote &packet);
 187
 188   PacketResult Handle_p(StringExtractorGDBRemote &packet);
 189
 190   PacketResult Handle_P(StringExtractorGDBRemote &packet);
 191
 192   PacketResult Handle_H(StringExtractorGDBRemote &packet);
 193
 194   PacketResult Handle_I(StringExtractorGDBRemote &packet);
 195
 196   PacketResult Handle_interrupt(StringExtractorGDBRemote &packet);
 197
 198   // Handles $m and $x packets.
 199   PacketResult Handle_memory_read(StringExtractorGDBRemote &packet);
 200
 201   PacketResult Handle_M(StringExtractorGDBRemote &packet);
 202   PacketResult Handle__M(StringExtractorGDBRemote &packet);
 203   PacketResult Handle__m(StringExtractorGDBRemote &packet);
 204
 205   PacketResult
 206   Handle_qMemoryRegionInfoSupported(StringExtractorGDBRemote &packet);
 207
 208   PacketResult Handle_qMemoryRegionInfo(StringExtractorGDBRemote &packet);
 209
 210   PacketResult Handle_Z(StringExtractorGDBRemote &packet);
 211
 212   PacketResult Handle_z(StringExtractorGDBRemote &packet);
 213
 214   PacketResult Handle_s(StringExtractorGDBRemote &packet);
 215
 216   PacketResult Handle_qXfer(StringExtractorGDBRemote &packet);
 217
 218   PacketResult Handle_QSaveRegisterState(StringExtractorGDBRemote &packet);
 219
 220   PacketResult Handle_jLLDBTraceSupported(StringExtractorGDBRemote &packet);
 221
 222   PacketResult Handle_jLLDBTraceStart(StringExtractorGDBRemote &packet);
 223
 224   PacketResult Handle_jLLDBTraceStop(StringExtractorGDBRemote &packet);
 225
 226   PacketResult Handle_jLLDBTraceGetState(StringExtractorGDBRemote &packet);
 227
 228   PacketResult Handle_jLLDBTraceGetBinaryData(StringExtractorGDBRemote &packet);
 229
 230   PacketResult Handle_QRestoreRegisterState(StringExtractorGDBRemote &packet);
 231
 232   PacketResult Handle_vAttach(StringExtractorGDBRemote &packet);
 233
 234   PacketResult Handle_vAttachWait(StringExtractorGDBRemote &packet);
 235
 236   PacketResult Handle_qVAttachOrWaitSupported(StringExtractorGDBRemote &packet);
 237
 238   PacketResult Handle_vAttachOrWait(StringExtractorGDBRemote &packet);
 239
 240   PacketResult Handle_vRun(StringExtractorGDBRemote &packet);
 241
 242   PacketResult Handle_D(StringExtractorGDBRemote &packet);
 243
 244   PacketResult Handle_qThreadStopInfo(StringExtractorGDBRemote &packet);
 245
 246   PacketResult Handle_jThreadsInfo(StringExtractorGDBRemote &packet);
 247
 248   PacketResult Handle_qWatchpointSupportInfo(StringExtractorGDBRemote &packet);
 249
 250   PacketResult Handle_qFileLoadAddress(StringExtractorGDBRemote &packet);
 251
 252   PacketResult Handle_QPassSignals(StringExtractorGDBRemote &packet);
 253
 254   PacketResult Handle_qSaveCore(StringExtractorGDBRemote &packet);
 255
 256   PacketResult Handle_QNonStop(StringExtractorGDBRemote &packet);
 257
 258   PacketResult HandleNotificationAck(std::deque<std::string> &queue);
 259
 260   PacketResult Handle_vStdio(StringExtractorGDBRemote &packet);
 261
 262   PacketResult Handle_vStopped(StringExtractorGDBRemote &packet);
 263
 264   PacketResult Handle_vCtrlC(StringExtractorGDBRemote &packet);
 265
 266   PacketResult Handle_g(StringExtractorGDBRemote &packet);
 267
 268   PacketResult Handle_qMemTags(StringExtractorGDBRemote &packet);
 269
 270   PacketResult Handle_QMemTags(StringExtractorGDBRemote &packet);
 271
 272   PacketResult Handle_T(StringExtractorGDBRemote &packet);
 273
 274   void SetCurrentThreadID(lldb::tid_t tid);
 275
 276   lldb::tid_t GetCurrentThreadID() const;
 277
 278   void SetContinueThreadID(lldb::tid_t tid);
 279
 280   lldb::tid_t GetContinueThreadID() const { return m_continue_tid; }
 281
 282   Status SetSTDIOFileDescriptor(int fd);
 283
 284   FileSpec FindModuleFile(const std::string &module_path,
 285                           const ArchSpec &arch) override;
 286
 287   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
 288   ReadXferObject(llvm::StringRef object, llvm::StringRef annex);
 289
 290   static std::string XMLEncodeAttributeValue(llvm::StringRef value);
 291
 292   std::vector<std::string> HandleFeatures(
 293       const llvm::ArrayRef<llvm::StringRef> client_features) override;
 294
 295   // Provide a response for successful continue action, i.e. send "OK"
 296   // in non-stop mode, no response otherwise.
 297   PacketResult SendContinueSuccessResponse();
 298
 299   void AppendThreadIDToResponse(Stream &response, lldb::pid_t pid,
 300                                 lldb::tid_t tid);
 301
 302 private:
 303   llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BuildTargetXml();
 304
 305   void HandleInferiorState_Exited(NativeProcessProtocol *process);
 306
 307   void HandleInferiorState_Stopped(NativeProcessProtocol *process);
 308
 309   NativeThreadProtocol *GetThreadFromSuffix(StringExtractorGDBRemote &packet);
 310
 311   uint32_t GetNextSavedRegistersID();
 312
 313   void MaybeCloseInferiorTerminalConnection();
 314
 315   void ClearProcessSpecificData();
 316
 317   void RegisterPacketHandlers();
 318
 319   void DataAvailableCallback();
 320
 321   void SendProcessOutput();
 322
 323   void StartSTDIOForwarding();
 324
 325   void StopSTDIOForwarding();
 326
 327   // Call SetEnabledExtensions() with appropriate flags on the process.
 328   void SetEnabledExtensions(NativeProcessProtocol &process);
 329
 330   // For GDBRemoteCommunicationServerLLGS only
 331   GDBRemoteCommunicationServerLLGS(const GDBRemoteCommunicationServerLLGS &) =
 332       delete;
 333   const GDBRemoteCommunicationServerLLGS &
 334   operator=(const GDBRemoteCommunicationServerLLGS &) = delete;
 335 };
 336
 337 std::string LLGSArgToURL(llvm::StringRef url_arg, bool reverse_connect);
 338
 339 } // namespace process_gdb_remote
 340 } // namespace lldb_private
 341
 342 #endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECOMMUNICATIONSERVERLLGS_H