lldb/tools/debugserver/source/libdebugserver.cpp

//===-- 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 <sys/socket.h>
#include <sys/types.h>
#include <errno.h>
#include <getopt.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/sysctl.h>

#include "DNB.h"
#include "DNBLog.h"
#include "DNBTimer.h"
#include "PseudoTerminal.h"
#include "RNBContext.h"
#include "RNBServices.h"
#include "RNBSocket.h"
#include "RNBRemote.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 %u (old %u)) 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 %u (old %u)) 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 %u (old %u)) 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(), SIGINT);
                    }
                }
                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;
}