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