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