upstream/dynamips-0.2.6-RC3/hypervisor.c

/*
 * Cisco 7200 (Predator) simulation platform.
 * Copyright (c) 2006 Christophe Fillot (cf@utc.fr)
 *
 * Hypervisor routines.
 */

/* By default, Cygwin supports only 64 FDs with select()! */
#ifdef __CYGWIN__
#define FD_SETSIZE 1024
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>

#include "utils.h"
#include "parser.h"
#include "net.h"
#include "registry.h"
#include "mips64.h"
#include "dynamips.h"
#include "dev_c7200.h"
#include "dev_c3600.h"
#include "dev_c2691.h"
#include "dev_c3725.h"
#include "dev_c3745.h"
#include "hypervisor.h"
#include "net_io.h"
#include "net_io_bridge.h"
#include "frame_relay.h"
#include "atm.h"

#define DEBUG_TOKEN  0

/* Hypervisor modules */
static hypervisor_module_t *module_list = NULL;
static volatile int hypervisor_running = 0;

/* Hypervisor connection list */
static hypervisor_conn_t *hypervisor_conn_list = NULL;

/* Show hypervisor version */
static int cmd_version(hypervisor_conn_t *conn,int argc,char *argv[])
{
   hypervisor_send_reply(conn,HSC_INFO_OK,1,"%s",sw_version);
   return(0);
}

/* Parser test */
static int cmd_parser_test(hypervisor_conn_t *conn,int argc,char *argv[])
{
   int i;

   for(i=0;i<argc;i++)
      hypervisor_send_reply(conn,HSC_INFO_MSG,0,
                            "arg %d (len %u): \"%s\"",
                            i,strlen(argv[i]),argv[i]);

   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   return(0);
}

/* Show hypervisor module list */
static int cmd_mod_list(hypervisor_conn_t *conn,int argc,char *argv[])
{
   hypervisor_module_t *m;

   for(m=module_list;m;m=m->next)
      hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s",m->name);

   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   return(0);
}

/* Show module command list */
static int cmd_modcmd_list(hypervisor_conn_t *conn,int argc,char *argv[])
{
   hypervisor_module_t *m;
   hypervisor_cmd_t *cmd;

   if (!(m = hypervisor_find_module(argv[0]))) {
      hypervisor_send_reply(conn,HSC_ERR_UNK_MODULE,1,"unknown module '%s'",
                            argv[0]);
      return(-1);
   }

   for(cmd=m->cmd_list;cmd;cmd=cmd->next)
      hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s (min/max args: %d/%d)",
                            cmd->name,cmd->min_param,cmd->max_param);

   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   return(0);
}

/* Set working directory */
static int cmd_set_working_dir(hypervisor_conn_t *conn,int argc,char *argv[])
{
   if (chdir(argv[0]) == -1) {
      hypervisor_send_reply(conn,HSC_ERR_INV_PARAM,1,
                            "chdir: %s",strerror(errno));
   } else {
      hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   }
   return(0);
}

/* Save the hypervisor configuration in the specified file */
static int cmd_save_config(hypervisor_conn_t *conn,int argc,char *argv[])
{
   FILE *fd;

   if (!(fd = fopen(argv[0],"w"))) {
      hypervisor_send_reply(conn,HSC_ERR_FILE,1,"fopen: %s",strerror(errno));
      return(-1);
   }

   /* Save configuration for all objects */
   netio_save_config_all(fd);
   frsw_save_config_all(fd);
   atmsw_save_config_all(fd);
   netio_bridge_save_config_all(fd);
   c7200_save_config_all(fd);
   c3600_save_config_all(fd);
   c2691_save_config_all(fd);
   c3725_save_config_all(fd);
   c3745_save_config_all(fd);

   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   return(0);
}

/* Reset hypervisor (delete all objects) */
static int cmd_reset(hypervisor_conn_t *conn,int argc,char *argv[])
{
   dynamips_reset();
   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   return(0);
}

/* Close connection */
static int cmd_close(hypervisor_conn_t *conn,int argc,char *argv[])
{
   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   conn->active = FALSE;
   return(0);
}

/* Stop hypervisor */
static int cmd_stop(hypervisor_conn_t *conn,int argc,char *argv[])
{
   hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
   hypervisor_running = FALSE;
   return(0);
}

/* Hypervisor commands */
static hypervisor_cmd_t hypervisor_cmd_array[] = {
   { "version", 0, 0, cmd_version, NULL },
   { "parser_test", 0, 10, cmd_parser_test, NULL },
   { "module_list", 0, 0, cmd_mod_list, NULL },
   { "cmd_list", 1, 1, cmd_modcmd_list, NULL },
   { "working_dir", 1, 1, cmd_set_working_dir, NULL },
   { "save_config", 1, 1, cmd_save_config, NULL },
   { "reset", 0, 0, cmd_reset, NULL },
   { "close", 0, 0, cmd_close, NULL },
   { "stop", 0, 0, cmd_stop, NULL },
   { NULL, -1, -1, NULL, NULL },
};

/* Send a reply */
int hypervisor_send_reply(hypervisor_conn_t *conn,int code,int done,
                          char *format,...)
{
   va_list ap;
   size_t n = 0;

   if (conn != NULL) {
      va_start(ap,format);
      n += fprintf(conn->out,"%3d%s",code,(done)?"-":" ");
      n += vfprintf(conn->out,format,ap);
      n += fprintf(conn->out,"\r\n");
      fflush(conn->out);
      va_end(ap);
   }

   return(n);
}

/* Find a module */
hypervisor_module_t *hypervisor_find_module(char *name)
{
   hypervisor_module_t *m;

   for(m=module_list;m;m=m->next)
      if (!strcmp(m->name,name))
         return m;

   return NULL;
}

/* Find a command in a module */
hypervisor_cmd_t *hypervisor_find_cmd(hypervisor_module_t *module,char *name)
{                                      
   hypervisor_cmd_t *cmd;
   
   for(cmd=module->cmd_list;cmd;cmd=cmd->next)
      if (!strcmp(cmd->name,name))
         return cmd;

   return NULL;
}

/* Find an object in the registry */
void *hypervisor_find_object(hypervisor_conn_t *conn,char *name,int obj_type)
{
   void *p;

   if (!(p = registry_find(name,obj_type))) {
      hypervisor_send_reply(conn,HSC_ERR_UNK_OBJ,1,
                            "unable to find object '%s'",name);
      return NULL;
   }

   return p;
}

/* Find a VM in the registry */
void *hypervisor_find_vm(hypervisor_conn_t *conn,char *name,int vm_type)
{
   vm_instance_t *vm;

   if (!(vm = vm_acquire(name))) {
      hypervisor_send_reply(conn,HSC_ERR_UNK_OBJ,1,
                            "unable to find VM '%s'",name);
      return NULL;
   }

   if (vm->type != vm_type) {
      vm_release(vm);
      hypervisor_send_reply(conn,HSC_ERR_BAD_OBJ,1,
                            "VM '%s' is not a VM type %d",
                            name,vm_type);
      return NULL;
   }

   return vm;
}

/* Register a module */
hypervisor_module_t *hypervisor_register_module(char *name)
{
   hypervisor_module_t *m;

   if (hypervisor_find_module(name) != NULL) {
      fprintf(stderr,"Hypervisor: module '%s' already exists.\n",name);
      return NULL;
   }
   
   if (!(m = malloc(sizeof(*m)))) {
      fprintf(stderr,"Hypervisor: unable to register new module.\n");
      return NULL;
   }

   m->name = name;
   m->cmd_list = NULL;

   m->next = module_list;
   module_list = m;
   return m;
}

/* Register a list of commands */
int hypervisor_register_cmd_list(hypervisor_module_t *module,
                                 hypervisor_cmd_t *cmd_list)
{
   hypervisor_cmd_t *cmd = cmd_list;

   while(cmd->next != NULL)
      cmd = cmd->next;

   cmd->next = module->cmd_list;
   module->cmd_list = cmd_list;
   return(0);
}

/* Register an array of commands */
int hypervisor_register_cmd_array(hypervisor_module_t *module,
                                  hypervisor_cmd_t *cmd_array)
{
   hypervisor_cmd_t *cmd;

   for(cmd=cmd_array;cmd->name!=NULL;cmd++) {
      cmd->next = module->cmd_list;
      module->cmd_list = cmd;
   }

   return(0);
}

/* Locate the module and execute command */
static int hypervisor_exec_cmd(hypervisor_conn_t *conn,
                               char *mod_name,char *cmd_name,
                               int argc,char *argv[])
{
   hypervisor_module_t *module;
   hypervisor_cmd_t *cmd;

   if (!(module = hypervisor_find_module(mod_name))) {
      hypervisor_send_reply(conn,HSC_ERR_UNK_MODULE,1,"Unknown module '%s'",
                            mod_name);
      return(-1);
   }

   if (!(cmd = hypervisor_find_cmd(module,cmd_name))) {
      hypervisor_send_reply(conn,HSC_ERR_UNK_CMD,1,"Unknown command '%s'",
                            cmd_name);
      return(-1);
   }

   if ((argc < cmd->min_param) || (argc > cmd->max_param))  {
      hypervisor_send_reply(conn,HSC_ERR_BAD_PARAM,1,
                            "Bad number of parameters (%d with min/max=%d/%d)",
                            argc,cmd->min_param,cmd->max_param);
      return(-1);
   }

   return(cmd->handler(conn,argc,argv));
}

/* Thread for servicing connections */
static void *hypervisor_thread(void *arg)
{   
   hypervisor_conn_t *conn = arg;
   char buffer[512],**tokens;
   parser_context_t ctx;
   int res;
   
   tokens = NULL;
   parser_context_init(&ctx);

   while(conn->active) {
      if (!fgets(buffer,sizeof(buffer),conn->in))
         break;
   
      if (!*buffer)
         continue;

      /* Tokenize command line */
      res = parser_scan_buffer(&ctx,buffer,strlen(buffer));

      if (res != 0) {   
         tokens = NULL;

         if (ctx.error != 0) {
            hypervisor_send_reply(conn,HSC_ERR_PARSING,1,"Parse error: %s",
                                  parser_strerror(&ctx));
            goto free_tokens;
         }

         if (ctx.tok_count < 2) {
            hypervisor_send_reply(conn,HSC_ERR_PARSING,1,
                                  "At least a module and a command "
                                  "must be specified");
            goto free_tokens;
         }

         /* Map token list to an array */
         tokens = parser_map_array(&ctx);
      
         if (!tokens) {
            hypervisor_send_reply(conn,HSC_ERR_PARSING,1,"No memory");
            goto free_tokens;
         }

         /* Execute command */
         //m_log("hypervisor_exec","%s\n",buffer);
         hypervisor_exec_cmd(conn,tokens[0],tokens[1],ctx.
                             tok_count-2,&tokens[2]);
      
      free_tokens:
         free(tokens);
         tokens = NULL;
         parser_context_free(&ctx);
      }
   }

   free(tokens);
   parser_context_free(&ctx);
   return NULL;
}

static void sigpipe_handler(int sig)
{
   printf("SIGPIPE received.\n");
}

/* Initialize hypervisor */
int hypervisor_init(void)
{
   hypervisor_module_t *module;

   module = hypervisor_register_module("hypervisor");
   assert(module != NULL);

   hypervisor_register_cmd_array(module,hypervisor_cmd_array);
   return(0);
}

/* Remove a connection from the list */
static void hypervisor_remove_conn(hypervisor_conn_t *conn)
{
   if (conn->pprev != NULL) {
      if (conn->next)
         conn->next->pprev = conn->pprev;

      *(conn->pprev) = conn->next;
   }
}

/* Close a connection */
static void hypervisor_close_conn(hypervisor_conn_t *conn)
{
   if (conn != NULL) {
      conn->active = FALSE;      
      shutdown(conn->client_fd,2);
      pthread_join(conn->tid,NULL);

      fclose(conn->in);
      fclose(conn->out);

      shutdown(conn->client_fd,2);
      close(conn->client_fd);

      hypervisor_remove_conn(conn);
      free(conn);
   }
}

/* Close connections (dead or all) */
static void hypervisor_close_conn_list(int dead_status)
{
   hypervisor_conn_t *conn,*next;
   
   for(conn=hypervisor_conn_list;conn;conn=next) {
      next = conn->next;

      if (dead_status && conn->active)
         continue;

      hypervisor_close_conn(conn);
   }
}

/* Add a new connection to the list */
static void hypervisor_add_conn(hypervisor_conn_t *conn)
{
   conn->next = hypervisor_conn_list;
   conn->pprev = &hypervisor_conn_list;

   if (hypervisor_conn_list != NULL)
      hypervisor_conn_list->pprev = &conn->next;

   hypervisor_conn_list = conn;
}

/* Create a new connection */
static hypervisor_conn_t *hypervisor_create_conn(int client_fd)
{
   hypervisor_conn_t *conn;

   if (!(conn = malloc(sizeof(*conn))))
      goto err_malloc;

   memset(conn,0,sizeof(*conn));
   conn->active    = TRUE;
   conn->client_fd = client_fd;

   /* Open input buffered stream */
   if (!(conn->in = fdopen(client_fd,"r"))) {
      perror("hypervisor_create_conn: fdopen/in");
      goto err_fd_in;
   }

   /* Open output buffered stream */
   if (!(conn->out = fdopen(client_fd,"w"))) {
      perror("hypervisor_create_conn: fdopen/out");
      goto err_fd_out;
   }

   /* Set line buffering */
   setlinebuf(conn->in);
   setlinebuf(conn->out);
  
   /* Create the managing thread */
   if (pthread_create(&conn->tid,NULL,hypervisor_thread,conn) != 0)
      goto err_thread;

   /* Add it to the connection list */
   hypervisor_add_conn(conn);
   return conn;

 err_thread:
   fclose(conn->out);
 err_fd_out:
   fclose(conn->in);
 err_fd_in:
   free(conn);
 err_malloc:
   return NULL;
}

/* Stop hypervisor from sighandler */
int hypervisor_stopsig(void)
{
   hypervisor_running = FALSE;
   return(0);
}

/* Hypervisor TCP server */
int hypervisor_tcp_server(int tcp_port)
{
   int fd_array[HYPERVISOR_MAX_FD];
   struct sockaddr_storage remote_addr;
   socklen_t remote_len;
   int i,res,clnt,fd_count,fd_max;
   struct timeval tv;
   fd_set fds;

   /* Initialize all hypervisor modules */
   hypervisor_init();
   hypervisor_nio_init();
   hypervisor_nio_bridge_init();
   hypervisor_frsw_init();
   hypervisor_atmsw_init();
   hypervisor_ethsw_init();
   hypervisor_vm_init();
   hypervisor_vm_debug_init();
   hypervisor_c7200_init();
   hypervisor_c3600_init();
   hypervisor_c2691_init();
   hypervisor_c3725_init();
   hypervisor_c3745_init();

   signal(SIGPIPE,sigpipe_handler);

   if (!tcp_port)
      tcp_port = HYPERVISOR_TCP_PORT;

   fd_count = ip_listen(tcp_port,SOCK_STREAM,HYPERVISOR_MAX_FD,fd_array);

   if (fd_count <= 0) {
      fprintf(stderr,"Hypervisor: unable to create TCP sockets.\n");
      return(-1);
   }

   /* Start accepting connections */
   printf("Hypervisor TCP control server started (port %d).\n",tcp_port);
   hypervisor_running = TRUE;

   while(hypervisor_running) {
      FD_ZERO(&fds);
      fd_max = -1;

      for(i=0;i<fd_count;i++)
         if (fd_array[i] != -1) {
            FD_SET(fd_array[i],&fds);
            if (fd_array[i] > fd_max)
               fd_max = fd_array[i];
         }

      /* Wait for incoming connections */
      tv.tv_sec  = 0;
      tv.tv_usec = 500 * 1000;  /* 500 ms */
      res = select(fd_max+1,&fds,NULL,NULL,&tv);

      if (res == -1) {
         if (errno == EINTR)
            continue;
         else
            perror("hypervisor_tcp_server: select");
      }

      /* Accept connections on signaled sockets */
      for(i=0;i<fd_count;i++) {
         if (fd_array[i] == -1)
            continue;
         
         if (!FD_ISSET(fd_array[i],&fds))
            continue;

         remote_len = sizeof(remote_addr);
         clnt = accept(fd_array[i],(struct sockaddr *)&remote_addr,
                       &remote_len);

         if (clnt < 0) {
            perror("hypervisor_tcp_server: accept");
            continue;
         }
            
         /* create a new connection and start a thread to handle it */
         if (!hypervisor_create_conn(clnt)) {
            fprintf(stderr,"hypervisor_tcp_server: unable to create new "
                    "connection for FD %d\n",clnt);
            close(clnt);
         }
      }

      /* Walk through the connection list to eliminate dead connections */
      hypervisor_close_conn_list(TRUE);
   }   

   /* Close all control sockets */
   printf("Hypervisor: closing control sockets.\n");
   for(i=0;i<fd_count;i++) {
      if (fd_array[i] != -1) {
         shutdown(fd_array[i],2);
         close(fd_array[i]);
      }
   }

   /* Close all remote client connections */
   printf("Hypervisor: closing remote client connections.\n");
   hypervisor_close_conn_list(FALSE);
   return(0);
}
1	dpavlin	1	/*
2			* Cisco 7200 (Predator) simulation platform.
3			* Copyright (c) 2006 Christophe Fillot (cf@utc.fr)
4			*
5			* Hypervisor routines.
6			*/
7
8			/* By default, Cygwin supports only 64 FDs with select()! */
9			#ifdef __CYGWIN__
10			#define FD_SETSIZE 1024
11			#endif
12
13			#include <stdio.h>
14			#include <stdlib.h>
15			#include <unistd.h>
16			#include <string.h>
17			#include <sys/types.h>
18			#include <sys/stat.h>
19			#include <sys/mman.h>
20			#include <signal.h>
21			#include <fcntl.h>
22			#include <errno.h>
23			#include <assert.h>
24			#include <stdarg.h>
25			#include <sys/ioctl.h>
26			#include <sys/types.h>
27			#include <sys/socket.h>
28			#include <arpa/inet.h>
29			#include <pthread.h>
30
31			#include "utils.h"
32			#include "parser.h"
33			#include "net.h"
34			#include "registry.h"
35			#include "mips64.h"
36			#include "dynamips.h"
37			#include "dev_c7200.h"
38			#include "dev_c3600.h"
39	dpavlin	4	#include "dev_c2691.h"
40			#include "dev_c3725.h"
41			#include "dev_c3745.h"
42	dpavlin	1	#include "hypervisor.h"
43			#include "net_io.h"
44			#include "net_io_bridge.h"
45			#include "frame_relay.h"
46			#include "atm.h"
47
48			#define DEBUG_TOKEN 0
49
50			/* Hypervisor modules */
51			static hypervisor_module_t *module_list = NULL;
52			static volatile int hypervisor_running = 0;
53
54			/* Hypervisor connection list */
55			static hypervisor_conn_t *hypervisor_conn_list = NULL;
56
57			/* Show hypervisor version */
58			static int cmd_version(hypervisor_conn_t conn,int argc,char argv[])
59			{
60			hypervisor_send_reply(conn,HSC_INFO_OK,1,"%s",sw_version);
61			return(0);
62			}
63
64	dpavlin	2	/* Parser test */
65			static int cmd_parser_test(hypervisor_conn_t conn,int argc,char argv[])
66			{
67			int i;
68
69			for(i=0;i<argc;i++)
70			hypervisor_send_reply(conn,HSC_INFO_MSG,0,
71			"arg %d (len %u): \"%s\"",
72			i,strlen(argv[i]),argv[i]);
73
74			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
75			return(0);
76			}
77
78	dpavlin	1	/* Show hypervisor module list */
79			static int cmd_mod_list(hypervisor_conn_t conn,int argc,char argv[])
80			{
81			hypervisor_module_t *m;
82
83			for(m=module_list;m;m=m->next)
84			hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s",m->name);
85
86			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
87			return(0);
88			}
89
90			/* Show module command list */
91			static int cmd_modcmd_list(hypervisor_conn_t conn,int argc,char argv[])
92			{
93			hypervisor_module_t *m;
94			hypervisor_cmd_t *cmd;
95
96			if (!(m = hypervisor_find_module(argv[0]))) {
97			hypervisor_send_reply(conn,HSC_ERR_UNK_MODULE,1,"unknown module '%s'",
98			argv[0]);
99			return(-1);
100			}
101
102			for(cmd=m->cmd_list;cmd;cmd=cmd->next)
103			hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s (min/max args: %d/%d)",
104			cmd->name,cmd->min_param,cmd->max_param);
105
106			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
107			return(0);
108			}
109
110			/* Set working directory */
111			static int cmd_set_working_dir(hypervisor_conn_t conn,int argc,char argv[])
112			{
113			if (chdir(argv[0]) == -1) {
114			hypervisor_send_reply(conn,HSC_ERR_INV_PARAM,1,
115			"chdir: %s",strerror(errno));
116			} else {
117			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
118			}
119			return(0);
120			}
121
122			/* Save the hypervisor configuration in the specified file */
123			static int cmd_save_config(hypervisor_conn_t conn,int argc,char argv[])
124			{
125			FILE *fd;
126
127			if (!(fd = fopen(argv[0],"w"))) {
128			hypervisor_send_reply(conn,HSC_ERR_FILE,1,"fopen: %s",strerror(errno));
129			return(-1);
130			}
131
132			/* Save configuration for all objects */
133			netio_save_config_all(fd);
134			frsw_save_config_all(fd);
135			atmsw_save_config_all(fd);
136			netio_bridge_save_config_all(fd);
137			c7200_save_config_all(fd);
138			c3600_save_config_all(fd);
139	dpavlin	4	c2691_save_config_all(fd);
140			c3725_save_config_all(fd);
141			c3745_save_config_all(fd);
142	dpavlin	1
143			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
144			return(0);
145			}
146
147			/* Reset hypervisor (delete all objects) */
148			static int cmd_reset(hypervisor_conn_t conn,int argc,char argv[])
149			{
150			dynamips_reset();
151			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
152			return(0);
153			}
154
155			/* Close connection */
156			static int cmd_close(hypervisor_conn_t conn,int argc,char argv[])
157			{
158			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
159			conn->active = FALSE;
160			return(0);
161			}
162
163			/* Stop hypervisor */
164			static int cmd_stop(hypervisor_conn_t conn,int argc,char argv[])
165			{
166			hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK");
167			hypervisor_running = FALSE;
168			return(0);
169			}
170
171			/* Hypervisor commands */
172			static hypervisor_cmd_t hypervisor_cmd_array[] = {
173			{ "version", 0, 0, cmd_version, NULL },
174	dpavlin	2	{ "parser_test", 0, 10, cmd_parser_test, NULL },
175	dpavlin	1	{ "module_list", 0, 0, cmd_mod_list, NULL },
176			{ "cmd_list", 1, 1, cmd_modcmd_list, NULL },
177			{ "working_dir", 1, 1, cmd_set_working_dir, NULL },
178			{ "save_config", 1, 1, cmd_save_config, NULL },
179			{ "reset", 0, 0, cmd_reset, NULL },
180			{ "close", 0, 0, cmd_close, NULL },
181			{ "stop", 0, 0, cmd_stop, NULL },
182			{ NULL, -1, -1, NULL, NULL },
183			};
184
185			/* Send a reply */
186			int hypervisor_send_reply(hypervisor_conn_t *conn,int code,int done,
187			char *format,...)
188			{
189			va_list ap;
190			size_t n = 0;
191
192			if (conn != NULL) {
193			va_start(ap,format);
194			n += fprintf(conn->out,"%3d%s",code,(done)?"-":" ");
195			n += vfprintf(conn->out,format,ap);
196			n += fprintf(conn->out,"\r\n");
197			fflush(conn->out);
198			va_end(ap);
199			}
200
201			return(n);
202			}
203
204			/* Find a module */
205			hypervisor_module_t hypervisor_find_module(char name)
206			{
207			hypervisor_module_t *m;
208
209			for(m=module_list;m;m=m->next)
210			if (!strcmp(m->name,name))
211			return m;
212
213			return NULL;
214			}
215
216			/* Find a command in a module */
217			hypervisor_cmd_t hypervisor_find_cmd(hypervisor_module_t module,char *name)
218			{
219			hypervisor_cmd_t *cmd;
220
221			for(cmd=module->cmd_list;cmd;cmd=cmd->next)
222			if (!strcmp(cmd->name,name))
223			return cmd;
224
225			return NULL;
226			}
227
228			/* Find an object in the registry */
229			void hypervisor_find_object(hypervisor_conn_t conn,char *name,int obj_type)
230			{
231			void *p;
232
233			if (!(p = registry_find(name,obj_type))) {
234			hypervisor_send_reply(conn,HSC_ERR_UNK_OBJ,1,
235			"unable to find object '%s'",name);
236			return NULL;
237			}
238
239			return p;
240			}
241
242			/* Find a VM in the registry */
243			void hypervisor_find_vm(hypervisor_conn_t conn,char *name,int vm_type)
244			{
245			vm_instance_t *vm;
246
247			if (!(vm = vm_acquire(name))) {
248			hypervisor_send_reply(conn,HSC_ERR_UNK_OBJ,1,
249			"unable to find VM '%s'",name);
250			return NULL;
251			}
252
253			if (vm->type != vm_type) {
254			vm_release(vm);
255			hypervisor_send_reply(conn,HSC_ERR_BAD_OBJ,1,
256			"VM '%s' is not a VM type %d",
257			name,vm_type);
258			return NULL;
259			}
260
261			return vm;
262			}
263
264			/* Register a module */
265			hypervisor_module_t hypervisor_register_module(char name)
266			{
267			hypervisor_module_t *m;
268
269			if (hypervisor_find_module(name) != NULL) {
270			fprintf(stderr,"Hypervisor: module '%s' already exists.\n",name);
271			return NULL;
272			}
273
274			if (!(m = malloc(sizeof(*m)))) {
275			fprintf(stderr,"Hypervisor: unable to register new module.\n");
276			return NULL;
277			}
278
279			m->name = name;
280			m->cmd_list = NULL;
281
282			m->next = module_list;
283			module_list = m;
284			return m;
285			}
286
287			/* Register a list of commands */
288			int hypervisor_register_cmd_list(hypervisor_module_t *module,
289			hypervisor_cmd_t *cmd_list)
290			{
291			hypervisor_cmd_t *cmd = cmd_list;
292
293			while(cmd->next != NULL)
294			cmd = cmd->next;
295
296			cmd->next = module->cmd_list;
297			module->cmd_list = cmd_list;
298			return(0);
299			}
300
301			/* Register an array of commands */
302			int hypervisor_register_cmd_array(hypervisor_module_t *module,
303			hypervisor_cmd_t *cmd_array)
304			{
305			hypervisor_cmd_t *cmd;
306
307			for(cmd=cmd_array;cmd->name!=NULL;cmd++) {
308			cmd->next = module->cmd_list;
309			module->cmd_list = cmd;
310			}
311
312			return(0);
313			}
314
315			/* Locate the module and execute command */
316			static int hypervisor_exec_cmd(hypervisor_conn_t *conn,
317			char mod_name,char cmd_name,
318			int argc,char *argv[])
319			{
320			hypervisor_module_t *module;
321			hypervisor_cmd_t *cmd;
322
323			if (!(module = hypervisor_find_module(mod_name))) {
324			hypervisor_send_reply(conn,HSC_ERR_UNK_MODULE,1,"Unknown module '%s'",
325			mod_name);
326			return(-1);
327			}
328
329			if (!(cmd = hypervisor_find_cmd(module,cmd_name))) {
330			hypervisor_send_reply(conn,HSC_ERR_UNK_CMD,1,"Unknown command '%s'",
331			cmd_name);
332			return(-1);
333			}
334
335			if ((argc < cmd->min_param) \|\| (argc > cmd->max_param)) {
336			hypervisor_send_reply(conn,HSC_ERR_BAD_PARAM,1,
337			"Bad number of parameters (%d with min/max=%d/%d)",
338			argc,cmd->min_param,cmd->max_param);
339			return(-1);
340			}
341
342			return(cmd->handler(conn,argc,argv));
343			}
344
345			/* Thread for servicing connections */
346			static void hypervisor_thread(void arg)
347			{
348			hypervisor_conn_t *conn = arg;
349	dpavlin	2	char buffer[512],**tokens;
350			parser_context_t ctx;
351			int res;
352	dpavlin	1
353	dpavlin	2	tokens = NULL;
354			parser_context_init(&ctx);
355
356	dpavlin	1	while(conn->active) {
357	dpavlin	2	if (!fgets(buffer,sizeof(buffer),conn->in))
358	dpavlin	1	break;
359
360			if (!*buffer)
361			continue;
362
363			/* Tokenize command line */
364	dpavlin	2	res = parser_scan_buffer(&ctx,buffer,strlen(buffer));
365	dpavlin	1
366	dpavlin	2	if (res != 0) {
367			tokens = NULL;
368	dpavlin	1
369	dpavlin	2	if (ctx.error != 0) {
370			hypervisor_send_reply(conn,HSC_ERR_PARSING,1,"Parse error: %s",
371			parser_strerror(&ctx));
372			goto free_tokens;
373			}
374	dpavlin	1
375	dpavlin	2	if (ctx.tok_count < 2) {
376			hypervisor_send_reply(conn,HSC_ERR_PARSING,1,
377			"At least a module and a command "
378			"must be specified");
379			goto free_tokens;
380			}
381
382			/* Map token list to an array */
383			tokens = parser_map_array(&ctx);
384	dpavlin	1
385	dpavlin	2	if (!tokens) {
386			hypervisor_send_reply(conn,HSC_ERR_PARSING,1,"No memory");
387			goto free_tokens;
388			}
389	dpavlin	1
390	dpavlin	2	/* Execute command */
391			//m_log("hypervisor_exec","%s\n",buffer);
392			hypervisor_exec_cmd(conn,tokens[0],tokens[1],ctx.
393			tok_count-2,&tokens[2]);
394	dpavlin	1
395	dpavlin	2	free_tokens:
396			free(tokens);
397			tokens = NULL;
398			parser_context_free(&ctx);
399			}
400	dpavlin	1	}
401
402	dpavlin	2	free(tokens);
403			parser_context_free(&ctx);
404	dpavlin	1	return NULL;
405			}
406
407			static void sigpipe_handler(int sig)
408			{
409			printf("SIGPIPE received.\n");
410			}
411
412			/* Initialize hypervisor */
413			int hypervisor_init(void)
414			{
415			hypervisor_module_t *module;
416
417			module = hypervisor_register_module("hypervisor");
418			assert(module != NULL);
419
420			hypervisor_register_cmd_array(module,hypervisor_cmd_array);
421			return(0);
422			}
423
424			/* Remove a connection from the list */
425			static void hypervisor_remove_conn(hypervisor_conn_t *conn)
426			{
427			if (conn->pprev != NULL) {
428			if (conn->next)
429			conn->next->pprev = conn->pprev;
430
431			*(conn->pprev) = conn->next;
432			}
433			}
434
435			/* Close a connection */
436			static void hypervisor_close_conn(hypervisor_conn_t *conn)
437			{
438			if (conn != NULL) {
439			conn->active = FALSE;
440			shutdown(conn->client_fd,2);
441			pthread_join(conn->tid,NULL);
442
443			fclose(conn->in);
444			fclose(conn->out);
445
446			shutdown(conn->client_fd,2);
447			close(conn->client_fd);
448
449			hypervisor_remove_conn(conn);
450			free(conn);
451			}
452			}
453
454			/* Close connections (dead or all) */
455			static void hypervisor_close_conn_list(int dead_status)
456			{
457			hypervisor_conn_t conn,next;
458
459			for(conn=hypervisor_conn_list;conn;conn=next) {
460			next = conn->next;
461
462			if (dead_status && conn->active)
463			continue;
464
465			hypervisor_close_conn(conn);
466			}
467			}
468
469			/* Add a new connection to the list */
470			static void hypervisor_add_conn(hypervisor_conn_t *conn)
471			{
472			conn->next = hypervisor_conn_list;
473			conn->pprev = &hypervisor_conn_list;
474
475			if (hypervisor_conn_list != NULL)
476			hypervisor_conn_list->pprev = &conn->next;
477
478			hypervisor_conn_list = conn;
479			}
480
481			/* Create a new connection */
482			static hypervisor_conn_t *hypervisor_create_conn(int client_fd)
483			{
484			hypervisor_conn_t *conn;
485
486			if (!(conn = malloc(sizeof(*conn))))
487			goto err_malloc;
488
489			memset(conn,0,sizeof(*conn));
490			conn->active = TRUE;
491			conn->client_fd = client_fd;
492
493			/* Open input buffered stream */
494			if (!(conn->in = fdopen(client_fd,"r"))) {
495			perror("hypervisor_create_conn: fdopen/in");
496			goto err_fd_in;
497			}
498
499			/* Open output buffered stream */
500			if (!(conn->out = fdopen(client_fd,"w"))) {
501			perror("hypervisor_create_conn: fdopen/out");
502			goto err_fd_out;
503			}
504
505			/* Set line buffering */
506			setlinebuf(conn->in);
507			setlinebuf(conn->out);
508
509			/* Create the managing thread */
510			if (pthread_create(&conn->tid,NULL,hypervisor_thread,conn) != 0)
511			goto err_thread;
512
513			/* Add it to the connection list */
514			hypervisor_add_conn(conn);
515			return conn;
516
517			err_thread:
518			fclose(conn->out);
519			err_fd_out:
520			fclose(conn->in);
521			err_fd_in:
522			free(conn);
523			err_malloc:
524			return NULL;
525			}
526
527			/* Stop hypervisor from sighandler */
528			int hypervisor_stopsig(void)
529			{
530			hypervisor_running = FALSE;
531			return(0);
532			}
533
534			/* Hypervisor TCP server */
535			int hypervisor_tcp_server(int tcp_port)
536			{
537			int fd_array[HYPERVISOR_MAX_FD];
538			struct sockaddr_storage remote_addr;
539			socklen_t remote_len;
540			int i,res,clnt,fd_count,fd_max;
541			struct timeval tv;
542			fd_set fds;
543
544			/* Initialize all hypervisor modules */
545			hypervisor_init();
546			hypervisor_nio_init();
547			hypervisor_nio_bridge_init();
548			hypervisor_frsw_init();
549			hypervisor_atmsw_init();
550			hypervisor_ethsw_init();
551			hypervisor_vm_init();
552	dpavlin	2	hypervisor_vm_debug_init();
553	dpavlin	1	hypervisor_c7200_init();
554			hypervisor_c3600_init();
555	dpavlin	4	hypervisor_c2691_init();
556			hypervisor_c3725_init();
557			hypervisor_c3745_init();
558	dpavlin	1
559			signal(SIGPIPE,sigpipe_handler);
560
561			if (!tcp_port)
562			tcp_port = HYPERVISOR_TCP_PORT;
563
564			fd_count = ip_listen(tcp_port,SOCK_STREAM,HYPERVISOR_MAX_FD,fd_array);
565
566			if (fd_count <= 0) {
567			fprintf(stderr,"Hypervisor: unable to create TCP sockets.\n");
568			return(-1);
569			}
570
571			/* Start accepting connections */
572	dpavlin	4	printf("Hypervisor TCP control server started (port %d).\n",tcp_port);
573	dpavlin	1	hypervisor_running = TRUE;
574
575			while(hypervisor_running) {
576			FD_ZERO(&fds);
577			fd_max = -1;
578
579			for(i=0;i<fd_count;i++)
580			if (fd_array[i] != -1) {
581			FD_SET(fd_array[i],&fds);
582			if (fd_array[i] > fd_max)
583			fd_max = fd_array[i];
584			}
585
586			/* Wait for incoming connections */
587			tv.tv_sec = 0;
588			tv.tv_usec = 500 * 1000; /* 500 ms */
589			res = select(fd_max+1,&fds,NULL,NULL,&tv);
590
591			if (res == -1) {
592			if (errno == EINTR)
593			continue;
594			else
595			perror("hypervisor_tcp_server: select");
596			}
597
598			/* Accept connections on signaled sockets */
599			for(i=0;i<fd_count;i++) {
600			if (fd_array[i] == -1)
601			continue;
602
603			if (!FD_ISSET(fd_array[i],&fds))
604			continue;
605
606			remote_len = sizeof(remote_addr);
607			clnt = accept(fd_array[i],(struct sockaddr *)&remote_addr,
608			&remote_len);
609
610			if (clnt < 0) {
611			perror("hypervisor_tcp_server: accept");
612			continue;
613			}
614
615			/* create a new connection and start a thread to handle it */
616			if (!hypervisor_create_conn(clnt)) {
617			fprintf(stderr,"hypervisor_tcp_server: unable to create new "
618			"connection for FD %d\n",clnt);
619			close(clnt);
620			}
621			}
622
623			/* Walk through the connection list to eliminate dead connections */
624			hypervisor_close_conn_list(TRUE);
625			}
626
627			/* Close all control sockets */
628			printf("Hypervisor: closing control sockets.\n");
629			for(i=0;i<fd_count;i++) {
630			if (fd_array[i] != -1) {
631			shutdown(fd_array[i],2);
632			close(fd_array[i]);
633			}
634			}
635
636			/* Close all remote client connections */
637			printf("Hypervisor: closing remote client connections.\n");
638			hypervisor_close_conn_list(FALSE);
639			return(0);
640			}