?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix Thumb variable shift condition code bug.
[qemu/mini2440.git] / vl.c
blobeaa4560c7a619f03ffadb476e8c30495d6ab9049
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2005 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 <unistd.h>
27 #include <fcntl.h>
28 #include <signal.h>
29 #include <time.h>
30 #include <errno.h>
31 #include <sys/time.h>
32
33 #ifndef _WIN32
34 #include <sys/times.h>
35 #include <sys/wait.h>
36 #include <termios.h>
37 #include <sys/poll.h>
38 #include <sys/mman.h>
39 #include <sys/ioctl.h>
40 #include <sys/socket.h>
41 #include <netinet/in.h>
42 #include <dirent.h>
43 #include <netdb.h>
44 #ifdef _BSD
45 #include <sys/stat.h>
46 #ifndef __APPLE__
47 #include <libutil.h>
48 #endif
49 #else
50 #include <linux/if.h>
51 #include <linux/if_tun.h>
52 #include <pty.h>
53 #include <malloc.h>
54 #include <linux/rtc.h>
55 #include <linux/ppdev.h>
56 #endif
57 #endif
58
59 #if defined(CONFIG_SLIRP)
60 #include "libslirp.h"
61 #endif
62
63 #ifdef _WIN32
64 #include <malloc.h>
65 #include <sys/timeb.h>
66 #include <windows.h>
67 #include <winsock2.h>
68 #include <ws2tcpip.h>
69 #define getopt_long_only getopt_long
70 #define memalign(align, size) malloc(size)
71 #endif
72
73 #ifdef CONFIG_SDL
74 #ifdef __APPLE__
75 #include <SDL/SDL.h>
76 #endif
77 #endif /* CONFIG_SDL */
78
79 #ifdef CONFIG_COCOA
80 #undef main
81 #define main qemu_main
82 #endif /* CONFIG_COCOA */
83
84 #include "disas.h"
85
86 #include "exec-all.h"
87
88 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
89
90 //#define DEBUG_UNUSED_IOPORT
91 //#define DEBUG_IOPORT
92
93 #if !defined(CONFIG_SOFTMMU)
94 #define PHYS_RAM_MAX_SIZE (256 * 1024 * 1024)
95 #else
96 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
97 #endif
98
99 #ifdef TARGET_PPC
100 #define DEFAULT_RAM_SIZE 144
101 #else
102 #define DEFAULT_RAM_SIZE 128
103 #endif
104 /* in ms */
105 #define GUI_REFRESH_INTERVAL 30
106
107 /* XXX: use a two level table to limit memory usage */
108 #define MAX_IOPORTS 65536
109
110 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
111 char phys_ram_file[1024];
112 void *ioport_opaque[MAX_IOPORTS];
113 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
114 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
115 BlockDriverState *bs_table[MAX_DISKS], *fd_table[MAX_FD];
116 int vga_ram_size;
117 int bios_size;
118 static DisplayState display_state;
119 int nographic;
120 const char* keyboard_layout = NULL;
121 int64_t ticks_per_sec;
122 int boot_device = 'c';
123 int ram_size;
124 int pit_min_timer_count = 0;
125 int nb_nics;
126 NICInfo nd_table[MAX_NICS];
127 QEMUTimer *gui_timer;
128 int vm_running;
129 int rtc_utc = 1;
130 int cirrus_vga_enabled = 1;
131 #ifdef TARGET_SPARC
132 int graphic_width = 1024;
133 int graphic_height = 768;
134 #else
135 int graphic_width = 800;
136 int graphic_height = 600;
137 #endif
138 int graphic_depth = 15;
139 int full_screen = 0;
140 TextConsole *vga_console;
141 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
142 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
143 #ifdef TARGET_I386
144 int win2k_install_hack = 0;
145 #endif
146 int usb_enabled = 0;
147 USBPort *vm_usb_ports[MAX_VM_USB_PORTS];
148 USBDevice *vm_usb_hub;
149 static VLANState *first_vlan;
150 int smp_cpus = 1;
151 #if defined(TARGET_SPARC)
152 #define MAX_CPUS 16
153 #elif defined(TARGET_I386)
154 #define MAX_CPUS 255
155 #else
156 #define MAX_CPUS 1
157 #endif
158
159 /***********************************************************/
160 /* x86 ISA bus support */
161
162 target_phys_addr_t isa_mem_base = 0;
163 PicState2 *isa_pic;
164
165 uint32_t default_ioport_readb(void *opaque, uint32_t address)
166 {
167 #ifdef DEBUG_UNUSED_IOPORT
168 fprintf(stderr, "inb: port=0x%04x\n", address);
169 #endif
170 return 0xff;
171 }
172
173 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
174 {
175 #ifdef DEBUG_UNUSED_IOPORT
176 fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
177 #endif
178 }
179
180 /* default is to make two byte accesses */
181 uint32_t default_ioport_readw(void *opaque, uint32_t address)
182 {
183 uint32_t data;
184 data = ioport_read_table[0][address](ioport_opaque[address], address);
185 address = (address + 1) & (MAX_IOPORTS - 1);
186 data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
187 return data;
188 }
189
190 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
191 {
192 ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
193 address = (address + 1) & (MAX_IOPORTS - 1);
194 ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
195 }
196
197 uint32_t default_ioport_readl(void *opaque, uint32_t address)
198 {
199 #ifdef DEBUG_UNUSED_IOPORT
200 fprintf(stderr, "inl: port=0x%04x\n", address);
201 #endif
202 return 0xffffffff;
203 }
204
205 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
206 {
207 #ifdef DEBUG_UNUSED_IOPORT
208 fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
209 #endif
210 }
211
212 void init_ioports(void)
213 {
214 int i;
215
216 for(i = 0; i < MAX_IOPORTS; i++) {
217 ioport_read_table[0][i] = default_ioport_readb;
218 ioport_write_table[0][i] = default_ioport_writeb;
219 ioport_read_table[1][i] = default_ioport_readw;
220 ioport_write_table[1][i] = default_ioport_writew;
221 ioport_read_table[2][i] = default_ioport_readl;
222 ioport_write_table[2][i] = default_ioport_writel;
223 }
224 }
225
226 /* size is the word size in byte */
227 int register_ioport_read(int start, int length, int size,
228 IOPortReadFunc *func, void *opaque)
229 {
230 int i, bsize;
231
232 if (size == 1) {
233 bsize = 0;
234 } else if (size == 2) {
235 bsize = 1;
236 } else if (size == 4) {
237 bsize = 2;
238 } else {
239 hw_error("register_ioport_read: invalid size");
240 return -1;
241 }
242 for(i = start; i < start + length; i += size) {
243 ioport_read_table[bsize][i] = func;
244 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
245 hw_error("register_ioport_read: invalid opaque");
246 ioport_opaque[i] = opaque;
247 }
248 return 0;
249 }
250
251 /* size is the word size in byte */
252 int register_ioport_write(int start, int length, int size,
253 IOPortWriteFunc *func, void *opaque)
254 {
255 int i, bsize;
256
257 if (size == 1) {
258 bsize = 0;
259 } else if (size == 2) {
260 bsize = 1;
261 } else if (size == 4) {
262 bsize = 2;
263 } else {
264 hw_error("register_ioport_write: invalid size");
265 return -1;
266 }
267 for(i = start; i < start + length; i += size) {
268 ioport_write_table[bsize][i] = func;
269 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
270 hw_error("register_ioport_read: invalid opaque");
271 ioport_opaque[i] = opaque;
272 }
273 return 0;
274 }
275
276 void isa_unassign_ioport(int start, int length)
277 {
278 int i;
279
280 for(i = start; i < start + length; i++) {
281 ioport_read_table[0][i] = default_ioport_readb;
282 ioport_read_table[1][i] = default_ioport_readw;
283 ioport_read_table[2][i] = default_ioport_readl;
284
285 ioport_write_table[0][i] = default_ioport_writeb;
286 ioport_write_table[1][i] = default_ioport_writew;
287 ioport_write_table[2][i] = default_ioport_writel;
288 }
289 }
290
291 /***********************************************************/
292
293 void pstrcpy(char *buf, int buf_size, const char *str)
294 {
295 int c;
296 char *q = buf;
297
298 if (buf_size <= 0)
299 return;
300
301 for(;;) {
302 c = *str++;
303 if (c == 0 || q >= buf + buf_size - 1)
304 break;
305 *q++ = c;
306 }
307 *q = '\0';
308 }
309
310 /* strcat and truncate. */
311 char *pstrcat(char *buf, int buf_size, const char *s)
312 {
313 int len;
314 len = strlen(buf);
315 if (len < buf_size)
316 pstrcpy(buf + len, buf_size - len, s);
317 return buf;
318 }
319
320 int strstart(const char *str, const char *val, const char **ptr)
321 {
322 const char *p, *q;
323 p = str;
324 q = val;
325 while (*q != '\0') {
326 if (*p != *q)
327 return 0;
328 p++;
329 q++;
330 }
331 if (ptr)
332 *ptr = p;
333 return 1;
334 }
335
336 /* return the size or -1 if error */
337 int get_image_size(const char *filename)
338 {
339 int fd, size;
340 fd = open(filename, O_RDONLY | O_BINARY);
341 if (fd < 0)
342 return -1;
343 size = lseek(fd, 0, SEEK_END);
344 close(fd);
345 return size;
346 }
347
348 /* return the size or -1 if error */
349 int load_image(const char *filename, uint8_t *addr)
350 {
351 int fd, size;
352 fd = open(filename, O_RDONLY | O_BINARY);
353 if (fd < 0)
354 return -1;
355 size = lseek(fd, 0, SEEK_END);
356 lseek(fd, 0, SEEK_SET);
357 if (read(fd, addr, size) != size) {
358 close(fd);
359 return -1;
360 }
361 close(fd);
362 return size;
363 }
364
365 void cpu_outb(CPUState *env, int addr, int val)
366 {
367 #ifdef DEBUG_IOPORT
368 if (loglevel & CPU_LOG_IOPORT)
369 fprintf(logfile, "outb: %04x %02x\n", addr, val);
370 #endif
371 ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
372 }
373
374 void cpu_outw(CPUState *env, int addr, int val)
375 {
376 #ifdef DEBUG_IOPORT
377 if (loglevel & CPU_LOG_IOPORT)
378 fprintf(logfile, "outw: %04x %04x\n", addr, val);
379 #endif
380 ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
381 }
382
383 void cpu_outl(CPUState *env, int addr, int val)
384 {
385 #ifdef DEBUG_IOPORT
386 if (loglevel & CPU_LOG_IOPORT)
387 fprintf(logfile, "outl: %04x %08x\n", addr, val);
388 #endif
389 ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
390 }
391
392 int cpu_inb(CPUState *env, int addr)
393 {
394 int val;
395 val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
396 #ifdef DEBUG_IOPORT
397 if (loglevel & CPU_LOG_IOPORT)
398 fprintf(logfile, "inb : %04x %02x\n", addr, val);
399 #endif
400 return val;
401 }
402
403 int cpu_inw(CPUState *env, int addr)
404 {
405 int val;
406 val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
407 #ifdef DEBUG_IOPORT
408 if (loglevel & CPU_LOG_IOPORT)
409 fprintf(logfile, "inw : %04x %04x\n", addr, val);
410 #endif
411 return val;
412 }
413
414 int cpu_inl(CPUState *env, int addr)
415 {
416 int val;
417 val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
418 #ifdef DEBUG_IOPORT
419 if (loglevel & CPU_LOG_IOPORT)
420 fprintf(logfile, "inl : %04x %08x\n", addr, val);
421 #endif
422 return val;
423 }
424
425 /***********************************************************/
426 void hw_error(const char *fmt, ...)
427 {
428 va_list ap;
429 CPUState *env;
430
431 va_start(ap, fmt);
432 fprintf(stderr, "qemu: hardware error: ");
433 vfprintf(stderr, fmt, ap);
434 fprintf(stderr, "\n");
435 for(env = first_cpu; env != NULL; env = env->next_cpu) {
436 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
437 #ifdef TARGET_I386
438 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
439 #else
440 cpu_dump_state(env, stderr, fprintf, 0);
441 #endif
442 }
443 va_end(ap);
444 abort();
445 }
446
447 /***********************************************************/
448 /* keyboard/mouse */
449
450 static QEMUPutKBDEvent *qemu_put_kbd_event;
451 static void *qemu_put_kbd_event_opaque;
452 static QEMUPutMouseEvent *qemu_put_mouse_event;
453 static void *qemu_put_mouse_event_opaque;
454
455 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
456 {
457 qemu_put_kbd_event_opaque = opaque;
458 qemu_put_kbd_event = func;
459 }
460
461 void qemu_add_mouse_event_handler(QEMUPutMouseEvent *func, void *opaque)
462 {
463 qemu_put_mouse_event_opaque = opaque;
464 qemu_put_mouse_event = func;
465 }
466
467 void kbd_put_keycode(int keycode)
468 {
469 if (qemu_put_kbd_event) {
470 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
471 }
472 }
473
474 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
475 {
476 if (qemu_put_mouse_event) {
477 qemu_put_mouse_event(qemu_put_mouse_event_opaque,
478 dx, dy, dz, buttons_state);
479 }
480 }
481
482 /***********************************************************/
483 /* timers */
484
485 #if defined(__powerpc__)
486
487 static inline uint32_t get_tbl(void)
488 {
489 uint32_t tbl;
490 asm volatile("mftb %0" : "=r" (tbl));
491 return tbl;
492 }
493
494 static inline uint32_t get_tbu(void)
495 {
496 uint32_t tbl;
497 asm volatile("mftbu %0" : "=r" (tbl));
498 return tbl;
499 }
500
501 int64_t cpu_get_real_ticks(void)
502 {
503 uint32_t l, h, h1;
504 /* NOTE: we test if wrapping has occurred */
505 do {
506 h = get_tbu();
507 l = get_tbl();
508 h1 = get_tbu();
509 } while (h != h1);
510 return ((int64_t)h << 32) | l;
511 }
512
513 #elif defined(__i386__)
514
515 int64_t cpu_get_real_ticks(void)
516 {
517 int64_t val;
518 asm volatile ("rdtsc" : "=A" (val));
519 return val;
520 }
521
522 #elif defined(__x86_64__)
523
524 int64_t cpu_get_real_ticks(void)
525 {
526 uint32_t low,high;
527 int64_t val;
528 asm volatile("rdtsc" : "=a" (low), "=d" (high));
529 val = high;
530 val <<= 32;
531 val |= low;
532 return val;
533 }
534
535 #elif defined(__ia64)
536
537 int64_t cpu_get_real_ticks(void)
538 {
539 int64_t val;
540 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
541 return val;
542 }
543
544 #elif defined(__s390__)
545
546 int64_t cpu_get_real_ticks(void)
547 {
548 int64_t val;
549 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
550 return val;
551 }
552
553 #else
554 #error unsupported CPU
555 #endif
556
557 static int64_t cpu_ticks_offset;
558 static int cpu_ticks_enabled;
559
560 static inline int64_t cpu_get_ticks(void)
561 {
562 if (!cpu_ticks_enabled) {
563 return cpu_ticks_offset;
564 } else {
565 return cpu_get_real_ticks() + cpu_ticks_offset;
566 }
567 }
568
569 /* enable cpu_get_ticks() */
570 void cpu_enable_ticks(void)
571 {
572 if (!cpu_ticks_enabled) {
573 cpu_ticks_offset -= cpu_get_real_ticks();
574 cpu_ticks_enabled = 1;
575 }
576 }
577
578 /* disable cpu_get_ticks() : the clock is stopped. You must not call
579 cpu_get_ticks() after that. */
580 void cpu_disable_ticks(void)
581 {
582 if (cpu_ticks_enabled) {
583 cpu_ticks_offset = cpu_get_ticks();
584 cpu_ticks_enabled = 0;
585 }
586 }
587
588 static int64_t get_clock(void)
589 {
590 #ifdef _WIN32
591 struct _timeb tb;
592 _ftime(&tb);
593 return ((int64_t)tb.time * 1000 + (int64_t)tb.millitm) * 1000;
594 #else
595 struct timeval tv;
596 gettimeofday(&tv, NULL);
597 return tv.tv_sec * 1000000LL + tv.tv_usec;
598 #endif
599 }
600
601 void cpu_calibrate_ticks(void)
602 {
603 int64_t usec, ticks;
604
605 usec = get_clock();
606 ticks = cpu_get_real_ticks();
607 #ifdef _WIN32
608 Sleep(50);
609 #else
610 usleep(50 * 1000);
611 #endif
612 usec = get_clock() - usec;
613 ticks = cpu_get_real_ticks() - ticks;
614 ticks_per_sec = (ticks * 1000000LL + (usec >> 1)) / usec;
615 }
616
617 /* compute with 96 bit intermediate result: (a*b)/c */
618 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
619 {
620 union {
621 uint64_t ll;
622 struct {
623 #ifdef WORDS_BIGENDIAN
624 uint32_t high, low;
625 #else
626 uint32_t low, high;
627 #endif
628 } l;
629 } u, res;
630 uint64_t rl, rh;
631
632 u.ll = a;
633 rl = (uint64_t)u.l.low * (uint64_t)b;
634 rh = (uint64_t)u.l.high * (uint64_t)b;
635 rh += (rl >> 32);
636 res.l.high = rh / c;
637 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
638 return res.ll;
639 }
640
641 #define QEMU_TIMER_REALTIME 0
642 #define QEMU_TIMER_VIRTUAL 1
643
644 struct QEMUClock {
645 int type;
646 /* XXX: add frequency */
647 };
648
649 struct QEMUTimer {
650 QEMUClock *clock;
651 int64_t expire_time;
652 QEMUTimerCB *cb;
653 void *opaque;
654 struct QEMUTimer *next;
655 };
656
657 QEMUClock *rt_clock;
658 QEMUClock *vm_clock;
659
660 static QEMUTimer *active_timers[2];
661 #ifdef _WIN32
662 static MMRESULT timerID;
663 #else
664 /* frequency of the times() clock tick */
665 static int timer_freq;
666 #endif
667
668 QEMUClock *qemu_new_clock(int type)
669 {
670 QEMUClock *clock;
671 clock = qemu_mallocz(sizeof(QEMUClock));
672 if (!clock)
673 return NULL;
674 clock->type = type;
675 return clock;
676 }
677
678 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
679 {
680 QEMUTimer *ts;
681
682 ts = qemu_mallocz(sizeof(QEMUTimer));
683 ts->clock = clock;
684 ts->cb = cb;
685 ts->opaque = opaque;
686 return ts;
687 }
688
689 void qemu_free_timer(QEMUTimer *ts)
690 {
691 qemu_free(ts);
692 }
693
694 /* stop a timer, but do not dealloc it */
695 void qemu_del_timer(QEMUTimer *ts)
696 {
697 QEMUTimer **pt, *t;
698
699 /* NOTE: this code must be signal safe because
700 qemu_timer_expired() can be called from a signal. */
701 pt = &active_timers[ts->clock->type];
702 for(;;) {
703 t = *pt;
704 if (!t)
705 break;
706 if (t == ts) {
707 *pt = t->next;
708 break;
709 }
710 pt = &t->next;
711 }
712 }
713
714 /* modify the current timer so that it will be fired when current_time
715 >= expire_time. The corresponding callback will be called. */
716 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
717 {
718 QEMUTimer **pt, *t;
719
720 qemu_del_timer(ts);
721
722 /* add the timer in the sorted list */
723 /* NOTE: this code must be signal safe because
724 qemu_timer_expired() can be called from a signal. */
725 pt = &active_timers[ts->clock->type];
726 for(;;) {
727 t = *pt;
728 if (!t)
729 break;
730 if (t->expire_time > expire_time)
731 break;
732 pt = &t->next;
733 }
734 ts->expire_time = expire_time;
735 ts->next = *pt;
736 *pt = ts;
737 }
738
739 int qemu_timer_pending(QEMUTimer *ts)
740 {
741 QEMUTimer *t;
742 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
743 if (t == ts)
744 return 1;
745 }
746 return 0;
747 }
748
749 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
750 {
751 if (!timer_head)
752 return 0;
753 return (timer_head->expire_time <= current_time);
754 }
755
756 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
757 {
758 QEMUTimer *ts;
759
760 for(;;) {
761 ts = *ptimer_head;
762 if (!ts || ts->expire_time > current_time)
763 break;
764 /* remove timer from the list before calling the callback */
765 *ptimer_head = ts->next;
766 ts->next = NULL;
767
768 /* run the callback (the timer list can be modified) */
769 ts->cb(ts->opaque);
770 }
771 }
772
773 int64_t qemu_get_clock(QEMUClock *clock)
774 {
775 switch(clock->type) {
776 case QEMU_TIMER_REALTIME:
777 #ifdef _WIN32
778 return GetTickCount();
779 #else
780 {
781 struct tms tp;
782
783 /* Note that using gettimeofday() is not a good solution
784 for timers because its value change when the date is
785 modified. */
786 if (timer_freq == 100) {
787 return times(&tp) * 10;
788 } else {
789 return ((int64_t)times(&tp) * 1000) / timer_freq;
790 }
791 }
792 #endif
793 default:
794 case QEMU_TIMER_VIRTUAL:
795 return cpu_get_ticks();
796 }
797 }
798
799 /* save a timer */
800 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
801 {
802 uint64_t expire_time;
803
804 if (qemu_timer_pending(ts)) {
805 expire_time = ts->expire_time;
806 } else {
807 expire_time = -1;
808 }
809 qemu_put_be64(f, expire_time);
810 }
811
812 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
813 {
814 uint64_t expire_time;
815
816 expire_time = qemu_get_be64(f);
817 if (expire_time != -1) {
818 qemu_mod_timer(ts, expire_time);
819 } else {
820 qemu_del_timer(ts);
821 }
822 }
823
824 static void timer_save(QEMUFile *f, void *opaque)
825 {
826 if (cpu_ticks_enabled) {
827 hw_error("cannot save state if virtual timers are running");
828 }
829 qemu_put_be64s(f, &cpu_ticks_offset);
830 qemu_put_be64s(f, &ticks_per_sec);
831 }
832
833 static int timer_load(QEMUFile *f, void *opaque, int version_id)
834 {
835 if (version_id != 1)
836 return -EINVAL;
837 if (cpu_ticks_enabled) {
838 return -EINVAL;
839 }
840 qemu_get_be64s(f, &cpu_ticks_offset);
841 qemu_get_be64s(f, &ticks_per_sec);
842 return 0;
843 }
844
845 #ifdef _WIN32
846 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
847 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
848 #else
849 static void host_alarm_handler(int host_signum)
850 #endif
851 {
852 #if 0
853 #define DISP_FREQ 1000
854 {
855 static int64_t delta_min = INT64_MAX;
856 static int64_t delta_max, delta_cum, last_clock, delta, ti;
857 static int count;
858 ti = qemu_get_clock(vm_clock);
859 if (last_clock != 0) {
860 delta = ti - last_clock;
861 if (delta < delta_min)
862 delta_min = delta;
863 if (delta > delta_max)
864 delta_max = delta;
865 delta_cum += delta;
866 if (++count == DISP_FREQ) {
867 printf("timer: min=%lld us max=%lld us avg=%lld us avg_freq=%0.3f Hz\n",
868 muldiv64(delta_min, 1000000, ticks_per_sec),
869 muldiv64(delta_max, 1000000, ticks_per_sec),
870 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
871 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
872 count = 0;
873 delta_min = INT64_MAX;
874 delta_max = 0;
875 delta_cum = 0;
876 }
877 }
878 last_clock = ti;
879 }
880 #endif
881 if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
882 qemu_get_clock(vm_clock)) ||
883 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
884 qemu_get_clock(rt_clock))) {
885 CPUState *env = cpu_single_env;
886 if (env) {
887 /* stop the currently executing cpu because a timer occured */
888 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
889 #ifdef USE_KQEMU
890 if (env->kqemu_enabled) {
891 kqemu_cpu_interrupt(env);
892 }
893 #endif
894 }
895 }
896 }
897
898 #ifndef _WIN32
899
900 #if defined(__linux__)
901
902 #define RTC_FREQ 1024
903
904 static int rtc_fd;
905
906 static int start_rtc_timer(void)
907 {
908 rtc_fd = open("/dev/rtc", O_RDONLY);
909 if (rtc_fd < 0)
910 return -1;
911 if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
912 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
913 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
914 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
915 goto fail;
916 }
917 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
918 fail:
919 close(rtc_fd);
920 return -1;
921 }
922 pit_min_timer_count = PIT_FREQ / RTC_FREQ;
923 return 0;
924 }
925
926 #else
927
928 static int start_rtc_timer(void)
929 {
930 return -1;
931 }
932
933 #endif /* !defined(__linux__) */
934
935 #endif /* !defined(_WIN32) */
936
937 static void init_timers(void)
938 {
939 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
940 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
941
942 #ifdef _WIN32
943 {
944 int count=0;
945 timerID = timeSetEvent(1, // interval (ms)
946 0, // resolution
947 host_alarm_handler, // function
948 (DWORD)&count, // user parameter
949 TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
950 if( !timerID ) {
951 perror("failed timer alarm");
952 exit(1);
953 }
954 }
955 pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
956 #else
957 {
958 struct sigaction act;
959 struct itimerval itv;
960
961 /* get times() syscall frequency */
962 timer_freq = sysconf(_SC_CLK_TCK);
963
964 /* timer signal */
965 sigfillset(&act.sa_mask);
966 act.sa_flags = 0;
967 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
968 act.sa_flags |= SA_ONSTACK;
969 #endif
970 act.sa_handler = host_alarm_handler;
971 sigaction(SIGALRM, &act, NULL);
972
973 itv.it_interval.tv_sec = 0;
974 itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */
975 itv.it_value.tv_sec = 0;
976 itv.it_value.tv_usec = 10 * 1000;
977 setitimer(ITIMER_REAL, &itv, NULL);
978 /* we probe the tick duration of the kernel to inform the user if
979 the emulated kernel requested a too high timer frequency */
980 getitimer(ITIMER_REAL, &itv);
981
982 #if defined(__linux__)
983 if (itv.it_interval.tv_usec > 1000) {
984 /* try to use /dev/rtc to have a faster timer */
985 if (start_rtc_timer() < 0)
986 goto use_itimer;
987 /* disable itimer */
988 itv.it_interval.tv_sec = 0;
989 itv.it_interval.tv_usec = 0;
990 itv.it_value.tv_sec = 0;
991 itv.it_value.tv_usec = 0;
992 setitimer(ITIMER_REAL, &itv, NULL);
993
994 /* use the RTC */
995 sigaction(SIGIO, &act, NULL);
996 fcntl(rtc_fd, F_SETFL, O_ASYNC);
997 fcntl(rtc_fd, F_SETOWN, getpid());
998 } else
999 #endif /* defined(__linux__) */
1000 {
1001 use_itimer:
1002 pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
1003 PIT_FREQ) / 1000000;
1004 }
1005 }
1006 #endif
1007 }
1008
1009 void quit_timers(void)
1010 {
1011 #ifdef _WIN32
1012 timeKillEvent(timerID);
1013 #endif
1014 }
1015
1016 /***********************************************************/
1017 /* character device */
1018
1019 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1020 {
1021 return s->chr_write(s, buf, len);
1022 }
1023
1024 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1025 {
1026 if (!s->chr_ioctl)
1027 return -ENOTSUP;
1028 return s->chr_ioctl(s, cmd, arg);
1029 }
1030
1031 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1032 {
1033 char buf[4096];
1034 va_list ap;
1035 va_start(ap, fmt);
1036 vsnprintf(buf, sizeof(buf), fmt, ap);
1037 qemu_chr_write(s, buf, strlen(buf));
1038 va_end(ap);
1039 }
1040
1041 void qemu_chr_send_event(CharDriverState *s, int event)
1042 {
1043 if (s->chr_send_event)
1044 s->chr_send_event(s, event);
1045 }
1046
1047 void qemu_chr_add_read_handler(CharDriverState *s,
1048 IOCanRWHandler *fd_can_read,
1049 IOReadHandler *fd_read, void *opaque)
1050 {
1051 s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
1052 }
1053
1054 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
1055 {
1056 s->chr_event = chr_event;
1057 }
1058
1059 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1060 {
1061 return len;
1062 }
1063
1064 static void null_chr_add_read_handler(CharDriverState *chr,
1065 IOCanRWHandler *fd_can_read,
1066 IOReadHandler *fd_read, void *opaque)
1067 {
1068 }
1069
1070 CharDriverState *qemu_chr_open_null(void)
1071 {
1072 CharDriverState *chr;
1073
1074 chr = qemu_mallocz(sizeof(CharDriverState));
1075 if (!chr)
1076 return NULL;
1077 chr->chr_write = null_chr_write;
1078 chr->chr_add_read_handler = null_chr_add_read_handler;
1079 return chr;
1080 }
1081
1082 #ifdef _WIN32
1083
1084 #define socket_error() WSAGetLastError()
1085 #undef EINTR
1086 #define EWOULDBLOCK WSAEWOULDBLOCK
1087 #define EINTR WSAEINTR
1088 #define EINPROGRESS WSAEINPROGRESS
1089
1090 static void socket_cleanup(void)
1091 {
1092 WSACleanup();
1093 }
1094
1095 static int socket_init(void)
1096 {
1097 WSADATA Data;
1098 int ret, err;
1099
1100 ret = WSAStartup(MAKEWORD(2,2), &Data);
1101 if (ret != 0) {
1102 err = WSAGetLastError();
1103 fprintf(stderr, "WSAStartup: %d\n", err);
1104 return -1;
1105 }
1106 atexit(socket_cleanup);
1107 return 0;
1108 }
1109
1110 static int send_all(int fd, const uint8_t *buf, int len1)
1111 {
1112 int ret, len;
1113
1114 len = len1;
1115 while (len > 0) {
1116 ret = send(fd, buf, len, 0);
1117 if (ret < 0) {
1118 int errno;
1119 errno = WSAGetLastError();
1120 if (errno != WSAEWOULDBLOCK) {
1121 return -1;
1122 }
1123 } else if (ret == 0) {
1124 break;
1125 } else {
1126 buf += ret;
1127 len -= ret;
1128 }
1129 }
1130 return len1 - len;
1131 }
1132
1133 void socket_set_nonblock(int fd)
1134 {
1135 unsigned long opt = 1;
1136 ioctlsocket(fd, FIONBIO, &opt);
1137 }
1138
1139 #else
1140
1141 #define socket_error() errno
1142 #define closesocket(s) close(s)
1143
1144 static int unix_write(int fd, const uint8_t *buf, int len1)
1145 {
1146 int ret, len;
1147
1148 len = len1;
1149 while (len > 0) {
1150 ret = write(fd, buf, len);
1151 if (ret < 0) {
1152 if (errno != EINTR && errno != EAGAIN)
1153 return -1;
1154 } else if (ret == 0) {
1155 break;
1156 } else {
1157 buf += ret;
1158 len -= ret;
1159 }
1160 }
1161 return len1 - len;
1162 }
1163
1164 static inline int send_all(int fd, const uint8_t *buf, int len1)
1165 {
1166 return unix_write(fd, buf, len1);
1167 }
1168
1169 void socket_set_nonblock(int fd)
1170 {
1171 fcntl(fd, F_SETFL, O_NONBLOCK);
1172 }
1173 #endif /* !_WIN32 */
1174
1175 #ifndef _WIN32
1176
1177 typedef struct {
1178 int fd_in, fd_out;
1179 IOCanRWHandler *fd_can_read;
1180 IOReadHandler *fd_read;
1181 void *fd_opaque;
1182 int max_size;
1183 } FDCharDriver;
1184
1185 #define STDIO_MAX_CLIENTS 2
1186
1187 static int stdio_nb_clients;
1188 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1189
1190 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1191 {
1192 FDCharDriver *s = chr->opaque;
1193 return unix_write(s->fd_out, buf, len);
1194 }
1195
1196 static int fd_chr_read_poll(void *opaque)
1197 {
1198 CharDriverState *chr = opaque;
1199 FDCharDriver *s = chr->opaque;
1200
1201 s->max_size = s->fd_can_read(s->fd_opaque);
1202 return s->max_size;
1203 }
1204
1205 static void fd_chr_read(void *opaque)
1206 {
1207 CharDriverState *chr = opaque;
1208 FDCharDriver *s = chr->opaque;
1209 int size, len;
1210 uint8_t buf[1024];
1211
1212 len = sizeof(buf);
1213 if (len > s->max_size)
1214 len = s->max_size;
1215 if (len == 0)
1216 return;
1217 size = read(s->fd_in, buf, len);
1218 if (size > 0) {
1219 s->fd_read(s->fd_opaque, buf, size);
1220 }
1221 }
1222
1223 static void fd_chr_add_read_handler(CharDriverState *chr,
1224 IOCanRWHandler *fd_can_read,
1225 IOReadHandler *fd_read, void *opaque)
1226 {
1227 FDCharDriver *s = chr->opaque;
1228
1229 if (s->fd_in >= 0) {
1230 s->fd_can_read = fd_can_read;
1231 s->fd_read = fd_read;
1232 s->fd_opaque = opaque;
1233 if (nographic && s->fd_in == 0) {
1234 } else {
1235 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
1236 fd_chr_read, NULL, chr);
1237 }
1238 }
1239 }
1240
1241 /* open a character device to a unix fd */
1242 CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1243 {
1244 CharDriverState *chr;
1245 FDCharDriver *s;
1246
1247 chr = qemu_mallocz(sizeof(CharDriverState));
1248 if (!chr)
1249 return NULL;
1250 s = qemu_mallocz(sizeof(FDCharDriver));
1251 if (!s) {
1252 free(chr);
1253 return NULL;
1254 }
1255 s->fd_in = fd_in;
1256 s->fd_out = fd_out;
1257 chr->opaque = s;
1258 chr->chr_write = fd_chr_write;
1259 chr->chr_add_read_handler = fd_chr_add_read_handler;
1260 return chr;
1261 }
1262
1263 CharDriverState *qemu_chr_open_file_out(const char *file_out)
1264 {
1265 int fd_out;
1266
1267 fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY);
1268 if (fd_out < 0)
1269 return NULL;
1270 return qemu_chr_open_fd(-1, fd_out);
1271 }
1272
1273 CharDriverState *qemu_chr_open_pipe(const char *filename)
1274 {
1275 int fd;
1276
1277 fd = open(filename, O_RDWR | O_BINARY);
1278 if (fd < 0)
1279 return NULL;
1280 return qemu_chr_open_fd(fd, fd);
1281 }
1282
1283
1284 /* for STDIO, we handle the case where several clients use it
1285 (nographic mode) */
1286
1287 #define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1288
1289 #define TERM_FIFO_MAX_SIZE 1
1290
1291 static int term_got_escape, client_index;
1292 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1293 int term_fifo_size;
1294
1295 void term_print_help(void)
1296 {
1297 printf("\n"
1298 "C-a h print this help\n"
1299 "C-a x exit emulator\n"
1300 "C-a s save disk data back to file (if -snapshot)\n"
1301 "C-a b send break (magic sysrq)\n"
1302 "C-a c switch between console and monitor\n"
1303 "C-a C-a send C-a\n"
1304 );
1305 }
1306
1307 /* called when a char is received */
1308 static void stdio_received_byte(int ch)
1309 {
1310 if (term_got_escape) {
1311 term_got_escape = 0;
1312 switch(ch) {
1313 case 'h':
1314 term_print_help();
1315 break;
1316 case 'x':
1317 exit(0);
1318 break;
1319 case 's':
1320 {
1321 int i;
1322 for (i = 0; i < MAX_DISKS; i++) {
1323 if (bs_table[i])
1324 bdrv_commit(bs_table[i]);
1325 }
1326 }
1327 break;
1328 case 'b':
1329 if (client_index < stdio_nb_clients) {
1330 CharDriverState *chr;
1331 FDCharDriver *s;
1332
1333 chr = stdio_clients[client_index];
1334 s = chr->opaque;
1335 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1336 }
1337 break;
1338 case 'c':
1339 client_index++;
1340 if (client_index >= stdio_nb_clients)
1341 client_index = 0;
1342 if (client_index == 0) {
1343 /* send a new line in the monitor to get the prompt */
1344 ch = '\r';
1345 goto send_char;
1346 }
1347 break;
1348 case TERM_ESCAPE:
1349 goto send_char;
1350 }
1351 } else if (ch == TERM_ESCAPE) {
1352 term_got_escape = 1;
1353 } else {
1354 send_char:
1355 if (client_index < stdio_nb_clients) {
1356 uint8_t buf[1];
1357 CharDriverState *chr;
1358 FDCharDriver *s;
1359
1360 chr = stdio_clients[client_index];
1361 s = chr->opaque;
1362 if (s->fd_can_read(s->fd_opaque) > 0) {
1363 buf[0] = ch;
1364 s->fd_read(s->fd_opaque, buf, 1);
1365 } else if (term_fifo_size == 0) {
1366 term_fifo[term_fifo_size++] = ch;
1367 }
1368 }
1369 }
1370 }
1371
1372 static int stdio_read_poll(void *opaque)
1373 {
1374 CharDriverState *chr;
1375 FDCharDriver *s;
1376
1377 if (client_index < stdio_nb_clients) {
1378 chr = stdio_clients[client_index];
1379 s = chr->opaque;
1380 /* try to flush the queue if needed */
1381 if (term_fifo_size != 0 && s->fd_can_read(s->fd_opaque) > 0) {
1382 s->fd_read(s->fd_opaque, term_fifo, 1);
1383 term_fifo_size = 0;
1384 }
1385 /* see if we can absorb more chars */
1386 if (term_fifo_size == 0)
1387 return 1;
1388 else
1389 return 0;
1390 } else {
1391 return 1;
1392 }
1393 }
1394
1395 static void stdio_read(void *opaque)
1396 {
1397 int size;
1398 uint8_t buf[1];
1399
1400 size = read(0, buf, 1);
1401 if (size > 0)
1402 stdio_received_byte(buf[0]);
1403 }
1404
1405 /* init terminal so that we can grab keys */
1406 static struct termios oldtty;
1407 static int old_fd0_flags;
1408
1409 static void term_exit(void)
1410 {
1411 tcsetattr (0, TCSANOW, &oldtty);
1412 fcntl(0, F_SETFL, old_fd0_flags);
1413 }
1414
1415 static void term_init(void)
1416 {
1417 struct termios tty;
1418
1419 tcgetattr (0, &tty);
1420 oldtty = tty;
1421 old_fd0_flags = fcntl(0, F_GETFL);
1422
1423 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1424 |INLCR|IGNCR|ICRNL|IXON);
1425 tty.c_oflag |= OPOST;
1426 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1427 /* if graphical mode, we allow Ctrl-C handling */
1428 if (nographic)
1429 tty.c_lflag &= ~ISIG;
1430 tty.c_cflag &= ~(CSIZE|PARENB);
1431 tty.c_cflag |= CS8;
1432 tty.c_cc[VMIN] = 1;
1433 tty.c_cc[VTIME] = 0;
1434
1435 tcsetattr (0, TCSANOW, &tty);
1436
1437 atexit(term_exit);
1438
1439 fcntl(0, F_SETFL, O_NONBLOCK);
1440 }
1441
1442 CharDriverState *qemu_chr_open_stdio(void)
1443 {
1444 CharDriverState *chr;
1445
1446 if (nographic) {
1447 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1448 return NULL;
1449 chr = qemu_chr_open_fd(0, 1);
1450 if (stdio_nb_clients == 0)
1451 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, NULL);
1452 client_index = stdio_nb_clients;
1453 } else {
1454 if (stdio_nb_clients != 0)
1455 return NULL;
1456 chr = qemu_chr_open_fd(0, 1);
1457 }
1458 stdio_clients[stdio_nb_clients++] = chr;
1459 if (stdio_nb_clients == 1) {
1460 /* set the terminal in raw mode */
1461 term_init();
1462 }
1463 return chr;
1464 }
1465
1466 #if defined(__linux__)
1467 CharDriverState *qemu_chr_open_pty(void)
1468 {
1469 struct termios tty;
1470 char slave_name[1024];
1471 int master_fd, slave_fd;
1472
1473 /* Not satisfying */
1474 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1475 return NULL;
1476 }
1477
1478 /* Disabling local echo and line-buffered output */
1479 tcgetattr (master_fd, &tty);
1480 tty.c_lflag &= ~(ECHO|ICANON|ISIG);
1481 tty.c_cc[VMIN] = 1;
1482 tty.c_cc[VTIME] = 0;
1483 tcsetattr (master_fd, TCSAFLUSH, &tty);
1484
1485 fprintf(stderr, "char device redirected to %s\n", slave_name);
1486 return qemu_chr_open_fd(master_fd, master_fd);
1487 }
1488
1489 static void tty_serial_init(int fd, int speed,
1490 int parity, int data_bits, int stop_bits)
1491 {
1492 struct termios tty;
1493 speed_t spd;
1494
1495 #if 0
1496 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1497 speed, parity, data_bits, stop_bits);
1498 #endif
1499 tcgetattr (fd, &tty);
1500
1501 switch(speed) {
1502 case 50:
1503 spd = B50;
1504 break;
1505 case 75:
1506 spd = B75;
1507 break;
1508 case 300:
1509 spd = B300;
1510 break;
1511 case 600:
1512 spd = B600;
1513 break;
1514 case 1200:
1515 spd = B1200;
1516 break;
1517 case 2400:
1518 spd = B2400;
1519 break;
1520 case 4800:
1521 spd = B4800;
1522 break;
1523 case 9600:
1524 spd = B9600;
1525 break;
1526 case 19200:
1527 spd = B19200;
1528 break;
1529 case 38400:
1530 spd = B38400;
1531 break;
1532 case 57600:
1533 spd = B57600;
1534 break;
1535 default:
1536 case 115200:
1537 spd = B115200;
1538 break;
1539 }
1540
1541 cfsetispeed(&tty, spd);
1542 cfsetospeed(&tty, spd);
1543
1544 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1545 |INLCR|IGNCR|ICRNL|IXON);
1546 tty.c_oflag |= OPOST;
1547 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1548 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS);
1549 switch(data_bits) {
1550 default:
1551 case 8:
1552 tty.c_cflag |= CS8;
1553 break;
1554 case 7:
1555 tty.c_cflag |= CS7;
1556 break;
1557 case 6:
1558 tty.c_cflag |= CS6;
1559 break;
1560 case 5:
1561 tty.c_cflag |= CS5;
1562 break;
1563 }
1564 switch(parity) {
1565 default:
1566 case 'N':
1567 break;
1568 case 'E':
1569 tty.c_cflag |= PARENB;
1570 break;
1571 case 'O':
1572 tty.c_cflag |= PARENB | PARODD;
1573 break;
1574 }
1575
1576 tcsetattr (fd, TCSANOW, &tty);
1577 }
1578
1579 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1580 {
1581 FDCharDriver *s = chr->opaque;
1582
1583 switch(cmd) {
1584 case CHR_IOCTL_SERIAL_SET_PARAMS:
1585 {
1586 QEMUSerialSetParams *ssp = arg;
1587 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1588 ssp->data_bits, ssp->stop_bits);
1589 }
1590 break;
1591 case CHR_IOCTL_SERIAL_SET_BREAK:
1592 {
1593 int enable = *(int *)arg;
1594 if (enable)
1595 tcsendbreak(s->fd_in, 1);
1596 }
1597 break;
1598 default:
1599 return -ENOTSUP;
1600 }
1601 return 0;
1602 }
1603
1604 CharDriverState *qemu_chr_open_tty(const char *filename)
1605 {
1606 CharDriverState *chr;
1607 int fd;
1608
1609 fd = open(filename, O_RDWR | O_NONBLOCK);
1610 if (fd < 0)
1611 return NULL;
1612 fcntl(fd, F_SETFL, O_NONBLOCK);
1613 tty_serial_init(fd, 115200, 'N', 8, 1);
1614 chr = qemu_chr_open_fd(fd, fd);
1615 if (!chr)
1616 return NULL;
1617 chr->chr_ioctl = tty_serial_ioctl;
1618 return chr;
1619 }
1620
1621 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1622 {
1623 int fd = (int)chr->opaque;
1624 uint8_t b;
1625
1626 switch(cmd) {
1627 case CHR_IOCTL_PP_READ_DATA:
1628 if (ioctl(fd, PPRDATA, &b) < 0)
1629 return -ENOTSUP;
1630 *(uint8_t *)arg = b;
1631 break;
1632 case CHR_IOCTL_PP_WRITE_DATA:
1633 b = *(uint8_t *)arg;
1634 if (ioctl(fd, PPWDATA, &b) < 0)
1635 return -ENOTSUP;
1636 break;
1637 case CHR_IOCTL_PP_READ_CONTROL:
1638 if (ioctl(fd, PPRCONTROL, &b) < 0)
1639 return -ENOTSUP;
1640 *(uint8_t *)arg = b;
1641 break;
1642 case CHR_IOCTL_PP_WRITE_CONTROL:
1643 b = *(uint8_t *)arg;
1644 if (ioctl(fd, PPWCONTROL, &b) < 0)
1645 return -ENOTSUP;
1646 break;
1647 case CHR_IOCTL_PP_READ_STATUS:
1648 if (ioctl(fd, PPRSTATUS, &b) < 0)
1649 return -ENOTSUP;
1650 *(uint8_t *)arg = b;
1651 break;
1652 default:
1653 return -ENOTSUP;
1654 }
1655 return 0;
1656 }
1657
1658 CharDriverState *qemu_chr_open_pp(const char *filename)
1659 {
1660 CharDriverState *chr;
1661 int fd;
1662
1663 fd = open(filename, O_RDWR);
1664 if (fd < 0)
1665 return NULL;
1666
1667 if (ioctl(fd, PPCLAIM) < 0) {
1668 close(fd);
1669 return NULL;
1670 }
1671
1672 chr = qemu_mallocz(sizeof(CharDriverState));
1673 if (!chr) {
1674 close(fd);
1675 return NULL;
1676 }
1677 chr->opaque = (void *)fd;
1678 chr->chr_write = null_chr_write;
1679 chr->chr_add_read_handler = null_chr_add_read_handler;
1680 chr->chr_ioctl = pp_ioctl;
1681 return chr;
1682 }
1683
1684 #else
1685 CharDriverState *qemu_chr_open_pty(void)
1686 {
1687 return NULL;
1688 }
1689 #endif
1690
1691 #endif /* !defined(_WIN32) */
1692
1693 CharDriverState *qemu_chr_open(const char *filename)
1694 {
1695 #ifndef _WIN32
1696 const char *p;
1697 #endif
1698
1699 if (!strcmp(filename, "vc")) {
1700 return text_console_init(&display_state);
1701 } else if (!strcmp(filename, "null")) {
1702 return qemu_chr_open_null();
1703 } else
1704 #ifndef _WIN32
1705 if (strstart(filename, "file:", &p)) {
1706 return qemu_chr_open_file_out(p);
1707 } else if (strstart(filename, "pipe:", &p)) {
1708 return qemu_chr_open_pipe(p);
1709 } else if (!strcmp(filename, "pty")) {
1710 return qemu_chr_open_pty();
1711 } else if (!strcmp(filename, "stdio")) {
1712 return qemu_chr_open_stdio();
1713 } else
1714 #endif
1715 #if defined(__linux__)
1716 if (strstart(filename, "/dev/parport", NULL)) {
1717 return qemu_chr_open_pp(filename);
1718 } else
1719 if (strstart(filename, "/dev/", NULL)) {
1720 return qemu_chr_open_tty(filename);
1721 } else
1722 #endif
1723 {
1724 return NULL;
1725 }
1726 }
1727
1728 /***********************************************************/
1729 /* network device redirectors */
1730
1731 void hex_dump(FILE *f, const uint8_t *buf, int size)
1732 {
1733 int len, i, j, c;
1734
1735 for(i=0;i<size;i+=16) {
1736 len = size - i;
1737 if (len > 16)
1738 len = 16;
1739 fprintf(f, "%08x ", i);
1740 for(j=0;j<16;j++) {
1741 if (j < len)
1742 fprintf(f, " %02x", buf[i+j]);
1743 else
1744 fprintf(f, " ");
1745 }
1746 fprintf(f, " ");
1747 for(j=0;j<len;j++) {
1748 c = buf[i+j];
1749 if (c < ' ' || c > '~')
1750 c = '.';
1751 fprintf(f, "%c", c);
1752 }
1753 fprintf(f, "\n");
1754 }
1755 }
1756
1757 static int parse_macaddr(uint8_t *macaddr, const char *p)
1758 {
1759 int i;
1760 for(i = 0; i < 6; i++) {
1761 macaddr[i] = strtol(p, (char **)&p, 16);
1762 if (i == 5) {
1763 if (*p != '\0')
1764 return -1;
1765 } else {
1766 if (*p != ':')
1767 return -1;
1768 p++;
1769 }
1770 }
1771 return 0;
1772 }
1773
1774 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
1775 {
1776 const char *p, *p1;
1777 int len;
1778 p = *pp;
1779 p1 = strchr(p, sep);
1780 if (!p1)
1781 return -1;
1782 len = p1 - p;
1783 p1++;
1784 if (buf_size > 0) {
1785 if (len > buf_size - 1)
1786 len = buf_size - 1;
1787 memcpy(buf, p, len);
1788 buf[len] = '\0';
1789 }
1790 *pp = p1;
1791 return 0;
1792 }
1793
1794 int parse_host_port(struct sockaddr_in *saddr, const char *str)
1795 {
1796 char buf[512];
1797 struct hostent *he;
1798 const char *p, *r;
1799 int port;
1800
1801 p = str;
1802 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1803 return -1;
1804 saddr->sin_family = AF_INET;
1805 if (buf[0] == '\0') {
1806 saddr->sin_addr.s_addr = 0;
1807 } else {
1808 if (isdigit(buf[0])) {
1809 if (!inet_aton(buf, &saddr->sin_addr))
1810 return -1;
1811 } else {
1812 if ((he = gethostbyname(buf)) == NULL)
1813 return - 1;
1814 saddr->sin_addr = *(struct in_addr *)he->h_addr;
1815 }
1816 }
1817 port = strtol(p, (char **)&r, 0);
1818 if (r == p)
1819 return -1;
1820 saddr->sin_port = htons(port);
1821 return 0;
1822 }
1823
1824 /* find or alloc a new VLAN */
1825 VLANState *qemu_find_vlan(int id)
1826 {
1827 VLANState **pvlan, *vlan;
1828 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
1829 if (vlan->id == id)
1830 return vlan;
1831 }
1832 vlan = qemu_mallocz(sizeof(VLANState));
1833 if (!vlan)
1834 return NULL;
1835 vlan->id = id;
1836 vlan->next = NULL;
1837 pvlan = &first_vlan;
1838 while (*pvlan != NULL)
1839 pvlan = &(*pvlan)->next;
1840 *pvlan = vlan;
1841 return vlan;
1842 }
1843
1844 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
1845 IOReadHandler *fd_read,
1846 IOCanRWHandler *fd_can_read,
1847 void *opaque)
1848 {
1849 VLANClientState *vc, **pvc;
1850 vc = qemu_mallocz(sizeof(VLANClientState));
1851 if (!vc)
1852 return NULL;
1853 vc->fd_read = fd_read;
1854 vc->fd_can_read = fd_can_read;
1855 vc->opaque = opaque;
1856 vc->vlan = vlan;
1857
1858 vc->next = NULL;
1859 pvc = &vlan->first_client;
1860 while (*pvc != NULL)
1861 pvc = &(*pvc)->next;
1862 *pvc = vc;
1863 return vc;
1864 }
1865
1866 int qemu_can_send_packet(VLANClientState *vc1)
1867 {
1868 VLANState *vlan = vc1->vlan;
1869 VLANClientState *vc;
1870
1871 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1872 if (vc != vc1) {
1873 if (vc->fd_can_read && !vc->fd_can_read(vc->opaque))
1874 return 0;
1875 }
1876 }
1877 return 1;
1878 }
1879
1880 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
1881 {
1882 VLANState *vlan = vc1->vlan;
1883 VLANClientState *vc;
1884
1885 #if 0
1886 printf("vlan %d send:\n", vlan->id);
1887 hex_dump(stdout, buf, size);
1888 #endif
1889 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
1890 if (vc != vc1) {
1891 vc->fd_read(vc->opaque, buf, size);
1892 }
1893 }
1894 }
1895
1896 #if defined(CONFIG_SLIRP)
1897
1898 /* slirp network adapter */
1899
1900 static int slirp_inited;
1901 static VLANClientState *slirp_vc;
1902
1903 int slirp_can_output(void)
1904 {
1905 return qemu_can_send_packet(slirp_vc);
1906 }
1907
1908 void slirp_output(const uint8_t *pkt, int pkt_len)
1909 {
1910 #if 0
1911 printf("slirp output:\n");
1912 hex_dump(stdout, pkt, pkt_len);
1913 #endif
1914 qemu_send_packet(slirp_vc, pkt, pkt_len);
1915 }
1916
1917 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
1918 {
1919 #if 0
1920 printf("slirp input:\n");
1921 hex_dump(stdout, buf, size);
1922 #endif
1923 slirp_input(buf, size);
1924 }
1925
1926 static int net_slirp_init(VLANState *vlan)
1927 {
1928 if (!slirp_inited) {
1929 slirp_inited = 1;
1930 slirp_init();
1931 }
1932 slirp_vc = qemu_new_vlan_client(vlan,
1933 slirp_receive, NULL, NULL);
1934 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
1935 return 0;
1936 }
1937
1938 static void net_slirp_redir(const char *redir_str)
1939 {
1940 int is_udp;
1941 char buf[256], *r;
1942 const char *p;
1943 struct in_addr guest_addr;
1944 int host_port, guest_port;
1945
1946 if (!slirp_inited) {
1947 slirp_inited = 1;
1948 slirp_init();
1949 }
1950
1951 p = redir_str;
1952 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1953 goto fail;
1954 if (!strcmp(buf, "tcp")) {
1955 is_udp = 0;
1956 } else if (!strcmp(buf, "udp")) {
1957 is_udp = 1;
1958 } else {
1959 goto fail;
1960 }
1961
1962 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1963 goto fail;
1964 host_port = strtol(buf, &r, 0);
1965 if (r == buf)
1966 goto fail;
1967
1968 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
1969 goto fail;
1970 if (buf[0] == '\0') {
1971 pstrcpy(buf, sizeof(buf), "10.0.2.15");
1972 }
1973 if (!inet_aton(buf, &guest_addr))
1974 goto fail;
1975
1976 guest_port = strtol(p, &r, 0);
1977 if (r == p)
1978 goto fail;
1979
1980 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
1981 fprintf(stderr, "qemu: could not set up redirection\n");
1982 exit(1);
1983 }
1984 return;
1985 fail:
1986 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
1987 exit(1);
1988 }
1989
1990 #ifndef _WIN32
1991
1992 char smb_dir[1024];
1993
1994 static void smb_exit(void)
1995 {
1996 DIR *d;
1997 struct dirent *de;
1998 char filename[1024];
1999
2000 /* erase all the files in the directory */
2001 d = opendir(smb_dir);
2002 for(;;) {
2003 de = readdir(d);
2004 if (!de)
2005 break;
2006 if (strcmp(de->d_name, ".") != 0 &&
2007 strcmp(de->d_name, "..") != 0) {
2008 snprintf(filename, sizeof(filename), "%s/%s",
2009 smb_dir, de->d_name);
2010 unlink(filename);
2011 }
2012 }
2013 closedir(d);
2014 rmdir(smb_dir);
2015 }
2016
2017 /* automatic user mode samba server configuration */
2018 void net_slirp_smb(const char *exported_dir)
2019 {
2020 char smb_conf[1024];
2021 char smb_cmdline[1024];
2022 FILE *f;
2023
2024 if (!slirp_inited) {
2025 slirp_inited = 1;
2026 slirp_init();
2027 }
2028
2029 /* XXX: better tmp dir construction */
2030 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
2031 if (mkdir(smb_dir, 0700) < 0) {
2032 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
2033 exit(1);
2034 }
2035 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
2036
2037 f = fopen(smb_conf, "w");
2038 if (!f) {
2039 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
2040 exit(1);
2041 }
2042 fprintf(f,
2043 "[global]\n"
2044 "private dir=%s\n"
2045 "smb ports=0\n"
2046 "socket address=127.0.0.1\n"
2047 "pid directory=%s\n"
2048 "lock directory=%s\n"
2049 "log file=%s/log.smbd\n"
2050 "smb passwd file=%s/smbpasswd\n"
2051 "security = share\n"
2052 "[qemu]\n"
2053 "path=%s\n"
2054 "read only=no\n"
2055 "guest ok=yes\n",
2056 smb_dir,
2057 smb_dir,
2058 smb_dir,
2059 smb_dir,
2060 smb_dir,
2061 exported_dir
2062 );
2063 fclose(f);
2064 atexit(smb_exit);
2065
2066 snprintf(smb_cmdline, sizeof(smb_cmdline), "/usr/sbin/smbd -s %s",
2067 smb_conf);
2068
2069 slirp_add_exec(0, smb_cmdline, 4, 139);
2070 }
2071
2072 #endif /* !defined(_WIN32) */
2073
2074 #endif /* CONFIG_SLIRP */
2075
2076 #if !defined(_WIN32)
2077
2078 typedef struct TAPState {
2079 VLANClientState *vc;
2080 int fd;
2081 } TAPState;
2082
2083 static void tap_receive(void *opaque, const uint8_t *buf, int size)
2084 {
2085 TAPState *s = opaque;
2086 int ret;
2087 for(;;) {
2088 ret = write(s->fd, buf, size);
2089 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
2090 } else {
2091 break;
2092 }
2093 }
2094 }
2095
2096 static void tap_send(void *opaque)
2097 {
2098 TAPState *s = opaque;
2099 uint8_t buf[4096];
2100 int size;
2101
2102 size = read(s->fd, buf, sizeof(buf));
2103 if (size > 0) {
2104 qemu_send_packet(s->vc, buf, size);
2105 }
2106 }
2107
2108 /* fd support */
2109
2110 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
2111 {
2112 TAPState *s;
2113
2114 s = qemu_mallocz(sizeof(TAPState));
2115 if (!s)
2116 return NULL;
2117 s->fd = fd;
2118 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
2119 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
2120 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
2121 return s;
2122 }
2123
2124 #ifdef _BSD
2125 static int tap_open(char *ifname, int ifname_size)
2126 {
2127 int fd;
2128 char *dev;
2129 struct stat s;
2130
2131 fd = open("/dev/tap", O_RDWR);
2132 if (fd < 0) {
2133 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
2134 return -1;
2135 }
2136
2137 fstat(fd, &s);
2138 dev = devname(s.st_rdev, S_IFCHR);
2139 pstrcpy(ifname, ifname_size, dev);
2140
2141 fcntl(fd, F_SETFL, O_NONBLOCK);
2142 return fd;
2143 }
2144 #else
2145 static int tap_open(char *ifname, int ifname_size)
2146 {
2147 struct ifreq ifr;
2148 int fd, ret;
2149
2150 fd = open("/dev/net/tun", O_RDWR);
2151 if (fd < 0) {
2152 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
2153 return -1;
2154 }
2155 memset(&ifr, 0, sizeof(ifr));
2156 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
2157 if (ifname[0] != '\0')
2158 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
2159 else
2160 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
2161 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
2162 if (ret != 0) {
2163 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
2164 close(fd);
2165 return -1;
2166 }
2167 pstrcpy(ifname, ifname_size, ifr.ifr_name);
2168 fcntl(fd, F_SETFL, O_NONBLOCK);
2169 return fd;
2170 }
2171 #endif
2172
2173 static int net_tap_init(VLANState *vlan, const char *ifname1,
2174 const char *setup_script)
2175 {
2176 TAPState *s;
2177 int pid, status, fd;
2178 char *args[3];
2179 char **parg;
2180 char ifname[128];
2181
2182 if (ifname1 != NULL)
2183 pstrcpy(ifname, sizeof(ifname), ifname1);
2184 else
2185 ifname[0] = '\0';
2186 fd = tap_open(ifname, sizeof(ifname));
2187 if (fd < 0)
2188 return -1;
2189
2190 if (!setup_script)
2191 setup_script = "";
2192 if (setup_script[0] != '\0') {
2193 /* try to launch network init script */
2194 pid = fork();
2195 if (pid >= 0) {
2196 if (pid == 0) {
2197 parg = args;
2198 *parg++ = (char *)setup_script;
2199 *parg++ = ifname;
2200 *parg++ = NULL;
2201 execv(setup_script, args);
2202 _exit(1);
2203 }
2204 while (waitpid(pid, &status, 0) != pid);
2205 if (!WIFEXITED(status) ||
2206 WEXITSTATUS(status) != 0) {
2207 fprintf(stderr, "%s: could not launch network script\n",
2208 setup_script);
2209 return -1;
2210 }
2211 }
2212 }
2213 s = net_tap_fd_init(vlan, fd);
2214 if (!s)
2215 return -1;
2216 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2217 "tap: ifname=%s setup_script=%s", ifname, setup_script);
2218 return 0;
2219 }
2220
2221 #endif /* !_WIN32 */
2222
2223 /* network connection */
2224 typedef struct NetSocketState {
2225 VLANClientState *vc;
2226 int fd;
2227 int state; /* 0 = getting length, 1 = getting data */
2228 int index;
2229 int packet_len;
2230 uint8_t buf[4096];
2231 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
2232 } NetSocketState;
2233
2234 typedef struct NetSocketListenState {
2235 VLANState *vlan;
2236 int fd;
2237 } NetSocketListenState;
2238
2239 /* XXX: we consider we can send the whole packet without blocking */
2240 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
2241 {
2242 NetSocketState *s = opaque;
2243 uint32_t len;
2244 len = htonl(size);
2245
2246 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
2247 send_all(s->fd, buf, size);
2248 }
2249
2250 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
2251 {
2252 NetSocketState *s = opaque;
2253 sendto(s->fd, buf, size, 0,
2254 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
2255 }
2256
2257 static void net_socket_send(void *opaque)
2258 {
2259 NetSocketState *s = opaque;
2260 int l, size, err;
2261 uint8_t buf1[4096];
2262 const uint8_t *buf;
2263
2264 size = recv(s->fd, buf1, sizeof(buf1), 0);
2265 if (size < 0) {
2266 err = socket_error();
2267 if (err != EWOULDBLOCK)
2268 goto eoc;
2269 } else if (size == 0) {
2270 /* end of connection */
2271 eoc:
2272 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2273 closesocket(s->fd);
2274 return;
2275 }
2276 buf = buf1;
2277 while (size > 0) {
2278 /* reassemble a packet from the network */
2279 switch(s->state) {
2280 case 0:
2281 l = 4 - s->index;
2282 if (l > size)
2283 l = size;
2284 memcpy(s->buf + s->index, buf, l);
2285 buf += l;
2286 size -= l;
2287 s->index += l;
2288 if (s->index == 4) {
2289 /* got length */
2290 s->packet_len = ntohl(*(uint32_t *)s->buf);
2291 s->index = 0;
2292 s->state = 1;
2293 }
2294 break;
2295 case 1:
2296 l = s->packet_len - s->index;
2297 if (l > size)
2298 l = size;
2299 memcpy(s->buf + s->index, buf, l);
2300 s->index += l;
2301 buf += l;
2302 size -= l;
2303 if (s->index >= s->packet_len) {
2304 qemu_send_packet(s->vc, s->buf, s->packet_len);
2305 s->index = 0;
2306 s->state = 0;
2307 }
2308 break;
2309 }
2310 }
2311 }
2312
2313 static void net_socket_send_dgram(void *opaque)
2314 {
2315 NetSocketState *s = opaque;
2316 int size;
2317
2318 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
2319 if (size < 0)
2320 return;
2321 if (size == 0) {
2322 /* end of connection */
2323 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2324 return;
2325 }
2326 qemu_send_packet(s->vc, s->buf, size);
2327 }
2328
2329 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
2330 {
2331 struct ip_mreq imr;
2332 int fd;
2333 int val, ret;
2334 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
2335 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
2336 inet_ntoa(mcastaddr->sin_addr),
2337 (int)ntohl(mcastaddr->sin_addr.s_addr));
2338 return -1;
2339
2340 }
2341 fd = socket(PF_INET, SOCK_DGRAM, 0);
2342 if (fd < 0) {
2343 perror("socket(PF_INET, SOCK_DGRAM)");
2344 return -1;
2345 }
2346
2347 val = 1;
2348 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
2349 (const char *)&val, sizeof(val));
2350 if (ret < 0) {
2351 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
2352 goto fail;
2353 }
2354
2355 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
2356 if (ret < 0) {
2357 perror("bind");
2358 goto fail;
2359 }
2360
2361 /* Add host to multicast group */
2362 imr.imr_multiaddr = mcastaddr->sin_addr;
2363 imr.imr_interface.s_addr = htonl(INADDR_ANY);
2364
2365 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
2366 (const char *)&imr, sizeof(struct ip_mreq));
2367 if (ret < 0) {
2368 perror("setsockopt(IP_ADD_MEMBERSHIP)");
2369 goto fail;
2370 }
2371
2372 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
2373 val = 1;
2374 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
2375 (const char *)&val, sizeof(val));
2376 if (ret < 0) {
2377 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
2378 goto fail;
2379 }
2380
2381 socket_set_nonblock(fd);
2382 return fd;
2383 fail:
2384 if (fd>=0) close(fd);
2385 return -1;
2386 }
2387
2388 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
2389 int is_connected)
2390 {
2391 struct sockaddr_in saddr;
2392 int newfd;
2393 socklen_t saddr_len;
2394 NetSocketState *s;
2395
2396 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
2397 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
2398 * by ONLY ONE process: we must "clone" this dgram socket --jjo
2399 */
2400
2401 if (is_connected) {
2402 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
2403 /* must be bound */
2404 if (saddr.sin_addr.s_addr==0) {
2405 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
2406 fd);
2407 return NULL;
2408 }
2409 /* clone dgram socket */
2410 newfd = net_socket_mcast_create(&saddr);
2411 if (newfd < 0) {
2412 /* error already reported by net_socket_mcast_create() */
2413 close(fd);
2414 return NULL;
2415 }
2416 /* clone newfd to fd, close newfd */
2417 dup2(newfd, fd);
2418 close(newfd);
2419
2420 } else {
2421 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
2422 fd, strerror(errno));
2423 return NULL;
2424 }
2425 }
2426
2427 s = qemu_mallocz(sizeof(NetSocketState));
2428 if (!s)
2429 return NULL;
2430 s->fd = fd;
2431
2432 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
2433 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
2434
2435 /* mcast: save bound address as dst */
2436 if (is_connected) s->dgram_dst=saddr;
2437
2438 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2439 "socket: fd=%d (%s mcast=%s:%d)",
2440 fd, is_connected? "cloned" : "",
2441 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2442 return s;
2443 }
2444
2445 static void net_socket_connect(void *opaque)
2446 {
2447 NetSocketState *s = opaque;
2448 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
2449 }
2450
2451 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
2452 int is_connected)
2453 {
2454 NetSocketState *s;
2455 s = qemu_mallocz(sizeof(NetSocketState));
2456 if (!s)
2457 return NULL;
2458 s->fd = fd;
2459 s->vc = qemu_new_vlan_client(vlan,
2460 net_socket_receive, NULL, s);
2461 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2462 "socket: fd=%d", fd);
2463 if (is_connected) {
2464 net_socket_connect(s);
2465 } else {
2466 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
2467 }
2468 return s;
2469 }
2470
2471 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
2472 int is_connected)
2473 {
2474 int so_type=-1, optlen=sizeof(so_type);
2475
2476 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
2477 fprintf(stderr, "qemu: error: setsockopt(SO_TYPE) for fd=%d failed\n", fd);
2478 return NULL;
2479 }
2480 switch(so_type) {
2481 case SOCK_DGRAM:
2482 return net_socket_fd_init_dgram(vlan, fd, is_connected);
2483 case SOCK_STREAM:
2484 return net_socket_fd_init_stream(vlan, fd, is_connected);
2485 default:
2486 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
2487 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
2488 return net_socket_fd_init_stream(vlan, fd, is_connected);
2489 }
2490 return NULL;
2491 }
2492
2493 static void net_socket_accept(void *opaque)
2494 {
2495 NetSocketListenState *s = opaque;
2496 NetSocketState *s1;
2497 struct sockaddr_in saddr;
2498 socklen_t len;
2499 int fd;
2500
2501 for(;;) {
2502 len = sizeof(saddr);
2503 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
2504 if (fd < 0 && errno != EINTR) {
2505 return;
2506 } else if (fd >= 0) {
2507 break;
2508 }
2509 }
2510 s1 = net_socket_fd_init(s->vlan, fd, 1);
2511 if (!s1) {
2512 close(fd);
2513 } else {
2514 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
2515 "socket: connection from %s:%d",
2516 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2517 }
2518 }
2519
2520 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
2521 {
2522 NetSocketListenState *s;
2523 int fd, val, ret;
2524 struct sockaddr_in saddr;
2525
2526 if (parse_host_port(&saddr, host_str) < 0)
2527 return -1;
2528
2529 s = qemu_mallocz(sizeof(NetSocketListenState));
2530 if (!s)
2531 return -1;
2532
2533 fd = socket(PF_INET, SOCK_STREAM, 0);
2534 if (fd < 0) {
2535 perror("socket");
2536 return -1;
2537 }
2538 socket_set_nonblock(fd);
2539
2540 /* allow fast reuse */
2541 val = 1;
2542 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2543
2544 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2545 if (ret < 0) {
2546 perror("bind");
2547 return -1;
2548 }
2549 ret = listen(fd, 0);
2550 if (ret < 0) {
2551 perror("listen");
2552 return -1;
2553 }
2554 s->vlan = vlan;
2555 s->fd = fd;
2556 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
2557 return 0;
2558 }
2559
2560 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
2561 {
2562 NetSocketState *s;
2563 int fd, connected, ret, err;
2564 struct sockaddr_in saddr;
2565
2566 if (parse_host_port(&saddr, host_str) < 0)
2567 return -1;
2568
2569 fd = socket(PF_INET, SOCK_STREAM, 0);
2570 if (fd < 0) {
2571 perror("socket");
2572 return -1;
2573 }
2574 socket_set_nonblock(fd);
2575
2576 connected = 0;
2577 for(;;) {
2578 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
2579 if (ret < 0) {
2580 err = socket_error();
2581 if (err == EINTR || err == EWOULDBLOCK) {
2582 } else if (err == EINPROGRESS) {
2583 break;
2584 } else {
2585 perror("connect");
2586 closesocket(fd);
2587 return -1;
2588 }
2589 } else {
2590 connected = 1;
2591 break;
2592 }
2593 }
2594 s = net_socket_fd_init(vlan, fd, connected);
2595 if (!s)
2596 return -1;
2597 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2598 "socket: connect to %s:%d",
2599 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2600 return 0;
2601 }
2602
2603 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
2604 {
2605 NetSocketState *s;
2606 int fd;
2607 struct sockaddr_in saddr;
2608
2609 if (parse_host_port(&saddr, host_str) < 0)
2610 return -1;
2611
2612
2613 fd = net_socket_mcast_create(&saddr);
2614 if (fd < 0)
2615 return -1;
2616
2617 s = net_socket_fd_init(vlan, fd, 0);
2618 if (!s)
2619 return -1;
2620
2621 s->dgram_dst = saddr;
2622
2623 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
2624 "socket: mcast=%s:%d",
2625 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
2626 return 0;
2627
2628 }
2629
2630 static int get_param_value(char *buf, int buf_size,
2631 const char *tag, const char *str)
2632 {
2633 const char *p;
2634 char *q;
2635 char option[128];
2636
2637 p = str;
2638 for(;;) {
2639 q = option;
2640 while (*p != '\0' && *p != '=') {
2641 if ((q - option) < sizeof(option) - 1)
2642 *q++ = *p;
2643 p++;
2644 }
2645 *q = '\0';
2646 if (*p != '=')
2647 break;
2648 p++;
2649 if (!strcmp(tag, option)) {
2650 q = buf;
2651 while (*p != '\0' && *p != ',') {
2652 if ((q - buf) < buf_size - 1)
2653 *q++ = *p;
2654 p++;
2655 }
2656 *q = '\0';
2657 return q - buf;
2658 } else {
2659 while (*p != '\0' && *p != ',') {
2660 p++;
2661 }
2662 }
2663 if (*p != ',')
2664 break;
2665 p++;
2666 }
2667 return 0;
2668 }
2669
2670 int net_client_init(const char *str)
2671 {
2672 const char *p;
2673 char *q;
2674 char device[64];
2675 char buf[1024];
2676 int vlan_id, ret;
2677 VLANState *vlan;
2678
2679 p = str;
2680 q = device;
2681 while (*p != '\0' && *p != ',') {
2682 if ((q - device) < sizeof(device) - 1)
2683 *q++ = *p;
2684 p++;
2685 }
2686 *q = '\0';
2687 if (*p == ',')
2688 p++;
2689 vlan_id = 0;
2690 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
2691 vlan_id = strtol(buf, NULL, 0);
2692 }
2693 vlan = qemu_find_vlan(vlan_id);
2694 if (!vlan) {
2695 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
2696 return -1;
2697 }
2698 if (!strcmp(device, "nic")) {
2699 NICInfo *nd;
2700 uint8_t *macaddr;
2701
2702 if (nb_nics >= MAX_NICS) {
2703 fprintf(stderr, "Too Many NICs\n");
2704 return -1;
2705 }
2706 nd = &nd_table[nb_nics];
2707 macaddr = nd->macaddr;
2708 macaddr[0] = 0x52;
2709 macaddr[1] = 0x54;
2710 macaddr[2] = 0x00;
2711 macaddr[3] = 0x12;
2712 macaddr[4] = 0x34;
2713 macaddr[5] = 0x56 + nb_nics;
2714
2715 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
2716 if (parse_macaddr(macaddr, buf) < 0) {
2717 fprintf(stderr, "invalid syntax for ethernet address\n");
2718 return -1;
2719 }
2720 }
2721 if (get_param_value(buf, sizeof(buf), "model", p)) {
2722 nd->model = strdup(buf);
2723 }
2724 nd->vlan = vlan;
2725 nb_nics++;
2726 ret = 0;
2727 } else
2728 if (!strcmp(device, "none")) {
2729 /* does nothing. It is needed to signal that no network cards
2730 are wanted */
2731 ret = 0;
2732 } else
2733 #ifdef CONFIG_SLIRP
2734 if (!strcmp(device, "user")) {
2735 ret = net_slirp_init(vlan);
2736 } else
2737 #endif
2738 #ifdef _WIN32
2739 if (!strcmp(device, "tap")) {
2740 char ifname[64];
2741 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
2742 fprintf(stderr, "tap: no interface name\n");
2743 return -1;
2744 }
2745 ret = tap_win32_init(vlan, ifname);
2746 } else
2747 #else
2748 if (!strcmp(device, "tap")) {
2749 char ifname[64];
2750 char setup_script[1024];
2751 int fd;
2752 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
2753 fd = strtol(buf, NULL, 0);
2754 ret = -1;
2755 if (net_tap_fd_init(vlan, fd))
2756 ret = 0;
2757 } else {
2758 get_param_value(ifname, sizeof(ifname), "ifname", p);
2759 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
2760 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
2761 }
2762 ret = net_tap_init(vlan, ifname, setup_script);
2763 }
2764 } else
2765 #endif
2766 if (!strcmp(device, "socket")) {
2767 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
2768 int fd;
2769 fd = strtol(buf, NULL, 0);
2770 ret = -1;
2771 if (net_socket_fd_init(vlan, fd, 1))
2772 ret = 0;
2773 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
2774 ret = net_socket_listen_init(vlan, buf);
2775 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
2776 ret = net_socket_connect_init(vlan, buf);
2777 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
2778 ret = net_socket_mcast_init(vlan, buf);
2779 } else {
2780 fprintf(stderr, "Unknown socket options: %s\n", p);
2781 return -1;
2782 }
2783 } else
2784 {
2785 fprintf(stderr, "Unknown network device: %s\n", device);
2786 return -1;
2787 }
2788 if (ret < 0) {
2789 fprintf(stderr, "Could not initialize device '%s'\n", device);
2790 }
2791
2792 return ret;
2793 }
2794
2795 void do_info_network(void)
2796 {
2797 VLANState *vlan;
2798 VLANClientState *vc;
2799
2800 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2801 term_printf("VLAN %d devices:\n", vlan->id);
2802 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
2803 term_printf(" %s\n", vc->info_str);
2804 }
2805 }
2806
2807 /***********************************************************/
2808 /* USB devices */
2809
2810 static int usb_device_add(const char *devname)
2811 {
2812 const char *p;
2813 USBDevice *dev;
2814 int i;
2815
2816 if (!vm_usb_hub)
2817 return -1;
2818 for(i = 0;i < MAX_VM_USB_PORTS; i++) {
2819 if (!vm_usb_ports[i]->dev)
2820 break;
2821 }
2822 if (i == MAX_VM_USB_PORTS)
2823 return -1;
2824
2825 if (strstart(devname, "host:", &p)) {
2826 dev = usb_host_device_open(p);
2827 if (!dev)
2828 return -1;
2829 } else if (!strcmp(devname, "mouse")) {
2830 dev = usb_mouse_init();
2831 if (!dev)
2832 return -1;
2833 } else {
2834 return -1;
2835 }
2836 usb_attach(vm_usb_ports[i], dev);
2837 return 0;
2838 }
2839
2840 static int usb_device_del(const char *devname)
2841 {
2842 USBDevice *dev;
2843 int bus_num, addr, i;
2844 const char *p;
2845
2846 if (!vm_usb_hub)
2847 return -1;
2848
2849 p = strchr(devname, '.');
2850 if (!p)
2851 return -1;
2852 bus_num = strtoul(devname, NULL, 0);
2853 addr = strtoul(p + 1, NULL, 0);
2854 if (bus_num != 0)
2855 return -1;
2856 for(i = 0;i < MAX_VM_USB_PORTS; i++) {
2857 dev = vm_usb_ports[i]->dev;
2858 if (dev && dev->addr == addr)
2859 break;
2860 }
2861 if (i == MAX_VM_USB_PORTS)
2862 return -1;
2863 usb_attach(vm_usb_ports[i], NULL);
2864 return 0;
2865 }
2866
2867 void do_usb_add(const char *devname)
2868 {
2869 int ret;
2870 ret = usb_device_add(devname);
2871 if (ret < 0)
2872 term_printf("Could not add USB device '%s'\n", devname);
2873 }
2874
2875 void do_usb_del(const char *devname)
2876 {
2877 int ret;
2878 ret = usb_device_del(devname);
2879 if (ret < 0)
2880 term_printf("Could not remove USB device '%s'\n", devname);
2881 }
2882
2883 void usb_info(void)
2884 {
2885 USBDevice *dev;
2886 int i;
2887 const char *speed_str;
2888
2889 if (!vm_usb_hub) {
2890 term_printf("USB support not enabled\n");
2891 return;
2892 }
2893
2894 for(i = 0; i < MAX_VM_USB_PORTS; i++) {
2895 dev = vm_usb_ports[i]->dev;
2896 if (dev) {
2897 term_printf("Hub port %d:\n", i);
2898 switch(dev->speed) {
2899 case USB_SPEED_LOW:
2900 speed_str = "1.5";
2901 break;
2902 case USB_SPEED_FULL:
2903 speed_str = "12";
2904 break;
2905 case USB_SPEED_HIGH:
2906 speed_str = "480";
2907 break;
2908 default:
2909 speed_str = "?";
2910 break;
2911 }
2912 term_printf(" Device %d.%d, speed %s Mb/s\n",
2913 0, dev->addr, speed_str);
2914 }
2915 }
2916 }
2917
2918 /***********************************************************/
2919 /* pid file */
2920
2921 static char *pid_filename;
2922
2923 /* Remove PID file. Called on normal exit */
2924
2925 static void remove_pidfile(void)
2926 {
2927 unlink (pid_filename);
2928 }
2929
2930 static void create_pidfile(const char *filename)
2931 {
2932 struct stat pidstat;
2933 FILE *f;
2934
2935 /* Try to write our PID to the named file */
2936 if (stat(filename, &pidstat) < 0) {
2937 if (errno == ENOENT) {
2938 if ((f = fopen (filename, "w")) == NULL) {
2939 perror("Opening pidfile");
2940 exit(1);
2941 }
2942 fprintf(f, "%d\n", getpid());
2943 fclose(f);
2944 pid_filename = qemu_strdup(filename);
2945 if (!pid_filename) {
2946 fprintf(stderr, "Could not save PID filename");
2947 exit(1);
2948 }
2949 atexit(remove_pidfile);
2950 }
2951 } else {
2952 fprintf(stderr, "%s already exists. Remove it and try again.\n",
2953 filename);
2954 exit(1);
2955 }
2956 }
2957
2958 /***********************************************************/
2959 /* dumb display */
2960
2961 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
2962 {
2963 }
2964
2965 static void dumb_resize(DisplayState *ds, int w, int h)
2966 {
2967 }
2968
2969 static void dumb_refresh(DisplayState *ds)
2970 {
2971 vga_update_display();
2972 }
2973
2974 void dumb_display_init(DisplayState *ds)
2975 {
2976 ds->data = NULL;
2977 ds->linesize = 0;
2978 ds->depth = 0;
2979 ds->dpy_update = dumb_update;
2980 ds->dpy_resize = dumb_resize;
2981 ds->dpy_refresh = dumb_refresh;
2982 }
2983
2984 #if !defined(CONFIG_SOFTMMU)
2985 /***********************************************************/
2986 /* cpu signal handler */
2987 static void host_segv_handler(int host_signum, siginfo_t *info,
2988 void *puc)
2989 {
2990 if (cpu_signal_handler(host_signum, info, puc))
2991 return;
2992 if (stdio_nb_clients > 0)
2993 term_exit();
2994 abort();
2995 }
2996 #endif
2997
2998 /***********************************************************/
2999 /* I/O handling */
3000
3001 #define MAX_IO_HANDLERS 64
3002
3003 typedef struct IOHandlerRecord {
3004 int fd;
3005 IOCanRWHandler *fd_read_poll;
3006 IOHandler *fd_read;
3007 IOHandler *fd_write;
3008 void *opaque;
3009 /* temporary data */
3010 struct pollfd *ufd;
3011 struct IOHandlerRecord *next;
3012 } IOHandlerRecord;
3013
3014 static IOHandlerRecord *first_io_handler;
3015
3016 /* XXX: fd_read_poll should be suppressed, but an API change is
3017 necessary in the character devices to suppress fd_can_read(). */
3018 int qemu_set_fd_handler2(int fd,
3019 IOCanRWHandler *fd_read_poll,
3020 IOHandler *fd_read,
3021 IOHandler *fd_write,
3022 void *opaque)
3023 {
3024 IOHandlerRecord **pioh, *ioh;
3025
3026 if (!fd_read && !fd_write) {
3027 pioh = &first_io_handler;
3028 for(;;) {
3029 ioh = *pioh;
3030 if (ioh == NULL)
3031 break;
3032 if (ioh->fd == fd) {
3033 *pioh = ioh->next;
3034 qemu_free(ioh);
3035 break;
3036 }
3037 pioh = &ioh->next;
3038 }
3039 } else {
3040 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3041 if (ioh->fd == fd)
3042 goto found;
3043 }
3044 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
3045 if (!ioh)
3046 return -1;
3047 ioh->next = first_io_handler;
3048 first_io_handler = ioh;
3049 found:
3050 ioh->fd = fd;
3051 ioh->fd_read_poll = fd_read_poll;
3052 ioh->fd_read = fd_read;
3053 ioh->fd_write = fd_write;
3054 ioh->opaque = opaque;
3055 }
3056 return 0;
3057 }
3058
3059 int qemu_set_fd_handler(int fd,
3060 IOHandler *fd_read,
3061 IOHandler *fd_write,
3062 void *opaque)
3063 {
3064 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
3065 }
3066
3067 /***********************************************************/
3068 /* savevm/loadvm support */
3069
3070 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
3071 {
3072 fwrite(buf, 1, size, f);
3073 }
3074
3075 void qemu_put_byte(QEMUFile *f, int v)
3076 {
3077 fputc(v, f);
3078 }
3079
3080 void qemu_put_be16(QEMUFile *f, unsigned int v)
3081 {
3082 qemu_put_byte(f, v >> 8);
3083 qemu_put_byte(f, v);
3084 }
3085
3086 void qemu_put_be32(QEMUFile *f, unsigned int v)
3087 {
3088 qemu_put_byte(f, v >> 24);
3089 qemu_put_byte(f, v >> 16);
3090 qemu_put_byte(f, v >> 8);
3091 qemu_put_byte(f, v);
3092 }
3093
3094 void qemu_put_be64(QEMUFile *f, uint64_t v)
3095 {
3096 qemu_put_be32(f, v >> 32);
3097 qemu_put_be32(f, v);
3098 }
3099
3100 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size)
3101 {
3102 return fread(buf, 1, size, f);
3103 }
3104
3105 int qemu_get_byte(QEMUFile *f)
3106 {
3107 int v;
3108 v = fgetc(f);
3109 if (v == EOF)
3110 return 0;
3111 else
3112 return v;
3113 }
3114
3115 unsigned int qemu_get_be16(QEMUFile *f)
3116 {
3117 unsigned int v;
3118 v = qemu_get_byte(f) << 8;
3119 v |= qemu_get_byte(f);
3120 return v;
3121 }
3122
3123 unsigned int qemu_get_be32(QEMUFile *f)
3124 {
3125 unsigned int v;
3126 v = qemu_get_byte(f) << 24;
3127 v |= qemu_get_byte(f) << 16;
3128 v |= qemu_get_byte(f) << 8;
3129 v |= qemu_get_byte(f);
3130 return v;
3131 }
3132
3133 uint64_t qemu_get_be64(QEMUFile *f)
3134 {
3135 uint64_t v;
3136 v = (uint64_t)qemu_get_be32(f) << 32;
3137 v |= qemu_get_be32(f);
3138 return v;
3139 }
3140
3141 int64_t qemu_ftell(QEMUFile *f)
3142 {
3143 return ftell(f);
3144 }
3145
3146 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
3147 {
3148 if (fseek(f, pos, whence) < 0)
3149 return -1;
3150 return ftell(f);
3151 }
3152
3153 typedef struct SaveStateEntry {
3154 char idstr[256];
3155 int instance_id;
3156 int version_id;
3157 SaveStateHandler *save_state;
3158 LoadStateHandler *load_state;
3159 void *opaque;
3160 struct SaveStateEntry *next;
3161 } SaveStateEntry;
3162
3163 static SaveStateEntry *first_se;
3164
3165 int register_savevm(const char *idstr,
3166 int instance_id,
3167 int version_id,
3168 SaveStateHandler *save_state,
3169 LoadStateHandler *load_state,
3170 void *opaque)
3171 {
3172 SaveStateEntry *se, **pse;
3173
3174 se = qemu_malloc(sizeof(SaveStateEntry));
3175 if (!se)
3176 return -1;
3177 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
3178 se->instance_id = instance_id;
3179 se->version_id = version_id;
3180 se->save_state = save_state;
3181 se->load_state = load_state;
3182 se->opaque = opaque;
3183 se->next = NULL;
3184
3185 /* add at the end of list */
3186 pse = &first_se;
3187 while (*pse != NULL)
3188 pse = &(*pse)->next;
3189 *pse = se;
3190 return 0;
3191 }
3192
3193 #define QEMU_VM_FILE_MAGIC 0x5145564d
3194 #define QEMU_VM_FILE_VERSION 0x00000001
3195
3196 int qemu_savevm(const char *filename)
3197 {
3198 SaveStateEntry *se;
3199 QEMUFile *f;
3200 int len, len_pos, cur_pos, saved_vm_running, ret;
3201
3202 saved_vm_running = vm_running;
3203 vm_stop(0);
3204
3205 f = fopen(filename, "wb");
3206 if (!f) {
3207 ret = -1;
3208 goto the_end;
3209 }
3210
3211 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
3212 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
3213
3214 for(se = first_se; se != NULL; se = se->next) {
3215 /* ID string */
3216 len = strlen(se->idstr);
3217 qemu_put_byte(f, len);
3218 qemu_put_buffer(f, se->idstr, len);
3219
3220 qemu_put_be32(f, se->instance_id);
3221 qemu_put_be32(f, se->version_id);
3222
3223 /* record size: filled later */
3224 len_pos = ftell(f);
3225 qemu_put_be32(f, 0);
3226
3227 se->save_state(f, se->opaque);
3228
3229 /* fill record size */
3230 cur_pos = ftell(f);
3231 len = ftell(f) - len_pos - 4;
3232 fseek(f, len_pos, SEEK_SET);
3233 qemu_put_be32(f, len);
3234 fseek(f, cur_pos, SEEK_SET);
3235 }
3236
3237 fclose(f);
3238 ret = 0;
3239 the_end:
3240 if (saved_vm_running)
3241 vm_start();
3242 return ret;
3243 }
3244
3245 static SaveStateEntry *find_se(const char *idstr, int instance_id)
3246 {
3247 SaveStateEntry *se;
3248
3249 for(se = first_se; se != NULL; se = se->next) {
3250 if (!strcmp(se->idstr, idstr) &&
3251 instance_id == se->instance_id)
3252 return se;
3253 }
3254 return NULL;
3255 }
3256
3257 int qemu_loadvm(const char *filename)
3258 {
3259 SaveStateEntry *se;
3260 QEMUFile *f;
3261 int len, cur_pos, ret, instance_id, record_len, version_id;
3262 int saved_vm_running;
3263 unsigned int v;
3264 char idstr[256];
3265
3266 saved_vm_running = vm_running;
3267 vm_stop(0);
3268
3269 f = fopen(filename, "rb");
3270 if (!f) {
3271 ret = -1;
3272 goto the_end;
3273 }
3274
3275 v = qemu_get_be32(f);
3276 if (v != QEMU_VM_FILE_MAGIC)
3277 goto fail;
3278 v = qemu_get_be32(f);
3279 if (v != QEMU_VM_FILE_VERSION) {
3280 fail:
3281 fclose(f);
3282 ret = -1;
3283 goto the_end;
3284 }
3285 for(;;) {
3286 len = qemu_get_byte(f);
3287 if (feof(f))
3288 break;
3289 qemu_get_buffer(f, idstr, len);
3290 idstr[len] = '\0';
3291 instance_id = qemu_get_be32(f);
3292 version_id = qemu_get_be32(f);
3293 record_len = qemu_get_be32(f);
3294 #if 0
3295 printf("idstr=%s instance=0x%x version=%d len=%d\n",
3296 idstr, instance_id, version_id, record_len);
3297 #endif
3298 cur_pos = ftell(f);
3299 se = find_se(idstr, instance_id);
3300 if (!se) {
3301 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
3302 instance_id, idstr);
3303 } else {
3304 ret = se->load_state(f, se->opaque, version_id);
3305 if (ret < 0) {
3306 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
3307 instance_id, idstr);
3308 }
3309 }
3310 /* always seek to exact end of record */
3311 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
3312 }
3313 fclose(f);
3314 ret = 0;
3315 the_end:
3316 if (saved_vm_running)
3317 vm_start();
3318 return ret;
3319 }
3320
3321 /***********************************************************/
3322 /* cpu save/restore */
3323
3324 #if defined(TARGET_I386)
3325
3326 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
3327 {
3328 qemu_put_be32(f, dt->selector);
3329 qemu_put_betl(f, dt->base);
3330 qemu_put_be32(f, dt->limit);
3331 qemu_put_be32(f, dt->flags);
3332 }
3333
3334 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
3335 {
3336 dt->selector = qemu_get_be32(f);
3337 dt->base = qemu_get_betl(f);
3338 dt->limit = qemu_get_be32(f);
3339 dt->flags = qemu_get_be32(f);
3340 }
3341
3342 void cpu_save(QEMUFile *f, void *opaque)
3343 {
3344 CPUState *env = opaque;
3345 uint16_t fptag, fpus, fpuc, fpregs_format;
3346 uint32_t hflags;
3347 int i;
3348
3349 for(i = 0; i < CPU_NB_REGS; i++)
3350 qemu_put_betls(f, &env->regs[i]);
3351 qemu_put_betls(f, &env->eip);
3352 qemu_put_betls(f, &env->eflags);
3353 hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
3354 qemu_put_be32s(f, &hflags);
3355
3356 /* FPU */
3357 fpuc = env->fpuc;
3358 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
3359 fptag = 0;
3360 for(i = 0; i < 8; i++) {
3361 fptag |= ((!env->fptags[i]) << i);
3362 }
3363
3364 qemu_put_be16s(f, &fpuc);
3365 qemu_put_be16s(f, &fpus);
3366 qemu_put_be16s(f, &fptag);
3367
3368 #ifdef USE_X86LDOUBLE
3369 fpregs_format = 0;
3370 #else
3371 fpregs_format = 1;
3372 #endif
3373 qemu_put_be16s(f, &fpregs_format);
3374
3375 for(i = 0; i < 8; i++) {
3376 #ifdef USE_X86LDOUBLE
3377 {
3378 uint64_t mant;
3379 uint16_t exp;
3380 /* we save the real CPU data (in case of MMX usage only 'mant'
3381 contains the MMX register */
3382 cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
3383 qemu_put_be64(f, mant);
3384 qemu_put_be16(f, exp);
3385 }
3386 #else
3387 /* if we use doubles for float emulation, we save the doubles to
3388 avoid losing information in case of MMX usage. It can give
3389 problems if the image is restored on a CPU where long
3390 doubles are used instead. */
3391 qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
3392 #endif
3393 }
3394
3395 for(i = 0; i < 6; i++)
3396 cpu_put_seg(f, &env->segs[i]);
3397 cpu_put_seg(f, &env->ldt);
3398 cpu_put_seg(f, &env->tr);
3399 cpu_put_seg(f, &env->gdt);
3400 cpu_put_seg(f, &env->idt);
3401
3402 qemu_put_be32s(f, &env->sysenter_cs);
3403 qemu_put_be32s(f, &env->sysenter_esp);
3404 qemu_put_be32s(f, &env->sysenter_eip);
3405
3406 qemu_put_betls(f, &env->cr[0]);
3407 qemu_put_betls(f, &env->cr[2]);
3408 qemu_put_betls(f, &env->cr[3]);
3409 qemu_put_betls(f, &env->cr[4]);
3410
3411 for(i = 0; i < 8; i++)
3412 qemu_put_betls(f, &env->dr[i]);
3413
3414 /* MMU */
3415 qemu_put_be32s(f, &env->a20_mask);
3416
3417 /* XMM */
3418 qemu_put_be32s(f, &env->mxcsr);
3419 for(i = 0; i < CPU_NB_REGS; i++) {
3420 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
3421 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
3422 }
3423
3424 #ifdef TARGET_X86_64
3425 qemu_put_be64s(f, &env->efer);
3426 qemu_put_be64s(f, &env->star);
3427 qemu_put_be64s(f, &env->lstar);
3428 qemu_put_be64s(f, &env->cstar);
3429 qemu_put_be64s(f, &env->fmask);
3430 qemu_put_be64s(f, &env->kernelgsbase);
3431 #endif
3432 }
3433
3434 #ifdef USE_X86LDOUBLE
3435 /* XXX: add that in a FPU generic layer */
3436 union x86_longdouble {
3437 uint64_t mant;
3438 uint16_t exp;
3439 };
3440
3441 #define MANTD1(fp) (fp & ((1LL << 52) - 1))
3442 #define EXPBIAS1 1023
3443 #define EXPD1(fp) ((fp >> 52) & 0x7FF)
3444 #define SIGND1(fp) ((fp >> 32) & 0x80000000)
3445
3446 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
3447 {
3448 int e;
3449 /* mantissa */
3450 p->mant = (MANTD1(temp) << 11) | (1LL << 63);
3451 /* exponent + sign */
3452 e = EXPD1(temp) - EXPBIAS1 + 16383;
3453 e |= SIGND1(temp) >> 16;
3454 p->exp = e;
3455 }
3456 #endif
3457
3458 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3459 {
3460 CPUState *env = opaque;
3461 int i, guess_mmx;
3462 uint32_t hflags;
3463 uint16_t fpus, fpuc, fptag, fpregs_format;
3464
3465 if (version_id != 3)
3466 return -EINVAL;
3467 for(i = 0; i < CPU_NB_REGS; i++)
3468 qemu_get_betls(f, &env->regs[i]);
3469 qemu_get_betls(f, &env->eip);
3470 qemu_get_betls(f, &env->eflags);
3471 qemu_get_be32s(f, &hflags);
3472
3473 qemu_get_be16s(f, &fpuc);
3474 qemu_get_be16s(f, &fpus);
3475 qemu_get_be16s(f, &fptag);
3476 qemu_get_be16s(f, &fpregs_format);
3477
3478 /* NOTE: we cannot always restore the FPU state if the image come
3479 from a host with a different 'USE_X86LDOUBLE' define. We guess
3480 if we are in an MMX state to restore correctly in that case. */
3481 guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
3482 for(i = 0; i < 8; i++) {
3483 uint64_t mant;
3484 uint16_t exp;
3485
3486 switch(fpregs_format) {
3487 case 0:
3488 mant = qemu_get_be64(f);
3489 exp = qemu_get_be16(f);
3490 #ifdef USE_X86LDOUBLE
3491 env->fpregs[i].d = cpu_set_fp80(mant, exp);
3492 #else
3493 /* difficult case */
3494 if (guess_mmx)
3495 env->fpregs[i].mmx.MMX_Q(0) = mant;
3496 else
3497 env->fpregs[i].d = cpu_set_fp80(mant, exp);
3498 #endif
3499 break;
3500 case 1:
3501 mant = qemu_get_be64(f);
3502 #ifdef USE_X86LDOUBLE
3503 {
3504 union x86_longdouble *p;
3505 /* difficult case */
3506 p = (void *)&env->fpregs[i];
3507 if (guess_mmx) {
3508 p->mant = mant;
3509 p->exp = 0xffff;
3510 } else {
3511 fp64_to_fp80(p, mant);
3512 }
3513 }
3514 #else
3515 env->fpregs[i].mmx.MMX_Q(0) = mant;
3516 #endif
3517 break;
3518 default:
3519 return -EINVAL;
3520 }
3521 }
3522
3523 env->fpuc = fpuc;
3524 /* XXX: restore FPU round state */
3525 env->fpstt = (fpus >> 11) & 7;
3526 env->fpus = fpus & ~0x3800;
3527 fptag ^= 0xff;
3528 for(i = 0; i < 8; i++) {
3529 env->fptags[i] = (fptag >> i) & 1;
3530 }
3531
3532 for(i = 0; i < 6; i++)
3533 cpu_get_seg(f, &env->segs[i]);
3534 cpu_get_seg(f, &env->ldt);
3535 cpu_get_seg(f, &env->tr);
3536 cpu_get_seg(f, &env->gdt);
3537 cpu_get_seg(f, &env->idt);
3538
3539 qemu_get_be32s(f, &env->sysenter_cs);
3540 qemu_get_be32s(f, &env->sysenter_esp);
3541 qemu_get_be32s(f, &env->sysenter_eip);
3542
3543 qemu_get_betls(f, &env->cr[0]);
3544 qemu_get_betls(f, &env->cr[2]);
3545 qemu_get_betls(f, &env->cr[3]);
3546 qemu_get_betls(f, &env->cr[4]);
3547
3548 for(i = 0; i < 8; i++)
3549 qemu_get_betls(f, &env->dr[i]);
3550
3551 /* MMU */
3552 qemu_get_be32s(f, &env->a20_mask);
3553
3554 qemu_get_be32s(f, &env->mxcsr);
3555 for(i = 0; i < CPU_NB_REGS; i++) {
3556 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
3557 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
3558 }
3559
3560 #ifdef TARGET_X86_64
3561 qemu_get_be64s(f, &env->efer);
3562 qemu_get_be64s(f, &env->star);
3563 qemu_get_be64s(f, &env->lstar);
3564 qemu_get_be64s(f, &env->cstar);
3565 qemu_get_be64s(f, &env->fmask);
3566 qemu_get_be64s(f, &env->kernelgsbase);
3567 #endif
3568
3569 /* XXX: compute hflags from scratch, except for CPL and IIF */
3570 env->hflags = hflags;
3571 tlb_flush(env, 1);
3572 return 0;
3573 }
3574
3575 #elif defined(TARGET_PPC)
3576 void cpu_save(QEMUFile *f, void *opaque)
3577 {
3578 }
3579
3580 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3581 {
3582 return 0;
3583 }
3584
3585 #elif defined(TARGET_MIPS)
3586 void cpu_save(QEMUFile *f, void *opaque)
3587 {
3588 }
3589
3590 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3591 {
3592 return 0;
3593 }
3594
3595 #elif defined(TARGET_SPARC)
3596 void cpu_save(QEMUFile *f, void *opaque)
3597 {
3598 CPUState *env = opaque;
3599 int i;
3600 uint32_t tmp;
3601
3602 for(i = 0; i < 8; i++)
3603 qemu_put_betls(f, &env->gregs[i]);
3604 for(i = 0; i < NWINDOWS * 16; i++)
3605 qemu_put_betls(f, &env->regbase[i]);
3606
3607 /* FPU */
3608 for(i = 0; i < TARGET_FPREGS; i++) {
3609 union {
3610 TARGET_FPREG_T f;
3611 target_ulong i;
3612 } u;
3613 u.f = env->fpr[i];
3614 qemu_put_betl(f, u.i);
3615 }
3616
3617 qemu_put_betls(f, &env->pc);
3618 qemu_put_betls(f, &env->npc);
3619 qemu_put_betls(f, &env->y);
3620 tmp = GET_PSR(env);
3621 qemu_put_be32(f, tmp);
3622 qemu_put_betls(f, &env->fsr);
3623 qemu_put_betls(f, &env->tbr);
3624 #ifndef TARGET_SPARC64
3625 qemu_put_be32s(f, &env->wim);
3626 /* MMU */
3627 for(i = 0; i < 16; i++)
3628 qemu_put_be32s(f, &env->mmuregs[i]);
3629 #endif
3630 }
3631
3632 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3633 {
3634 CPUState *env = opaque;
3635 int i;
3636 uint32_t tmp;
3637
3638 for(i = 0; i < 8; i++)
3639 qemu_get_betls(f, &env->gregs[i]);
3640 for(i = 0; i < NWINDOWS * 16; i++)
3641 qemu_get_betls(f, &env->regbase[i]);
3642
3643 /* FPU */
3644 for(i = 0; i < TARGET_FPREGS; i++) {
3645 union {
3646 TARGET_FPREG_T f;
3647 target_ulong i;
3648 } u;
3649 u.i = qemu_get_betl(f);
3650 env->fpr[i] = u.f;
3651 }
3652
3653 qemu_get_betls(f, &env->pc);
3654 qemu_get_betls(f, &env->npc);
3655 qemu_get_betls(f, &env->y);
3656 tmp = qemu_get_be32(f);
3657 env->cwp = 0; /* needed to ensure that the wrapping registers are
3658 correctly updated */
3659 PUT_PSR(env, tmp);
3660 qemu_get_betls(f, &env->fsr);
3661 qemu_get_betls(f, &env->tbr);
3662 #ifndef TARGET_SPARC64
3663 qemu_get_be32s(f, &env->wim);
3664 /* MMU */
3665 for(i = 0; i < 16; i++)
3666 qemu_get_be32s(f, &env->mmuregs[i]);
3667 #endif
3668 tlb_flush(env, 1);
3669 return 0;
3670 }
3671
3672 #elif defined(TARGET_ARM)
3673
3674 /* ??? Need to implement these. */
3675 void cpu_save(QEMUFile *f, void *opaque)
3676 {
3677 }
3678
3679 int cpu_load(QEMUFile *f, void *opaque, int version_id)
3680 {
3681 return 0;
3682 }
3683
3684 #else
3685
3686 #warning No CPU save/restore functions
3687
3688 #endif
3689
3690 /***********************************************************/
3691 /* ram save/restore */
3692
3693 /* we just avoid storing empty pages */
3694 static void ram_put_page(QEMUFile *f, const uint8_t *buf, int len)
3695 {
3696 int i, v;
3697
3698 v = buf[0];
3699 for(i = 1; i < len; i++) {
3700 if (buf[i] != v)
3701 goto normal_save;
3702 }
3703 qemu_put_byte(f, 1);
3704 qemu_put_byte(f, v);
3705 return;
3706 normal_save:
3707 qemu_put_byte(f, 0);
3708 qemu_put_buffer(f, buf, len);
3709 }
3710
3711 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3712 {
3713 int v;
3714
3715 v = qemu_get_byte(f);
3716 switch(v) {
3717 case 0:
3718 if (qemu_get_buffer(f, buf, len) != len)
3719 return -EIO;
3720 break;
3721 case 1:
3722 v = qemu_get_byte(f);
3723 memset(buf, v, len);
3724 break;
3725 default:
3726 return -EINVAL;
3727 }
3728 return 0;
3729 }
3730
3731 static void ram_save(QEMUFile *f, void *opaque)
3732 {
3733 int i;
3734 qemu_put_be32(f, phys_ram_size);
3735 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3736 ram_put_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3737 }
3738 }
3739
3740 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3741 {
3742 int i, ret;
3743
3744 if (version_id != 1)
3745 return -EINVAL;
3746 if (qemu_get_be32(f) != phys_ram_size)
3747 return -EINVAL;
3748 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3749 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3750 if (ret)
3751 return ret;
3752 }
3753 return 0;
3754 }
3755
3756 /***********************************************************/
3757 /* machine registration */
3758
3759 QEMUMachine *first_machine = NULL;
3760
3761 int qemu_register_machine(QEMUMachine *m)
3762 {
3763 QEMUMachine **pm;
3764 pm = &first_machine;
3765 while (*pm != NULL)
3766 pm = &(*pm)->next;
3767 m->next = NULL;
3768 *pm = m;
3769 return 0;
3770 }
3771
3772 QEMUMachine *find_machine(const char *name)
3773 {
3774 QEMUMachine *m;
3775
3776 for(m = first_machine; m != NULL; m = m->next) {
3777 if (!strcmp(m->name, name))
3778 return m;
3779 }
3780 return NULL;
3781 }
3782
3783 /***********************************************************/
3784 /* main execution loop */
3785
3786 void gui_update(void *opaque)
3787 {
3788 display_state.dpy_refresh(&display_state);
3789 qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
3790 }
3791
3792 struct vm_change_state_entry {
3793 VMChangeStateHandler *cb;
3794 void *opaque;
3795 LIST_ENTRY (vm_change_state_entry) entries;
3796 };
3797
3798 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3799
3800 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3801 void *opaque)
3802 {
3803 VMChangeStateEntry *e;
3804
3805 e = qemu_mallocz(sizeof (*e));
3806 if (!e)
3807 return NULL;
3808
3809 e->cb = cb;
3810 e->opaque = opaque;
3811 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3812 return e;
3813 }
3814
3815 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3816 {
3817 LIST_REMOVE (e, entries);
3818 qemu_free (e);
3819 }
3820
3821 static void vm_state_notify(int running)
3822 {
3823 VMChangeStateEntry *e;
3824
3825 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3826 e->cb(e->opaque, running);
3827 }
3828 }
3829
3830 /* XXX: support several handlers */
3831 static VMStopHandler *vm_stop_cb;
3832 static void *vm_stop_opaque;
3833
3834 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
3835 {
3836 vm_stop_cb = cb;
3837 vm_stop_opaque = opaque;
3838 return 0;
3839 }
3840
3841 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
3842 {
3843 vm_stop_cb = NULL;
3844 }
3845
3846 void vm_start(void)
3847 {
3848 if (!vm_running) {
3849 cpu_enable_ticks();
3850 vm_running = 1;
3851 vm_state_notify(1);
3852 }
3853 }
3854
3855 void vm_stop(int reason)
3856 {
3857 if (vm_running) {
3858 cpu_disable_ticks();
3859 vm_running = 0;
3860 if (reason != 0) {
3861 if (vm_stop_cb) {
3862 vm_stop_cb(vm_stop_opaque, reason);
3863 }
3864 }
3865 vm_state_notify(0);
3866 }
3867 }
3868
3869 /* reset/shutdown handler */
3870
3871 typedef struct QEMUResetEntry {
3872 QEMUResetHandler *func;
3873 void *opaque;
3874 struct QEMUResetEntry *next;
3875 } QEMUResetEntry;
3876
3877 static QEMUResetEntry *first_reset_entry;
3878 static int reset_requested;
3879 static int shutdown_requested;
3880 static int powerdown_requested;
3881
3882 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3883 {
3884 QEMUResetEntry **pre, *re;
3885
3886 pre = &first_reset_entry;
3887 while (*pre != NULL)
3888 pre = &(*pre)->next;
3889 re = qemu_mallocz(sizeof(QEMUResetEntry));
3890 re->func = func;
3891 re->opaque = opaque;
3892 re->next = NULL;
3893 *pre = re;
3894 }
3895
3896 void qemu_system_reset(void)
3897 {
3898 QEMUResetEntry *re;
3899
3900 /* reset all devices */
3901 for(re = first_reset_entry; re != NULL; re = re->next) {
3902 re->func(re->opaque);
3903 }
3904 }
3905
3906 void qemu_system_reset_request(void)
3907 {
3908 reset_requested = 1;
3909 if (cpu_single_env)
3910 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3911 }
3912
3913 void qemu_system_shutdown_request(void)
3914 {
3915 shutdown_requested = 1;
3916 if (cpu_single_env)
3917 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3918 }
3919
3920 void qemu_system_powerdown_request(void)
3921 {
3922 powerdown_requested = 1;
3923 if (cpu_single_env)
3924 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3925 }
3926
3927 void main_loop_wait(int timeout)
3928 {
3929 IOHandlerRecord *ioh, *ioh_next;
3930 fd_set rfds, wfds;
3931 int ret, nfds;
3932 struct timeval tv;
3933
3934 #ifdef _WIN32
3935 /* XXX: see how to merge it with the select. The constraint is
3936 that the select must be interrupted by the timer */
3937 if (timeout > 0)
3938 Sleep(timeout);
3939 #endif
3940 /* poll any events */
3941 /* XXX: separate device handlers from system ones */
3942 nfds = -1;
3943 FD_ZERO(&rfds);
3944 FD_ZERO(&wfds);
3945 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3946 if (ioh->fd_read &&
3947 (!ioh->fd_read_poll ||
3948 ioh->fd_read_poll(ioh->opaque) != 0)) {
3949 FD_SET(ioh->fd, &rfds);
3950 if (ioh->fd > nfds)
3951 nfds = ioh->fd;
3952 }
3953 if (ioh->fd_write) {
3954 FD_SET(ioh->fd, &wfds);
3955 if (ioh->fd > nfds)
3956 nfds = ioh->fd;
3957 }
3958 }
3959
3960 tv.tv_sec = 0;
3961 #ifdef _WIN32
3962 tv.tv_usec = 0;
3963 #else
3964 tv.tv_usec = timeout * 1000;
3965 #endif
3966 ret = select(nfds + 1, &rfds, &wfds, NULL, &tv);
3967 if (ret > 0) {
3968 /* XXX: better handling of removal */
3969 for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
3970 ioh_next = ioh->next;
3971 if (FD_ISSET(ioh->fd, &rfds)) {
3972 ioh->fd_read(ioh->opaque);
3973 }
3974 if (FD_ISSET(ioh->fd, &wfds)) {
3975 ioh->fd_write(ioh->opaque);
3976 }
3977 }
3978 }
3979 #ifdef _WIN32
3980 tap_win32_poll();
3981 #endif
3982
3983 #if defined(CONFIG_SLIRP)
3984 /* XXX: merge with the previous select() */
3985 if (slirp_inited) {
3986 fd_set rfds, wfds, xfds;
3987 int nfds;
3988 struct timeval tv;
3989
3990 nfds = -1;
3991 FD_ZERO(&rfds);
3992 FD_ZERO(&wfds);
3993 FD_ZERO(&xfds);
3994 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3995 tv.tv_sec = 0;
3996 tv.tv_usec = 0;
3997 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3998 if (ret >= 0) {
3999 slirp_select_poll(&rfds, &wfds, &xfds);
4000 }
4001 }
4002 #endif
4003
4004 if (vm_running) {
4005 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4006 qemu_get_clock(vm_clock));
4007 /* run dma transfers, if any */
4008 DMA_run();
4009 }
4010
4011 /* real time timers */
4012 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4013 qemu_get_clock(rt_clock));
4014 }
4015
4016 static CPUState *cur_cpu;
4017
4018 int main_loop(void)
4019 {
4020 int ret, timeout;
4021 CPUState *env;
4022
4023 cur_cpu = first_cpu;
4024 for(;;) {
4025 if (vm_running) {
4026
4027 env = cur_cpu;
4028 for(;;) {
4029 /* get next cpu */
4030 env = env->next_cpu;
4031 if (!env)
4032 env = first_cpu;
4033 ret = cpu_exec(env);
4034 if (ret != EXCP_HALTED)
4035 break;
4036 /* all CPUs are halted ? */
4037 if (env == cur_cpu) {
4038 ret = EXCP_HLT;
4039 break;
4040 }
4041 }
4042 cur_cpu = env;
4043
4044 if (shutdown_requested) {
4045 ret = EXCP_INTERRUPT;
4046 break;
4047 }
4048 if (reset_requested) {
4049 reset_requested = 0;
4050 qemu_system_reset();
4051 ret = EXCP_INTERRUPT;
4052 }
4053 if (powerdown_requested) {
4054 powerdown_requested = 0;
4055 qemu_system_powerdown();
4056 ret = EXCP_INTERRUPT;
4057 }
4058 if (ret == EXCP_DEBUG) {
4059 vm_stop(EXCP_DEBUG);
4060 }
4061 /* if hlt instruction, we wait until the next IRQ */
4062 /* XXX: use timeout computed from timers */
4063 if (ret == EXCP_HLT)
4064 timeout = 10;
4065 else
4066 timeout = 0;
4067 } else {
4068 timeout = 10;
4069 }
4070 main_loop_wait(timeout);
4071 }
4072 cpu_disable_ticks();
4073 return ret;
4074 }
4075
4076 void help(void)
4077 {
4078 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2005 Fabrice Bellard\n"
4079 "usage: %s [options] [disk_image]\n"
4080 "\n"
4081 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4082 "\n"
4083 "Standard options:\n"
4084 "-M machine select emulated machine (-M ? for list)\n"
4085 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
4086 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
4087 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
4088 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
4089 "-boot [a|c|d] boot on floppy (a), hard disk (c) or CD-ROM (d)\n"
4090 "-snapshot write to temporary files instead of disk image files\n"
4091 "-m megs set virtual RAM size to megs MB [default=%d]\n"
4092 "-smp n set the number of CPUs to 'n' [default=1]\n"
4093 "-nographic disable graphical output and redirect serial I/Os to console\n"
4094 #ifndef _WIN32
4095 "-k language use keyboard layout (for example \"fr\" for French)\n"
4096 #endif
4097 #ifdef HAS_AUDIO
4098 "-audio-help print list of audio drivers and their options\n"
4099 "-soundhw c1,... enable audio support\n"
4100 " and only specified sound cards (comma separated list)\n"
4101 " use -soundhw ? to get the list of supported cards\n"
4102 " use -soundhw all to enable all of them\n"
4103 #endif
4104 "-localtime set the real time clock to local time [default=utc]\n"
4105 "-full-screen start in full screen\n"
4106 #ifdef TARGET_I386
4107 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
4108 #endif
4109 "-usb enable the USB driver (will be the default soon)\n"
4110 "-usbdevice name add the host or guest USB device 'name'\n"
4111 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4112 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
4113 #endif
4114 "\n"
4115 "Network options:\n"
4116 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
4117 " create a new Network Interface Card and connect it to VLAN 'n'\n"
4118 #ifdef CONFIG_SLIRP
4119 "-net user[,vlan=n]\n"
4120 " connect the user mode network stack to VLAN 'n'\n"
4121 #endif
4122 #ifdef _WIN32
4123 "-net tap[,vlan=n],ifname=name\n"
4124 " connect the host TAP network interface to VLAN 'n'\n"
4125 #else
4126 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file]\n"
4127 " connect the host TAP network interface to VLAN 'n' and use\n"
4128 " the network script 'file' (default=%s);\n"
4129 " use 'fd=h' to connect to an already opened TAP interface\n"
4130 #endif
4131 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
4132 " connect the vlan 'n' to another VLAN using a socket connection\n"
4133 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
4134 " connect the vlan 'n' to multicast maddr and port\n"
4135 "-net none use it alone to have zero network devices; if no -net option\n"
4136 " is provided, the default is '-net nic -net user'\n"
4137 "\n"
4138 #ifdef CONFIG_SLIRP
4139 "-tftp prefix allow tftp access to files starting with prefix [-net user]\n"
4140 #ifndef _WIN32
4141 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
4142 #endif
4143 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
4144 " redirect TCP or UDP connections from host to guest [-net user]\n"
4145 #endif
4146 "\n"
4147 "Linux boot specific:\n"
4148 "-kernel bzImage use 'bzImage' as kernel image\n"
4149 "-append cmdline use 'cmdline' as kernel command line\n"
4150 "-initrd file use 'file' as initial ram disk\n"
4151 "\n"
4152 "Debug/Expert options:\n"
4153 "-monitor dev redirect the monitor to char device 'dev'\n"
4154 "-serial dev redirect the serial port to char device 'dev'\n"
4155 "-parallel dev redirect the parallel port to char device 'dev'\n"
4156 "-pidfile file Write PID to 'file'\n"
4157 "-S freeze CPU at startup (use 'c' to start execution)\n"
4158 "-s wait gdb connection to port %d\n"
4159 "-p port change gdb connection port\n"
4160 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
4161 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
4162 " translation (t=none or lba) (usually qemu can guess them)\n"
4163 "-L path set the directory for the BIOS and VGA BIOS\n"
4164 #ifdef USE_KQEMU
4165 "-no-kqemu disable KQEMU kernel module usage\n"
4166 #endif
4167 #ifdef USE_CODE_COPY
4168 "-no-code-copy disable code copy acceleration\n"
4169 #endif
4170 #ifdef TARGET_I386
4171 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
4172 " (default is CL-GD5446 PCI VGA)\n"
4173 #endif
4174 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
4175 "\n"
4176 "During emulation, the following keys are useful:\n"
4177 "ctrl-alt-f toggle full screen\n"
4178 "ctrl-alt-n switch to virtual console 'n'\n"
4179 "ctrl-alt toggle mouse and keyboard grab\n"
4180 "\n"
4181 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4182 ,
4183 #ifdef CONFIG_SOFTMMU
4184 "qemu",
4185 #else
4186 "qemu-fast",
4187 #endif
4188 DEFAULT_RAM_SIZE,
4189 #ifndef _WIN32
4190 DEFAULT_NETWORK_SCRIPT,
4191 #endif
4192 DEFAULT_GDBSTUB_PORT,
4193 "/tmp/qemu.log");
4194 #ifndef CONFIG_SOFTMMU
4195 printf("\n"
4196 "NOTE: this version of QEMU is faster but it needs slightly patched OSes to\n"
4197 "work. Please use the 'qemu' executable to have a more accurate (but slower)\n"
4198 "PC emulation.\n");
4199 #endif
4200 exit(1);
4201 }
4202
4203 #define HAS_ARG 0x0001
4204
4205 enum {
4206 QEMU_OPTION_h,
4207
4208 QEMU_OPTION_M,
4209 QEMU_OPTION_fda,
4210 QEMU_OPTION_fdb,
4211 QEMU_OPTION_hda,
4212 QEMU_OPTION_hdb,
4213 QEMU_OPTION_hdc,
4214 QEMU_OPTION_hdd,
4215 QEMU_OPTION_cdrom,
4216 QEMU_OPTION_boot,
4217 QEMU_OPTION_snapshot,
4218 QEMU_OPTION_m,
4219 QEMU_OPTION_nographic,
4220 #ifdef HAS_AUDIO
4221 QEMU_OPTION_audio_help,
4222 QEMU_OPTION_soundhw,
4223 #endif
4224
4225 QEMU_OPTION_net,
4226 QEMU_OPTION_tftp,
4227 QEMU_OPTION_smb,
4228 QEMU_OPTION_redir,
4229
4230 QEMU_OPTION_kernel,
4231 QEMU_OPTION_append,
4232 QEMU_OPTION_initrd,
4233
4234 QEMU_OPTION_S,
4235 QEMU_OPTION_s,
4236 QEMU_OPTION_p,
4237 QEMU_OPTION_d,
4238 QEMU_OPTION_hdachs,
4239 QEMU_OPTION_L,
4240 QEMU_OPTION_no_code_copy,
4241 QEMU_OPTION_k,
4242 QEMU_OPTION_localtime,
4243 QEMU_OPTION_cirrusvga,
4244 QEMU_OPTION_g,
4245 QEMU_OPTION_std_vga,
4246 QEMU_OPTION_monitor,
4247 QEMU_OPTION_serial,
4248 QEMU_OPTION_parallel,
4249 QEMU_OPTION_loadvm,
4250 QEMU_OPTION_full_screen,
4251 QEMU_OPTION_pidfile,
4252 QEMU_OPTION_no_kqemu,
4253 QEMU_OPTION_win2k_hack,
4254 QEMU_OPTION_usb,
4255 QEMU_OPTION_usbdevice,
4256 QEMU_OPTION_smp,
4257 };
4258
4259 typedef struct QEMUOption {
4260 const char *name;
4261 int flags;
4262 int index;
4263 } QEMUOption;
4264
4265 const QEMUOption qemu_options[] = {
4266 { "h", 0, QEMU_OPTION_h },
4267
4268 { "M", HAS_ARG, QEMU_OPTION_M },
4269 { "fda", HAS_ARG, QEMU_OPTION_fda },
4270 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4271 { "hda", HAS_ARG, QEMU_OPTION_hda },
4272 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4273 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4274 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
4275 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
4276 { "boot", HAS_ARG, QEMU_OPTION_boot },
4277 { "snapshot", 0, QEMU_OPTION_snapshot },
4278 { "m", HAS_ARG, QEMU_OPTION_m },
4279 { "nographic", 0, QEMU_OPTION_nographic },
4280 { "k", HAS_ARG, QEMU_OPTION_k },
4281 #ifdef HAS_AUDIO
4282 { "audio-help", 0, QEMU_OPTION_audio_help },
4283 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4284 #endif
4285
4286 { "net", HAS_ARG, QEMU_OPTION_net},
4287 #ifdef CONFIG_SLIRP
4288 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
4289 #ifndef _WIN32
4290 { "smb", HAS_ARG, QEMU_OPTION_smb },
4291 #endif
4292 { "redir", HAS_ARG, QEMU_OPTION_redir },
4293 #endif
4294
4295 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4296 { "append", HAS_ARG, QEMU_OPTION_append },
4297 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4298
4299 { "S", 0, QEMU_OPTION_S },
4300 { "s", 0, QEMU_OPTION_s },
4301 { "p", HAS_ARG, QEMU_OPTION_p },
4302 { "d", HAS_ARG, QEMU_OPTION_d },
4303 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4304 { "L", HAS_ARG, QEMU_OPTION_L },
4305 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
4306 #ifdef USE_KQEMU
4307 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
4308 #endif
4309 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4310 { "g", 1, QEMU_OPTION_g },
4311 #endif
4312 { "localtime", 0, QEMU_OPTION_localtime },
4313 { "std-vga", 0, QEMU_OPTION_std_vga },
4314 { "monitor", 1, QEMU_OPTION_monitor },
4315 { "serial", 1, QEMU_OPTION_serial },
4316 { "parallel", 1, QEMU_OPTION_parallel },
4317 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4318 { "full-screen", 0, QEMU_OPTION_full_screen },
4319 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
4320 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4321 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4322 { "smp", HAS_ARG, QEMU_OPTION_smp },
4323
4324 /* temporary options */
4325 { "usb", 0, QEMU_OPTION_usb },
4326 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
4327 { NULL },
4328 };
4329
4330 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
4331
4332 /* this stack is only used during signal handling */
4333 #define SIGNAL_STACK_SIZE 32768
4334
4335 static uint8_t *signal_stack;
4336
4337 #endif
4338
4339 /* password input */
4340
4341 static BlockDriverState *get_bdrv(int index)
4342 {
4343 BlockDriverState *bs;
4344
4345 if (index < 4) {
4346 bs = bs_table[index];
4347 } else if (index < 6) {
4348 bs = fd_table[index - 4];
4349 } else {
4350 bs = NULL;
4351 }
4352 return bs;
4353 }
4354
4355 static void read_passwords(void)
4356 {
4357 BlockDriverState *bs;
4358 int i, j;
4359 char password[256];
4360
4361 for(i = 0; i < 6; i++) {
4362 bs = get_bdrv(i);
4363 if (bs && bdrv_is_encrypted(bs)) {
4364 term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
4365 for(j = 0; j < 3; j++) {
4366 monitor_readline("Password: ",
4367 1, password, sizeof(password));
4368 if (bdrv_set_key(bs, password) == 0)
4369 break;
4370 term_printf("invalid password\n");
4371 }
4372 }
4373 }
4374 }
4375
4376 /* XXX: currently we cannot use simultaneously different CPUs */
4377 void register_machines(void)
4378 {
4379 #if defined(TARGET_I386)
4380 qemu_register_machine(&pc_machine);
4381 qemu_register_machine(&isapc_machine);
4382 #elif defined(TARGET_PPC)
4383 qemu_register_machine(&heathrow_machine);
4384 qemu_register_machine(&core99_machine);
4385 qemu_register_machine(&prep_machine);
4386 #elif defined(TARGET_MIPS)
4387 qemu_register_machine(&mips_machine);
4388 #elif defined(TARGET_SPARC)
4389 #ifdef TARGET_SPARC64
4390 qemu_register_machine(&sun4u_machine);
4391 #else
4392 qemu_register_machine(&sun4m_machine);
4393 #endif
4394 #elif defined(TARGET_ARM)
4395 qemu_register_machine(&integratorcp_machine);
4396 #else
4397 #error unsupported CPU
4398 #endif
4399 }
4400
4401 #ifdef HAS_AUDIO
4402 struct soundhw soundhw[] = {
4403 {
4404 "sb16",
4405 "Creative Sound Blaster 16",
4406 0,
4407 1,
4408 { .init_isa = SB16_init }
4409 },
4410
4411 #ifdef CONFIG_ADLIB
4412 {
4413 "adlib",
4414 #ifdef HAS_YMF262
4415 "Yamaha YMF262 (OPL3)",
4416 #else
4417 "Yamaha YM3812 (OPL2)",
4418 #endif
4419 0,
4420 1,
4421 { .init_isa = Adlib_init }
4422 },
4423 #endif
4424
4425 #ifdef CONFIG_GUS
4426 {
4427 "gus",
4428 "Gravis Ultrasound GF1",
4429 0,
4430 1,
4431 { .init_isa = GUS_init }
4432 },
4433 #endif
4434
4435 {
4436 "es1370",
4437 "ENSONIQ AudioPCI ES1370",
4438 0,
4439 0,
4440 { .init_pci = es1370_init }
4441 },
4442
4443 { NULL, NULL, 0, 0, { NULL } }
4444 };
4445
4446 static void select_soundhw (const char *optarg)
4447 {
4448 struct soundhw *c;
4449
4450 if (*optarg == '?') {
4451 show_valid_cards:
4452
4453 printf ("Valid sound card names (comma separated):\n");
4454 for (c = soundhw; c->name; ++c) {
4455 printf ("%-11s %s\n", c->name, c->descr);
4456 }
4457 printf ("\n-soundhw all will enable all of the above\n");
4458 exit (*optarg != '?');
4459 }
4460 else {
4461 size_t l;
4462 const char *p;
4463 char *e;
4464 int bad_card = 0;
4465
4466 if (!strcmp (optarg, "all")) {
4467 for (c = soundhw; c->name; ++c) {
4468 c->enabled = 1;
4469 }
4470 return;
4471 }
4472
4473 p = optarg;
4474 while (*p) {
4475 e = strchr (p, ',');
4476 l = !e ? strlen (p) : (size_t) (e - p);
4477
4478 for (c = soundhw; c->name; ++c) {
4479 if (!strncmp (c->name, p, l)) {
4480 c->enabled = 1;
4481 break;
4482 }
4483 }
4484
4485 if (!c->name) {
4486 if (l > 80) {
4487 fprintf (stderr,
4488 "Unknown sound card name (too big to show)\n");
4489 }
4490 else {
4491 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4492 (int) l, p);
4493 }
4494 bad_card = 1;
4495 }
4496 p += l + (e != NULL);
4497 }
4498
4499 if (bad_card)
4500 goto show_valid_cards;
4501 }
4502 }
4503 #endif
4504
4505 #define MAX_NET_CLIENTS 32
4506
4507 int main(int argc, char **argv)
4508 {
4509 #ifdef CONFIG_GDBSTUB
4510 int use_gdbstub, gdbstub_port;
4511 #endif
4512 int i, cdrom_index;
4513 int snapshot, linux_boot;
4514 const char *initrd_filename;
4515 const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
4516 const char *kernel_filename, *kernel_cmdline;
4517 DisplayState *ds = &display_state;
4518 int cyls, heads, secs, translation;
4519 int start_emulation = 1;
4520 char net_clients[MAX_NET_CLIENTS][256];
4521 int nb_net_clients;
4522 int optind;
4523 const char *r, *optarg;
4524 CharDriverState *monitor_hd;
4525 char monitor_device[128];
4526 char serial_devices[MAX_SERIAL_PORTS][128];
4527 int serial_device_index;
4528 char parallel_devices[MAX_PARALLEL_PORTS][128];
4529 int parallel_device_index;
4530 const char *loadvm = NULL;
4531 QEMUMachine *machine;
4532 char usb_devices[MAX_VM_USB_PORTS][128];
4533 int usb_devices_index;
4534
4535 LIST_INIT (&vm_change_state_head);
4536 #if !defined(CONFIG_SOFTMMU)
4537 /* we never want that malloc() uses mmap() */
4538 mallopt(M_MMAP_THRESHOLD, 4096 * 1024);
4539 #endif
4540 register_machines();
4541 machine = first_machine;
4542 initrd_filename = NULL;
4543 for(i = 0; i < MAX_FD; i++)
4544 fd_filename[i] = NULL;
4545 for(i = 0; i < MAX_DISKS; i++)
4546 hd_filename[i] = NULL;
4547 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
4548 vga_ram_size = VGA_RAM_SIZE;
4549 bios_size = BIOS_SIZE;
4550 #ifdef CONFIG_GDBSTUB
4551 use_gdbstub = 0;
4552 gdbstub_port = DEFAULT_GDBSTUB_PORT;
4553 #endif
4554 snapshot = 0;
4555 nographic = 0;
4556 kernel_filename = NULL;
4557 kernel_cmdline = "";
4558 #ifdef TARGET_PPC
4559 cdrom_index = 1;
4560 #else
4561 cdrom_index = 2;
4562 #endif
4563 cyls = heads = secs = 0;
4564 translation = BIOS_ATA_TRANSLATION_AUTO;
4565 pstrcpy(monitor_device, sizeof(monitor_device), "vc");
4566
4567 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
4568 for(i = 1; i < MAX_SERIAL_PORTS; i++)
4569 serial_devices[i][0] = '\0';
4570 serial_device_index = 0;
4571
4572 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
4573 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4574 parallel_devices[i][0] = '\0';
4575 parallel_device_index = 0;
4576
4577 usb_devices_index = 0;
4578
4579 nb_net_clients = 0;
4580
4581 nb_nics = 0;
4582 /* default mac address of the first network interface */
4583
4584 optind = 1;
4585 for(;;) {
4586 if (optind >= argc)
4587 break;
4588 r = argv[optind];
4589 if (r[0] != '-') {
4590 hd_filename[0] = argv[optind++];
4591 } else {
4592 const QEMUOption *popt;
4593
4594 optind++;
4595 popt = qemu_options;
4596 for(;;) {
4597 if (!popt->name) {
4598 fprintf(stderr, "%s: invalid option -- '%s'\n",
4599 argv[0], r);
4600 exit(1);
4601 }
4602 if (!strcmp(popt->name, r + 1))
4603 break;
4604 popt++;
4605 }
4606 if (popt->flags & HAS_ARG) {
4607 if (optind >= argc) {
4608 fprintf(stderr, "%s: option '%s' requires an argument\n",
4609 argv[0], r);
4610 exit(1);
4611 }
4612 optarg = argv[optind++];
4613 } else {
4614 optarg = NULL;
4615 }
4616
4617 switch(popt->index) {
4618 case QEMU_OPTION_M:
4619 machine = find_machine(optarg);
4620 if (!machine) {
4621 QEMUMachine *m;
4622 printf("Supported machines are:\n");
4623 for(m = first_machine; m != NULL; m = m->next) {
4624 printf("%-10s %s%s\n",
4625 m->name, m->desc,
4626 m == first_machine ? " (default)" : "");
4627 }
4628 exit(1);
4629 }
4630 break;
4631 case QEMU_OPTION_initrd:
4632 initrd_filename = optarg;
4633 break;
4634 case QEMU_OPTION_hda:
4635 case QEMU_OPTION_hdb:
4636 case QEMU_OPTION_hdc:
4637 case QEMU_OPTION_hdd:
4638 {
4639 int hd_index;
4640 hd_index = popt->index - QEMU_OPTION_hda;
4641 hd_filename[hd_index] = optarg;
4642 if (hd_index == cdrom_index)
4643 cdrom_index = -1;
4644 }
4645 break;
4646 case QEMU_OPTION_snapshot:
4647 snapshot = 1;
4648 break;
4649 case QEMU_OPTION_hdachs:
4650 {
4651 const char *p;
4652 p = optarg;
4653 cyls = strtol(p, (char **)&p, 0);
4654 if (cyls < 1 || cyls > 16383)
4655 goto chs_fail;
4656 if (*p != ',')
4657 goto chs_fail;
4658 p++;
4659 heads = strtol(p, (char **)&p, 0);
4660 if (heads < 1 || heads > 16)
4661 goto chs_fail;
4662 if (*p != ',')
4663 goto chs_fail;
4664 p++;
4665 secs = strtol(p, (char **)&p, 0);
4666 if (secs < 1 || secs > 63)
4667 goto chs_fail;
4668 if (*p == ',') {
4669 p++;
4670 if (!strcmp(p, "none"))
4671 translation = BIOS_ATA_TRANSLATION_NONE;
4672 else if (!strcmp(p, "lba"))
4673 translation = BIOS_ATA_TRANSLATION_LBA;
4674 else if (!strcmp(p, "auto"))
4675 translation = BIOS_ATA_TRANSLATION_AUTO;
4676 else
4677 goto chs_fail;
4678 } else if (*p != '\0') {
4679 chs_fail:
4680 fprintf(stderr, "qemu: invalid physical CHS format\n");
4681 exit(1);
4682 }
4683 }
4684 break;
4685 case QEMU_OPTION_nographic:
4686 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
4687 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
4688 nographic = 1;
4689 break;
4690 case QEMU_OPTION_kernel:
4691 kernel_filename = optarg;
4692 break;
4693 case QEMU_OPTION_append:
4694 kernel_cmdline = optarg;
4695 break;
4696 case QEMU_OPTION_cdrom:
4697 if (cdrom_index >= 0) {
4698 hd_filename[cdrom_index] = optarg;
4699 }
4700 break;
4701 case QEMU_OPTION_boot:
4702 boot_device = optarg[0];
4703 if (boot_device != 'a' &&
4704 #ifdef TARGET_SPARC
4705 // Network boot
4706 boot_device != 'n' &&
4707 #endif
4708 boot_device != 'c' && boot_device != 'd') {
4709 fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
4710 exit(1);
4711 }
4712 break;
4713 case QEMU_OPTION_fda:
4714 fd_filename[0] = optarg;
4715 break;
4716 case QEMU_OPTION_fdb:
4717 fd_filename[1] = optarg;
4718 break;
4719 case QEMU_OPTION_no_code_copy:
4720 code_copy_enabled = 0;
4721 break;
4722 case QEMU_OPTION_net:
4723 if (nb_net_clients >= MAX_NET_CLIENTS) {
4724 fprintf(stderr, "qemu: too many network clients\n");
4725 exit(1);
4726 }
4727 pstrcpy(net_clients[nb_net_clients],
4728 sizeof(net_clients[0]),
4729 optarg);
4730 nb_net_clients++;
4731 break;
4732 #ifdef CONFIG_SLIRP
4733 case QEMU_OPTION_tftp:
4734 tftp_prefix = optarg;
4735 break;
4736 #ifndef _WIN32
4737 case QEMU_OPTION_smb:
4738 net_slirp_smb(optarg);
4739 break;
4740 #endif
4741 case QEMU_OPTION_redir:
4742 net_slirp_redir(optarg);
4743 break;
4744 #endif
4745 #ifdef HAS_AUDIO
4746 case QEMU_OPTION_audio_help:
4747 AUD_help ();
4748 exit (0);
4749 break;
4750 case QEMU_OPTION_soundhw:
4751 select_soundhw (optarg);
4752 break;
4753 #endif
4754 case QEMU_OPTION_h:
4755 help();
4756 break;
4757 case QEMU_OPTION_m:
4758 ram_size = atoi(optarg) * 1024 * 1024;
4759 if (ram_size <= 0)
4760 help();
4761 if (ram_size > PHYS_RAM_MAX_SIZE) {
4762 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
4763 PHYS_RAM_MAX_SIZE / (1024 * 1024));
4764 exit(1);
4765 }
4766 break;
4767 case QEMU_OPTION_d:
4768 {
4769 int mask;
4770 CPULogItem *item;
4771
4772 mask = cpu_str_to_log_mask(optarg);
4773 if (!mask) {
4774 printf("Log items (comma separated):\n");
4775 for(item = cpu_log_items; item->mask != 0; item++) {
4776 printf("%-10s %s\n", item->name, item->help);
4777 }
4778 exit(1);
4779 }
4780 cpu_set_log(mask);
4781 }
4782 break;
4783 #ifdef CONFIG_GDBSTUB
4784 case QEMU_OPTION_s:
4785 use_gdbstub = 1;
4786 break;
4787 case QEMU_OPTION_p:
4788 gdbstub_port = atoi(optarg);
4789 break;
4790 #endif
4791 case QEMU_OPTION_L:
4792 bios_dir = optarg;
4793 break;
4794 case QEMU_OPTION_S:
4795 start_emulation = 0;
4796 break;
4797 case QEMU_OPTION_k:
4798 keyboard_layout = optarg;
4799 break;
4800 case QEMU_OPTION_localtime:
4801 rtc_utc = 0;
4802 break;
4803 case QEMU_OPTION_cirrusvga:
4804 cirrus_vga_enabled = 1;
4805 break;
4806 case QEMU_OPTION_std_vga:
4807 cirrus_vga_enabled = 0;
4808 break;
4809 case QEMU_OPTION_g:
4810 {
4811 const char *p;
4812 int w, h, depth;
4813 p = optarg;
4814 w = strtol(p, (char **)&p, 10);
4815 if (w <= 0) {
4816 graphic_error:
4817 fprintf(stderr, "qemu: invalid resolution or depth\n");
4818 exit(1);
4819 }
4820 if (*p != 'x')
4821 goto graphic_error;
4822 p++;
4823 h = strtol(p, (char **)&p, 10);
4824 if (h <= 0)
4825 goto graphic_error;
4826 if (*p == 'x') {
4827 p++;
4828 depth = strtol(p, (char **)&p, 10);
4829 if (depth != 8 && depth != 15 && depth != 16 &&
4830 depth != 24 && depth != 32)
4831 goto graphic_error;
4832 } else if (*p == '\0') {
4833 depth = graphic_depth;
4834 } else {
4835 goto graphic_error;
4836 }
4837
4838 graphic_width = w;
4839 graphic_height = h;
4840 graphic_depth = depth;
4841 }
4842 break;
4843 case QEMU_OPTION_monitor:
4844 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
4845 break;
4846 case QEMU_OPTION_serial:
4847 if (serial_device_index >= MAX_SERIAL_PORTS) {
4848 fprintf(stderr, "qemu: too many serial ports\n");
4849 exit(1);
4850 }
4851 pstrcpy(serial_devices[serial_device_index],
4852 sizeof(serial_devices[0]), optarg);
4853 serial_device_index++;
4854 break;
4855 case QEMU_OPTION_parallel:
4856 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4857 fprintf(stderr, "qemu: too many parallel ports\n");
4858 exit(1);
4859 }
4860 pstrcpy(parallel_devices[parallel_device_index],
4861 sizeof(parallel_devices[0]), optarg);
4862 parallel_device_index++;
4863 break;
4864 case QEMU_OPTION_loadvm:
4865 loadvm = optarg;
4866 break;
4867 case QEMU_OPTION_full_screen:
4868 full_screen = 1;
4869 break;
4870 case QEMU_OPTION_pidfile:
4871 create_pidfile(optarg);
4872 break;
4873 #ifdef TARGET_I386
4874 case QEMU_OPTION_win2k_hack:
4875 win2k_install_hack = 1;
4876 break;
4877 #endif
4878 #ifdef USE_KQEMU
4879 case QEMU_OPTION_no_kqemu:
4880 kqemu_allowed = 0;
4881 break;
4882 #endif
4883 case QEMU_OPTION_usb:
4884 usb_enabled = 1;
4885 break;
4886 case QEMU_OPTION_usbdevice:
4887 usb_enabled = 1;
4888 if (usb_devices_index >= MAX_VM_USB_PORTS) {
4889 fprintf(stderr, "Too many USB devices\n");
4890 exit(1);
4891 }
4892 pstrcpy(usb_devices[usb_devices_index],
4893 sizeof(usb_devices[usb_devices_index]),
4894 optarg);
4895 usb_devices_index++;
4896 break;
4897 case QEMU_OPTION_smp:
4898 smp_cpus = atoi(optarg);
4899 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
4900 fprintf(stderr, "Invalid number of CPUs\n");
4901 exit(1);
4902 }
4903 break;
4904 }
4905 }
4906 }
4907
4908 #ifdef USE_KQEMU
4909 if (smp_cpus > 1)
4910 kqemu_allowed = 0;
4911 #endif
4912 linux_boot = (kernel_filename != NULL);
4913
4914 if (!linux_boot &&
4915 hd_filename[0] == '\0' &&
4916 (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
4917 fd_filename[0] == '\0')
4918 help();
4919
4920 /* boot to cd by default if no hard disk */
4921 if (hd_filename[0] == '\0' && boot_device == 'c') {
4922 if (fd_filename[0] != '\0')
4923 boot_device = 'a';
4924 else
4925 boot_device = 'd';
4926 }
4927
4928 #if !defined(CONFIG_SOFTMMU)
4929 /* must avoid mmap() usage of glibc by setting a buffer "by hand" */
4930 {
4931 static uint8_t stdout_buf[4096];
4932 setvbuf(stdout, stdout_buf, _IOLBF, sizeof(stdout_buf));
4933 }
4934 #else
4935 setvbuf(stdout, NULL, _IOLBF, 0);
4936 #endif
4937
4938 #ifdef _WIN32
4939 socket_init();
4940 #endif
4941
4942 /* init network clients */
4943 if (nb_net_clients == 0) {
4944 /* if no clients, we use a default config */
4945 pstrcpy(net_clients[0], sizeof(net_clients[0]),
4946 "nic");
4947 pstrcpy(net_clients[1], sizeof(net_clients[0]),
4948 "user");
4949 nb_net_clients = 2;
4950 }
4951
4952 for(i = 0;i < nb_net_clients; i++) {
4953 if (net_client_init(net_clients[i]) < 0)
4954 exit(1);
4955 }
4956
4957 /* init the memory */
4958 phys_ram_size = ram_size + vga_ram_size + bios_size;
4959
4960 #ifdef CONFIG_SOFTMMU
4961 phys_ram_base = qemu_vmalloc(phys_ram_size);
4962 if (!phys_ram_base) {
4963 fprintf(stderr, "Could not allocate physical memory\n");
4964 exit(1);
4965 }
4966 #else
4967 /* as we must map the same page at several addresses, we must use
4968 a fd */
4969 {
4970 const char *tmpdir;
4971
4972 tmpdir = getenv("QEMU_TMPDIR");
4973 if (!tmpdir)
4974 tmpdir = "/tmp";
4975 snprintf(phys_ram_file, sizeof(phys_ram_file), "%s/vlXXXXXX", tmpdir);
4976 if (mkstemp(phys_ram_file) < 0) {
4977 fprintf(stderr, "Could not create temporary memory file '%s'\n",
4978 phys_ram_file);
4979 exit(1);
4980 }
4981 phys_ram_fd = open(phys_ram_file, O_CREAT | O_TRUNC | O_RDWR, 0600);
4982 if (phys_ram_fd < 0) {
4983 fprintf(stderr, "Could not open temporary memory file '%s'\n",
4984 phys_ram_file);
4985 exit(1);
4986 }
4987 ftruncate(phys_ram_fd, phys_ram_size);
4988 unlink(phys_ram_file);
4989 phys_ram_base = mmap(get_mmap_addr(phys_ram_size),
4990 phys_ram_size,
4991 PROT_WRITE | PROT_READ, MAP_SHARED | MAP_FIXED,
4992 phys_ram_fd, 0);
4993 if (phys_ram_base == MAP_FAILED) {
4994 fprintf(stderr, "Could not map physical memory\n");
4995 exit(1);
4996 }
4997 }
4998 #endif
4999
5000 /* we always create the cdrom drive, even if no disk is there */
5001 bdrv_init();
5002 if (cdrom_index >= 0) {
5003 bs_table[cdrom_index] = bdrv_new("cdrom");
5004 bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
5005 }
5006
5007 /* open the virtual block devices */
5008 for(i = 0; i < MAX_DISKS; i++) {
5009 if (hd_filename[i]) {
5010 if (!bs_table[i]) {
5011 char buf[64];
5012 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
5013 bs_table[i] = bdrv_new(buf);
5014 }
5015 if (bdrv_open(bs_table[i], hd_filename[i], snapshot) < 0) {
5016 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
5017 hd_filename[i]);
5018 exit(1);
5019 }
5020 if (i == 0 && cyls != 0) {
5021 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
5022 bdrv_set_translation_hint(bs_table[i], translation);
5023 }
5024 }
5025 }
5026
5027 /* we always create at least one floppy disk */
5028 fd_table[0] = bdrv_new("fda");
5029 bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
5030
5031 for(i = 0; i < MAX_FD; i++) {
5032 if (fd_filename[i]) {
5033 if (!fd_table[i]) {
5034 char buf[64];
5035 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
5036 fd_table[i] = bdrv_new(buf);
5037 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
5038 }
5039 if (fd_filename[i] != '\0') {
5040 if (bdrv_open(fd_table[i], fd_filename[i], snapshot) < 0) {
5041 fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
5042 fd_filename[i]);
5043 exit(1);
5044 }
5045 }
5046 }
5047 }
5048
5049 /* init USB devices */
5050 if (usb_enabled) {
5051 vm_usb_hub = usb_hub_init(vm_usb_ports, MAX_VM_USB_PORTS);
5052 for(i = 0; i < usb_devices_index; i++) {
5053 if (usb_device_add(usb_devices[i]) < 0) {
5054 fprintf(stderr, "Warning: could not add USB device %s\n",
5055 usb_devices[i]);
5056 }
5057 }
5058 }
5059
5060 register_savevm("timer", 0, 1, timer_save, timer_load, NULL);
5061 register_savevm("ram", 0, 1, ram_save, ram_load, NULL);
5062
5063 init_ioports();
5064 cpu_calibrate_ticks();
5065
5066 /* terminal init */
5067 if (nographic) {
5068 dumb_display_init(ds);
5069 } else {
5070 #if defined(CONFIG_SDL)
5071 sdl_display_init(ds, full_screen);
5072 #elif defined(CONFIG_COCOA)
5073 cocoa_display_init(ds, full_screen);
5074 #else
5075 dumb_display_init(ds);
5076 #endif
5077 }
5078
5079 vga_console = graphic_console_init(ds);
5080
5081 monitor_hd = qemu_chr_open(monitor_device);
5082 if (!monitor_hd) {
5083 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5084 exit(1);
5085 }
5086 monitor_init(monitor_hd, !nographic);
5087
5088 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5089 if (serial_devices[i][0] != '\0') {
5090 serial_hds[i] = qemu_chr_open(serial_devices[i]);
5091 if (!serial_hds[i]) {
5092 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5093 serial_devices[i]);
5094 exit(1);
5095 }
5096 if (!strcmp(serial_devices[i], "vc"))
5097 qemu_chr_printf(serial_hds[i], "serial%d console\n", i);
5098 }
5099 }
5100
5101 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5102 if (parallel_devices[i][0] != '\0') {
5103 parallel_hds[i] = qemu_chr_open(parallel_devices[i]);
5104 if (!parallel_hds[i]) {
5105 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5106 parallel_devices[i]);
5107 exit(1);
5108 }
5109 if (!strcmp(parallel_devices[i], "vc"))
5110 qemu_chr_printf(parallel_hds[i], "parallel%d console\n", i);
5111 }
5112 }
5113
5114 /* setup cpu signal handlers for MMU / self modifying code handling */
5115 #if !defined(CONFIG_SOFTMMU)
5116
5117 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5118 {
5119 stack_t stk;
5120 signal_stack = memalign(16, SIGNAL_STACK_SIZE);
5121 stk.ss_sp = signal_stack;
5122 stk.ss_size = SIGNAL_STACK_SIZE;
5123 stk.ss_flags = 0;
5124
5125 if (sigaltstack(&stk, NULL) < 0) {
5126 perror("sigaltstack");
5127 exit(1);
5128 }
5129 }
5130 #endif
5131 {
5132 struct sigaction act;
5133
5134 sigfillset(&act.sa_mask);
5135 act.sa_flags = SA_SIGINFO;
5136 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5137 act.sa_flags |= SA_ONSTACK;
5138 #endif
5139 act.sa_sigaction = host_segv_handler;
5140 sigaction(SIGSEGV, &act, NULL);
5141 sigaction(SIGBUS, &act, NULL);
5142 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
5143 sigaction(SIGFPE, &act, NULL);
5144 #endif
5145 }
5146 #endif
5147
5148 #ifndef _WIN32
5149 {
5150 struct sigaction act;
5151 sigfillset(&act.sa_mask);
5152 act.sa_flags = 0;
5153 act.sa_handler = SIG_IGN;
5154 sigaction(SIGPIPE, &act, NULL);
5155 }
5156 #endif
5157 init_timers();
5158
5159 machine->init(ram_size, vga_ram_size, boot_device,
5160 ds, fd_filename, snapshot,
5161 kernel_filename, kernel_cmdline, initrd_filename);
5162
5163 gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
5164 qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
5165
5166 #ifdef CONFIG_GDBSTUB
5167 if (use_gdbstub) {
5168 if (gdbserver_start(gdbstub_port) < 0) {
5169 fprintf(stderr, "Could not open gdbserver socket on port %d\n",
5170 gdbstub_port);
5171 exit(1);
5172 } else {
5173 printf("Waiting gdb connection on port %d\n", gdbstub_port);
5174 }
5175 } else
5176 #endif
5177 if (loadvm)
5178 qemu_loadvm(loadvm);
5179
5180 {
5181 /* XXX: simplify init */
5182 read_passwords();
5183 if (start_emulation) {
5184 vm_start();
5185 }
5186 }
5187 main_loop();
5188 quit_timers();
5189 return 0;
5190 }
Samsung s3c2440 and arm920t support for the mini2440 dev board