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

Subversion Repositories or1k

[/] [or1k/] [branches/] [stable_0_2_x/] [or1ksim/] [vapi/] [vapi.c] - Blame information for rev 1646

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


/* vapi.c -- Verification API Interface
   Copyright (C) 2001, Marko Mlinar, markom@opencores.org
 
This file is part of 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 2 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, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
#include "config.h"
 
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdarg.h>
#include <signal.h>
#include <errno.h>
 
/* Added by CZ 24/05/01 */
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/poll.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/tcp.h>
 
#include "config.h"
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
 
#include "port.h"
#include "arch.h"
#include "sim-config.h"
#include "vapi.h"
#include "debug.h"
 
DEFAULT_DEBUG_CHANNEL(vapi);
 
static unsigned int serverIP = 0;
 
static unsigned int server_fd = 0;
static unsigned int nhandlers = 0;
 
static int tcp_level = 0;
 
static struct vapi_handler {
  int fd;
  unsigned long base_id, num_ids;
  void (*read_func)(unsigned long, unsigned long, void *);
  void *priv_dat;
  struct vapi_handler *next;
  int temp;
} *vapi_handler = NULL;
 
/* Structure for polling, it is cached, that it doesn't have to be rebuilt each time */
static struct pollfd *fds = NULL;
static int nfds = 0;
 
/* Rebuilds the fds structures; see fds.  */
void rebuild_fds () {
  struct vapi_handler *t;
  if (fds)
    free (fds);
  fds = (struct pollfd *) malloc (sizeof (struct pollfd) * (nhandlers + 1));
  if (!fds) {
    fprintf (stderr, "FATAL: Out of memory.\n");
    exit (1);
  }
 
  nfds = 0;
  fds[nfds].fd = server_fd;
  fds[nfds].events = POLLIN;
  fds[nfds++].revents = 0;
 
  for (t = vapi_handler; t; t = t->next) {
    if (t->fd) {
      t->temp = nfds;
      fds[nfds].fd = t->fd;
      fds[nfds].events = POLLIN;
      fds[nfds++].revents = 0;
    } else
      t->temp = -1;
  }
}
 
/* Determines whether a certain handler handles an ID */
static inline int handler_fits_id( const struct vapi_handler *t, unsigned long id ) {
  return ((id >= t->base_id) && (id < t->base_id + t->num_ids));
}
 
/* Finds a handler with given ID, return it, NULL if not found.  */
static struct vapi_handler *find_handler (unsigned long id) {
  struct vapi_handler *t = vapi_handler;
  while (t && !handler_fits_id (t, id))
    t = t->next;
  return t;
}
 
/* Adds a handler with given id and returns it.  */
static struct vapi_handler *add_handler (unsigned long base_id, unsigned long num_ids) {
  struct vapi_handler **t = &vapi_handler;
  struct vapi_handler *tt;
  while ((*t))
    t = &(*t)->next;
  tt = (struct vapi_handler *)malloc (sizeof (struct vapi_handler));
  tt->next = NULL;
  tt->base_id = base_id;
  tt->num_ids = num_ids;
  tt->read_func = NULL;
  tt->priv_dat = NULL;
  tt->fd = 0;
  (*t) = tt;
  free (fds);
  fds = NULL;
  nhandlers++;
  rebuild_fds ();
  return tt;
}
 
void vapi_write_log_file(VAPI_COMMAND command, unsigned long devid, unsigned long data)
{
  if (!runtime.vapi.vapi_file)
    return;
  if (!config.vapi.hide_device_id && devid <= VAPI_MAX_DEVID)
    fprintf (runtime.vapi.vapi_file, "%04lx", devid);
  fprintf (runtime.vapi.vapi_file, "%1x%08lx\n", command, data);
}
 
static int vapi_write_stream(int fd, void* buf, int len)
{
  int n;
  char* w_buf = (char*)buf;
  struct pollfd block;
 
  while(len) {
    if((n = write(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 = fd;
        block.events = POLLOUT;
        block.revents = 0;
        poll(&block,1,-1);
        continue;
      case EINTR:
        continue;
      case EPIPE:
        close(fd);
        fd = 0;
        return -1;
      default:
        return -1;
      }
    } else {
      len -= n;
      w_buf += n;
    }
  }
  return 0;
}
 
static int vapi_read_stream(int fd, void* buf, int len)
{
  int n;
  char* r_buf = (char*)buf;
  struct pollfd block;
 
  while(len) {
    if((n = read(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 = fd;
        block.events = POLLIN;
        block.revents = 0;
        poll(&block,1,-1);
        continue;
      case EINTR:
        continue;
      default:
        return -1;
      }
    } else if(n == 0) {
      close(fd);
      fd = 0;
      return -1;
    } else {
      len -= n;
      r_buf += n;
    }
  }
  return 0;
}
 
/* Added by CZ 24/05/01 */
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;
  socklen_t len;
  char myname[256];
  int flags;
  char sTemp[256];
 
  /* 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;
  }
  serverIP = 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;
  }
  runtime.vapi.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;
}
 
static void server_request()
{
  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;
      runtime.vapi.enabled = 0;
      serverIP = 0;
    }
    return;
  }
 
  if(fcntl(fd,F_GETFL,&flags) < 0) {
    sprintf(sTemp,"Unable to get flags for vapi socket %d",fd);
    perror(sTemp);
    close(fd);
    return;
  }
 
  if(fcntl(fd,F_SETFL, flags | O_NONBLOCK) < 0) {
    sprintf(sTemp,"Unable to set flags for vapi 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;
  }
 
  /* Install new handler */
  {
    unsigned long id;
    struct vapi_handler *t;
    if (vapi_read_stream (fd, &id, sizeof (id))) {
      perror ("Cannot get id");
      close (fd);
      return;
    }
    t = find_handler (id);
    if (t) {
      if (t->fd) {
        fprintf (stderr, "WARNING: Test with id %lx already connected. Ignoring.\n", id);
        close (fd);
        return;
      } else {
        t->fd = fd;
        rebuild_fds ();
      }
    } else {
      fprintf (stderr, "WARNING: Test with id %lx not registered. Ignoring.\n", id);
      close(fd); /* kill the connection */
      return;
    }
    if(config.sim.verbose)
      PRINTF ("\nConnection with test (id %lx) established.\n", id);
  }
}
 
static int write_packet (unsigned long id, unsigned long data) {
  struct vapi_handler *t = find_handler (id);
  if (!t || !t->fd)
    return 1;
  id = htonl (id);
  if (vapi_write_stream(t->fd, &id, sizeof (id)) < 0)
    return 1;
  data = htonl (data);
  if (vapi_write_stream(t->fd, &data, sizeof (data)) < 0)
    return 1;
  return 0;
}
 
static int read_packet (int fd, unsigned long *id, unsigned long *data)
{
  if (fd <= 0)
    return 1;
  if (vapi_read_stream(fd, id, sizeof(unsigned long)) < 0)
    return 1;
  *id = ntohl (*id);
  if (vapi_read_stream(fd, data, sizeof(unsigned long)) < 0)
    return 1;
  *data = ntohl (*data);
  return 0;
}
 
static void vapi_request (struct vapi_handler *t)
{
  unsigned long id, data;
 
  if (read_packet(t->fd, &id, &data)) {
    if (t->fd > 0) {
      perror("vapi read");
      close(t->fd);
      t->fd = 0;
      rebuild_fds ();
    }
    return;
  }
 
  vapi_write_log_file (VAPI_COMMAND_REQUEST, id, data);
  TRACE ("[%08lx, %08lx]\n", id, data);
 
  /* This packet may be for another handler */
  if (!handler_fits_id (t, id))
    t = find_handler (id);
  if (!t || !t->read_func)
    fprintf (stderr, "WARNING: Received packet for undefined id %08lx, data %08lx\n", id, data);
  else
    t->read_func(id, data, t->priv_dat);
}
 
void vapi_check ()
{
  struct vapi_handler *t;
 
  if (!server_fd || !fds) {
    fprintf (stderr, "FATAL: Unable to maintain VAPI server.\n");
    exit (1);
  }
 
  TRACE(".");
 
  /* Handle everything in queue. */
  while(1) {
    switch(poll(fds, nfds, 0)) {
    case -1:
      if(errno == EINTR)
        continue;
      perror("poll");
      if (server_fd)
        close(server_fd);
      runtime.vapi.enabled = 0;
      serverIP = 0;
      return;
    case 0: /* Nothing interesting going on */
      return;
    default:
      /* Handle the vapi ports first. */
      for (t = vapi_handler; t; t = t->next)
        if (t->temp >= 0 && fds[t->temp].revents)
          vapi_request (t);
 
      if(fds[0].revents) {
        if(fds[0].revents & POLLIN)
          server_request();
        else { /* Error Occurred */
          fprintf(stderr,"Received flags 0x%08x on server. Shutting down.\n", fds[0].revents);
          if (server_fd)
            close(server_fd);
          server_fd = 0;
          runtime.vapi.enabled = 0;
          serverIP = 0;
        }
      }
      break;
    } /* End of switch statement */
  } /* End of while statement */
}
 
/* Inits the VAPI, according to sim-config */
int vapi_init ()
{
  nhandlers = 0;
  vapi_handler = NULL;
  if (!runtime.vapi.enabled)
    return 0; /* Nothing to do */
 
  runtime.vapi.server_port = config.vapi.server_port;
  if (!runtime.vapi.server_port) {
    fprintf (stderr, "WARNING: server_port = 0, shutting down VAPI\n");
    runtime.vapi.enabled = 0;
    return 1;
  }
  if ((server_fd = get_server_socket("or1ksim", "tcp", runtime.vapi.server_port)))
    PRINTF("VAPI Server started on port %d\n", runtime.vapi.server_port);
  else {
    perror ("Connection");
    return 1;
  }
 
  rebuild_fds ();
 
  if ((runtime.vapi.vapi_file = fopen (config.vapi.vapi_fn, "wt+")) == NULL)
    fprintf (stderr, "WARNING: cannot open VAPI log file\n");
 
  return 0;
}
 
/* Closes the VAPI */
void vapi_done ()
{
  int i;
  struct vapi_handler *t = vapi_handler;
 
  for (i = 0; i < nfds; i++)
    if (fds[i].fd)
      close (fds[i].fd);
  server_fd = 0;
  runtime.vapi.enabled = 0;
  serverIP = 0;
  free (fds);
  fds = 0;
  if (runtime.vapi.vapi_file) {
    /* Mark end of simulation */
    vapi_write_log_file (VAPI_COMMAND_END, 0, 0);
    fclose (runtime.vapi.vapi_file);
  }
 
  while (vapi_handler) {
    t = vapi_handler;
    vapi_handler = vapi_handler->next;
    free (t);
  }
}
 
/* Installs a vapi handler for one VAPI id */
void vapi_install_handler (unsigned long id, void (*read_func) (unsigned long, unsigned long, void *), void *dat)
{
  vapi_install_multi_handler (id, 1, read_func, dat);
}
 
/* Installs a vapi handler for many VAPI id */
void vapi_install_multi_handler (unsigned long base_id, unsigned long num_ids, void (*read_func) (unsigned long, unsigned long, void *), void *dat)
{
  struct vapi_handler *tt;
 
  TRACE("vapi_install_handler %08lx, %lu, %p\n", base_id, num_ids, read_func);
  if (read_func == NULL) {
    struct vapi_handler **t = &vapi_handler;
    while ((*t) && !handler_fits_id (*t, base_id))
      t = &(*t)->next;
    if (!t) {
      fprintf (stderr, "Cannot uninstall VAPI read handler from id %lx\n",
               base_id);
      exit (1);
    }
    tt = *t;
    (*t) = (*t)->next;
    free (tt);
    nhandlers--;
  } else {
    tt = find_handler (base_id);
    if (!tt) {
      tt = add_handler (base_id, num_ids);
      tt->read_func = read_func;
      tt->priv_dat = dat;
    } else {
      tt->read_func = read_func;
      tt->priv_dat = dat;
      rebuild_fds ();
    }
  }
}
 
/* Returns number of unconnected handles.  */
int vapi_num_unconnected (int printout)
{
  struct vapi_handler *t = vapi_handler;
  int numu = 0;
  for (; t; t = t->next) {
    if (!t->fd) {
      numu++;
      if (printout) {
        if ( t->num_ids == 1 )
          PRINTF (" 0x%lx", t->base_id);
        else
          PRINTF (" 0x%lx..0x%lx", t->base_id, t->base_id + t->num_ids - 1);
      }
    }
  }
  return numu;
}
 
/* Sends a packet to specified test */
void vapi_send (unsigned long id, unsigned long data)
{
  TRACE ("vapi_send [%08lx %08lx]\n", id, data);
  vapi_write_log_file (VAPI_COMMAND_SEND, id, data);
  write_packet (id, data);
}
 
/*
int main ()
{
  runtime.vapi.enabled = 1;
  config.vapi.server_port = 9999;
  vapi_init ();
  while (1) {
    vapi_check();
    usleep(1);
  }
  vapi_done ();
}*/
 
/*---------------------------------------------------[ VAPI configuration ]---*/
void vapi_enabled(union param_val val, void *dat)
{
  config.vapi.enabled = val.int_val;
}
 
void vapi_server_port(union param_val val, void *dat)
{
  config.vapi.server_port = val.int_val;
}
 
void vapi_log_enabled(union param_val val, void *dat)
{
  config.vapi.log_enabled = val.int_val;
}
 
void vapi_hide_device_id(union param_val val, void *dat)
{
  config.vapi.hide_device_id = val.int_val;
}
 
void vapi_log_fn(union param_val val, void *dat)
{
  strcpy(config.vapi.vapi_fn, val.str_val);
}
 
void reg_vapi_sec(void)
{
  struct config_section *sec = reg_config_sec("VAPI", NULL, NULL);
 
  reg_config_param(sec, "enabled", paramt_int, vapi_enabled);
  reg_config_param(sec, "server_port", paramt_int, vapi_server_port);
  reg_config_param(sec, "log_enabled", paramt_int, vapi_log_enabled);
  reg_config_param(sec, "hide_device_id", paramt_int, vapi_hide_device_id);
  reg_config_param(sec, "vapi_log_fn", paramt_str, vapi_log_fn);
}

Line No.	Rev	Author	Line
1	293	markom	`/* vapi.c -- Verification API Interface`
2			`Copyright (C) 2001, Marko Mlinar, markom@opencores.org`
3
4			`This file is part of OpenRISC 1000 Architectural Simulator.`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2 of the License, or`
9			`(at your option) any later version.`
10
11			`This program is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
19
20	336	markom	`#include "config.h"`
21	293	markom
22			`#include <stdio.h>`
23			`#include <ctype.h>`
24			`#include <string.h>`
25			`#include <stdlib.h>`
26			`#include <unistd.h>`
27			`#include <stdarg.h>`
28			`#include <signal.h>`
29			`#include <errno.h>`
30
31			`/* Added by CZ 24/05/01 */`
32			`#include <sys/stat.h>`
33			`#include <sys/types.h>`
34			`#include <sys/socket.h>`
35			`#include <netinet/in.h>`
36			`#include <sys/select.h>`
37			`#include <sys/poll.h>`
38			`#include <fcntl.h>`
39			`#include <netdb.h>`
40			`#include <netinet/tcp.h>`
41
42	1358	nogj	`#include "config.h"`
43
44			`#ifdef HAVE_INTTYPES_H`
45			`#include <inttypes.h>`
46			`#endif`
47
48			`#include "port.h"`
49			`#include "arch.h"`
50	336	markom	`#include "sim-config.h"`
51	439	erez	`#include "vapi.h"`
52	1308	phoenix	`#include "debug.h"`
53	293	markom
54	1492	nogj	`DEFAULT_DEBUG_CHANNEL(vapi);`
55
56	304	markom	`static unsigned int serverIP = 0;`
57	293	markom
58	304	markom	`static unsigned int server_fd = 0;`
59			`static unsigned int nhandlers = 0;`
60
61	293	markom	`static int tcp_level = 0;`
62
63	304	markom	`static struct vapi_handler {`
64			`int fd;`
65	477	erez	`unsigned long base_id, num_ids;`
66	1366	nogj	`void (read_func)(unsigned long, unsigned long, void );`
67			`void *priv_dat;`
68	293	markom	`struct vapi_handler *next;`
69	304	markom	`int temp;`
70	442	erez	`} *vapi_handler = NULL;`
71	293	markom
72	304	markom	`/* Structure for polling, it is cached, that it doesn't have to be rebuilt each time */`
73			`static struct pollfd *fds = NULL;`
74			`static int nfds = 0;`
75
76			`/* Rebuilds the fds structures; see fds. */`
77			`void rebuild_fds () {`
78			`struct vapi_handler *t;`
79			`if (fds)`
80			`free (fds);`
81			`fds = (struct pollfd ) malloc (sizeof (struct pollfd) (nhandlers + 1));`
82			`if (!fds) {`
83			`fprintf (stderr, "FATAL: Out of memory.\n");`
84			`exit (1);`
85			`}`
86
87			`nfds = 0;`
88			`fds[nfds].fd = server_fd;`
89			`fds[nfds].events = POLLIN;`
90			`fds[nfds++].revents = 0;`
91
92			`for (t = vapi_handler; t; t = t->next) {`
93			`if (t->fd) {`
94			`t->temp = nfds;`
95			`fds[nfds].fd = t->fd;`
96			`fds[nfds].events = POLLIN;`
97			`fds[nfds++].revents = 0;`
98			`} else`
99			`t->temp = -1;`
100			`}`
101			`}`
102
103	477	erez	`/* Determines whether a certain handler handles an ID */`
104			`static inline int handler_fits_id( const struct vapi_handler *t, unsigned long id ) {`
105			`return ((id >= t->base_id) && (id < t->base_id + t->num_ids));`
106			`}`
107
108	304	markom	`/* Finds a handler with given ID, return it, NULL if not found. */`
109			`static struct vapi_handler *find_handler (unsigned long id) {`
110			`struct vapi_handler *t = vapi_handler;`
111	477	erez	`while (t && !handler_fits_id (t, id))`
112	304	markom	`t = t->next;`
113			`return t;`
114			`}`
115
116			`/* Adds a handler with given id and returns it. */`
117	477	erez	`static struct vapi_handler *add_handler (unsigned long base_id, unsigned long num_ids) {`
118	304	markom	`struct vapi_handler **t = &vapi_handler;`
119			`struct vapi_handler *tt;`
120			`while ((*t))`
121			`t = &(*t)->next;`
122			`tt = (struct vapi_handler *)malloc (sizeof (struct vapi_handler));`
123			`tt->next = NULL;`
124	477	erez	`tt->base_id = base_id;`
125			`tt->num_ids = num_ids;`
126	304	markom	`tt->read_func = NULL;`
127	1366	nogj	`tt->priv_dat = NULL;`
128	304	markom	`tt->fd = 0;`
129			`(*t) = tt;`
130			`free (fds);`
131			`fds = NULL;`
132			`nhandlers++;`
133			`rebuild_fds ();`
134			`return tt;`
135			`}`
136
137	439	erez	`void vapi_write_log_file(VAPI_COMMAND command, unsigned long devid, unsigned long data)`
138	419	erez	`{`
139	439	erez	`if (!runtime.vapi.vapi_file)`
140			`return;`
141	477	erez	`if (!config.vapi.hide_device_id && devid <= VAPI_MAX_DEVID)`
142	1308	phoenix	`fprintf (runtime.vapi.vapi_file, "%04lx", devid);`
143			`fprintf (runtime.vapi.vapi_file, "%1x%08lx\n", command, data);`
144	419	erez	`}`
145
146	304	markom	`static int vapi_write_stream(int fd, void* buf, int len)`
147			`{`
148			`int n;`
149			`char* w_buf = (char*)buf;`
150			`struct pollfd block;`
151
152			`while(len) {`
153			`if((n = write(fd, w_buf, len)) < 0) {`
154			`switch(errno) {`
155			`case EWOULDBLOCK: /* or EAGAIN */`
156			`/* We've been called on a descriptor marked`
157			`for nonblocking I/O. We better simulate`
158			`blocking behavior. */`
159			`block.fd = fd;`
160			`block.events = POLLOUT;`
161			`block.revents = 0;`
162			`poll(&block,1,-1);`
163			`continue;`
164			`case EINTR:`
165			`continue;`
166			`case EPIPE:`
167			`close(fd);`
168			`fd = 0;`
169			`return -1;`
170			`default:`
171			`return -1;`
172			`}`
173			`} else {`
174			`len -= n;`
175			`w_buf += n;`
176			`}`
177			`}`
178			`return 0;`
179			`}`
180
181			`static int vapi_read_stream(int fd, void* buf, int len)`
182			`{`
183			`int n;`
184			`char* r_buf = (char*)buf;`
185			`struct pollfd block;`
186
187			`while(len) {`
188			`if((n = read(fd,r_buf,len)) < 0) {`
189			`switch(errno) {`
190			`case EWOULDBLOCK: /* or EAGAIN */`
191			`/* We've been called on a descriptor marked`
192			`for nonblocking I/O. We better simulate`
193			`blocking behavior. */`
194			`block.fd = fd;`
195			`block.events = POLLIN;`
196			`block.revents = 0;`
197			`poll(&block,1,-1);`
198			`continue;`
199			`case EINTR:`
200			`continue;`
201			`default:`
202			`return -1;`
203			`}`
204			`} else if(n == 0) {`
205			`close(fd);`
206			`fd = 0;`
207			`return -1;`
208			`} else {`
209			`len -= n;`
210			`r_buf += n;`
211			`}`
212			`}`
213			`return 0;`
214			`}`
215
216	293	markom	`/* Added by CZ 24/05/01 */`
217			`int get_server_socket(const char* name,const char* proto,int port)`
218			`{`
219			`struct servent *service;`
220			`struct protoent *protocol;`
221			`struct sockaddr_in sa;`
222			`struct hostent *hp;`
223			`int sockfd;`
224	1557	nogj	`socklen_t len;`
225	293	markom	`char myname[256];`
226			`int flags;`
227			`char sTemp[256];`
228
229			`/* First, get the protocol number of TCP */`
230			`if(!(protocol = getprotobyname(proto))) {`
231			`sprintf(sTemp,"Unable to load protocol \"%s\"",proto);`
232			`perror(sTemp);`
233			`return 0;`
234			`}`
235			`tcp_level = protocol->p_proto; /* Save for later */`
236
237			`/* If we weren't passed a non standard port, get the port`
238			`from the services directory. */`
239			`if(!port) {`
240	1308	phoenix	`if((service = getservbyname(name,protocol->p_name)))`
241	293	markom	`port = ntohs(service->s_port);`
242			`}`
243	336	markom
244	293	markom	`/* Create the socket using the TCP protocol */`
245			`if((sockfd = socket(PF_INET,SOCK_STREAM,protocol->p_proto)) < 0) {`
246			`perror("Unable to create socket");`
247			`return 0;`
248			`}`
249	336	markom
250	293	markom	`flags = 1;`
251			`if(setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,(const char*)&flags,sizeof(int)) < 0) {`
252			`sprintf(sTemp,"Can not set SO_REUSEADDR option on socket %d",sockfd);`
253			`perror(sTemp);`
254			`close(sockfd);`
255			`return 0;`
256			`}`
257
258			`/* The server should also be non blocking. Get the current flags. */`
259			`if(fcntl(sockfd,F_GETFL,&flags) < 0) {`
260			`sprintf(sTemp,"Unable to get flags for socket %d",sockfd);`
261			`perror(sTemp);`
262			`close(sockfd);`
263			`return 0;`
264			`}`
265
266			`/* Set the nonblocking flag */`
267			`if(fcntl(sockfd,F_SETFL, flags \| O_NONBLOCK) < 0) {`
268			`sprintf(sTemp,"Unable to set flags for socket %d to value 0x%08x",`
269			`sockfd,flags \| O_NONBLOCK);`
270			`perror(sTemp);`
271			`close(sockfd);`
272			`return 0;`
273			`}`
274
275			`/* Find out what our address is */`
276			`memset(&sa,0,sizeof(struct sockaddr_in));`
277			`gethostname(myname,sizeof(myname));`
278			`if(!(hp = gethostbyname(myname))) {`
279			`perror("Unable to read hostname");`
280			`close(sockfd);`
281			`return 0;`
282			`}`
283
284			`/* Bind our socket to the appropriate address */`
285			`sa.sin_family = hp->h_addrtype;`
286			`sa.sin_port = htons(port);`
287			`if(bind(sockfd,(struct sockaddr*)&sa,sizeof(struct sockaddr_in)) < 0) {`
288			`sprintf(sTemp,"Unable to bind socket %d to port %d",sockfd,port);`
289			`perror(sTemp);`
290			`close(sockfd);`
291			`return 0;`
292			`}`
293			`serverIP = sa.sin_addr.s_addr;`
294	1557	nogj	`len = sizeof(struct sockaddr_in);`
295			`if(getsockname(sockfd,(struct sockaddr*)&sa,&len) < 0) {`
296	293	markom	`sprintf(sTemp,"Unable to get socket information for socket %d",sockfd);`
297			`perror(sTemp);`
298			`close(sockfd);`
299			`return 0;`
300			`}`
301	551	markom	`runtime.vapi.server_port = ntohs(sa.sin_port);`
302	293	markom
303			`/* Set the backlog to 1 connections */`
304			`if(listen(sockfd,1) < 0) {`
305			`sprintf(sTemp,"Unable to set backlog on socket %d to %d",sockfd,1);`
306			`perror(sTemp);`
307			`close(sockfd);`
308			`return 0;`
309			`}`
310
311			`return sockfd;`
312			`}`
313
314	442	erez	`static void server_request()`
315	293	markom	`{`
316			`struct sockaddr_in sa;`
317			`struct sockaddr* addr = (struct sockaddr*)&sa;`
318	1557	nogj	`socklen_t len = sizeof(struct sockaddr_in);`
319			`int fd = accept(server_fd, addr, &len);`
320	293	markom	`int on_off = 0; /* Turn off Nagel's algorithm on the socket */`
321			`int flags;`
322			`char sTemp[256];`
323
324			`if(fd < 0) {`
325			`/* This is valid, because a connection could have started,`
326			`and then terminated due to a protocol error or user`
327			`initiation before the accept could take place. */`
328			`if(errno != EWOULDBLOCK && errno != EAGAIN) {`
329			`perror("accept");`
330			`close(server_fd);`
331			`server_fd = 0;`
332	551	markom	`runtime.vapi.enabled = 0;`
333	293	markom	`serverIP = 0;`
334	336	markom	`}`
335	293	markom	`return;`
336			`}`
337
338			`if(fcntl(fd,F_GETFL,&flags) < 0) {`
339			`sprintf(sTemp,"Unable to get flags for vapi socket %d",fd);`
340			`perror(sTemp);`
341			`close(fd);`
342			`return;`
343			`}`
344
345			`if(fcntl(fd,F_SETFL, flags \| O_NONBLOCK) < 0) {`
346			`sprintf(sTemp,"Unable to set flags for vapi socket %d to value 0x%08x",`
347			`fd,flags \| O_NONBLOCK);`
348			`perror(sTemp);`
349			`close(fd);`
350			`return;`
351			`}`
352
353			`if(setsockopt(fd,tcp_level,TCP_NODELAY,&on_off,sizeof(int)) < 0) {`
354			`sprintf(sTemp,"Unable to disable Nagel's algorithm for socket %d.\nsetsockopt",fd);`
355			`perror(sTemp);`
356			`close(fd);`
357			`return;`
358			`}`
359	304	markom
360			`/* Install new handler */`
361			`{`
362			`unsigned long id;`
363			`struct vapi_handler *t;`
364			`if (vapi_read_stream (fd, &id, sizeof (id))) {`
365			`perror ("Cannot get id");`
366			`close (fd);`
367			`return;`
368	293	markom	`}`
369	304	markom	`t = find_handler (id);`
370	355	markom	`if (t) {`
371	304	markom	`if (t->fd) {`
372	1308	phoenix	`fprintf (stderr, "WARNING: Test with id %lx already connected. Ignoring.\n", id);`
373	304	markom	`close (fd);`
374			`return;`
375	355	markom	`} else {`
376			`t->fd = fd;`
377			`rebuild_fds ();`
378			`}`
379			`} else {`
380	1308	phoenix	`fprintf (stderr, "WARNING: Test with id %lx not registered. Ignoring.\n", id);`
381	355	markom	`close(fd); /* kill the connection */`
382			`return;`
383	293	markom	`}`
384	304	markom	`if(config.sim.verbose)`
385	1308	phoenix	`PRINTF ("\nConnection with test (id %lx) established.\n", id);`
386	293	markom	`}`
387			`}`
388
389			`static int write_packet (unsigned long id, unsigned long data) {`
390	304	markom	`struct vapi_handler *t = find_handler (id);`
391			`if (!t \|\| !t->fd)`
392			`return 1;`
393	293	markom	`id = htonl (id);`
394	304	markom	`if (vapi_write_stream(t->fd, &id, sizeof (id)) < 0)`
395	293	markom	`return 1;`
396			`data = htonl (data);`
397	304	markom	`if (vapi_write_stream(t->fd, &data, sizeof (data)) < 0)`
398	293	markom	`return 1;`
399			`return 0;`
400	442	erez	`}`
401	293	markom
402	442	erez	`static int read_packet (int fd, unsigned long id, unsigned long data)`
403			`{`
404	477	erez	`if (fd <= 0)`
405	293	markom	`return 1;`
406	477	erez	`if (vapi_read_stream(fd, id, sizeof(unsigned long)) < 0)`
407	293	markom	`return 1;`
408	442	erez	`id = ntohl (id);`
409	477	erez	`if (vapi_read_stream(fd, data, sizeof(unsigned long)) < 0)`
410	304	markom	`return 1;`
411	442	erez	`data = ntohl (data);`
412	293	markom	`return 0;`
413	304	markom	`}`
414	293	markom
415	442	erez	`static void vapi_request (struct vapi_handler *t)`
416			`{`
417			`unsigned long id, data;`
418
419			`if (read_packet(t->fd, &id, &data)) {`
420	477	erez	`if (t->fd > 0) {`
421	293	markom	`perror("vapi read");`
422	304	markom	`close(t->fd);`
423			`t->fd = 0;`
424	361	markom	`rebuild_fds ();`
425	293	markom	`}`
426			`return;`
427			`}`
428
429	442	erez	`vapi_write_log_file (VAPI_COMMAND_REQUEST, id, data);`
430	1492	nogj	`TRACE ("[%08lx, %08lx]\n", id, data);`
431	442	erez
432			`/* This packet may be for another handler */`
433	477	erez	`if (!handler_fits_id (t, id))`
434	442	erez	`t = find_handler (id);`
435			`if (!t \|\| !t->read_func)`
436	1308	phoenix	`fprintf (stderr, "WARNING: Received packet for undefined id %08lx, data %08lx\n", id, data);`
437	293	markom	`else`
438	1366	nogj	`t->read_func(id, data, t->priv_dat);`
439	293	markom	`}`
440
441			`void vapi_check ()`
442			`{`
443	304	markom	`struct vapi_handler *t;`
444	293	markom
445	304	markom	`if (!server_fd \|\| !fds) {`
446			`fprintf (stderr, "FATAL: Unable to maintain VAPI server.\n");`
447			`exit (1);`
448	293	markom	`}`
449
450	1492	nogj	`TRACE(".");`
451	355	markom
452	304	markom	`/* Handle everything in queue. */`
453	293	markom	`while(1) {`
454	304	markom	`switch(poll(fds, nfds, 0)) {`
455	293	markom	`case -1:`
456			`if(errno == EINTR)`
457			`continue;`
458			`perror("poll");`
459	304	markom	`if (server_fd)`
460			`close(server_fd);`
461	551	markom	`runtime.vapi.enabled = 0;`
462	304	markom	`serverIP = 0;`
463			`return;`
464	293	markom	`case 0: /* Nothing interesting going on */`
465			`return;`
466			`default:`
467	304	markom	`/* Handle the vapi ports first. */`
468			`for (t = vapi_handler; t; t = t->next)`
469			`if (t->temp >= 0 && fds[t->temp].revents)`
470			`vapi_request (t);`
471	293	markom
472	304	markom	`if(fds[0].revents) {`
473	293	markom	`if(fds[0].revents & POLLIN)`
474			`server_request();`
475			`else { /* Error Occurred */`
476	304	markom	`fprintf(stderr,"Received flags 0x%08x on server. Shutting down.\n", fds[0].revents);`
477			`if (server_fd)`
478			`close(server_fd);`
479	293	markom	`server_fd = 0;`
480	551	markom	`runtime.vapi.enabled = 0;`
481	293	markom	`serverIP = 0;`
482			`}`
483			`}`
484			`break;`
485			`} /* End of switch statement */`
486			`} /* End of while statement */`
487			`}`
488
489	304	markom	`/* Inits the VAPI, according to sim-config */`
490			`int vapi_init ()`
491	293	markom	`{`
492	304	markom	`nhandlers = 0;`
493			`vapi_handler = NULL;`
494	551	markom	`if (!runtime.vapi.enabled)`
495	304	markom	`return 0; /* Nothing to do */`
496
497	551	markom	`runtime.vapi.server_port = config.vapi.server_port;`
498			`if (!runtime.vapi.server_port) {`
499	304	markom	`fprintf (stderr, "WARNING: server_port = 0, shutting down VAPI\n");`
500	551	markom	`runtime.vapi.enabled = 0;`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [branches/] [stable_0_2_x/] [or1ksim/] [vapi/] [vapi.c] - Blame information for rev 1646