![[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: /*
2: * Cisco 7200 (Predator) simulation platform.
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:
26: #include "mips64.h"
27: #include "dynamips.h"
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.