Subversion Repositories openrisc_2011-10-31

// ----------------------------------------------------------------------------
 
// Remote Serial Protocol connection: implementation
 
// Copyright (C) 2008  Embecosm Limited <info@embecosm.com>
 
// Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
// This file is part of the cycle accurate model of the OpenRISC 1000 based
// system-on-chip, ORPSoC, built using Verilator.
 
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
 
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
// License for more details.
 
// You should have received a copy of the GNU Lesser General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
// ----------------------------------------------------------------------------
 
// $Id: RspConnection.cpp 327 2009-03-07 19:10:56Z jeremy $
 
#include <iostream>
#include <iomanip>
 
#include <cerrno>
#include <csignal>
#include <cstring>
 
#include <netdb.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <poll.h>
 
#include "RspConnection.h"
#include "Utils.h"
 
using std::cerr;
using std::cout;
using std::dec;
using std::endl;
using std::flush;
using std::hex;
using std::setfill;
using std::setw;
 
// Define RSP_TRACE to turn on tracing of packets sent and received
// #define RSP_TRACE
 
 
//-----------------------------------------------------------------------------
//! Constructor when using a port number
 
//! Calls the generic initializer.
 
//! @param[in] _portNum     The port number to connect to
//-----------------------------------------------------------------------------
RspConnection::RspConnection (int  _portNum)
{
  rspInit (_portNum, DEFAULT_RSP_SERVICE);
 
}	// RspConnection ()
 
 
//-----------------------------------------------------------------------------
//! Constructor when using a service
 
//! Calls the generic initializer.
 
//! @param[in] _serviceName  The service name to use. Defaults to
//!                          DEFAULT_RSP_SERVER
//-----------------------------------------------------------------------------
RspConnection::RspConnection (const char *_serviceName)
{
  rspInit (0, _serviceName);
 
}	// RspConnection ()
 
 
//-----------------------------------------------------------------------------
//! Destructor
 
//! Close the connection if it is still open
//-----------------------------------------------------------------------------
RspConnection::~RspConnection ()
{
  this->rspClose ();		// Don't confuse with any other close ()
 
}	// ~RspConnection ()
 
 
//-----------------------------------------------------------------------------
//! Generic initialization routine specifying both port number and service
//! name.
 
//! Private, since this is not intended to be called by users. The service
//! name is only used if port number is zero.
 
//! Allocate the two fifos from packets from the client and to the client.
 
//! We only use a single packet in transit at any one time, so allocate that
//! packet here (rather than getting a new one each time.
 
//! @param[in] _portNum       The port number to connect to
//! @param[in] _serviceName   The service name to use (if PortNum == 0).
//-----------------------------------------------------------------------------
void
RspConnection::rspInit (int         _portNum,
			const char *_serviceName)
{
  portNum     = _portNum;
  serviceName = _serviceName;
  clientFd    = -1;
 
}	// init ()
 
 
//-----------------------------------------------------------------------------
//! Get a new client connection.
 
//! Blocks until the client connection is available.
 
//! A lot of this code is copied from remote_open in gdbserver remote-utils.c.
 
//! This involves setting up a socket to listen on a socket for attempted
//! connections from a single GDB instance (we couldn't be talking to multiple
//! GDBs at once!).
 
//! The service is specified either as a port number in the Or1ksim
//! configuration (parameter rsp_port in section debug, default 51000) or as a
//! service name in the constant OR1KSIM_RSP_SERVICE.
 
//! If there is a catastrophic communication failure, service will be
//! terminated using sc_stop.
 
//! The protocol used for communication is specified in OR1KSIM_RSP_PROTOCOL.
 
//! @return  TRUE if the connection was established or can be retried. FALSE
//!          if the error was so serious the program must be aborted.
//-----------------------------------------------------------------------------
bool
RspConnection::rspConnect ()
{
  // 0 is used as the RSP port number to indicate that we should use the
  // service name instead.
  if (0 == portNum)
    {
      struct servent *service = getservbyname (serviceName, "tcp");
 
      if (NULL == service)
	{
	  cerr << "ERROR: RSP unable to find service \"" << serviceName
	       << "\": " << strerror (errno) << endl;
	  return  false;
	}
 
      portNum = ntohs (service->s_port);
    }
 
  // Open a socket on which we'll listen for clients
  int  tmpFd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (tmpFd < 0)
    {
      cerr << "ERROR: Cannot open RSP socket" << endl;
      return  false;
    }
 
  // Allow rapid reuse of the port on this socket
  int  optval = 1;
  setsockopt (tmpFd, SOL_SOCKET, SO_REUSEADDR, (char *)&optval,
	      sizeof (optval));
 
 
 
  // Bind the port to the socket
  struct sockaddr_in  sockAddr;
  sockAddr.sin_family      = PF_INET;
  sockAddr.sin_port        = htons (portNum);
  sockAddr.sin_addr.s_addr = INADDR_ANY;
 
  if (bind (tmpFd, (struct sockaddr *) &sockAddr, sizeof (sockAddr)))
    {
      cerr << "ERROR: Cannot bind to RSP socket" << endl;
      return  false;
    }
 
  // Listen for (at most one) client
  if (listen (tmpFd, 1))
    {
      cerr << "ERROR: Cannot listen on RSP socket" << endl;
      return  false;
    }
 
  cout << "Listening for RSP on port " <<  portNum << endl << flush;
 
  // Accept a client which connects
  socklen_t  len;		// Size of the socket address
  clientFd = accept (tmpFd, (struct sockaddr *)&sockAddr, &len);
 
  if (-1 == clientFd)
    {
      cerr << "Warning: Failed to accept RSP client" << endl;
      return  true;			// OK to retry
    }
 
  // Enable TCP keep alive process
  optval = 1;
  setsockopt (clientFd, SOL_SOCKET, SO_KEEPALIVE, (char *)&optval,
	      sizeof (optval));
 
  int flags;
 
  /* If they have O_NONBLOCK, use the Posix way to do it */
 
#if defined(O_NONBLOCK)
  /* Fixme: O_NONBLOCK is defined but broken on SunOS 4.1.x and AIX 3.2.5. */
  if (-1 == (flags = fcntl(clientFd, F_GETFL, 0)))
    flags = 0;
 
  fcntl(clientFd, F_SETFL, flags | O_NONBLOCK);
#else
  /* Otherwise, use the old way of doing it */
  flags = 1;
  ioctl(clientFd, FIOBIO, &flags);
#endif
 
  /* Set socket to be non-blocking */
 
  /* We do this because when we're given a continue, or step
     instruction,command we set the processor stall off, then instantly check
     if it's stopped. If it hasn't then we drop through and wait for input
     from GDB. Obviously this will cause problems when it will stop after we
     do the check. So now, rspSocketPeek() been implemented to simply check if
     there's an incoming command from GDB (although, mainly interested in 
     int. commands), otherwise it returns back to poll the processor's
     stall bit. It can only do this if the socket is non-blocking.
 
     At first test, simply adding this line appeared to give no problems with
     the existing code. No "simulation" of blocking behaviour on the
     non-blocking socket was required (in the event that a read/write throws
     back a EWOULDBLOCK error, as was looked to be the case in the previous
     GDB handling code) -- Julius
  */
  if (ioctl(clientFd, FIONBIO, (char *)&optval) > 0 )
    {
      cerr << "RspConnect: ioctl failed, line "<< __LINE__ << endl;
      close(clientFd);
      close(tmpFd);
      return false;
    }
 
  // Don't delay small packets, for better interactive response (disable
  // Nagel's algorithm)
  optval = 1;
  setsockopt (clientFd, IPPROTO_TCP, TCP_NODELAY, (char *)&optval,
	      sizeof (optval));
 
  // Socket is no longer needed
  close (tmpFd);			// No longer need this
  signal (SIGPIPE, SIG_IGN);		// So we don't exit if client dies
 
  cout << "Remote debugging from host " << inet_ntoa (sockAddr.sin_addr)
       << endl;
  return true;
 
}	// rspConnect ()
 
 
//-----------------------------------------------------------------------------
//! Close a client connection if it is open
//-----------------------------------------------------------------------------
void
RspConnection::rspClose ()
{
  if (isConnected ())
    {
      cout << "Closing connection" << endl;
      close (clientFd);
      clientFd = -1;
    }
}	// rspClose ()
 
 
//-----------------------------------------------------------------------------
//! Report if we are connected to a client.
 
//! @return  TRUE if we are connected, FALSE otherwise
//-----------------------------------------------------------------------------
bool
RspConnection::isConnected ()
{
  return -1 != clientFd;
 
}	// isConnected ()
 
//-----------------------------------------------------------------------------
//! Peek at data coming into server from GDB
 
//! Useful for polling for ETX (0x3) chars being sent when GDB wants to
//! interrupt
 
//! @return the char we peeked, 0 otherwise
//-----------------------------------------------------------------------------
char 
RspConnection::rspSocketPeek()
{
  char  c;
  int n;
  // Using recv here instead of read becuase we can pass the MSG_PEEK
  // flag, which lets us look at what's on the socket, without actually
  // taking it off
 
  //if (DEBUG_GDB) 
  //  printf("peeking at GDB socket...\n");
 
  n = recv (clientFd, &c, sizeof (c), MSG_PEEK);
 
  //if (DEBUG_GDB) 
  //  printf("peeked, got n=%d, c=0x%x\n",n, c);
 
  if (n>0)
    return c;
  else
    return -1;
  /*
  if (n > 0)
    return c;
  else
    return '\0';
  */
 
}
 
//-----------------------------------------------------------------------------
//! Get the next packet from the RSP connection
 
//! Modeled on the stub version supplied with GDB. This allows the user to
//! replace the character read function, which is why we get stuff a character
//! at at time.
 
//! Unlike the reference implementation, we don't deal with sequence
//! numbers. GDB has never used them, and this implementation is only intended
//! for use with GDB 6.8 or later. Sequence numbers were removed from the RSP
//! standard at GDB 5.0.
 
//! Since this is SystemC, if we hit something that is not a packet and
//! requires a restart/retransmission, we wait so another thread gets a lookin.
 
//! @param[in] pkt  The packet for storing the result.
 
//! @return  TRUE to indicate success, FALSE otherwise (means a communications
//!          failure)
//-----------------------------------------------------------------------------
bool
RspConnection::getPkt (RspPacket *pkt)
{
  // Keep getting packets, until one is found with a valid checksum
  while (true)
    {
      int            bufSize = pkt->getBufSize ();
      unsigned char  checksum;		// The checksum we have computed
      int            count;		// Index into the buffer
      int 	     ch;		// Current character
 
 
      // Wait around for the start character ('$'). Ignore all other
      // characters
      ch = getRspChar ();
      while (ch != '$')
	{
	  if (-1 == ch)
	    {
	      return  false;		// Connection failed
	    }
	  else
	    {
 	      ch = getRspChar ();
	    }
	}
 
      // Read until a '#' or end of buffer is found
      checksum =  0;
      count    =  0;
      while (count < bufSize - 1)
	{
	  ch = getRspChar ();
 
	  if (-1 == ch)
	    {
	      return  false;		// Connection failed
	    }
 
	  // If we hit a start of line char begin all over again
	  if ('$' == ch)
	    {
	      checksum =  0;
	      count    =  0;
 
	      continue;
	    }
 
	  // Break out if we get the end of line char
	  if ('#' == ch)
	    {
	      break;
	    }
 
	  // Update the checksum and add the char to the buffer
	  checksum         = checksum + (unsigned char)ch;
	  pkt->data[count] = (char)ch;
	  count++;
	}
 
      // Mark the end of the buffer with EOS - it's convenient for non-binary
      // data to be valid strings.
      pkt->data[count] = 0;
      pkt->setLen (count);
 
      // If we have a valid end of packet char, validate the checksum. If we
      // don't it's because we ran out of buffer in the previous loop.
      if ('#' == ch)
	{
	  unsigned char  xmitcsum;	// The checksum in the packet
 
	  ch = getRspChar ();
	  if (-1 == ch)
	    {
	      return  false;		// Connection failed
	    }
	  xmitcsum = Utils::char2Hex (ch) << 4;
 
	  ch = getRspChar ();
	  if (-1 == ch)
	    {
	      return  false;			// Connection failed
	    }
 
	  xmitcsum += Utils::char2Hex (ch);
 
	  // If the checksums don't match print a warning, and put the
	  // negative ack back to the client. Otherwise put a positive ack.
	  if (checksum != xmitcsum)
	    {
	      cerr << "Warning: Bad RSP checksum: Computed 0x"
			<< setw (2) << setfill ('0') << hex
			<< checksum << ", received 0x" << xmitcsum
			<< setfill (' ') << dec << endl;
	      if (!putRspChar ('-'))		// Failed checksum
		{
		  return  false;		// Comms failure
		}
	    }
	  else
	    {
	      if (!putRspChar ('+'))		// successful transfer
		{
		  return  false;		// Comms failure
		}
	      else
		{
#ifdef RSP_TRACE
		  cout << "getPkt: " << *pkt << endl;
#endif
		  return  true;			// Success
		}
	    }
	}
      else
	{
	  cerr << "Warning: RSP packet overran buffer" << endl;
	}
    }
 
}	// getPkt ()
 
 
//-----------------------------------------------------------------------------
//! Put the packet out on the RSP connection
 
//! Modeled on the stub version supplied with GDB. Put out the data preceded
//! by a '$', followed by a '#' and a one byte checksum. '$', '#', '*' and '}'
//! are escaped by preceding them with '}' and then XORing the character with
//! 0x20.
 
//! Since this is SystemC, if we hit something that requires a
//! restart/retransmission, we wait so another thread gets a lookin.
 
//! @param[in] pkt  The Packet to transmit
 
//! @return  TRUE to indicate success, FALSE otherwise (means a communications
//!          failure).
//-----------------------------------------------------------------------------
bool
RspConnection::putPkt (RspPacket *pkt)
{
  int  len = pkt->getLen ();
  int  ch;				// Ack char
 
  // Construct $<packet info>#<checksum>. Repeat until the GDB client
  // acknowledges satisfactory receipt.
  do
    {
      unsigned char checksum = 0;	// Computed checksum
      int           count    = 0;	// Index into the buffer
 
      if (!putRspChar ('$'))		// Start char
	{
	  return  false;		// Comms failure
	}
 
 
      // Body of the packet
      for (count = 0; count < len; count++)
	{
	  unsigned char  ch = pkt->data[count];
 
	  // Check for escaped chars
	  if (('$' == ch) || ('#' == ch) || ('*' == ch) || ('}' == ch))
	    {
	      ch       ^= 0x20;
	      checksum += (unsigned char)'}';
	      if (!putRspChar ('}'))
		{
		  return  false;	// Comms failure
		}
 
	    }
 
	  checksum += ch;
	  if (!putRspChar (ch))
	    {
	      return  false;		// Comms failure
	    }
	}
 
      if (!putRspChar ('#'))		// End char
	{
	  return  false;		// Comms failure
	}
 
      // Computed checksum
      if (!putRspChar (Utils::hex2Char (checksum >> 4)))
	{
	  return  false;		// Comms failure
	}
      if (!putRspChar (Utils::hex2Char (checksum % 16)))
	{
	  return  false;		// Comms failure
	}
 
      // Check for ack of connection failure
      ch = getRspChar ();
      if (-1 == ch)
	{
	  return  false;		// Comms failure
	}
    }
  while ('+' != ch);
 
#ifdef RSP_TRACE
  cout << "putPkt: " << *pkt << endl;
#endif
  return  true;
 
}	// putPkt ()
 
 
//-----------------------------------------------------------------------------
//! Put a single character out on the RSP connection
 
//! Utility routine. This should only be called if the client is open, but we
//! check for safety.
 
//! @param[in] c         The character to put out
 
//! @return  TRUE if char sent OK, FALSE if not (communications failure)
//-----------------------------------------------------------------------------
bool
RspConnection::putRspChar (char  c)
{
  if (-1 == clientFd)
    {
      cerr << "Warning: Attempt to write '" << c
		<< "' to unopened RSP client: Ignored" << endl;
      return  false;
    }
 
  // Write until successful (we retry after interrupts) or catastrophic
  // failure.
  while (true)
    {
      switch (write (clientFd, &c, sizeof (c)))
	{
	case -1:
	  // Error: only allow interrupts or would block
	  if ((EAGAIN != errno) && (EINTR != errno))
	    {
	      cerr << "Warning: Failed to write to RSP client: "
			<< "Closing client connection: "
			<<  strerror (errno) << endl;
	      return  false;
	    }
 
	  break;
 
	case 0:
	  break;		// Nothing written! Try again
 
	default:
	  return  true;		// Success, we can return
	}
    }
}	// putRspChar ()
 
 
//-----------------------------------------------------------------------------
//! Get a single character from the RSP connection
 
//! Utility routine. This should only be called if the client is open, but we
//! check for safety.
 
//! @return  The character received or -1 on failure
//-----------------------------------------------------------------------------
int
RspConnection::getRspChar ()
{
  if (-1 == clientFd)
    {
      cerr << "Warning: Attempt to read from "
	   << "unopened RSP client: Ignored" << endl;
      return  -1;
    }
 
  // Blocking read until successful (we retry after interrupts) or
  // catastrophic failure.
  while (true)
    {
      unsigned char  c;
 
      switch (read (clientFd, &c, sizeof (c)))
	{
	case -1:
	  if (errno == EAGAIN || errno == EWOULDBLOCK)
	    continue;
	  // Error: only allow interrupts
	  if (EINTR != errno)
	    {
	      cerr << "Warning: Failed to read from RSP client: "
		   << "Closing client connection: "
		   <<  strerror (errno) << endl;
	      return  -1;
	    }
	  break;
 
	case 0:
	  return  -1;
 
	default:
	  return  c & 0xff;	// Success, we can return (no sign extend!)
	}
    }
 
}	// getRspChar ()