0cb742dafb
Rewrite with hard-coded offsets into the PE file format to discern if a binary is PE32 or PE32+, and then to determine if it contains a "CLR Data Directory" entry that looks valid. Tested with PE32 and PE32+ compiled Mono binaries, PE32 and PE32+ native binaries, and a random assortment of garbage files. Former-commit-id: 9e7ac86ec84f653a2f79b87183efd5b0ebda001b
3242 lines
111 KiB
C++
3242 lines
111 KiB
C++
//===-- GDBRemoteCommunicationServerLLGS.cpp --------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <errno.h>
|
|
|
|
#include "lldb/Host/Config.h"
|
|
|
|
#include "GDBRemoteCommunicationServerLLGS.h"
|
|
#include "lldb/Utility/StreamGDBRemote.h"
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
#include <chrono>
|
|
#include <cstring>
|
|
#include <thread>
|
|
|
|
// Other libraries and framework includes
|
|
#include "lldb/Core/RegisterValue.h"
|
|
#include "lldb/Core/State.h"
|
|
#include "lldb/Host/ConnectionFileDescriptor.h"
|
|
#include "lldb/Host/Debug.h"
|
|
#include "lldb/Host/File.h"
|
|
#include "lldb/Host/FileSystem.h"
|
|
#include "lldb/Host/Host.h"
|
|
#include "lldb/Host/HostInfo.h"
|
|
#include "lldb/Host/PosixApi.h"
|
|
#include "lldb/Host/common/NativeProcessProtocol.h"
|
|
#include "lldb/Host/common/NativeRegisterContext.h"
|
|
#include "lldb/Host/common/NativeThreadProtocol.h"
|
|
#include "lldb/Interpreter/Args.h"
|
|
#include "lldb/Target/FileAction.h"
|
|
#include "lldb/Target/MemoryRegionInfo.h"
|
|
#include "lldb/Utility/DataBuffer.h"
|
|
#include "lldb/Utility/Endian.h"
|
|
#include "lldb/Utility/JSON.h"
|
|
#include "lldb/Utility/LLDBAssert.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
#include "lldb/Utility/UriParser.h"
|
|
#include "llvm/ADT/Triple.h"
|
|
#include "llvm/Support/ScopedPrinter.h"
|
|
|
|
// Project includes
|
|
#include "ProcessGDBRemote.h"
|
|
#include "ProcessGDBRemoteLog.h"
|
|
#include "Utility/StringExtractorGDBRemote.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
using namespace lldb_private::process_gdb_remote;
|
|
using namespace llvm;
|
|
|
|
//----------------------------------------------------------------------
|
|
// GDBRemote Errors
|
|
//----------------------------------------------------------------------
|
|
|
|
namespace {
|
|
enum GDBRemoteServerError {
|
|
// Set to the first unused error number in literal form below
|
|
eErrorFirst = 29,
|
|
eErrorNoProcess = eErrorFirst,
|
|
eErrorResume,
|
|
eErrorExitStatus
|
|
};
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// GDBRemoteCommunicationServerLLGS constructor
|
|
//----------------------------------------------------------------------
|
|
GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
|
|
MainLoop &mainloop, const NativeProcessProtocol::Factory &process_factory)
|
|
: GDBRemoteCommunicationServerCommon("gdb-remote.server",
|
|
"gdb-remote.server.rx_packet"),
|
|
m_mainloop(mainloop), m_process_factory(process_factory),
|
|
m_stdio_communication("process.stdio") {
|
|
RegisterPacketHandlers();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() {
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_C);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_c);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_D);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_H);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_I);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_interrupt,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_interrupt);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_m,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_memory_read);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_M);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_p);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_P);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qC);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qfThreadInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qRegisterInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qsThreadInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_jThreadsInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_s);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_stop_reason,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ?
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_vAttach,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_vAttach);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_vCont,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_vCont);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_vCont_actions,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_vCont_actions);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_x,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_memory_read);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_Z);
|
|
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_z);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_QPassSignals,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_QPassSignals);
|
|
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_jTraceStart,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_jTraceStart);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_jTraceStop,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
|
|
RegisterMemberFunctionHandler(
|
|
StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
|
|
&GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);
|
|
|
|
RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
|
|
[this](StringExtractorGDBRemote packet, Status &error,
|
|
bool &interrupt, bool &quit) {
|
|
quit = true;
|
|
return this->Handle_k(packet);
|
|
});
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) {
|
|
m_process_launch_info = info;
|
|
}
|
|
|
|
Status GDBRemoteCommunicationServerLLGS::LaunchProcess() {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
if (!m_process_launch_info.GetArguments().GetArgumentCount())
|
|
return Status("%s: no process command line specified to launch",
|
|
__FUNCTION__);
|
|
|
|
const bool should_forward_stdio =
|
|
m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr ||
|
|
m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr ||
|
|
m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr;
|
|
m_process_launch_info.SetLaunchInSeparateProcessGroup(true);
|
|
m_process_launch_info.GetFlags().Set(eLaunchFlagDebug);
|
|
|
|
const bool default_to_use_pty = true;
|
|
m_process_launch_info.FinalizeFileActions(nullptr, default_to_use_pty);
|
|
|
|
{
|
|
std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
|
|
assert(!m_debugged_process_up && "lldb-server creating debugged "
|
|
"process but one already exists");
|
|
auto process_or =
|
|
m_process_factory.Launch(m_process_launch_info, *this, m_mainloop);
|
|
if (!process_or)
|
|
return Status(process_or.takeError());
|
|
m_debugged_process_up = std::move(*process_or);
|
|
}
|
|
|
|
// Handle mirroring of inferior stdout/stderr over the gdb-remote protocol
|
|
// as needed.
|
|
// llgs local-process debugging may specify PTY paths, which will make these
|
|
// file actions non-null
|
|
// process launch -i/e/o will also make these file actions non-null
|
|
// nullptr means that the traffic is expected to flow over gdb-remote protocol
|
|
if (should_forward_stdio) {
|
|
// nullptr means it's not redirected to file or pty (in case of LLGS local)
|
|
// at least one of stdio will be transferred pty<->gdb-remote
|
|
// we need to give the pty master handle to this object to read and/or write
|
|
LLDB_LOG(log,
|
|
"pid = {0}: setting up stdout/stderr redirection via $O "
|
|
"gdb-remote commands",
|
|
m_debugged_process_up->GetID());
|
|
|
|
// Setup stdout/stderr mapping from inferior to $O
|
|
auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor();
|
|
if (terminal_fd >= 0) {
|
|
if (log)
|
|
log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting "
|
|
"inferior STDIO fd to %d",
|
|
__FUNCTION__, terminal_fd);
|
|
Status status = SetSTDIOFileDescriptor(terminal_fd);
|
|
if (status.Fail())
|
|
return status;
|
|
} else {
|
|
if (log)
|
|
log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring "
|
|
"inferior STDIO since terminal fd reported as %d",
|
|
__FUNCTION__, terminal_fd);
|
|
}
|
|
} else {
|
|
LLDB_LOG(log,
|
|
"pid = {0} skipping stdout/stderr redirection via $O: inferior "
|
|
"will communicate over client-provided file descriptors",
|
|
m_debugged_process_up->GetID());
|
|
}
|
|
|
|
printf("Launched '%s' as process %" PRIu64 "...\n",
|
|
m_process_launch_info.GetArguments().GetArgumentAtIndex(0),
|
|
m_debugged_process_up->GetID());
|
|
|
|
return Status();
|
|
}
|
|
|
|
Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64,
|
|
__FUNCTION__, pid);
|
|
|
|
// Before we try to attach, make sure we aren't already monitoring something
|
|
// else.
|
|
if (m_debugged_process_up &&
|
|
m_debugged_process_up->GetID() != LLDB_INVALID_PROCESS_ID)
|
|
return Status("cannot attach to a process %" PRIu64
|
|
" when another process with pid %" PRIu64
|
|
" is being debugged.",
|
|
pid, m_debugged_process_up->GetID());
|
|
|
|
// Try to attach.
|
|
auto process_or = m_process_factory.Attach(pid, *this, m_mainloop);
|
|
if (!process_or) {
|
|
Status status(process_or.takeError());
|
|
llvm::errs() << llvm::formatv("failed to attach to process {0}: {1}", pid,
|
|
status);
|
|
return status;
|
|
}
|
|
m_debugged_process_up = std::move(*process_or);
|
|
|
|
// Setup stdout/stderr mapping from inferior.
|
|
auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor();
|
|
if (terminal_fd >= 0) {
|
|
if (log)
|
|
log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting "
|
|
"inferior STDIO fd to %d",
|
|
__FUNCTION__, terminal_fd);
|
|
Status status = SetSTDIOFileDescriptor(terminal_fd);
|
|
if (status.Fail())
|
|
return status;
|
|
} else {
|
|
if (log)
|
|
log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring "
|
|
"inferior STDIO since terminal fd reported as %d",
|
|
__FUNCTION__, terminal_fd);
|
|
}
|
|
|
|
printf("Attached to process %" PRIu64 "...\n", pid);
|
|
return Status();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::InitializeDelegate(
|
|
NativeProcessProtocol *process) {
|
|
assert(process && "process cannot be NULL");
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
if (log) {
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s called with "
|
|
"NativeProcessProtocol pid %" PRIu64 ", current state: %s",
|
|
__FUNCTION__, process->GetID(),
|
|
StateAsCString(process->GetState()));
|
|
}
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::SendWResponse(
|
|
NativeProcessProtocol *process) {
|
|
assert(process && "process cannot be NULL");
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
// send W notification
|
|
auto wait_status = process->GetExitStatus();
|
|
if (!wait_status) {
|
|
LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status",
|
|
process->GetID());
|
|
|
|
StreamGDBRemote response;
|
|
response.PutChar('E');
|
|
response.PutHex8(GDBRemoteServerError::eErrorExitStatus);
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(),
|
|
*wait_status);
|
|
|
|
StreamGDBRemote response;
|
|
response.Format("{0:g}", *wait_status);
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
static void AppendHexValue(StreamString &response, const uint8_t *buf,
|
|
uint32_t buf_size, bool swap) {
|
|
int64_t i;
|
|
if (swap) {
|
|
for (i = buf_size - 1; i >= 0; i--)
|
|
response.PutHex8(buf[i]);
|
|
} else {
|
|
for (i = 0; i < buf_size; i++)
|
|
response.PutHex8(buf[i]);
|
|
}
|
|
}
|
|
|
|
static void WriteRegisterValueInHexFixedWidth(
|
|
StreamString &response, NativeRegisterContext ®_ctx,
|
|
const RegisterInfo ®_info, const RegisterValue *reg_value_p,
|
|
lldb::ByteOrder byte_order) {
|
|
RegisterValue reg_value;
|
|
if (!reg_value_p) {
|
|
Status error = reg_ctx.ReadRegister(®_info, reg_value);
|
|
if (error.Success())
|
|
reg_value_p = ®_value;
|
|
// else log.
|
|
}
|
|
|
|
if (reg_value_p) {
|
|
AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(),
|
|
reg_value_p->GetByteSize(),
|
|
byte_order == lldb::eByteOrderLittle);
|
|
} else {
|
|
// Zero-out any unreadable values.
|
|
if (reg_info.byte_size > 0) {
|
|
std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
|
|
AppendHexValue(response, zeros.data(), zeros.size(), false);
|
|
}
|
|
}
|
|
}
|
|
|
|
static JSONObject::SP GetRegistersAsJSON(NativeThreadProtocol &thread) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
NativeRegisterContext& reg_ctx = thread.GetRegisterContext();
|
|
|
|
JSONObject::SP register_object_sp = std::make_shared<JSONObject>();
|
|
|
|
#ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET
|
|
// Expedite all registers in the first register set (i.e. should be GPRs) that
|
|
// are not contained in other registers.
|
|
const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0);
|
|
if (!reg_set_p)
|
|
return nullptr;
|
|
for (const uint32_t *reg_num_p = reg_set_p->registers;
|
|
*reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) {
|
|
uint32_t reg_num = *reg_num_p;
|
|
#else
|
|
// Expedite only a couple of registers until we figure out why sending
|
|
// registers is
|
|
// expensive.
|
|
static const uint32_t k_expedited_registers[] = {
|
|
LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP,
|
|
LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM};
|
|
|
|
for (const uint32_t *generic_reg_p = k_expedited_registers;
|
|
*generic_reg_p != LLDB_INVALID_REGNUM; ++generic_reg_p) {
|
|
uint32_t reg_num = reg_ctx.ConvertRegisterKindToRegisterNumber(
|
|
eRegisterKindGeneric, *generic_reg_p);
|
|
if (reg_num == LLDB_INVALID_REGNUM)
|
|
continue; // Target does not support the given register.
|
|
#endif
|
|
|
|
const RegisterInfo *const reg_info_p =
|
|
reg_ctx.GetRegisterInfoAtIndex(reg_num);
|
|
if (reg_info_p == nullptr) {
|
|
if (log)
|
|
log->Printf(
|
|
"%s failed to get register info for register index %" PRIu32,
|
|
__FUNCTION__, reg_num);
|
|
continue;
|
|
}
|
|
|
|
if (reg_info_p->value_regs != nullptr)
|
|
continue; // Only expedite registers that are not contained in other
|
|
// registers.
|
|
|
|
RegisterValue reg_value;
|
|
Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s",
|
|
__FUNCTION__,
|
|
reg_info_p->name ? reg_info_p->name : "<unnamed-register>",
|
|
reg_num, error.AsCString());
|
|
continue;
|
|
}
|
|
|
|
StreamString stream;
|
|
WriteRegisterValueInHexFixedWidth(stream, reg_ctx, *reg_info_p,
|
|
®_value, lldb::eByteOrderBig);
|
|
|
|
register_object_sp->SetObject(
|
|
llvm::to_string(reg_num),
|
|
std::make_shared<JSONString>(stream.GetString()));
|
|
}
|
|
|
|
return register_object_sp;
|
|
}
|
|
|
|
static const char *GetStopReasonString(StopReason stop_reason) {
|
|
switch (stop_reason) {
|
|
case eStopReasonTrace:
|
|
return "trace";
|
|
case eStopReasonBreakpoint:
|
|
return "breakpoint";
|
|
case eStopReasonWatchpoint:
|
|
return "watchpoint";
|
|
case eStopReasonSignal:
|
|
return "signal";
|
|
case eStopReasonException:
|
|
return "exception";
|
|
case eStopReasonExec:
|
|
return "exec";
|
|
case eStopReasonInstrumentation:
|
|
case eStopReasonInvalid:
|
|
case eStopReasonPlanComplete:
|
|
case eStopReasonThreadExiting:
|
|
case eStopReasonNone:
|
|
break; // ignored
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process,
|
|
bool abridged) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
|
|
JSONArray::SP threads_array_sp = std::make_shared<JSONArray>();
|
|
|
|
// Ensure we can get info on the given thread.
|
|
uint32_t thread_idx = 0;
|
|
for (NativeThreadProtocol *thread;
|
|
(thread = process.GetThreadAtIndex(thread_idx)) != nullptr;
|
|
++thread_idx) {
|
|
|
|
lldb::tid_t tid = thread->GetID();
|
|
|
|
// Grab the reason this thread stopped.
|
|
struct ThreadStopInfo tid_stop_info;
|
|
std::string description;
|
|
if (!thread->GetStopReason(tid_stop_info, description))
|
|
return nullptr;
|
|
|
|
const int signum = tid_stop_info.details.signal.signo;
|
|
if (log) {
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
|
|
" tid %" PRIu64
|
|
" got signal signo = %d, reason = %d, exc_type = %" PRIu64,
|
|
__FUNCTION__, process.GetID(), tid, signum,
|
|
tid_stop_info.reason, tid_stop_info.details.exception.type);
|
|
}
|
|
|
|
JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
|
|
threads_array_sp->AppendObject(thread_obj_sp);
|
|
|
|
if (!abridged) {
|
|
if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread))
|
|
thread_obj_sp->SetObject("registers", registers_sp);
|
|
}
|
|
|
|
thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
|
|
if (signum != 0)
|
|
thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum));
|
|
|
|
const std::string thread_name = thread->GetName();
|
|
if (!thread_name.empty())
|
|
thread_obj_sp->SetObject("name",
|
|
std::make_shared<JSONString>(thread_name));
|
|
|
|
if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
|
|
thread_obj_sp->SetObject("reason",
|
|
std::make_shared<JSONString>(stop_reason_str));
|
|
|
|
if (!description.empty())
|
|
thread_obj_sp->SetObject("description",
|
|
std::make_shared<JSONString>(description));
|
|
|
|
if ((tid_stop_info.reason == eStopReasonException) &&
|
|
tid_stop_info.details.exception.type) {
|
|
thread_obj_sp->SetObject(
|
|
"metype",
|
|
std::make_shared<JSONNumber>(tid_stop_info.details.exception.type));
|
|
|
|
JSONArray::SP medata_array_sp = std::make_shared<JSONArray>();
|
|
for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count;
|
|
++i) {
|
|
medata_array_sp->AppendObject(std::make_shared<JSONNumber>(
|
|
tid_stop_info.details.exception.data[i]));
|
|
}
|
|
thread_obj_sp->SetObject("medata", medata_array_sp);
|
|
}
|
|
|
|
// TODO: Expedite interesting regions of inferior memory
|
|
}
|
|
|
|
return threads_array_sp;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
|
|
lldb::tid_t tid) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
|
|
// Ensure we have a debugged process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(50);
|
|
|
|
LLDB_LOG(log, "preparing packet for pid {0} tid {1}",
|
|
m_debugged_process_up->GetID(), tid);
|
|
|
|
// Ensure we can get info on the given thread.
|
|
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
|
|
if (!thread)
|
|
return SendErrorResponse(51);
|
|
|
|
// Grab the reason this thread stopped.
|
|
struct ThreadStopInfo tid_stop_info;
|
|
std::string description;
|
|
if (!thread->GetStopReason(tid_stop_info, description))
|
|
return SendErrorResponse(52);
|
|
|
|
// FIXME implement register handling for exec'd inferiors.
|
|
// if (tid_stop_info.reason == eStopReasonExec)
|
|
// {
|
|
// const bool force = true;
|
|
// InitializeRegisters(force);
|
|
// }
|
|
|
|
StreamString response;
|
|
// Output the T packet with the thread
|
|
response.PutChar('T');
|
|
int signum = tid_stop_info.details.signal.signo;
|
|
LLDB_LOG(
|
|
log,
|
|
"pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}",
|
|
m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info.reason),
|
|
tid_stop_info.details.exception.type);
|
|
|
|
// Print the signal number.
|
|
response.PutHex8(signum & 0xff);
|
|
|
|
// Include the tid.
|
|
response.Printf("thread:%" PRIx64 ";", tid);
|
|
|
|
// Include the thread name if there is one.
|
|
const std::string thread_name = thread->GetName();
|
|
if (!thread_name.empty()) {
|
|
size_t thread_name_len = thread_name.length();
|
|
|
|
if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) {
|
|
response.PutCString("name:");
|
|
response.PutCString(thread_name);
|
|
} else {
|
|
// The thread name contains special chars, send as hex bytes.
|
|
response.PutCString("hexname:");
|
|
response.PutCStringAsRawHex8(thread_name.c_str());
|
|
}
|
|
response.PutChar(';');
|
|
}
|
|
|
|
// If a 'QListThreadsInStopReply' was sent to enable this feature, we
|
|
// will send all thread IDs back in the "threads" key whose value is
|
|
// a list of hex thread IDs separated by commas:
|
|
// "threads:10a,10b,10c;"
|
|
// This will save the debugger from having to send a pair of qfThreadInfo
|
|
// and qsThreadInfo packets, but it also might take a lot of room in the
|
|
// stop reply packet, so it must be enabled only on systems where there
|
|
// are no limits on packet lengths.
|
|
if (m_list_threads_in_stop_reply) {
|
|
response.PutCString("threads:");
|
|
|
|
uint32_t thread_index = 0;
|
|
NativeThreadProtocol *listed_thread;
|
|
for (listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
|
|
listed_thread; ++thread_index,
|
|
listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
|
|
if (thread_index > 0)
|
|
response.PutChar(',');
|
|
response.Printf("%" PRIx64, listed_thread->GetID());
|
|
}
|
|
response.PutChar(';');
|
|
|
|
// Include JSON info that describes the stop reason for any threads
|
|
// that actually have stop reasons. We use the new "jstopinfo" key
|
|
// whose values is hex ascii JSON that contains the thread IDs
|
|
// thread stop info only for threads that have stop reasons. Only send
|
|
// this if we have more than one thread otherwise this packet has all
|
|
// the info it needs.
|
|
if (thread_index > 0) {
|
|
const bool threads_with_valid_stop_info_only = true;
|
|
JSONArray::SP threads_info_sp = GetJSONThreadsInfo(
|
|
*m_debugged_process_up, threads_with_valid_stop_info_only);
|
|
if (threads_info_sp) {
|
|
response.PutCString("jstopinfo:");
|
|
StreamString unescaped_response;
|
|
threads_info_sp->Write(unescaped_response);
|
|
response.PutCStringAsRawHex8(unescaped_response.GetData());
|
|
response.PutChar(';');
|
|
} else
|
|
LLDB_LOG(log, "failed to prepare a jstopinfo field for pid {0}",
|
|
m_debugged_process_up->GetID());
|
|
}
|
|
|
|
uint32_t i = 0;
|
|
response.PutCString("thread-pcs");
|
|
char delimiter = ':';
|
|
for (NativeThreadProtocol *thread;
|
|
(thread = m_debugged_process_up->GetThreadAtIndex(i)) != nullptr;
|
|
++i) {
|
|
NativeRegisterContext& reg_ctx = thread->GetRegisterContext();
|
|
|
|
uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber(
|
|
eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
|
|
const RegisterInfo *const reg_info_p =
|
|
reg_ctx.GetRegisterInfoAtIndex(reg_to_read);
|
|
|
|
RegisterValue reg_value;
|
|
Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s",
|
|
__FUNCTION__,
|
|
reg_info_p->name ? reg_info_p->name
|
|
: "<unnamed-register>",
|
|
reg_to_read, error.AsCString());
|
|
continue;
|
|
}
|
|
|
|
response.PutChar(delimiter);
|
|
delimiter = ',';
|
|
WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
|
|
®_value, endian::InlHostByteOrder());
|
|
}
|
|
|
|
response.PutChar(';');
|
|
}
|
|
|
|
//
|
|
// Expedite registers.
|
|
//
|
|
|
|
// Grab the register context.
|
|
NativeRegisterContext& reg_ctx = thread->GetRegisterContext();
|
|
// Expedite all registers in the first register set (i.e. should be GPRs)
|
|
// that are not contained in other registers.
|
|
const RegisterSet *reg_set_p;
|
|
if (reg_ctx.GetRegisterSetCount() > 0 &&
|
|
((reg_set_p = reg_ctx.GetRegisterSet(0)) != nullptr)) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s expediting registers "
|
|
"from set '%s' (registers set count: %zu)",
|
|
__FUNCTION__,
|
|
reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
|
|
reg_set_p->num_registers);
|
|
|
|
for (const uint32_t *reg_num_p = reg_set_p->registers;
|
|
*reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) {
|
|
const RegisterInfo *const reg_info_p =
|
|
reg_ctx.GetRegisterInfoAtIndex(*reg_num_p);
|
|
if (reg_info_p == nullptr) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get "
|
|
"register info for register set '%s', register index "
|
|
"%" PRIu32,
|
|
__FUNCTION__,
|
|
reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
|
|
*reg_num_p);
|
|
} else if (reg_info_p->value_regs == nullptr) {
|
|
// Only expediate registers that are not contained in other registers.
|
|
RegisterValue reg_value;
|
|
Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
|
|
if (error.Success()) {
|
|
response.Printf("%.02x:", *reg_num_p);
|
|
WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
|
|
®_value, lldb::eByteOrderBig);
|
|
response.PutChar(';');
|
|
} else {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to read "
|
|
"register '%s' index %" PRIu32 ": %s",
|
|
__FUNCTION__,
|
|
reg_info_p->name ? reg_info_p->name
|
|
: "<unnamed-register>",
|
|
*reg_num_p, error.AsCString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const char *reason_str = GetStopReasonString(tid_stop_info.reason);
|
|
if (reason_str != nullptr) {
|
|
response.Printf("reason:%s;", reason_str);
|
|
}
|
|
|
|
if (!description.empty()) {
|
|
// Description may contains special chars, send as hex bytes.
|
|
response.PutCString("description:");
|
|
response.PutCStringAsRawHex8(description.c_str());
|
|
response.PutChar(';');
|
|
} else if ((tid_stop_info.reason == eStopReasonException) &&
|
|
tid_stop_info.details.exception.type) {
|
|
response.PutCString("metype:");
|
|
response.PutHex64(tid_stop_info.details.exception.type);
|
|
response.PutCString(";mecount:");
|
|
response.PutHex32(tid_stop_info.details.exception.data_count);
|
|
response.PutChar(';');
|
|
|
|
for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) {
|
|
response.PutCString("medata:");
|
|
response.PutHex64(tid_stop_info.details.exception.data[i]);
|
|
response.PutChar(';');
|
|
}
|
|
}
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited(
|
|
NativeProcessProtocol *process) {
|
|
assert(process && "process cannot be NULL");
|
|
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
|
|
|
|
PacketResult result = SendStopReasonForState(StateType::eStateExited);
|
|
if (result != PacketResult::Success) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop "
|
|
"notification for PID %" PRIu64 ", state: eStateExited",
|
|
__FUNCTION__, process->GetID());
|
|
}
|
|
|
|
// Close the pipe to the inferior terminal i/o if we launched it
|
|
// and set one up.
|
|
MaybeCloseInferiorTerminalConnection();
|
|
|
|
// We are ready to exit the debug monitor.
|
|
m_exit_now = true;
|
|
m_mainloop.RequestTermination();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped(
|
|
NativeProcessProtocol *process) {
|
|
assert(process && "process cannot be NULL");
|
|
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
|
|
|
|
// Send the stop reason unless this is the stop after the
|
|
// launch or attach.
|
|
switch (m_inferior_prev_state) {
|
|
case eStateLaunching:
|
|
case eStateAttaching:
|
|
// Don't send anything per debugserver behavior.
|
|
break;
|
|
default:
|
|
// In all other cases, send the stop reason.
|
|
PacketResult result = SendStopReasonForState(StateType::eStateStopped);
|
|
if (result != PacketResult::Success) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop "
|
|
"notification for PID %" PRIu64 ", state: eStateExited",
|
|
__FUNCTION__, process->GetID());
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::ProcessStateChanged(
|
|
NativeProcessProtocol *process, lldb::StateType state) {
|
|
assert(process && "process cannot be NULL");
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
if (log) {
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s called with "
|
|
"NativeProcessProtocol pid %" PRIu64 ", state: %s",
|
|
__FUNCTION__, process->GetID(), StateAsCString(state));
|
|
}
|
|
|
|
switch (state) {
|
|
case StateType::eStateRunning:
|
|
StartSTDIOForwarding();
|
|
break;
|
|
|
|
case StateType::eStateStopped:
|
|
// Make sure we get all of the pending stdout/stderr from the inferior
|
|
// and send it to the lldb host before we send the state change
|
|
// notification
|
|
SendProcessOutput();
|
|
// Then stop the forwarding, so that any late output (see llvm.org/pr25652)
|
|
// does not
|
|
// interfere with our protocol.
|
|
StopSTDIOForwarding();
|
|
HandleInferiorState_Stopped(process);
|
|
break;
|
|
|
|
case StateType::eStateExited:
|
|
// Same as above
|
|
SendProcessOutput();
|
|
StopSTDIOForwarding();
|
|
HandleInferiorState_Exited(process);
|
|
break;
|
|
|
|
default:
|
|
if (log) {
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s didn't handle state "
|
|
"change for pid %" PRIu64 ", new state: %s",
|
|
__FUNCTION__, process->GetID(), StateAsCString(state));
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Remember the previous state reported to us.
|
|
m_inferior_prev_state = state;
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::DidExec(NativeProcessProtocol *process) {
|
|
ClearProcessSpecificData();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::DataAvailableCallback() {
|
|
Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_COMM));
|
|
|
|
if (!m_handshake_completed) {
|
|
if (!HandshakeWithClient()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with "
|
|
"client failed, exiting",
|
|
__FUNCTION__);
|
|
m_mainloop.RequestTermination();
|
|
return;
|
|
}
|
|
m_handshake_completed = true;
|
|
}
|
|
|
|
bool interrupt = false;
|
|
bool done = false;
|
|
Status error;
|
|
while (true) {
|
|
const PacketResult result = GetPacketAndSendResponse(
|
|
std::chrono::microseconds(0), error, interrupt, done);
|
|
if (result == PacketResult::ErrorReplyTimeout)
|
|
break; // No more packets in the queue
|
|
|
|
if ((result != PacketResult::Success)) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet "
|
|
"failed: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
m_mainloop.RequestTermination();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
Status GDBRemoteCommunicationServerLLGS::InitializeConnection(
|
|
std::unique_ptr<Connection> &&connection) {
|
|
IOObjectSP read_object_sp = connection->GetReadObject();
|
|
GDBRemoteCommunicationServer::SetConnection(connection.release());
|
|
|
|
Status error;
|
|
m_network_handle_up = m_mainloop.RegisterReadObject(
|
|
read_object_sp, [this](MainLoopBase &) { DataAvailableCallback(); },
|
|
error);
|
|
return error;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::SendONotification(const char *buffer,
|
|
uint32_t len) {
|
|
if ((buffer == nullptr) || (len == 0)) {
|
|
// Nothing to send.
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
StreamString response;
|
|
response.PutChar('O');
|
|
response.PutBytesAsRawHex8(buffer, len);
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
Status GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) {
|
|
Status error;
|
|
|
|
// Set up the reading/handling of process I/O
|
|
std::unique_ptr<ConnectionFileDescriptor> conn_up(
|
|
new ConnectionFileDescriptor(fd, true));
|
|
if (!conn_up) {
|
|
error.SetErrorString("failed to create ConnectionFileDescriptor");
|
|
return error;
|
|
}
|
|
|
|
m_stdio_communication.SetCloseOnEOF(false);
|
|
m_stdio_communication.SetConnection(conn_up.release());
|
|
if (!m_stdio_communication.IsConnected()) {
|
|
error.SetErrorString(
|
|
"failed to set connection for inferior I/O communication");
|
|
return error;
|
|
}
|
|
|
|
return Status();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() {
|
|
// Don't forward if not connected (e.g. when attaching).
|
|
if (!m_stdio_communication.IsConnected())
|
|
return;
|
|
|
|
Status error;
|
|
lldbassert(!m_stdio_handle_up);
|
|
m_stdio_handle_up = m_mainloop.RegisterReadObject(
|
|
m_stdio_communication.GetConnection()->GetReadObject(),
|
|
[this](MainLoopBase &) { SendProcessOutput(); }, error);
|
|
|
|
if (!m_stdio_handle_up) {
|
|
// Not much we can do about the failure. Log it and continue without
|
|
// forwarding.
|
|
if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS))
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio "
|
|
"forwarding: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
}
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() {
|
|
m_stdio_handle_up.reset();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::SendProcessOutput() {
|
|
char buffer[1024];
|
|
ConnectionStatus status;
|
|
Status error;
|
|
while (true) {
|
|
size_t bytes_read = m_stdio_communication.Read(
|
|
buffer, sizeof buffer, std::chrono::microseconds(0), status, &error);
|
|
switch (status) {
|
|
case eConnectionStatusSuccess:
|
|
SendONotification(buffer, bytes_read);
|
|
break;
|
|
case eConnectionStatusLostConnection:
|
|
case eConnectionStatusEndOfFile:
|
|
case eConnectionStatusError:
|
|
case eConnectionStatusNoConnection:
|
|
if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS))
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s Stopping stdio "
|
|
"forwarding as communication returned status %d (error: "
|
|
"%s)",
|
|
__FUNCTION__, status, error.AsCString());
|
|
m_stdio_handle_up.reset();
|
|
return;
|
|
|
|
case eConnectionStatusInterrupted:
|
|
case eConnectionStatusTimedOut:
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_jTraceStart(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
if (!packet.ConsumeFront("jTraceStart:"))
|
|
return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
|
|
|
|
TraceOptions options;
|
|
uint64_t type = std::numeric_limits<uint64_t>::max();
|
|
uint64_t buffersize = std::numeric_limits<uint64_t>::max();
|
|
lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
|
|
uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
|
|
|
|
auto json_object = StructuredData::ParseJSON(packet.Peek());
|
|
|
|
if (!json_object ||
|
|
json_object->GetType() != lldb::eStructuredDataTypeDictionary)
|
|
return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
|
|
|
|
auto json_dict = json_object->GetAsDictionary();
|
|
|
|
json_dict->GetValueForKeyAsInteger("metabuffersize", metabuffersize);
|
|
options.setMetaDataBufferSize(metabuffersize);
|
|
|
|
json_dict->GetValueForKeyAsInteger("buffersize", buffersize);
|
|
options.setTraceBufferSize(buffersize);
|
|
|
|
json_dict->GetValueForKeyAsInteger("type", type);
|
|
options.setType(static_cast<lldb::TraceType>(type));
|
|
|
|
json_dict->GetValueForKeyAsInteger("threadid", tid);
|
|
options.setThreadID(tid);
|
|
|
|
StructuredData::ObjectSP custom_params_sp =
|
|
json_dict->GetValueForKey("params");
|
|
if (custom_params_sp &&
|
|
custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary)
|
|
return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");
|
|
|
|
options.setTraceParams(
|
|
static_pointer_cast<StructuredData::Dictionary>(custom_params_sp));
|
|
|
|
if (buffersize == std::numeric_limits<uint64_t>::max() ||
|
|
type != lldb::TraceType::eTraceTypeProcessorTrace) {
|
|
LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize,
|
|
type);
|
|
return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet ");
|
|
}
|
|
|
|
Status error;
|
|
lldb::user_id_t uid = LLDB_INVALID_UID;
|
|
uid = m_debugged_process_up->StartTrace(options, error);
|
|
LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError());
|
|
if (error.Fail())
|
|
return SendErrorResponse(error);
|
|
|
|
StreamGDBRemote response;
|
|
response.Printf("%" PRIx64, uid);
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_jTraceStop(
|
|
StringExtractorGDBRemote &packet) {
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
if (!packet.ConsumeFront("jTraceStop:"))
|
|
return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
|
|
|
|
lldb::user_id_t uid = LLDB_INVALID_UID;
|
|
lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
|
|
|
|
auto json_object = StructuredData::ParseJSON(packet.Peek());
|
|
|
|
if (!json_object ||
|
|
json_object->GetType() != lldb::eStructuredDataTypeDictionary)
|
|
return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
|
|
|
|
auto json_dict = json_object->GetAsDictionary();
|
|
|
|
if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
|
|
return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");
|
|
|
|
json_dict->GetValueForKeyAsInteger("threadid", tid);
|
|
|
|
Status error = m_debugged_process_up->StopTrace(uid, tid);
|
|
|
|
if (error.Fail())
|
|
return SendErrorResponse(error);
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead(
|
|
StringExtractorGDBRemote &packet) {
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
if (!packet.ConsumeFront("jTraceConfigRead:"))
|
|
return SendIllFormedResponse(packet,
|
|
"jTraceConfigRead: Ill formed packet ");
|
|
|
|
lldb::user_id_t uid = LLDB_INVALID_UID;
|
|
lldb::tid_t threadid = LLDB_INVALID_THREAD_ID;
|
|
|
|
auto json_object = StructuredData::ParseJSON(packet.Peek());
|
|
|
|
if (!json_object ||
|
|
json_object->GetType() != lldb::eStructuredDataTypeDictionary)
|
|
return SendIllFormedResponse(packet,
|
|
"jTraceConfigRead: Ill formed packet ");
|
|
|
|
auto json_dict = json_object->GetAsDictionary();
|
|
|
|
if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
|
|
return SendIllFormedResponse(packet,
|
|
"jTraceConfigRead: Ill formed packet ");
|
|
|
|
json_dict->GetValueForKeyAsInteger("threadid", threadid);
|
|
|
|
TraceOptions options;
|
|
StreamGDBRemote response;
|
|
|
|
options.setThreadID(threadid);
|
|
Status error = m_debugged_process_up->GetTraceConfig(uid, options);
|
|
|
|
if (error.Fail())
|
|
return SendErrorResponse(error);
|
|
|
|
StreamGDBRemote escaped_response;
|
|
StructuredData::Dictionary json_packet;
|
|
|
|
json_packet.AddIntegerItem("type", options.getType());
|
|
json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
|
|
json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
|
|
|
|
StructuredData::DictionarySP custom_params = options.getTraceParams();
|
|
if (custom_params)
|
|
json_packet.AddItem("params", custom_params);
|
|
|
|
StreamString json_string;
|
|
json_packet.Dump(json_string, false);
|
|
escaped_response.PutEscapedBytes(json_string.GetData(),
|
|
json_string.GetSize());
|
|
return SendPacketNoLock(escaped_response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_jTraceRead(
|
|
StringExtractorGDBRemote &packet) {
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
enum PacketType { MetaData, BufferData };
|
|
PacketType tracetype = MetaData;
|
|
|
|
if (packet.ConsumeFront("jTraceBufferRead:"))
|
|
tracetype = BufferData;
|
|
else if (packet.ConsumeFront("jTraceMetaRead:"))
|
|
tracetype = MetaData;
|
|
else {
|
|
return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
|
|
}
|
|
|
|
lldb::user_id_t uid = LLDB_INVALID_UID;
|
|
|
|
uint64_t byte_count = std::numeric_limits<uint64_t>::max();
|
|
lldb::tid_t tid = LLDB_INVALID_THREAD_ID;
|
|
uint64_t offset = std::numeric_limits<uint64_t>::max();
|
|
|
|
auto json_object = StructuredData::ParseJSON(packet.Peek());
|
|
|
|
if (!json_object ||
|
|
json_object->GetType() != lldb::eStructuredDataTypeDictionary)
|
|
return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
|
|
|
|
auto json_dict = json_object->GetAsDictionary();
|
|
|
|
if (!json_dict->GetValueForKeyAsInteger("traceid", uid) ||
|
|
!json_dict->GetValueForKeyAsInteger("offset", offset) ||
|
|
!json_dict->GetValueForKeyAsInteger("buffersize", byte_count))
|
|
return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
|
|
|
|
json_dict->GetValueForKeyAsInteger("threadid", tid);
|
|
|
|
// Allocate the response buffer.
|
|
std::unique_ptr<uint8_t[]> buffer (new (std::nothrow) uint8_t[byte_count]);
|
|
if (!buffer)
|
|
return SendErrorResponse(0x78);
|
|
|
|
StreamGDBRemote response;
|
|
Status error;
|
|
llvm::MutableArrayRef<uint8_t> buf(buffer.get(), byte_count);
|
|
|
|
if (tracetype == BufferData)
|
|
error = m_debugged_process_up->GetData(uid, tid, buf, offset);
|
|
else if (tracetype == MetaData)
|
|
error = m_debugged_process_up->GetMetaData(uid, tid, buf, offset);
|
|
|
|
if (error.Fail())
|
|
return SendErrorResponse(error);
|
|
|
|
for (auto i : buf)
|
|
response.PutHex8(i);
|
|
|
|
StreamGDBRemote escaped_response;
|
|
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
|
|
return SendPacketNoLock(escaped_response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
lldb::pid_t pid = m_debugged_process_up->GetID();
|
|
|
|
if (pid == LLDB_INVALID_PROCESS_ID)
|
|
return SendErrorResponse(1);
|
|
|
|
ProcessInstanceInfo proc_info;
|
|
if (!Host::GetProcessInfo(pid, proc_info))
|
|
return SendErrorResponse(1);
|
|
|
|
StreamString response;
|
|
CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) {
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
// Make sure we set the current thread so g and p packets return
|
|
// the data the gdb will expect.
|
|
lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
|
|
SetCurrentThreadID(tid);
|
|
|
|
NativeThreadProtocol *thread = m_debugged_process_up->GetCurrentThread();
|
|
if (!thread)
|
|
return SendErrorResponse(69);
|
|
|
|
StreamString response;
|
|
response.Printf("QC%" PRIx64, thread->GetID());
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
StopSTDIOForwarding();
|
|
|
|
if (!m_debugged_process_up) {
|
|
LLDB_LOG(log, "No debugged process found.");
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
Status error = m_debugged_process_up->Kill();
|
|
if (error.Fail())
|
|
LLDB_LOG(log, "Failed to kill debugged process {0}: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
|
|
// No OK response for kill packet.
|
|
// return SendOKResponse ();
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR(
|
|
StringExtractorGDBRemote &packet) {
|
|
packet.SetFilePos(::strlen("QSetDisableASLR:"));
|
|
if (packet.GetU32(0))
|
|
m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR);
|
|
else
|
|
m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR);
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir(
|
|
StringExtractorGDBRemote &packet) {
|
|
packet.SetFilePos(::strlen("QSetWorkingDir:"));
|
|
std::string path;
|
|
packet.GetHexByteString(path);
|
|
m_process_launch_info.SetWorkingDirectory(FileSpec{path, true});
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
|
|
StringExtractorGDBRemote &packet) {
|
|
FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
|
|
if (working_dir) {
|
|
StreamString response;
|
|
response.PutCStringAsRawHex8(working_dir.GetCString());
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
return SendErrorResponse(14);
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
|
|
|
|
// Ensure we have a native process.
|
|
if (!m_debugged_process_up) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
|
|
"shared pointer",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x36);
|
|
}
|
|
|
|
// Pull out the signal number.
|
|
packet.SetFilePos(::strlen("C"));
|
|
if (packet.GetBytesLeft() < 1) {
|
|
// Shouldn't be using a C without a signal.
|
|
return SendIllFormedResponse(packet, "C packet specified without signal.");
|
|
}
|
|
const uint32_t signo =
|
|
packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
|
|
if (signo == std::numeric_limits<uint32_t>::max())
|
|
return SendIllFormedResponse(packet, "failed to parse signal number");
|
|
|
|
// Handle optional continue address.
|
|
if (packet.GetBytesLeft() > 0) {
|
|
// FIXME add continue at address support for $C{signo}[;{continue-address}].
|
|
if (*packet.Peek() == ';')
|
|
return SendUnimplementedResponse(packet.GetStringRef().c_str());
|
|
else
|
|
return SendIllFormedResponse(
|
|
packet, "unexpected content after $C{signal-number}");
|
|
}
|
|
|
|
ResumeActionList resume_actions(StateType::eStateRunning, 0);
|
|
Status error;
|
|
|
|
// We have two branches: what to do if a continue thread is specified (in
|
|
// which case we target
|
|
// sending the signal to that thread), or when we don't have a continue thread
|
|
// set (in which
|
|
// case we send a signal to the process).
|
|
|
|
// TODO discuss with Greg Clayton, make sure this makes sense.
|
|
|
|
lldb::tid_t signal_tid = GetContinueThreadID();
|
|
if (signal_tid != LLDB_INVALID_THREAD_ID) {
|
|
// The resume action for the continue thread (or all threads if a continue
|
|
// thread is not set).
|
|
ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning,
|
|
static_cast<int>(signo)};
|
|
|
|
// Add the action for the continue thread (or all threads when the continue
|
|
// thread isn't present).
|
|
resume_actions.Append(action);
|
|
} else {
|
|
// Send the signal to the process since we weren't targeting a specific
|
|
// continue thread with the signal.
|
|
error = m_debugged_process_up->Signal(signo);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "failed to send signal for process {0}: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
|
|
return SendErrorResponse(0x52);
|
|
}
|
|
}
|
|
|
|
// Resume the threads.
|
|
error = m_debugged_process_up->Resume(resume_actions);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "failed to resume threads for process {0}: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
|
|
return SendErrorResponse(0x38);
|
|
}
|
|
|
|
// Don't send an "OK" packet; response is the stopped/exited message.
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
|
|
|
|
packet.SetFilePos(packet.GetFilePos() + ::strlen("c"));
|
|
|
|
// For now just support all continue.
|
|
const bool has_continue_address = (packet.GetBytesLeft() > 0);
|
|
if (has_continue_address) {
|
|
LLDB_LOG(log, "not implemented for c[address] variant [{0} remains]",
|
|
packet.Peek());
|
|
return SendUnimplementedResponse(packet.GetStringRef().c_str());
|
|
}
|
|
|
|
// Ensure we have a native process.
|
|
if (!m_debugged_process_up) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
|
|
"shared pointer",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x36);
|
|
}
|
|
|
|
// Build the ResumeActionList
|
|
ResumeActionList actions(StateType::eStateRunning, 0);
|
|
|
|
Status error = m_debugged_process_up->Resume(actions);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "c failed for process {0}: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(GDBRemoteServerError::eErrorResume);
|
|
}
|
|
|
|
LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID());
|
|
// No response required from continue.
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_vCont_actions(
|
|
StringExtractorGDBRemote &packet) {
|
|
StreamString response;
|
|
response.Printf("vCont;c;C;s;S");
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_vCont(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s handling vCont packet",
|
|
__FUNCTION__);
|
|
|
|
packet.SetFilePos(::strlen("vCont"));
|
|
|
|
if (packet.GetBytesLeft() == 0) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s missing action from "
|
|
"vCont package",
|
|
__FUNCTION__);
|
|
return SendIllFormedResponse(packet, "Missing action from vCont package");
|
|
}
|
|
|
|
// Check if this is all continue (no options or ";c").
|
|
if (::strcmp(packet.Peek(), ";c") == 0) {
|
|
// Move past the ';', then do a simple 'c'.
|
|
packet.SetFilePos(packet.GetFilePos() + 1);
|
|
return Handle_c(packet);
|
|
} else if (::strcmp(packet.Peek(), ";s") == 0) {
|
|
// Move past the ';', then do a simple 's'.
|
|
packet.SetFilePos(packet.GetFilePos() + 1);
|
|
return Handle_s(packet);
|
|
}
|
|
|
|
// Ensure we have a native process.
|
|
if (!m_debugged_process_up) {
|
|
LLDB_LOG(log, "no debugged process");
|
|
return SendErrorResponse(0x36);
|
|
}
|
|
|
|
ResumeActionList thread_actions;
|
|
|
|
while (packet.GetBytesLeft() && *packet.Peek() == ';') {
|
|
// Skip the semi-colon.
|
|
packet.GetChar();
|
|
|
|
// Build up the thread action.
|
|
ResumeAction thread_action;
|
|
thread_action.tid = LLDB_INVALID_THREAD_ID;
|
|
thread_action.state = eStateInvalid;
|
|
thread_action.signal = 0;
|
|
|
|
const char action = packet.GetChar();
|
|
switch (action) {
|
|
case 'C':
|
|
thread_action.signal = packet.GetHexMaxU32(false, 0);
|
|
if (thread_action.signal == 0)
|
|
return SendIllFormedResponse(
|
|
packet, "Could not parse signal in vCont packet C action");
|
|
LLVM_FALLTHROUGH;
|
|
|
|
case 'c':
|
|
// Continue
|
|
thread_action.state = eStateRunning;
|
|
break;
|
|
|
|
case 'S':
|
|
thread_action.signal = packet.GetHexMaxU32(false, 0);
|
|
if (thread_action.signal == 0)
|
|
return SendIllFormedResponse(
|
|
packet, "Could not parse signal in vCont packet S action");
|
|
LLVM_FALLTHROUGH;
|
|
|
|
case 's':
|
|
// Step
|
|
thread_action.state = eStateStepping;
|
|
break;
|
|
|
|
default:
|
|
return SendIllFormedResponse(packet, "Unsupported vCont action");
|
|
break;
|
|
}
|
|
|
|
// Parse out optional :{thread-id} value.
|
|
if (packet.GetBytesLeft() && (*packet.Peek() == ':')) {
|
|
// Consume the separator.
|
|
packet.GetChar();
|
|
|
|
thread_action.tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID);
|
|
if (thread_action.tid == LLDB_INVALID_THREAD_ID)
|
|
return SendIllFormedResponse(
|
|
packet, "Could not parse thread number in vCont packet");
|
|
}
|
|
|
|
thread_actions.Append(thread_action);
|
|
}
|
|
|
|
Status error = m_debugged_process_up->Resume(thread_actions);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "vCont failed for process {0}: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(GDBRemoteServerError::eErrorResume);
|
|
}
|
|
|
|
LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID());
|
|
// No response required from vCont.
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
LLDB_LOG(log, "setting current thread id to {0}", tid);
|
|
|
|
m_current_tid = tid;
|
|
if (m_debugged_process_up)
|
|
m_debugged_process_up->SetCurrentThreadID(m_current_tid);
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
LLDB_LOG(log, "setting continue thread id to {0}", tid);
|
|
|
|
m_continue_tid = tid;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_stop_reason(
|
|
StringExtractorGDBRemote &packet) {
|
|
// Handle the $? gdbremote command.
|
|
|
|
// If no process, indicate error
|
|
if (!m_debugged_process_up)
|
|
return SendErrorResponse(02);
|
|
|
|
return SendStopReasonForState(m_debugged_process_up->GetState());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::SendStopReasonForState(
|
|
lldb::StateType process_state) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
switch (process_state) {
|
|
case eStateAttaching:
|
|
case eStateLaunching:
|
|
case eStateRunning:
|
|
case eStateStepping:
|
|
case eStateDetached:
|
|
// NOTE: gdb protocol doc looks like it should return $OK
|
|
// when everything is running (i.e. no stopped result).
|
|
return PacketResult::Success; // Ignore
|
|
|
|
case eStateSuspended:
|
|
case eStateStopped:
|
|
case eStateCrashed: {
|
|
lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
|
|
// Make sure we set the current thread so g and p packets return
|
|
// the data the gdb will expect.
|
|
SetCurrentThreadID(tid);
|
|
return SendStopReplyPacketForThread(tid);
|
|
}
|
|
|
|
case eStateInvalid:
|
|
case eStateUnloaded:
|
|
case eStateExited:
|
|
return SendWResponse(m_debugged_process_up.get());
|
|
|
|
default:
|
|
LLDB_LOG(log, "pid {0}, current state reporting not handled: {1}",
|
|
m_debugged_process_up->GetID(), process_state);
|
|
break;
|
|
}
|
|
|
|
return SendErrorResponse(0);
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(68);
|
|
|
|
// Ensure we have a thread.
|
|
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0);
|
|
if (!thread)
|
|
return SendErrorResponse(69);
|
|
|
|
// Get the register context for the first thread.
|
|
NativeRegisterContext ®_context = thread->GetRegisterContext();
|
|
|
|
// Parse out the register number from the request.
|
|
packet.SetFilePos(strlen("qRegisterInfo"));
|
|
const uint32_t reg_index =
|
|
packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
|
|
if (reg_index == std::numeric_limits<uint32_t>::max())
|
|
return SendErrorResponse(69);
|
|
|
|
// Return the end of registers response if we've iterated one past the end of
|
|
// the register set.
|
|
if (reg_index >= reg_context.GetUserRegisterCount())
|
|
return SendErrorResponse(69);
|
|
|
|
const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
|
|
if (!reg_info)
|
|
return SendErrorResponse(69);
|
|
|
|
// Build the reginfos response.
|
|
StreamGDBRemote response;
|
|
|
|
response.PutCString("name:");
|
|
response.PutCString(reg_info->name);
|
|
response.PutChar(';');
|
|
|
|
if (reg_info->alt_name && reg_info->alt_name[0]) {
|
|
response.PutCString("alt-name:");
|
|
response.PutCString(reg_info->alt_name);
|
|
response.PutChar(';');
|
|
}
|
|
|
|
response.Printf("bitsize:%" PRIu32 ";offset:%" PRIu32 ";",
|
|
reg_info->byte_size * 8, reg_info->byte_offset);
|
|
|
|
switch (reg_info->encoding) {
|
|
case eEncodingUint:
|
|
response.PutCString("encoding:uint;");
|
|
break;
|
|
case eEncodingSint:
|
|
response.PutCString("encoding:sint;");
|
|
break;
|
|
case eEncodingIEEE754:
|
|
response.PutCString("encoding:ieee754;");
|
|
break;
|
|
case eEncodingVector:
|
|
response.PutCString("encoding:vector;");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (reg_info->format) {
|
|
case eFormatBinary:
|
|
response.PutCString("format:binary;");
|
|
break;
|
|
case eFormatDecimal:
|
|
response.PutCString("format:decimal;");
|
|
break;
|
|
case eFormatHex:
|
|
response.PutCString("format:hex;");
|
|
break;
|
|
case eFormatFloat:
|
|
response.PutCString("format:float;");
|
|
break;
|
|
case eFormatVectorOfSInt8:
|
|
response.PutCString("format:vector-sint8;");
|
|
break;
|
|
case eFormatVectorOfUInt8:
|
|
response.PutCString("format:vector-uint8;");
|
|
break;
|
|
case eFormatVectorOfSInt16:
|
|
response.PutCString("format:vector-sint16;");
|
|
break;
|
|
case eFormatVectorOfUInt16:
|
|
response.PutCString("format:vector-uint16;");
|
|
break;
|
|
case eFormatVectorOfSInt32:
|
|
response.PutCString("format:vector-sint32;");
|
|
break;
|
|
case eFormatVectorOfUInt32:
|
|
response.PutCString("format:vector-uint32;");
|
|
break;
|
|
case eFormatVectorOfFloat32:
|
|
response.PutCString("format:vector-float32;");
|
|
break;
|
|
case eFormatVectorOfUInt64:
|
|
response.PutCString("format:vector-uint64;");
|
|
break;
|
|
case eFormatVectorOfUInt128:
|
|
response.PutCString("format:vector-uint128;");
|
|
break;
|
|
default:
|
|
break;
|
|
};
|
|
|
|
const char *const register_set_name =
|
|
reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index);
|
|
if (register_set_name) {
|
|
response.PutCString("set:");
|
|
response.PutCString(register_set_name);
|
|
response.PutChar(';');
|
|
}
|
|
|
|
if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] !=
|
|
LLDB_INVALID_REGNUM)
|
|
response.Printf("ehframe:%" PRIu32 ";",
|
|
reg_info->kinds[RegisterKind::eRegisterKindEHFrame]);
|
|
|
|
if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
|
|
response.Printf("dwarf:%" PRIu32 ";",
|
|
reg_info->kinds[RegisterKind::eRegisterKindDWARF]);
|
|
|
|
switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) {
|
|
case LLDB_REGNUM_GENERIC_PC:
|
|
response.PutCString("generic:pc;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_SP:
|
|
response.PutCString("generic:sp;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_FP:
|
|
response.PutCString("generic:fp;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_RA:
|
|
response.PutCString("generic:ra;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_FLAGS:
|
|
response.PutCString("generic:flags;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG1:
|
|
response.PutCString("generic:arg1;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG2:
|
|
response.PutCString("generic:arg2;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG3:
|
|
response.PutCString("generic:arg3;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG4:
|
|
response.PutCString("generic:arg4;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG5:
|
|
response.PutCString("generic:arg5;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG6:
|
|
response.PutCString("generic:arg6;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG7:
|
|
response.PutCString("generic:arg7;");
|
|
break;
|
|
case LLDB_REGNUM_GENERIC_ARG8:
|
|
response.PutCString("generic:arg8;");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM) {
|
|
response.PutCString("container-regs:");
|
|
int i = 0;
|
|
for (const uint32_t *reg_num = reg_info->value_regs;
|
|
*reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
|
|
if (i > 0)
|
|
response.PutChar(',');
|
|
response.Printf("%" PRIx32, *reg_num);
|
|
}
|
|
response.PutChar(';');
|
|
}
|
|
|
|
if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) {
|
|
response.PutCString("invalidate-regs:");
|
|
int i = 0;
|
|
for (const uint32_t *reg_num = reg_info->invalidate_regs;
|
|
*reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i) {
|
|
if (i > 0)
|
|
response.PutChar(',');
|
|
response.Printf("%" PRIx32, *reg_num);
|
|
}
|
|
response.PutChar(';');
|
|
}
|
|
|
|
if (reg_info->dynamic_size_dwarf_expr_bytes) {
|
|
const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
|
|
response.PutCString("dynamic_size_dwarf_expr_bytes:");
|
|
for (uint32_t i = 0; i < dwarf_opcode_len; ++i)
|
|
response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]);
|
|
response.PutChar(';');
|
|
}
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
LLDB_LOG(log, "no process ({0}), returning OK",
|
|
m_debugged_process_up ? "invalid process id"
|
|
: "null m_debugged_process_up");
|
|
return SendOKResponse();
|
|
}
|
|
|
|
StreamGDBRemote response;
|
|
response.PutChar('m');
|
|
|
|
LLDB_LOG(log, "starting thread iteration");
|
|
NativeThreadProtocol *thread;
|
|
uint32_t thread_index;
|
|
for (thread_index = 0,
|
|
thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
|
|
thread; ++thread_index,
|
|
thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
|
|
LLDB_LOG(log, "iterated thread {0}(tid={2})", thread_index,
|
|
thread->GetID());
|
|
if (thread_index > 0)
|
|
response.PutChar(',');
|
|
response.Printf("%" PRIx64, thread->GetID());
|
|
}
|
|
|
|
LLDB_LOG(log, "finished thread iteration");
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
// FIXME for now we return the full thread list in the initial packet and
|
|
// always do nothing here.
|
|
return SendPacketNoLock("l");
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Parse out the register number from the request.
|
|
packet.SetFilePos(strlen("p"));
|
|
const uint32_t reg_index =
|
|
packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
|
|
if (reg_index == std::numeric_limits<uint32_t>::max()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
|
|
"parse register number from request \"%s\"",
|
|
__FUNCTION__, packet.GetStringRef().c_str());
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Get the thread to use.
|
|
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
|
|
if (!thread) {
|
|
LLDB_LOG(log, "failed, no thread available");
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Get the thread's register context.
|
|
NativeRegisterContext ®_context = thread->GetRegisterContext();
|
|
|
|
// Return the end of registers response if we've iterated one past the end of
|
|
// the register set.
|
|
if (reg_index >= reg_context.GetUserRegisterCount()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
|
|
"register %" PRIu32 " beyond register count %" PRIu32,
|
|
__FUNCTION__, reg_index,
|
|
reg_context.GetUserRegisterCount());
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
|
|
if (!reg_info) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
|
|
"register %" PRIu32 " returned NULL",
|
|
__FUNCTION__, reg_index);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Build the reginfos response.
|
|
StreamGDBRemote response;
|
|
|
|
// Retrieve the value
|
|
RegisterValue reg_value;
|
|
Status error = reg_context.ReadRegister(reg_info, reg_value);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, read of "
|
|
"requested register %" PRIu32 " (%s) failed: %s",
|
|
__FUNCTION__, reg_index, reg_info->name, error.AsCString());
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
const uint8_t *const data =
|
|
reinterpret_cast<const uint8_t *>(reg_value.GetBytes());
|
|
if (!data) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get data "
|
|
"bytes from requested register %" PRIu32,
|
|
__FUNCTION__, reg_index);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// FIXME flip as needed to get data in big/little endian format for this host.
|
|
for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i)
|
|
response.PutHex8(data[i]);
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Ensure there is more content.
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Empty P packet");
|
|
|
|
// Parse out the register number from the request.
|
|
packet.SetFilePos(strlen("P"));
|
|
const uint32_t reg_index =
|
|
packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
|
|
if (reg_index == std::numeric_limits<uint32_t>::max()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
|
|
"parse register number from request \"%s\"",
|
|
__FUNCTION__, packet.GetStringRef().c_str());
|
|
return SendErrorResponse(0x29);
|
|
}
|
|
|
|
// Note debugserver would send an E30 here.
|
|
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '='))
|
|
return SendIllFormedResponse(
|
|
packet, "P packet missing '=' char after register number");
|
|
|
|
// Parse out the value.
|
|
uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register
|
|
size_t reg_size = packet.GetHexBytesAvail(reg_bytes);
|
|
|
|
// Get the thread to use.
|
|
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
|
|
if (!thread) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread "
|
|
"available (thread index 0)",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x28);
|
|
}
|
|
|
|
// Get the thread's register context.
|
|
NativeRegisterContext ®_context = thread->GetRegisterContext();
|
|
const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
|
|
if (!reg_info) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
|
|
"register %" PRIu32 " returned NULL",
|
|
__FUNCTION__, reg_index);
|
|
return SendErrorResponse(0x48);
|
|
}
|
|
|
|
// Return the end of registers response if we've iterated one past the end of
|
|
// the register set.
|
|
if (reg_index >= reg_context.GetUserRegisterCount()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
|
|
"register %" PRIu32 " beyond register count %" PRIu32,
|
|
__FUNCTION__, reg_index, reg_context.GetUserRegisterCount());
|
|
return SendErrorResponse(0x47);
|
|
}
|
|
|
|
// The dwarf expression are evaluate on host site
|
|
// which may cause register size to change
|
|
// Hence the reg_size may not be same as reg_info->bytes_size
|
|
if ((reg_size != reg_info->byte_size) &&
|
|
!(reg_info->dynamic_size_dwarf_expr_bytes)) {
|
|
return SendIllFormedResponse(packet, "P packet register size is incorrect");
|
|
}
|
|
|
|
// Build the reginfos response.
|
|
StreamGDBRemote response;
|
|
|
|
RegisterValue reg_value(
|
|
reg_bytes, reg_size,
|
|
m_debugged_process_up->GetArchitecture().GetByteOrder());
|
|
Status error = reg_context.WriteRegister(reg_info, reg_value);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, write of "
|
|
"requested register %" PRIu32 " (%s) failed: %s",
|
|
__FUNCTION__, reg_index, reg_info->name, error.AsCString());
|
|
return SendErrorResponse(0x32);
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Parse out which variant of $H is requested.
|
|
packet.SetFilePos(strlen("H"));
|
|
if (packet.GetBytesLeft() < 1) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, H command "
|
|
"missing {g,c} variant",
|
|
__FUNCTION__);
|
|
return SendIllFormedResponse(packet, "H command missing {g,c} variant");
|
|
}
|
|
|
|
const char h_variant = packet.GetChar();
|
|
switch (h_variant) {
|
|
case 'g':
|
|
break;
|
|
|
|
case 'c':
|
|
break;
|
|
|
|
default:
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c",
|
|
__FUNCTION__, h_variant);
|
|
return SendIllFormedResponse(packet,
|
|
"H variant unsupported, should be c or g");
|
|
}
|
|
|
|
// Parse out the thread number.
|
|
// FIXME return a parse success/fail value. All values are valid here.
|
|
const lldb::tid_t tid =
|
|
packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max());
|
|
|
|
// Ensure we have the given thread when not specifying -1 (all threads) or 0
|
|
// (any thread).
|
|
if (tid != LLDB_INVALID_THREAD_ID && tid != 0) {
|
|
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
|
|
if (!thread) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64
|
|
" not found",
|
|
__FUNCTION__, tid);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
}
|
|
|
|
// Now switch the given thread type.
|
|
switch (h_variant) {
|
|
case 'g':
|
|
SetCurrentThreadID(tid);
|
|
break;
|
|
|
|
case 'c':
|
|
SetContinueThreadID(tid);
|
|
break;
|
|
|
|
default:
|
|
assert(false && "unsupported $H variant - shouldn't get here");
|
|
return SendIllFormedResponse(packet,
|
|
"H variant unsupported, should be c or g");
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
packet.SetFilePos(::strlen("I"));
|
|
uint8_t tmp[4096];
|
|
for (;;) {
|
|
size_t read = packet.GetHexBytesAvail(tmp);
|
|
if (read == 0) {
|
|
break;
|
|
}
|
|
// write directly to stdin *this might block if stdin buffer is full*
|
|
// TODO: enqueue this block in circular buffer and send window size to
|
|
// remote host
|
|
ConnectionStatus status;
|
|
Status error;
|
|
m_stdio_communication.Write(tmp, read, status, &error);
|
|
if (error.Fail()) {
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_interrupt(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
LLDB_LOG(log, "failed, no process available");
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Interrupt the process.
|
|
Status error = m_debugged_process_up->Interrupt();
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "failed for process {0}: {1}", m_debugged_process_up->GetID(),
|
|
error);
|
|
return SendErrorResponse(GDBRemoteServerError::eErrorResume);
|
|
}
|
|
|
|
LLDB_LOG(log, "stopped process {0}", m_debugged_process_up->GetID());
|
|
|
|
// No response required from stop all.
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_memory_read(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Parse out the memory address.
|
|
packet.SetFilePos(strlen("m"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Too short m packet");
|
|
|
|
// Read the address. Punting on validation.
|
|
// FIXME replace with Hex U64 read with no default value that fails on failed
|
|
// read.
|
|
const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
|
|
|
|
// Validate comma.
|
|
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
|
|
return SendIllFormedResponse(packet, "Comma sep missing in m packet");
|
|
|
|
// Get # bytes to read.
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Length missing in m packet");
|
|
|
|
const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
|
|
if (byte_count == 0) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to read: "
|
|
"zero-length packet",
|
|
__FUNCTION__);
|
|
return SendOKResponse();
|
|
}
|
|
|
|
// Allocate the response buffer.
|
|
std::string buf(byte_count, '\0');
|
|
if (buf.empty())
|
|
return SendErrorResponse(0x78);
|
|
|
|
// Retrieve the process memory.
|
|
size_t bytes_read = 0;
|
|
Status error = m_debugged_process_up->ReadMemoryWithoutTrap(
|
|
read_addr, &buf[0], byte_count, bytes_read);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
|
|
" mem 0x%" PRIx64 ": failed to read. Error: %s",
|
|
__FUNCTION__, m_debugged_process_up->GetID(), read_addr,
|
|
error.AsCString());
|
|
return SendErrorResponse(0x08);
|
|
}
|
|
|
|
if (bytes_read == 0) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
|
|
" mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes",
|
|
__FUNCTION__, m_debugged_process_up->GetID(), read_addr,
|
|
byte_count);
|
|
return SendErrorResponse(0x08);
|
|
}
|
|
|
|
StreamGDBRemote response;
|
|
packet.SetFilePos(0);
|
|
char kind = packet.GetChar('?');
|
|
if (kind == 'x')
|
|
response.PutEscapedBytes(buf.data(), byte_count);
|
|
else {
|
|
assert(kind == 'm');
|
|
for (size_t i = 0; i < bytes_read; ++i)
|
|
response.PutHex8(buf[i]);
|
|
}
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Parse out the memory address.
|
|
packet.SetFilePos(strlen("M"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Too short M packet");
|
|
|
|
// Read the address. Punting on validation.
|
|
// FIXME replace with Hex U64 read with no default value that fails on failed
|
|
// read.
|
|
const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0);
|
|
|
|
// Validate comma.
|
|
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
|
|
return SendIllFormedResponse(packet, "Comma sep missing in M packet");
|
|
|
|
// Get # bytes to read.
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Length missing in M packet");
|
|
|
|
const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
|
|
if (byte_count == 0) {
|
|
LLDB_LOG(log, "nothing to write: zero-length packet");
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
// Validate colon.
|
|
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':'))
|
|
return SendIllFormedResponse(
|
|
packet, "Comma sep missing in M packet after byte length");
|
|
|
|
// Allocate the conversion buffer.
|
|
std::vector<uint8_t> buf(byte_count, 0);
|
|
if (buf.empty())
|
|
return SendErrorResponse(0x78);
|
|
|
|
// Convert the hex memory write contents to bytes.
|
|
StreamGDBRemote response;
|
|
const uint64_t convert_count = packet.GetHexBytes(buf, 0);
|
|
if (convert_count != byte_count) {
|
|
LLDB_LOG(log,
|
|
"pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
|
|
"to convert.",
|
|
m_debugged_process_up->GetID(), write_addr, byte_count,
|
|
convert_count);
|
|
return SendIllFormedResponse(packet, "M content byte length specified did "
|
|
"not match hex-encoded content "
|
|
"length");
|
|
}
|
|
|
|
// Write the process memory.
|
|
size_t bytes_written = 0;
|
|
Status error = m_debugged_process_up->WriteMemory(write_addr, &buf[0],
|
|
byte_count, bytes_written);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "pid {0} mem {1:x}: failed to write. Error: {2}",
|
|
m_debugged_process_up->GetID(), write_addr, error);
|
|
return SendErrorResponse(0x09);
|
|
}
|
|
|
|
if (bytes_written == 0) {
|
|
LLDB_LOG(log, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes",
|
|
m_debugged_process_up->GetID(), write_addr, byte_count);
|
|
return SendErrorResponse(0x09);
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
// Currently only the NativeProcessProtocol knows if it can handle a
|
|
// qMemoryRegionInfoSupported
|
|
// request, but we're not guaranteed to be attached to a process. For now
|
|
// we'll assume the
|
|
// client only asks this when a process is being debugged.
|
|
|
|
// Ensure we have a process running; otherwise, we can't figure this out
|
|
// since we won't have a NativeProcessProtocol.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Test if we can get any region back when asking for the region around NULL.
|
|
MemoryRegionInfo region_info;
|
|
const Status error =
|
|
m_debugged_process_up->GetMemoryRegionInfo(0, region_info);
|
|
if (error.Fail()) {
|
|
// We don't support memory region info collection for this
|
|
// NativeProcessProtocol.
|
|
return SendUnimplementedResponse("");
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
// Ensure we have a process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Parse out the memory address.
|
|
packet.SetFilePos(strlen("qMemoryRegionInfo:"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet");
|
|
|
|
// Read the address. Punting on validation.
|
|
const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
|
|
|
|
StreamGDBRemote response;
|
|
|
|
// Get the memory region info for the target address.
|
|
MemoryRegionInfo region_info;
|
|
const Status error =
|
|
m_debugged_process_up->GetMemoryRegionInfo(read_addr, region_info);
|
|
if (error.Fail()) {
|
|
// Return the error message.
|
|
|
|
response.PutCString("error:");
|
|
response.PutCStringAsRawHex8(error.AsCString());
|
|
response.PutChar(';');
|
|
} else {
|
|
// Range start and size.
|
|
response.Printf("start:%" PRIx64 ";size:%" PRIx64 ";",
|
|
region_info.GetRange().GetRangeBase(),
|
|
region_info.GetRange().GetByteSize());
|
|
|
|
// Permissions.
|
|
if (region_info.GetReadable() || region_info.GetWritable() ||
|
|
region_info.GetExecutable()) {
|
|
// Write permissions info.
|
|
response.PutCString("permissions:");
|
|
|
|
if (region_info.GetReadable())
|
|
response.PutChar('r');
|
|
if (region_info.GetWritable())
|
|
response.PutChar('w');
|
|
if (region_info.GetExecutable())
|
|
response.PutChar('x');
|
|
|
|
response.PutChar(';');
|
|
}
|
|
|
|
// Name
|
|
ConstString name = region_info.GetName();
|
|
if (name) {
|
|
response.PutCString("name:");
|
|
response.PutCStringAsRawHex8(name.AsCString());
|
|
response.PutChar(';');
|
|
}
|
|
}
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) {
|
|
// Ensure we have a process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
LLDB_LOG(log, "failed, no process available");
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Parse out software or hardware breakpoint or watchpoint requested.
|
|
packet.SetFilePos(strlen("Z"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(
|
|
packet, "Too short Z packet, missing software/hardware specifier");
|
|
|
|
bool want_breakpoint = true;
|
|
bool want_hardware = false;
|
|
uint32_t watch_flags = 0;
|
|
|
|
const GDBStoppointType stoppoint_type =
|
|
GDBStoppointType(packet.GetS32(eStoppointInvalid));
|
|
switch (stoppoint_type) {
|
|
case eBreakpointSoftware:
|
|
want_hardware = false;
|
|
want_breakpoint = true;
|
|
break;
|
|
case eBreakpointHardware:
|
|
want_hardware = true;
|
|
want_breakpoint = true;
|
|
break;
|
|
case eWatchpointWrite:
|
|
watch_flags = 1;
|
|
want_hardware = true;
|
|
want_breakpoint = false;
|
|
break;
|
|
case eWatchpointRead:
|
|
watch_flags = 2;
|
|
want_hardware = true;
|
|
want_breakpoint = false;
|
|
break;
|
|
case eWatchpointReadWrite:
|
|
watch_flags = 3;
|
|
want_hardware = true;
|
|
want_breakpoint = false;
|
|
break;
|
|
case eStoppointInvalid:
|
|
return SendIllFormedResponse(
|
|
packet, "Z packet had invalid software/hardware specifier");
|
|
}
|
|
|
|
if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
|
|
return SendIllFormedResponse(
|
|
packet, "Malformed Z packet, expecting comma after stoppoint type");
|
|
|
|
// Parse out the stoppoint address.
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Too short Z packet, missing address");
|
|
const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);
|
|
|
|
if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
|
|
return SendIllFormedResponse(
|
|
packet, "Malformed Z packet, expecting comma after address");
|
|
|
|
// Parse out the stoppoint size (i.e. size hint for opcode size).
|
|
const uint32_t size =
|
|
packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
|
|
if (size == std::numeric_limits<uint32_t>::max())
|
|
return SendIllFormedResponse(
|
|
packet, "Malformed Z packet, failed to parse size argument");
|
|
|
|
if (want_breakpoint) {
|
|
// Try to set the breakpoint.
|
|
const Status error =
|
|
m_debugged_process_up->SetBreakpoint(addr, size, want_hardware);
|
|
if (error.Success())
|
|
return SendOKResponse();
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(0x09);
|
|
} else {
|
|
// Try to set the watchpoint.
|
|
const Status error = m_debugged_process_up->SetWatchpoint(
|
|
addr, size, watch_flags, want_hardware);
|
|
if (error.Success())
|
|
return SendOKResponse();
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
|
|
LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(0x09);
|
|
}
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
|
|
// Ensure we have a process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
LLDB_LOG(log, "failed, no process available");
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
// Parse out software or hardware breakpoint or watchpoint requested.
|
|
packet.SetFilePos(strlen("z"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(
|
|
packet, "Too short z packet, missing software/hardware specifier");
|
|
|
|
bool want_breakpoint = true;
|
|
bool want_hardware = false;
|
|
|
|
const GDBStoppointType stoppoint_type =
|
|
GDBStoppointType(packet.GetS32(eStoppointInvalid));
|
|
switch (stoppoint_type) {
|
|
case eBreakpointHardware:
|
|
want_breakpoint = true;
|
|
want_hardware = true;
|
|
break;
|
|
case eBreakpointSoftware:
|
|
want_breakpoint = true;
|
|
break;
|
|
case eWatchpointWrite:
|
|
want_breakpoint = false;
|
|
break;
|
|
case eWatchpointRead:
|
|
want_breakpoint = false;
|
|
break;
|
|
case eWatchpointReadWrite:
|
|
want_breakpoint = false;
|
|
break;
|
|
default:
|
|
return SendIllFormedResponse(
|
|
packet, "z packet had invalid software/hardware specifier");
|
|
}
|
|
|
|
if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
|
|
return SendIllFormedResponse(
|
|
packet, "Malformed z packet, expecting comma after stoppoint type");
|
|
|
|
// Parse out the stoppoint address.
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet, "Too short z packet, missing address");
|
|
const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);
|
|
|
|
if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
|
|
return SendIllFormedResponse(
|
|
packet, "Malformed z packet, expecting comma after address");
|
|
|
|
/*
|
|
// Parse out the stoppoint size (i.e. size hint for opcode size).
|
|
const uint32_t size = packet.GetHexMaxU32 (false,
|
|
std::numeric_limits<uint32_t>::max ());
|
|
if (size == std::numeric_limits<uint32_t>::max ())
|
|
return SendIllFormedResponse(packet, "Malformed z packet, failed to parse
|
|
size argument");
|
|
*/
|
|
|
|
if (want_breakpoint) {
|
|
// Try to clear the breakpoint.
|
|
const Status error =
|
|
m_debugged_process_up->RemoveBreakpoint(addr, want_hardware);
|
|
if (error.Success())
|
|
return SendOKResponse();
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
|
|
LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(0x09);
|
|
} else {
|
|
// Try to clear the watchpoint.
|
|
const Status error = m_debugged_process_up->RemoveWatchpoint(addr);
|
|
if (error.Success())
|
|
return SendOKResponse();
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
|
|
LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(0x09);
|
|
}
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
|
|
// Ensure we have a process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x32);
|
|
}
|
|
|
|
// We first try to use a continue thread id. If any one or any all set, use
|
|
// the current thread.
|
|
// Bail out if we don't have a thread id.
|
|
lldb::tid_t tid = GetContinueThreadID();
|
|
if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
|
|
tid = GetCurrentThreadID();
|
|
if (tid == LLDB_INVALID_THREAD_ID)
|
|
return SendErrorResponse(0x33);
|
|
|
|
// Double check that we have such a thread.
|
|
// TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
|
|
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
|
|
if (!thread)
|
|
return SendErrorResponse(0x33);
|
|
|
|
// Create the step action for the given thread.
|
|
ResumeAction action = {tid, eStateStepping, 0};
|
|
|
|
// Setup the actions list.
|
|
ResumeActionList actions;
|
|
actions.Append(action);
|
|
|
|
// All other threads stop while we're single stepping a thread.
|
|
actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
|
|
Status error = m_debugged_process_up->Resume(actions);
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
|
|
" tid %" PRIu64 " Resume() failed with error: %s",
|
|
__FUNCTION__, m_debugged_process_up->GetID(), tid,
|
|
error.AsCString());
|
|
return SendErrorResponse(0x49);
|
|
}
|
|
|
|
// No response here - the stop or exit will come from the resulting action.
|
|
return PacketResult::Success;
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read(
|
|
StringExtractorGDBRemote &packet) {
|
|
// *BSD impls should be able to do this too.
|
|
#if defined(__linux__) || defined(__NetBSD__)
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
// Parse out the offset.
|
|
packet.SetFilePos(strlen("qXfer:auxv:read::"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(packet,
|
|
"qXfer:auxv:read:: packet missing offset");
|
|
|
|
const uint64_t auxv_offset =
|
|
packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
|
|
if (auxv_offset == std::numeric_limits<uint64_t>::max())
|
|
return SendIllFormedResponse(packet,
|
|
"qXfer:auxv:read:: packet missing offset");
|
|
|
|
// Parse out comma.
|
|
if (packet.GetBytesLeft() < 1 || packet.GetChar() != ',')
|
|
return SendIllFormedResponse(
|
|
packet, "qXfer:auxv:read:: packet missing comma after offset");
|
|
|
|
// Parse out the length.
|
|
const uint64_t auxv_length =
|
|
packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
|
|
if (auxv_length == std::numeric_limits<uint64_t>::max())
|
|
return SendIllFormedResponse(packet,
|
|
"qXfer:auxv:read:: packet missing length");
|
|
|
|
// Grab the auxv data if we need it.
|
|
if (!m_active_auxv_buffer_up) {
|
|
// Make sure we have a valid process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x10);
|
|
}
|
|
|
|
// Grab the auxv data.
|
|
auto buffer_or_error = m_debugged_process_up->GetAuxvData();
|
|
if (!buffer_or_error) {
|
|
std::error_code ec = buffer_or_error.getError();
|
|
LLDB_LOG(log, "no auxv data retrieved: {0}", ec.message());
|
|
return SendErrorResponse(ec.value());
|
|
}
|
|
m_active_auxv_buffer_up = std::move(*buffer_or_error);
|
|
}
|
|
|
|
StreamGDBRemote response;
|
|
bool done_with_buffer = false;
|
|
|
|
llvm::StringRef buffer = m_active_auxv_buffer_up->getBuffer();
|
|
if (auxv_offset >= buffer.size()) {
|
|
// We have nothing left to send. Mark the buffer as complete.
|
|
response.PutChar('l');
|
|
done_with_buffer = true;
|
|
} else {
|
|
// Figure out how many bytes are available starting at the given offset.
|
|
buffer = buffer.drop_front(auxv_offset);
|
|
|
|
// Mark the response type according to whether we're reading the remainder
|
|
// of the auxv data.
|
|
if (auxv_length >= buffer.size()) {
|
|
// There will be nothing left to read after this
|
|
response.PutChar('l');
|
|
done_with_buffer = true;
|
|
} else {
|
|
// There will still be bytes to read after this request.
|
|
response.PutChar('m');
|
|
buffer = buffer.take_front(auxv_length);
|
|
}
|
|
|
|
// Now write the data in encoded binary form.
|
|
response.PutEscapedBytes(buffer.data(), buffer.size());
|
|
}
|
|
|
|
if (done_with_buffer)
|
|
m_active_auxv_buffer_up.reset();
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
#else
|
|
return SendUnimplementedResponse("not implemented on this platform");
|
|
#endif
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Move past packet name.
|
|
packet.SetFilePos(strlen("QSaveRegisterState"));
|
|
|
|
// Get the thread to use.
|
|
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
|
|
if (!thread) {
|
|
if (m_thread_suffix_supported)
|
|
return SendIllFormedResponse(
|
|
packet, "No thread specified in QSaveRegisterState packet");
|
|
else
|
|
return SendIllFormedResponse(packet,
|
|
"No thread was is set with the Hg packet");
|
|
}
|
|
|
|
// Grab the register context for the thread.
|
|
NativeRegisterContext& reg_context = thread->GetRegisterContext();
|
|
|
|
// Save registers to a buffer.
|
|
DataBufferSP register_data_sp;
|
|
Status error = reg_context.ReadAllRegisterValues(register_data_sp);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "pid {0} failed to save all register values: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(0x75);
|
|
}
|
|
|
|
// Allocate a new save id.
|
|
const uint32_t save_id = GetNextSavedRegistersID();
|
|
assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) &&
|
|
"GetNextRegisterSaveID() returned an existing register save id");
|
|
|
|
// Save the register data buffer under the save id.
|
|
{
|
|
std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
|
|
m_saved_registers_map[save_id] = register_data_sp;
|
|
}
|
|
|
|
// Write the response.
|
|
StreamGDBRemote response;
|
|
response.Printf("%" PRIu32, save_id);
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Parse out save id.
|
|
packet.SetFilePos(strlen("QRestoreRegisterState:"));
|
|
if (packet.GetBytesLeft() < 1)
|
|
return SendIllFormedResponse(
|
|
packet, "QRestoreRegisterState packet missing register save id");
|
|
|
|
const uint32_t save_id = packet.GetU32(0);
|
|
if (save_id == 0) {
|
|
LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, "
|
|
"expecting decimal uint32_t");
|
|
return SendErrorResponse(0x76);
|
|
}
|
|
|
|
// Get the thread to use.
|
|
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
|
|
if (!thread) {
|
|
if (m_thread_suffix_supported)
|
|
return SendIllFormedResponse(
|
|
packet, "No thread specified in QRestoreRegisterState packet");
|
|
else
|
|
return SendIllFormedResponse(packet,
|
|
"No thread was is set with the Hg packet");
|
|
}
|
|
|
|
// Grab the register context for the thread.
|
|
NativeRegisterContext ®_context = thread->GetRegisterContext();
|
|
|
|
// Retrieve register state buffer, then remove from the list.
|
|
DataBufferSP register_data_sp;
|
|
{
|
|
std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
|
|
|
|
// Find the register set buffer for the given save id.
|
|
auto it = m_saved_registers_map.find(save_id);
|
|
if (it == m_saved_registers_map.end()) {
|
|
LLDB_LOG(log,
|
|
"pid {0} does not have a register set save buffer for id {1}",
|
|
m_debugged_process_up->GetID(), save_id);
|
|
return SendErrorResponse(0x77);
|
|
}
|
|
register_data_sp = it->second;
|
|
|
|
// Remove it from the map.
|
|
m_saved_registers_map.erase(it);
|
|
}
|
|
|
|
Status error = reg_context.WriteAllRegisterValues(register_data_sp);
|
|
if (error.Fail()) {
|
|
LLDB_LOG(log, "pid {0} failed to restore all register values: {1}",
|
|
m_debugged_process_up->GetID(), error);
|
|
return SendErrorResponse(0x77);
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_vAttach(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
// Consume the ';' after vAttach.
|
|
packet.SetFilePos(strlen("vAttach"));
|
|
if (!packet.GetBytesLeft() || packet.GetChar() != ';')
|
|
return SendIllFormedResponse(packet, "vAttach missing expected ';'");
|
|
|
|
// Grab the PID to which we will attach (assume hex encoding).
|
|
lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16);
|
|
if (pid == LLDB_INVALID_PROCESS_ID)
|
|
return SendIllFormedResponse(packet,
|
|
"vAttach failed to parse the process id");
|
|
|
|
// Attempt to attach.
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s attempting to attach to "
|
|
"pid %" PRIu64,
|
|
__FUNCTION__, pid);
|
|
|
|
Status error = AttachToProcess(pid);
|
|
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to attach to "
|
|
"pid %" PRIu64 ": %s\n",
|
|
__FUNCTION__, pid, error.AsCString());
|
|
return SendErrorResponse(0x01);
|
|
}
|
|
|
|
// Notify we attached by sending a stop packet.
|
|
return SendStopReasonForState(m_debugged_process_up->GetState());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
StopSTDIOForwarding();
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)) {
|
|
if (log)
|
|
log->Printf(
|
|
"GDBRemoteCommunicationServerLLGS::%s failed, no process available",
|
|
__FUNCTION__);
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
|
|
lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
|
|
|
|
// Consume the ';' after D.
|
|
packet.SetFilePos(1);
|
|
if (packet.GetBytesLeft()) {
|
|
if (packet.GetChar() != ';')
|
|
return SendIllFormedResponse(packet, "D missing expected ';'");
|
|
|
|
// Grab the PID from which we will detach (assume hex encoding).
|
|
pid = packet.GetU32(LLDB_INVALID_PROCESS_ID, 16);
|
|
if (pid == LLDB_INVALID_PROCESS_ID)
|
|
return SendIllFormedResponse(packet, "D failed to parse the process id");
|
|
}
|
|
|
|
if (pid != LLDB_INVALID_PROCESS_ID && m_debugged_process_up->GetID() != pid) {
|
|
return SendIllFormedResponse(packet, "Invalid pid");
|
|
}
|
|
|
|
const Status error = m_debugged_process_up->Detach();
|
|
if (error.Fail()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to detach from "
|
|
"pid %" PRIu64 ": %s\n",
|
|
__FUNCTION__, m_debugged_process_up->GetID(),
|
|
error.AsCString());
|
|
return SendErrorResponse(0x01);
|
|
}
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
packet.SetFilePos(strlen("qThreadStopInfo"));
|
|
const lldb::tid_t tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID);
|
|
if (tid == LLDB_INVALID_THREAD_ID) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
|
|
"parse thread id from request \"%s\"",
|
|
__FUNCTION__, packet.GetStringRef().c_str());
|
|
return SendErrorResponse(0x15);
|
|
}
|
|
return SendStopReplyPacketForThread(tid);
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo(
|
|
StringExtractorGDBRemote &) {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
|
|
|
|
// Ensure we have a debugged process.
|
|
if (!m_debugged_process_up ||
|
|
(m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID))
|
|
return SendErrorResponse(50);
|
|
LLDB_LOG(log, "preparing packet for pid {0}", m_debugged_process_up->GetID());
|
|
|
|
StreamString response;
|
|
const bool threads_with_valid_stop_info_only = false;
|
|
JSONArray::SP threads_array_sp = GetJSONThreadsInfo(
|
|
*m_debugged_process_up, threads_with_valid_stop_info_only);
|
|
if (!threads_array_sp) {
|
|
LLDB_LOG(log, "failed to prepare a packet for pid {0}",
|
|
m_debugged_process_up->GetID());
|
|
return SendErrorResponse(52);
|
|
}
|
|
|
|
threads_array_sp->Write(response);
|
|
StreamGDBRemote escaped_response;
|
|
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
|
|
return SendPacketNoLock(escaped_response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo(
|
|
StringExtractorGDBRemote &packet) {
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
|
|
return SendErrorResponse(68);
|
|
|
|
packet.SetFilePos(strlen("qWatchpointSupportInfo"));
|
|
if (packet.GetBytesLeft() == 0)
|
|
return SendOKResponse();
|
|
if (packet.GetChar() != ':')
|
|
return SendErrorResponse(67);
|
|
|
|
auto hw_debug_cap = m_debugged_process_up->GetHardwareDebugSupportInfo();
|
|
|
|
StreamGDBRemote response;
|
|
if (hw_debug_cap == llvm::None)
|
|
response.Printf("num:0;");
|
|
else
|
|
response.Printf("num:%d;", hw_debug_cap->second);
|
|
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress(
|
|
StringExtractorGDBRemote &packet) {
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up ||
|
|
m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
|
|
return SendErrorResponse(67);
|
|
|
|
packet.SetFilePos(strlen("qFileLoadAddress:"));
|
|
if (packet.GetBytesLeft() == 0)
|
|
return SendErrorResponse(68);
|
|
|
|
std::string file_name;
|
|
packet.GetHexByteString(file_name);
|
|
|
|
lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS;
|
|
Status error =
|
|
m_debugged_process_up->GetFileLoadAddress(file_name, file_load_address);
|
|
if (error.Fail())
|
|
return SendErrorResponse(69);
|
|
|
|
if (file_load_address == LLDB_INVALID_ADDRESS)
|
|
return SendErrorResponse(1); // File not loaded
|
|
|
|
StreamGDBRemote response;
|
|
response.PutHex64(file_load_address);
|
|
return SendPacketNoLock(response.GetString());
|
|
}
|
|
|
|
GDBRemoteCommunication::PacketResult
|
|
GDBRemoteCommunicationServerLLGS::Handle_QPassSignals(
|
|
StringExtractorGDBRemote &packet) {
|
|
std::vector<int> signals;
|
|
packet.SetFilePos(strlen("QPassSignals:"));
|
|
|
|
// Read sequence of hex signal numbers divided by a semicolon and
|
|
// optionally spaces.
|
|
while (packet.GetBytesLeft() > 0) {
|
|
int signal = packet.GetS32(-1, 16);
|
|
if (signal < 0)
|
|
return SendIllFormedResponse(packet, "Failed to parse signal number.");
|
|
signals.push_back(signal);
|
|
|
|
packet.SkipSpaces();
|
|
char separator = packet.GetChar();
|
|
if (separator == '\0')
|
|
break; // End of string
|
|
if (separator != ';')
|
|
return SendIllFormedResponse(packet, "Invalid separator,"
|
|
" expected semicolon.");
|
|
}
|
|
|
|
// Fail if we don't have a current process.
|
|
if (!m_debugged_process_up)
|
|
return SendErrorResponse(68);
|
|
|
|
Status error = m_debugged_process_up->IgnoreSignals(signals);
|
|
if (error.Fail())
|
|
return SendErrorResponse(69);
|
|
|
|
return SendOKResponse();
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
// Tell the stdio connection to shut down.
|
|
if (m_stdio_communication.IsConnected()) {
|
|
auto connection = m_stdio_communication.GetConnection();
|
|
if (connection) {
|
|
Status error;
|
|
connection->Disconnect(&error);
|
|
|
|
if (error.Success()) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
|
|
"terminal stdio - SUCCESS",
|
|
__FUNCTION__);
|
|
} else {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
|
|
"terminal stdio - FAIL: %s",
|
|
__FUNCTION__, error.AsCString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix(
|
|
StringExtractorGDBRemote &packet) {
|
|
// We have no thread if we don't have a process.
|
|
if (!m_debugged_process_up ||
|
|
m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID)
|
|
return nullptr;
|
|
|
|
// If the client hasn't asked for thread suffix support, there will not be a
|
|
// thread suffix.
|
|
// Use the current thread in that case.
|
|
if (!m_thread_suffix_supported) {
|
|
const lldb::tid_t current_tid = GetCurrentThreadID();
|
|
if (current_tid == LLDB_INVALID_THREAD_ID)
|
|
return nullptr;
|
|
else if (current_tid == 0) {
|
|
// Pick a thread.
|
|
return m_debugged_process_up->GetThreadAtIndex(0);
|
|
} else
|
|
return m_debugged_process_up->GetThreadByID(current_tid);
|
|
}
|
|
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
|
|
|
|
// Parse out the ';'.
|
|
if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
|
|
"error: expected ';' prior to start of thread suffix: packet "
|
|
"contents = '%s'",
|
|
__FUNCTION__, packet.GetStringRef().c_str());
|
|
return nullptr;
|
|
}
|
|
|
|
if (!packet.GetBytesLeft())
|
|
return nullptr;
|
|
|
|
// Parse out thread: portion.
|
|
if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) {
|
|
if (log)
|
|
log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
|
|
"error: expected 'thread:' but not found, packet contents = "
|
|
"'%s'",
|
|
__FUNCTION__, packet.GetStringRef().c_str());
|
|
return nullptr;
|
|
}
|
|
packet.SetFilePos(packet.GetFilePos() + strlen("thread:"));
|
|
const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
|
|
if (tid != 0)
|
|
return m_debugged_process_up->GetThreadByID(tid);
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const {
|
|
if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID) {
|
|
// Use whatever the debug process says is the current thread id
|
|
// since the protocol either didn't specify or specified we want
|
|
// any/all threads marked as the current thread.
|
|
if (!m_debugged_process_up)
|
|
return LLDB_INVALID_THREAD_ID;
|
|
return m_debugged_process_up->GetCurrentThreadID();
|
|
}
|
|
// Use the specific current thread id set by the gdb remote protocol.
|
|
return m_current_tid;
|
|
}
|
|
|
|
uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() {
|
|
std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
|
|
return m_next_saved_registers_id++;
|
|
}
|
|
|
|
void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() {
|
|
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
|
|
|
|
LLDB_LOG(log, "clearing auxv buffer: {0}", m_active_auxv_buffer_up.get());
|
|
m_active_auxv_buffer_up.reset();
|
|
}
|
|
|
|
FileSpec
|
|
GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path,
|
|
const ArchSpec &arch) {
|
|
if (m_debugged_process_up) {
|
|
FileSpec file_spec;
|
|
if (m_debugged_process_up
|
|
->GetLoadedModuleFileSpec(module_path.c_str(), file_spec)
|
|
.Success()) {
|
|
if (file_spec.Exists())
|
|
return file_spec;
|
|
}
|
|
}
|
|
|
|
return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
|
|
}
|