URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc3/] [or1ksim/] [debug/] [gdbcomm.c] - Blame information for rev 1748

Go to most recent revision | Details | Compare with Previous | View Log


/* gdbcomm.c -- Communication routines for gdb
 
   Copyright (C) 2001 by Marko Mlinar, markom@opencores.org
   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 <stdio.h>
#include <sys/poll.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/tcp.h>
#include <errno.h>
 
/* Package includes */
#include "sim-config.h"
#include "gdb.h"
#include "gdbcomm.h"
#include "debug-unit.h"
#include "vapi.h"
 
 
/* Forward declaration of static functions */
static void  jtag_request ();
static void  gdb_request (void);
static void  protocol_clean (int, int32_t);
static int   get_server_socket (const char *name, const char *proto, int port);
static int   gdb_read (void *buf, int len);
static int   gdb_write (const void *buf, int len);
 
/* Data structures for this file */
static unsigned int  server_ip   = 0;
static unsigned int  server_port = 0;
static unsigned int  server_fd   = 0;
static unsigned int  gdb_fd      = 0;
static int           tcp_level   = 0;
 
/* Added by CZ 24/05/01 */
static int
get_server_socket (const char *name, const char *proto, int port)
{
  struct servent *service;
  struct protoent *protocol;
  struct sockaddr_in sa;
  struct hostent *hp;
  int sockfd;
  char myname[256];
  int flags;
  char sTemp[256];
  socklen_t len;
 
  /* First, get the protocol number of TCP */
  if (!(protocol = getprotobyname (proto)))
    {
      sprintf (sTemp, "Unable to load protocol \"%s\"", proto);
      perror (sTemp);
      return 0;
    }
  tcp_level = protocol->p_proto;        /* Save for later */
 
  /* If we weren't passed a non standard port, get the port
     from the services directory. */
  if (!port)
    {
      if ((service = getservbyname (name, protocol->p_name)))
        port = ntohs (service->s_port);
    }
 
  /* Create the socket using the TCP protocol */
  if ((sockfd = socket (PF_INET, SOCK_STREAM, protocol->p_proto)) < 0)
    {
      perror ("Unable to create socket");
      return 0;
    }
 
  flags = 1;
  if (setsockopt
      (sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *) &flags,
       sizeof (int)) < 0)
    {
      sprintf (sTemp, "Can not set SO_REUSEADDR option on socket %d", sockfd);
      perror (sTemp);
      close (sockfd);
      return 0;
    }
 
  /* The server should also be non blocking. Get the current flags. */
  if (fcntl (sockfd, F_GETFL, &flags) < 0)
    {
      sprintf (sTemp, "Unable to get flags for socket %d", sockfd);
      perror (sTemp);
      close (sockfd);
      return 0;
    }
 
  /* Set the nonblocking flag */
  if (fcntl (sockfd, F_SETFL, flags | O_NONBLOCK) < 0)
    {
      sprintf (sTemp, "Unable to set flags for socket %d to value 0x%08x",
               sockfd, flags | O_NONBLOCK);
      perror (sTemp);
      close (sockfd);
      return 0;
    }
 
  /* Find out what our address is */
  memset (&sa, 0, sizeof (struct sockaddr_in));
  gethostname (myname, sizeof (myname));
  if (!(hp = gethostbyname (myname)))
    {
      perror ("Unable to read hostname");
      close (sockfd);
      return 0;
    }
 
  /* Bind our socket to the appropriate address */
  sa.sin_family = hp->h_addrtype;
  sa.sin_port = htons (port);
  if (bind (sockfd, (struct sockaddr *) &sa, sizeof (struct sockaddr_in)) < 0)
    {
      sprintf (sTemp, "Unable to bind socket %d to port %d", sockfd, port);
      perror (sTemp);
      close (sockfd);
      return 0;
    }
  server_ip = sa.sin_addr.s_addr;
  len = sizeof (struct sockaddr_in);
  if (getsockname (sockfd, (struct sockaddr *) &sa, &len) < 0)
    {
      sprintf (sTemp, "Unable to get socket information for socket %d",
               sockfd);
      perror (sTemp);
      close (sockfd);
      return 0;
    }
  server_port = ntohs (sa.sin_port);
 
  /* Set the backlog to 1 connections */
  if (listen (sockfd, 1) < 0)
    {
      sprintf (sTemp, "Unable to set backlog on socket %d to %d", sockfd, 1);
      perror (sTemp);
      close (sockfd);
      return 0;
    }
 
  return sockfd;
}
 
void
block_jtag ()
{
  struct pollfd fds[2];
  int n = 0;
 
  fds[n].fd = server_fd;
  fds[n].events = POLLIN;
  fds[n++].revents = 0;
  if (gdb_fd)
    {
      fds[n].fd = gdb_fd;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
  poll (fds, n, -1);
}
 
void
handle_server_socket (enum boolean block)
{
  struct pollfd fds[3];
  int n = 0;
  int timeout = block ? -1 : 0;
  enum boolean data_on_stdin = FALSE;
  int o_serv_fd = server_fd;
 
  if (!o_serv_fd && !gdb_fd)
    return;
 
  if (o_serv_fd)
    {
      fds[n].fd = o_serv_fd;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
  if (gdb_fd)
    {
      fds[n].fd = gdb_fd;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
  if (block)
    {
      fds[n].fd = 0;
      fds[n].events = POLLIN;
      fds[n++].revents = 0;
    }
 
  while (!data_on_stdin)
    {
      fds[0].revents = 0;
      fds[1].revents = 0;
      fds[2].revents = 0;
      switch (poll (fds, n, timeout))
        {
        case -1:
          if (errno == EINTR)
            continue;
          perror ("poll");
          server_fd = 0;
          break;
        case 0:          /* Nothing interesting going on */
          data_on_stdin = TRUE; /* Can only get here if nonblocking */
          break;
        default:
          /* Make sure to handle the gdb port first! */
          if ((fds[0].revents && gdb_fd && !o_serv_fd) ||
              (fds[1].revents && server_fd && gdb_fd))
            {
              int revents = o_serv_fd ? fds[1].revents : fds[0].revents;
 
              if (revents & POLLIN)
                gdb_request ();
              else              /* Error Occurred */
                {
                  fprintf (stderr,
                           "Received flags 0x%08x on gdb socket. Shutting down.\n",
                           revents);
                  close (gdb_fd);
                  gdb_fd = 0;
                }
            }
          if (fds[0].revents && o_serv_fd)
            {
              if (fds[0].revents & POLLIN)
                jtag_request ();
              else              /* Error Occurred */
                {
                  fprintf (stderr,
                           "Received flags 0x%08x on server. Shutting down.\n",
                           fds[0].revents);
                  close (o_serv_fd);
                  server_fd = 0;
                  server_port = 0;
                  server_ip = 0;
                }
            }
          if (fds[2].revents || (fds[1].revents && !gdb_fd))
            data_on_stdin = TRUE;
          break;
        }                       /* End of switch statement */
    }                           /* End of while statement */
}
 
static void
jtag_request (void)
{
  struct sockaddr_in sa;
  struct sockaddr *addr = (struct sockaddr *) &sa;
  socklen_t len = sizeof (struct sockaddr_in);
  int fd = accept (server_fd, addr, &len);
  int on_off = 0;                /* Turn off Nagel's algorithm on the socket */
  int flags;
  char sTemp[256];
 
  if (fd < 0)
    {
      /* This is valid, because a connection could have started,
         and then terminated due to a protocol error or user
         initiation before the accept could take place. */
      if (errno != EWOULDBLOCK && errno != EAGAIN)
        {
          perror ("accept");
          close (server_fd);
          server_fd = 0;
          server_port = 0;
          server_ip = 0;
        }
      return;
    }
 
  if (gdb_fd)
    {
      close (fd);
      return;
    }
 
  if ((flags = fcntl (fd, F_GETFL)) < 0) /* JPB */
    {
      sprintf (sTemp, "Unable to get flags for gdb socket %d", fd);
      perror (sTemp);
      close (fd);
      return;
    }
 
  if (fcntl (fd, F_SETFL, flags | O_NONBLOCK) < 0)
    {
      sprintf (sTemp, "Unable to set flags for gdb socket %d to value 0x%08x",
               fd, flags | O_NONBLOCK);
      perror (sTemp);
      close (fd);
      return;
    }
 
  if (setsockopt (fd, tcp_level, TCP_NODELAY, &on_off, sizeof (int)) < 0)
    {
      sprintf (sTemp,
               "Unable to disable Nagel's algorithm for socket %d.\nsetsockopt",
               fd);
      perror (sTemp);
      close (fd);
      return;
    }
 
  gdb_fd = fd;
}
 
static void
gdb_request (void)
{
  struct jtr_read_message          msg_read;
  struct jtr_write_message         msg_write;
  struct jtr_read_block_message    msg_bread;
  struct jtr_write_block_message  *msg_bwrite;
  struct jtr_chain_message         msg_chain;
  struct jtr_read_response         resp_read;
  struct jtr_write_response        resp_write;
  struct jtr_read_block_response  *resp_bread;
  struct jtr_write_block_response  resp_bwrite;
  struct jtr_chain_response        resp_chain;
 
  char *buf;
  int err = 0;
  uint32_t command, length;
  int len, i;
 
  /* First, we must read the incomming command */
  if (gdb_read (&command, sizeof (uint32_t)) < 0)
    {
      if (gdb_fd)
        {
          perror ("gdb socket - 1");
          close (gdb_fd);
          gdb_fd = 0;
        }
      return;
    }
  if (gdb_read (&length, sizeof (uint32_t)) < 0)
    {
      if (gdb_fd)
        {
          perror ("gdb socket - 2");
          close (gdb_fd);
          gdb_fd = 0;
        }
      return;
    }
  length = ntohl (length);
 
  /* Now, verify the protocol and implement the command */
  switch (ntohl (command))
    {
    case OR1K_JTAG_COMMAND_WRITE:
      if (length != sizeof (msg_write) - 8)
        {
          protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char *) &msg_write;
      if (gdb_read (&buf[8], length) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 3");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_write.address = ntohl (msg_write.address);
      msg_write.data_h = ntohl (msg_write.data_h);
      msg_write.data_l = ntohl (msg_write.data_l);
      err = debug_set_register (msg_write.address, msg_write.data_l);
      resp_write.status = htonl (err);
      if (gdb_write (&resp_write, sizeof (resp_write)) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 4");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    case OR1K_JTAG_COMMAND_READ:
      if (length != sizeof (msg_read) - 8)
        {
          protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char *) &msg_read;
      if (gdb_read (&buf[8], length) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 5");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_read.address = ntohl (msg_read.address);
      err = debug_get_register (msg_read.address, &resp_read.data_l);
      resp_read.status = htonl (err);
      resp_read.data_h = 0;
      resp_read.data_l = htonl (resp_read.data_l);
      if (gdb_write (&resp_read, sizeof (resp_read)) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 6");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    case OR1K_JTAG_COMMAND_WRITE_BLOCK:
      if (length < sizeof (struct jtr_write_block_message) - 8)
        {
          protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      if (!(buf = (char *) malloc (8 + length)))
        {
          protocol_clean (length, JTAG_PROXY_OUT_OF_MEMORY);
          return;
        }
      msg_bwrite = (struct jtr_write_block_message *) buf;
      if (gdb_read (&buf[8], length) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 5");
              close (gdb_fd);
              gdb_fd = 0;
            }
          free (buf);
          return;
        }
      msg_bwrite->address = ntohl (msg_bwrite->address);
      msg_bwrite->num_regs = ntohl (msg_bwrite->num_regs);
      for (i = 0; i < msg_bwrite->num_regs; i++)
        {
          int t_err = 0;
 
          msg_bwrite->data[i] = ntohl (msg_bwrite->data[i]);
          t_err =
            debug_set_register (msg_bwrite->address + 4 * i,
                                msg_bwrite->data[i]);
          err = err ? err : t_err;
        }
      resp_bwrite.status = htonl (err);
      free (buf);
      buf = NULL;
      msg_bwrite = NULL;
      if (gdb_write (&resp_bwrite, sizeof (resp_bwrite)) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 4");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    case OR1K_JTAG_COMMAND_READ_BLOCK:
      if (length != sizeof (msg_bread) - 8)
        {
          protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char *) &msg_bread;
      if (gdb_read (&buf[8], length) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 5");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_bread.address = ntohl (msg_bread.address);
      msg_bread.num_regs = ntohl (msg_bread.num_regs);
      len =
        sizeof (struct jtr_read_block_response) + 4 * (msg_bread.num_regs - 1);
      if (!(buf = (char *) malloc (len)))
        {
          protocol_clean (0, JTAG_PROXY_OUT_OF_MEMORY);
          return;
        }
      resp_bread = (struct jtr_read_block_response *) buf;
      for (i = 0; i < msg_bread.num_regs; i++)
        {
          int t_err;
 
          t_err =
            debug_get_register (msg_bread.address + 4 * i,
                                &resp_bread->data[i]);
          resp_bread->data[i] = htonl (resp_bread->data[i]);
          err = err ? err : t_err;
        }
      resp_bread->status = htonl (err);
      resp_bread->num_regs = htonl (msg_bread.num_regs);
      if (gdb_write (resp_bread, len) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 6");
              close (gdb_fd);
              gdb_fd = 0;
            }
          free (buf);
          return;
        }
      free (buf);
      buf = NULL;
      resp_bread = NULL;
      break;
    case OR1K_JTAG_COMMAND_CHAIN:
      if (length != sizeof (msg_chain) - 8)
        {
          protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);
          return;
        }
      buf = (char *) &msg_chain;
      if (gdb_read (&buf[8], sizeof (msg_chain) - 8) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 7");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      msg_chain.chain = htonl (msg_chain.chain);
      err = debug_set_chain (msg_chain.chain);
      resp_chain.status = htonl (err);
      if (gdb_write (&resp_chain, sizeof (resp_chain)) < 0)
        {
          if (gdb_fd)
            {
              perror ("gdb socket - 8");
              close (gdb_fd);
              gdb_fd = 0;
            }
          return;
        }
      break;
    default:
      protocol_clean (length, JTAG_PROXY_COMMAND_NOT_IMPLEMENTED);
      break;
    }
}
 
static void
protocol_clean (int length, int32_t err)
{
  char buf[4096];
 
  err = htonl (err);
  if ((gdb_read (buf, length) < 0) ||
      ((gdb_write (&err, sizeof (err)) < 0) && gdb_fd))
    {
      perror ("gdb socket - 9");
      close (gdb_fd);
      gdb_fd = 0;
    }
}
 
static int
gdb_write (const void *buf, int len)
{
  int n, log_n = 0;
  const char *w_buf = (const char *) buf;
  const uint32_t *log_buf = (const uint32_t *) buf;
  struct pollfd block;
 
  while (len)
    {
      if ((n = write (gdb_fd, w_buf, len)) < 0)
        {
          switch (errno)
            {
            case EWOULDBLOCK:   /* or EAGAIN */
              /* We've been called on a descriptor marked
                 for nonblocking I/O. We better simulate
                 blocking behavior. */
              block.fd = gdb_fd;
              block.events = POLLOUT;
              block.revents = 0;
              poll (&block, 1, -1);
              continue;
            case EINTR:
              continue;
            case EPIPE:
              close (gdb_fd);
              gdb_fd = 0;
              return -1;
            default:
              return -1;
            }
        }
      else
        {
          len -= n;
          w_buf += n;
          if (config.debug.vapi_id)
            for (log_n += n; log_n >= 4; log_n -= 4, ++log_buf)
              vapi_write_log_file (VAPI_COMMAND_SEND, config.debug.vapi_id,
                                   ntohl (*log_buf));
        }
    }
  return 0;
}
 
static int
gdb_read (void *buf, int len)
{
  int n, log_n = 0;
  char *r_buf = (char *) buf;
  uint32_t *log_buf = (uint32_t *) buf;
  struct pollfd block;
 
  while (len)
    {
      if ((n = read (gdb_fd, r_buf, len)) < 0)
        {
          switch (errno)
            {
            case EWOULDBLOCK:   /* or EAGAIN */
              /* We've been called on a descriptor marked
                 for nonblocking I/O. We better simulate
                 blocking behavior. */
              block.fd = gdb_fd;
              block.events = POLLIN;
              block.revents = 0;
              poll (&block, 1, -1);
              continue;
            case EINTR:
              continue;
            default:
              return -1;
            }
        }
      else if (n == 0)
        {
          close (gdb_fd);
          gdb_fd = 0;
          return -1;
        }
      else
        {
          len -= n;
          r_buf += n;
          if (config.debug.vapi_id)
            for (log_n += n; log_n >= 4; log_n -= 4, ++log_buf)
              vapi_write_log_file (VAPI_COMMAND_REQUEST, config.debug.vapi_id,
                                   ntohl (*log_buf));
        }
    }
  return 0;
}
 
void
gdbcomm_init ()
{
  server_port = config.debug.server_port;
  if ((server_fd = get_server_socket ("or1ksim", "tcp", server_port)))
    PRINTF ("JTAG Proxy server started on port %d\n", server_port);
  else
    PRINTF ("Cannot start JTAG proxy server on port %d\n", server_port);
}

Line No.	Rev	Author	Line
1	321	markom	`/* gdbcomm.c -- Communication routines for gdb`
2
3	1744	jeremybenn	`Copyright (C) 2001 by Marko Mlinar, markom@opencores.org`
4			`Copyright (C) 2008 Embecosm Limited`
5	1748	jeremybenn
6	1744	jeremybenn	`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
7	1748	jeremybenn
8			`This file is part of Or1ksim, the OpenRISC 1000 Architectural Simulator.`
9
10	1744	jeremybenn	`This program is free software; you can redistribute it and/or modify it`
11			`under the terms of the GNU General Public License as published by the Free`
12			`Software Foundation; either version 3 of the License, or (at your option)`
13			`any later version.`
14	1748	jeremybenn
15	1744	jeremybenn	`This program is distributed in the hope that it will be useful, but WITHOUT`
16			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
17			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for`
18			`more details.`
19	1748	jeremybenn
20	1744	jeremybenn	`You should have received a copy of the GNU General Public License along`
21	1748	jeremybenn	`with this program. If not, see <http://www.gnu.org/licenses/>. */`
22	321	markom
23	1748	jeremybenn	`/* This program is commented throughout in a fashion suitable for processing`
24			`with Doxygen. */`
25	321	markom
26	1744	jeremybenn
27	1748	jeremybenn	`/* Autoconf and/or portability configuration */`
28			`#include "config.h"`
29			`#include "port.h"`
30
31			`/* System includes */`
32	321	markom	`#include <stdlib.h>`
33	1748	jeremybenn	`#include <unistd.h>`
34	321	markom	`#include <stdio.h>`
35			`#include <sys/poll.h>`
36			`#include <fcntl.h>`
37			`#include <netdb.h>`
38			`#include <netinet/tcp.h>`
39	1748	jeremybenn	`#include <errno.h>`
40	321	markom
41	1748	jeremybenn	`/* Package includes */`
42			`#include "sim-config.h"`
43	321	markom	`#include "gdb.h"`
44			`#include "gdbcomm.h"`
45	1748	jeremybenn	`#include "debug-unit.h"`
46	439	erez	`#include "vapi.h"`
47	321	markom
48	1308	phoenix
49	1748	jeremybenn	`/* Forward declaration of static functions */`
50			`static void jtag_request ();`
51			`static void gdb_request (void);`
52			`static void protocol_clean (int, int32_t);`
53			`static int get_server_socket (const char name, const char proto, int port);`
54			`static int gdb_read (void *buf, int len);`
55			`static int gdb_write (const void *buf, int len);`
56	321	markom
57	1748	jeremybenn	`/* Data structures for this file */`
58			`static unsigned int server_ip = 0;`
59			`static unsigned int server_port = 0;`
60			`static unsigned int server_fd = 0;`
61			`static unsigned int gdb_fd = 0;`
62			`static int tcp_level = 0;`
63	321	markom
64			`/* Added by CZ 24/05/01 */`
65	1748	jeremybenn	`static int`
66			`get_server_socket (const char name, const char proto, int port)`
67	321	markom	`{`
68			`struct servent *service;`
69			`struct protoent *protocol;`
70			`struct sockaddr_in sa;`
71	1748	jeremybenn	`struct hostent *hp;`
72	321	markom	`int sockfd;`
73			`char myname[256];`
74			`int flags;`
75			`char sTemp[256];`
76	1557	nogj	`socklen_t len;`
77	321	markom
78			`/* First, get the protocol number of TCP */`
79	1748	jeremybenn	`if (!(protocol = getprotobyname (proto)))`
80	321	markom	`{`
81	1748	jeremybenn	`sprintf (sTemp, "Unable to load protocol \"%s\"", proto);`
82			`perror (sTemp);`
83	321	markom	`return 0;`
84			`}`
85	1748	jeremybenn	`tcp_level = protocol->p_proto; /* Save for later */`
86	321	markom
87			`/* If we weren't passed a non standard port, get the port`
88			`from the services directory. */`
89	1748	jeremybenn	`if (!port)`
90	321	markom	`{`
91	1748	jeremybenn	`if ((service = getservbyname (name, protocol->p_name)))`
92			`port = ntohs (service->s_port);`
93	321	markom	`}`
94	1748	jeremybenn
95	321	markom	`/* Create the socket using the TCP protocol */`
96	1748	jeremybenn	`if ((sockfd = socket (PF_INET, SOCK_STREAM, protocol->p_proto)) < 0)`
97	321	markom	`{`
98	1748	jeremybenn	`perror ("Unable to create socket");`
99	321	markom	`return 0;`
100			`}`
101	1748	jeremybenn
102	321	markom	`flags = 1;`
103	1748	jeremybenn	`if (setsockopt`
104			`(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char *) &flags,`
105			`sizeof (int)) < 0)`
106	321	markom	`{`
107	1748	jeremybenn	`sprintf (sTemp, "Can not set SO_REUSEADDR option on socket %d", sockfd);`
108			`perror (sTemp);`
109			`close (sockfd);`
110	321	markom	`return 0;`
111			`}`
112
113			`/* The server should also be non blocking. Get the current flags. */`
114	1748	jeremybenn	`if (fcntl (sockfd, F_GETFL, &flags) < 0)`
115	321	markom	`{`
116	1748	jeremybenn	`sprintf (sTemp, "Unable to get flags for socket %d", sockfd);`
117			`perror (sTemp);`
118			`close (sockfd);`
119	321	markom	`return 0;`
120			`}`
121
122			`/* Set the nonblocking flag */`
123	1748	jeremybenn	`if (fcntl (sockfd, F_SETFL, flags \| O_NONBLOCK) < 0)`
124	321	markom	`{`
125	1748	jeremybenn	`sprintf (sTemp, "Unable to set flags for socket %d to value 0x%08x",`
126			`sockfd, flags \| O_NONBLOCK);`
127			`perror (sTemp);`
128			`close (sockfd);`
129	321	markom	`return 0;`
130			`}`
131
132			`/* Find out what our address is */`
133	1748	jeremybenn	`memset (&sa, 0, sizeof (struct sockaddr_in));`
134			`gethostname (myname, sizeof (myname));`
135			`if (!(hp = gethostbyname (myname)))`
136	321	markom	`{`
137	1748	jeremybenn	`perror ("Unable to read hostname");`
138			`close (sockfd);`
139	321	markom	`return 0;`
140			`}`
141	1748	jeremybenn
142	321	markom	`/* Bind our socket to the appropriate address */`
143			`sa.sin_family = hp->h_addrtype;`
144	1748	jeremybenn	`sa.sin_port = htons (port);`
145			`if (bind (sockfd, (struct sockaddr *) &sa, sizeof (struct sockaddr_in)) < 0)`
146	321	markom	`{`
147	1748	jeremybenn	`sprintf (sTemp, "Unable to bind socket %d to port %d", sockfd, port);`
148			`perror (sTemp);`
149			`close (sockfd);`
150	321	markom	`return 0;`
151			`}`
152	1748	jeremybenn	`server_ip = sa.sin_addr.s_addr;`
153			`len = sizeof (struct sockaddr_in);`
154			`if (getsockname (sockfd, (struct sockaddr *) &sa, &len) < 0)`
155	321	markom	`{`
156	1748	jeremybenn	`sprintf (sTemp, "Unable to get socket information for socket %d",`
157			`sockfd);`
158			`perror (sTemp);`
159			`close (sockfd);`
160	321	markom	`return 0;`
161			`}`
162	1748	jeremybenn	`server_port = ntohs (sa.sin_port);`
163	321	markom
164			`/* Set the backlog to 1 connections */`
165	1748	jeremybenn	`if (listen (sockfd, 1) < 0)`
166	321	markom	`{`
167	1748	jeremybenn	`sprintf (sTemp, "Unable to set backlog on socket %d to %d", sockfd, 1);`
168			`perror (sTemp);`
169			`close (sockfd);`
170	321	markom	`return 0;`
171			`}`
172
173			`return sockfd;`
174			`}`
175
176	1748	jeremybenn	`void`
177			`block_jtag ()`
178	321	markom	`{`
179			`struct pollfd fds[2];`
180			`int n = 0;`
181
182			`fds[n].fd = server_fd;`
183			`fds[n].events = POLLIN;`
184			`fds[n++].revents = 0;`
185	1748	jeremybenn	`if (gdb_fd)`
186	321	markom	`{`
187			`fds[n].fd = gdb_fd;`
188			`fds[n].events = POLLIN;`
189			`fds[n++].revents = 0;`
190			`}`
191	1748	jeremybenn	`poll (fds, n, -1);`
192	321	markom	`}`
193
194	1748	jeremybenn	`void`
195			`handle_server_socket (enum boolean block)`
196	321	markom	`{`
197			`struct pollfd fds[3];`
198			`int n = 0;`
199			`int timeout = block ? -1 : 0;`
200	1748	jeremybenn	`enum boolean data_on_stdin = FALSE;`
201	321	markom	`int o_serv_fd = server_fd;`
202	1748	jeremybenn
203			`if (!o_serv_fd && !gdb_fd)`
204	321	markom	`return;`
205
206	1748	jeremybenn	`if (o_serv_fd)`
207	321	markom	`{`
208			`fds[n].fd = o_serv_fd;`
209			`fds[n].events = POLLIN;`
210			`fds[n++].revents = 0;`
211			`}`
212	1748	jeremybenn	`if (gdb_fd)`
213	321	markom	`{`
214			`fds[n].fd = gdb_fd;`
215			`fds[n].events = POLLIN;`
216			`fds[n++].revents = 0;`
217			`}`
218	1748	jeremybenn	`if (block)`
219	321	markom	`{`
220			`fds[n].fd = 0;`
221			`fds[n].events = POLLIN;`
222			`fds[n++].revents = 0;`
223			`}`
224
225	1748	jeremybenn	`while (!data_on_stdin)`
226	321	markom	`{`
227	1748	jeremybenn	`fds[0].revents = 0;`
228			`fds[1].revents = 0;`
229			`fds[2].revents = 0;`
230			`switch (poll (fds, n, timeout))`
231			`{`
232			`case -1:`
233			`if (errno == EINTR)`
234			`continue;`
235			`perror ("poll");`
236			`server_fd = 0;`
237			`break;`
238			`case 0: /* Nothing interesting going on */`
239			`data_on_stdin = TRUE; /* Can only get here if nonblocking */`
240			`break;`
241			`default:`
242			`/* Make sure to handle the gdb port first! */`
243			`if ((fds[0].revents && gdb_fd && !o_serv_fd) \|\|`
244			`(fds[1].revents && server_fd && gdb_fd))`
245			`{`
246			`int revents = o_serv_fd ? fds[1].revents : fds[0].revents;`
247	321	markom
248	1748	jeremybenn	`if (revents & POLLIN)`
249			`gdb_request ();`
250			`else /* Error Occurred */`
251			`{`
252			`fprintf (stderr,`
253			`"Received flags 0x%08x on gdb socket. Shutting down.\n",`
254			`revents);`
255			`close (gdb_fd);`
256			`gdb_fd = 0;`
257			`}`
258			`}`
259			`if (fds[0].revents && o_serv_fd)`
260			`{`
261			`if (fds[0].revents & POLLIN)`
262			`jtag_request ();`
263			`else /* Error Occurred */`
264			`{`
265			`fprintf (stderr,`
266			`"Received flags 0x%08x on server. Shutting down.\n",`
267			`fds[0].revents);`
268			`close (o_serv_fd);`
269			`server_fd = 0;`
270			`server_port = 0;`
271			`server_ip = 0;`
272			`}`
273			`}`
274			`if (fds[2].revents \|\| (fds[1].revents && !gdb_fd))`
275			`data_on_stdin = TRUE;`
276			`break;`
277			`} /* End of switch statement */`
278			`} /* End of while statement */`
279	321	markom	`}`
280
281	1748	jeremybenn	`static void`
282			`jtag_request (void)`
283	321	markom	`{`
284			`struct sockaddr_in sa;`
285	1748	jeremybenn	`struct sockaddr addr = (struct sockaddr ) &sa;`
286			`socklen_t len = sizeof (struct sockaddr_in);`
287			`int fd = accept (server_fd, addr, &len);`
288			`int on_off = 0; /* Turn off Nagel's algorithm on the socket */`
289	321	markom	`int flags;`
290			`char sTemp[256];`
291
292	1748	jeremybenn	`if (fd < 0)`
293	321	markom	`{`
294			`/* This is valid, because a connection could have started,`
295	479	markom	`and then terminated due to a protocol error or user`
296			`initiation before the accept could take place. */`
297	1748	jeremybenn	`if (errno != EWOULDBLOCK && errno != EAGAIN)`
298			`{`
299			`perror ("accept");`
300			`close (server_fd);`
301			`server_fd = 0;`
302			`server_port = 0;`
303			`server_ip = 0;`
304			`}`
305	321	markom	`return;`
306			`}`
307
308	1748	jeremybenn	`if (gdb_fd)`
309	321	markom	`{`
310	1748	jeremybenn	`close (fd);`
311	321	markom	`return;`
312			`}`
313
314	1748	jeremybenn	`if ((flags = fcntl (fd, F_GETFL)) < 0) /* JPB */`
315	321	markom	`{`
316	1748	jeremybenn	`sprintf (sTemp, "Unable to get flags for gdb socket %d", fd);`
317			`perror (sTemp);`
318			`close (fd);`
319	321	markom	`return;`
320			`}`
321	1748	jeremybenn
322			`if (fcntl (fd, F_SETFL, flags \| O_NONBLOCK) < 0)`
323	321	markom	`{`
324	1748	jeremybenn	`sprintf (sTemp, "Unable to set flags for gdb socket %d to value 0x%08x",`
325			`fd, flags \| O_NONBLOCK);`
326			`perror (sTemp);`
327			`close (fd);`
328	321	markom	`return;`
329			`}`
330
331	1748	jeremybenn	`if (setsockopt (fd, tcp_level, TCP_NODELAY, &on_off, sizeof (int)) < 0)`
332	321	markom	`{`
333	1748	jeremybenn	`sprintf (sTemp,`
334			`"Unable to disable Nagel's algorithm for socket %d.\nsetsockopt",`
335			`fd);`
336			`perror (sTemp);`
337			`close (fd);`
338	321	markom	`return;`
339			`}`
340
341			`gdb_fd = fd;`
342			`}`
343
344	1748	jeremybenn	`static void`
345			`gdb_request (void)`
346	321	markom	`{`
347	1748	jeremybenn	`struct jtr_read_message msg_read;`
348			`struct jtr_write_message msg_write;`
349			`struct jtr_read_block_message msg_bread;`
350			`struct jtr_write_block_message *msg_bwrite;`
351			`struct jtr_chain_message msg_chain;`
352			`struct jtr_read_response resp_read;`
353			`struct jtr_write_response resp_write;`
354			`struct jtr_read_block_response *resp_bread;`
355			`struct jtr_write_block_response resp_bwrite;`
356			`struct jtr_chain_response resp_chain;`
357
358	321	markom	`char *buf;`
359			`int err = 0;`
360	1748	jeremybenn	`uint32_t command, length;`
361			`int len, i;`
362	321	markom
363			`/* First, we must read the incomming command */`
364	1748	jeremybenn	`if (gdb_read (&command, sizeof (uint32_t)) < 0)`
365	321	markom	`{`
366	1748	jeremybenn	`if (gdb_fd)`
367			`{`
368			`perror ("gdb socket - 1");`
369			`close (gdb_fd);`
370			`gdb_fd = 0;`
371			`}`
372	321	markom	`return;`
373			`}`
374	1748	jeremybenn	`if (gdb_read (&length, sizeof (uint32_t)) < 0)`
375	321	markom	`{`
376	1748	jeremybenn	`if (gdb_fd)`
377			`{`
378			`perror ("gdb socket - 2");`
379			`close (gdb_fd);`
380			`gdb_fd = 0;`
381			`}`
382	321	markom	`return;`
383			`}`
384	1748	jeremybenn	`length = ntohl (length);`
385	321	markom
386			`/* Now, verify the protocol and implement the command */`
387	1748	jeremybenn	`switch (ntohl (command))`
388	321	markom	`{`
389	1748	jeremybenn	`case OR1K_JTAG_COMMAND_WRITE:`
390			`if (length != sizeof (msg_write) - 8)`
391			`{`
392			`protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);`
393			`return;`
394			`}`
395			`buf = (char *) &msg_write;`
396			`if (gdb_read (&buf[8], length) < 0)`
397			`{`
398			`if (gdb_fd)`
399			`{`
400			`perror ("gdb socket - 3");`
401			`close (gdb_fd);`
402			`gdb_fd = 0;`
403			`}`
404			`return;`
405			`}`
406			`msg_write.address = ntohl (msg_write.address);`
407			`msg_write.data_h = ntohl (msg_write.data_h);`
408			`msg_write.data_l = ntohl (msg_write.data_l);`
409			`err = debug_set_register (msg_write.address, msg_write.data_l);`
410			`resp_write.status = htonl (err);`
411			`if (gdb_write (&resp_write, sizeof (resp_write)) < 0)`
412			`{`
413			`if (gdb_fd)`
414			`{`
415			`perror ("gdb socket - 4");`
416			`close (gdb_fd);`
417			`gdb_fd = 0;`
418			`}`
419			`return;`
420			`}`
421	321	markom	`break;`
422	1748	jeremybenn	`case OR1K_JTAG_COMMAND_READ:`
423			`if (length != sizeof (msg_read) - 8)`
424			`{`
425			`protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);`
426			`return;`
427			`}`
428			`buf = (char *) &msg_read;`
429			`if (gdb_read (&buf[8], length) < 0)`
430			`{`
431			`if (gdb_fd)`
432			`{`
433			`perror ("gdb socket - 5");`
434			`close (gdb_fd);`
435			`gdb_fd = 0;`
436			`}`
437			`return;`
438			`}`
439			`msg_read.address = ntohl (msg_read.address);`
440			`err = debug_get_register (msg_read.address, &resp_read.data_l);`
441			`resp_read.status = htonl (err);`
442			`resp_read.data_h = 0;`
443			`resp_read.data_l = htonl (resp_read.data_l);`
444			`if (gdb_write (&resp_read, sizeof (resp_read)) < 0)`
445			`{`
446			`if (gdb_fd)`
447			`{`
448			`perror ("gdb socket - 6");`
449			`close (gdb_fd);`
450			`gdb_fd = 0;`
451			`}`
452			`return;`
453			`}`
454	321	markom	`break;`
455	1748	jeremybenn	`case OR1K_JTAG_COMMAND_WRITE_BLOCK:`
456			`if (length < sizeof (struct jtr_write_block_message) - 8)`
457			`{`
458			`protocol_clean (length, JTAG_PROXY_PROTOCOL_ERROR);`
459			`return;`
460			`}`
461			`if (!(buf = (char *) malloc (8 + length)))`
462			`{`
463			`protocol_clean (length, JTAG_PROXY_OUT_OF_MEMORY);`
464			`return;`
465			`}`
466			`msg_bwrite = (struct jtr_write_block_message *) buf;`
467			`if (gdb_read (&buf[8], length) < 0)`
468			`{`
469			`if (gdb_fd)`
470			`{`
471			`perror ("gdb socket - 5");`
472			`close (gdb_fd);`
473			`gdb_fd = 0;`
474			`}`
475			`free (buf);`
476			`return;`
477			`}`
478			`msg_bwrite->address = ntohl (msg_bwrite->address);`
479			`msg_bwrite->num_regs = ntohl (msg_bwrite->num_regs);`
480			`for (i = 0; i < msg_bwrite->num_regs; i++)`
481			`{`
482			`int t_err = 0;`
483	321	markom
484	1748	jeremybenn	`msg_bwrite->data[i] = ntohl (msg_bwrite->data[i]);`
485			`t_err =`
486			`debug_set_register (msg_bwrite->address + 4 * i,`
487			`msg_bwrite->data[i]);`
488			`err = err ? err : t_err;`
489			`}`
490			`resp_bwrite.status = htonl (err);`
491			`free (buf);`
492	321	markom	`buf = NULL;`
493			`msg_bwrite = NULL;`
494	1748	jeremybenn	`if (gdb_write (&resp_bwrite, sizeof (resp_bwrite)) < 0)`
495			`{`
496			`if (gdb_fd)`
497			`{`
498			`perror ("gdb socket - 4");`
499			`close (gdb_fd);`
500			`gdb_fd = 0;`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [rel-0-3-0-rc3/] [or1ksim/] [debug/] [gdbcomm.c] - Blame information for rev 1748