LLDB mainline
GDBRemoteCommunicationServerLLGS.h
Go to the documentation of this file.
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
17#include "lldb/Host/MainLoop.h"
21
23
25
26namespace lldb_private {
27
28namespace process_gdb_remote {
29
30class ProcessGDBRemote;
31
35public:
36 // Constructors and Destructors
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.
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
79 lldb::StateType state) override;
80
81 void DidExec(NativeProcessProtocol *process) override;
82
83 void
85 std::unique_ptr<NativeProcessProtocol> child_process) override;
86
87 Status InitializeConnection(std::unique_ptr<Connection> connection);
88
90 enum class Flag {
91 vkilled = (1u << 0),
92
94 };
95
96 std::unique_ptr<NativeProcessProtocol> process_up;
98 };
99
100protected:
108 std::recursive_mutex m_debugged_process_mutex;
109 std::unordered_map<lldb::pid_t, DebuggedProcess> m_debugged_processes;
110
113
114 llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> m_xfer_buffer_map;
116 std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
120 bool m_non_stop = false;
122 std::deque<std::string> m_stdio_notification_queue;
123 std::deque<std::string> m_stop_notification_queue;
124
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.
131
132 PacketResult SendONotification(const char *buffer, uint32_t len);
133
135
137
139 lldb::tid_t tid,
140 bool force_synchronous);
141
143 lldb::StateType process_state,
144 bool force_synchronous);
145
146 void EnqueueStopReplyPackets(lldb::tid_t thread_to_skip);
147
149
151
153
155
157
159
161
163
165
167 const ResumeActionList &actions);
168
170
172
174
176
178
180
181 void AddProcessThreads(StreamGDBRemote &response,
182 NativeProcessProtocol &process, bool &had_any);
183
185
187
189
191
193
195
197
198 // Handles $m and $x packets.
200
204
207
209
211
213
215
217
219
221
223
225
227
229
231
233
235
237
239
241
243
245
247
249
251
253
255
257
258 PacketResult HandleNotificationAck(std::deque<std::string> &queue);
259
261
263
265
267
269
271
273
275
277
279
281
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.
298
299 void AppendThreadIDToResponse(Stream &response, lldb::pid_t pid,
300 lldb::tid_t tid);
301
302private:
303 llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> BuildTargetXml();
304
306
308
310
311 uint32_t GetNextSavedRegistersID();
312
314
316
318
320
321 void SendProcessOutput();
322
324
325 void StopSTDIOForwarding();
326
327 // Call SetEnabledExtensions() with appropriate flags on the process.
329
330 // For GDBRemoteCommunicationServerLLGS only
332 delete;
335};
336
337std::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
An architecture specification class.
Definition: ArchSpec.h:31
An abstract communications class.
Definition: Communication.h:39
A file utility class.
Definition: FileSpec.h:56
std::unique_ptr< ReadHandle > ReadHandleUP
Definition: MainLoopBase.h:44
Extension
Extension flag constants, returned by Manager::GetSupportedExtensions() and passed to SetEnabledExten...
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
GDBRemoteCommunicationServerLLGS(const GDBRemoteCommunicationServerLLGS &)=delete
void AddProcessThreads(StreamGDBRemote &response, NativeProcessProtocol &process, bool &had_any)
llvm::StringMap< std::unique_ptr< llvm::MemoryBuffer > > m_xfer_buffer_map
PacketResult SendStopReasonForState(NativeProcessProtocol &process, lldb::StateType process_state, bool force_synchronous)
FileSpec FindModuleFile(const std::string &module_path, const ArchSpec &arch) override
void NewSubprocess(NativeProcessProtocol *parent_process, std::unique_ptr< NativeProcessProtocol > child_process) override
NativeThreadProtocol * GetThreadFromSuffix(StringExtractorGDBRemote &packet)
Status LaunchProcess() override
Launch a process with the current launch settings.
Status AttachWaitProcess(llvm::StringRef process_name, bool include_existing)
Wait to attach to a process with a given name.
const GDBRemoteCommunicationServerLLGS & operator=(const GDBRemoteCommunicationServerLLGS &)=delete
PacketResult ResumeProcess(NativeProcessProtocol &process, const ResumeActionList &actions)
PacketResult SendStopReplyPacketForThread(NativeProcessProtocol &process, lldb::tid_t tid, bool force_synchronous)
void AppendThreadIDToResponse(Stream &response, lldb::pid_t pid, lldb::tid_t tid)
std::vector< std::string > HandleFeatures(const llvm::ArrayRef< llvm::StringRef > client_features) override
void ProcessStateChanged(NativeProcessProtocol *process, lldb::StateType state) override
llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > > ReadXferObject(llvm::StringRef object, llvm::StringRef annex)
llvm::Expected< std::unique_ptr< llvm::MemoryBuffer > > BuildTargetXml()
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:90
std::string LLGSArgToURL(llvm::StringRef url_arg, bool reverse_connect)
A class that represents a running process on the host machine.
StateType
Process and Thread States.
uint64_t pid_t
Definition: lldb-types.h:83
uint64_t tid_t
Definition: lldb-types.h:84