![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dynamips.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 dynamips.c CVS log | Up to [Dynamips Cisco Emulator] / cf |
1.1 root 1: /*
2: * Cisco 7200 (Predator) simulation platform.
3: * Copyright (c) 2005,2006 Christophe Fillot ([email protected])
4: *
5: * Many thanks to Nicolas Szalay for his patch
6: * for the command line parsing and virtual machine
7: * settings (RAM, ROM, NVRAM, ...)
8: */
9:
10: #include <stdio.h>
11: #include <stdlib.h>
12: #include <unistd.h>
13: #include <string.h>
14: #include <sys/types.h>
15: #include <sys/stat.h>
16: #include <sys/mman.h>
17: #include <signal.h>
18: #include <fcntl.h>
19: #include <assert.h>
20:
21: #include ARCH_INC_FILE
22:
23: #include "rbtree.h"
24: #include "cp0.h"
25: #include "memory.h"
26: #include "cpu.h"
27: #include "device.h"
28: #include "mips64_exec.h"
29: #include "dev_c7200.h"
30: #include "dev_c7200_bay.h"
31: #include "dev_vtty.h"
32: #include "ptask.h"
33: #include "atm.h"
34: #include "net_io_bridge.h"
35:
36: #ifdef PROFILE
37: #include "profiler.h"
38: #endif
39:
40: /* Default name for logfile */
41: #define LOGFILE_DEFAULT_NAME "pred_log0.txt"
42:
43: /* Software version */
44: static const char *sw_version = "0.2.3b-"JIT_ARCH;
45:
46: /* Log file */
47: FILE *log_file = NULL;
48:
49: /* Instruction block trace (produces tons of logs!) */
50: int insn_itrace = 0;
51:
52: /* JIT use */
53: int jit_use = JIT_SUPPORT;
54:
55: /* VM flags */
56: volatile int vm_save_state = 0;
57: volatile int vm_running = 0;
58:
59: /* Cisco 7200 router instance */
60: c7200_t c7200_router;
61:
62: /* By default, use embedded ROM */
63: char *rom_filename = NULL;
64:
65: /* RAM size (in Mb, by default 256) */
66: u_int ram_size = 256;
67:
68: /* ROM size (in Mb, by default 4) */
69: u_int rom_size = 4;
70:
71: /* NVRAM size (in Kb, by default 128) */
72: u_int nvram_size = 128;
73:
74: /* Config register */
75: u_int conf_reg = 0x2102;
76:
77: /* Clock divisor (see cp0.c) */
78: u_int clock_divisor = 2;
79:
80: /* Port Adapter descriptions */
81: static char *pa_desc[MAX_PA_BAYS];
82: static int pa_index = 0;
83:
84: /* Console port VTTY type and parameters */
85: int vtty_con_type = VTTY_TYPE_TERM;
86: int vtty_con_tcp_port;
87:
88: /* AUX port VTTY type and parameters */
89: int vtty_aux_type = VTTY_TYPE_NONE;
90: int vtty_aux_tcp_port;
91:
92: /* Symbols */
93: rbtree_tree *sym_tree = NULL;
94:
95: /* ELF entry point */
96: m_uint32_t ios_entry_point;
97:
98: /* Symbol lookup */
99: struct symbol *sym_lookup(m_uint64_t addr)
100: {
101: return(rbtree_lookup(sym_tree,&addr));
102: }
103:
104: /* Insert a new symbol */
105: struct symbol *sym_insert(char *name,m_uint64_t addr)
106: {
107: struct symbol *sym;
108: size_t len;
109:
110: len = strlen(name);
111:
112: if (!(sym = malloc(len + sizeof(*sym))))
113: return NULL;
114:
115: memcpy(sym->name,name,len+1);
116: sym->addr = addr;
117:
118: if (rbtree_insert(sym_tree,sym,sym) == -1) {
119: free(sym);
120: return NULL;
121: }
122:
123: return sym;
124: }
125:
126: /* Symbol comparison function */
127: static int sym_compare(m_uint64_t *a1,struct symbol *sym)
128: {
129: if (*a1 > sym->addr)
130: return(1);
131:
132: if (*a1 < sym->addr)
133: return(-1);
134:
135: return(0);
136: }
137:
138: /* Create the symbol tree */
139: int sym_create_tree(void)
140: {
141: sym_tree = rbtree_create((tree_fcompare)sym_compare,NULL);
142: return(sym_tree ? 0 : -1);
143: }
144:
145: /* Generic signal handler */
146: void signal_gen_handler(int sig)
147: {
148: switch(sig) {
149: case SIGHUP:
150: insn_itrace = 1 - insn_itrace;
151: printf("Instruction block trace %sabled\n",
152: insn_itrace ? "en" : "dis");
153: break;
154:
155: case SIGQUIT:
156: /* save VM context */
157: vm_save_state = TRUE;
158: vm_running = FALSE;
159: break;
160:
161: default:
162: fprintf(stderr,"Unhandled signal %d\n",sig);
163: }
164: }
165:
166: /* Setups signals */
167: static void setup_signals(void)
168: {
169: struct sigaction act;
170:
171: memset(&act,0,sizeof(act));
172: act.sa_handler = signal_gen_handler;
173: act.sa_flags = SA_RESTART;
174: sigaction(SIGHUP,&act,NULL);
175: sigaction(SIGQUIT,&act,NULL);
176: }
177:
178: /* Load a raw image into the simulated memory */
179: int load_raw_image(cpu_mips_t *cpu,char *filename,m_uint64_t vaddr)
180: {
181: struct stat file_info;
182: size_t len,clen;
183: void *haddr;
184: FILE *bfd;
185:
186: if (!(bfd = fopen(filename,"r"))) {
187: perror("fopen");
188: return(-1);
189: }
190:
191: if (fstat(fileno(bfd),&file_info) == -1) {
192: perror("stat");
193: return(-1);
194: }
195:
196: len = file_info.st_size;
197:
198: printf("Loading RAW file '%s' at virtual address 0x%llx (size=%lu)\n",
199: filename,vaddr,(u_long)len);
200:
201: while(len > 0)
202: {
203: haddr = cpu->mem_op_lookup(cpu,vaddr);
204:
205: if (!haddr) {
206: fprintf(stderr,"load_raw_image: invalid load address 0x%llx\n",
207: vaddr);
208: return(-1);
209: }
210:
211: if (len > MIPS_MIN_PAGE_SIZE)
212: clen = MIPS_MIN_PAGE_SIZE;
213: else
214: clen = len;
215:
216: clen = fread((u_char *)haddr,clen,1,bfd);
217:
218: if (clen != 1)
219: break;
220:
221: vaddr += MIPS_MIN_PAGE_SIZE;
222: len -= clen;
223: }
224:
225: fclose(bfd);
226: return(0);
227: }
228:
229: /* Load an ELF image into the simulated memory */
230: int load_elf_image(cpu_mips_t *cpu,char *filename,m_uint32_t *entry_point)
231: {
232: m_uint64_t vaddr;
233: void *haddr;
234: Elf32_Ehdr *ehdr;
235: Elf32_Phdr *phdr;
236: Elf *img_elf;
237: size_t len,clen;
238: int i,fd;
239: FILE *bfd;
240:
241: if ((fd = open(filename,O_RDONLY)) == -1)
242: return(-1);
243:
244: if (elf_version(EV_CURRENT) == EV_NONE) {
245: fprintf(stderr,"load_elf_image: library out of date\n");
246: return(-1);
247: }
248:
249: if (!(img_elf = elf_begin(fd,ELF_C_READ,NULL))) {
250: fprintf(stderr,"load_elf_image: elf_begin: %s\n",
251: elf_errmsg(elf_errno()));
252: return(-1);
253: }
254:
255: if (!(phdr = elf32_getphdr(img_elf))) {
256: fprintf(stderr,"load_elf_image: elf32_getphdr: %s\n",
257: elf_errmsg(elf_errno()));
258: return(-1);
259: }
260:
261: ehdr = elf32_getehdr(img_elf);
262: phdr = elf32_getphdr(img_elf);
263:
264: printf("Loading ELF file '%s'...\n",filename);
265: bfd = fdopen(fd,"rb");
266:
267: if (!bfd) {
268: perror("load_elf_image: fdopen");
269: return(-1);
270: }
271:
272: for(i=0;i<ehdr->e_phnum;i++,phdr++)
273: {
274: fseek(bfd,phdr->p_offset,SEEK_SET);
275:
276: vaddr = (m_uint64_t)phdr->p_vaddr;
277: len = phdr->p_filesz;
278:
279: printf(" * Adding section at virtual address 0x%llx\n",vaddr);
280:
281: while(len > 0)
282: {
283: haddr = cpu->mem_op_lookup(cpu,vaddr);
284:
285: if (!haddr) {
286: fprintf(stderr,"load_elf_image: invalid load address 0x%llx\n",
287: vaddr);
288: return(-1);
289: }
290:
291: if (len > MIPS_MIN_PAGE_SIZE)
292: clen = MIPS_MIN_PAGE_SIZE;
293: else
294: clen = len;
295:
296: clen = fread((u_char *)haddr,clen,1,bfd);
297:
298: if (clen != 1)
299: break;
300:
301: vaddr += MIPS_MIN_PAGE_SIZE;
302: len -= clen;
303: }
304: }
305:
306: printf("ELF entry point: 0x%x\n",ehdr->e_entry);
307:
308: if (entry_point)
309: *entry_point = ehdr->e_entry;
310:
311: return(0);
312: }
313:
314: /* Load a symbol file */
315: int load_sym_file(char *filename)
316: {
317: char buffer[4096],func_name[128];
318: m_uint64_t addr;
319: char sym_type;
320: FILE *fd;
321:
322: if ((!sym_tree) && (sym_create_tree() == -1)) {
323: fprintf(stderr,"Unable to create symbol tree.\n");
324: return(-1);
325: }
326:
327: if (!(fd = fopen(filename,"r"))) {
328: perror("load_sym_file: fopen");
329: return(-1);
330: }
331:
332: while(!feof(fd)) {
333: fgets(buffer,sizeof(buffer),fd);
334:
335: if (sscanf(buffer,"%llx %c %s",&addr,&sym_type,func_name) == 3) {
336: sym_insert(func_name,addr);
337: }
338: }
339:
340: fclose(fd);
341: return(0);
342: }
343:
344: /* Display the command line use */
345: static void show_usage(int argc,char *argv[])
346: {
347: printf("Usage: %s [options] <ios_image>\n\n",argv[0]);
348:
349: printf("Available options:\n"
350: " -r <ram_size> : Set the virtual RAM size (default is %d Mb)\n"
351: " -o <rom_size> : Set the virtual ROM size (default is %d Mb)\n"
352: " -n <nvram_size> : Set the NVRAM size (default is %d Kb)\n"
353: " -l <log_file> : Set logging file (default is %s)\n"
354: " -C <cfg_file> : Import an IOS configuration file into NVRAM\n"
355: " -R <rom_file> : Load an alternate ROM (default is embedded)\n"
356: " -s <sym_file> : Load symbol file\n"
357: " -c <conf_reg> : Set the configuration register "
358: "(default is 0x%04x)\n"
359: " -m <mac_addr> : Set the MAC address of the chassis "
360: "(IOS chooses default)\n"
361: " -k <clock_div> : Set the clock divisor (default is %d)\n"
362: " -T <port> : Console is on TCP <port> "
363: "(default is on the terminal)\n"
364: " -A <port> : AUX is on TCP <port> (default is no AUX port)\n"
365: " -i : Instruction block trace, very slow\n"
366: " -j : Disable the JIT compiler, very slow\n"
367: " -t <npe_type> : Select NPE type\n"
368: " -M <midplane> : Select Midplane (\"std\" or \"vxr\")\n"
369: " -p <pa_desc> : Define a Port Adapter\n"
370: " -a <cfg_file> : Virtual ATM switch configuration file\n"
371: " -b <cfg_file> : Virtual bridge configuration file\n"
372: "\n",
373: ram_size,rom_size,nvram_size,LOGFILE_DEFAULT_NAME,
374: conf_reg,clock_divisor);
375:
376: printf("<pa_desc> format:\n"
377: " \"slot:pa_driver:netio_type{:netio_parameters}\"\n"
378: "\n");
379:
380: /* Show the possible NPE drivers */
381: c7200_npe_show_drivers();
382:
383: /* Show the possible PA drivers */
384: c7200_pa_show_drivers();
385:
386: /* Show the possible NETIO types */
387: netio_show_types();
388: }
389:
390: int main(int argc,char *argv[])
391: {
392: char *options_list = "r:o:n:c:m:l:C:ijt:p:k:T:A:a:b:s:R:M:";
393: char *log_file_name = NULL;
394: char *ios_image_name;
395: char *ios_cfg_file = NULL;
396: char *mac_addr = NULL;
397: int option;
398: cpu_mips_t *cpu0;
399: m_uint32_t rom_entry_point;
400:
401: #ifdef PROFILE
402: atexit(profiler_savestat);
403: #endif
404:
405: printf("Cisco 7200 Simulation Platform (version %s)\n",sw_version);
406: printf("Copyright (c) 2005,2006 Christophe Fillot.\n\n");
407:
408: memset(&c7200_router,0,sizeof(c7200_router));
409:
410: /* Initialize ATM code */
411: atm_init();
412:
413: /* Command line arguments : early try */
414: opterr = 0;
415:
416: while((option = getopt(argc,argv,options_list)) != -1) {
417: switch(option)
418: {
419: /* RAM size */
420: case 'r':
421: ram_size = strtol(optarg, NULL, 10);
422: printf("Virtual RAM size set to %d MB.\n",ram_size);
423: break;
424:
425: /* ROM size */
426: case 'o':
427: rom_size = strtol(optarg, NULL, 10);
428: printf("Virtual ROM size set to %d MB.\n",rom_size);
429: break;
430:
431: /* NVRAM size */
432: case 'n':
433: nvram_size = strtol(optarg, NULL, 10);
434: printf("NVRAM size set to %d KB.\n", nvram_size);
435: break;
436:
437: /* Config Register */
438: case 'c':
439: conf_reg = strtol(optarg, NULL, 0);
440: printf("Config. Register set to 0x%x.\n",conf_reg);
441: break;
442:
443: /* Set the base MAC address */
444: case 'm':
445: mac_addr = optarg;
446: printf("MAC address set to '%s'.\n",mac_addr);
447: break;
448:
449: /* Log file */
450: case 'l':
451: if (!(log_file_name = malloc(strlen(optarg)+1))) {
452: fprintf(stderr,"Unable to set log file name.\n");
453: exit(EXIT_FAILURE);
454: }
455: strcpy(log_file_name, optarg);
456: printf("Log file: writing to %s\n",log_file_name);
457: break;
458:
459: /* IOS configuration file */
460: case 'C':
461: ios_cfg_file = optarg;
462: break;
463:
464: /* Alternate ROM */
465: case 'R':
466: rom_filename = optarg;
467: break;
468:
469: /* Symbol file */
470: case 's':
471: load_sym_file(optarg);
472: break;
473:
474: /* Instruction block trace */
475: case 'i':
476: insn_itrace = TRUE;
477: break;
478:
479: /* Disable JIT */
480: case 'j':
481: jit_use = FALSE;
482: break;
483:
484: /* NPE type */
485: case 't':
486: c7200_router.npe_type = optarg;
487: break;
488:
489: /* Midplane type */
490: case 'M':
491: c7200_router.midplane_type = optarg;
492: break;
493:
494: /* PA settings */
495: case 'p':
496: if (pa_index == MAX_PA_BAYS)
497: fprintf(stderr,"All PA slots are filled.\n");
498: else
499: pa_desc[pa_index++] = optarg;
500: break;
501:
502: /* Clock divisor */
503: case 'k':
504: clock_divisor = atoi(optarg);
505:
506: if (!clock_divisor) {
507: fprintf(stderr,"Invalid Clock Divisor specified!\n");
508: exit(EXIT_FAILURE);
509: }
510:
511: printf("Using a clock divisor of %d.\n",clock_divisor);
512: break;
513:
514: /* TCP server for Console Port */
515: case 'T':
516: vtty_con_type = VTTY_TYPE_TCP;
517: vtty_con_tcp_port = atoi(optarg);
518: break;
519:
520: /* TCP server for AUX Port */
521: case 'A':
522: vtty_aux_type = VTTY_TYPE_TCP;
523: vtty_aux_tcp_port = atoi(optarg);
524: break;
525:
526: /* Virtual ATM switch */
527: case 'a':
528: if (atmsw_start(optarg) == -1)
529: exit(EXIT_FAILURE);
530: break;
531:
532: /* Virtual bridge */
533: case 'b':
534: if (netio_bridge_start(optarg) == -1)
535: exit(EXIT_FAILURE);
536: break;
537:
538: /* Oops ! */
539: case '?':
540: show_usage(argc,argv);
541: exit(EXIT_FAILURE);
542: }
543: }
544:
545: /* Last argument, this is the IOS filename */
546: if (optind == (argc - 1)) {
547: /* setting IOS image file */
548: ios_image_name = argv[optind];
549: printf("IOS image file: %s\n\n", ios_image_name);
550: } else {
551: /* IOS missing */
552: fprintf(stderr,"Please specify an IOS image filename\n");
553: show_usage(argc,argv);
554: exit(EXIT_FAILURE);
555: }
556:
557: /* Set the default value of the log file name */
558: if (!log_file_name) {
559: if (!(log_file_name = malloc(strlen(LOGFILE_DEFAULT_NAME)+1))) {
560: fprintf(stderr,"Unable to set log file name.\n");
561: exit(EXIT_FAILURE);
562: }
563: strcpy(log_file_name,LOGFILE_DEFAULT_NAME);
564: }
565:
566: if (!(log_file = fopen(log_file_name,"w"))) {
567: fprintf(stderr,"Unable to create log file.\n");
568: exit(EXIT_FAILURE);
569: }
570:
571: /* Periodic tasks initialization */
572: if (ptask_init(0) == -1)
573: exit(EXIT_FAILURE);
574:
575: /* Create instruction lookup tables */
576: mips64_jit_create_ilt();
577: mips64_exec_create_ilt();
578:
579: /* Create a CPU group */
580: sys_cpu_group = cpu_group_create("System CPU Group");
581:
582: /* Initialize the virtual MIPS processor */
583: if (!(cpu0 = cpu_create(0))) {
584: fprintf(stderr,"Unable to create CPU0!\n");
585: exit(EXIT_FAILURE);
586: }
587:
588: /* Add this CPU to the system CPU group */
589: cpu_group_add(sys_cpu_group,cpu0);
590: c7200_router.cpu_group = sys_cpu_group;
591:
592: /* Initialize the C7200 platform */
593: if (c7200_init_platform(&c7200_router,pa_desc,mac_addr) == -1) {
594: fprintf(stderr,"Unable to initialize the C7200 platform hardware.\n");
595: exit(EXIT_FAILURE);
596: }
597:
598: /* Load IOS configuration file */
599: if (ios_cfg_file != NULL) {
600: dev_nvram_push_config(sys_cpu_group,ios_cfg_file);
601: conf_reg &= ~0x40;
602: }
603:
604: /* Load ROM (ELF image or embedded) */
605: rom_entry_point = 0xbfc00000;
606:
607: if (rom_filename) {
608: if (load_elf_image(cpu0,rom_filename,&rom_entry_point) < 0) {
609: fprintf(stderr,"Unable to load alternate ROM '%s', "
610: "fallback to embedded ROM.\n\n",rom_filename);
611: rom_filename = NULL;
612: }
613: }
614:
615: /* Load IOS image */
616: if (load_elf_image(cpu0,ios_image_name,&ios_entry_point) < 0) {
617: fprintf(stderr,"Cisco IOS load failed.\n");
618: exit(EXIT_FAILURE);
619: }
620:
621: cpu0->pc = sign_extend(rom_entry_point,32);
622: cpu0->cp0.reg[MIPS_CP0_PRID] = 0x2012ULL;
623: cpu0->cp0.reg[MIPS_CP0_CONFIG] = 0x00c08ff0ULL;
624:
625: setup_signals();
626:
627: /* Launch the simulation */
628: printf("\nStarting simulation (CPU0 PC=0x%llx), JIT is %sabled.\n",
629: cpu0->pc,jit_use ? "en":"dis");
630:
631: cpu_start(cpu0);
632:
633: /* Run until all CPU of the system CPU group are halted */
634: while(!cpu_group_check_state(sys_cpu_group,MIPS_CPU_HALTED))
635: usleep(200000);
636:
637: printf("\n\nSimulation halted (CPU0 PC=0x%llx).\n\n",cpu0->pc);
638: return(0);
639: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.