Subversion Repositories or1k

/* rsp-server.c -- Remote Serial Protocol server for GDB

   Copyright (C) 2008 Embecosm Limited

   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>

   This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.

   This program is free software; you can redistribute it and/or modify it

   under the terms of the GNU 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 General Public License for

   more details.

   You should have received a copy of the GNU General Public License along

   with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* This program is commented throughout in a fashion suitable for processing

   with Doxygen. */

/* Autoconf and/or portability configuration */

#include "config.h"

#include "port.h"

/* System includes */

#include <stdlib.h>

#include <unistd.h>

#include <netdb.h>

#include <stdio.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <fcntl.h>

#include <arpa/inet.h>

#include <poll.h>

#include <netinet/tcp.h>

#include <signal.h>

/* Package includes */

#include "sim-config.h"

#include "except.h"

#include "opcode/or32.h"

#include "spr-defs.h"

#include "execute.h"

#include "debug-unit.h"

#include "sprs.h"

#include "toplevel-support.h"

/* Define to log each packet */

/* #define RSP_TRACE  1 */

/*! Name of the Or1ksim RSP service */

#define OR1KSIM_RSP_SERVICE  "or1ksim-rsp"

/*! Protocol used by Or1ksim */

#define OR1KSIM_RSP_PROTOCOL  "tcp"

/*! Thread ID used by Or1ksim */

#define OR1KSIM_TID  1

/* Indices of GDB registers that are not GPRs. Must match GDB settings! */

#define PPC_REGNUM  (MAX_GPRS + 0)      /*!< Previous PC */

#define NPC_REGNUM  (MAX_GPRS + 1)      /*!< Next PC */

#define SR_REGNUM   (MAX_GPRS + 2)      /*!< Supervision Register */

#define NUM_REGS    (MAX_GRPS + 3)      /*!< Total GDB registers */

/*! Trap instruction for OR32 */

#define OR1K_TRAP_INSTR  0x21000001

/*! Definition of GDB target signals. Data taken from the GDB 6.8

    source. Only those we use defined here. */

enum target_signal {

  TARGET_SIGNAL_NONE =  0,

  TARGET_SIGNAL_INT  =  2,

  TARGET_SIGNAL_ILL  =  4,

  TARGET_SIGNAL_TRAP =  5,

  TARGET_SIGNAL_FPE  =  8,

  TARGET_SIGNAL_BUS  = 10,

  TARGET_SIGNAL_SEGV = 11,

  TARGET_SIGNAL_ALRM = 14,

  TARGET_SIGNAL_USR2 = 31,

  TARGET_SIGNAL_PWR  = 32

};

/*! The maximum number of characters in inbound/outbound buffers.  The largest

    packets are the 'G' packet, which must hold the 'G' and all the registers

    with two hex digits per byte and the 'g' reply, which must hold all the

    registers, and (in our implementation) an end-of-string (0)

    character. Adding the EOS allows us to print out the packet as a

    string. So at least NUMREGBYTES*2 + 1 (for the 'G' or the EOS) are needed

    for register packets */

#define GDB_BUF_MAX  ((NUM_REGS) * 8 + 1)

/*! Size of the matchpoint hash table. Largest prime < 2^10 */

#define MP_HASH_SIZE  1021

/*! String to map hex digits to chars */

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

/*! Data structure for RSP buffers. Can't be null terminated, since it may

  include zero bytes */

struct rsp_buf

{

  char  data[GDB_BUF_MAX];

  int   len;

};

/*! Enumeration of different types of matchpoint. These have explicit values

    matching the second digit of 'z' and 'Z' packets. */

enum mp_type {

  BP_MEMORY   = 0,

  BP_HARDWARE = 1,

  WP_WRITE    = 2,

  WP_READ     = 3,

  WP_ACCESS   = 4

};

/*! Data structure for a matchpoint hash table entry */

struct mp_entry

{

  enum mp_type       type;              /*!< Type of matchpoint */

  unsigned long int  addr;              /*!< Address with the matchpoint */

  unsigned long int  instr;             /*!< Substituted instruction */

  struct mp_entry   *next;              /*!< Next entry with this hash */

};

/*! Central data for the RSP connection */

static struct

{

  int                client_waiting;    /*!< Is client waiting a response? */

  int                proto_num;         /*!< Number of the protocol used */

  int                client_fd;         /*!< FD for talking to GDB */

  int                sigval;            /*!< GDB signal for any exception */

  unsigned long int  start_addr;        /*!< Start of last run */

  struct mp_entry   *mp_hash[MP_HASH_SIZE];     /*!< Matchpoint hash table */

} rsp;

/* Forward declarations of static functions */

static void               rsp_get_client ();

static void               rsp_client_request ();

static void               rsp_client_close ();

static void               put_packet (struct rsp_buf *buf);

static void               put_str_packet (const char *str);

static struct rsp_buf    *get_packet ();

static void               put_rsp_char (char  c);

static int                get_rsp_char ();

static int                rsp_unescape (char *data,

                                        int   len);

static void               mp_hash_init ();

static void               mp_hash_add (enum mp_type       type,

                                       unsigned long int  addr,

                                       unsigned long int  instr);

static struct mp_entry   *mp_hash_lookup (enum mp_type       type,

                                          unsigned long int  addr);

static struct mp_entry   *mp_hash_delete (enum mp_type       type,

                                          unsigned long int  addr);

static int                hex (int  c);

static void               reg2hex (unsigned long int  val,

                                   char              *buf);

static unsigned long int  hex2reg (char *buf);

static void               ascii2hex (char *dest,

                                     char *src);

static void               hex2ascii (char *dest,

                                     char *src);

static void               set_npc (unsigned long int  addr);

static void               rsp_report_exception ();

static void               rsp_continue (struct rsp_buf *buf);

static void               rsp_continue_with_signal (struct rsp_buf *buf);

static void               rsp_continue_generic (unsigned long int  addr,

                                                unsigned long int  except);

static void               rsp_read_all_regs ();

static void               rsp_write_all_regs (struct rsp_buf *buf);

static void               rsp_read_mem (struct rsp_buf *buf);

static void               rsp_write_mem (struct rsp_buf *buf);

static void               rsp_read_reg (struct rsp_buf *buf);

static void               rsp_write_reg (struct rsp_buf *buf);

static void               rsp_query (struct rsp_buf *buf);

static void               rsp_command (struct rsp_buf *buf);

static void               rsp_set (struct rsp_buf *buf);

static void               rsp_restart ();

static void               rsp_step (struct rsp_buf *buf);

static void               rsp_step_with_signal (struct rsp_buf *buf);

static void               rsp_step_generic (unsigned long int  addr,

                                            unsigned long int  except);

static void               rsp_vpkt (struct rsp_buf *buf);

static void               rsp_write_mem_bin (struct rsp_buf *buf);

static void               rsp_remove_matchpoint (struct rsp_buf *buf);

static void               rsp_insert_matchpoint (struct rsp_buf *buf);

/*---------------------------------------------------------------------------*/

/*!Initialize the Remote Serial Protocol connection

   Set up the central data structures.                                       */

/*---------------------------------------------------------------------------*/

void

rsp_init ()

{

  /* Clear out the central data structure */

  rsp.client_waiting =  0;               /* GDB client is not waiting for us */

  rsp.client_fd      = -1;              /* i.e. invalid */

  rsp.sigval         =  0;               /* No exception */

  rsp.start_addr     = EXCEPT_RESET;    /* Default restart point */

  /* Set up the matchpoint hash table */

  mp_hash_init ();

}       /* rsp_init () */

/*---------------------------------------------------------------------------*/

/*!Look for action on RSP

   This function is called when the processor has stalled, which, except for

   initialization, must be due to an interrupt.

   If we have no RSP client, we get one. We can make no progress until the

   client is available.

   Then if the cause is an exception following a step or continue command, and

   the exception not been notified to GDB, a packet reporting the cause of the

   exception is sent.

   The next client request is then processed.                                */

/*---------------------------------------------------------------------------*/

void

handle_rsp ()

{

  /* If we have no RSP client, wait until we get one. */

  while (-1 == rsp.client_fd)

    {

      rsp_get_client ();

      rsp.client_waiting = 0;            /* No longer waiting */

    }

  /* If we have an unacknowledged exception tell the GDB client. If this

     exception was a trap due to a memory breakpoint, then adjust the NPC. */

  if (rsp.client_waiting)

    {

      if ((TARGET_SIGNAL_TRAP == rsp.sigval) &&

          (NULL != mp_hash_lookup (BP_MEMORY, cpu_state.sprs[SPR_PPC])))

        {

          set_npc (cpu_state.sprs[SPR_PPC]);

        }

      rsp_report_exception();

      rsp.client_waiting = 0;            /* No longer waiting */

    }

  /* Get a RSP client request */

  rsp_client_request ();

}       /* handle_rsp () */

/*---------------------------------------------------------------------------*/

/*!Note an exception for future processing

   The simulator has encountered an exception. Record it here, so that a

   future call to handle_exception will report it back to the client. The

   signal is supplied in Or1ksim form and recorded in GDB form.

   We flag up a warning if an exception is already pending, and ignore the

   earlier exception.

   @param[in] except  The exception (Or1ksim form)                           */

/*---------------------------------------------------------------------------*/

void

rsp_exception (unsigned long int  except)

{

  int  sigval;                  /* GDB signal equivalent to exception */

  switch (except)

    {

    case EXCEPT_RESET:    sigval = TARGET_SIGNAL_PWR;  break;

    case EXCEPT_BUSERR:   sigval = TARGET_SIGNAL_BUS;  break;

    case EXCEPT_DPF:      sigval = TARGET_SIGNAL_SEGV; break;

    case EXCEPT_IPF:      sigval = TARGET_SIGNAL_SEGV; break;

    case EXCEPT_TICK:     sigval = TARGET_SIGNAL_ALRM; break;

    case EXCEPT_ALIGN:    sigval = TARGET_SIGNAL_BUS;  break;

    case EXCEPT_ILLEGAL:  sigval = TARGET_SIGNAL_ILL;  break;

    case EXCEPT_INT:      sigval = TARGET_SIGNAL_INT;  break;

    case EXCEPT_DTLBMISS: sigval = TARGET_SIGNAL_SEGV; break;

    case EXCEPT_ITLBMISS: sigval = TARGET_SIGNAL_SEGV; break;

    case EXCEPT_RANGE:    sigval = TARGET_SIGNAL_FPE;  break;

    case EXCEPT_SYSCALL:  sigval = TARGET_SIGNAL_USR2; break;

    case EXCEPT_FPE:      sigval = TARGET_SIGNAL_FPE;  break;

    case EXCEPT_TRAP:     sigval = TARGET_SIGNAL_TRAP; break;

    default:

      fprintf (stderr, "Warning: Unknown RSP exception %lu: Ignored\n", except);

      return;

    }

  if ((0 != rsp.sigval) && (sigval != rsp.sigval))

    {

      fprintf (stderr, "Warning: RSP signal %d received while signal "

               "%d pending: Pending exception replaced\n", sigval, rsp.sigval);

    }

  rsp.sigval         = sigval;          /* Save the signal value */

}       /* rsp_exception () */

/*---------------------------------------------------------------------------*/

/*!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.

   The protocol used for communication is specified in OR1KSIM_RSP_PROTOCOL. */

/*---------------------------------------------------------------------------*/

static void

rsp_get_client ()

{

  int                 tmp_fd;           /* Temporary descriptor for socket */

  int                 optval;           /* Socket options */

  struct sockaddr_in  sock_addr;        /* Socket address */

  socklen_t           len;              /* Size of the socket address */

  /* 0 is used as the RSP port number to indicate that we should use the

     service name instead. */

  if (0 == config.debug.rsp_port)

    {

      struct servent *service =

        getservbyname (OR1KSIM_RSP_SERVICE, "tcp");

      if (NULL == service)

        {

          fprintf (stderr, "Warning: RSP unable to find service \"%s\": %s\n",

                   OR1KSIM_RSP_SERVICE, strerror (errno));

          return;

        }

      config.debug.rsp_port = ntohs (service->s_port);

    }

  /* Open a socket on which we'll listen for clients */

  tmp_fd = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP);

  if (tmp_fd < 0)

    {

      fprintf (stderr, "ERROR: Cannot open RSP socket\n");

      sim_done ();

    }

  /* Allow rapid reuse of the port on this socket */

  optval = 1;

  setsockopt (tmp_fd, SOL_SOCKET, SO_REUSEADDR, (char *)&optval,

              sizeof (optval));

  /* Bind the port to the socket */

  sock_addr.sin_family      = PF_INET;

  sock_addr.sin_port        = htons (config.debug.rsp_port);

  sock_addr.sin_addr.s_addr = INADDR_ANY;

  if (bind (tmp_fd, (struct sockaddr *) &sock_addr, sizeof (sock_addr)))

    {

      fprintf (stderr, "ERROR: Cannot bind to RSP socket\n");

      sim_done ();

    }

  /* Listen for (at most one) client */

  if (listen (tmp_fd, 1))

    {

      fprintf (stderr, "ERROR: Cannot listen on RSP socket\n");

      sim_done ();

    }

  printf ("Listening for RSP on port %d\n", config.debug.rsp_port);

  fflush (stdout);

  /* Accept a client which connects */

  rsp.client_fd = accept (tmp_fd, (struct sockaddr *)&sock_addr, &len);

  if (-1 == rsp.client_fd)

    {

      fprintf (stderr, "Warning: Failed to accept RSP client\n");

      return;

    }

  /* Enable TCP keep alive process */

  optval = 1;

  setsockopt (rsp.client_fd, SOL_SOCKET, SO_KEEPALIVE, (char *)&optval,

              sizeof (optval));

  /* Don't delay small packets, for better interactive response (disable

     Nagel's algorithm) */

  optval = 1;

  setsockopt (rsp.client_fd, IPPROTO_TCP, TCP_NODELAY, (char *)&optval,

              sizeof (optval));

  /* Socket is no longer needed */

  close (tmp_fd);                       /* No longer need this */

  signal (SIGPIPE, SIG_IGN);            /* So we don't exit if client dies */

  printf ("Remote debugging from host %s\n", inet_ntoa (sock_addr.sin_addr));

  /* If fcntl () is available, use it to enable async I/O

#if defined(F_SETFL) && defined (FASYNC)

  save_fcntl_flags = fcntl (remote_desc, F_GETFL, 0);

  fcntl (remote_desc, F_SETFL, save_fcntl_flags | FASYNC);

#if defined (F_SETOWN)

  fcntl (remote_desc, F_SETOWN, getpid ());

#endif

#endif */

}       /* rsp_get_client () */

/*---------------------------------------------------------------------------*/

/*!Deal with a request from the GDB client session

   In general, apart from the simplest requests, this function replies on

   other functions to implement the functionality.                           */

/*---------------------------------------------------------------------------*/

static void

rsp_client_request ()

{

  struct rsp_buf *buf = get_packet ();  /* Message sent to us */

  // Null packet means we hit EOF or the link was closed for some other

  // reason. Close the client and return

  if (NULL == buf)

    {

      rsp_client_close ();

      return;

    }

#if RSP_TRACE

  printf ("Packet received %s: %d chars\n", buf->data, buf->len );

  fflush (stdout);

#endif

  switch (buf->data[0])

    {

    case '!':

      /* Request for extended remote mode */

      put_str_packet ("OK");

      return;

    case '?':

      /* Return last signal ID */

      rsp_report_exception();

      return;

    case 'A':

      /* Initialization of argv not supported */

      fprintf (stderr, "Warning: RSP 'A' packet not supported: ignored\n");

      put_str_packet ("E01");

      return;

    case 'b':

      /* Setting baud rate is deprecated */

      fprintf (stderr, "Warning: RSP 'b' packet is deprecated and not "

               "supported: ignored\n");

      return;

    case 'B':

      /* Breakpoints should be set using Z packets */

      fprintf (stderr, "Warning: RSP 'B' packet is deprecated (use 'Z'/'z' "

               "packets instead): ignored\n");

      return;

    case 'c':

      /* Continue */

      rsp_continue (buf);

      return;

    case 'C':

      /* Continue with signal */

      rsp_continue_with_signal (buf);

      return;

    case 'd':

      /* Disable debug using a general query */

      fprintf (stderr, "Warning: RSP 'd' packet is deprecated (define a 'Q' "

               "packet instead: ignored\n");

      return;

    case 'D':

      /* Detach GDB. Do this by closing the client. The rules say that

         execution should continue. TODO. Is this really then intended

         meaning? Or does it just mean that only vAttach will be recognized

         after this? */

      put_str_packet ("OK");

      rsp_client_close ();

      set_stall_state (0);

      rsp.sigval = TARGET_SIGNAL_NONE;  /* No signal now */

      return;

    case 'F':

      /* File I/O is not currently supported */

      fprintf (stderr, "Warning: RSP file I/O not currently supported: 'F' "

               "packet ignored\n");

      return;

    case 'g':

      rsp_read_all_regs ();

      return;

    case 'G':

      rsp_write_all_regs (buf);

      return;

    case 'H':

      /* Set the thread number of subsequent operations. For now ignore

         silently and just reply "OK" */

      put_str_packet ("OK");

      return;

    case 'i':

      /* Single instruction step */

      fprintf (stderr, "Warning: RSP cycle stepping not supported: target "

               "stopped immediately\n");

      rsp.client_waiting = 1;                   /* Stop reply will be sent */

      return;

    case 'I':

      /* Single instruction step with signal */

      fprintf (stderr, "Warning: RSP cycle stepping not supported: target "

               "stopped immediately\n");

      rsp.client_waiting = 1;                   /* Stop reply will be sent */

      return;

    case 'k':

      /* Kill request. Do nothing for now. */

      return;

    case 'm':

      /* Read memory (symbolic) */

      rsp_read_mem (buf);

      return;

    case 'M':

      /* Write memory (symbolic) */

      rsp_write_mem (buf);

      return;

    case 'p':

      /* Read a register */

      rsp_read_reg (buf);

      return;

    case 'P':

      /* Write a register */

      rsp_write_reg (buf);

      return;

    case 'q':

      /* Any one of a number of query packets */

      rsp_query (buf);

      return;

    case 'Q':

      /* Any one of a number of set packets */

      rsp_set (buf);

      return;

    case 'r':

      /* Reset the system. Deprecated (use 'R' instead) */

      fprintf (stderr, "Warning: RSP 'r' packet is deprecated (use 'R' "

               "packet instead): ignored\n");

      return;

    case 'R':

      /* Restart the program being debugged. */

      rsp_restart ();

      return;

    case 's':

      /* Single step (one high level instruction). This could be hard without

         DWARF2 info */

      rsp_step (buf);

      return;

    case 'S':

      /* Single step (one high level instruction) with signal. This could be

         hard without DWARF2 info */

      rsp_step_with_signal (buf);

      return;

    case 't':

      /* Search. This is not well defined in the manual and for now we don't

         support it. No response is defined. */

      fprintf (stderr, "Warning: RSP 't' packet not supported: ignored\n");

      return;

    case 'T':

      /* Is the thread alive. We are bare metal, so don't have a thread

         context. The answer is always "OK". */

      put_str_packet ("OK");

      return;

    case 'v':

      /* Any one of a number of packets to control execution */

      rsp_vpkt (buf);

      return;

    case 'X':

      /* Write memory (binary) */

      rsp_write_mem_bin (buf);

      return;

    case 'z':

      /* Remove a breakpoint/watchpoint. */

      rsp_remove_matchpoint (buf);

      return;

    case 'Z':

      /* Insert a breakpoint/watchpoint. */

      rsp_insert_matchpoint (buf);

      return;

    default:

      /* Unknown commands are ignored */

      fprintf (stderr, "Warning: Unknown RSP request %s\n", buf->data);

      return;

    }

}       /* rsp_client_request () */

/*---------------------------------------------------------------------------*/

/*!Close the connection to the client if it is open                          */

/*---------------------------------------------------------------------------*/

static void

rsp_client_close ()

{

  if (-1 != rsp.client_fd)

    {

      close (rsp.client_fd);

      rsp.client_fd = -1;

    }

}       /* rsp_client_close () */

/*---------------------------------------------------------------------------*/

/*!Send a packet to the GDB client

   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.

   @param[in] buf  The data to send                                          */

/*---------------------------------------------------------------------------*/

static void

put_packet (struct rsp_buf *buf)

{

  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 RSP_TRACE

      printf ("Putting %s\n", buf->data);

      fflush (stdout);

#endif

      put_rsp_char ('$');               /* Start char */

      /* Body of the packet */

      for (count = 0; count < buf->len; count++)

        {

          unsigned char  ch = buf->data[count];

          /* Check for escaped chars */

          if (('$' == ch) || ('#' == ch) || ('*' == ch) || ('}' == ch))

            {

              ch       ^= 0x20;

              checksum += (unsigned char)'}';

              put_rsp_char ('}');

            }

          checksum += ch;

          put_rsp_char (ch);

        }

      put_rsp_char ('#');               /* End char */

      /* Computed checksum */

      put_rsp_char (hexchars[checksum >> 4]);

      put_rsp_char (hexchars[checksum % 16]);

      /* Check for ack of connection failure */

      ch = get_rsp_char ();