?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
allow '-nics 0'
[qemu.git] / vl.c
blob18f957dccf438f5f52498f125483b7ac3475a881
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "vl.h"
25
26 #include <getopt.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <signal.h>
30 #include <time.h>
31 #include <errno.h>
32 #include <sys/time.h>
33
34 #ifndef _WIN32
35 #include <sys/times.h>
36 #include <sys/wait.h>
37 #include <termios.h>
38 #include <sys/poll.h>
39 #include <sys/mman.h>
40 #include <sys/ioctl.h>
41 #include <sys/socket.h>
42 #ifdef _BSD
43 #include <sys/stat.h>
44 #include <libutil.h>
45 #else
46 #include <linux/if.h>
47 #include <linux/if_tun.h>
48 #include <pty.h>
49 #include <malloc.h>
50 #include <linux/rtc.h>
51 #endif
52 #endif
53
54 #if defined(CONFIG_SLIRP)
55 #include "libslirp.h"
56 #endif
57
58 #ifdef _WIN32
59 #include <malloc.h>
60 #include <sys/timeb.h>
61 #include <windows.h>
62 #define getopt_long_only getopt_long
63 #define memalign(align, size) malloc(size)
64 #endif
65
66 #ifdef CONFIG_SDL
67 #if defined(__linux__)
68 /* SDL use the pthreads and they modify sigaction. We don't
69 want that. */
70 #if (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 2))
71 extern void __libc_sigaction();
72 #define sigaction(sig, act, oact) __libc_sigaction(sig, act, oact)
73 #else
74 extern void __sigaction();
75 #define sigaction(sig, act, oact) __sigaction(sig, act, oact)
76 #endif
77 #endif /* __linux__ */
78 #endif /* CONFIG_SDL */
79
80 #include "disas.h"
81
82 #include "exec-all.h"
83
84 //#define DO_TB_FLUSH
85
86 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
87
88 //#define DEBUG_UNUSED_IOPORT
89 //#define DEBUG_IOPORT
90
91 #if !defined(CONFIG_SOFTMMU)
92 #define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)
93 #else
94 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
95 #endif
96
97 /* in ms */
98 #define GUI_REFRESH_INTERVAL 30
99
100 /* XXX: use a two level table to limit memory usage */
101 #define MAX_IOPORTS 65536
102
103 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
104 char phys_ram_file[1024];
105 CPUState *global_env;
106 CPUState *cpu_single_env;
107 void *ioport_opaque[MAX_IOPORTS];
108 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
109 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
110 BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD];
111 int vga_ram_size;
112 static DisplayState display_state;
113 int nographic;
114 int64_t ticks_per_sec;
115 int boot_device = 'c';
116 static int ram_size;
117 static char network_script[1024];
118 int pit_min_timer_count = 0;
119 int nb_nics;
120 NetDriverState nd_table[MAX_NICS];
121 SerialState *serial_console;
122 QEMUTimer *gui_timer;
123 int vm_running;
124 int audio_enabled = 0;
125
126 /***********************************************************/
127 /* x86 ISA bus support */
128
129 target_phys_addr_t isa_mem_base = 0;
130
131 uint32_t default_ioport_readb(void *opaque, uint32_t address)
132 {
133 #ifdef DEBUG_UNUSED_IOPORT
134 fprintf(stderr, "inb: port=0x%04x\n", address);
135 #endif
136 return 0xff;
137 }
138
139 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
140 {
141 #ifdef DEBUG_UNUSED_IOPORT
142 fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
143 #endif
144 }
145
146 /* default is to make two byte accesses */
147 uint32_t default_ioport_readw(void *opaque, uint32_t address)
148 {
149 uint32_t data;
150 data = ioport_read_table[0][address](ioport_opaque[address], address);
151 address = (address + 1) & (MAX_IOPORTS - 1);
152 data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
153 return data;
154 }
155
156 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
157 {
158 ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
159 address = (address + 1) & (MAX_IOPORTS - 1);
160 ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
161 }
162
163 uint32_t default_ioport_readl(void *opaque, uint32_t address)
164 {
165 #ifdef DEBUG_UNUSED_IOPORT
166 fprintf(stderr, "inl: port=0x%04x\n", address);
167 #endif
168 return 0xffffffff;
169 }
170
171 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
172 {
173 #ifdef DEBUG_UNUSED_IOPORT
174 fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
175 #endif
176 }
177
178 void init_ioports(void)
179 {
180 int i;
181
182 for(i = 0; i < MAX_IOPORTS; i++) {
183 ioport_read_table[0][i] = default_ioport_readb;
184 ioport_write_table[0][i] = default_ioport_writeb;
185 ioport_read_table[1][i] = default_ioport_readw;
186 ioport_write_table[1][i] = default_ioport_writew;
187 ioport_read_table[2][i] = default_ioport_readl;
188 ioport_write_table[2][i] = default_ioport_writel;
189 }
190 }
191
192 /* size is the word size in byte */
193 int register_ioport_read(int start, int length, int size,
194 IOPortReadFunc *func, void *opaque)
195 {
196 int i, bsize;
197
198 if (size == 1) {
199 bsize = 0;
200 } else if (size == 2) {
201 bsize = 1;
202 } else if (size == 4) {
203 bsize = 2;
204 } else {
205 hw_error("register_ioport_read: invalid size");
206 return -1;
207 }
208 for(i = start; i < start + length; i += size) {
209 ioport_read_table[bsize][i] = func;
210 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
211 hw_error("register_ioport_read: invalid opaque");
212 ioport_opaque[i] = opaque;
213 }
214 return 0;
215 }
216
217 /* size is the word size in byte */
218 int register_ioport_write(int start, int length, int size,
219 IOPortWriteFunc *func, void *opaque)
220 {
221 int i, bsize;
222
223 if (size == 1) {
224 bsize = 0;
225 } else if (size == 2) {
226 bsize = 1;
227 } else if (size == 4) {
228 bsize = 2;
229 } else {
230 hw_error("register_ioport_write: invalid size");
231 return -1;
232 }
233 for(i = start; i < start + length; i += size) {
234 ioport_write_table[bsize][i] = func;
235 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
236 hw_error("register_ioport_read: invalid opaque");
237 ioport_opaque[i] = opaque;
238 }
239 return 0;
240 }
241
242 void pstrcpy(char *buf, int buf_size, const char *str)
243 {
244 int c;
245 char *q = buf;
246
247 if (buf_size <= 0)
248 return;
249
250 for(;;) {
251 c = *str++;
252 if (c == 0 || q >= buf + buf_size - 1)
253 break;
254 *q++ = c;
255 }
256 *q = '\0';
257 }
258
259 /* strcat and truncate. */
260 char *pstrcat(char *buf, int buf_size, const char *s)
261 {
262 int len;
263 len = strlen(buf);
264 if (len < buf_size)
265 pstrcpy(buf + len, buf_size - len, s);
266 return buf;
267 }
268
269 /* return the size or -1 if error */
270 int load_image(const char *filename, uint8_t *addr)
271 {
272 int fd, size;
273 fd = open(filename, O_RDONLY | O_BINARY);
274 if (fd < 0)
275 return -1;
276 size = lseek(fd, 0, SEEK_END);
277 lseek(fd, 0, SEEK_SET);
278 if (read(fd, addr, size) != size) {
279 close(fd);
280 return -1;
281 }
282 close(fd);
283 return size;
284 }
285
286 void cpu_outb(CPUState *env, int addr, int val)
287 {
288 #ifdef DEBUG_IOPORT
289 if (loglevel & CPU_LOG_IOPORT)
290 fprintf(logfile, "outb: %04x %02x\n", addr, val);
291 #endif
292 ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
293 }
294
295 void cpu_outw(CPUState *env, int addr, int val)
296 {
297 #ifdef DEBUG_IOPORT
298 if (loglevel & CPU_LOG_IOPORT)
299 fprintf(logfile, "outw: %04x %04x\n", addr, val);
300 #endif
301 ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
302 }
303
304 void cpu_outl(CPUState *env, int addr, int val)
305 {
306 #ifdef DEBUG_IOPORT
307 if (loglevel & CPU_LOG_IOPORT)
308 fprintf(logfile, "outl: %04x %08x\n", addr, val);
309 #endif
310 ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
311 }
312
313 int cpu_inb(CPUState *env, int addr)
314 {
315 int val;
316 val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
317 #ifdef DEBUG_IOPORT
318 if (loglevel & CPU_LOG_IOPORT)
319 fprintf(logfile, "inb : %04x %02x\n", addr, val);
320 #endif
321 return val;
322 }
323
324 int cpu_inw(CPUState *env, int addr)
325 {
326 int val;
327 val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
328 #ifdef DEBUG_IOPORT
329 if (loglevel & CPU_LOG_IOPORT)
330 fprintf(logfile, "inw : %04x %04x\n", addr, val);
331 #endif
332 return val;
333 }
334
335 int cpu_inl(CPUState *env, int addr)
336 {
337 int val;
338 val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
339 #ifdef DEBUG_IOPORT
340 if (loglevel & CPU_LOG_IOPORT)
341 fprintf(logfile, "inl : %04x %08x\n", addr, val);
342 #endif
343 return val;
344 }
345
346 /***********************************************************/
347 void hw_error(const char *fmt, ...)
348 {
349 va_list ap;
350
351 va_start(ap, fmt);
352 fprintf(stderr, "qemu: hardware error: ");
353 vfprintf(stderr, fmt, ap);
354 fprintf(stderr, "\n");
355 #ifdef TARGET_I386
356 cpu_x86_dump_state(global_env, stderr, X86_DUMP_FPU | X86_DUMP_CCOP);
357 #else
358 cpu_dump_state(global_env, stderr, 0);
359 #endif
360 va_end(ap);
361 abort();
362 }
363
364 /***********************************************************/
365 /* timers */
366
367 #if defined(__powerpc__)
368
369 static inline uint32_t get_tbl(void)
370 {
371 uint32_t tbl;
372 asm volatile("mftb %0" : "=r" (tbl));
373 return tbl;
374 }
375
376 static inline uint32_t get_tbu(void)
377 {
378 uint32_t tbl;
379 asm volatile("mftbu %0" : "=r" (tbl));
380 return tbl;
381 }
382
383 int64_t cpu_get_real_ticks(void)
384 {
385 uint32_t l, h, h1;
386 /* NOTE: we test if wrapping has occurred */
387 do {
388 h = get_tbu();
389 l = get_tbl();
390 h1 = get_tbu();
391 } while (h != h1);
392 return ((int64_t)h << 32) | l;
393 }
394
395 #elif defined(__i386__)
396
397 int64_t cpu_get_real_ticks(void)
398 {
399 int64_t val;
400 asm volatile ("rdtsc" : "=A" (val));
401 return val;
402 }
403
404 #elif defined(__x86_64__)
405
406 int64_t cpu_get_real_ticks(void)
407 {
408 uint32_t low,high;
409 int64_t val;
410 asm volatile("rdtsc" : "=a" (low), "=d" (high));
411 val = high;
412 val <<= 32;
413 val |= low;
414 return val;
415 }
416
417 #else
418 #error unsupported CPU
419 #endif
420
421 static int64_t cpu_ticks_offset;
422 static int cpu_ticks_enabled;
423
424 static inline int64_t cpu_get_ticks(void)
425 {
426 if (!cpu_ticks_enabled) {
427 return cpu_ticks_offset;
428 } else {
429 return cpu_get_real_ticks() + cpu_ticks_offset;
430 }
431 }
432
433 /* enable cpu_get_ticks() */
434 void cpu_enable_ticks(void)
435 {
436 if (!cpu_ticks_enabled) {
437 cpu_ticks_offset -= cpu_get_real_ticks();
438 cpu_ticks_enabled = 1;
439 }
440 }
441
442 /* disable cpu_get_ticks() : the clock is stopped. You must not call
443 cpu_get_ticks() after that. */
444 void cpu_disable_ticks(void)
445 {
446 if (cpu_ticks_enabled) {
447 cpu_ticks_offset = cpu_get_ticks();
448 cpu_ticks_enabled = 0;
449 }
450 }
451
452 static int64_t get_clock(void)
453 {
454 #ifdef _WIN32
455 struct _timeb tb;
456 _ftime(&tb);
457 return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000;
458 #else
459 struct timeval tv;
460 gettimeofday(&tv, NULL);
461 return tv.tv_sec * 1000000LL + tv.tv_usec;
462 #endif
463 }
464
465 void cpu_calibrate_ticks(void)
466 {
467 int64_t usec, ticks;
468
469 usec = get_clock();
470 ticks = cpu_get_real_ticks();
471 #ifdef _WIN32
472 Sleep(50);
473 #else
474 usleep(50 * 1000);
475 #endif
476 usec = get_clock() - usec;
477 ticks = cpu_get_real_ticks() - ticks;
478 ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;
479 }
480
481 /* compute with 96 bit intermediate result: (a*b)/c */
482 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
483 {
484 union {
485 uint64_t ll;
486 struct {
487 #ifdef WORDS_BIGENDIAN
488 uint32_t high, low;
489 #else
490 uint32_t low, high;
491 #endif
492 } l;
493 } u, res;
494 uint64_t rl, rh;
495
496 u.ll = a;
497 rl = (uint64_t)u.l.low * (uint64_t)b;
498 rh = (uint64_t)u.l.high * (uint64_t)b;
499 rh += (rl >> 32);
500 res.l.high = rh / c;
501 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
502 return res.ll;
503 }
504
505 #define QEMU_TIMER_REALTIME 0
506 #define QEMU_TIMER_VIRTUAL 1
507
508 struct QEMUClock {
509 int type;
510 /* XXX: add frequency */
511 };
512
513 struct QEMUTimer {
514 QEMUClock *clock;
515 int64_t expire_time;
516 QEMUTimerCB *cb;
517 void *opaque;
518 struct QEMUTimer *next;
519 };
520
521 QEMUClock *rt_clock;
522 QEMUClock *vm_clock;
523
524 static QEMUTimer *active_timers[2];
525 #ifdef _WIN32
526 static MMRESULT timerID;
527 #else
528 /* frequency of the times() clock tick */
529 static int timer_freq;
530 #endif
531
532 QEMUClock *qemu_new_clock(int type)
533 {
534 QEMUClock *clock;
535 clock = qemu_mallocz(sizeof(QEMUClock));
536 if (!clock)
537 return NULL;
538 clock->type = type;
539 return clock;
540 }
541
542 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
543 {
544 QEMUTimer *ts;
545
546 ts = qemu_mallocz(sizeof(QEMUTimer));
547 ts->clock = clock;
548 ts->cb = cb;
549 ts->opaque = opaque;
550 return ts;
551 }
552
553 void qemu_free_timer(QEMUTimer *ts)
554 {
555 qemu_free(ts);
556 }
557
558 /* stop a timer, but do not dealloc it */
559 void qemu_del_timer(QEMUTimer *ts)
560 {
561 QEMUTimer **pt, *t;
562
563 /* NOTE: this code must be signal safe because
564 qemu_timer_expired() can be called from a signal. */
565 pt = &active_timers[ts->clock->type];
566 for(;;) {
567 t = *pt;
568 if (!t)
569 break;
570 if (t == ts) {
571 *pt = t->next;
572 break;
573 }
574 pt = &t->next;
575 }
576 }
577
578 /* modify the current timer so that it will be fired when current_time
579 >= expire_time. The corresponding callback will be called. */
580 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
581 {
582 QEMUTimer **pt, *t;
583
584 qemu_del_timer(ts);
585
586 /* add the timer in the sorted list */
587 /* NOTE: this code must be signal safe because
588 qemu_timer_expired() can be called from a signal. */
589 pt = &active_timers[ts->clock->type];
590 for(;;) {
591 t = *pt;
592 if (!t)
593 break;
594 if (t->expire_time > expire_time)
595 break;
596 pt = &t->next;
597 }
598 ts->expire_time = expire_time;
599 ts->next = *pt;
600 *pt = ts;
601 }
602
603 int qemu_timer_pending(QEMUTimer *ts)
604 {
605 QEMUTimer *t;
606 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
607 if (t == ts)
608 return 1;
609 }
610 return 0;
611 }
612
613 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
614 {
615 if (!timer_head)
616 return 0;
617 return (timer_head->expire_time <= current_time);
618 }
619
620 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
621 {
622 QEMUTimer *ts;
623
624 for(;;) {
625 ts = *ptimer_head;
626 if (ts->expire_time > current_time)
627 break;
628 /* remove timer from the list before calling the callback */
629 *ptimer_head = ts->next;
630 ts->next = NULL;
631
632 /* run the callback (the timer list can be modified) */
633 ts->cb(ts->opaque);
634 }
635 }
636
637 int64_t qemu_get_clock(QEMUClock *clock)
638 {
639 switch(clock->type) {
640 case QEMU_TIMER_REALTIME:
641 #ifdef _WIN32
642 return GetTickCount();
643 #else
644 {
645 struct tms tp;
646
647 /* Note that using gettimeofday() is not a good solution
648 for timers because its value change when the date is
649 modified. */
650 if (timer_freq == 100) {
651 return times(&tp) * 10;
652 } else {
653 return ((int64_t)times(&tp) * 1000) / timer_freq;
654 }
655 }
656 #endif
657 default:
658 case QEMU_TIMER_VIRTUAL:
659 return cpu_get_ticks();
660 }
661 }
662
663 /* save a timer */
664 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
665 {
666 uint64_t expire_time;
667
668 if (qemu_timer_pending(ts)) {
669 expire_time = ts->expire_time;
670 } else {
671 expire_time = -1;
672 }
673 qemu_put_be64(f, expire_time);
674 }
675
676 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
677 {
678 uint64_t expire_time;
679
680 expire_time = qemu_get_be64(f);
681 if (expire_time != -1) {
682 qemu_mod_timer(ts, expire_time);
683 } else {
684 qemu_del_timer(ts);
685 }
686 }
687
688 static void timer_save(QEMUFile *f, void *opaque)
689 {
690 if (cpu_ticks_enabled) {
691 hw_error("cannot save state if virtual timers are running");
692 }
693 qemu_put_be64s(f, &cpu_ticks_offset);
694 qemu_put_be64s(f, &ticks_per_sec);
695 }
696
697 static int timer_load(QEMUFile *f, void *opaque, int version_id)
698 {
699 if (version_id != 1)
700 return -EINVAL;
701 if (cpu_ticks_enabled) {
702 return -EINVAL;
703 }
704 qemu_get_be64s(f, &cpu_ticks_offset);
705 qemu_get_be64s(f, &ticks_per_sec);
706 return 0;
707 }
708
709 #ifdef _WIN32
710 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
711 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
712 #else
713 static void host_alarm_handler(int host_signum)
714 #endif
715 {
716 if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
717 qemu_get_clock(vm_clock)) ||
718 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
719 qemu_get_clock(rt_clock))) {
720 /* stop the cpu because a timer occured */
721 cpu_interrupt(global_env, CPU_INTERRUPT_EXIT);
722 }
723 }
724
725 #ifndef _WIN32
726
727 #define RTC_FREQ 1024
728
729 static int rtc_fd;
730
731 static int start_rtc_timer(void)
732 {
733 rtc_fd = open("/dev/rtc", O_RDONLY);
734 if (rtc_fd < 0)
735 return -1;
736 if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
737 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
738 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
739 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
740 goto fail;
741 }
742 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
743 fail:
744 close(rtc_fd);
745 return -1;
746 }
747 pit_min_timer_count = PIT_FREQ / RTC_FREQ;
748 return 0;
749 }
750
751 #endif
752
753 static void init_timers(void)
754 {
755 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
756 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
757
758 #ifdef _WIN32
759 {
760 int count=0;
761 timerID = timeSetEvent(10, // interval (ms)
762 0, // resolution
763 host_alarm_handler, // function
764 (DWORD)&count, // user parameter
765 TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
766 if( !timerID ) {
767 perror("failed timer alarm");
768 exit(1);
769 }
770 }
771 pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
772 #else
773 {
774 struct sigaction act;
775 struct itimerval itv;
776
777 /* get times() syscall frequency */
778 timer_freq = sysconf(_SC_CLK_TCK);
779
780 /* timer signal */
781 sigfillset(&act.sa_mask);
782 act.sa_flags = 0;
783 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
784 act.sa_flags |= SA_ONSTACK;
785 #endif
786 act.sa_handler = host_alarm_handler;
787 sigaction(SIGALRM, &act, NULL);
788
789 itv.it_interval.tv_sec = 0;
790 itv.it_interval.tv_usec = 1000;
791 itv.it_value.tv_sec = 0;
792 itv.it_value.tv_usec = 10 * 1000;
793 setitimer(ITIMER_REAL, &itv, NULL);
794 /* we probe the tick duration of the kernel to inform the user if
795 the emulated kernel requested a too high timer frequency */
796 getitimer(ITIMER_REAL, &itv);
797
798 if (itv.it_interval.tv_usec > 1000) {
799 /* try to use /dev/rtc to have a faster timer */
800 if (start_rtc_timer() < 0)
801 goto use_itimer;
802 /* disable itimer */
803 itv.it_interval.tv_sec = 0;
804 itv.it_interval.tv_usec = 0;
805 itv.it_value.tv_sec = 0;
806 itv.it_value.tv_usec = 0;
807 setitimer(ITIMER_REAL, &itv, NULL);
808
809 /* use the RTC */
810 sigaction(SIGIO, &act, NULL);
811 fcntl(rtc_fd, F_SETFL, O_ASYNC);
812 fcntl(rtc_fd, F_SETOWN, getpid());
813 } else {
814 use_itimer:
815 pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
816 PIT_FREQ) / 1000000;
817 }
818 }
819 #endif
820 }
821
822 void quit_timers(void)
823 {
824 #ifdef _WIN32
825 timeKillEvent(timerID);
826 #endif
827 }
828
829 /***********************************************************/
830 /* serial device */
831
832 #ifdef _WIN32
833
834 int serial_open_device(void)
835 {
836 return -1;
837 }
838
839 #else
840
841 int serial_open_device(void)
842 {
843 char slave_name[1024];
844 int master_fd, slave_fd;
845
846 if (serial_console == NULL && nographic) {
847 /* use console for serial port */
848 return 0;
849 } else {
850 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
851 fprintf(stderr, "warning: could not create pseudo terminal for serial port\n");
852 return -1;
853 }
854 fprintf(stderr, "Serial port redirected to %s\n", slave_name);
855 return master_fd;
856 }
857 }
858
859 #endif
860
861 /***********************************************************/
862 /* Linux network device redirectors */
863
864 void hex_dump(FILE *f, const uint8_t *buf, int size)
865 {
866 int len, i, j, c;
867
868 for(i=0;i<size;i+=16) {
869 len = size - i;
870 if (len > 16)
871 len = 16;
872 fprintf(f, "%08x ", i);
873 for(j=0;j<16;j++) {
874 if (j < len)
875 fprintf(f, " %02x", buf[i+j]);
876 else
877 fprintf(f, " ");
878 }
879 fprintf(f, " ");
880 for(j=0;j<len;j++) {
881 c = buf[i+j];
882 if (c < ' ' || c > '~')
883 c = '.';
884 fprintf(f, "%c", c);
885 }
886 fprintf(f, "\n");
887 }
888 }
889
890 void qemu_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
891 {
892 nd->send_packet(nd, buf, size);
893 }
894
895 void qemu_add_read_packet(NetDriverState *nd, IOCanRWHandler *fd_can_read,
896 IOReadHandler *fd_read, void *opaque)
897 {
898 nd->add_read_packet(nd, fd_can_read, fd_read, opaque);
899 }
900
901 /* dummy network adapter */
902
903 static void dummy_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
904 {
905 }
906
907 static void dummy_add_read_packet(NetDriverState *nd,
908 IOCanRWHandler *fd_can_read,
909 IOReadHandler *fd_read, void *opaque)
910 {
911 }
912
913 static int net_dummy_init(NetDriverState *nd)
914 {
915 nd->send_packet = dummy_send_packet;
916 nd->add_read_packet = dummy_add_read_packet;
917 pstrcpy(nd->ifname, sizeof(nd->ifname), "dummy");
918 return 0;
919 }
920
921 #if defined(CONFIG_SLIRP)
922
923 /* slirp network adapter */
924
925 static void *slirp_fd_opaque;
926 static IOCanRWHandler *slirp_fd_can_read;
927 static IOReadHandler *slirp_fd_read;
928 static int slirp_inited;
929
930 int slirp_can_output(void)
931 {
932 return slirp_fd_can_read(slirp_fd_opaque);
933 }
934
935 void slirp_output(const uint8_t *pkt, int pkt_len)
936 {
937 #if 0
938 printf("output:\n");
939 hex_dump(stdout, pkt, pkt_len);
940 #endif
941 slirp_fd_read(slirp_fd_opaque, pkt, pkt_len);
942 }
943
944 static void slirp_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
945 {
946 #if 0
947 printf("input:\n");
948 hex_dump(stdout, buf, size);
949 #endif
950 slirp_input(buf, size);
951 }
952
953 static void slirp_add_read_packet(NetDriverState *nd,
954 IOCanRWHandler *fd_can_read,
955 IOReadHandler *fd_read, void *opaque)
956 {
957 slirp_fd_opaque = opaque;
958 slirp_fd_can_read = fd_can_read;
959 slirp_fd_read = fd_read;
960 }
961
962 static int net_slirp_init(NetDriverState *nd)
963 {
964 if (!slirp_inited) {
965 slirp_inited = 1;
966 slirp_init();
967 }
968 nd->send_packet = slirp_send_packet;
969 nd->add_read_packet = slirp_add_read_packet;
970 pstrcpy(nd->ifname, sizeof(nd->ifname), "slirp");
971 return 0;
972 }
973
974 #endif /* CONFIG_SLIRP */
975
976 #if !defined(_WIN32)
977 #ifdef _BSD
978 static int tun_open(char *ifname, int ifname_size)
979 {
980 int fd;
981 char *dev;
982 struct stat s;
983
984 fd = open("/dev/tap", O_RDWR);
985 if (fd < 0) {
986 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
987 return -1;
988 }
989
990 fstat(fd, &s);
991 dev = devname(s.st_rdev, S_IFCHR);
992 pstrcpy(ifname, ifname_size, dev);
993
994 fcntl(fd, F_SETFL, O_NONBLOCK);
995 return fd;
996 }
997 #else
998 static int tun_open(char *ifname, int ifname_size)
999 {
1000 struct ifreq ifr;
1001 int fd, ret;
1002
1003 fd = open("/dev/net/tun", O_RDWR);
1004 if (fd < 0) {
1005 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
1006 return -1;
1007 }
1008 memset(&ifr, 0, sizeof(ifr));
1009 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
1010 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tun%d");
1011 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
1012 if (ret != 0) {
1013 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
1014 close(fd);
1015 return -1;
1016 }
1017 printf("Connected to host network interface: %s\n", ifr.ifr_name);
1018 pstrcpy(ifname, ifname_size, ifr.ifr_name);
1019 fcntl(fd, F_SETFL, O_NONBLOCK);
1020 return fd;
1021 }
1022 #endif
1023
1024 static void tun_send_packet(NetDriverState *nd, const uint8_t *buf, int size)
1025 {
1026 write(nd->fd, buf, size);
1027 }
1028
1029 static void tun_add_read_packet(NetDriverState *nd,
1030 IOCanRWHandler *fd_can_read,
1031 IOReadHandler *fd_read, void *opaque)
1032 {
1033 qemu_add_fd_read_handler(nd->fd, fd_can_read, fd_read, opaque);
1034 }
1035
1036 static int net_tun_init(NetDriverState *nd)
1037 {
1038 int pid, status;
1039 char *args[3];
1040 char **parg;
1041
1042 nd->fd = tun_open(nd->ifname, sizeof(nd->ifname));
1043 if (nd->fd < 0)
1044 return -1;
1045
1046 /* try to launch network init script */
1047 pid = fork();
1048 if (pid >= 0) {
1049 if (pid == 0) {
1050 parg = args;
1051 *parg++ = network_script;
1052 *parg++ = nd->ifname;
1053 *parg++ = NULL;
1054 execv(network_script, args);
1055 exit(1);
1056 }
1057 while (waitpid(pid, &status, 0) != pid);
1058 if (!WIFEXITED(status) ||
1059 WEXITSTATUS(status) != 0) {
1060 fprintf(stderr, "%s: could not launch network script\n",
1061 network_script);
1062 }
1063 }
1064 nd->send_packet = tun_send_packet;
1065 nd->add_read_packet = tun_add_read_packet;
1066 return 0;
1067 }
1068
1069 static int net_fd_init(NetDriverState *nd, int fd)
1070 {
1071 nd->fd = fd;
1072 nd->send_packet = tun_send_packet;
1073 nd->add_read_packet = tun_add_read_packet;
1074 pstrcpy(nd->ifname, sizeof(nd->ifname), "tunfd");
1075 return 0;
1076 }
1077
1078 #endif /* !_WIN32 */
1079
1080 /***********************************************************/
1081 /* dumb display */
1082
1083 #ifdef _WIN32
1084
1085 static void term_exit(void)
1086 {
1087 }
1088
1089 static void term_init(void)
1090 {
1091 }
1092
1093 #else
1094
1095 /* init terminal so that we can grab keys */
1096 static struct termios oldtty;
1097
1098 static void term_exit(void)
1099 {
1100 tcsetattr (0, TCSANOW, &oldtty);
1101 }
1102
1103 static void term_init(void)
1104 {
1105 struct termios tty;
1106
1107 tcgetattr (0, &tty);
1108 oldtty = tty;
1109
1110 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1111 |INLCR|IGNCR|ICRNL|IXON);
1112 tty.c_oflag |= OPOST;
1113 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1114 /* if graphical mode, we allow Ctrl-C handling */
1115 if (nographic)
1116 tty.c_lflag &= ~ISIG;
1117 tty.c_cflag &= ~(CSIZE|PARENB);
1118 tty.c_cflag |= CS8;
1119 tty.c_cc[VMIN] = 1;
1120 tty.c_cc[VTIME] = 0;
1121
1122 tcsetattr (0, TCSANOW, &tty);
1123
1124 atexit(term_exit);
1125
1126 fcntl(0, F_SETFL, O_NONBLOCK);
1127 }
1128
1129 #endif
1130
1131 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
1132 {
1133 }
1134
1135 static void dumb_resize(DisplayState *ds, int w, int h)
1136 {
1137 }
1138
1139 static void dumb_refresh(DisplayState *ds)
1140 {
1141 vga_update_display();
1142 }
1143
1144 void dumb_display_init(DisplayState *ds)
1145 {
1146 ds->data = NULL;
1147 ds->linesize = 0;
1148 ds->depth = 0;
1149 ds->dpy_update = dumb_update;
1150 ds->dpy_resize = dumb_resize;
1151 ds->dpy_refresh = dumb_refresh;
1152 }
1153
1154 #if !defined(CONFIG_SOFTMMU)
1155 /***********************************************************/
1156 /* cpu signal handler */
1157 static void host_segv_handler(int host_signum, siginfo_t *info,
1158 void *puc)
1159 {
1160 if (cpu_signal_handler(host_signum, info, puc))
1161 return;
1162 term_exit();
1163 abort();
1164 }
1165 #endif
1166
1167 /***********************************************************/
1168 /* I/O handling */
1169
1170 #define MAX_IO_HANDLERS 64
1171
1172 typedef struct IOHandlerRecord {
1173 int fd;
1174 IOCanRWHandler *fd_can_read;
1175 IOReadHandler *fd_read;
1176 void *opaque;
1177 /* temporary data */
1178 struct pollfd *ufd;
1179 int max_size;
1180 struct IOHandlerRecord *next;
1181 } IOHandlerRecord;
1182
1183 static IOHandlerRecord *first_io_handler;
1184
1185 int qemu_add_fd_read_handler(int fd, IOCanRWHandler *fd_can_read,
1186 IOReadHandler *fd_read, void *opaque)
1187 {
1188 IOHandlerRecord *ioh;
1189
1190 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
1191 if (!ioh)
1192 return -1;
1193 ioh->fd = fd;
1194 ioh->fd_can_read = fd_can_read;
1195 ioh->fd_read = fd_read;
1196 ioh->opaque = opaque;
1197 ioh->next = first_io_handler;
1198 first_io_handler = ioh;
1199 return 0;
1200 }
1201
1202 void qemu_del_fd_read_handler(int fd)
1203 {
1204 IOHandlerRecord **pioh, *ioh;
1205
1206 pioh = &first_io_handler;
1207 for(;;) {
1208 ioh = *pioh;
1209 if (ioh == NULL)
1210 break;
1211 if (ioh->fd == fd) {
1212 *pioh = ioh->next;
1213 break;
1214 }
1215 pioh = &ioh->next;
1216 }
1217 }
1218
1219 /***********************************************************/
1220 /* savevm/loadvm support */
1221
1222 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
1223 {
1224 fwrite(buf, 1, size, f);
1225 }
1226
1227 void qemu_put_byte(QEMUFile *f, int v)
1228 {
1229 fputc(v, f);
1230 }
1231
1232 void qemu_put_be16(QEMUFile *f, unsigned int v)
1233 {
1234 qemu_put_byte(f, v >> 8);
1235 qemu_put_byte(f, v);
1236 }
1237
1238 void qemu_put_be32(QEMUFile *f, unsigned int v)
1239 {
1240 qemu_put_byte(f, v >> 24);
1241 qemu_put_byte(f, v >> 16);
1242 qemu_put_byte(f, v >> 8);
1243 qemu_put_byte(f, v);
1244 }
1245
1246 void qemu_put_be64(QEMUFile *f, uint64_t v)
1247 {
1248 qemu_put_be32(f, v >> 32);
1249 qemu_put_be32(f, v);
1250 }
1251
1252 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
1253 {
1254 return fread(buf, 1, size, f);
1255 }
1256
1257 int qemu_get_byte(QEMUFile *f)
1258 {
1259 int v;
1260 v = fgetc(f);
1261 if (v == EOF)
1262 return 0;
1263 else
1264 return v;
1265 }
1266
1267 unsigned int qemu_get_be16(QEMUFile *f)
1268 {
1269 unsigned int v;
1270 v = qemu_get_byte(f) << 8;
1271 v |= qemu_get_byte(f);
1272 return v;
1273 }
1274
1275 unsigned int qemu_get_be32(QEMUFile *f)
1276 {
1277 unsigned int v;
1278 v = qemu_get_byte(f) << 24;
1279 v |= qemu_get_byte(f) << 16;
1280 v |= qemu_get_byte(f) << 8;
1281 v |= qemu_get_byte(f);
1282 return v;
1283 }
1284
1285 uint64_t qemu_get_be64(QEMUFile *f)
1286 {
1287 uint64_t v;
1288 v = (uint64_t)qemu_get_be32(f) << 32;
1289 v |= qemu_get_be32(f);
1290 return v;
1291 }
1292
1293 int64_t qemu_ftell(QEMUFile *f)
1294 {
1295 return ftell(f);
1296 }
1297
1298 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
1299 {
1300 if (fseek(f, pos, whence) < 0)
1301 return -1;
1302 return ftell(f);
1303 }
1304
1305 typedef struct SaveStateEntry {
1306 char idstr[256];
1307 int instance_id;
1308 int version_id;
1309 SaveStateHandler *save_state;
1310 LoadStateHandler *load_state;
1311 void *opaque;
1312 struct SaveStateEntry *next;
1313 } SaveStateEntry;
1314
1315 static SaveStateEntry *first_se;
1316
1317 int register_savevm(const char *idstr,
1318 int instance_id,
1319 int version_id,
1320 SaveStateHandler *save_state,
1321 LoadStateHandler *load_state,
1322 void *opaque)
1323 {
1324 SaveStateEntry *se, **pse;
1325
1326 se = qemu_malloc(sizeof(SaveStateEntry));
1327 if (!se)
1328 return -1;
1329 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
1330 se->instance_id = instance_id;
1331 se->version_id = version_id;
1332 se->save_state = save_state;
1333 se->load_state = load_state;
1334 se->opaque = opaque;
1335 se->next = NULL;
1336
1337 /* add at the end of list */
1338 pse = &first_se;
1339 while (*pse != NULL)
1340 pse = &(*pse)->next;
1341 *pse = se;
1342 return 0;
1343 }
1344
1345 #define QEMU_VM_FILE_MAGIC 0x5145564d
1346 #define QEMU_VM_FILE_VERSION 0x00000001
1347
1348 int qemu_savevm(const char *filename)
1349 {
1350 SaveStateEntry *se;
1351 QEMUFile *f;
1352 int len, len_pos, cur_pos, saved_vm_running, ret;
1353
1354 saved_vm_running = vm_running;
1355 vm_stop(0);
1356
1357 f = fopen(filename, "wb");
1358 if (!f) {
1359 ret = -1;
1360 goto the_end;
1361 }
1362
1363 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
1364 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
1365
1366 for(se = first_se; se != NULL; se = se->next) {
1367 /* ID string */
1368 len = strlen(se->idstr);
1369 qemu_put_byte(f, len);
1370 qemu_put_buffer(f, se->idstr, len);
1371
1372 qemu_put_be32(f, se->instance_id);
1373 qemu_put_be32(f, se->version_id);
1374
1375 /* record size: filled later */
1376 len_pos = ftell(f);
1377 qemu_put_be32(f, 0);
1378
1379 se->save_state(f, se->opaque);
1380
1381 /* fill record size */
1382 cur_pos = ftell(f);
1383 len = ftell(f) - len_pos - 4;
1384 fseek(f, len_pos, SEEK_SET);
1385 qemu_put_be32(f, len);
1386 fseek(f, cur_pos, SEEK_SET);
1387 }
1388
1389 fclose(f);
1390 ret = 0;
1391 the_end:
1392 if (saved_vm_running)
1393 vm_start();
1394 return ret;
1395 }
1396
1397 static SaveStateEntry *find_se(const char *idstr, int instance_id)
1398 {
1399 SaveStateEntry *se;
1400
1401 for(se = first_se; se != NULL; se = se->next) {
1402 if (!strcmp(se->idstr, idstr) &&
1403 instance_id == se->instance_id)
1404 return se;
1405 }
1406 return NULL;
1407 }
1408
1409 int qemu_loadvm(const char *filename)
1410 {
1411 SaveStateEntry *se;
1412 QEMUFile *f;
1413 int len, cur_pos, ret, instance_id, record_len, version_id;
1414 int saved_vm_running;
1415 unsigned int v;
1416 char idstr[256];
1417
1418 saved_vm_running = vm_running;
1419 vm_stop(0);
1420
1421 f = fopen(filename, "rb");
1422 if (!f) {
1423 ret = -1;
1424 goto the_end;
1425 }
1426
1427 v = qemu_get_be32(f);
1428 if (v != QEMU_VM_FILE_MAGIC)
1429 goto fail;
1430 v = qemu_get_be32(f);
1431 if (v != QEMU_VM_FILE_VERSION) {
1432 fail:
1433 fclose(f);
1434 ret = -1;
1435 goto the_end;
1436 }
1437 for(;;) {
1438 #if defined (DO_TB_FLUSH)
1439 tb_flush(global_env);
1440 #endif
1441 len = qemu_get_byte(f);
1442 if (feof(f))
1443 break;
1444 qemu_get_buffer(f, idstr, len);
1445 idstr[len] = '\0';
1446 instance_id = qemu_get_be32(f);
1447 version_id = qemu_get_be32(f);
1448 record_len = qemu_get_be32(f);
1449 #if 0
1450 printf("idstr=%s instance=0x%x version=%d len=%d\n",
1451 idstr, instance_id, version_id, record_len);
1452 #endif
1453 cur_pos = ftell(f);
1454 se = find_se(idstr, instance_id);
1455 if (!se) {
1456 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
1457 instance_id, idstr);
1458 } else {
1459 ret = se->load_state(f, se->opaque, version_id);
1460 if (ret < 0) {
1461 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
1462 instance_id, idstr);
1463 }
1464 }
1465 /* always seek to exact end of record */
1466 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
1467 }
1468 fclose(f);
1469 ret = 0;
1470 the_end:
1471 if (saved_vm_running)
1472 vm_start();
1473 return ret;
1474 }
1475
1476 /***********************************************************/
1477 /* cpu save/restore */
1478
1479 #if defined(TARGET_I386)
1480
1481 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
1482 {
1483 qemu_put_be32(f, (uint32_t)dt->base);
1484 qemu_put_be32(f, dt->limit);
1485 qemu_put_be32(f, dt->flags);
1486 }
1487
1488 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
1489 {
1490 dt->base = (uint8_t *)qemu_get_be32(f);
1491 dt->limit = qemu_get_be32(f);
1492 dt->flags = qemu_get_be32(f);
1493 }
1494
1495 void cpu_save(QEMUFile *f, void *opaque)
1496 {
1497 CPUState *env = opaque;
1498 uint16_t fptag, fpus, fpuc;
1499 uint32_t hflags;
1500 int i;
1501
1502 for(i = 0; i < 8; i++)
1503 qemu_put_be32s(f, &env->regs[i]);
1504 qemu_put_be32s(f, &env->eip);
1505 qemu_put_be32s(f, &env->eflags);
1506 qemu_put_be32s(f, &env->eflags);
1507 hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
1508 qemu_put_be32s(f, &hflags);
1509
1510 /* FPU */
1511 fpuc = env->fpuc;
1512 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
1513 fptag = 0;
1514 for (i=7; i>=0; i--) {
1515 fptag <<= 2;
1516 if (env->fptags[i]) {
1517 fptag |= 3;
1518 }
1519 }
1520
1521 qemu_put_be16s(f, &fpuc);
1522 qemu_put_be16s(f, &fpus);
1523 qemu_put_be16s(f, &fptag);
1524
1525 for(i = 0; i < 8; i++) {
1526 uint64_t mant;
1527 uint16_t exp;
1528 cpu_get_fp80(&mant, &exp, env->fpregs[i]);
1529 qemu_put_be64(f, mant);
1530 qemu_put_be16(f, exp);
1531 }
1532
1533 for(i = 0; i < 6; i++)
1534 cpu_put_seg(f, &env->segs[i]);
1535 cpu_put_seg(f, &env->ldt);
1536 cpu_put_seg(f, &env->tr);
1537 cpu_put_seg(f, &env->gdt);
1538 cpu_put_seg(f, &env->idt);
1539
1540 qemu_put_be32s(f, &env->sysenter_cs);
1541 qemu_put_be32s(f, &env->sysenter_esp);
1542 qemu_put_be32s(f, &env->sysenter_eip);
1543
1544 qemu_put_be32s(f, &env->cr[0]);
1545 qemu_put_be32s(f, &env->cr[2]);
1546 qemu_put_be32s(f, &env->cr[3]);
1547 qemu_put_be32s(f, &env->cr[4]);
1548
1549 for(i = 0; i < 8; i++)
1550 qemu_put_be32s(f, &env->dr[i]);
1551
1552 /* MMU */
1553 qemu_put_be32s(f, &env->a20_mask);
1554 }
1555
1556 int cpu_load(QEMUFile *f, void *opaque, int version_id)
1557 {
1558 CPUState *env = opaque;
1559 int i;
1560 uint32_t hflags;
1561 uint16_t fpus, fpuc, fptag;
1562
1563 if (version_id != 1)
1564 return -EINVAL;
1565 for(i = 0; i < 8; i++)
1566 qemu_get_be32s(f, &env->regs[i]);
1567 qemu_get_be32s(f, &env->eip);
1568 qemu_get_be32s(f, &env->eflags);
1569 qemu_get_be32s(f, &env->eflags);
1570 qemu_get_be32s(f, &hflags);
1571
1572 qemu_get_be16s(f, &fpuc);
1573 qemu_get_be16s(f, &fpus);
1574 qemu_get_be16s(f, &fptag);
1575
1576 for(i = 0; i < 8; i++) {
1577 uint64_t mant;
1578 uint16_t exp;
1579 mant = qemu_get_be64(f);
1580 exp = qemu_get_be16(f);
1581 env->fpregs[i] = cpu_set_fp80(mant, exp);
1582 }
1583
1584 env->fpuc = fpuc;
1585 env->fpstt = (fpus >> 11) & 7;
1586 env->fpus = fpus & ~0x3800;
1587 for(i = 0; i < 8; i++) {
1588 env->fptags[i] = ((fptag & 3) == 3);
1589 fptag >>= 2;
1590 }
1591
1592 for(i = 0; i < 6; i++)
1593 cpu_get_seg(f, &env->segs[i]);
1594 cpu_get_seg(f, &env->ldt);
1595 cpu_get_seg(f, &env->tr);
1596 cpu_get_seg(f, &env->gdt);
1597 cpu_get_seg(f, &env->idt);
1598
1599 qemu_get_be32s(f, &env->sysenter_cs);
1600 qemu_get_be32s(f, &env->sysenter_esp);
1601 qemu_get_be32s(f, &env->sysenter_eip);
1602
1603 qemu_get_be32s(f, &env->cr[0]);
1604 qemu_get_be32s(f, &env->cr[2]);
1605 qemu_get_be32s(f, &env->cr[3]);
1606 qemu_get_be32s(f, &env->cr[4]);
1607
1608 for(i = 0; i < 8; i++)
1609 qemu_get_be32s(f, &env->dr[i]);
1610
1611 /* MMU */
1612 qemu_get_be32s(f, &env->a20_mask);
1613
1614 /* XXX: compute hflags from scratch, except for CPL and IIF */
1615 env->hflags = hflags;
1616 tlb_flush(env, 1);
1617 return 0;
1618 }
1619
1620 #elif defined(TARGET_PPC)
1621 void cpu_save(QEMUFile *f, void *opaque)
1622 {
1623 }
1624
1625 int cpu_load(QEMUFile *f, void *opaque, int version_id)
1626 {
1627 return 0;
1628 }
1629 #else
1630
1631 #warning No CPU save/restore functions
1632
1633 #endif
1634
1635 /***********************************************************/
1636 /* ram save/restore */
1637
1638 /* we just avoid storing empty pages */
1639 static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len)
1640 {
1641 int i, v;
1642
1643 v = buf[0];
1644 for(i = 1; i < len; i++) {
1645 if (buf[i] != v)
1646 goto normal_save;
1647 }
1648 qemu_put_byte(f, 1);
1649 qemu_put_byte(f, v);
1650 return;
1651 normal_save:
1652 qemu_put_byte(f, 0);
1653 qemu_put_buffer(f, buf, len);
1654 }
1655
1656 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
1657 {
1658 int v;
1659
1660 v = qemu_get_byte(f);
1661 switch(v) {
1662 case 0:
1663 if (qemu_get_buffer(f, buf, len) != len)
1664 return -EIO;
1665 break;
1666 case 1:
1667 v = qemu_get_byte(f);
1668 memset(buf, v, len);
1669 break;
1670 default:
1671 return -EINVAL;
1672 }
1673 return 0;
1674 }
1675
1676 static void ram_save(QEMUFile *f, void *opaque)
1677 {
1678 int i;
1679 qemu_put_be32(f, phys_ram_size);
1680 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
1681 ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
1682 }
1683 }
1684
1685 static int ram_load(QEMUFile *f, void *opaque, int version_id)
1686 {
1687 int i, ret;
1688
1689 if (version_id != 1)
1690 return -EINVAL;
1691 if (qemu_get_be32(f) != phys_ram_size)
1692 return -EINVAL;
1693 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
1694 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
1695 if (ret)
1696 return ret;
1697 }
1698 return 0;
1699 }
1700
1701 /***********************************************************/
1702 /* main execution loop */
1703
1704 void gui_update(void *opaque)
1705 {
1706 display_state.dpy_refresh(&display_state);
1707 qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
1708 }
1709
1710 /* XXX: support several handlers */
1711 VMStopHandler *vm_stop_cb;
1712 VMStopHandler *vm_stop_opaque;
1713
1714 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
1715 {
1716 vm_stop_cb = cb;
1717 vm_stop_opaque = opaque;
1718 return 0;
1719 }
1720
1721 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
1722 {
1723 vm_stop_cb = NULL;
1724 }
1725
1726 void vm_start(void)
1727 {
1728 if (!vm_running) {
1729 cpu_enable_ticks();
1730 vm_running = 1;
1731 }
1732 }
1733
1734 void vm_stop(int reason)
1735 {
1736 if (vm_running) {
1737 cpu_disable_ticks();
1738 vm_running = 0;
1739 if (reason != 0) {
1740 if (vm_stop_cb) {
1741 vm_stop_cb(vm_stop_opaque, reason);
1742 }
1743 }
1744 }
1745 }
1746
1747 int main_loop(void)
1748 {
1749 #ifndef _WIN32
1750 struct pollfd ufds[MAX_IO_HANDLERS + 1], *pf;
1751 IOHandlerRecord *ioh, *ioh_next;
1752 uint8_t buf[4096];
1753 int n, max_size;
1754 #endif
1755 int ret, timeout;
1756 CPUState *env = global_env;
1757
1758 for(;;) {
1759 if (vm_running) {
1760 ret = cpu_exec(env);
1761 if (reset_requested) {
1762 ret = EXCP_INTERRUPT;
1763 break;
1764 }
1765 if (ret == EXCP_DEBUG) {
1766 vm_stop(EXCP_DEBUG);
1767 }
1768 /* if hlt instruction, we wait until the next IRQ */
1769 /* XXX: use timeout computed from timers */
1770 if (ret == EXCP_HLT)
1771 timeout = 10;
1772 else
1773 timeout = 0;
1774 } else {
1775 timeout = 10;
1776 }
1777
1778 #ifdef _WIN32
1779 if (timeout > 0)
1780 Sleep(timeout);
1781 #else
1782
1783 /* poll any events */
1784 /* XXX: separate device handlers from system ones */
1785 pf = ufds;
1786 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
1787 if (!ioh->fd_can_read) {
1788 max_size = 0;
1789 pf->fd = ioh->fd;
1790 pf->events = POLLIN;
1791 ioh->ufd = pf;
1792 pf++;
1793 } else {
1794 max_size = ioh->fd_can_read(ioh->opaque);
1795 if (max_size > 0) {
1796 if (max_size > sizeof(buf))
1797 max_size = sizeof(buf);
1798 pf->fd = ioh->fd;
1799 pf->events = POLLIN;
1800 ioh->ufd = pf;
1801 pf++;
1802 } else {
1803 ioh->ufd = NULL;
1804 }
1805 }
1806 ioh->max_size = max_size;
1807 }
1808
1809 ret = poll(ufds, pf - ufds, timeout);
1810 if (ret > 0) {
1811 /* XXX: better handling of removal */
1812 for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
1813 ioh_next = ioh->next;
1814 pf = ioh->ufd;
1815 if (pf) {
1816 if (pf->revents & POLLIN) {
1817 if (ioh->max_size == 0) {
1818 /* just a read event */
1819 ioh->fd_read(ioh->opaque, NULL, 0);
1820 } else {
1821 n = read(ioh->fd, buf, ioh->max_size);
1822 if (n >= 0) {
1823 ioh->fd_read(ioh->opaque, buf, n);
1824 } else if (errno != -EAGAIN) {
1825 ioh->fd_read(ioh->opaque, NULL, -errno);
1826 }
1827 }
1828 }
1829 }
1830 }
1831 }
1832
1833 #if defined(CONFIG_SLIRP)
1834 /* XXX: merge with poll() */
1835 if (slirp_inited) {
1836 fd_set rfds, wfds, xfds;
1837 int nfds;
1838 struct timeval tv;
1839
1840 nfds = -1;
1841 FD_ZERO(&rfds);
1842 FD_ZERO(&wfds);
1843 FD_ZERO(&xfds);
1844 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
1845 tv.tv_sec = 0;
1846 tv.tv_usec = 0;
1847 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
1848 if (ret >= 0) {
1849 slirp_select_poll(&rfds, &wfds, &xfds);
1850 }
1851 }
1852 #endif
1853
1854 #endif
1855
1856 if (vm_running) {
1857 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
1858 qemu_get_clock(vm_clock));
1859
1860 if (audio_enabled) {
1861 /* XXX: add explicit timer */
1862 SB16_run();
1863 }
1864
1865 /* run dma transfers, if any */
1866 DMA_run();
1867 }
1868
1869 /* real time timers */
1870 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
1871 qemu_get_clock(rt_clock));
1872 }
1873 cpu_disable_ticks();
1874 return ret;
1875 }
1876
1877 void help(void)
1878 {
1879 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2004 Fabrice Bellard\n"
1880 "usage: %s [options] [disk_image]\n"
1881 "\n"
1882 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
1883 "\n"
1884 "Standard options:\n"
1885 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
1886 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
1887 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
1888 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
1889 "-boot [a|b|c|d] boot on floppy (a, b), hard disk (c) or CD-ROM (d)\n"
1890 "-snapshot write to temporary files instead of disk image files\n"
1891 "-m megs set virtual RAM size to megs MB\n"
1892 "-nographic disable graphical output and redirect serial I/Os to console\n"
1893 "-enable-audio enable audio support\n"
1894 "\n"
1895 "Network options:\n"
1896 "-nics n simulate 'n' network cards [default=1]\n"
1897 "-macaddr addr set the mac address of the first interface\n"
1898 "-n script set tap/tun network init script [default=%s]\n"
1899 "-tun-fd fd use this fd as already opened tap/tun interface\n"
1900 #ifdef CONFIG_SLIRP
1901 "-user-net use user mode network stack [default if no tap/tun script]\n"
1902 #endif
1903 "-dummy-net use dummy network stack\n"
1904 "\n"
1905 "Linux boot specific:\n"
1906 "-kernel bzImage use 'bzImage' as kernel image\n"
1907 "-append cmdline use 'cmdline' as kernel command line\n"
1908 "-initrd file use 'file' as initial ram disk\n"
1909 "\n"
1910 "Debug/Expert options:\n"
1911 "-s wait gdb connection to port %d\n"
1912 "-p port change gdb connection port\n"
1913 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
1914 "-hdachs c,h,s force hard disk 0 geometry (usually qemu can guess it)\n"
1915 "-L path set the directory for the BIOS and VGA BIOS\n"
1916 #ifdef USE_CODE_COPY
1917 "-no-code-copy disable code copy acceleration\n"
1918 #endif
1919
1920 "\n"
1921 "During emulation, use C-a h to get terminal commands:\n",
1922 #ifdef CONFIG_SOFTMMU
1923 "qemu",
1924 #else
1925 "qemu-fast",
1926 #endif
1927 DEFAULT_NETWORK_SCRIPT,
1928 DEFAULT_GDBSTUB_PORT,
1929 "/tmp/qemu.log");
1930 term_print_help();
1931 #ifndef CONFIG_SOFTMMU
1932 printf("\n"
1933 "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n"
1934 "work. Please use the 'qemu' executable to have a more accurate (but slower)\n"
1935 "PC emulation.\n");
1936 #endif
1937 exit(1);
1938 }
1939
1940 struct option long_options[] = {
1941 { "initrd", 1, NULL, 0, },
1942 { "hda", 1, NULL, 0, },
1943 { "hdb", 1, NULL, 0, },
1944 { "snapshot", 0, NULL, 0, },
1945 { "hdachs", 1, NULL, 0, },
1946 { "nographic", 0, NULL, 0, },
1947 { "kernel", 1, NULL, 0, },
1948 { "append", 1, NULL, 0, },
1949 { "tun-fd", 1, NULL, 0, },
1950 { "hdc", 1, NULL, 0, },
1951 { "hdd", 1, NULL, 0, },
1952 { "cdrom", 1, NULL, 0, },
1953 { "boot", 1, NULL, 0, },
1954 { "fda", 1, NULL, 0, },
1955 { "fdb", 1, NULL, 0, },
1956 { "no-code-copy", 0, NULL, 0 },
1957 { "nics", 1, NULL, 0 },
1958 { "macaddr", 1, NULL, 0 },
1959 { "user-net", 0, NULL, 0 },
1960 { "dummy-net", 0, NULL, 0 },
1961 { "enable-audio", 0, NULL, 0 },
1962 { NULL, 0, NULL, 0 },
1963 };
1964
1965 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
1966
1967 /* this stack is only used during signal handling */
1968 #define SIGNAL_STACK_SIZE 32768
1969
1970 static uint8_t *signal_stack;
1971
1972 #endif
1973
1974 #define NET_IF_TUN 0
1975 #define NET_IF_USER 1
1976 #define NET_IF_DUMMY 2
1977
1978 int main(int argc, char **argv)
1979 {
1980 #ifdef CONFIG_GDBSTUB
1981 int use_gdbstub, gdbstub_port;
1982 #endif
1983 int c, i, long_index, has_cdrom;
1984 int snapshot, linux_boot;
1985 CPUState *env;
1986 const char *initrd_filename;
1987 const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
1988 const char *kernel_filename, *kernel_cmdline;
1989 DisplayState *ds = &display_state;
1990 int cyls, heads, secs;
1991 int start_emulation = 1;
1992 uint8_t macaddr[6];
1993 int net_if_type, nb_tun_fds, tun_fds[MAX_NICS];
1994
1995 #if !defined(CONFIG_SOFTMMU)
1996 /* we never want that malloc() uses mmap() */
1997 mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
1998 #endif
1999 initrd_filename = NULL;
2000 for(i = 0; i < MAX_FD; i++)
2001 fd_filename[i] = NULL;
2002 for(i = 0; i < MAX_DISKS; i++)
2003 hd_filename[i] = NULL;
2004 ram_size = 32 * 1024 * 1024;
2005 vga_ram_size = VGA_RAM_SIZE;
2006 pstrcpy(network_script, sizeof(network_script), DEFAULT_NETWORK_SCRIPT);
2007 #ifdef CONFIG_GDBSTUB
2008 use_gdbstub = 0;
2009 gdbstub_port = DEFAULT_GDBSTUB_PORT;
2010 #endif
2011 snapshot = 0;
2012 nographic = 0;
2013 kernel_filename = NULL;
2014 kernel_cmdline = "";
2015 has_cdrom = 1;
2016 cyls = heads = secs = 0;
2017
2018 nb_tun_fds = 0;
2019 net_if_type = -1;
2020 nb_nics = 1;
2021 /* default mac address of the first network interface */
2022 macaddr[0] = 0x52;
2023 macaddr[1] = 0x54;
2024 macaddr[2] = 0x00;
2025 macaddr[3] = 0x12;
2026 macaddr[4] = 0x34;
2027 macaddr[5] = 0x56;
2028
2029
2030 for(;;) {
2031 c = getopt_long_only(argc, argv, "hm:d:n:sp:L:S", long_options, &long_index);
2032 if (c == -1)
2033 break;
2034 switch(c) {
2035 case 0:
2036 switch(long_index) {
2037 case 0:
2038 initrd_filename = optarg;
2039 break;
2040 case 1:
2041 hd_filename[0] = optarg;
2042 break;
2043 case 2:
2044 hd_filename[1] = optarg;
2045 break;
2046 case 3:
2047 snapshot = 1;
2048 break;
2049 case 4:
2050 {
2051 const char *p;
2052 p = optarg;
2053 cyls = strtol(p, (char **)&p, 0);
2054 if (*p != ',')
2055 goto chs_fail;
2056 p++;
2057 heads = strtol(p, (char **)&p, 0);
2058 if (*p != ',')
2059 goto chs_fail;
2060 p++;
2061 secs = strtol(p, (char **)&p, 0);
2062 if (*p != '\0') {
2063 chs_fail:
2064 cyls = 0;
2065 }
2066 }
2067 break;
2068 case 5:
2069 nographic = 1;
2070 break;
2071 case 6:
2072 kernel_filename = optarg;
2073 break;
2074 case 7:
2075 kernel_cmdline = optarg;
2076 break;
2077 case 8:
2078 {
2079 const char *p;
2080 int fd;
2081 if (nb_tun_fds < MAX_NICS) {
2082 fd = strtol(optarg, (char **)&p, 0);
2083 if (*p != '\0') {
2084 fprintf(stderr, "qemu: invalid fd for network interface %d\n", nb_tun_fds);
2085 exit(1);
2086 }
2087 tun_fds[nb_tun_fds++] = fd;
2088 }
2089 }
2090 break;
2091 case 9:
2092 hd_filename[2] = optarg;
2093 has_cdrom = 0;
2094 break;
2095 case 10:
2096 hd_filename[3] = optarg;
2097 break;
2098 case 11:
2099 hd_filename[2] = optarg;
2100 has_cdrom = 1;
2101 break;
2102 case 12:
2103 boot_device = optarg[0];
2104 if (boot_device != 'a' && boot_device != 'b' &&
2105 boot_device != 'c' && boot_device != 'd') {
2106 fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
2107 exit(1);
2108 }
2109 break;
2110 case 13:
2111 fd_filename[0] = optarg;
2112 break;
2113 case 14:
2114 fd_filename[1] = optarg;
2115 break;
2116 case 15:
2117 code_copy_enabled = 0;
2118 break;
2119 case 16:
2120 nb_nics = atoi(optarg);
2121 if (nb_nics < 0 || nb_nics > MAX_NICS) {
2122 fprintf(stderr, "qemu: invalid number of network interfaces\n");
2123 exit(1);
2124 }
2125 break;
2126 case 17:
2127 {
2128 const char *p;
2129 int i;
2130 p = optarg;
2131 for(i = 0; i < 6; i++) {
2132 macaddr[i] = strtol(p, (char **)&p, 16);
2133 if (i == 5) {
2134 if (*p != '\0')
2135 goto macaddr_error;
2136 } else {
2137 if (*p != ':') {
2138 macaddr_error:
2139 fprintf(stderr, "qemu: invalid syntax for ethernet address\n");
2140 exit(1);
2141 }
2142 p++;
2143 }
2144 }
2145 }
2146 break;
2147 case 18:
2148 net_if_type = NET_IF_USER;
2149 break;
2150 case 19:
2151 net_if_type = NET_IF_DUMMY;
2152 break;
2153 case 20:
2154 audio_enabled = 1;
2155 break;
2156 }
2157 break;
2158 case 'h':
2159 help();
2160 break;
2161 case 'm':
2162 ram_size = atoi(optarg) * 1024 * 1024;
2163 if (ram_size <= 0)
2164 help();
2165 if (ram_size > PHYS_RAM_MAX_SIZE) {
2166 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
2167 PHYS_RAM_MAX_SIZE / (1024 * 1024));
2168 exit(1);
2169 }
2170 break;
2171 case 'd':
2172 {
2173 int mask;
2174 CPULogItem *item;
2175
2176 mask = cpu_str_to_log_mask(optarg);
2177 if (!mask) {
2178 printf("Log items (comma separated):\n");
2179 for(item = cpu_log_items; item->mask != 0; item++) {
2180 printf("%-10s %s\n", item->name, item->help);
2181 }
2182 exit(1);
2183 }
2184 cpu_set_log(mask);
2185 }
2186 break;
2187 case 'n':
2188 pstrcpy(network_script, sizeof(network_script), optarg);
2189 break;
2190 #ifdef CONFIG_GDBSTUB
2191 case 's':
2192 use_gdbstub = 1;
2193 break;
2194 case 'p':
2195 gdbstub_port = atoi(optarg);
2196 break;
2197 #endif
2198 case 'L':
2199 bios_dir = optarg;
2200 break;
2201 case 'S':
2202 start_emulation = 0;
2203 break;
2204 }
2205 }
2206
2207 if (optind < argc) {
2208 hd_filename[0] = argv[optind++];
2209 }
2210
2211 linux_boot = (kernel_filename != NULL);
2212
2213 if (!linux_boot && hd_filename[0] == '\0' && hd_filename[2] == '\0' &&
2214 fd_filename[0] == '\0')
2215 help();
2216
2217 /* boot to cd by default if no hard disk */
2218 if (hd_filename[0] == '\0' && boot_device == 'c') {
2219 if (fd_filename[0] != '\0')
2220 boot_device = 'a';
2221 else
2222 boot_device = 'd';
2223 }
2224
2225 #if !defined(CONFIG_SOFTMMU)
2226 /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
2227 {
2228 static uint8_t stdout_buf[4096];
2229 setvbuf(stdout, stdout_buf, _IOLBF, sizeof(stdout_buf));
2230 }
2231 #else
2232 setvbuf(stdout, NULL, _IOLBF, 0);
2233 #endif
2234
2235 /* init host network redirectors */
2236 if (net_if_type == -1) {
2237 net_if_type = NET_IF_TUN;
2238 #if defined(CONFIG_SLIRP)
2239 if (access(network_script, R_OK) < 0) {
2240 net_if_type = NET_IF_USER;
2241 }
2242 #endif
2243 }
2244
2245 for(i = 0; i < nb_nics; i++) {
2246 NetDriverState *nd = &nd_table[i];
2247 nd->index = i;
2248 /* init virtual mac address */
2249 nd->macaddr[0] = macaddr[0];
2250 nd->macaddr[1] = macaddr[1];
2251 nd->macaddr[2] = macaddr[2];
2252 nd->macaddr[3] = macaddr[3];
2253 nd->macaddr[4] = macaddr[4];
2254 nd->macaddr[5] = macaddr[5] + i;
2255 switch(net_if_type) {
2256 #if defined(CONFIG_SLIRP)
2257 case NET_IF_USER:
2258 net_slirp_init(nd);
2259 break;
2260 #endif
2261 #if !defined(_WIN32)
2262 case NET_IF_TUN:
2263 if (i < nb_tun_fds) {
2264 net_fd_init(nd, tun_fds[i]);
2265 } else {
2266 if (net_tun_init(nd) < 0)
2267 net_dummy_init(nd);
2268 }
2269 break;
2270 #endif
2271 case NET_IF_DUMMY:
2272 default:
2273 net_dummy_init(nd);
2274 break;
2275 }
2276 }
2277
2278 /* init the memory */
2279 phys_ram_size = ram_size + vga_ram_size;
2280
2281 #ifdef CONFIG_SOFTMMU
2282 #ifdef _BSD
2283 /* mallocs are always aligned on BSD. */
2284 phys_ram_base = malloc(phys_ram_size);
2285 #else
2286 phys_ram_base = memalign(TARGET_PAGE_SIZE, phys_ram_size);
2287 #endif
2288 if (!phys_ram_base) {
2289 fprintf(stderr, "Could not allocate physical memory\n");
2290 exit(1);
2291 }
2292 #else
2293 /* as we must map the same page at several addresses, we must use
2294 a fd */
2295 {
2296 const char *tmpdir;
2297
2298 tmpdir = getenv("QEMU_TMPDIR");
2299 if (!tmpdir)
2300 tmpdir = "/tmp";
2301 snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/vlXXXXXX", tmpdir);
2302 if (mkstemp(phys_ram_file) < 0) {
2303 fprintf(stderr, "Could not create temporary memory file '%s'\n",
2304 phys_ram_file);
2305 exit(1);
2306 }
2307 phys_ram_fd = open(phys_ram_file, O_CREAT | O_TRUNC | O_RDWR, 0600);
2308 if (phys_ram_fd < 0) {
2309 fprintf(stderr, "Could not open temporary memory file '%s'\n",
2310 phys_ram_file);
2311 exit(1);
2312 }
2313 ftruncate(phys_ram_fd, phys_ram_size);
2314 unlink(phys_ram_file);
2315 phys_ram_base = mmap(get_mmap_addr(phys_ram_size),
2316 phys_ram_size,
2317 PROT_WRITE | PROT_READ, MAP_SHARED | MAP_FIXED,
2318 phys_ram_fd, 0);
2319 if (phys_ram_base == MAP_FAILED) {
2320 fprintf(stderr, "Could not map physical memory\n");
2321 exit(1);
2322 }
2323 }
2324 #endif
2325
2326 /* we always create the cdrom drive, even if no disk is there */
2327 if (has_cdrom) {
2328 bs_table[2] = bdrv_new("cdrom");
2329 bdrv_set_type_hint(bs_table[2], BDRV_TYPE_CDROM);
2330 }
2331
2332 /* open the virtual block devices */
2333 for(i = 0; i < MAX_DISKS; i++) {
2334 if (hd_filename[i]) {
2335 if (!bs_table[i]) {
2336 char buf[64];
2337 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
2338 bs_table[i] = bdrv_new(buf);
2339 }
2340 if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) {
2341 fprintf(stderr, "qemu: could not open hard disk image '%s\n",
2342 hd_filename[i]);
2343 exit(1);
2344 }
2345 if (i == 0 && cyls != 0)
2346 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
2347 }
2348 }
2349
2350 /* we always create at least one floppy disk */
2351 fd_table[0] = bdrv_new("fda");
2352 bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
2353
2354 for(i = 0; i < MAX_FD; i++) {
2355 if (fd_filename[i]) {
2356 if (!fd_table[i]) {
2357 char buf[64];
2358 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
2359 fd_table[i] = bdrv_new(buf);
2360 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
2361 }
2362 if (fd_filename[i] != '\0') {
2363 if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) {
2364 fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
2365 fd_filename[i]);
2366 exit(1);
2367 }
2368 }
2369 }
2370 }
2371
2372 /* init CPU state */
2373 env = cpu_init();
2374 global_env = env;
2375 cpu_single_env = env;
2376
2377 register_savevm("timer", 0, 1, timer_save, timer_load, env);
2378 register_savevm("cpu", 0, 1, cpu_save, cpu_load, env);
2379 register_savevm("ram", 0, 1, ram_save, ram_load, NULL);
2380
2381 init_ioports();
2382 cpu_calibrate_ticks();
2383
2384 /* terminal init */
2385 if (nographic) {
2386 dumb_display_init(ds);
2387 } else {
2388 #ifdef CONFIG_SDL
2389 sdl_display_init(ds);
2390 #else
2391 dumb_display_init(ds);
2392 #endif
2393 }
2394
2395 /* setup cpu signal handlers for MMU / self modifying code handling */
2396 #if !defined(CONFIG_SOFTMMU)
2397
2398 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
2399 {
2400 stack_t stk;
2401 signal_stack = memalign(16, SIGNAL_STACK_SIZE);
2402 stk.ss_sp = signal_stack;
2403 stk.ss_size = SIGNAL_STACK_SIZE;
2404 stk.ss_flags = 0;
2405
2406 if (sigaltstack(&stk, NULL) < 0) {
2407 perror("sigaltstack");
2408 exit(1);
2409 }
2410 }
2411 #endif
2412 {
2413 struct sigaction act;
2414
2415 sigfillset(&act.sa_mask);
2416 act.sa_flags = SA_SIGINFO;
2417 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
2418 act.sa_flags |= SA_ONSTACK;
2419 #endif
2420 act.sa_sigaction = host_segv_handler;
2421 sigaction(SIGSEGV, &act, NULL);
2422 sigaction(SIGBUS, &act, NULL);
2423 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
2424 sigaction(SIGFPE, &act, NULL);
2425 #endif
2426 }
2427 #endif
2428
2429 #ifndef _WIN32
2430 {
2431 struct sigaction act;
2432 sigfillset(&act.sa_mask);
2433 act.sa_flags = 0;
2434 act.sa_handler = SIG_IGN;
2435 sigaction(SIGPIPE, &act, NULL);
2436 }
2437 #endif
2438 init_timers();
2439
2440 #if defined(TARGET_I386)
2441 pc_init(ram_size, vga_ram_size, boot_device,
2442 ds, fd_filename, snapshot,
2443 kernel_filename, kernel_cmdline, initrd_filename);
2444 #elif defined(TARGET_PPC)
2445 ppc_init(ram_size, vga_ram_size, boot_device,
2446 ds, fd_filename, snapshot,
2447 kernel_filename, kernel_cmdline, initrd_filename);
2448 #endif
2449
2450 /* launched after the device init so that it can display or not a
2451 banner */
2452 monitor_init();
2453
2454 gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
2455 qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
2456
2457 #ifdef CONFIG_GDBSTUB
2458 if (use_gdbstub) {
2459 if (gdbserver_start(gdbstub_port) < 0) {
2460 fprintf(stderr, "Could not open gdbserver socket on port %d\n",
2461 gdbstub_port);
2462 exit(1);
2463 } else {
2464 printf("Waiting gdb connection on port %d\n", gdbstub_port);
2465 }
2466 } else
2467 #endif
2468 if (start_emulation)
2469 {
2470 vm_start();
2471 }
2472 term_init();
2473 main_loop();
2474 quit_timers();
2475 return 0;
2476 }
QEmu