1 //===-- GDBRemoteClientBase.cpp ---------------------------------*- 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 #include "GDBRemoteClientBase.h"
10 
11 #include "llvm/ADT/StringExtras.h"
12 
13 #include "lldb/Target/UnixSignals.h"
14 #include "lldb/Utility/LLDBAssert.h"
15 
16 #include "ProcessGDBRemoteLog.h"
17 
18 using namespace lldb;
19 using namespace lldb_private;
20 using namespace lldb_private::process_gdb_remote;
21 using namespace std::chrono;
22 
23 static const seconds kInterruptTimeout(5);
24 
25 /////////////////////////
26 // GDBRemoteClientBase //
27 /////////////////////////
28 
29 GDBRemoteClientBase::ContinueDelegate::~ContinueDelegate() = default;
30 
31 GDBRemoteClientBase::GDBRemoteClientBase(const char *comm_name,
32                                          const char *listener_name)
33     : GDBRemoteCommunication(comm_name, listener_name), m_async_count(0),
34       m_is_running(false), m_should_stop(false) {}
35 
36 StateType GDBRemoteClientBase::SendContinuePacketAndWaitForResponse(
37     ContinueDelegate &delegate, const UnixSignals &signals,
38     llvm::StringRef payload, StringExtractorGDBRemote &response) {
39   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
40   response.Clear();
41 
42   {
43     std::lock_guard<std::mutex> lock(m_mutex);
44     m_continue_packet = payload;
45     m_should_stop = false;
46   }
47   ContinueLock cont_lock(*this);
48   if (!cont_lock)
49     return eStateInvalid;
50   OnRunPacketSent(true);
51 
52   for (;;) {
53     PacketResult read_result = ReadPacket(response, kInterruptTimeout, false);
54     switch (read_result) {
55     case PacketResult::ErrorReplyTimeout: {
56       std::lock_guard<std::mutex> lock(m_mutex);
57       if (m_async_count == 0)
58         continue;
59       if (steady_clock::now() >= m_interrupt_time + kInterruptTimeout)
60         return eStateInvalid;
61       break;
62     }
63     case PacketResult::Success:
64       break;
65     default:
66       LLDB_LOGF(log, "GDBRemoteClientBase::%s () ReadPacket(...) => false",
67                 __FUNCTION__);
68       return eStateInvalid;
69     }
70     if (response.Empty())
71       return eStateInvalid;
72 
73     const char stop_type = response.GetChar();
74     LLDB_LOGF(log, "GDBRemoteClientBase::%s () got packet: %s", __FUNCTION__,
75               response.GetStringRef().data());
76 
77     switch (stop_type) {
78     case 'W':
79     case 'X':
80       return eStateExited;
81     case 'E':
82       // ERROR
83       return eStateInvalid;
84     default:
85       LLDB_LOGF(log, "GDBRemoteClientBase::%s () unrecognized async packet",
86                 __FUNCTION__);
87       return eStateInvalid;
88     case 'O': {
89       std::string inferior_stdout;
90       response.GetHexByteString(inferior_stdout);
91       delegate.HandleAsyncStdout(inferior_stdout);
92       break;
93     }
94     case 'A':
95       delegate.HandleAsyncMisc(
96           llvm::StringRef(response.GetStringRef()).substr(1));
97       break;
98     case 'J':
99       delegate.HandleAsyncStructuredDataPacket(response.GetStringRef());
100       break;
101     case 'T':
102     case 'S':
103       // Do this with the continue lock held.
104       const bool should_stop = ShouldStop(signals, response);
105       response.SetFilePos(0);
106 
107       // The packet we should resume with. In the future we should check our
108       // thread list and "do the right thing" for new threads that show up
109       // while we stop and run async packets. Setting the packet to 'c' to
110       // continue all threads is the right thing to do 99.99% of the time
111       // because if a thread was single stepping, and we sent an interrupt, we
112       // will notice above that we didn't stop due to an interrupt but stopped
113       // due to stepping and we would _not_ continue. This packet may get
114       // modified by the async actions (e.g. to send a signal).
115       m_continue_packet = 'c';
116       cont_lock.unlock();
117 
118       delegate.HandleStopReply();
119       if (should_stop)
120         return eStateStopped;
121 
122       switch (cont_lock.lock()) {
123       case ContinueLock::LockResult::Success:
124         break;
125       case ContinueLock::LockResult::Failed:
126         return eStateInvalid;
127       case ContinueLock::LockResult::Cancelled:
128         return eStateStopped;
129       }
130       OnRunPacketSent(false);
131       break;
132     }
133   }
134 }
135 
136 bool GDBRemoteClientBase::SendAsyncSignal(int signo) {
137   Lock lock(*this, true);
138   if (!lock || !lock.DidInterrupt())
139     return false;
140 
141   m_continue_packet = 'C';
142   m_continue_packet += llvm::hexdigit((signo / 16) % 16);
143   m_continue_packet += llvm::hexdigit(signo % 16);
144   return true;
145 }
146 
147 bool GDBRemoteClientBase::Interrupt() {
148   Lock lock(*this, true);
149   if (!lock.DidInterrupt())
150     return false;
151   m_should_stop = true;
152   return true;
153 }
154 GDBRemoteCommunication::PacketResult
155 GDBRemoteClientBase::SendPacketAndWaitForResponse(
156     llvm::StringRef payload, StringExtractorGDBRemote &response,
157     bool send_async) {
158   Lock lock(*this, send_async);
159   if (!lock) {
160     if (Log *log =
161             ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS))
162       LLDB_LOGF(log,
163                 "GDBRemoteClientBase::%s failed to get mutex, not sending "
164                 "packet '%.*s' (send_async=%d)",
165                 __FUNCTION__, int(payload.size()), payload.data(), send_async);
166     return PacketResult::ErrorSendFailed;
167   }
168 
169   return SendPacketAndWaitForResponseNoLock(payload, response);
170 }
171 
172 GDBRemoteCommunication::PacketResult
173 GDBRemoteClientBase::SendPacketAndReceiveResponseWithOutputSupport(
174     llvm::StringRef payload, StringExtractorGDBRemote &response,
175     bool send_async,
176     llvm::function_ref<void(llvm::StringRef)> output_callback) {
177   Lock lock(*this, send_async);
178   if (!lock) {
179     if (Log *log =
180             ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS))
181       LLDB_LOGF(log,
182                 "GDBRemoteClientBase::%s failed to get mutex, not sending "
183                 "packet '%.*s' (send_async=%d)",
184                 __FUNCTION__, int(payload.size()), payload.data(), send_async);
185     return PacketResult::ErrorSendFailed;
186   }
187 
188   PacketResult packet_result = SendPacketNoLock(payload);
189   if (packet_result != PacketResult::Success)
190     return packet_result;
191 
192   return ReadPacketWithOutputSupport(response, GetPacketTimeout(), true,
193                                      output_callback);
194 }
195 
196 GDBRemoteCommunication::PacketResult
197 GDBRemoteClientBase::SendPacketAndWaitForResponseNoLock(
198     llvm::StringRef payload, StringExtractorGDBRemote &response) {
199   PacketResult packet_result = SendPacketNoLock(payload);
200   if (packet_result != PacketResult::Success)
201     return packet_result;
202 
203   const size_t max_response_retries = 3;
204   for (size_t i = 0; i < max_response_retries; ++i) {
205     packet_result = ReadPacket(response, GetPacketTimeout(), true);
206     // Make sure we received a response
207     if (packet_result != PacketResult::Success)
208       return packet_result;
209     // Make sure our response is valid for the payload that was sent
210     if (response.ValidateResponse())
211       return packet_result;
212     // Response says it wasn't valid
213     Log *log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS);
214     LLDB_LOGF(
215         log,
216         "error: packet with payload \"%.*s\" got invalid response \"%s\": %s",
217         int(payload.size()), payload.data(), response.GetStringRef().data(),
218         (i == (max_response_retries - 1))
219             ? "using invalid response and giving up"
220             : "ignoring response and waiting for another");
221   }
222   return packet_result;
223 }
224 
225 bool GDBRemoteClientBase::SendvContPacket(llvm::StringRef payload,
226                                           StringExtractorGDBRemote &response) {
227   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
228   LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s ()", __FUNCTION__);
229 
230   // we want to lock down packet sending while we continue
231   Lock lock(*this, true);
232 
233   LLDB_LOGF(log,
234             "GDBRemoteCommunicationClient::%s () sending vCont packet: %.*s",
235             __FUNCTION__, int(payload.size()), payload.data());
236 
237   if (SendPacketNoLock(payload) != PacketResult::Success)
238     return false;
239 
240   OnRunPacketSent(true);
241 
242   // wait for the response to the vCont
243   if (ReadPacket(response, llvm::None, false) == PacketResult::Success) {
244     if (response.IsOKResponse())
245       return true;
246   }
247 
248   return false;
249 }
250 bool GDBRemoteClientBase::ShouldStop(const UnixSignals &signals,
251                                      StringExtractorGDBRemote &response) {
252   std::lock_guard<std::mutex> lock(m_mutex);
253 
254   if (m_async_count == 0)
255     return true; // We were not interrupted. The process stopped on its own.
256 
257   // Older debugserver stubs (before April 2016) can return two stop-reply
258   // packets in response to a ^C packet. Additionally, all debugservers still
259   // return two stop replies if the inferior stops due to some other reason
260   // before the remote stub manages to interrupt it. We need to wait for this
261   // additional packet to make sure the packet sequence does not get skewed.
262   StringExtractorGDBRemote extra_stop_reply_packet;
263   ReadPacket(extra_stop_reply_packet, milliseconds(100), false);
264 
265   // Interrupting is typically done using SIGSTOP or SIGINT, so if the process
266   // stops with some other signal, we definitely want to stop.
267   const uint8_t signo = response.GetHexU8(UINT8_MAX);
268   if (signo != signals.GetSignalNumberFromName("SIGSTOP") &&
269       signo != signals.GetSignalNumberFromName("SIGINT"))
270     return true;
271 
272   // We probably only stopped to perform some async processing, so continue
273   // after that is done.
274   // TODO: This is not 100% correct, as the process may have been stopped with
275   // SIGINT or SIGSTOP that was not caused by us (e.g. raise(SIGINT)). This will
276   // normally cause a stop, but if it's done concurrently with a async
277   // interrupt, that stop will get eaten (llvm.org/pr20231).
278   return false;
279 }
280 
281 void GDBRemoteClientBase::OnRunPacketSent(bool first) {
282   if (first)
283     BroadcastEvent(eBroadcastBitRunPacketSent, nullptr);
284 }
285 
286 ///////////////////////////////////////
287 // GDBRemoteClientBase::ContinueLock //
288 ///////////////////////////////////////
289 
290 GDBRemoteClientBase::ContinueLock::ContinueLock(GDBRemoteClientBase &comm)
291     : m_comm(comm), m_acquired(false) {
292   lock();
293 }
294 
295 GDBRemoteClientBase::ContinueLock::~ContinueLock() {
296   if (m_acquired)
297     unlock();
298 }
299 
300 void GDBRemoteClientBase::ContinueLock::unlock() {
301   lldbassert(m_acquired);
302   {
303     std::unique_lock<std::mutex> lock(m_comm.m_mutex);
304     m_comm.m_is_running = false;
305   }
306   m_comm.m_cv.notify_all();
307   m_acquired = false;
308 }
309 
310 GDBRemoteClientBase::ContinueLock::LockResult
311 GDBRemoteClientBase::ContinueLock::lock() {
312   Log *log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS);
313   LLDB_LOGF(log, "GDBRemoteClientBase::ContinueLock::%s() resuming with %s",
314             __FUNCTION__, m_comm.m_continue_packet.c_str());
315 
316   lldbassert(!m_acquired);
317   std::unique_lock<std::mutex> lock(m_comm.m_mutex);
318   m_comm.m_cv.wait(lock, [this] { return m_comm.m_async_count == 0; });
319   if (m_comm.m_should_stop) {
320     m_comm.m_should_stop = false;
321     LLDB_LOGF(log, "GDBRemoteClientBase::ContinueLock::%s() cancelled",
322               __FUNCTION__);
323     return LockResult::Cancelled;
324   }
325   if (m_comm.SendPacketNoLock(m_comm.m_continue_packet) !=
326       PacketResult::Success)
327     return LockResult::Failed;
328 
329   lldbassert(!m_comm.m_is_running);
330   m_comm.m_is_running = true;
331   m_acquired = true;
332   return LockResult::Success;
333 }
334 
335 ///////////////////////////////
336 // GDBRemoteClientBase::Lock //
337 ///////////////////////////////
338 
339 GDBRemoteClientBase::Lock::Lock(GDBRemoteClientBase &comm, bool interrupt)
340     : m_async_lock(comm.m_async_mutex, std::defer_lock), m_comm(comm),
341       m_acquired(false), m_did_interrupt(false) {
342   SyncWithContinueThread(interrupt);
343   if (m_acquired)
344     m_async_lock.lock();
345 }
346 
347 void GDBRemoteClientBase::Lock::SyncWithContinueThread(bool interrupt) {
348   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
349   std::unique_lock<std::mutex> lock(m_comm.m_mutex);
350   if (m_comm.m_is_running && !interrupt)
351     return; // We were asked to avoid interrupting the sender. Lock is not
352             // acquired.
353 
354   ++m_comm.m_async_count;
355   if (m_comm.m_is_running) {
356     if (m_comm.m_async_count == 1) {
357       // The sender has sent the continue packet and we are the first async
358       // packet. Let's interrupt it.
359       const char ctrl_c = '\x03';
360       ConnectionStatus status = eConnectionStatusSuccess;
361       size_t bytes_written = m_comm.Write(&ctrl_c, 1, status, nullptr);
362       if (bytes_written == 0) {
363         --m_comm.m_async_count;
364         LLDB_LOGF(log, "GDBRemoteClientBase::Lock::Lock failed to send "
365                        "interrupt packet");
366         return;
367       }
368       if (log)
369         log->PutCString("GDBRemoteClientBase::Lock::Lock sent packet: \\x03");
370       m_comm.m_interrupt_time = steady_clock::now();
371     }
372     m_comm.m_cv.wait(lock, [this] { return !m_comm.m_is_running; });
373     m_did_interrupt = true;
374   }
375   m_acquired = true;
376 }
377 
378 GDBRemoteClientBase::Lock::~Lock() {
379   if (!m_acquired)
380     return;
381   {
382     std::unique_lock<std::mutex> lock(m_comm.m_mutex);
383     --m_comm.m_async_count;
384   }
385   m_comm.m_cv.notify_one();
386 }
387