/[dynamips]/trunk/vm.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /trunk/vm.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

upstream/dynamips-0.2.7-RC2/vm.c revision 8 by dpavlin, Sat Oct 6 16:24:54 2007 UTC upstream/dynamips-0.2.8-RC1/vm.c revision 11 by dpavlin, Sat Oct 6 16:33:40 2007 UTC
# Line 33  Line 33 
33  /* Type of VM file naming (0=use VM name, 1=use instance ID) */  /* Type of VM file naming (0=use VM name, 1=use instance ID) */
34  int vm_file_naming_type = 0;  int vm_file_naming_type = 0;
35    
36    /* Platform list */
37    static struct vm_platform_list *vm_platforms = NULL;
38    
39  /* Pool of ghost images */  /* Pool of ghost images */
40  static vm_ghost_image_t *vm_ghost_pool = NULL;  static vm_ghost_image_t *vm_ghost_pool = NULL;
41    
# Line 133  void vm_object_dump(vm_instance_t *vm) Line 136  void vm_object_dump(vm_instance_t *vm)
136  /* Get VM type */  /* Get VM type */
137  char *vm_get_type(vm_instance_t *vm)  char *vm_get_type(vm_instance_t *vm)
138  {  {
139     char *machine;     return vm->platform->name;
   
    switch(vm->type) {  
       case VM_TYPE_C3600:  
          machine = "c3600";  
          break;  
       case VM_TYPE_C7200:  
          machine = "c7200";  
          break;  
       case VM_TYPE_C2691:  
          machine = "c2691";  
          break;  
       case VM_TYPE_C3725:  
          machine = "c3725";  
          break;  
      case VM_TYPE_C3745:  
          machine = "c3745";  
          break;  
      case VM_TYPE_C2600:  
          machine = "c2600";  
          break;  
      case VM_TYPE_MSFC1:  
          machine = "msfc1";  
          break;  
      case VM_TYPE_PPC32_TEST:  
          machine = "ppc32_test";  
          break;  
       default:  
          machine = "unknown";  
          break;  
    }  
   
    return machine;  
140  }  }
141    
142  /* Get platform type */  /* Get log name */
143  char *vm_get_platform_type(vm_instance_t *vm)  static char *vm_get_log_name(vm_instance_t *vm)
144  {  {
145     char *machine;     if (vm->platform->log_name != NULL)
146          return vm->platform->log_name;
147    
148     switch(vm->type) {     /* default value */
149        case VM_TYPE_C3600:     return "VM";
          machine = "C3600";  
          break;  
       case VM_TYPE_C7200:  
          machine = "C7200";  
          break;      
       case VM_TYPE_C2691:  
          machine = "C2691";  
          break;  
       case VM_TYPE_C3725:  
          machine = "C3725";  
          break;  
       case VM_TYPE_C3745:  
          machine = "C3745";  
          break;  
       case VM_TYPE_C2600:  
          machine = "C2600";  
          break;  
       case VM_TYPE_MSFC1:  
          machine = "MSFC1";  
          break;  
       case VM_TYPE_PPC32_TEST:  
          machine = "PPC32_TEST";  
          break;  
       default:  
          machine = "VM";  
          break;  
    }  
   
    return machine;  
150  }  }
151    
152  /* Get MAC address MSB */  /* Get MAC address MSB */
153  u_int vm_get_mac_addr_msb(vm_instance_t *vm)  u_int vm_get_mac_addr_msb(vm_instance_t *vm)
154  {  {
155     switch(vm->type) {     if (vm->platform->get_mac_addr_msb != NULL)
156        case VM_TYPE_C3600:        return(vm->platform->get_mac_addr_msb());
157           return(0xCC);    
158       /* default value */
159        case VM_TYPE_C7200:     return(0xC6);
          return(0xCA);  
   
       case VM_TYPE_C2691:  
          return(0xC0);  
   
       case VM_TYPE_C3725:  
          return(0xC2);  
   
       case VM_TYPE_C3745:  
          return(0xC4);  
   
       case VM_TYPE_C2600:  
          return(0xC8);  
   
       default:  
          return(0xC6);  
    }  
160  }  }
161    
162  /* Generate a filename for use by the instance */  /* Generate a filename for use by the instance */
# Line 373  void vm_error(vm_instance_t *vm,char *fo Line 299  void vm_error(vm_instance_t *vm,char *fo
299     vsnprintf(buffer,sizeof(buffer),format,ap);     vsnprintf(buffer,sizeof(buffer),format,ap);
300     va_end(ap);     va_end(ap);
301    
302     fprintf(stderr,"%s '%s': %s",vm_get_platform_type(vm),vm->name,buffer);     fprintf(stderr,"%s '%s': %s",vm_get_log_name(vm),vm->name,buffer);
303  }  }
304    
305  /* Create a new VM instance */  /* Create a new VM instance */
306  vm_instance_t *vm_create(char *name,int instance_id,int machine_type)  static vm_instance_t *vm_create(char *name,int instance_id,
307                                    vm_platform_t *platform)
308  {  {
309     vm_instance_t *vm;     vm_instance_t *vm;
310    
# Line 387  vm_instance_t *vm_create(char *name,int Line 314  vm_instance_t *vm_create(char *name,int
314     }     }
315        
316     memset(vm,0,sizeof(*vm));     memset(vm,0,sizeof(*vm));
317    
318       if (!(vm->name = strdup(name))) {
319          fprintf(stderr,"VM %s: unable to store instance name!\n",name);
320          goto err_name;
321       }
322    
323     vm->instance_id          = instance_id;     vm->instance_id          = instance_id;
324     vm->type                 = machine_type;     vm->platform             = platform;
325     vm->status               = VM_STATUS_HALTED;     vm->status               = VM_STATUS_HALTED;
326     vm->jit_use              = JIT_SUPPORT;     vm->jit_use              = JIT_SUPPORT;
327     vm->exec_blk_direct_jump = TRUE;     vm->exec_blk_direct_jump = TRUE;
# Line 396  vm_instance_t *vm_create(char *name,int Line 329  vm_instance_t *vm_create(char *name,int
329     vm->vtty_aux_type        = VTTY_TYPE_NONE;     vm->vtty_aux_type        = VTTY_TYPE_NONE;
330     vm->timer_irq_check_itv  = VM_TIMER_IRQ_CHECK_ITV;     vm->timer_irq_check_itv  = VM_TIMER_IRQ_CHECK_ITV;
331     vm->log_file_enabled     = TRUE;     vm->log_file_enabled     = TRUE;
332       vm->rommon_vars.filename = vm_build_filename(vm,"rommon_vars");
333    
334     if (!(vm->name = strdup(name))) {     if (!vm->rommon_vars.filename)
335        fprintf(stderr,"VM %s: unable to store instance name!\n",name);        goto err_rommon;
336        goto err_name;  
337     }     /* XXX */
338       rommon_load_file(&vm->rommon_vars);
339    
340     /* create lock file */     /* create lock file */
341     if (vm_get_lock(vm) == -1)     if (vm_get_lock(vm) == -1)
# Line 423  vm_instance_t *vm_create(char *name,int Line 358  vm_instance_t *vm_create(char *name,int
358   err_log:   err_log:
359     free(vm->lock_file);     free(vm->lock_file);
360   err_lock:   err_lock:
361       free(vm->rommon_vars.filename);
362     err_rommon:
363     free(vm->name);     free(vm->name);
364   err_name:   err_name:
365     free(vm);     free(vm);
# Line 447  int vm_hardware_shutdown(vm_instance_t * Line 384  int vm_hardware_shutdown(vm_instance_t *
384     /* Mark the VM as halted */     /* Mark the VM as halted */
385     vm->status = VM_STATUS_HALTED;     vm->status = VM_STATUS_HALTED;
386    
    /* Disable NVRAM operations */  
    vm->nvram_extract_config = NULL;  
    vm->nvram_push_config = NULL;  
   
387     /* Free the object list */     /* Free the object list */
388     vm_object_free_list(vm);     vm_object_free_list(vm);
389    
# Line 504  void vm_free(vm_instance_t *vm) Line 437  void vm_free(vm_instance_t *vm)
437        vm_chunk_free_all(vm);        vm_chunk_free_all(vm);
438    
439        /* Free various elements */        /* Free various elements */
440          free(vm->rommon_vars.filename);
441        free(vm->ghost_ram_filename);        free(vm->ghost_ram_filename);
442        free(vm->sym_filename);        free(vm->sym_filename);
443        free(vm->ios_image);        free(vm->ios_image);
# Line 984  int vm_ios_set_config(vm_instance_t *vm, Line 918  int vm_ios_set_config(vm_instance_t *vm,
918  /* Extract IOS configuration from NVRAM and write it to a file */  /* Extract IOS configuration from NVRAM and write it to a file */
919  int vm_nvram_extract_config(vm_instance_t *vm,char *filename)  int vm_nvram_extract_config(vm_instance_t *vm,char *filename)
920  {  {
921     char *cfg_buffer;     u_char *cfg_buffer;
922     ssize_t cfg_len;     ssize_t cfg_len;
923     FILE *fd;     FILE *fd;
924    
925     if (!vm->nvram_extract_config)     if (!vm->platform->nvram_extract_config)
926        return(-1);        return(-1);
927    
928     /* Extract the IOS configuration */     /* Extract the IOS configuration */
929     if (((cfg_len = vm->nvram_extract_config(vm,&cfg_buffer)) < 0) ||     if (((cfg_len = vm->platform->nvram_extract_config(vm,&cfg_buffer)) < 0) ||
930         (cfg_buffer == NULL))         (cfg_buffer == NULL))
931        return(-1);        return(-1);
932    
# Line 1013  int vm_nvram_extract_config(vm_instance_ Line 947  int vm_nvram_extract_config(vm_instance_
947  /* Read an IOS configuraton from a file and push it to NVRAM */  /* Read an IOS configuraton from a file and push it to NVRAM */
948  int vm_nvram_push_config(vm_instance_t *vm,char *filename)  int vm_nvram_push_config(vm_instance_t *vm,char *filename)
949  {  {
950     char *cfg_buffer;     u_char *cfg_buffer;
951     ssize_t len;     ssize_t len;
952     int res;     int res;
953    
954     if (!vm->nvram_push_config)     if (!vm->platform->nvram_push_config)
955        return(-1);        return(-1);
956    
957     /* Read configuration */     /* Read configuration */
# Line 1025  int vm_nvram_push_config(vm_instance_t * Line 959  int vm_nvram_push_config(vm_instance_t *
959        return(-1);        return(-1);
960    
961     /* Push it! */     /* Push it! */
962     res = vm->nvram_push_config(vm,cfg_buffer,len);     res = vm->platform->nvram_push_config(vm,cfg_buffer,len);
963     free(cfg_buffer);     free(cfg_buffer);
964     return(res);     return(res);
965  }  }
# Line 1033  int vm_nvram_push_config(vm_instance_t * Line 967  int vm_nvram_push_config(vm_instance_t *
967  /* Save general VM configuration into the specified file */  /* Save general VM configuration into the specified file */
968  void vm_save_config(vm_instance_t *vm,FILE *fd)  void vm_save_config(vm_instance_t *vm,FILE *fd)
969  {  {
970       fprintf(fd,"vm create %s %u %s\n",
971               vm->name,vm->instance_id,vm->platform->name);
972    
973     if (vm->ios_image)     if (vm->ios_image)
974        fprintf(fd,"vm set_ios %s %s\n",vm->name,vm->ios_image);        fprintf(fd,"vm set_ios %s %s\n",vm->name,vm->ios_image);
975    
# Line 1047  void vm_save_config(vm_instance_t *vm,FI Line 984  void vm_save_config(vm_instance_t *vm,FI
984    
985     if (vm->vtty_aux_type == VTTY_TYPE_TCP)     if (vm->vtty_aux_type == VTTY_TYPE_TCP)
986        fprintf(fd,"vm set_aux_tcp_port %s %d\n",vm->name,vm->vtty_aux_tcp_port);        fprintf(fd,"vm set_aux_tcp_port %s %d\n",vm->name,vm->vtty_aux_tcp_port);
987    
988       /* Save slot config */
989       vm_slot_save_all_config(vm,fd);
990    }
991    
992    /* Find a platform */
993    vm_platform_t *vm_platform_find(char *name)
994    {
995       struct vm_platform_list *p;
996    
997       for(p=vm_platforms;p;p=p->next)
998          if (!strcmp(p->platform->name,name))
999             return(p->platform);
1000    
1001       return NULL;
1002    }
1003    
1004    /* Find a platform given its CLI name */
1005    vm_platform_t *vm_platform_find_cli_name(char *name)
1006    {
1007       struct vm_platform_list *p;
1008    
1009       for(p=vm_platforms;p;p=p->next)
1010          if (!strcmp(p->platform->cli_name,name))
1011             return(p->platform);
1012    
1013       return NULL;
1014    }
1015    
1016    /* Register a platform */
1017    int vm_platform_register(vm_platform_t *platform)
1018    {
1019       struct vm_platform_list *p;
1020    
1021       if (vm_platform_find(platform->name) != NULL) {
1022          fprintf(stderr,"vm_platform_register: platform '%s' already exists.\n",
1023                  platform->name);
1024          return(-1);
1025       }
1026    
1027       if (!(p = malloc(sizeof(*p)))) {
1028          fprintf(stderr,"vm_platform_register: unable to record platform.\n");
1029          return(-1);
1030       }
1031    
1032       p->platform = platform;
1033       p->next = vm_platforms;
1034       vm_platforms = p;
1035       return(0);
1036    }
1037    
1038    /* Create an instance of the specified type */
1039    vm_instance_t *vm_create_instance(char *name,int instance_id,char *type)
1040    {
1041       vm_platform_t *platform;
1042       vm_instance_t *vm = NULL;
1043    
1044       if (!(platform = vm_platform_find(type))) {
1045          fprintf(stderr,"VM %s: unknown platform '%s'\n",name,type);
1046          goto error;
1047       }
1048    
1049       /* Create a generic VM instance */
1050       if (!(vm = vm_create(name,instance_id,platform)))
1051          goto error;
1052    
1053       /* Initialize specific parts */
1054       if (vm->platform->create_instance(vm) == -1)
1055          goto error;
1056    
1057       return vm;
1058    
1059     error:
1060       fprintf(stderr,"VM %s: unable to create instance!\n",name);
1061       vm_free(vm);
1062       return NULL;
1063    }
1064    
1065    /* Free resources used by a VM instance */
1066    static int vm_reg_delete_instance(void *data,void *arg)
1067    {
1068       vm_instance_t *vm = data;
1069       return(vm->platform->delete_instance(vm));
1070    }
1071    
1072    /* Delete a VM instance */
1073    int vm_delete_instance(char *name)
1074    {
1075       return(registry_delete_if_unused(name,OBJ_TYPE_VM,
1076                                        vm_reg_delete_instance,NULL));
1077    }
1078    
1079    /* Initialize a VM instance */
1080    int vm_init_instance(vm_instance_t *vm)
1081    {
1082       return(vm->platform->init_instance(vm));
1083    }
1084    
1085    /* Stop a VM instance */
1086    int vm_stop_instance(vm_instance_t *vm)
1087    {
1088       return(vm->platform->stop_instance(vm));
1089    }
1090    
1091    /* Delete all VM instances */
1092    int vm_delete_all_instances(void)
1093    {
1094       return(registry_delete_type(OBJ_TYPE_VM,vm_reg_delete_instance,NULL));
1095    }
1096    
1097    /* Save configurations of all VM instances */
1098    static void vm_reg_save_config(registry_entry_t *entry,void *opt,int *err)
1099    {
1100       vm_instance_t *vm = entry->data;
1101       FILE *fd = opt;
1102      
1103       vm_save_config(vm,fd);
1104    
1105       /* Save specific platform options */
1106       if (vm->platform->save_config != NULL)
1107          vm->platform->save_config(vm,fd);
1108    }
1109    
1110    /* Save all VM configs */
1111    int vm_save_config_all(FILE *fd)
1112    {  
1113       registry_foreach_type(OBJ_TYPE_VM,vm_reg_save_config,fd,NULL);
1114       return(0);
1115  }  }

Legend:
Removed from v.8  
changed lines
  Added in v.11

  ViewVC Help
Powered by ViewVC 1.1.26