shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
llvm-project/lldb/tools/debugserver/source/libdebugserver.cpp
Kate Stone b9c1b51e45 *** This commit represents a complete reformatting of the LLDB source code 
*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751
2016-09-06 20:57:50 +00:00

384 lines
13 KiB
C++
Raw Blame History

//===-- libdebugserver.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 <getopt.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/sysctl.h>
#include <sys/types.h>
#include "DNB.h"
#include "DNBLog.h"
#include "DNBTimer.h"
#include "PseudoTerminal.h"
#include "RNBContext.h"
#include "RNBRemote.h"
#include "RNBServices.h"
#include "RNBSocket.h"
#include "SysSignal.h"
//----------------------------------------------------------------------
// Run loop modes which determine which run loop function will be called
//----------------------------------------------------------------------
typedef enum {
eRNBRunLoopModeInvalid = 0,
eRNBRunLoopModeGetStartModeFromRemoteProtocol,
eRNBRunLoopModeInferiorExecuting,
eRNBRunLoopModeExit
} RNBRunLoopMode;
//----------------------------------------------------------------------
// Global Variables
//----------------------------------------------------------------------
RNBRemoteSP g_remoteSP;
int g_disable_aslr = 0;
int g_isatty = 0;
#define RNBLogSTDOUT(fmt, ...) \
do { \
if (g_isatty) { \
fprintf(stdout, fmt, ##__VA_ARGS__); \
} else { \
_DNBLog(0, fmt, ##__VA_ARGS__); \
} \
} while (0)
#define RNBLogSTDERR(fmt, ...) \
do { \
if (g_isatty) { \
fprintf(stderr, fmt, ##__VA_ARGS__); \
} else { \
_DNBLog(0, fmt, ##__VA_ARGS__); \
} \
} while (0)
//----------------------------------------------------------------------
// Get our program path and arguments from the remote connection.
// We will need to start up the remote connection without a PID, get the
// arguments, wait for the new process to finish launching and hit its
// entry point, and then return the run loop mode that should come next.
//----------------------------------------------------------------------
RNBRunLoopMode RNBRunLoopGetStartModeFromRemote(RNBRemoteSP &remoteSP) {
std::string packet;
if (remoteSP.get() != NULL) {
RNBRemote *remote = remoteSP.get();
RNBContext &ctx = remote->Context();
uint32_t event_mask = RNBContext::event_read_packet_available;
// Spin waiting to get the A packet.
while (1) {
DNBLogThreadedIf(LOG_RNB_MAX,
"%s ctx.Events().WaitForSetEvents( 0x%08x ) ...",
__FUNCTION__, event_mask);
nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
DNBLogThreadedIf(LOG_RNB_MAX,
"%s ctx.Events().WaitForSetEvents( 0x%08x ) => 0x%08x",
__FUNCTION__, event_mask, set_events);
if (set_events & RNBContext::event_read_packet_available) {
rnb_err_t err = rnb_err;
RNBRemote::PacketEnum type;
err = remote->HandleReceivedPacket(&type);
// check if we tried to attach to a process
if (type == RNBRemote::vattach || type == RNBRemote::vattachwait) {
if (err == rnb_success)
return eRNBRunLoopModeInferiorExecuting;
else {
RNBLogSTDERR("error: attach failed.");
return eRNBRunLoopModeExit;
}
}
if (err == rnb_success) {
DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Got success...", __FUNCTION__);
continue;
} else if (err == rnb_not_connected) {
RNBLogSTDERR("error: connection lost.");
return eRNBRunLoopModeExit;
} else {
// a catch all for any other gdb remote packets that failed
DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s Error getting packet.",
__FUNCTION__);
continue;
}
DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s", __FUNCTION__);
} else {
DNBLogThreadedIf(LOG_RNB_MINIMAL,
"%s Connection closed before getting \"A\" packet.",
__FUNCTION__);
return eRNBRunLoopModeExit;
}
}
}
return eRNBRunLoopModeExit;
}
//----------------------------------------------------------------------
// Watch for signals:
// SIGINT: so we can halt our inferior. (disabled for now)
// SIGPIPE: in case our child process dies
//----------------------------------------------------------------------
nub_process_t g_pid;
int g_sigpipe_received = 0;
void signal_handler(int signo) {
DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s (%s)", __FUNCTION__,
SysSignal::Name(signo));
switch (signo) {
// case SIGINT:
// DNBProcessKill (g_pid, signo);
// break;
case SIGPIPE:
g_sigpipe_received = 1;
break;
}
}
// Return the new run loop mode based off of the current process state
RNBRunLoopMode HandleProcessStateChange(RNBRemoteSP &remote, bool initialize) {
RNBContext &ctx = remote->Context();
nub_process_t pid = ctx.ProcessID();
if (pid == INVALID_NUB_PROCESS) {
DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s error: pid invalid, exiting...",
__FUNCTION__);
return eRNBRunLoopModeExit;
}
nub_state_t pid_state = DNBProcessGetState(pid);
DNBLogThreadedIf(LOG_RNB_MINIMAL,
"%s (&remote, initialize=%i) pid_state = %s", __FUNCTION__,
(int)initialize, DNBStateAsString(pid_state));
switch (pid_state) {
case eStateInvalid:
case eStateUnloaded:
// Something bad happened
return eRNBRunLoopModeExit;
break;
case eStateAttaching:
case eStateLaunching:
return eRNBRunLoopModeInferiorExecuting;
case eStateSuspended:
case eStateCrashed:
case eStateStopped:
if (initialize == false) {
// Compare the last stop count to our current notion of a stop count
// to make sure we don't notify more than once for a given stop.
nub_size_t prev_pid_stop_count = ctx.GetProcessStopCount();
bool pid_stop_count_changed =
ctx.SetProcessStopCount(DNBProcessGetStopCount(pid));
if (pid_stop_count_changed) {
remote->FlushSTDIO();
if (ctx.GetProcessStopCount() == 1) {
DNBLogThreadedIf(
LOG_RNB_MINIMAL, "%s (&remote, initialize=%i) pid_state = %s "
"pid_stop_count %zu (old %zu)) Notify??? no, "
"first stop...",
__FUNCTION__, (int)initialize, DNBStateAsString(pid_state),
ctx.GetProcessStopCount(), prev_pid_stop_count);
} else {
DNBLogThreadedIf(
LOG_RNB_MINIMAL, "%s (&remote, initialize=%i) pid_state = %s "
"pid_stop_count %zu (old %zu)) Notify??? YES!!!",
__FUNCTION__, (int)initialize, DNBStateAsString(pid_state),
ctx.GetProcessStopCount(), prev_pid_stop_count);
remote->NotifyThatProcessStopped();
}
} else {
DNBLogThreadedIf(LOG_RNB_MINIMAL, "%s (&remote, initialize=%i) "
"pid_state = %s pid_stop_count %zu "
"(old %zu)) Notify??? skipping...",
__FUNCTION__, (int)initialize,
DNBStateAsString(pid_state), ctx.GetProcessStopCount(),
prev_pid_stop_count);
}
}
return eRNBRunLoopModeInferiorExecuting;
case eStateStepping:
case eStateRunning:
return eRNBRunLoopModeInferiorExecuting;
case eStateExited:
remote->HandlePacket_last_signal(NULL);
return eRNBRunLoopModeExit;
case eStateDetached:
return eRNBRunLoopModeExit;
}
// Catch all...
return eRNBRunLoopModeExit;
}
// This function handles the case where our inferior program is stopped and
// we are waiting for gdb remote protocol packets. When a packet occurs that
// makes the inferior run, we need to leave this function with a new state
// as the return code.
RNBRunLoopMode RNBRunLoopInferiorExecuting(RNBRemoteSP &remote) {
DNBLogThreadedIf(LOG_RNB_MINIMAL, "#### %s", __FUNCTION__);
RNBContext &ctx = remote->Context();
// Init our mode and set 'is_running' based on the current process state
RNBRunLoopMode mode = HandleProcessStateChange(remote, true);
while (ctx.ProcessID() != INVALID_NUB_PROCESS) {
std::string set_events_str;
uint32_t event_mask = ctx.NormalEventBits();
if (!ctx.ProcessStateRunning()) {
// Clear the stdio bits if we are not running so we don't send any async
// packets
event_mask &= ~RNBContext::event_proc_stdio_available;
}
// We want to make sure we consume all process state changes and have
// whomever is notifying us to wait for us to reset the event bit before
// continuing.
// ctx.Events().SetResetAckMask (RNBContext::event_proc_state_changed);
DNBLogThreadedIf(LOG_RNB_EVENTS,
"%s ctx.Events().WaitForSetEvents(0x%08x) ...",
__FUNCTION__, event_mask);
nub_event_t set_events = ctx.Events().WaitForSetEvents(event_mask);
DNBLogThreadedIf(LOG_RNB_EVENTS,
"%s ctx.Events().WaitForSetEvents(0x%08x) => 0x%08x (%s)",
__FUNCTION__, event_mask, set_events,
ctx.EventsAsString(set_events, set_events_str));
if (set_events) {
if ((set_events & RNBContext::event_proc_thread_exiting) ||
(set_events & RNBContext::event_proc_stdio_available)) {
remote->FlushSTDIO();
}
if (set_events & RNBContext::event_read_packet_available) {
// handleReceivedPacket will take care of resetting the
// event_read_packet_available events when there are no more...
set_events ^= RNBContext::event_read_packet_available;
if (ctx.ProcessStateRunning()) {
if (remote->HandleAsyncPacket() == rnb_not_connected) {
// TODO: connect again? Exit?
}
} else {
if (remote->HandleReceivedPacket() == rnb_not_connected) {
// TODO: connect again? Exit?
}
}
}
if (set_events & RNBContext::event_proc_state_changed) {
mode = HandleProcessStateChange(remote, false);
ctx.Events().ResetEvents(RNBContext::event_proc_state_changed);
set_events ^= RNBContext::event_proc_state_changed;
}
if (set_events & RNBContext::event_proc_thread_exiting) {
mode = eRNBRunLoopModeExit;
}
if (set_events & RNBContext::event_read_thread_exiting) {
// Out remote packet receiving thread exited, exit for now.
if (ctx.HasValidProcessID()) {
// TODO: We should add code that will leave the current process
// in its current state and listen for another connection...
if (ctx.ProcessStateRunning()) {
DNBProcessKill(ctx.ProcessID());
}
}
mode = eRNBRunLoopModeExit;
}
}
// Reset all event bits that weren't reset for now...
if (set_events != 0)
ctx.Events().ResetEvents(set_events);
if (mode != eRNBRunLoopModeInferiorExecuting)
break;
}
return mode;
}
void ASLLogCallback(void *baton, uint32_t flags, const char *format,
va_list args) {
#if 0
vprintf(format, args);
#endif
}
extern "C" int debug_server_main(int fd) {
#if 1
g_isatty = 0;
#else
g_isatty = ::isatty(STDIN_FILENO);
DNBLogSetDebug(1);
DNBLogSetVerbose(1);
DNBLogSetLogMask(-1);
DNBLogSetLogCallback(ASLLogCallback, NULL);
#endif
signal(SIGPIPE, signal_handler);
g_remoteSP.reset(new RNBRemote);
RNBRemote *remote = g_remoteSP.get();
if (remote == NULL) {
RNBLogSTDERR("error: failed to create a remote connection class\n");
return -1;
}
RNBRunLoopMode mode = eRNBRunLoopModeGetStartModeFromRemoteProtocol;
while (mode != eRNBRunLoopModeExit) {
switch (mode) {
case eRNBRunLoopModeGetStartModeFromRemoteProtocol:
if (g_remoteSP->Comm().useFD(fd) == rnb_success) {
RNBLogSTDOUT("Starting remote data thread.\n");
g_remoteSP->StartReadRemoteDataThread();
RNBLogSTDOUT("Waiting for start mode from remote.\n");
mode = RNBRunLoopGetStartModeFromRemote(g_remoteSP);
} else {
mode = eRNBRunLoopModeExit;
}
break;
case eRNBRunLoopModeInferiorExecuting:
mode = RNBRunLoopInferiorExecuting(g_remoteSP);
break;
default:
mode = eRNBRunLoopModeExit;
break;
case eRNBRunLoopModeExit:
break;
}
}
g_remoteSP->StopReadRemoteDataThread();
g_remoteSP->Context().SetProcessID(INVALID_NUB_PROCESS);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink