mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-04-16 05:10:32 +00:00
2d4edfbc6a
don't crash if we disable logging when some code already has a copy of the logger. Prior to this fix, logs were handed out as pointers and if they were held onto while a log got disabled, then it could cause a crash. Now all logs are handed out as shared pointers so this problem shouldn't happen anymore. We are also using our new shared pointers that put the shared pointer count and the object into the same allocation for a tad better performance. llvm-svn: 118319
859 lines
29 KiB
C++
859 lines
29 KiB
C++
//===-- GDBRemoteCommunication.cpp ------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#include "GDBRemoteCommunication.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
#include "lldb/Interpreter/Args.h"
|
|
#include "lldb/Core/ConnectionFileDescriptor.h"
|
|
#include "lldb/Core/Log.h"
|
|
#include "lldb/Core/State.h"
|
|
#include "lldb/Core/StreamString.h"
|
|
#include "lldb/Host/TimeValue.h"
|
|
|
|
// Project includes
|
|
#include "Utility/StringExtractorGDBRemote.h"
|
|
#include "ProcessGDBRemote.h"
|
|
#include "ProcessGDBRemoteLog.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//----------------------------------------------------------------------
|
|
// GDBRemoteCommunication constructor
|
|
//----------------------------------------------------------------------
|
|
GDBRemoteCommunication::GDBRemoteCommunication() :
|
|
Communication("gdb-remote.packets"),
|
|
m_send_acks (true),
|
|
m_rx_packet_listener ("gdbremote.rx_packet"),
|
|
m_sequence_mutex (Mutex::eMutexTypeRecursive),
|
|
m_is_running (false),
|
|
m_async_mutex (Mutex::eMutexTypeRecursive),
|
|
m_async_packet_predicate (false),
|
|
m_async_packet (),
|
|
m_async_response (),
|
|
m_async_timeout (UINT32_MAX),
|
|
m_async_signal (-1),
|
|
m_arch(),
|
|
m_os(),
|
|
m_vendor(),
|
|
m_byte_order(eByteOrderHost),
|
|
m_pointer_byte_size(0)
|
|
{
|
|
m_rx_packet_listener.StartListeningForEvents(this,
|
|
Communication::eBroadcastBitPacketAvailable |
|
|
Communication::eBroadcastBitReadThreadDidExit);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Destructor
|
|
//----------------------------------------------------------------------
|
|
GDBRemoteCommunication::~GDBRemoteCommunication()
|
|
{
|
|
m_rx_packet_listener.StopListeningForEvents(this,
|
|
Communication::eBroadcastBitPacketAvailable |
|
|
Communication::eBroadcastBitReadThreadDidExit);
|
|
if (IsConnected())
|
|
{
|
|
StopReadThread();
|
|
Disconnect();
|
|
}
|
|
}
|
|
|
|
|
|
char
|
|
GDBRemoteCommunication::CalculcateChecksum (const char *payload, size_t payload_length)
|
|
{
|
|
int checksum = 0;
|
|
|
|
// We only need to compute the checksum if we are sending acks
|
|
if (m_send_acks)
|
|
{
|
|
for (size_t i = 0; i < payload_length; ++i)
|
|
checksum += payload[i];
|
|
}
|
|
return checksum & 255;
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::SendAck (char ack_char)
|
|
{
|
|
Mutex::Locker locker(m_sequence_mutex);
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_PACKETS, "send packet: %c", ack_char);
|
|
ConnectionStatus status = eConnectionStatusSuccess;
|
|
return Write (&ack_char, 1, status, NULL) == 1;
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::SendPacketAndWaitForResponse
|
|
(
|
|
const char *payload,
|
|
StringExtractorGDBRemote &response,
|
|
uint32_t timeout_seconds,
|
|
bool send_async
|
|
)
|
|
{
|
|
return SendPacketAndWaitForResponse (payload,
|
|
::strlen (payload),
|
|
response,
|
|
timeout_seconds,
|
|
send_async);
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::SendPacketAndWaitForResponse
|
|
(
|
|
const char *payload,
|
|
size_t payload_length,
|
|
StringExtractorGDBRemote &response,
|
|
uint32_t timeout_seconds,
|
|
bool send_async
|
|
)
|
|
{
|
|
Mutex::Locker locker;
|
|
TimeValue timeout_time;
|
|
timeout_time = TimeValue::Now();
|
|
timeout_time.OffsetWithSeconds (timeout_seconds);
|
|
|
|
if (GetSequenceMutex (locker))
|
|
{
|
|
if (SendPacketNoLock (payload, strlen(payload)))
|
|
return WaitForPacketNoLock (response, &timeout_time);
|
|
}
|
|
else
|
|
{
|
|
if (send_async)
|
|
{
|
|
Mutex::Locker async_locker (m_async_mutex);
|
|
m_async_packet.assign(payload, payload_length);
|
|
m_async_timeout = timeout_seconds;
|
|
m_async_packet_predicate.SetValue (true, eBroadcastNever);
|
|
|
|
bool timed_out = false;
|
|
if (SendInterrupt(locker, 1, &timed_out))
|
|
{
|
|
if (m_async_packet_predicate.WaitForValueEqualTo (false, &timeout_time, &timed_out))
|
|
{
|
|
response = m_async_response;
|
|
return response.GetStringRef().size();
|
|
}
|
|
}
|
|
// if (timed_out)
|
|
// m_error.SetErrorString("Timeout.");
|
|
// else
|
|
// m_error.SetErrorString("Unknown error.");
|
|
}
|
|
else
|
|
{
|
|
// m_error.SetErrorString("Sequence mutex is locked.");
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//template<typename _Tp>
|
|
//class ScopedValueChanger
|
|
//{
|
|
//public:
|
|
// // Take a value reference and the value to assing it to when this class
|
|
// // instance goes out of scope.
|
|
// ScopedValueChanger (_Tp &value_ref, _Tp value) :
|
|
// m_value_ref (value_ref),
|
|
// m_value (value)
|
|
// {
|
|
// }
|
|
//
|
|
// // This object is going out of scope, change the value pointed to by
|
|
// // m_value_ref to the value we got during construction which was stored in
|
|
// // m_value;
|
|
// ~ScopedValueChanger ()
|
|
// {
|
|
// m_value_ref = m_value;
|
|
// }
|
|
//protected:
|
|
// _Tp &m_value_ref; // A reference to the value we wil change when this object destructs
|
|
// _Tp m_value; // The value to assign to m_value_ref when this goes out of scope.
|
|
//};
|
|
|
|
StateType
|
|
GDBRemoteCommunication::SendContinuePacketAndWaitForResponse
|
|
(
|
|
ProcessGDBRemote *process,
|
|
const char *payload,
|
|
size_t packet_length,
|
|
StringExtractorGDBRemote &response
|
|
)
|
|
{
|
|
LogSP log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
|
|
LogSP async_log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_ASYNC));
|
|
if (log)
|
|
log->Printf ("GDBRemoteCommunication::%s ()", __FUNCTION__);
|
|
|
|
Mutex::Locker locker(m_sequence_mutex);
|
|
m_is_running.SetValue (true, eBroadcastNever);
|
|
|
|
// ScopedValueChanger<bool> restore_running_to_false (m_is_running, false);
|
|
StateType state = eStateRunning;
|
|
|
|
if (SendPacket(payload, packet_length) == 0)
|
|
state = eStateInvalid;
|
|
|
|
while (state == eStateRunning)
|
|
{
|
|
log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
|
|
if (log)
|
|
log->Printf ("GDBRemoteCommunication::%s () WaitForPacket(...)", __FUNCTION__);
|
|
|
|
if (WaitForPacket (response, (TimeValue*)NULL))
|
|
{
|
|
log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
|
|
async_log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_ASYNC);
|
|
if (response.Empty())
|
|
state = eStateInvalid;
|
|
else
|
|
{
|
|
const char stop_type = response.GetChar();
|
|
if (log)
|
|
log->Printf ("GDBRemoteCommunication::%s () got '%c' packet", __FUNCTION__, stop_type);
|
|
switch (stop_type)
|
|
{
|
|
case 'T':
|
|
case 'S':
|
|
if (m_async_signal != -1)
|
|
{
|
|
if (async_log)
|
|
async_log->Printf ("async: send signo = %s", Host::GetSignalAsCString (m_async_signal));
|
|
|
|
// Save off the async signal we are supposed to send
|
|
const int async_signal = m_async_signal;
|
|
// Clear the async signal member so we don't end up
|
|
// sending the signal multiple times...
|
|
m_async_signal = -1;
|
|
// Check which signal we stopped with
|
|
uint8_t signo = response.GetHexU8(255);
|
|
if (signo == async_signal)
|
|
{
|
|
if (async_log)
|
|
async_log->Printf ("async: stopped with signal %s, we are done running", Host::GetSignalAsCString (signo));
|
|
|
|
// We already stopped with a signal that we wanted
|
|
// to stop with, so we are done
|
|
response.SetFilePos (0);
|
|
}
|
|
else
|
|
{
|
|
// We stopped with a different signal that the one
|
|
// we wanted to stop with, so now we must resume
|
|
// with the signal we want
|
|
char signal_packet[32];
|
|
int signal_packet_len = 0;
|
|
signal_packet_len = ::snprintf (signal_packet,
|
|
sizeof (signal_packet),
|
|
"C%2.2x",
|
|
async_signal);
|
|
|
|
if (async_log)
|
|
async_log->Printf ("async: stopped with signal %s, resume with %s",
|
|
Host::GetSignalAsCString (signo),
|
|
Host::GetSignalAsCString (async_signal));
|
|
|
|
if (SendPacket(signal_packet, signal_packet_len) == 0)
|
|
{
|
|
if (async_log)
|
|
async_log->Printf ("async: error: failed to resume with %s",
|
|
Host::GetSignalAsCString (async_signal));
|
|
state = eStateInvalid;
|
|
break;
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
else if (m_async_packet_predicate.GetValue())
|
|
{
|
|
if (async_log)
|
|
async_log->Printf ("async: send async packet: %s",
|
|
m_async_packet.c_str());
|
|
|
|
// We are supposed to send an asynchronous packet while
|
|
// we are running.
|
|
m_async_response.Clear();
|
|
if (!m_async_packet.empty())
|
|
{
|
|
SendPacketAndWaitForResponse (&m_async_packet[0],
|
|
m_async_packet.size(),
|
|
m_async_response,
|
|
m_async_timeout,
|
|
false);
|
|
}
|
|
// Let the other thread that was trying to send the async
|
|
// packet know that the packet has been sent.
|
|
m_async_packet_predicate.SetValue(false, eBroadcastAlways);
|
|
|
|
if (async_log)
|
|
async_log->Printf ("async: resume after async response received: %s",
|
|
m_async_response.GetStringRef().c_str());
|
|
|
|
// Continue again
|
|
if (SendPacket("c", 1) == 0)
|
|
{
|
|
state = eStateInvalid;
|
|
break;
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
// Stop with signal and thread info
|
|
state = eStateStopped;
|
|
break;
|
|
|
|
case 'W':
|
|
// process exited
|
|
state = eStateExited;
|
|
break;
|
|
|
|
case 'O':
|
|
// STDOUT
|
|
{
|
|
std::string inferior_stdout;
|
|
inferior_stdout.reserve(response.GetBytesLeft () / 2);
|
|
char ch;
|
|
while ((ch = response.GetHexU8()) != '\0')
|
|
inferior_stdout.append(1, ch);
|
|
process->AppendSTDOUT (inferior_stdout.c_str(), inferior_stdout.size());
|
|
}
|
|
break;
|
|
|
|
case 'E':
|
|
// ERROR
|
|
state = eStateInvalid;
|
|
break;
|
|
|
|
default:
|
|
if (log)
|
|
log->Printf ("GDBRemoteCommunication::%s () got unrecognized async packet: '%s'", __FUNCTION__, stop_type);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
|
|
if (log)
|
|
log->Printf ("GDBRemoteCommunication::%s () WaitForPacket(...) => false", __FUNCTION__);
|
|
state = eStateInvalid;
|
|
}
|
|
}
|
|
log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS);
|
|
if (log)
|
|
log->Printf ("GDBRemoteCommunication::%s () => %s", __FUNCTION__, StateAsCString(state));
|
|
response.SetFilePos(0);
|
|
m_is_running.SetValue (false, eBroadcastOnChange);
|
|
return state;
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::SendPacket (const char *payload)
|
|
{
|
|
Mutex::Locker locker(m_sequence_mutex);
|
|
return SendPacketNoLock (payload, ::strlen (payload));
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::SendPacket (const char *payload, size_t payload_length)
|
|
{
|
|
Mutex::Locker locker(m_sequence_mutex);
|
|
return SendPacketNoLock (payload, payload_length);
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::SendPacketNoLock (const char *payload, size_t payload_length)
|
|
{
|
|
if (IsConnected())
|
|
{
|
|
StreamString packet(0, 4, eByteOrderBig);
|
|
|
|
packet.PutChar('$');
|
|
packet.Write (payload, payload_length);
|
|
packet.PutChar('#');
|
|
packet.PutHex8(CalculcateChecksum (payload, payload_length));
|
|
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_PACKETS, "send packet: %s", packet.GetData());
|
|
ConnectionStatus status = eConnectionStatusSuccess;
|
|
size_t bytes_written = Write (packet.GetData(), packet.GetSize(), status, NULL);
|
|
if (bytes_written == packet.GetSize())
|
|
{
|
|
if (m_send_acks)
|
|
{
|
|
if (GetAck (1) != '+')
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_PACKETS, "error: failed to send packet: %s", packet.GetData());
|
|
}
|
|
return bytes_written;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
char
|
|
GDBRemoteCommunication::GetAck (uint32_t timeout_seconds)
|
|
{
|
|
StringExtractorGDBRemote response;
|
|
if (WaitForPacket (response, timeout_seconds) == 1)
|
|
return response.GetChar();
|
|
return 0;
|
|
}
|
|
|
|
bool
|
|
GDBRemoteCommunication::GetSequenceMutex (Mutex::Locker& locker)
|
|
{
|
|
return locker.TryLock (m_sequence_mutex.GetMutex());
|
|
}
|
|
|
|
bool
|
|
GDBRemoteCommunication::SendAsyncSignal (int signo)
|
|
{
|
|
m_async_signal = signo;
|
|
bool timed_out = false;
|
|
Mutex::Locker locker;
|
|
if (SendInterrupt (locker, 1, &timed_out))
|
|
return true;
|
|
m_async_signal = -1;
|
|
return false;
|
|
}
|
|
|
|
// This function takes a mutex locker as a parameter in case the GetSequenceMutex
|
|
// actually succeeds. If it doesn't succeed in acquiring the sequence mutex
|
|
// (the expected result), then it will send the halt packet. If it does succeed
|
|
// then the caller that requested the interrupt will want to keep the sequence
|
|
// locked down so that no one else can send packets while the caller has control.
|
|
// This function usually gets called when we are running and need to stop the
|
|
// target. It can also be used when we are running and and we need to do something
|
|
// else (like read/write memory), so we need to interrupt the running process
|
|
// (gdb remote protocol requires this), and do what we need to do, then resume.
|
|
|
|
bool
|
|
GDBRemoteCommunication::SendInterrupt (Mutex::Locker& locker, uint32_t seconds_to_wait_for_stop, bool *timed_out)
|
|
{
|
|
if (timed_out)
|
|
*timed_out = false;
|
|
|
|
if (IsConnected() && IsRunning())
|
|
{
|
|
// Only send an interrupt if our debugserver is running...
|
|
if (GetSequenceMutex (locker) == false)
|
|
{
|
|
// Someone has the mutex locked waiting for a response or for the
|
|
// inferior to stop, so send the interrupt on the down low...
|
|
char ctrl_c = '\x03';
|
|
ConnectionStatus status = eConnectionStatusSuccess;
|
|
TimeValue timeout;
|
|
if (seconds_to_wait_for_stop)
|
|
{
|
|
timeout = TimeValue::Now();
|
|
timeout.OffsetWithSeconds (seconds_to_wait_for_stop);
|
|
}
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_PACKETS, "send packet: \\x03");
|
|
if (Write (&ctrl_c, 1, status, NULL) > 0)
|
|
{
|
|
if (seconds_to_wait_for_stop)
|
|
m_is_running.WaitForValueEqualTo (false, &timeout, timed_out);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::WaitForPacket (StringExtractorGDBRemote &response, uint32_t timeout_seconds)
|
|
{
|
|
TimeValue timeout_time;
|
|
timeout_time = TimeValue::Now();
|
|
timeout_time.OffsetWithSeconds (timeout_seconds);
|
|
return WaitForPacketNoLock (response, &timeout_time);
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::WaitForPacket (StringExtractorGDBRemote &response, TimeValue* timeout_time_ptr)
|
|
{
|
|
Mutex::Locker locker(m_sequence_mutex);
|
|
return WaitForPacketNoLock (response, timeout_time_ptr);
|
|
}
|
|
|
|
size_t
|
|
GDBRemoteCommunication::WaitForPacketNoLock (StringExtractorGDBRemote &response, TimeValue* timeout_time_ptr)
|
|
{
|
|
bool checksum_error = false;
|
|
response.Clear ();
|
|
|
|
EventSP event_sp;
|
|
|
|
if (m_rx_packet_listener.WaitForEvent (timeout_time_ptr, event_sp))
|
|
{
|
|
const uint32_t event_type = event_sp->GetType();
|
|
if (event_type | Communication::eBroadcastBitPacketAvailable)
|
|
{
|
|
const EventDataBytes *event_bytes = EventDataBytes::GetEventDataFromEvent(event_sp.get());
|
|
if (event_bytes)
|
|
{
|
|
const char * packet_data = (const char *)event_bytes->GetBytes();
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_PACKETS, "read packet: %s", packet_data);
|
|
const size_t packet_size = event_bytes->GetByteSize();
|
|
if (packet_data && packet_size > 0)
|
|
{
|
|
std::string &response_str = response.GetStringRef();
|
|
if (packet_data[0] == '$')
|
|
{
|
|
assert (packet_size >= 4); // Must have at least '$#CC' where CC is checksum
|
|
assert (packet_data[packet_size-3] == '#');
|
|
assert (::isxdigit (packet_data[packet_size-2])); // Must be checksum hex byte
|
|
assert (::isxdigit (packet_data[packet_size-1])); // Must be checksum hex byte
|
|
response_str.assign (packet_data + 1, packet_size - 4);
|
|
if (m_send_acks)
|
|
{
|
|
char packet_checksum = strtol (&packet_data[packet_size-2], NULL, 16);
|
|
char actual_checksum = CalculcateChecksum (&response_str[0], response_str.size());
|
|
checksum_error = packet_checksum != actual_checksum;
|
|
// Send the ack or nack if needed
|
|
if (checksum_error)
|
|
SendAck('-');
|
|
else
|
|
SendAck('+');
|
|
}
|
|
}
|
|
else
|
|
{
|
|
response_str.assign (packet_data, packet_size);
|
|
}
|
|
return response_str.size();
|
|
}
|
|
}
|
|
}
|
|
else if (Communication::eBroadcastBitReadThreadDidExit)
|
|
{
|
|
// Our read thread exited on us so just fall through and return zero...
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
GDBRemoteCommunication::AppendBytesToCache (const uint8_t *src, size_t src_len, bool broadcast)
|
|
{
|
|
// Put the packet data into the buffer in a thread safe fashion
|
|
Mutex::Locker locker(m_bytes_mutex);
|
|
m_bytes.append ((const char *)src, src_len);
|
|
|
|
// Parse up the packets into gdb remote packets
|
|
while (!m_bytes.empty())
|
|
{
|
|
// end_idx must be one past the last valid packet byte. Start
|
|
// it off with an invalid value that is the same as the current
|
|
// index.
|
|
size_t end_idx = 0;
|
|
|
|
switch (m_bytes[0])
|
|
{
|
|
case '+': // Look for ack
|
|
case '-': // Look for cancel
|
|
case '\x03': // ^C to halt target
|
|
end_idx = 1; // The command is one byte long...
|
|
break;
|
|
|
|
case '$':
|
|
// Look for a standard gdb packet?
|
|
end_idx = m_bytes.find('#');
|
|
if (end_idx != std::string::npos)
|
|
{
|
|
if (end_idx + 2 < m_bytes.size())
|
|
{
|
|
end_idx += 3;
|
|
}
|
|
else
|
|
{
|
|
// Checksum bytes aren't all here yet
|
|
end_idx = std::string::npos;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (end_idx == std::string::npos)
|
|
{
|
|
//ProcessGDBRemoteLog::LogIf (GDBR_LOG_PACKETS | GDBR_LOG_VERBOSE, "GDBRemoteCommunication::%s packet not yet complete: '%s'",__FUNCTION__, m_bytes.c_str());
|
|
return;
|
|
}
|
|
else if (end_idx > 0)
|
|
{
|
|
// We have a valid packet...
|
|
assert (end_idx <= m_bytes.size());
|
|
std::auto_ptr<EventDataBytes> event_bytes_ap (new EventDataBytes (&m_bytes[0], end_idx));
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_COMM, "got full packet: %s", event_bytes_ap->GetBytes());
|
|
BroadcastEvent (eBroadcastBitPacketAvailable, event_bytes_ap.release());
|
|
m_bytes.erase(0, end_idx);
|
|
}
|
|
else
|
|
{
|
|
assert (1 <= m_bytes.size());
|
|
ProcessGDBRemoteLog::LogIf (GDBR_LOG_COMM, "GDBRemoteCommunication::%s tossing junk byte at %c",__FUNCTION__, m_bytes[0]);
|
|
m_bytes.erase(0, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
lldb::pid_t
|
|
GDBRemoteCommunication::GetCurrentProcessID (uint32_t timeout_seconds)
|
|
{
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse("qC", strlen("qC"), response, timeout_seconds, false))
|
|
{
|
|
if (response.GetChar() == 'Q')
|
|
if (response.GetChar() == 'C')
|
|
return response.GetHexMaxU32 (false, LLDB_INVALID_PROCESS_ID);
|
|
}
|
|
return LLDB_INVALID_PROCESS_ID;
|
|
}
|
|
|
|
bool
|
|
GDBRemoteCommunication::GetLaunchSuccess (uint32_t timeout_seconds, std::string &error_str)
|
|
{
|
|
error_str.clear();
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse("qLaunchSuccess", strlen("qLaunchSuccess"), response, timeout_seconds, false))
|
|
{
|
|
if (response.IsOKPacket())
|
|
return true;
|
|
if (response.GetChar() == 'E')
|
|
{
|
|
// A string the describes what failed when launching...
|
|
error_str = response.GetStringRef().substr(1);
|
|
}
|
|
else
|
|
{
|
|
error_str.assign ("unknown error occurred launching process");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
error_str.assign ("failed to send the qLaunchSuccess packet");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int
|
|
GDBRemoteCommunication::SendArgumentsPacket (char const *argv[], uint32_t timeout_seconds)
|
|
{
|
|
if (argv && argv[0])
|
|
{
|
|
StreamString packet;
|
|
packet.PutChar('A');
|
|
const char *arg;
|
|
for (uint32_t i = 0; (arg = argv[i]) != NULL; ++i)
|
|
{
|
|
const int arg_len = strlen(arg);
|
|
if (i > 0)
|
|
packet.PutChar(',');
|
|
packet.Printf("%i,%i,", arg_len * 2, i);
|
|
packet.PutBytesAsRawHex8(arg, arg_len, eByteOrderHost, eByteOrderHost);
|
|
}
|
|
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, timeout_seconds, false))
|
|
{
|
|
if (response.IsOKPacket())
|
|
return 0;
|
|
uint8_t error = response.GetError();
|
|
if (error)
|
|
return error;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
int
|
|
GDBRemoteCommunication::SendEnvironmentPacket (char const *name_equal_value, uint32_t timeout_seconds)
|
|
{
|
|
if (name_equal_value && name_equal_value[0])
|
|
{
|
|
StreamString packet;
|
|
packet.Printf("QEnvironment:%s", name_equal_value);
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, timeout_seconds, false))
|
|
{
|
|
if (response.IsOKPacket())
|
|
return 0;
|
|
uint8_t error = response.GetError();
|
|
if (error)
|
|
return error;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool
|
|
GDBRemoteCommunication::GetHostInfo (uint32_t timeout_seconds)
|
|
{
|
|
m_arch.Clear();
|
|
m_os.Clear();
|
|
m_vendor.Clear();
|
|
m_byte_order = eByteOrderHost;
|
|
m_pointer_byte_size = 0;
|
|
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse ("qHostInfo", response, timeout_seconds, false))
|
|
{
|
|
if (response.IsUnsupportedPacket())
|
|
return false;
|
|
|
|
|
|
std::string name;
|
|
std::string value;
|
|
while (response.GetNameColonValue(name, value))
|
|
{
|
|
if (name.compare("cputype") == 0)
|
|
{
|
|
// exception type in big endian hex
|
|
m_arch.SetCPUType(Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 0));
|
|
}
|
|
else if (name.compare("cpusubtype") == 0)
|
|
{
|
|
// exception count in big endian hex
|
|
m_arch.SetCPUSubtype(Args::StringToUInt32 (value.c_str(), 0, 0));
|
|
}
|
|
else if (name.compare("ostype") == 0)
|
|
{
|
|
// exception data in big endian hex
|
|
m_os.SetCString(value.c_str());
|
|
}
|
|
else if (name.compare("vendor") == 0)
|
|
{
|
|
m_vendor.SetCString(value.c_str());
|
|
}
|
|
else if (name.compare("endian") == 0)
|
|
{
|
|
if (value.compare("little") == 0)
|
|
m_byte_order = eByteOrderLittle;
|
|
else if (value.compare("big") == 0)
|
|
m_byte_order = eByteOrderBig;
|
|
else if (value.compare("pdp") == 0)
|
|
m_byte_order = eByteOrderPDP;
|
|
}
|
|
else if (name.compare("ptrsize") == 0)
|
|
{
|
|
m_pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 0);
|
|
}
|
|
}
|
|
}
|
|
return HostInfoIsValid();
|
|
}
|
|
|
|
int
|
|
GDBRemoteCommunication::SendAttach
|
|
(
|
|
lldb::pid_t pid,
|
|
uint32_t timeout_seconds,
|
|
StringExtractorGDBRemote& response
|
|
)
|
|
{
|
|
if (pid != LLDB_INVALID_PROCESS_ID)
|
|
{
|
|
StreamString packet;
|
|
packet.Printf("vAttach;%x", pid);
|
|
|
|
if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, timeout_seconds, false))
|
|
{
|
|
if (response.IsErrorPacket())
|
|
return response.GetError();
|
|
return 0;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
const lldb_private::ArchSpec &
|
|
GDBRemoteCommunication::GetHostArchitecture ()
|
|
{
|
|
if (!HostInfoIsValid ())
|
|
GetHostInfo (1);
|
|
return m_arch;
|
|
}
|
|
|
|
const lldb_private::ConstString &
|
|
GDBRemoteCommunication::GetOSString ()
|
|
{
|
|
if (!HostInfoIsValid ())
|
|
GetHostInfo (1);
|
|
return m_os;
|
|
}
|
|
|
|
const lldb_private::ConstString &
|
|
GDBRemoteCommunication::GetVendorString()
|
|
{
|
|
if (!HostInfoIsValid ())
|
|
GetHostInfo (1);
|
|
return m_vendor;
|
|
}
|
|
|
|
lldb::ByteOrder
|
|
GDBRemoteCommunication::GetByteOrder ()
|
|
{
|
|
if (!HostInfoIsValid ())
|
|
GetHostInfo (1);
|
|
return m_byte_order;
|
|
}
|
|
|
|
uint32_t
|
|
GDBRemoteCommunication::GetAddressByteSize ()
|
|
{
|
|
if (!HostInfoIsValid ())
|
|
GetHostInfo (1);
|
|
return m_pointer_byte_size;
|
|
}
|
|
|
|
addr_t
|
|
GDBRemoteCommunication::AllocateMemory (size_t size, uint32_t permissions, uint32_t timeout_seconds)
|
|
{
|
|
char packet[64];
|
|
::snprintf (packet, sizeof(packet), "_M%zx,%s%s%s", size,
|
|
permissions & lldb::ePermissionsReadable ? "r" : "",
|
|
permissions & lldb::ePermissionsWritable ? "w" : "",
|
|
permissions & lldb::ePermissionsExecutable ? "x" : "");
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse (packet, response, timeout_seconds, false))
|
|
{
|
|
if (!response.IsErrorPacket())
|
|
return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
|
|
}
|
|
return LLDB_INVALID_ADDRESS;
|
|
}
|
|
|
|
bool
|
|
GDBRemoteCommunication::DeallocateMemory (addr_t addr, uint32_t timeout_seconds)
|
|
{
|
|
char packet[64];
|
|
snprintf(packet, sizeof(packet), "_m%llx", (uint64_t)addr);
|
|
StringExtractorGDBRemote response;
|
|
if (SendPacketAndWaitForResponse (packet, response, timeout_seconds, false))
|
|
{
|
|
if (!response.IsOKPacket())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|