4dc72284b2
while the inferior is running) to be fast. The previous code would always cause the sender to timeout, yet still return success due to the way we were waiting for a value (incorrect value) to change. Now the ProcessGDBRemote plug-in has a public and private "is running" predicate. This allows things that need to send async packets to interrupt and wait for the private "is running" state to be flipped to false, and then resume quickly with no timeout. llvm-svn: 123903
291 lines
9.4 KiB
C++
291 lines
9.4 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 <list>
|
|
#include <string>
|
|
|
|
// Other libraries and framework includes
|
|
// Project includes
|
|
#include "lldb/lldb-private.h"
|
|
#include "lldb/Core/ArchSpec.h"
|
|
#include "lldb/Core/Communication.h"
|
|
#include "lldb/Core/ConstString.h"
|
|
#include "lldb/Core/Error.h"
|
|
#include "lldb/Core/Listener.h"
|
|
#include "lldb/Host/Mutex.h"
|
|
#include "lldb/Host/Predicate.h"
|
|
|
|
#include "Utility/StringExtractorGDBRemote.h"
|
|
|
|
class ProcessGDBRemote;
|
|
|
|
class GDBRemoteCommunication :
|
|
public lldb_private::Communication
|
|
{
|
|
public:
|
|
enum
|
|
{
|
|
eBroadcastBitRunPacketSent = kLoUserBroadcastBit
|
|
};
|
|
//------------------------------------------------------------------
|
|
// Constructors and Destructors
|
|
//------------------------------------------------------------------
|
|
GDBRemoteCommunication();
|
|
|
|
virtual
|
|
~GDBRemoteCommunication();
|
|
|
|
size_t
|
|
SendPacket (const char *payload);
|
|
|
|
size_t
|
|
SendPacket (const char *payload,
|
|
size_t payload_length);
|
|
|
|
size_t
|
|
SendPacketAndWaitForResponse (const char *send_payload,
|
|
StringExtractorGDBRemote &response,
|
|
uint32_t timeout_seconds,
|
|
bool send_async);
|
|
|
|
size_t
|
|
SendPacketAndWaitForResponse (const char *send_payload,
|
|
size_t send_length,
|
|
StringExtractorGDBRemote &response,
|
|
uint32_t timeout_seconds,
|
|
bool send_async);
|
|
|
|
lldb::StateType
|
|
SendContinuePacketAndWaitForResponse (ProcessGDBRemote *process,
|
|
const char *packet_payload,
|
|
size_t packet_length,
|
|
StringExtractorGDBRemote &response);
|
|
|
|
// Wait for a packet within 'nsec' seconds
|
|
size_t
|
|
WaitForPacket (StringExtractorGDBRemote &response,
|
|
uint32_t nsec);
|
|
|
|
// Wait for a packet with an absolute timeout time. If 'timeout' is NULL
|
|
// wait indefinitely.
|
|
size_t
|
|
WaitForPacket (StringExtractorGDBRemote &response,
|
|
lldb_private::TimeValue* timeout);
|
|
|
|
char
|
|
GetAck (uint32_t timeout_seconds);
|
|
|
|
size_t
|
|
SendAck (char ack_char);
|
|
|
|
char
|
|
CalculcateChecksum (const char *payload,
|
|
size_t payload_length);
|
|
|
|
void
|
|
SetAckMode (bool enabled)
|
|
{
|
|
m_send_acks = enabled;
|
|
}
|
|
|
|
bool
|
|
GetThreadSuffixSupported () const
|
|
{
|
|
return m_thread_suffix_supported;
|
|
}
|
|
|
|
void
|
|
SetThreadSuffixSupported (bool enabled)
|
|
{
|
|
m_thread_suffix_supported = enabled;
|
|
}
|
|
|
|
bool
|
|
SendAsyncSignal (int signo);
|
|
|
|
bool
|
|
SendInterrupt (lldb_private::Mutex::Locker &locker,
|
|
uint32_t seconds_to_wait_for_stop,
|
|
bool *timed_out = NULL);
|
|
|
|
bool
|
|
GetSequenceMutex(lldb_private::Mutex::Locker& locker);
|
|
|
|
//------------------------------------------------------------------
|
|
// Communication overrides
|
|
//------------------------------------------------------------------
|
|
virtual void
|
|
AppendBytesToCache (const uint8_t *src, size_t src_len, bool broadcast, lldb::ConnectionStatus status);
|
|
|
|
|
|
lldb::pid_t
|
|
GetCurrentProcessID (uint32_t timeout_seconds);
|
|
|
|
bool
|
|
GetLaunchSuccess (uint32_t timeout_seconds, std::string &error_str);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a GDB remote protocol 'A' packet that delivers program
|
|
/// arguments to the remote server.
|
|
///
|
|
/// @param[in] argv
|
|
/// A NULL terminated array of const C strings to use as the
|
|
/// arguments.
|
|
///
|
|
/// @param[in] timeout_seconds
|
|
/// The number of seconds to wait for a response from the remote
|
|
/// server.
|
|
///
|
|
/// @return
|
|
/// Zero if the response was "OK", a positive value if the
|
|
/// the response was "Exx" where xx are two hex digits, or
|
|
/// -1 if the call is unsupported or any other unexpected
|
|
/// response was received.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SendArgumentsPacket (char const *argv[], uint32_t timeout_seconds);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a "QEnvironment:NAME=VALUE" packet that will build up the
|
|
/// environment that will get used when launching an application
|
|
/// in conjunction with the 'A' packet. This function can be called
|
|
/// multiple times in a row in order to pass on the desired
|
|
/// environment that the inferior should be launched with.
|
|
///
|
|
/// @param[in] name_equal_value
|
|
/// A NULL terminated C string that contains a single environment
|
|
/// in the format "NAME=VALUE".
|
|
///
|
|
/// @param[in] timeout_seconds
|
|
/// The number of seconds to wait for a response from the remote
|
|
/// server.
|
|
///
|
|
/// @return
|
|
/// Zero if the response was "OK", a positive value if the
|
|
/// the response was "Exx" where xx are two hex digits, or
|
|
/// -1 if the call is unsupported or any other unexpected
|
|
/// response was received.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SendEnvironmentPacket (char const *name_equal_value,
|
|
uint32_t timeout_seconds);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Sends a "vAttach:PID" where PID is in hex.
|
|
///
|
|
/// @param[in] pid
|
|
/// A process ID for the remote gdb server to attach to.
|
|
///
|
|
/// @param[in] timeout_seconds
|
|
/// The number of seconds to wait for a response from the remote
|
|
/// server.
|
|
///
|
|
/// @param[out] response
|
|
/// The response received from the gdb server. If the return
|
|
/// value is zero, \a response will contain a stop reply
|
|
/// packet.
|
|
///
|
|
/// @return
|
|
/// Zero if the attach was successful, or an error indicating
|
|
/// an error code.
|
|
//------------------------------------------------------------------
|
|
int
|
|
SendAttach (lldb::pid_t pid,
|
|
uint32_t timeout_seconds,
|
|
StringExtractorGDBRemote& response);
|
|
|
|
|
|
lldb::addr_t
|
|
AllocateMemory (size_t size, uint32_t permissions, uint32_t timeout_seconds);
|
|
|
|
bool
|
|
DeallocateMemory (lldb::addr_t addr, uint32_t timeout_seconds);
|
|
|
|
bool
|
|
IsRunning() const
|
|
{
|
|
return m_public_is_running.GetValue();
|
|
}
|
|
|
|
bool
|
|
GetHostInfo (uint32_t timeout_seconds);
|
|
|
|
bool
|
|
HostInfoIsValid () const
|
|
{
|
|
return m_pointer_byte_size != 0;
|
|
}
|
|
|
|
const lldb_private::ArchSpec &
|
|
GetHostArchitecture ();
|
|
|
|
const lldb_private::ConstString &
|
|
GetOSString ();
|
|
|
|
const lldb_private::ConstString &
|
|
GetVendorString();
|
|
|
|
lldb::ByteOrder
|
|
GetByteOrder ();
|
|
|
|
uint32_t
|
|
GetAddressByteSize ();
|
|
|
|
protected:
|
|
typedef std::list<std::string> packet_collection;
|
|
|
|
size_t
|
|
SendPacketNoLock (const char *payload,
|
|
size_t payload_length);
|
|
|
|
size_t
|
|
WaitForPacketNoLock (StringExtractorGDBRemote &response,
|
|
lldb_private::TimeValue* timeout_time_ptr);
|
|
|
|
//------------------------------------------------------------------
|
|
// Classes that inherit from GDBRemoteCommunication can see and modify these
|
|
//------------------------------------------------------------------
|
|
bool m_send_acks:1,
|
|
m_thread_suffix_supported:1;
|
|
lldb_private::Listener m_rx_packet_listener;
|
|
lldb_private::Mutex m_sequence_mutex; // Restrict access to sending/receiving packets to a single thread at a time
|
|
lldb_private::Predicate<bool> m_public_is_running;
|
|
lldb_private::Predicate<bool> m_private_is_running;
|
|
|
|
// If we need to send a packet while the target is running, the m_async_XXX
|
|
// member variables take care of making this happen.
|
|
lldb_private::Mutex m_async_mutex;
|
|
lldb_private::Predicate<bool> m_async_packet_predicate;
|
|
std::string m_async_packet;
|
|
StringExtractorGDBRemote m_async_response;
|
|
uint32_t m_async_timeout;
|
|
int m_async_signal; // We were asked to deliver a signal to the inferior process.
|
|
|
|
lldb_private::ArchSpec m_arch; // Results from the qHostInfo call
|
|
uint32_t m_cpusubtype; // Results from the qHostInfo call
|
|
lldb_private::ConstString m_os; // Results from the qHostInfo call
|
|
lldb_private::ConstString m_vendor; // Results from the qHostInfo call
|
|
lldb::ByteOrder m_byte_order; // Results from the qHostInfo call
|
|
uint32_t m_pointer_byte_size; // Results from the qHostInfo call
|
|
|
|
|
|
private:
|
|
//------------------------------------------------------------------
|
|
// For GDBRemoteCommunication only
|
|
//------------------------------------------------------------------
|
|
DISALLOW_COPY_AND_ASSIGN (GDBRemoteCommunication);
|
|
};
|
|
|
|
#endif // liblldb_GDBRemoteCommunication_h_
|