1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
| //===-- GDBRemoteCommunication.h --------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_GDBRemoteCommunication_h_
#define liblldb_GDBRemoteCommunication_h_
#include "GDBRemoteCommunicationHistory.h"
#include <condition_variable>
#include <mutex>
#include <queue>
#include <string>
#include <vector>
#include "lldb/Core/Communication.h"
#include "lldb/Host/Config.h"
#include "lldb/Host/HostThread.h"
#include "lldb/Utility/Args.h"
#include "lldb/Utility/Listener.h"
#include "lldb/Utility/Predicate.h"
#include "lldb/Utility/StringExtractorGDBRemote.h"
#include "lldb/lldb-public.h"
namespace lldb_private {
namespace process_gdb_remote {
enum GDBStoppointType {
eStoppointInvalid = -1,
eBreakpointSoftware = 0,
eBreakpointHardware,
eWatchpointWrite,
eWatchpointRead,
eWatchpointReadWrite
};
enum class CompressionType {
None = 0, // no compression
ZlibDeflate, // zlib's deflate compression scheme, requires zlib or Apple's
// libcompression
LZFSE, // an Apple compression scheme, requires Apple's libcompression
LZ4, // lz compression - called "lz4 raw" in libcompression terms, compat with
// https://code.google.com/p/lz4/
LZMA, // Lempel–Ziv–Markov chain algorithm
};
class ProcessGDBRemote;
class GDBRemoteCommunication : public Communication {
public:
enum {
eBroadcastBitRunPacketSent = kLoUserBroadcastBit,
eBroadcastBitGdbReadThreadGotNotify =
kLoUserBroadcastBit << 1 // Sent when we received a notify packet.
};
enum class PacketType { Invalid = 0, Standard, Notify };
enum class PacketResult {
Success = 0, // Success
ErrorSendFailed, // Status sending the packet
ErrorSendAck, // Didn't get an ack back after sending a packet
ErrorReplyFailed, // Status getting the reply
ErrorReplyTimeout, // Timed out waiting for reply
ErrorReplyInvalid, // Got a reply but it wasn't valid for the packet that
// was sent
ErrorReplyAck, // Sending reply ack failed
ErrorDisconnected, // We were disconnected
ErrorNoSequenceLock // We couldn't get the sequence lock for a multi-packet
// request
};
// Class to change the timeout for a given scope and restore it to the
// original value when the
// created ScopedTimeout object got out of scope
class ScopedTimeout {
public:
ScopedTimeout(GDBRemoteCommunication &gdb_comm,
std::chrono::seconds timeout);
~ScopedTimeout();
private:
GDBRemoteCommunication &m_gdb_comm;
std::chrono::seconds m_saved_timeout;
// Don't ever reduce the timeout for a packet, only increase it. If the
// requested timeout if less than the current timeout, we don't set it
// and won't need to restore it.
bool m_timeout_modified;
};
GDBRemoteCommunication(const char *comm_name, const char *listener_name);
~GDBRemoteCommunication() override;
PacketResult GetAck();
size_t SendAck();
size_t SendNack();
char CalculcateChecksum(llvm::StringRef payload);
PacketType CheckForPacket(const uint8_t *src, size_t src_len,
StringExtractorGDBRemote &packet);
bool GetSendAcks() { return m_send_acks; }
// Set the global packet timeout.
//
// For clients, this is the timeout that gets used when sending
// packets and waiting for responses. For servers, this is used when waiting
// for ACKs.
std::chrono::seconds SetPacketTimeout(std::chrono::seconds packet_timeout) {
const auto old_packet_timeout = m_packet_timeout;
m_packet_timeout = packet_timeout;
return old_packet_timeout;
}
std::chrono::seconds GetPacketTimeout() const { return m_packet_timeout; }
// Start a debugserver instance on the current host using the
// supplied connection URL.
Status StartDebugserverProcess(
const char *url,
Platform *platform, // If non nullptr, then check with the platform for
// the GDB server binary if it can't be located
ProcessLaunchInfo &launch_info, uint16_t *port, const Args *inferior_args,
int pass_comm_fd); // Communication file descriptor to pass during
// fork/exec to avoid having to connect/accept
void DumpHistory(Stream &strm);
void SetHistoryStream(llvm::raw_ostream *strm);
static llvm::Error ConnectLocally(GDBRemoteCommunication &client,
GDBRemoteCommunication &server);
protected:
std::chrono::seconds m_packet_timeout;
uint32_t m_echo_number;
LazyBool m_supports_qEcho;
GDBRemoteCommunicationHistory m_history;
bool m_send_acks;
bool m_is_platform; // Set to true if this class represents a platform,
// false if this class represents a debug session for
// a single process
CompressionType m_compression_type;
PacketResult SendPacketNoLock(llvm::StringRef payload);
PacketResult SendRawPacketNoLock(llvm::StringRef payload,
bool skip_ack = false);
PacketResult ReadPacket(StringExtractorGDBRemote &response,
Timeout<std::micro> timeout, bool sync_on_timeout);
PacketResult ReadPacketWithOutputSupport(
StringExtractorGDBRemote &response, Timeout<std::micro> timeout,
bool sync_on_timeout,
llvm::function_ref<void(llvm::StringRef)> output_callback);
// Pop a packet from the queue in a thread safe manner
PacketResult PopPacketFromQueue(StringExtractorGDBRemote &response,
Timeout<std::micro> timeout);
PacketResult WaitForPacketNoLock(StringExtractorGDBRemote &response,
Timeout<std::micro> timeout,
bool sync_on_timeout);
bool CompressionIsEnabled() {
return m_compression_type != CompressionType::None;
}
// If compression is enabled, decompress the packet in m_bytes and update
// m_bytes with the uncompressed version.
// Returns 'true' packet was decompressed and m_bytes is the now-decompressed
// text.
// Returns 'false' if unable to decompress or if the checksum was invalid.
//
// NB: Once the packet has been decompressed, checksum cannot be computed
// based
// on m_bytes. The checksum was for the compressed packet.
bool DecompressPacket();
Status StartListenThread(const char *hostname = "127.0.0.1",
uint16_t port = 0);
bool JoinListenThread();
static lldb::thread_result_t ListenThread(lldb::thread_arg_t arg);
// GDB-Remote read thread
// . this thread constantly tries to read from the communication
// class and stores all packets received in a queue. The usual
// threads read requests simply pop packets off the queue in the
// usual order.
// This setup allows us to intercept and handle async packets, such
// as the notify packet.
// This method is defined as part of communication.h
// when the read thread gets any bytes it will pass them on to this function
void AppendBytesToCache(const uint8_t *bytes, size_t len, bool broadcast,
lldb::ConnectionStatus status) override;
private:
std::queue<StringExtractorGDBRemote> m_packet_queue; // The packet queue
std::mutex m_packet_queue_mutex; // Mutex for accessing queue
std::condition_variable
m_condition_queue_not_empty; // Condition variable to wait for packets
HostThread m_listen_thread;
std::string m_listen_url;
#if defined(HAVE_LIBCOMPRESSION)
CompressionType m_decompression_scratch_type = CompressionType::None;
void *m_decompression_scratch = nullptr;
#endif
DISALLOW_COPY_AND_ASSIGN(GDBRemoteCommunication);
};
} // namespace process_gdb_remote
} // namespace lldb_private
namespace llvm {
template <>
struct format_provider<
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult> {
static void format(const lldb_private::process_gdb_remote::
GDBRemoteCommunication::PacketResult &state,
raw_ostream &Stream, StringRef Style);
};
} // namespace llvm
#endif // liblldb_GDBRemoteCommunication_h_
|