mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-04-13 11:51:17 +00:00
ccd6cffba3
The standard remote debugging workflow with gdb is to start the application on the remote host under gdbserver (e.g.: gdbserver :5039 a.out) and then connect to it with gdb. The same workflow is supported by debugserver/lldb-gdbserver with a very similar syntax but to access all features of lldb we need to be connected also to an lldb-platform instance running on the target. Before this change this had to be done manually with starting a separate lldb-platform on the target machine and then connecting to it with lldb before connecting to the process. This change modifies the behavior of "platform connect" with automatically connecting to the process instance if it was started by the remote platform. With this command replacing gdbserver in a gdb based worflow is usually as simple as replacing the command to execute gdbserver with executing lldb-platform. Differential revision: http://reviews.llvm.org/D14952 llvm-svn: 255016
380 lines
11 KiB
C++
380 lines
11 KiB
C++
//===-- GDBRemoteCommunication.h --------------------------------*- C++ -*-===//
|
||
//
|
||
// The LLVM Compiler Infrastructure
|
||
//
|
||
// This file is distributed under the University of Illinois Open Source
|
||
// License. See LICENSE.TXT for details.
|
||
//
|
||
//===----------------------------------------------------------------------===//
|
||
|
||
#ifndef liblldb_GDBRemoteCommunication_h_
|
||
#define liblldb_GDBRemoteCommunication_h_
|
||
|
||
// C Includes
|
||
// C++ Includes
|
||
#include <string>
|
||
#include <queue>
|
||
#include <vector>
|
||
|
||
// Other libraries and framework includes
|
||
// Project includes
|
||
#include "lldb/lldb-public.h"
|
||
#include "lldb/Core/Communication.h"
|
||
#include "lldb/Core/Listener.h"
|
||
#include "lldb/Host/HostThread.h"
|
||
#include "lldb/Host/Mutex.h"
|
||
#include "lldb/Host/Predicate.h"
|
||
#include "lldb/Host/TimeValue.h"
|
||
#include "lldb/Interpreter/Args.h"
|
||
|
||
#include "Utility/StringExtractorGDBRemote.h"
|
||
|
||
namespace lldb_private {
|
||
namespace process_gdb_remote {
|
||
|
||
typedef enum
|
||
{
|
||
eStoppointInvalid = -1,
|
||
eBreakpointSoftware = 0,
|
||
eBreakpointHardware,
|
||
eWatchpointWrite,
|
||
eWatchpointRead,
|
||
eWatchpointReadWrite
|
||
} GDBStoppointType;
|
||
|
||
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, // Error sending the packet
|
||
ErrorSendAck, // Didn't get an ack back after sending a packet
|
||
ErrorReplyFailed, // Error 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, uint32_t timeout);
|
||
~ScopedTimeout ();
|
||
|
||
private:
|
||
GDBRemoteCommunication& m_gdb_comm;
|
||
uint32_t m_saved_timeout;
|
||
};
|
||
|
||
GDBRemoteCommunication(const char *comm_name,
|
||
const char *listener_name);
|
||
|
||
~GDBRemoteCommunication() override;
|
||
|
||
PacketResult
|
||
GetAck ();
|
||
|
||
size_t
|
||
SendAck ();
|
||
|
||
size_t
|
||
SendNack ();
|
||
|
||
char
|
||
CalculcateChecksum (const char *payload,
|
||
size_t payload_length);
|
||
|
||
bool
|
||
GetSequenceMutex(Mutex::Locker& locker, const char *failure_message = nullptr);
|
||
|
||
PacketType
|
||
CheckForPacket (const uint8_t *src,
|
||
size_t src_len,
|
||
StringExtractorGDBRemote &packet);
|
||
|
||
bool
|
||
IsRunning() const
|
||
{
|
||
return m_public_is_running.GetValue();
|
||
}
|
||
|
||
bool
|
||
GetSendAcks ()
|
||
{
|
||
return m_send_acks;
|
||
}
|
||
|
||
//------------------------------------------------------------------
|
||
// Client and server must implement these pure virtual functions
|
||
//------------------------------------------------------------------
|
||
virtual bool
|
||
GetThreadSuffixSupported () = 0;
|
||
|
||
//------------------------------------------------------------------
|
||
// Set the global packet timeout.
|
||
//
|
||
// For clients, this is the timeout that gets used when sending
|
||
// packets and waiting for responses. For servers, this might not
|
||
// get used, and if it doesn't this should be moved to the
|
||
// GDBRemoteCommunicationClient.
|
||
//------------------------------------------------------------------
|
||
uint32_t
|
||
SetPacketTimeout (uint32_t packet_timeout)
|
||
{
|
||
const uint32_t old_packet_timeout = m_packet_timeout;
|
||
m_packet_timeout = packet_timeout;
|
||
return old_packet_timeout;
|
||
}
|
||
|
||
uint32_t
|
||
GetPacketTimeoutInMicroSeconds () const
|
||
{
|
||
return m_packet_timeout * TimeValue::MicroSecPerSec;
|
||
}
|
||
|
||
//------------------------------------------------------------------
|
||
// Start a debugserver instance on the current host using the
|
||
// supplied connection URL.
|
||
//------------------------------------------------------------------
|
||
Error
|
||
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 = Args());
|
||
|
||
void
|
||
DumpHistory(Stream &strm);
|
||
|
||
protected:
|
||
class History
|
||
{
|
||
public:
|
||
enum PacketType
|
||
{
|
||
ePacketTypeInvalid = 0,
|
||
ePacketTypeSend,
|
||
ePacketTypeRecv
|
||
};
|
||
|
||
struct Entry
|
||
{
|
||
Entry() :
|
||
packet(),
|
||
type (ePacketTypeInvalid),
|
||
bytes_transmitted (0),
|
||
packet_idx (0),
|
||
tid (LLDB_INVALID_THREAD_ID)
|
||
{
|
||
}
|
||
|
||
void
|
||
Clear ()
|
||
{
|
||
packet.clear();
|
||
type = ePacketTypeInvalid;
|
||
bytes_transmitted = 0;
|
||
packet_idx = 0;
|
||
tid = LLDB_INVALID_THREAD_ID;
|
||
}
|
||
std::string packet;
|
||
PacketType type;
|
||
uint32_t bytes_transmitted;
|
||
uint32_t packet_idx;
|
||
lldb::tid_t tid;
|
||
};
|
||
|
||
History (uint32_t size);
|
||
|
||
~History ();
|
||
|
||
// For single char packets for ack, nack and /x03
|
||
void
|
||
AddPacket (char packet_char,
|
||
PacketType type,
|
||
uint32_t bytes_transmitted);
|
||
|
||
void
|
||
AddPacket (const std::string &src,
|
||
uint32_t src_len,
|
||
PacketType type,
|
||
uint32_t bytes_transmitted);
|
||
|
||
void
|
||
Dump (Stream &strm) const;
|
||
|
||
void
|
||
Dump (Log *log) const;
|
||
|
||
bool
|
||
DidDumpToLog () const
|
||
{
|
||
return m_dumped_to_log;
|
||
}
|
||
|
||
protected:
|
||
uint32_t
|
||
GetFirstSavedPacketIndex () const
|
||
{
|
||
if (m_total_packet_count < m_packets.size())
|
||
return 0;
|
||
else
|
||
return m_curr_idx + 1;
|
||
}
|
||
|
||
uint32_t
|
||
GetNumPacketsInHistory () const
|
||
{
|
||
if (m_total_packet_count < m_packets.size())
|
||
return m_total_packet_count;
|
||
else
|
||
return (uint32_t)m_packets.size();
|
||
}
|
||
|
||
uint32_t
|
||
GetNextIndex()
|
||
{
|
||
++m_total_packet_count;
|
||
const uint32_t idx = m_curr_idx;
|
||
m_curr_idx = NormalizeIndex(idx + 1);
|
||
return idx;
|
||
}
|
||
|
||
uint32_t
|
||
NormalizeIndex (uint32_t i) const
|
||
{
|
||
return i % m_packets.size();
|
||
}
|
||
|
||
std::vector<Entry> m_packets;
|
||
uint32_t m_curr_idx;
|
||
uint32_t m_total_packet_count;
|
||
mutable bool m_dumped_to_log;
|
||
};
|
||
|
||
uint32_t m_packet_timeout;
|
||
uint32_t m_echo_number;
|
||
LazyBool m_supports_qEcho;
|
||
#ifdef ENABLE_MUTEX_ERROR_CHECKING
|
||
TrackingMutex m_sequence_mutex;
|
||
#else
|
||
Mutex m_sequence_mutex; // Restrict access to sending/receiving packets to a single thread at a time
|
||
#endif
|
||
Predicate<bool> m_public_is_running;
|
||
Predicate<bool> m_private_is_running;
|
||
History 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
|
||
SendPacket (const char *payload,
|
||
size_t payload_length);
|
||
|
||
PacketResult
|
||
SendPacketNoLock (const char *payload,
|
||
size_t payload_length);
|
||
|
||
PacketResult
|
||
ReadPacket (StringExtractorGDBRemote &response, uint32_t timeout_usec, bool sync_on_timeout);
|
||
|
||
// Pop a packet from the queue in a thread safe manner
|
||
PacketResult
|
||
PopPacketFromQueue (StringExtractorGDBRemote &response, uint32_t timeout_usec);
|
||
|
||
PacketResult
|
||
WaitForPacketWithTimeoutMicroSecondsNoLock (StringExtractorGDBRemote &response,
|
||
uint32_t timeout_usec,
|
||
bool sync_on_timeout);
|
||
|
||
bool
|
||
WaitForNotRunningPrivate (const TimeValue *timeout_ptr);
|
||
|
||
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 ();
|
||
|
||
Error
|
||
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
|
||
lldb_private::Mutex m_packet_queue_mutex; // Mutex for accessing queue
|
||
Condition m_condition_queue_not_empty; // Condition variable to wait for packets
|
||
|
||
HostThread m_listen_thread;
|
||
std::string m_listen_url;
|
||
|
||
DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunication);
|
||
};
|
||
|
||
} // namespace process_gdb_remote
|
||
} // namespace lldb_private
|
||
|
||
#endif // liblldb_GDBRemoteCommunication_h_
|