1 //===-- GDBRemoteClientBase.h -----------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #ifndef liblldb_GDBRemoteClientBase_h_
10 #define liblldb_GDBRemoteClientBase_h_
12 #include "GDBRemoteCommunication.h"
14 #include <condition_variable>
16 namespace lldb_private {
17 namespace process_gdb_remote {
19 class GDBRemoteClientBase : public GDBRemoteCommunication {
21 struct ContinueDelegate {
22 virtual ~ContinueDelegate();
23 virtual void HandleAsyncStdout(llvm::StringRef out) = 0;
24 virtual void HandleAsyncMisc(llvm::StringRef data) = 0;
25 virtual void HandleStopReply() = 0;
27 /// Process asynchronously-received structured data.
30 /// The complete data packet, expected to start with JSON-async.
31 virtual void HandleAsyncStructuredDataPacket(llvm::StringRef data) = 0;
34 GDBRemoteClientBase(const char *comm_name, const char *listener_name);
36 bool SendAsyncSignal(int signo);
40 lldb::StateType SendContinuePacketAndWaitForResponse(
41 ContinueDelegate &delegate, const UnixSignals &signals,
42 llvm::StringRef payload, StringExtractorGDBRemote &response);
44 PacketResult SendPacketAndWaitForResponse(llvm::StringRef payload,
45 StringExtractorGDBRemote &response,
48 PacketResult SendPacketAndReceiveResponseWithOutputSupport(
49 llvm::StringRef payload, StringExtractorGDBRemote &response,
51 llvm::function_ref<void(llvm::StringRef)> output_callback);
53 bool SendvContPacket(llvm::StringRef payload,
54 StringExtractorGDBRemote &response);
58 Lock(GDBRemoteClientBase &comm, bool interrupt);
61 explicit operator bool() { return m_acquired; }
63 // Whether we had to interrupt the continue thread to acquire the
65 bool DidInterrupt() const { return m_did_interrupt; }
68 std::unique_lock<std::recursive_mutex> m_async_lock;
69 GDBRemoteClientBase &m_comm;
73 void SyncWithContinueThread(bool interrupt);
78 SendPacketAndWaitForResponseNoLock(llvm::StringRef payload,
79 StringExtractorGDBRemote &response);
81 virtual void OnRunPacketSent(bool first);
84 /// Variables handling synchronization between the Continue thread and any
85 /// other threads wishing to send packets over the connection. Either the
86 /// continue thread has control over the connection (m_is_running == true) or
87 /// the connection is free for an arbitrary number of other senders to take
88 /// which indicate their interest by incrementing m_async_count.
90 /// Semantics of individual states:
92 /// - m_continue_packet == false, m_async_count == 0:
93 /// connection is free
94 /// - m_continue_packet == true, m_async_count == 0:
95 /// only continue thread is present
96 /// - m_continue_packet == true, m_async_count > 0:
97 /// continue thread has control, async threads should interrupt it and wait
98 /// for it to set m_continue_packet to false
99 /// - m_continue_packet == false, m_async_count > 0:
100 /// async threads have control, continue thread needs to wait for them to
101 /// finish (m_async_count goes down to 0).
104 std::condition_variable m_cv;
106 /// Packet with which to resume after an async interrupt. Can be changed by
107 /// an async thread e.g. to inject a signal.
108 std::string m_continue_packet;
110 /// When was the interrupt packet sent. Used to make sure we time out if the
111 /// stub does not respond to interrupt requests.
112 std::chrono::time_point<std::chrono::steady_clock> m_interrupt_time;
114 /// Number of threads interested in sending.
115 uint32_t m_async_count;
117 /// Whether the continue thread has control.
120 /// Whether we should resume after a stop.
124 /// This handles the synchronization between individual async threads. For
125 /// now they just use a simple mutex.
126 std::recursive_mutex m_async_mutex;
128 bool ShouldStop(const UnixSignals &signals,
129 StringExtractorGDBRemote &response);
133 enum class LockResult { Success, Cancelled, Failed };
135 explicit ContinueLock(GDBRemoteClientBase &comm);
137 explicit operator bool() { return m_acquired; }
144 GDBRemoteClientBase &m_comm;
149 } // namespace process_gdb_remote
150 } // namespace lldb_private
152 #endif // liblldb_GDBRemoteCommunicationClient_h_