gdbserve.c

这个是LINUX下的GDB调度工具的源码

/* gdbserve.c -- NLM debugging stub for Novell NetWare.

   This is originally based on an m68k software stub written by Glenn
   Engel at HP, but has changed quite a bit.  It was modified for the
   i386 by Jim Kingdon, Cygnus Support.  It was modified to run under
   NetWare by Ian Lance Taylor, Cygnus Support.

   This code is intended to produce an NLM (a NetWare Loadable Module)
   to run under Novell NetWare.  To create the NLM, compile this code
   into an object file using the NLM SDK on any i386 host, and use the
   nlmconv program (available in the GNU binutils) to transform the
   resulting object file into an NLM.  */

/****************************************************************************

		THIS SOFTWARE IS NOT COPYRIGHTED

   HP offers the following for use in the public domain.  HP makes no
   warranty with regard to the software or it's performance and the
   user accepts the software "AS IS" with all faults.

   HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
   TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
   OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

****************************************************************************/

/****************************************************************************
 *
 *    The following gdb commands are supported:
 *
 * command          function                               Return value
 *
 *    g             return the value of the CPU registers  hex data or ENN
 *    G             set the value of the CPU registers     OK or ENN
 *
 *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
 *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
 *
 *    c             Resume at current address              SNN   ( signal NN)
 *    cAA..AA       Continue at address AA..AA             SNN
 *
 *    s             Step one instruction                   SNN
 *    sAA..AA       Step one instruction from AA..AA       SNN
 *
 *    k             kill
 *
 *    ?             What was the last sigval ?             SNN   (signal NN)
 *
 * All commands and responses are sent with a packet which includes a
 * checksum.  A packet consists of
 *
 * $<packet info>#<checksum>.
 *
 * where
 * <packet info> :: <characters representing the command or response>
 * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
 *
 * When a packet is received, it is first acknowledged with either '+' or '-'.
 * '+' indicates a successful transfer.  '-' indicates a failed transfer.
 *
 * Example:
 *
 * Host:                  Reply:
 * $m0,10#2a               +$00010203040506070809101112131415#42
 *
 ****************************************************************************/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <time.h>

#ifdef __i386__
#include <dfs.h>
#include <conio.h>
#include <advanced.h>
#include <debugapi.h>
#include <process.h>
#else
#include <nwtypes.h>
#include <nwdfs.h>
#include <nwconio.h>
#include <nwadv.h>
#include <nwdbgapi.h>
#include <nwthread.h>
#endif

#include <aio.h>
#include "cpu.h"


/****************************************************/
/* This information is from Novell.  It is not in any of the standard
   NetWare header files.  */

struct DBG_LoadDefinitionStructure
{
	void *reserved1[4];
	LONG reserved5;
	LONG LDCodeImageOffset;
	LONG LDCodeImageLength;
	LONG LDDataImageOffset;
	LONG LDDataImageLength;
	LONG LDUninitializedDataLength;
	LONG LDCustomDataOffset;
	LONG LDCustomDataSize;
	LONG reserved6[2];
	LONG (*LDInitializationProcedure)(void);
};

#define LO_NORMAL		0x0000
#define LO_STARTUP		0x0001
#define LO_PROTECT		0x0002
#define LO_DEBUG		0x0004
#define LO_AUTO_LOAD  		0x0008

/* Loader returned error codes */
#define LOAD_COULD_NOT_FIND_FILE		1
#define LOAD_ERROR_READING_FILE			2
#define LOAD_NOT_NLM_FILE_FORMAT		3
#define LOAD_WRONG_NLM_FILE_VERSION		4
#define LOAD_REENTRANT_INITIALIZE_FAILURE	5
#define LOAD_CAN_NOT_LOAD_MULTIPLE_COPIES	6
#define LOAD_ALREADY_IN_PROGRESS		7
#define LOAD_NOT_ENOUGH_MEMORY			8
#define LOAD_INITIALIZE_FAILURE			9
#define LOAD_INCONSISTENT_FILE_FORMAT		10
#define LOAD_CAN_NOT_LOAD_AT_STARTUP		11
#define LOAD_AUTO_LOAD_MODULES_NOT_LOADED	12
#define LOAD_UNRESOLVED_EXTERNAL		13
#define LOAD_PUBLIC_ALREADY_DEFINED		14
/****************************************************/

/* The main thread ID.  */
static int mainthread;

/* An error message for the main thread to print.  */
static char *error_message;

/* The AIO port handle.  */
static int AIOhandle;

/* BUFMAX defines the maximum number of characters in inbound/outbound
   buffers.  At least NUMREGBYTES*2 are needed for register packets */
#define BUFMAX (REGISTER_BYTES * 2 + 16)

/* remote_debug > 0 prints ill-formed commands in valid packets and
   checksum errors. */
static int remote_debug = 1;

static const char hexchars[] = "0123456789abcdef";

unsigned char breakpoint_insn[] = BREAKPOINT;

char *mem2hex (void *mem, char *buf, int count, int may_fault);
char *hex2mem (char *buf, void *mem, int count, int may_fault);
extern void set_step_traps (struct StackFrame *);
extern void clear_step_traps (struct StackFrame *);

static int __main() {};

/* Read a character from the serial port.  This must busy wait, but
   that's OK because we will be the only thread running anyhow.  */

static int
getDebugChar (void)
{
  int err;
  LONG got;
  unsigned char ret;

  do
    {
      err = AIOReadData (AIOhandle, (char *) &ret, 1, &got);
      if (err != 0)
	{
	  error_message = "AIOReadData failed";
	  ResumeThread (mainthread);
	  return -1;
	}
    }
  while (got == 0);

  return ret;
}

/* Write a character to the serial port.  Returns 0 on failure,
   non-zero on success.  */

static int
putDebugChar (unsigned char c)
{
  int err;
  LONG put;

  put = 0;
  while (put < 1)
    {
      err = AIOWriteData (AIOhandle, (char *) &c, 1, &put);
      if (err != 0)
	ConsolePrintf ("AIOWriteData: err = %d, put = %d\r\n", err, put);
    }
  return 1;
}

/* Turn a hex character into a number.  */

static int
hex (char ch)
{
  if ((ch >= 'a') && (ch <= 'f'))
    return (ch-'a'+10);
  if ((ch >= '0') && (ch <= '9'))
    return (ch-'0');
  if ((ch >= 'A') && (ch <= 'F'))
    return (ch-'A'+10);
  return (-1);
}

/* Scan for the sequence $<data>#<checksum>.  Returns 0 on failure,
   non-zero on success.  */

static int
getpacket (char *buffer)
{
  unsigned char checksum;
  unsigned char xmitcsum;
  int i;
  int count;
  int ch;

  do
    {
      /* wait around for the start character, ignore all other characters */
      while ((ch = getDebugChar()) != '$')
	if (ch == -1)
	  return 0;
      checksum = 0;
      xmitcsum = -1;

      count = 0;

      /* now, read until a # or end of buffer is found */
      while (count < BUFMAX)
	{
	  ch = getDebugChar();
	  if (ch == -1)
	    return 0;
	  if (ch == '#')
	    break;
	  checksum = checksum + ch;
	  buffer[count] = ch;
	  count = count + 1;
	}
      buffer[count] = 0;

      if (ch == '#')
	{
	  ch = getDebugChar ();
	  if (ch == -1)
	    return 0;
	  xmitcsum = hex(ch) << 4;
	  ch = getDebugChar ();
	  if (ch == -1)
	    return 0;
	  xmitcsum += hex(ch);

	  if (checksum != xmitcsum)
	    {
	      if (remote_debug)
		ConsolePrintf ("bad checksum.  My count = 0x%x, sent=0x%x. buf=%s\n",
			       checksum,xmitcsum,buffer);
	      /* failed checksum */
	      if (! putDebugChar('-'))
		return 0;
	      return 1;
	    }
	  else
	    {
	      /* successful transfer */
	      if (! putDebugChar('+'))
		return 0;
	      /* if a sequence char is present, reply the sequence ID */
	      if (buffer[2] == ':')
		{
		  if (! putDebugChar (buffer[0])
		      || ! putDebugChar (buffer[1]))
		    return 0;
		  /* remove sequence chars from buffer */
		  count = strlen(buffer);
		  for (i=3; i <= count; i++)
		    buffer[i-3] = buffer[i];
		}
	    }
	}
    }
  while (checksum != xmitcsum);

  if (remote_debug)
    ConsolePrintf ("Received packet \"%s\"\r\n", buffer);

  return 1;
}

/* Send the packet in buffer.  Returns 0 on failure, non-zero on
   success.  */

static int
putpacket (char *buffer)
{
  unsigned char checksum;
  int count;
  int ch;

  if (remote_debug)
    ConsolePrintf ("Sending packet \"%s\"\r\n", buffer);

  /*  $<packet info>#<checksum>. */
  do
    {
      if (! putDebugChar('$'))
	return 0;
      checksum = 0;
      count = 0;

      while (ch=buffer[count])
	{
	  if (! putDebugChar(ch))
	    return 0;
	  checksum += ch;
	  count += 1;
	}

      if (! putDebugChar('#')
	  || ! putDebugChar(hexchars[checksum >> 4])
	  || ! putDebugChar(hexchars[checksum % 16]))
	return 0;

      ch = getDebugChar ();
      if (ch == -1)
	return 0;
    }
  while (ch != '+');

  return 1;
}

static char remcomInBuffer[BUFMAX];
static char remcomOutBuffer[BUFMAX];
static short error;

static void
debug_error (char *format, char *parm)
{
  if (remote_debug)
    {
      ConsolePrintf (format, parm);
      ConsolePrintf ("\n");
    }
}

/* This is set if we could get a memory access fault.  */
static int mem_may_fault;

/* Indicate to caller of mem2hex or hex2mem that there has been an
   error.  */
volatile int mem_err = 0;

#ifndef ALTERNATE_MEM_FUNCS
/* These are separate functions so that they are so short and sweet
   that the compiler won't save any registers (if there is a fault
   to mem_fault, they won't get restored, so there better not be any
   saved).  */

int
get_char (char *addr)
{
  return *addr;
}

void
set_char (char *addr, int val)
{
  *addr = val;
}
#endif /* ALTERNATE_MEM_FUNCS */

/* convert the memory pointed to by mem into hex, placing result in buf */
/* return a pointer to the last char put in buf (null) */
/* If MAY_FAULT is non-zero, then we should set mem_err in response to
   a fault; if zero treat a fault like any other fault in the stub.  */

char *
mem2hex (void *mem, char *buf, int count, int may_fault)
{
  int i;
  unsigned char ch;
  char *ptr = mem;

  mem_may_fault = may_fault;
  for (i = 0; i < count; i++)
    {
      ch = get_char (ptr++);
      if (may_fault && mem_err)
	return (buf);
      *buf++ = hexchars[ch >> 4];
      *buf++ = hexchars[ch % 16];
    }
  *buf = 0;
  mem_may_fault = 0;
  return(buf);
}

/* convert the hex array pointed to by buf into binary to be placed in mem */
/* return a pointer to the character AFTER the last byte written */

char *
hex2mem (char *buf, void *mem, int count, int may_fault)
{
  int i;
  unsigned char ch;
  char *ptr = mem;

  mem_may_fault = may_fault;
  for (i=0;i<count;i++)
    {
      ch = hex(*buf++) << 4;
      ch = ch + hex(*buf++);
      set_char (ptr++, ch);
      if (may_fault && mem_err)
	return (ptr);
    }
  mem_may_fault = 0;
  return(mem);
}

/* This function takes the 386 exception vector and attempts to
   translate this number into a unix compatible signal value.  */

int
computeSignal (int exceptionVector)
{
  int sigval;
  switch (exceptionVector)
    {
    case 0 : sigval = 8; break; /* divide by zero */
    case 1 : sigval = 5; break; /* debug exception */
    case 3 : sigval = 5; break; /* breakpoint */
    case 4 : sigval = 16; break; /* into instruction (overflow) */
    case 5 : sigval = 16; break; /* bound instruction */
    case 6 : sigval = 4; break; /* Invalid opcode */
    case 7 : sigval = 8; break; /* coprocessor not available */
    case 8 : sigval = 7; break; /* double fault */
    case 9 : sigval = 11; break; /* coprocessor segment overrun */
    case 10 : sigval = 11; break; /* Invalid TSS */
    case 11 : sigval = 11; break; /* Segment not present */
    case 12 : sigval = 11; break; /* stack exception */
    case 13 : sigval = 11; break; /* general protection */
    case 14 : sigval = 11; break; /* page fault */
    case 16 : sigval = 7; break; /* coprocessor error */
    default:
      sigval = 7;		/* "software generated"*/
    }
  return (sigval);
}

/**********************************************/
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
/* RETURN NUMBER OF CHARS PROCESSED           */
/**********************************************/
static int
hexToInt (char **ptr, int *intValue)
{
  int numChars = 0;
  int hexValue;

  *intValue = 0;

  while (**ptr)
    {
      hexValue = hex(**ptr);
      if (hexValue >=0)
	{
	  *intValue = (*intValue <<4) | hexValue;
	  numChars ++;
	}
      else
	break;

      (*ptr)++;
    }

  return (numChars);
}

/* This function does all command processing for interfacing to gdb.
   It is called whenever an exception occurs in the module being
   debugged.  */

static LONG
handle_exception (struct StackFrame *frame)
{
  int addr, length;
  char *ptr;
  static struct DBG_LoadDefinitionStructure *ldinfo = 0;
  static unsigned char first_insn[BREAKPOINT_SIZE]; /* The first instruction in the program.  */

#if 0
  /* According to some documentation from Novell, the bell sometimes
     may be ringing at this point.  This can be stopped on Netware 4
     systems by calling the undocumented StopBell() function. */

  StopBell ();
#endif