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
|
//===-- GDBRemoteClientBase.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 LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECLIENTBASE_H
#define LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECLIENTBASE_H
#include "GDBRemoteCommunication.h"
#include <condition_variable>
namespace lldb_private {
namespace process_gdb_remote {
class GDBRemoteClientBase : public GDBRemoteCommunication {
public:
struct ContinueDelegate {
virtual ~ContinueDelegate();
virtual void HandleAsyncStdout(llvm::StringRef out) = 0;
virtual void HandleAsyncMisc(llvm::StringRef data) = 0;
virtual void HandleStopReply() = 0;
/// Process asynchronously-received structured data.
///
/// \param[in] data
/// The complete data packet, expected to start with JSON-async.
virtual void HandleAsyncStructuredDataPacket(llvm::StringRef data) = 0;
};
GDBRemoteClientBase(const char *comm_name, const char *listener_name);
bool SendAsyncSignal(int signo);
bool Interrupt();
lldb::StateType SendContinuePacketAndWaitForResponse(
ContinueDelegate &delegate, const UnixSignals &signals,
llvm::StringRef payload, StringExtractorGDBRemote &response);
PacketResult SendPacketAndWaitForResponse(llvm::StringRef payload,
StringExtractorGDBRemote &response,
bool send_async);
PacketResult SendPacketAndReceiveResponseWithOutputSupport(
llvm::StringRef payload, StringExtractorGDBRemote &response,
bool send_async,
llvm::function_ref<void(llvm::StringRef)> output_callback);
bool SendvContPacket(llvm::StringRef payload,
StringExtractorGDBRemote &response);
class Lock {
public:
Lock(GDBRemoteClientBase &comm, bool interrupt);
~Lock();
explicit operator bool() { return m_acquired; }
// Whether we had to interrupt the continue thread to acquire the
// connection.
bool DidInterrupt() const { return m_did_interrupt; }
private:
std::unique_lock<std::recursive_mutex> m_async_lock;
GDBRemoteClientBase &m_comm;
bool m_acquired;
bool m_did_interrupt;
void SyncWithContinueThread(bool interrupt);
};
protected:
PacketResult
SendPacketAndWaitForResponseNoLock(llvm::StringRef payload,
StringExtractorGDBRemote &response);
virtual void OnRunPacketSent(bool first);
private:
/// Variables handling synchronization between the Continue thread and any
/// other threads wishing to send packets over the connection. Either the
/// continue thread has control over the connection (m_is_running == true) or
/// the connection is free for an arbitrary number of other senders to take
/// which indicate their interest by incrementing m_async_count.
///
/// Semantics of individual states:
///
/// - m_continue_packet == false, m_async_count == 0:
/// connection is free
/// - m_continue_packet == true, m_async_count == 0:
/// only continue thread is present
/// - m_continue_packet == true, m_async_count > 0:
/// continue thread has control, async threads should interrupt it and wait
/// for it to set m_continue_packet to false
/// - m_continue_packet == false, m_async_count > 0:
/// async threads have control, continue thread needs to wait for them to
/// finish (m_async_count goes down to 0).
/// @{
std::mutex m_mutex;
std::condition_variable m_cv;
/// Packet with which to resume after an async interrupt. Can be changed by
/// an async thread e.g. to inject a signal.
std::string m_continue_packet;
/// When was the interrupt packet sent. Used to make sure we time out if the
/// stub does not respond to interrupt requests.
std::chrono::time_point<std::chrono::steady_clock> m_interrupt_time;
/// Number of threads interested in sending.
uint32_t m_async_count;
/// Whether the continue thread has control.
bool m_is_running;
/// Whether we should resume after a stop.
bool m_should_stop;
/// @}
/// This handles the synchronization between individual async threads. For
/// now they just use a simple mutex.
std::recursive_mutex m_async_mutex;
bool ShouldStop(const UnixSignals &signals,
StringExtractorGDBRemote &response);
class ContinueLock {
public:
enum class LockResult { Success, Cancelled, Failed };
explicit ContinueLock(GDBRemoteClientBase &comm);
~ContinueLock();
explicit operator bool() { return m_acquired; }
LockResult lock();
void unlock();
private:
GDBRemoteClientBase &m_comm;
bool m_acquired;
};
};
} // namespace process_gdb_remote
} // namespace lldb_private
#endif // LLDB_SOURCE_PLUGINS_PROCESS_GDB_REMOTE_GDBREMOTECLIENTBASE_H
|