![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hv_c7200.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Dynamips Cisco Emulator] / cf|
Return to hv_c7200.c CVS log | Up to [Dynamips Cisco Emulator] / cf |
1.1 root 1: /* 1.1.1.2 ! root 2: * Cisco router simulation platform. 1.1 root 3: * Copyright (c) 2006 Christophe Fillot ([email protected]) 4: * 5: * Hypervisor C7200 routines. 6: */ 7: 8: #include <stdio.h> 9: #include <stdlib.h> 10: #include <unistd.h> 11: #include <string.h> 12: #include <sys/types.h> 13: #include <sys/stat.h> 14: #include <sys/mman.h> 15: #include <signal.h> 16: #include <fcntl.h> 17: #include <errno.h> 18: #include <assert.h> 19: #include <stdarg.h> 20: #include <sys/ioctl.h> 21: #include <sys/types.h> 22: #include <sys/socket.h> 23: #include <arpa/inet.h> 24: #include <pthread.h> 25: 1.1.1.2 ! root 26: #include "cpu.h" ! 27: #include "vm.h" 1.1 root 28: #include "device.h" 29: #include "dev_c7200.h" 30: #include "dev_vtty.h" 31: #include "utils.h" 32: #include "net.h" 33: #include "atm.h" 34: #include "frame_relay.h" 35: #include "crc.h" 36: #include "net_io.h" 37: #include "net_io_bridge.h" 38: #ifdef GEN_ETH 39: #include "gen_eth.h" 40: #endif 41: #include "registry.h" 42: #include "hypervisor.h" 43: 44: /* Create a C7200 instance */ 45: static int cmd_create(hypervisor_conn_t *conn,int argc,char *argv[]) 46: { 47: c7200_t *router; 48: 49: if (!(router = c7200_create_instance(argv[0],atoi(argv[1])))) { 50: hypervisor_send_reply(conn,HSC_ERR_CREATE,1, 51: "unable to create C7200 instance '%s'", 52: argv[0]); 53: return(-1); 54: } 55: 56: router->vm->vtty_con_type = VTTY_TYPE_NONE; 57: router->vm->vtty_aux_type = VTTY_TYPE_NONE; 58: 59: vm_release(router->vm); 60: hypervisor_send_reply(conn,HSC_INFO_OK,1,"C7200 '%s' created",argv[0]); 61: return(0); 62: } 63: 64: /* Delete a C7200 instance */ 65: static int cmd_delete(hypervisor_conn_t *conn,int argc,char *argv[]) 66: { 67: int res; 68: 69: res = c7200_delete_instance(argv[0]); 70: 71: if (res == 1) { 72: hypervisor_send_reply(conn,HSC_INFO_OK,1,"C7200 '%s' deleted",argv[0]); 73: } else { 74: hypervisor_send_reply(conn,HSC_ERR_DELETE,1, 75: "unable to delete C7200 '%s'",argv[0]); 76: } 77: 78: return(res); 79: } 80: 81: /* Set the NPE type */ 82: static int cmd_set_npe(hypervisor_conn_t *conn,int argc,char *argv[]) 83: { 84: vm_instance_t *vm; 85: 86: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 87: return(-1); 88: 89: if ((c7200_npe_set_type(VM_C7200(vm),argv[1])) == -1) { 90: vm_release(vm); 91: hypervisor_send_reply(conn,HSC_ERR_CREATE,1, 92: "unable to set NPE type for router '%s'", 93: argv[0]); 94: return(-1); 95: } 96: 97: vm_release(vm); 98: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 99: return(0); 100: } 101: 102: /* Set the Midplane type */ 103: static int cmd_set_midplane(hypervisor_conn_t *conn,int argc,char *argv[]) 104: { 105: vm_instance_t *vm; 106: 107: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 108: return(-1); 109: 110: if ((c7200_midplane_set_type(VM_C7200(vm),argv[1])) == -1) { 111: vm_release(vm); 112: hypervisor_send_reply(conn,HSC_ERR_CREATE,1, 113: "unable to set Midplane type for router '%s'", 114: argv[0]); 115: return(-1); 116: } 117: 118: vm_release(vm); 119: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 120: return(0); 121: } 122: 123: /* Set the base MAC address for the chassis */ 124: static int cmd_set_mac_addr(hypervisor_conn_t *conn,int argc,char *argv[]) 125: { 126: vm_instance_t *vm; 127: 128: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 129: return(-1); 130: 131: if ((c7200_midplane_set_mac_addr(VM_C7200(vm),argv[1])) == -1) { 132: vm_release(vm); 133: hypervisor_send_reply(conn,HSC_ERR_CREATE,1, 134: "unable to set MAC address for router '%s'", 135: argv[0]); 136: return(-1); 137: } 138: 139: vm_release(vm); 140: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 141: return(0); 142: } 143: 144: /* Start a C7200 instance */ 145: static int cmd_start(hypervisor_conn_t *conn,int argc,char *argv[]) 146: { 147: vm_instance_t *vm; 148: c7200_t *router; 149: 150: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 151: return(-1); 152: 153: router = VM_C7200(vm); 154: 155: if (router->vm->vtty_con_type == VTTY_TYPE_NONE) { 156: hypervisor_send_reply(conn,HSC_INFO_MSG,0, 157: "Warning: no console port defined for " 158: "C7200 '%s'",argv[0]); 159: } 160: 161: if (c7200_init_instance(router) == -1) { 162: vm_release(vm); 163: hypervisor_send_reply(conn,HSC_ERR_START,1, 164: "unable to start instance '%s'", 165: argv[0]); 166: return(-1); 167: } 168: 169: vm_release(vm); 170: hypervisor_send_reply(conn,HSC_INFO_OK,1,"C7200 '%s' started",argv[0]); 171: return(0); 172: } 173: 174: /* Stop a C7200 instance */ 175: static int cmd_stop(hypervisor_conn_t *conn,int argc,char *argv[]) 176: { 177: vm_instance_t *vm; 178: c7200_t *router; 179: 180: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 181: return(-1); 182: 183: router = VM_C7200(vm); 184: 185: if (c7200_stop_instance(router) == -1) { 186: vm_release(vm); 187: hypervisor_send_reply(conn,HSC_ERR_STOP,1, 188: "unable to stop instance '%s'", 189: argv[0]); 190: return(-1); 191: } 192: 193: vm_release(vm); 194: hypervisor_send_reply(conn,HSC_INFO_OK,1,"C7200 '%s' stopped",argv[0]); 195: return(0); 196: } 197: 198: /* Show PA bindings */ 199: static int cmd_pa_bindings(hypervisor_conn_t *conn,int argc,char *argv[]) 200: { 201: vm_instance_t *vm; 202: c7200_t *router; 203: char *pa_type; 204: int i; 205: 206: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 207: return(-1); 208: 209: router = VM_C7200(vm); 210: 211: for(i=0;i<C7200_MAX_PA_BAYS;i++) { 212: pa_type = c7200_pa_get_type(router,i); 213: if (pa_type) 214: hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%u: %s",i,pa_type); 215: } 216: 217: vm_release(vm); 218: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 219: return(0); 220: } 221: 222: /* Show PA NIO bindings */ 223: static int cmd_pa_nio_bindings(hypervisor_conn_t *conn,int argc,char *argv[]) 224: { 225: struct c7200_nio_binding *nb; 226: struct c7200_pa_bay *bay; 227: vm_instance_t *vm; 228: c7200_t *router; 229: u_int pa_bay; 230: 231: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 232: return(-1); 233: 234: router = VM_C7200(vm); 235: pa_bay = atoi(argv[1]); 236: 237: if (!(bay = c7200_pa_get_info(router,pa_bay))) { 238: vm_release(vm); 239: hypervisor_send_reply(conn,HSC_ERR_UNK_OBJ,1,"Invalid slot %u",pa_bay); 240: return(-1); 241: } 242: 243: for(nb=bay->nio_list;nb;nb=nb->next) 244: hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%u: %s", 245: nb->port_id,nb->nio->name); 246: 247: vm_release(vm); 248: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 249: return(0); 250: } 251: 252: /* Add a PA binding for the specified slot */ 253: static int cmd_add_pa_binding(hypervisor_conn_t *conn,int argc,char *argv[]) 254: { 255: vm_instance_t *vm; 256: c7200_t *router; 257: u_int pa_bay; 258: 259: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 260: return(-1); 261: 262: router = VM_C7200(vm); 263: pa_bay = atoi(argv[1]); 264: 265: if (c7200_pa_add_binding(router,argv[2],pa_bay) == -1) { 266: vm_release(vm); 267: hypervisor_send_reply(conn,HSC_ERR_BINDING,1, 268: "C7200 %s: unable to add PA binding for slot %u", 269: argv[0],pa_bay); 270: return(-1); 271: } 272: 273: vm_release(vm); 274: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 275: return(0); 276: } 277: 278: /* Remove a PA binding for the specified slot */ 279: static int cmd_remove_pa_binding(hypervisor_conn_t *conn,int argc,char *argv[]) 280: { 281: vm_instance_t *vm; 282: c7200_t *router; 283: u_int pa_bay; 284: 285: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 286: return(-1); 287: 288: router = VM_C7200(vm); 289: pa_bay = atoi(argv[1]); 290: 291: if (c7200_pa_remove_binding(router,pa_bay) == -1) { 292: vm_release(vm); 293: hypervisor_send_reply(conn,HSC_ERR_BINDING,1, 294: "C7200 %s: unable to remove PA binding for " 295: "slot %u",argv[0],pa_bay); 296: return(-1); 297: } 298: 299: vm_release(vm); 300: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 301: return(0); 302: } 303: 304: /* Add a NIO binding to the specified slot/port */ 305: static int cmd_add_nio_binding(hypervisor_conn_t *conn,int argc,char *argv[]) 306: { 307: u_int pa_bay,port_id; 308: vm_instance_t *vm; 309: c7200_t *router; 310: 311: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 312: return(-1); 313: 314: router = VM_C7200(vm); 315: 316: pa_bay = atoi(argv[1]); 317: port_id = atoi(argv[2]); 318: 319: if (c7200_pa_add_nio_binding(router,pa_bay,port_id,argv[3]) == -1) { 320: vm_release(vm); 321: hypervisor_send_reply(conn,HSC_ERR_BINDING,1, 322: "C7200 %s: unable to add NIO binding for " 323: "interface %u/%u",argv[0],pa_bay,port_id); 324: return(-1); 325: } 326: 327: vm_release(vm); 328: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 329: return(0); 330: } 331: 332: /* Remove a NIO binding from the specified slot/port */ 333: static int cmd_remove_nio_binding(hypervisor_conn_t *conn, 334: int argc,char *argv[]) 335: { 336: u_int pa_bay,port_id; 337: vm_instance_t *vm; 338: c7200_t *router; 339: 340: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 341: return(-1); 342: 343: router = VM_C7200(vm); 344: 345: pa_bay = atoi(argv[1]); 346: port_id = atoi(argv[2]); 347: 348: if (c7200_pa_remove_nio_binding(router,pa_bay,port_id) == -1) { 349: vm_release(vm); 350: hypervisor_send_reply(conn,HSC_ERR_BINDING,1, 351: "C7200 %s: unable to remove NIO binding for " 352: "interface %u/%u",argv[0],pa_bay,port_id); 353: return(-1); 354: } 355: 356: vm_release(vm); 357: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 358: return(0); 359: } 360: 361: /* Enable NIO of the specified slot/port */ 362: static int cmd_pa_enable_nio(hypervisor_conn_t *conn,int argc,char *argv[]) 363: { 364: u_int pa_bay,port_id; 365: vm_instance_t *vm; 366: c7200_t *router; 367: 368: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 369: return(-1); 370: 371: router = VM_C7200(vm); 372: 373: pa_bay = atoi(argv[1]); 374: port_id = atoi(argv[2]); 375: 376: if (c7200_pa_enable_nio(router,pa_bay,port_id) == -1) { 377: vm_release(vm); 378: hypervisor_send_reply(conn,HSC_ERR_BINDING,1, 379: "C7200 %s: unable to enable NIO for " 380: "interface %u/%u",argv[0],pa_bay,port_id); 381: return(-1); 382: } 383: 384: vm_release(vm); 385: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 386: return(0); 387: } 388: 389: /* Disable NIO of the specified slot/port */ 390: static int cmd_pa_disable_nio(hypervisor_conn_t *conn,int argc,char *argv[]) 391: { 392: u_int pa_bay,port_id; 393: vm_instance_t *vm; 394: c7200_t *router; 395: 396: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 397: return(-1); 398: 399: router = VM_C7200(vm); 400: 401: pa_bay = atoi(argv[1]); 402: port_id = atoi(argv[2]); 403: 404: if (c7200_pa_disable_nio(router,pa_bay,port_id) == -1) { 405: vm_release(vm); 406: hypervisor_send_reply(conn,HSC_ERR_BINDING,1, 407: "C7200 %s: unable to unset NIO for " 408: "interface %u/%u", 409: argv[0],pa_bay,port_id); 410: return(-1); 411: } 412: 413: vm_release(vm); 414: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 415: return(0); 416: } 417: 418: /* Initialize a PA while the router is running */ 419: static int cmd_pa_init_online(hypervisor_conn_t *conn,int argc,char *argv[]) 420: { 421: vm_instance_t *vm; 422: c7200_t *router; 423: u_int pa_bay; 424: 425: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 426: return(-1); 427: 428: router = VM_C7200(vm); 429: 430: pa_bay = atoi(argv[1]); 431: c7200_pa_init_online(router,pa_bay); 432: 433: vm_release(vm); 434: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 435: return(0); 436: } 437: 438: /* Stop a PA while the router is running */ 439: static int cmd_pa_stop_online(hypervisor_conn_t *conn,int argc,char *argv[]) 440: { 441: vm_instance_t *vm; 442: c7200_t *router; 443: u_int pa_bay; 444: 445: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 446: return(-1); 447: 448: router = VM_C7200(vm); 449: 450: pa_bay = atoi(argv[1]); 451: c7200_pa_stop_online(router,pa_bay); 452: 453: vm_release(vm); 454: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 455: return(0); 456: } 457: 458: /* Show C7200 hardware */ 459: static int cmd_show_hardware(hypervisor_conn_t *conn,int argc,char *argv[]) 460: { 461: vm_instance_t *vm; 462: c7200_t *router; 463: 464: if (!(vm = hypervisor_find_vm(conn,argv[0],VM_TYPE_C7200))) 465: return(-1); 466: 467: router = VM_C7200(vm); 468: c7200_show_hardware(router); 469: 470: vm_release(vm); 471: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 472: return(0); 473: } 474: 475: /* Show info about C7200 object */ 476: static void cmd_show_c7200_list(registry_entry_t *entry,void *opt,int *err) 477: { 478: hypervisor_conn_t *conn = opt; 479: vm_instance_t *vm = entry->data; 480: 481: if (vm->type == VM_TYPE_C7200) 482: hypervisor_send_reply(conn,HSC_INFO_MSG,0,"%s",entry->name); 483: } 484: 485: /* C7200 List */ 486: static int cmd_c7200_list(hypervisor_conn_t *conn,int argc,char *argv[]) 487: { 488: int err = 0; 489: registry_foreach_type(OBJ_TYPE_VM,cmd_show_c7200_list,conn,&err); 490: hypervisor_send_reply(conn,HSC_INFO_OK,1,"OK"); 491: return(0); 492: } 493: 494: /* C7200 commands */ 495: static hypervisor_cmd_t c7200_cmd_array[] = { 496: { "create", 2, 2, cmd_create, NULL }, 497: { "delete", 1, 1, cmd_delete, NULL }, 498: { "set_npe", 2, 2, cmd_set_npe, NULL }, 499: { "set_midplane", 2, 2, cmd_set_midplane, NULL }, 500: { "set_mac_addr", 2, 2, cmd_set_mac_addr, NULL }, 501: { "start", 1, 1, cmd_start, NULL }, 502: { "stop", 1, 1, cmd_stop, NULL }, 503: { "pa_bindings", 1, 1, cmd_pa_bindings, NULL }, 504: { "pa_nio_bindings", 2, 2, cmd_pa_nio_bindings, NULL }, 505: { "add_pa_binding", 3, 3, cmd_add_pa_binding, NULL }, 506: { "remove_pa_binding", 2, 2, cmd_remove_pa_binding, NULL }, 507: { "add_nio_binding", 4, 4, cmd_add_nio_binding, NULL }, 508: { "remove_nio_binding", 3, 3, cmd_remove_nio_binding, NULL }, 509: { "pa_enable_nio", 3, 3, cmd_pa_enable_nio, NULL }, 510: { "pa_disable_nio", 3, 3, cmd_pa_disable_nio, NULL }, 511: { "pa_init_online", 2, 2, cmd_pa_init_online, NULL }, 512: { "pa_stop_online", 2, 2, cmd_pa_stop_online, NULL }, 513: { "show_hardware", 1, 1, cmd_show_hardware, NULL }, 514: { "list", 0, 0, cmd_c7200_list, NULL }, 515: { NULL, -1, -1, NULL, NULL }, 516: }; 517: 518: /* Hypervisor C7200 initialization */ 519: int hypervisor_c7200_init(void) 520: { 521: hypervisor_module_t *module; 522: 523: module = hypervisor_register_module("c7200"); 524: assert(module != NULL); 525: 526: hypervisor_register_cmd_array(module,c7200_cmd_array); 527: return(0); 528: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.