Subversion Repositories openrisc

// ----------------------------------------------------------------------------

// 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 ()