?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add ARM Angel semihosting to system emulation.
[qemu/mini2440.git] / vl.c
blob9f620cb1deed1a21fa9e31f20a38421b9169d7ee
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2006 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 #include <zlib.h>
33
34 #ifndef _WIN32
35 #include <sys/times.h>
36 #include <sys/wait.h>
37 #include <termios.h>
38 #include <sys/poll.h>
39 #include <sys/mman.h>
40 #include <sys/ioctl.h>
41 #include <sys/socket.h>
42 #include <netinet/in.h>
43 #include <dirent.h>
44 #include <netdb.h>
45 #ifdef _BSD
46 #include <sys/stat.h>
47 #ifndef __APPLE__
48 #include <libutil.h>
49 #endif
50 #else
51 #ifndef __sun__
52 #include <linux/if.h>
53 #include <linux/if_tun.h>
54 #include <pty.h>
55 #include <malloc.h>
56 #include <linux/rtc.h>
57 #include <linux/ppdev.h>
58 #endif
59 #endif
60 #endif
61
62 #if defined(CONFIG_SLIRP)
63 #include "libslirp.h"
64 #endif
65
66 #ifdef _WIN32
67 #include <malloc.h>
68 #include <sys/timeb.h>
69 #include <windows.h>
70 #define getopt_long_only getopt_long
71 #define memalign(align, size) malloc(size)
72 #endif
73
74 #include "qemu_socket.h"
75
76 #ifdef CONFIG_SDL
77 #ifdef __APPLE__
78 #include <SDL/SDL.h>
79 #endif
80 #endif /* CONFIG_SDL */
81
82 #ifdef CONFIG_COCOA
83 #undef main
84 #define main qemu_main
85 #endif /* CONFIG_COCOA */
86
87 #include "disas.h"
88
89 #include "exec-all.h"
90
91 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
92 #ifdef __sun__
93 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
94 #else
95 #define SMBD_COMMAND "/usr/sbin/smbd"
96 #endif
97
98 //#define DEBUG_UNUSED_IOPORT
99 //#define DEBUG_IOPORT
100
101 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
102
103 #ifdef TARGET_PPC
104 #define DEFAULT_RAM_SIZE 144
105 #else
106 #define DEFAULT_RAM_SIZE 128
107 #endif
108 /* in ms */
109 #define GUI_REFRESH_INTERVAL 30
110
111 /* Max number of USB devices that can be specified on the commandline. */
112 #define MAX_USB_CMDLINE 8
113
114 /* XXX: use a two level table to limit memory usage */
115 #define MAX_IOPORTS 65536
116
117 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
118 char phys_ram_file[1024];
119 void *ioport_opaque[MAX_IOPORTS];
120 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
121 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
122 /* Note: bs_table[MAX_DISKS] is a dummy block driver if none available
123 to store the VM snapshots */
124 BlockDriverState *bs_table[MAX_DISKS + 1], *fd_table[MAX_FD];
125 /* point to the block driver where the snapshots are managed */
126 BlockDriverState *bs_snapshots;
127 int vga_ram_size;
128 int bios_size;
129 static DisplayState display_state;
130 int nographic;
131 const char* keyboard_layout = NULL;
132 int64_t ticks_per_sec;
133 int boot_device = 'c';
134 int ram_size;
135 int pit_min_timer_count = 0;
136 int nb_nics;
137 NICInfo nd_table[MAX_NICS];
138 QEMUTimer *gui_timer;
139 int vm_running;
140 int rtc_utc = 1;
141 int cirrus_vga_enabled = 1;
142 #ifdef TARGET_SPARC
143 int graphic_width = 1024;
144 int graphic_height = 768;
145 #else
146 int graphic_width = 800;
147 int graphic_height = 600;
148 #endif
149 int graphic_depth = 15;
150 int full_screen = 0;
151 int no_quit = 0;
152 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
153 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
154 #ifdef TARGET_I386
155 int win2k_install_hack = 0;
156 #endif
157 int usb_enabled = 0;
158 static VLANState *first_vlan;
159 int smp_cpus = 1;
160 const char *vnc_display;
161 #if defined(TARGET_SPARC)
162 #define MAX_CPUS 16
163 #elif defined(TARGET_I386)
164 #define MAX_CPUS 255
165 #else
166 #define MAX_CPUS 1
167 #endif
168 int acpi_enabled = 1;
169 int fd_bootchk = 1;
170 int no_reboot = 0;
171 int daemonize = 0;
172 const char *option_rom[MAX_OPTION_ROMS];
173 int nb_option_roms;
174 int semihosting_enabled = 0;
175
176 /***********************************************************/
177 /* x86 ISA bus support */
178
179 target_phys_addr_t isa_mem_base = 0;
180 PicState2 *isa_pic;
181
182 uint32_t default_ioport_readb(void *opaque, uint32_t address)
183 {
184 #ifdef DEBUG_UNUSED_IOPORT
185 fprintf(stderr, "inb: port=0x%04x\n", address);
186 #endif
187 return 0xff;
188 }
189
190 void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
191 {
192 #ifdef DEBUG_UNUSED_IOPORT
193 fprintf(stderr, "outb: port=0x%04x data=0x%02x\n", address, data);
194 #endif
195 }
196
197 /* default is to make two byte accesses */
198 uint32_t default_ioport_readw(void *opaque, uint32_t address)
199 {
200 uint32_t data;
201 data = ioport_read_table[0][address](ioport_opaque[address], address);
202 address = (address + 1) & (MAX_IOPORTS - 1);
203 data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
204 return data;
205 }
206
207 void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
208 {
209 ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
210 address = (address + 1) & (MAX_IOPORTS - 1);
211 ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
212 }
213
214 uint32_t default_ioport_readl(void *opaque, uint32_t address)
215 {
216 #ifdef DEBUG_UNUSED_IOPORT
217 fprintf(stderr, "inl: port=0x%04x\n", address);
218 #endif
219 return 0xffffffff;
220 }
221
222 void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
223 {
224 #ifdef DEBUG_UNUSED_IOPORT
225 fprintf(stderr, "outl: port=0x%04x data=0x%02x\n", address, data);
226 #endif
227 }
228
229 void init_ioports(void)
230 {
231 int i;
232
233 for(i = 0; i < MAX_IOPORTS; i++) {
234 ioport_read_table[0][i] = default_ioport_readb;
235 ioport_write_table[0][i] = default_ioport_writeb;
236 ioport_read_table[1][i] = default_ioport_readw;
237 ioport_write_table[1][i] = default_ioport_writew;
238 ioport_read_table[2][i] = default_ioport_readl;
239 ioport_write_table[2][i] = default_ioport_writel;
240 }
241 }
242
243 /* size is the word size in byte */
244 int register_ioport_read(int start, int length, int size,
245 IOPortReadFunc *func, void *opaque)
246 {
247 int i, bsize;
248
249 if (size == 1) {
250 bsize = 0;
251 } else if (size == 2) {
252 bsize = 1;
253 } else if (size == 4) {
254 bsize = 2;
255 } else {
256 hw_error("register_ioport_read: invalid size");
257 return -1;
258 }
259 for(i = start; i < start + length; i += size) {
260 ioport_read_table[bsize][i] = func;
261 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
262 hw_error("register_ioport_read: invalid opaque");
263 ioport_opaque[i] = opaque;
264 }
265 return 0;
266 }
267
268 /* size is the word size in byte */
269 int register_ioport_write(int start, int length, int size,
270 IOPortWriteFunc *func, void *opaque)
271 {
272 int i, bsize;
273
274 if (size == 1) {
275 bsize = 0;
276 } else if (size == 2) {
277 bsize = 1;
278 } else if (size == 4) {
279 bsize = 2;
280 } else {
281 hw_error("register_ioport_write: invalid size");
282 return -1;
283 }
284 for(i = start; i < start + length; i += size) {
285 ioport_write_table[bsize][i] = func;
286 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
287 hw_error("register_ioport_write: invalid opaque");
288 ioport_opaque[i] = opaque;
289 }
290 return 0;
291 }
292
293 void isa_unassign_ioport(int start, int length)
294 {
295 int i;
296
297 for(i = start; i < start + length; i++) {
298 ioport_read_table[0][i] = default_ioport_readb;
299 ioport_read_table[1][i] = default_ioport_readw;
300 ioport_read_table[2][i] = default_ioport_readl;
301
302 ioport_write_table[0][i] = default_ioport_writeb;
303 ioport_write_table[1][i] = default_ioport_writew;
304 ioport_write_table[2][i] = default_ioport_writel;
305 }
306 }
307
308 /***********************************************************/
309
310 void cpu_outb(CPUState *env, int addr, int val)
311 {
312 #ifdef DEBUG_IOPORT
313 if (loglevel & CPU_LOG_IOPORT)
314 fprintf(logfile, "outb: %04x %02x\n", addr, val);
315 #endif
316 ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
317 #ifdef USE_KQEMU
318 if (env)
319 env->last_io_time = cpu_get_time_fast();
320 #endif
321 }
322
323 void cpu_outw(CPUState *env, int addr, int val)
324 {
325 #ifdef DEBUG_IOPORT
326 if (loglevel & CPU_LOG_IOPORT)
327 fprintf(logfile, "outw: %04x %04x\n", addr, val);
328 #endif
329 ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
330 #ifdef USE_KQEMU
331 if (env)
332 env->last_io_time = cpu_get_time_fast();
333 #endif
334 }
335
336 void cpu_outl(CPUState *env, int addr, int val)
337 {
338 #ifdef DEBUG_IOPORT
339 if (loglevel & CPU_LOG_IOPORT)
340 fprintf(logfile, "outl: %04x %08x\n", addr, val);
341 #endif
342 ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
343 #ifdef USE_KQEMU
344 if (env)
345 env->last_io_time = cpu_get_time_fast();
346 #endif
347 }
348
349 int cpu_inb(CPUState *env, int addr)
350 {
351 int val;
352 val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
353 #ifdef DEBUG_IOPORT
354 if (loglevel & CPU_LOG_IOPORT)
355 fprintf(logfile, "inb : %04x %02x\n", addr, val);
356 #endif
357 #ifdef USE_KQEMU
358 if (env)
359 env->last_io_time = cpu_get_time_fast();
360 #endif
361 return val;
362 }
363
364 int cpu_inw(CPUState *env, int addr)
365 {
366 int val;
367 val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
368 #ifdef DEBUG_IOPORT
369 if (loglevel & CPU_LOG_IOPORT)
370 fprintf(logfile, "inw : %04x %04x\n", addr, val);
371 #endif
372 #ifdef USE_KQEMU
373 if (env)
374 env->last_io_time = cpu_get_time_fast();
375 #endif
376 return val;
377 }
378
379 int cpu_inl(CPUState *env, int addr)
380 {
381 int val;
382 val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
383 #ifdef DEBUG_IOPORT
384 if (loglevel & CPU_LOG_IOPORT)
385 fprintf(logfile, "inl : %04x %08x\n", addr, val);
386 #endif
387 #ifdef USE_KQEMU
388 if (env)
389 env->last_io_time = cpu_get_time_fast();
390 #endif
391 return val;
392 }
393
394 /***********************************************************/
395 void hw_error(const char *fmt, ...)
396 {
397 va_list ap;
398 CPUState *env;
399
400 va_start(ap, fmt);
401 fprintf(stderr, "qemu: hardware error: ");
402 vfprintf(stderr, fmt, ap);
403 fprintf(stderr, "\n");
404 for(env = first_cpu; env != NULL; env = env->next_cpu) {
405 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
406 #ifdef TARGET_I386
407 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
408 #else
409 cpu_dump_state(env, stderr, fprintf, 0);
410 #endif
411 }
412 va_end(ap);
413 abort();
414 }
415
416 /***********************************************************/
417 /* keyboard/mouse */
418
419 static QEMUPutKBDEvent *qemu_put_kbd_event;
420 static void *qemu_put_kbd_event_opaque;
421 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
422 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
423
424 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
425 {
426 qemu_put_kbd_event_opaque = opaque;
427 qemu_put_kbd_event = func;
428 }
429
430 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
431 void *opaque, int absolute,
432 const char *name)
433 {
434 QEMUPutMouseEntry *s, *cursor;
435
436 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
437 if (!s)
438 return NULL;
439
440 s->qemu_put_mouse_event = func;
441 s->qemu_put_mouse_event_opaque = opaque;
442 s->qemu_put_mouse_event_absolute = absolute;
443 s->qemu_put_mouse_event_name = qemu_strdup(name);
444 s->next = NULL;
445
446 if (!qemu_put_mouse_event_head) {
447 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
448 return s;
449 }
450
451 cursor = qemu_put_mouse_event_head;
452 while (cursor->next != NULL)
453 cursor = cursor->next;
454
455 cursor->next = s;
456 qemu_put_mouse_event_current = s;
457
458 return s;
459 }
460
461 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
462 {
463 QEMUPutMouseEntry *prev = NULL, *cursor;
464
465 if (!qemu_put_mouse_event_head || entry == NULL)
466 return;
467
468 cursor = qemu_put_mouse_event_head;
469 while (cursor != NULL && cursor != entry) {
470 prev = cursor;
471 cursor = cursor->next;
472 }
473
474 if (cursor == NULL) // does not exist or list empty
475 return;
476 else if (prev == NULL) { // entry is head
477 qemu_put_mouse_event_head = cursor->next;
478 if (qemu_put_mouse_event_current == entry)
479 qemu_put_mouse_event_current = cursor->next;
480 qemu_free(entry->qemu_put_mouse_event_name);
481 qemu_free(entry);
482 return;
483 }
484
485 prev->next = entry->next;
486
487 if (qemu_put_mouse_event_current == entry)
488 qemu_put_mouse_event_current = prev;
489
490 qemu_free(entry->qemu_put_mouse_event_name);
491 qemu_free(entry);
492 }
493
494 void kbd_put_keycode(int keycode)
495 {
496 if (qemu_put_kbd_event) {
497 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
498 }
499 }
500
501 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
502 {
503 QEMUPutMouseEvent *mouse_event;
504 void *mouse_event_opaque;
505
506 if (!qemu_put_mouse_event_current) {
507 return;
508 }
509
510 mouse_event =
511 qemu_put_mouse_event_current->qemu_put_mouse_event;
512 mouse_event_opaque =
513 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
514
515 if (mouse_event) {
516 mouse_event(mouse_event_opaque, dx, dy, dz, buttons_state);
517 }
518 }
519
520 int kbd_mouse_is_absolute(void)
521 {
522 if (!qemu_put_mouse_event_current)
523 return 0;
524
525 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
526 }
527
528 void do_info_mice(void)
529 {
530 QEMUPutMouseEntry *cursor;
531 int index = 0;
532
533 if (!qemu_put_mouse_event_head) {
534 term_printf("No mouse devices connected\n");
535 return;
536 }
537
538 term_printf("Mouse devices available:\n");
539 cursor = qemu_put_mouse_event_head;
540 while (cursor != NULL) {
541 term_printf("%c Mouse #%d: %s\n",
542 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
543 index, cursor->qemu_put_mouse_event_name);
544 index++;
545 cursor = cursor->next;
546 }
547 }
548
549 void do_mouse_set(int index)
550 {
551 QEMUPutMouseEntry *cursor;
552 int i = 0;
553
554 if (!qemu_put_mouse_event_head) {
555 term_printf("No mouse devices connected\n");
556 return;
557 }
558
559 cursor = qemu_put_mouse_event_head;
560 while (cursor != NULL && index != i) {
561 i++;
562 cursor = cursor->next;
563 }
564
565 if (cursor != NULL)
566 qemu_put_mouse_event_current = cursor;
567 else
568 term_printf("Mouse at given index not found\n");
569 }
570
571 /* compute with 96 bit intermediate result: (a*b)/c */
572 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
573 {
574 union {
575 uint64_t ll;
576 struct {
577 #ifdef WORDS_BIGENDIAN
578 uint32_t high, low;
579 #else
580 uint32_t low, high;
581 #endif
582 } l;
583 } u, res;
584 uint64_t rl, rh;
585
586 u.ll = a;
587 rl = (uint64_t)u.l.low * (uint64_t)b;
588 rh = (uint64_t)u.l.high * (uint64_t)b;
589 rh += (rl >> 32);
590 res.l.high = rh / c;
591 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
592 return res.ll;
593 }
594
595 /***********************************************************/
596 /* real time host monotonic timer */
597
598 #define QEMU_TIMER_BASE 1000000000LL
599
600 #ifdef WIN32
601
602 static int64_t clock_freq;
603
604 static void init_get_clock(void)
605 {
606 LARGE_INTEGER freq;
607 int ret;
608 ret = QueryPerformanceFrequency(&freq);
609 if (ret == 0) {
610 fprintf(stderr, "Could not calibrate ticks\n");
611 exit(1);
612 }
613 clock_freq = freq.QuadPart;
614 }
615
616 static int64_t get_clock(void)
617 {
618 LARGE_INTEGER ti;
619 QueryPerformanceCounter(&ti);
620 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
621 }
622
623 #else
624
625 static int use_rt_clock;
626
627 static void init_get_clock(void)
628 {
629 use_rt_clock = 0;
630 #if defined(__linux__)
631 {
632 struct timespec ts;
633 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
634 use_rt_clock = 1;
635 }
636 }
637 #endif
638 }
639
640 static int64_t get_clock(void)
641 {
642 #if defined(__linux__)
643 if (use_rt_clock) {
644 struct timespec ts;
645 clock_gettime(CLOCK_MONOTONIC, &ts);
646 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
647 } else
648 #endif
649 {
650 /* XXX: using gettimeofday leads to problems if the date
651 changes, so it should be avoided. */
652 struct timeval tv;
653 gettimeofday(&tv, NULL);
654 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
655 }
656 }
657
658 #endif
659
660 /***********************************************************/
661 /* guest cycle counter */
662
663 static int64_t cpu_ticks_prev;
664 static int64_t cpu_ticks_offset;
665 static int64_t cpu_clock_offset;
666 static int cpu_ticks_enabled;
667
668 /* return the host CPU cycle counter and handle stop/restart */
669 int64_t cpu_get_ticks(void)
670 {
671 if (!cpu_ticks_enabled) {
672 return cpu_ticks_offset;
673 } else {
674 int64_t ticks;
675 ticks = cpu_get_real_ticks();
676 if (cpu_ticks_prev > ticks) {
677 /* Note: non increasing ticks may happen if the host uses
678 software suspend */
679 cpu_ticks_offset += cpu_ticks_prev - ticks;
680 }
681 cpu_ticks_prev = ticks;
682 return ticks + cpu_ticks_offset;
683 }
684 }
685
686 /* return the host CPU monotonic timer and handle stop/restart */
687 static int64_t cpu_get_clock(void)
688 {
689 int64_t ti;
690 if (!cpu_ticks_enabled) {
691 return cpu_clock_offset;
692 } else {
693 ti = get_clock();
694 return ti + cpu_clock_offset;
695 }
696 }
697
698 /* enable cpu_get_ticks() */
699 void cpu_enable_ticks(void)
700 {
701 if (!cpu_ticks_enabled) {
702 cpu_ticks_offset -= cpu_get_real_ticks();
703 cpu_clock_offset -= get_clock();
704 cpu_ticks_enabled = 1;
705 }
706 }
707
708 /* disable cpu_get_ticks() : the clock is stopped. You must not call
709 cpu_get_ticks() after that. */
710 void cpu_disable_ticks(void)
711 {
712 if (cpu_ticks_enabled) {
713 cpu_ticks_offset = cpu_get_ticks();
714 cpu_clock_offset = cpu_get_clock();
715 cpu_ticks_enabled = 0;
716 }
717 }
718
719 /***********************************************************/
720 /* timers */
721
722 #define QEMU_TIMER_REALTIME 0
723 #define QEMU_TIMER_VIRTUAL 1
724
725 struct QEMUClock {
726 int type;
727 /* XXX: add frequency */
728 };
729
730 struct QEMUTimer {
731 QEMUClock *clock;
732 int64_t expire_time;
733 QEMUTimerCB *cb;
734 void *opaque;
735 struct QEMUTimer *next;
736 };
737
738 QEMUClock *rt_clock;
739 QEMUClock *vm_clock;
740
741 static QEMUTimer *active_timers[2];
742 #ifdef _WIN32
743 static MMRESULT timerID;
744 static HANDLE host_alarm = NULL;
745 static unsigned int period = 1;
746 #else
747 /* frequency of the times() clock tick */
748 static int timer_freq;
749 #endif
750
751 QEMUClock *qemu_new_clock(int type)
752 {
753 QEMUClock *clock;
754 clock = qemu_mallocz(sizeof(QEMUClock));
755 if (!clock)
756 return NULL;
757 clock->type = type;
758 return clock;
759 }
760
761 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
762 {
763 QEMUTimer *ts;
764
765 ts = qemu_mallocz(sizeof(QEMUTimer));
766 ts->clock = clock;
767 ts->cb = cb;
768 ts->opaque = opaque;
769 return ts;
770 }
771
772 void qemu_free_timer(QEMUTimer *ts)
773 {
774 qemu_free(ts);
775 }
776
777 /* stop a timer, but do not dealloc it */
778 void qemu_del_timer(QEMUTimer *ts)
779 {
780 QEMUTimer **pt, *t;
781
782 /* NOTE: this code must be signal safe because
783 qemu_timer_expired() can be called from a signal. */
784 pt = &active_timers[ts->clock->type];
785 for(;;) {
786 t = *pt;
787 if (!t)
788 break;
789 if (t == ts) {
790 *pt = t->next;
791 break;
792 }
793 pt = &t->next;
794 }
795 }
796
797 /* modify the current timer so that it will be fired when current_time
798 >= expire_time. The corresponding callback will be called. */
799 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
800 {
801 QEMUTimer **pt, *t;
802
803 qemu_del_timer(ts);
804
805 /* add the timer in the sorted list */
806 /* NOTE: this code must be signal safe because
807 qemu_timer_expired() can be called from a signal. */
808 pt = &active_timers[ts->clock->type];
809 for(;;) {
810 t = *pt;
811 if (!t)
812 break;
813 if (t->expire_time > expire_time)
814 break;
815 pt = &t->next;
816 }
817 ts->expire_time = expire_time;
818 ts->next = *pt;
819 *pt = ts;
820 }
821
822 int qemu_timer_pending(QEMUTimer *ts)
823 {
824 QEMUTimer *t;
825 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
826 if (t == ts)
827 return 1;
828 }
829 return 0;
830 }
831
832 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
833 {
834 if (!timer_head)
835 return 0;
836 return (timer_head->expire_time <= current_time);
837 }
838
839 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
840 {
841 QEMUTimer *ts;
842
843 for(;;) {
844 ts = *ptimer_head;
845 if (!ts || ts->expire_time > current_time)
846 break;
847 /* remove timer from the list before calling the callback */
848 *ptimer_head = ts->next;
849 ts->next = NULL;
850
851 /* run the callback (the timer list can be modified) */
852 ts->cb(ts->opaque);
853 }
854 }
855
856 int64_t qemu_get_clock(QEMUClock *clock)
857 {
858 switch(clock->type) {
859 case QEMU_TIMER_REALTIME:
860 return get_clock() / 1000000;
861 default:
862 case QEMU_TIMER_VIRTUAL:
863 return cpu_get_clock();
864 }
865 }
866
867 static void init_timers(void)
868 {
869 init_get_clock();
870 ticks_per_sec = QEMU_TIMER_BASE;
871 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
872 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
873 }
874
875 /* save a timer */
876 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
877 {
878 uint64_t expire_time;
879
880 if (qemu_timer_pending(ts)) {
881 expire_time = ts->expire_time;
882 } else {
883 expire_time = -1;
884 }
885 qemu_put_be64(f, expire_time);
886 }
887
888 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
889 {
890 uint64_t expire_time;
891
892 expire_time = qemu_get_be64(f);
893 if (expire_time != -1) {
894 qemu_mod_timer(ts, expire_time);
895 } else {
896 qemu_del_timer(ts);
897 }
898 }
899
900 static void timer_save(QEMUFile *f, void *opaque)
901 {
902 if (cpu_ticks_enabled) {
903 hw_error("cannot save state if virtual timers are running");
904 }
905 qemu_put_be64s(f, &cpu_ticks_offset);
906 qemu_put_be64s(f, &ticks_per_sec);
907 qemu_put_be64s(f, &cpu_clock_offset);
908 }
909
910 static int timer_load(QEMUFile *f, void *opaque, int version_id)
911 {
912 if (version_id != 1 && version_id != 2)
913 return -EINVAL;
914 if (cpu_ticks_enabled) {
915 return -EINVAL;
916 }
917 qemu_get_be64s(f, &cpu_ticks_offset);
918 qemu_get_be64s(f, &ticks_per_sec);
919 if (version_id == 2) {
920 qemu_get_be64s(f, &cpu_clock_offset);
921 }
922 return 0;
923 }
924
925 #ifdef _WIN32
926 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
927 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
928 #else
929 static void host_alarm_handler(int host_signum)
930 #endif
931 {
932 #if 0
933 #define DISP_FREQ 1000
934 {
935 static int64_t delta_min = INT64_MAX;
936 static int64_t delta_max, delta_cum, last_clock, delta, ti;
937 static int count;
938 ti = qemu_get_clock(vm_clock);
939 if (last_clock != 0) {
940 delta = ti - last_clock;
941 if (delta < delta_min)
942 delta_min = delta;
943 if (delta > delta_max)
944 delta_max = delta;
945 delta_cum += delta;
946 if (++count == DISP_FREQ) {
947 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
948 muldiv64(delta_min, 1000000, ticks_per_sec),
949 muldiv64(delta_max, 1000000, ticks_per_sec),
950 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
951 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
952 count = 0;
953 delta_min = INT64_MAX;
954 delta_max = 0;
955 delta_cum = 0;
956 }
957 }
958 last_clock = ti;
959 }
960 #endif
961 if (qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
962 qemu_get_clock(vm_clock)) ||
963 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
964 qemu_get_clock(rt_clock))) {
965 #ifdef _WIN32
966 SetEvent(host_alarm);
967 #endif
968 CPUState *env = cpu_single_env;
969 if (env) {
970 /* stop the currently executing cpu because a timer occured */
971 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
972 #ifdef USE_KQEMU
973 if (env->kqemu_enabled) {
974 kqemu_cpu_interrupt(env);
975 }
976 #endif
977 }
978 }
979 }
980
981 #ifndef _WIN32
982
983 #if defined(__linux__)
984
985 #define RTC_FREQ 1024
986
987 static int rtc_fd;
988
989 static int start_rtc_timer(void)
990 {
991 rtc_fd = open("/dev/rtc", O_RDONLY);
992 if (rtc_fd < 0)
993 return -1;
994 if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
995 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
996 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
997 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
998 goto fail;
999 }
1000 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1001 fail:
1002 close(rtc_fd);
1003 return -1;
1004 }
1005 pit_min_timer_count = PIT_FREQ / RTC_FREQ;
1006 return 0;
1007 }
1008
1009 #else
1010
1011 static int start_rtc_timer(void)
1012 {
1013 return -1;
1014 }
1015
1016 #endif /* !defined(__linux__) */
1017
1018 #endif /* !defined(_WIN32) */
1019
1020 static void init_timer_alarm(void)
1021 {
1022 #ifdef _WIN32
1023 {
1024 int count=0;
1025 TIMECAPS tc;
1026
1027 ZeroMemory(&tc, sizeof(TIMECAPS));
1028 timeGetDevCaps(&tc, sizeof(TIMECAPS));
1029 if (period < tc.wPeriodMin)
1030 period = tc.wPeriodMin;
1031 timeBeginPeriod(period);
1032 timerID = timeSetEvent(1, // interval (ms)
1033 period, // resolution
1034 host_alarm_handler, // function
1035 (DWORD)&count, // user parameter
1036 TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
1037 if( !timerID ) {
1038 perror("failed timer alarm");
1039 exit(1);
1040 }
1041 host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1042 if (!host_alarm) {
1043 perror("failed CreateEvent");
1044 exit(1);
1045 }
1046 qemu_add_wait_object(host_alarm, NULL, NULL);
1047 }
1048 pit_min_timer_count = ((uint64_t)10000 * PIT_FREQ) / 1000000;
1049 #else
1050 {
1051 struct sigaction act;
1052 struct itimerval itv;
1053
1054 /* get times() syscall frequency */
1055 timer_freq = sysconf(_SC_CLK_TCK);
1056
1057 /* timer signal */
1058 sigfillset(&act.sa_mask);
1059 act.sa_flags = 0;
1060 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
1061 act.sa_flags |= SA_ONSTACK;
1062 #endif
1063 act.sa_handler = host_alarm_handler;
1064 sigaction(SIGALRM, &act, NULL);
1065
1066 itv.it_interval.tv_sec = 0;
1067 itv.it_interval.tv_usec = 999; /* for i386 kernel 2.6 to get 1 ms */
1068 itv.it_value.tv_sec = 0;
1069 itv.it_value.tv_usec = 10 * 1000;
1070 setitimer(ITIMER_REAL, &itv, NULL);
1071 /* we probe the tick duration of the kernel to inform the user if
1072 the emulated kernel requested a too high timer frequency */
1073 getitimer(ITIMER_REAL, &itv);
1074
1075 #if defined(__linux__)
1076 /* XXX: force /dev/rtc usage because even 2.6 kernels may not
1077 have timers with 1 ms resolution. The correct solution will
1078 be to use the POSIX real time timers available in recent
1079 2.6 kernels */
1080 if (itv.it_interval.tv_usec > 1000 || 1) {
1081 /* try to use /dev/rtc to have a faster timer */
1082 if (start_rtc_timer() < 0)
1083 goto use_itimer;
1084 /* disable itimer */
1085 itv.it_interval.tv_sec = 0;
1086 itv.it_interval.tv_usec = 0;
1087 itv.it_value.tv_sec = 0;
1088 itv.it_value.tv_usec = 0;
1089 setitimer(ITIMER_REAL, &itv, NULL);
1090
1091 /* use the RTC */
1092 sigaction(SIGIO, &act, NULL);
1093 fcntl(rtc_fd, F_SETFL, O_ASYNC);
1094 fcntl(rtc_fd, F_SETOWN, getpid());
1095 } else
1096 #endif /* defined(__linux__) */
1097 {
1098 use_itimer:
1099 pit_min_timer_count = ((uint64_t)itv.it_interval.tv_usec *
1100 PIT_FREQ) / 1000000;
1101 }
1102 }
1103 #endif
1104 }
1105
1106 void quit_timers(void)
1107 {
1108 #ifdef _WIN32
1109 timeKillEvent(timerID);
1110 timeEndPeriod(period);
1111 if (host_alarm) {
1112 CloseHandle(host_alarm);
1113 host_alarm = NULL;
1114 }
1115 #endif
1116 }
1117
1118 /***********************************************************/
1119 /* character device */
1120
1121 static void qemu_chr_reset_bh(void *opaque)
1122 {
1123 CharDriverState *s = opaque;
1124 if (s->chr_event)
1125 s->chr_event(s, CHR_EVENT_RESET);
1126 qemu_bh_delete(s->bh);
1127 s->bh = NULL;
1128 }
1129
1130 void qemu_chr_reset(CharDriverState *s)
1131 {
1132 if (s->bh == NULL) {
1133 s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1134 qemu_bh_schedule(s->bh);
1135 }
1136 }
1137
1138 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1139 {
1140 return s->chr_write(s, buf, len);
1141 }
1142
1143 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1144 {
1145 if (!s->chr_ioctl)
1146 return -ENOTSUP;
1147 return s->chr_ioctl(s, cmd, arg);
1148 }
1149
1150 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1151 {
1152 char buf[4096];
1153 va_list ap;
1154 va_start(ap, fmt);
1155 vsnprintf(buf, sizeof(buf), fmt, ap);
1156 qemu_chr_write(s, buf, strlen(buf));
1157 va_end(ap);
1158 }
1159
1160 void qemu_chr_send_event(CharDriverState *s, int event)
1161 {
1162 if (s->chr_send_event)
1163 s->chr_send_event(s, event);
1164 }
1165
1166 void qemu_chr_add_read_handler(CharDriverState *s,
1167 IOCanRWHandler *fd_can_read,
1168 IOReadHandler *fd_read, void *opaque)
1169 {
1170 s->chr_add_read_handler(s, fd_can_read, fd_read, opaque);
1171 }
1172
1173 void qemu_chr_add_event_handler(CharDriverState *s, IOEventHandler *chr_event)
1174 {
1175 s->chr_event = chr_event;
1176 }
1177
1178 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1179 {
1180 return len;
1181 }
1182
1183 static void null_chr_add_read_handler(CharDriverState *chr,
1184 IOCanRWHandler *fd_can_read,
1185 IOReadHandler *fd_read, void *opaque)
1186 {
1187 }
1188
1189 static CharDriverState *qemu_chr_open_null(void)
1190 {
1191 CharDriverState *chr;
1192
1193 chr = qemu_mallocz(sizeof(CharDriverState));
1194 if (!chr)
1195 return NULL;
1196 chr->chr_write = null_chr_write;
1197 chr->chr_add_read_handler = null_chr_add_read_handler;
1198 return chr;
1199 }
1200
1201 #ifdef _WIN32
1202
1203 static void socket_cleanup(void)
1204 {
1205 WSACleanup();
1206 }
1207
1208 static int socket_init(void)
1209 {
1210 WSADATA Data;
1211 int ret, err;
1212
1213 ret = WSAStartup(MAKEWORD(2,2), &Data);
1214 if (ret != 0) {
1215 err = WSAGetLastError();
1216 fprintf(stderr, "WSAStartup: %d\n", err);
1217 return -1;
1218 }
1219 atexit(socket_cleanup);
1220 return 0;
1221 }
1222
1223 static int send_all(int fd, const uint8_t *buf, int len1)
1224 {
1225 int ret, len;
1226
1227 len = len1;
1228 while (len > 0) {
1229 ret = send(fd, buf, len, 0);
1230 if (ret < 0) {
1231 int errno;
1232 errno = WSAGetLastError();
1233 if (errno != WSAEWOULDBLOCK) {
1234 return -1;
1235 }
1236 } else if (ret == 0) {
1237 break;
1238 } else {
1239 buf += ret;
1240 len -= ret;
1241 }
1242 }
1243 return len1 - len;
1244 }
1245
1246 void socket_set_nonblock(int fd)
1247 {
1248 unsigned long opt = 1;
1249 ioctlsocket(fd, FIONBIO, &opt);
1250 }
1251
1252 #else
1253
1254 static int unix_write(int fd, const uint8_t *buf, int len1)
1255 {
1256 int ret, len;
1257
1258 len = len1;
1259 while (len > 0) {
1260 ret = write(fd, buf, len);
1261 if (ret < 0) {
1262 if (errno != EINTR && errno != EAGAIN)
1263 return -1;
1264 } else if (ret == 0) {
1265 break;
1266 } else {
1267 buf += ret;
1268 len -= ret;
1269 }
1270 }
1271 return len1 - len;
1272 }
1273
1274 static inline int send_all(int fd, const uint8_t *buf, int len1)
1275 {
1276 return unix_write(fd, buf, len1);
1277 }
1278
1279 void socket_set_nonblock(int fd)
1280 {
1281 fcntl(fd, F_SETFL, O_NONBLOCK);
1282 }
1283 #endif /* !_WIN32 */
1284
1285 #ifndef _WIN32
1286
1287 typedef struct {
1288 int fd_in, fd_out;
1289 IOCanRWHandler *fd_can_read;
1290 IOReadHandler *fd_read;
1291 void *fd_opaque;
1292 int max_size;
1293 } FDCharDriver;
1294
1295 #define STDIO_MAX_CLIENTS 2
1296
1297 static int stdio_nb_clients;
1298 static CharDriverState *stdio_clients[STDIO_MAX_CLIENTS];
1299
1300 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1301 {
1302 FDCharDriver *s = chr->opaque;
1303 return unix_write(s->fd_out, buf, len);
1304 }
1305
1306 static int fd_chr_read_poll(void *opaque)
1307 {
1308 CharDriverState *chr = opaque;
1309 FDCharDriver *s = chr->opaque;
1310
1311 s->max_size = s->fd_can_read(s->fd_opaque);
1312 return s->max_size;
1313 }
1314
1315 static void fd_chr_read(void *opaque)
1316 {
1317 CharDriverState *chr = opaque;
1318 FDCharDriver *s = chr->opaque;
1319 int size, len;
1320 uint8_t buf[1024];
1321
1322 len = sizeof(buf);
1323 if (len > s->max_size)
1324 len = s->max_size;
1325 if (len == 0)
1326 return;
1327 size = read(s->fd_in, buf, len);
1328 if (size == 0) {
1329 /* FD has been closed. Remove it from the active list. */
1330 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
1331 return;
1332 }
1333 if (size > 0) {
1334 s->fd_read(s->fd_opaque, buf, size);
1335 }
1336 }
1337
1338 static void fd_chr_add_read_handler(CharDriverState *chr,
1339 IOCanRWHandler *fd_can_read,
1340 IOReadHandler *fd_read, void *opaque)
1341 {
1342 FDCharDriver *s = chr->opaque;
1343
1344 if (s->fd_in >= 0) {
1345 s->fd_can_read = fd_can_read;
1346 s->fd_read = fd_read;
1347 s->fd_opaque = opaque;
1348 if (nographic && s->fd_in == 0) {
1349 } else {
1350 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
1351 fd_chr_read, NULL, chr);
1352 }
1353 }
1354 }
1355
1356 /* open a character device to a unix fd */
1357 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
1358 {
1359 CharDriverState *chr;
1360 FDCharDriver *s;
1361
1362 chr = qemu_mallocz(sizeof(CharDriverState));
1363 if (!chr)
1364 return NULL;
1365 s = qemu_mallocz(sizeof(FDCharDriver));
1366 if (!s) {
1367 free(chr);
1368 return NULL;
1369 }
1370 s->fd_in = fd_in;
1371 s->fd_out = fd_out;
1372 chr->opaque = s;
1373 chr->chr_write = fd_chr_write;
1374 chr->chr_add_read_handler = fd_chr_add_read_handler;
1375
1376 qemu_chr_reset(chr);
1377
1378 return chr;
1379 }
1380
1381 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
1382 {
1383 int fd_out;
1384
1385 fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666);
1386 if (fd_out < 0)
1387 return NULL;
1388 return qemu_chr_open_fd(-1, fd_out);
1389 }
1390
1391 static CharDriverState *qemu_chr_open_pipe(const char *filename)
1392 {
1393 int fd_in, fd_out;
1394 char filename_in[256], filename_out[256];
1395
1396 snprintf(filename_in, 256, "%s.in", filename);
1397 snprintf(filename_out, 256, "%s.out", filename);
1398 fd_in = open(filename_in, O_RDWR | O_BINARY);
1399 fd_out = open(filename_out, O_RDWR | O_BINARY);
1400 if (fd_in < 0 || fd_out < 0) {
1401 if (fd_in >= 0)
1402 close(fd_in);
1403 if (fd_out >= 0)
1404 close(fd_out);
1405 fd_in = fd_out = open(filename, O_RDWR | O_BINARY);
1406 if (fd_in < 0)
1407 return NULL;
1408 }
1409 return qemu_chr_open_fd(fd_in, fd_out);
1410 }
1411
1412
1413 /* for STDIO, we handle the case where several clients use it
1414 (nographic mode) */
1415
1416 #define TERM_ESCAPE 0x01 /* ctrl-a is used for escape */
1417
1418 #define TERM_FIFO_MAX_SIZE 1
1419
1420 static int term_got_escape, client_index;
1421 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
1422 static int term_fifo_size;
1423 static int term_timestamps;
1424 static int64_t term_timestamps_start;
1425
1426 void term_print_help(void)
1427 {
1428 printf("\n"
1429 "C-a h print this help\n"
1430 "C-a x exit emulator\n"
1431 "C-a s save disk data back to file (if -snapshot)\n"
1432 "C-a b send break (magic sysrq)\n"
1433 "C-a t toggle console timestamps\n"
1434 "C-a c switch between console and monitor\n"
1435 "C-a C-a send C-a\n"
1436 );
1437 }
1438
1439 /* called when a char is received */
1440 static void stdio_received_byte(int ch)
1441 {
1442 if (term_got_escape) {
1443 term_got_escape = 0;
1444 switch(ch) {
1445 case 'h':
1446 term_print_help();
1447 break;
1448 case 'x':
1449 exit(0);
1450 break;
1451 case 's':
1452 {
1453 int i;
1454 for (i = 0; i < MAX_DISKS; i++) {
1455 if (bs_table[i])
1456 bdrv_commit(bs_table[i]);
1457 }
1458 }
1459 break;
1460 case 'b':
1461 if (client_index < stdio_nb_clients) {
1462 CharDriverState *chr;
1463 FDCharDriver *s;
1464
1465 chr = stdio_clients[client_index];
1466 s = chr->opaque;
1467 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
1468 }
1469 break;
1470 case 'c':
1471 client_index++;
1472 if (client_index >= stdio_nb_clients)
1473 client_index = 0;
1474 if (client_index == 0) {
1475 /* send a new line in the monitor to get the prompt */
1476 ch = '\r';
1477 goto send_char;
1478 }
1479 break;
1480 case 't':
1481 term_timestamps = !term_timestamps;
1482 term_timestamps_start = -1;
1483 break;
1484 case TERM_ESCAPE:
1485 goto send_char;
1486 }
1487 } else if (ch == TERM_ESCAPE) {
1488 term_got_escape = 1;
1489 } else {
1490 send_char:
1491 if (client_index < stdio_nb_clients) {
1492 uint8_t buf[1];
1493 CharDriverState *chr;
1494 FDCharDriver *s;
1495
1496 chr = stdio_clients[client_index];
1497 s = chr->opaque;
1498 if (s->fd_can_read(s->fd_opaque) > 0) {
1499 buf[0] = ch;
1500 s->fd_read(s->fd_opaque, buf, 1);
1501 } else if (term_fifo_size == 0) {
1502 term_fifo[term_fifo_size++] = ch;
1503 }
1504 }
1505 }
1506 }
1507
1508 static int stdio_read_poll(void *opaque)
1509 {
1510 CharDriverState *chr;
1511 FDCharDriver *s;
1512
1513 if (client_index < stdio_nb_clients) {
1514 chr = stdio_clients[client_index];
1515 s = chr->opaque;
1516 /* try to flush the queue if needed */
1517 if (term_fifo_size != 0 && s->fd_can_read(s->fd_opaque) > 0) {
1518 s->fd_read(s->fd_opaque, term_fifo, 1);
1519 term_fifo_size = 0;
1520 }
1521 /* see if we can absorb more chars */
1522 if (term_fifo_size == 0)
1523 return 1;
1524 else
1525 return 0;
1526 } else {
1527 return 1;
1528 }
1529 }
1530
1531 static void stdio_read(void *opaque)
1532 {
1533 int size;
1534 uint8_t buf[1];
1535
1536 size = read(0, buf, 1);
1537 if (size == 0) {
1538 /* stdin has been closed. Remove it from the active list. */
1539 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
1540 return;
1541 }
1542 if (size > 0)
1543 stdio_received_byte(buf[0]);
1544 }
1545
1546 static int stdio_write(CharDriverState *chr, const uint8_t *buf, int len)
1547 {
1548 FDCharDriver *s = chr->opaque;
1549 if (!term_timestamps) {
1550 return unix_write(s->fd_out, buf, len);
1551 } else {
1552 int i;
1553 char buf1[64];
1554
1555 for(i = 0; i < len; i++) {
1556 unix_write(s->fd_out, buf + i, 1);
1557 if (buf[i] == '\n') {
1558 int64_t ti;
1559 int secs;
1560
1561 ti = get_clock();
1562 if (term_timestamps_start == -1)
1563 term_timestamps_start = ti;
1564 ti -= term_timestamps_start;
1565 secs = ti / 1000000000;
1566 snprintf(buf1, sizeof(buf1),
1567 "[%02d:%02d:%02d.%03d] ",
1568 secs / 3600,
1569 (secs / 60) % 60,
1570 secs % 60,
1571 (int)((ti / 1000000) % 1000));
1572 unix_write(s->fd_out, buf1, strlen(buf1));
1573 }
1574 }
1575 return len;
1576 }
1577 }
1578
1579 /* init terminal so that we can grab keys */
1580 static struct termios oldtty;
1581 static int old_fd0_flags;
1582
1583 static void term_exit(void)
1584 {
1585 tcsetattr (0, TCSANOW, &oldtty);
1586 fcntl(0, F_SETFL, old_fd0_flags);
1587 }
1588
1589 static void term_init(void)
1590 {
1591 struct termios tty;
1592
1593 tcgetattr (0, &tty);
1594 oldtty = tty;
1595 old_fd0_flags = fcntl(0, F_GETFL);
1596
1597 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1598 |INLCR|IGNCR|ICRNL|IXON);
1599 tty.c_oflag |= OPOST;
1600 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1601 /* if graphical mode, we allow Ctrl-C handling */
1602 if (nographic)
1603 tty.c_lflag &= ~ISIG;
1604 tty.c_cflag &= ~(CSIZE|PARENB);
1605 tty.c_cflag |= CS8;
1606 tty.c_cc[VMIN] = 1;
1607 tty.c_cc[VTIME] = 0;
1608
1609 tcsetattr (0, TCSANOW, &tty);
1610
1611 atexit(term_exit);
1612
1613 fcntl(0, F_SETFL, O_NONBLOCK);
1614 }
1615
1616 static CharDriverState *qemu_chr_open_stdio(void)
1617 {
1618 CharDriverState *chr;
1619
1620 if (nographic) {
1621 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
1622 return NULL;
1623 chr = qemu_chr_open_fd(0, 1);
1624 chr->chr_write = stdio_write;
1625 if (stdio_nb_clients == 0)
1626 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, NULL);
1627 client_index = stdio_nb_clients;
1628 } else {
1629 if (stdio_nb_clients != 0)
1630 return NULL;
1631 chr = qemu_chr_open_fd(0, 1);
1632 }
1633 stdio_clients[stdio_nb_clients++] = chr;
1634 if (stdio_nb_clients == 1) {
1635 /* set the terminal in raw mode */
1636 term_init();
1637 }
1638 return chr;
1639 }
1640
1641 #if defined(__linux__)
1642 static CharDriverState *qemu_chr_open_pty(void)
1643 {
1644 struct termios tty;
1645 char slave_name[1024];
1646 int master_fd, slave_fd;
1647
1648 /* Not satisfying */
1649 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
1650 return NULL;
1651 }
1652
1653 /* Disabling local echo and line-buffered output */
1654 tcgetattr (master_fd, &tty);
1655 tty.c_lflag &= ~(ECHO|ICANON|ISIG);
1656 tty.c_cc[VMIN] = 1;
1657 tty.c_cc[VTIME] = 0;
1658 tcsetattr (master_fd, TCSAFLUSH, &tty);
1659
1660 fprintf(stderr, "char device redirected to %s\n", slave_name);
1661 return qemu_chr_open_fd(master_fd, master_fd);
1662 }
1663
1664 static void tty_serial_init(int fd, int speed,
1665 int parity, int data_bits, int stop_bits)
1666 {
1667 struct termios tty;
1668 speed_t spd;
1669
1670 #if 0
1671 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
1672 speed, parity, data_bits, stop_bits);
1673 #endif
1674 tcgetattr (fd, &tty);
1675
1676 switch(speed) {
1677 case 50:
1678 spd = B50;
1679 break;
1680 case 75:
1681 spd = B75;
1682 break;
1683 case 300:
1684 spd = B300;
1685 break;
1686 case 600:
1687 spd = B600;
1688 break;
1689 case 1200:
1690 spd = B1200;
1691 break;
1692 case 2400:
1693 spd = B2400;
1694 break;
1695 case 4800:
1696 spd = B4800;
1697 break;
1698 case 9600:
1699 spd = B9600;
1700 break;
1701 case 19200:
1702 spd = B19200;
1703 break;
1704 case 38400:
1705 spd = B38400;
1706 break;
1707 case 57600:
1708 spd = B57600;
1709 break;
1710 default:
1711 case 115200:
1712 spd = B115200;
1713 break;
1714 }
1715
1716 cfsetispeed(&tty, spd);
1717 cfsetospeed(&tty, spd);
1718
1719 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1720 |INLCR|IGNCR|ICRNL|IXON);
1721 tty.c_oflag |= OPOST;
1722 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
1723 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
1724 switch(data_bits) {
1725 default:
1726 case 8:
1727 tty.c_cflag |= CS8;
1728 break;
1729 case 7:
1730 tty.c_cflag |= CS7;
1731 break;
1732 case 6:
1733 tty.c_cflag |= CS6;
1734 break;
1735 case 5:
1736 tty.c_cflag |= CS5;
1737 break;
1738 }
1739 switch(parity) {
1740 default:
1741 case 'N':
1742 break;
1743 case 'E':
1744 tty.c_cflag |= PARENB;
1745 break;
1746 case 'O':
1747 tty.c_cflag |= PARENB | PARODD;
1748 break;
1749 }
1750 if (stop_bits == 2)
1751 tty.c_cflag |= CSTOPB;
1752
1753 tcsetattr (fd, TCSANOW, &tty);
1754 }
1755
1756 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
1757 {
1758 FDCharDriver *s = chr->opaque;
1759
1760 switch(cmd) {
1761 case CHR_IOCTL_SERIAL_SET_PARAMS:
1762 {
1763 QEMUSerialSetParams *ssp = arg;
1764 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
1765 ssp->data_bits, ssp->stop_bits);
1766 }
1767 break;
1768 case CHR_IOCTL_SERIAL_SET_BREAK:
1769 {
1770 int enable = *(int *)arg;
1771 if (enable)
1772 tcsendbreak(s->fd_in, 1);
1773 }
1774 break;
1775 default:
1776 return -ENOTSUP;
1777 }
1778 return 0;
1779 }
1780
1781 static CharDriverState *qemu_chr_open_tty(const char *filename)
1782 {
1783 CharDriverState *chr;
1784 int fd;
1785
1786 fd = open(filename, O_RDWR | O_NONBLOCK);
1787 if (fd < 0)
1788 return NULL;
1789 fcntl(fd, F_SETFL, O_NONBLOCK);
1790 tty_serial_init(fd, 115200, 'N', 8, 1);
1791 chr = qemu_chr_open_fd(fd, fd);
1792 if (!chr)
1793 return NULL;
1794 chr->chr_ioctl = tty_serial_ioctl;
1795 qemu_chr_reset(chr);
1796 return chr;
1797 }
1798
1799 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
1800 {
1801 int fd = (int)chr->opaque;
1802 uint8_t b;
1803
1804 switch(cmd) {
1805 case CHR_IOCTL_PP_READ_DATA:
1806 if (ioctl(fd, PPRDATA, &b) < 0)
1807 return -ENOTSUP;
1808 *(uint8_t *)arg = b;
1809 break;
1810 case CHR_IOCTL_PP_WRITE_DATA:
1811 b = *(uint8_t *)arg;
1812 if (ioctl(fd, PPWDATA, &b) < 0)
1813 return -ENOTSUP;
1814 break;
1815 case CHR_IOCTL_PP_READ_CONTROL:
1816 if (ioctl(fd, PPRCONTROL, &b) < 0)
1817 return -ENOTSUP;
1818 *(uint8_t *)arg = b;
1819 break;
1820 case CHR_IOCTL_PP_WRITE_CONTROL:
1821 b = *(uint8_t *)arg;
1822 if (ioctl(fd, PPWCONTROL, &b) < 0)
1823 return -ENOTSUP;
1824 break;
1825 case CHR_IOCTL_PP_READ_STATUS:
1826 if (ioctl(fd, PPRSTATUS, &b) < 0)
1827 return -ENOTSUP;
1828 *(uint8_t *)arg = b;
1829 break;
1830 default:
1831 return -ENOTSUP;
1832 }
1833 return 0;
1834 }
1835
1836 static CharDriverState *qemu_chr_open_pp(const char *filename)
1837 {
1838 CharDriverState *chr;
1839 int fd;
1840
1841 fd = open(filename, O_RDWR);
1842 if (fd < 0)
1843 return NULL;
1844
1845 if (ioctl(fd, PPCLAIM) < 0) {
1846 close(fd);
1847 return NULL;
1848 }
1849
1850 chr = qemu_mallocz(sizeof(CharDriverState));
1851 if (!chr) {
1852 close(fd);
1853 return NULL;
1854 }
1855 chr->opaque = (void *)fd;
1856 chr->chr_write = null_chr_write;
1857 chr->chr_add_read_handler = null_chr_add_read_handler;
1858 chr->chr_ioctl = pp_ioctl;
1859
1860 qemu_chr_reset(chr);
1861
1862 return chr;
1863 }
1864
1865 #else
1866 static CharDriverState *qemu_chr_open_pty(void)
1867 {
1868 return NULL;
1869 }
1870 #endif
1871
1872 #endif /* !defined(_WIN32) */
1873
1874 #ifdef _WIN32
1875 typedef struct {
1876 IOCanRWHandler *fd_can_read;
1877 IOReadHandler *fd_read;
1878 void *win_opaque;
1879 int max_size;
1880 HANDLE hcom, hrecv, hsend;
1881 OVERLAPPED orecv, osend;
1882 BOOL fpipe;
1883 DWORD len;
1884 } WinCharState;
1885
1886 #define NSENDBUF 2048
1887 #define NRECVBUF 2048
1888 #define MAXCONNECT 1
1889 #define NTIMEOUT 5000
1890
1891 static int win_chr_poll(void *opaque);
1892 static int win_chr_pipe_poll(void *opaque);
1893
1894 static void win_chr_close2(WinCharState *s)
1895 {
1896 if (s->hsend) {
1897 CloseHandle(s->hsend);
1898 s->hsend = NULL;
1899 }
1900 if (s->hrecv) {
1901 CloseHandle(s->hrecv);
1902 s->hrecv = NULL;
1903 }
1904 if (s->hcom) {
1905 CloseHandle(s->hcom);
1906 s->hcom = NULL;
1907 }
1908 if (s->fpipe)
1909 qemu_del_polling_cb(win_chr_pipe_poll, s);
1910 else
1911 qemu_del_polling_cb(win_chr_poll, s);
1912 }
1913
1914 static void win_chr_close(CharDriverState *chr)
1915 {
1916 WinCharState *s = chr->opaque;
1917 win_chr_close2(s);
1918 }
1919
1920 static int win_chr_init(WinCharState *s, const char *filename)
1921 {
1922 COMMCONFIG comcfg;
1923 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
1924 COMSTAT comstat;
1925 DWORD size;
1926 DWORD err;
1927
1928 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
1929 if (!s->hsend) {
1930 fprintf(stderr, "Failed CreateEvent\n");
1931 goto fail;
1932 }
1933 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
1934 if (!s->hrecv) {
1935 fprintf(stderr, "Failed CreateEvent\n");
1936 goto fail;
1937 }
1938
1939 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
1940 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
1941 if (s->hcom == INVALID_HANDLE_VALUE) {
1942 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
1943 s->hcom = NULL;
1944 goto fail;
1945 }
1946
1947 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
1948 fprintf(stderr, "Failed SetupComm\n");
1949 goto fail;
1950 }
1951
1952 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
1953 size = sizeof(COMMCONFIG);
1954 GetDefaultCommConfig(filename, &comcfg, &size);
1955 comcfg.dcb.DCBlength = sizeof(DCB);
1956 CommConfigDialog(filename, NULL, &comcfg);
1957
1958 if (!SetCommState(s->hcom, &comcfg.dcb)) {
1959 fprintf(stderr, "Failed SetCommState\n");
1960 goto fail;
1961 }
1962
1963 if (!SetCommMask(s->hcom, EV_ERR)) {
1964 fprintf(stderr, "Failed SetCommMask\n");
1965 goto fail;
1966 }
1967
1968 cto.ReadIntervalTimeout = MAXDWORD;
1969 if (!SetCommTimeouts(s->hcom, &cto)) {
1970 fprintf(stderr, "Failed SetCommTimeouts\n");
1971 goto fail;
1972 }
1973
1974 if (!ClearCommError(s->hcom, &err, &comstat)) {
1975 fprintf(stderr, "Failed ClearCommError\n");
1976 goto fail;
1977 }
1978 qemu_add_polling_cb(win_chr_poll, s);
1979 return 0;
1980
1981 fail:
1982 win_chr_close2(s);
1983 return -1;
1984 }
1985
1986 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
1987 {
1988 WinCharState *s = chr->opaque;
1989 DWORD len, ret, size, err;
1990
1991 len = len1;
1992 ZeroMemory(&s->osend, sizeof(s->osend));
1993 s->osend.hEvent = s->hsend;
1994 while (len > 0) {
1995 if (s->hsend)
1996 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
1997 else
1998 ret = WriteFile(s->hcom, buf, len, &size, NULL);
1999 if (!ret) {
2000 err = GetLastError();
2001 if (err == ERROR_IO_PENDING) {
2002 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2003 if (ret) {
2004 buf += size;
2005 len -= size;
2006 } else {
2007 break;
2008 }
2009 } else {
2010 break;
2011 }
2012 } else {
2013 buf += size;
2014 len -= size;
2015 }
2016 }
2017 return len1 - len;
2018 }
2019
2020 static int win_chr_read_poll(WinCharState *s)
2021 {
2022 s->max_size = s->fd_can_read(s->win_opaque);
2023 return s->max_size;
2024 }
2025
2026 static void win_chr_readfile(WinCharState *s)
2027 {
2028 int ret, err;
2029 uint8_t buf[1024];
2030 DWORD size;
2031
2032 ZeroMemory(&s->orecv, sizeof(s->orecv));
2033 s->orecv.hEvent = s->hrecv;
2034 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2035 if (!ret) {
2036 err = GetLastError();
2037 if (err == ERROR_IO_PENDING) {
2038 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2039 }
2040 }
2041
2042 if (size > 0) {
2043 s->fd_read(s->win_opaque, buf, size);
2044 }
2045 }
2046
2047 static void win_chr_read(WinCharState *s)
2048 {
2049 if (s->len > s->max_size)
2050 s->len = s->max_size;
2051 if (s->len == 0)
2052 return;
2053
2054 win_chr_readfile(s);
2055 }
2056
2057 static int win_chr_poll(void *opaque)
2058 {
2059 WinCharState *s = opaque;
2060 COMSTAT status;
2061 DWORD comerr;
2062
2063 ClearCommError(s->hcom, &comerr, &status);
2064 if (status.cbInQue > 0) {
2065 s->len = status.cbInQue;
2066 win_chr_read_poll(s);
2067 win_chr_read(s);
2068 return 1;
2069 }
2070 return 0;
2071 }
2072
2073 static void win_chr_add_read_handler(CharDriverState *chr,
2074 IOCanRWHandler *fd_can_read,
2075 IOReadHandler *fd_read, void *opaque)
2076 {
2077 WinCharState *s = chr->opaque;
2078
2079 s->fd_can_read = fd_can_read;
2080 s->fd_read = fd_read;
2081 s->win_opaque = opaque;
2082 }
2083
2084 static CharDriverState *qemu_chr_open_win(const char *filename)
2085 {
2086 CharDriverState *chr;
2087 WinCharState *s;
2088
2089 chr = qemu_mallocz(sizeof(CharDriverState));
2090 if (!chr)
2091 return NULL;
2092 s = qemu_mallocz(sizeof(WinCharState));
2093 if (!s) {
2094 free(chr);
2095 return NULL;
2096 }
2097 chr->opaque = s;
2098 chr->chr_write = win_chr_write;
2099 chr->chr_add_read_handler = win_chr_add_read_handler;
2100 chr->chr_close = win_chr_close;
2101
2102 if (win_chr_init(s, filename) < 0) {
2103 free(s);
2104 free(chr);
2105 return NULL;
2106 }
2107 qemu_chr_reset(chr);
2108 return chr;
2109 }
2110
2111 static int win_chr_pipe_poll(void *opaque)
2112 {
2113 WinCharState *s = opaque;
2114 DWORD size;
2115
2116 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2117 if (size > 0) {
2118 s->len = size;
2119 win_chr_read_poll(s);
2120 win_chr_read(s);
2121 return 1;
2122 }
2123 return 0;
2124 }
2125
2126 static int win_chr_pipe_init(WinCharState *s, const char *filename)
2127 {
2128 OVERLAPPED ov;
2129 int ret;
2130 DWORD size;
2131 char openname[256];
2132
2133 s->fpipe = TRUE;
2134
2135 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2136 if (!s->hsend) {
2137 fprintf(stderr, "Failed CreateEvent\n");
2138 goto fail;
2139 }
2140 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2141 if (!s->hrecv) {
2142 fprintf(stderr, "Failed CreateEvent\n");
2143 goto fail;
2144 }
2145
2146 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2147 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2148 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2149 PIPE_WAIT,
2150 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2151 if (s->hcom == INVALID_HANDLE_VALUE) {
2152 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2153 s->hcom = NULL;
2154 goto fail;
2155 }
2156
2157 ZeroMemory(&ov, sizeof(ov));
2158 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2159 ret = ConnectNamedPipe(s->hcom, &ov);
2160 if (ret) {
2161 fprintf(stderr, "Failed ConnectNamedPipe\n");
2162 goto fail;
2163 }
2164
2165 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2166 if (!ret) {
2167 fprintf(stderr, "Failed GetOverlappedResult\n");
2168 if (ov.hEvent) {
2169 CloseHandle(ov.hEvent);
2170 ov.hEvent = NULL;
2171 }
2172 goto fail;
2173 }
2174
2175 if (ov.hEvent) {
2176 CloseHandle(ov.hEvent);
2177 ov.hEvent = NULL;
2178 }
2179 qemu_add_polling_cb(win_chr_pipe_poll, s);
2180 return 0;
2181
2182 fail:
2183 win_chr_close2(s);
2184 return -1;
2185 }
2186
2187
2188 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2189 {
2190 CharDriverState *chr;
2191 WinCharState *s;
2192
2193 chr = qemu_mallocz(sizeof(CharDriverState));
2194 if (!chr)
2195 return NULL;
2196 s = qemu_mallocz(sizeof(WinCharState));
2197 if (!s) {
2198 free(chr);
2199 return NULL;
2200 }
2201 chr->opaque = s;
2202 chr->chr_write = win_chr_write;
2203 chr->chr_add_read_handler = win_chr_add_read_handler;
2204 chr->chr_close = win_chr_close;
2205
2206 if (win_chr_pipe_init(s, filename) < 0) {
2207 free(s);
2208 free(chr);
2209 return NULL;
2210 }
2211 qemu_chr_reset(chr);
2212 return chr;
2213 }
2214
2215 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2216 {
2217 CharDriverState *chr;
2218 WinCharState *s;
2219
2220 chr = qemu_mallocz(sizeof(CharDriverState));
2221 if (!chr)
2222 return NULL;
2223 s = qemu_mallocz(sizeof(WinCharState));
2224 if (!s) {
2225 free(chr);
2226 return NULL;
2227 }
2228 s->hcom = fd_out;
2229 chr->opaque = s;
2230 chr->chr_write = win_chr_write;
2231 chr->chr_add_read_handler = win_chr_add_read_handler;
2232 qemu_chr_reset(chr);
2233 return chr;
2234 }
2235
2236 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2237 {
2238 HANDLE fd_out;
2239
2240 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2241 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2242 if (fd_out == INVALID_HANDLE_VALUE)
2243 return NULL;
2244
2245 return qemu_chr_open_win_file(fd_out);
2246 }
2247 #endif
2248
2249 /***********************************************************/
2250 /* UDP Net console */
2251
2252 typedef struct {
2253 IOCanRWHandler *fd_can_read;
2254 IOReadHandler *fd_read;
2255 void *fd_opaque;
2256 int fd;
2257 struct sockaddr_in daddr;
2258 char buf[1024];
2259 int bufcnt;
2260 int bufptr;
2261 int max_size;
2262 } NetCharDriver;
2263
2264 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2265 {
2266 NetCharDriver *s = chr->opaque;
2267
2268 return sendto(s->fd, buf, len, 0,
2269 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2270 }
2271
2272 static int udp_chr_read_poll(void *opaque)
2273 {
2274 CharDriverState *chr = opaque;
2275 NetCharDriver *s = chr->opaque;
2276
2277 s->max_size = s->fd_can_read(s->fd_opaque);
2278
2279 /* If there were any stray characters in the queue process them
2280 * first
2281 */
2282 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2283 s->fd_read(s->fd_opaque, &s->buf[s->bufptr], 1);
2284 s->bufptr++;
2285 s->max_size = s->fd_can_read(s->fd_opaque);
2286 }
2287 return s->max_size;
2288 }
2289
2290 static void udp_chr_read(void *opaque)
2291 {
2292 CharDriverState *chr = opaque;
2293 NetCharDriver *s = chr->opaque;
2294
2295 if (s->max_size == 0)
2296 return;
2297 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2298 s->bufptr = s->bufcnt;
2299 if (s->bufcnt <= 0)
2300 return;
2301
2302 s->bufptr = 0;
2303 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2304 s->fd_read(s->fd_opaque, &s->buf[s->bufptr], 1);
2305 s->bufptr++;
2306 s->max_size = s->fd_can_read(s->fd_opaque);
2307 }
2308 }
2309
2310 static void udp_chr_add_read_handler(CharDriverState *chr,
2311 IOCanRWHandler *fd_can_read,
2312 IOReadHandler *fd_read, void *opaque)
2313 {
2314 NetCharDriver *s = chr->opaque;
2315
2316 if (s->fd >= 0) {
2317 s->fd_can_read = fd_can_read;
2318 s->fd_read = fd_read;
2319 s->fd_opaque = opaque;
2320 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2321 udp_chr_read, NULL, chr);
2322 }
2323 }
2324
2325 int parse_host_port(struct sockaddr_in *saddr, const char *str);
2326 #ifndef _WIN32
2327 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
2328 #endif
2329 int parse_host_src_port(struct sockaddr_in *haddr,
2330 struct sockaddr_in *saddr,
2331 const char *str);
2332
2333 static CharDriverState *qemu_chr_open_udp(const char *def)
2334 {
2335 CharDriverState *chr = NULL;
2336 NetCharDriver *s = NULL;
2337 int fd = -1;
2338 struct sockaddr_in saddr;
2339
2340 chr = qemu_mallocz(sizeof(CharDriverState));
2341 if (!chr)
2342 goto return_err;
2343 s = qemu_mallocz(sizeof(NetCharDriver));
2344 if (!s)
2345 goto return_err;
2346
2347 fd = socket(PF_INET, SOCK_DGRAM, 0);
2348 if (fd < 0) {
2349 perror("socket(PF_INET, SOCK_DGRAM)");
2350 goto return_err;
2351 }
2352
2353 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
2354 printf("Could not parse: %s\n", def);
2355 goto return_err;
2356 }
2357
2358 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
2359 {
2360 perror("bind");
2361 goto return_err;
2362 }
2363
2364 s->fd = fd;
2365 s->bufcnt = 0;
2366 s->bufptr = 0;
2367 chr->opaque = s;
2368 chr->chr_write = udp_chr_write;
2369 chr->chr_add_read_handler = udp_chr_add_read_handler;
2370 return chr;
2371
2372 return_err:
2373 if (chr)
2374 free(chr);
2375 if (s)
2376 free(s);
2377 if (fd >= 0)
2378 closesocket(fd);
2379 return NULL;
2380 }
2381
2382 /***********************************************************/
2383 /* TCP Net console */
2384
2385 typedef struct {
2386 IOCanRWHandler *fd_can_read;
2387 IOReadHandler *fd_read;
2388 void *fd_opaque;
2389 int fd, listen_fd;
2390 int connected;
2391 int max_size;
2392 int do_telnetopt;
2393 int is_unix;
2394 } TCPCharDriver;
2395
2396 static void tcp_chr_accept(void *opaque);
2397
2398 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2399 {
2400 TCPCharDriver *s = chr->opaque;
2401 if (s->connected) {
2402 return send_all(s->fd, buf, len);
2403 } else {
2404 /* XXX: indicate an error ? */
2405 return len;
2406 }
2407 }
2408
2409 static int tcp_chr_read_poll(void *opaque)
2410 {
2411 CharDriverState *chr = opaque;
2412 TCPCharDriver *s = chr->opaque;
2413 if (!s->connected)
2414 return 0;
2415 if (!s->fd_can_read)
2416 return 0;
2417 s->max_size = s->fd_can_read(s->fd_opaque);
2418 return s->max_size;
2419 }
2420
2421 #define IAC 255
2422 #define IAC_BREAK 243
2423 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
2424 TCPCharDriver *s,
2425 char *buf, int *size)
2426 {
2427 /* Handle any telnet client's basic IAC options to satisfy char by
2428 * char mode with no echo. All IAC options will be removed from
2429 * the buf and the do_telnetopt variable will be used to track the
2430 * state of the width of the IAC information.
2431 *
2432 * IAC commands come in sets of 3 bytes with the exception of the
2433 * "IAC BREAK" command and the double IAC.
2434 */
2435
2436 int i;
2437 int j = 0;
2438
2439 for (i = 0; i < *size; i++) {
2440 if (s->do_telnetopt > 1) {
2441 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
2442 /* Double IAC means send an IAC */
2443 if (j != i)
2444 buf[j] = buf[i];
2445 j++;
2446 s->do_telnetopt = 1;
2447 } else {
2448 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
2449 /* Handle IAC break commands by sending a serial break */
2450 chr->chr_event(s->fd_opaque, CHR_EVENT_BREAK);
2451 s->do_telnetopt++;
2452 }
2453 s->do_telnetopt++;
2454 }
2455 if (s->do_telnetopt >= 4) {
2456 s->do_telnetopt = 1;
2457 }
2458 } else {
2459 if ((unsigned char)buf[i] == IAC) {
2460 s->do_telnetopt = 2;
2461 } else {
2462 if (j != i)
2463 buf[j] = buf[i];
2464 j++;
2465 }
2466 }
2467 }
2468 *size = j;
2469 }
2470
2471 static void tcp_chr_read(void *opaque)
2472 {
2473 CharDriverState *chr = opaque;
2474 TCPCharDriver *s = chr->opaque;
2475 uint8_t buf[1024];
2476 int len, size;
2477
2478 if (!s->connected || s->max_size <= 0)
2479 return;
2480 len = sizeof(buf);
2481 if (len > s->max_size)
2482 len = s->max_size;
2483 size = recv(s->fd, buf, len, 0);
2484 if (size == 0) {
2485 /* connection closed */
2486 s->connected = 0;
2487 if (s->listen_fd >= 0) {
2488 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2489 }
2490 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
2491 closesocket(s->fd);
2492 s->fd = -1;
2493 } else if (size > 0) {
2494 if (s->do_telnetopt)
2495 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
2496 if (size > 0)
2497 s->fd_read(s->fd_opaque, buf, size);
2498 }
2499 }
2500
2501 static void tcp_chr_add_read_handler(CharDriverState *chr,
2502 IOCanRWHandler *fd_can_read,
2503 IOReadHandler *fd_read, void *opaque)
2504 {
2505 TCPCharDriver *s = chr->opaque;
2506
2507 s->fd_can_read = fd_can_read;
2508 s->fd_read = fd_read;
2509 s->fd_opaque = opaque;
2510 }
2511
2512 static void tcp_chr_connect(void *opaque)
2513 {
2514 CharDriverState *chr = opaque;
2515 TCPCharDriver *s = chr->opaque;
2516
2517 s->connected = 1;
2518 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
2519 tcp_chr_read, NULL, chr);
2520 qemu_chr_reset(chr);
2521 }
2522
2523 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
2524 static void tcp_chr_telnet_init(int fd)
2525 {
2526 char buf[3];
2527 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
2528 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
2529 send(fd, (char *)buf, 3, 0);
2530 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
2531 send(fd, (char *)buf, 3, 0);
2532 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
2533 send(fd, (char *)buf, 3, 0);
2534 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
2535 send(fd, (char *)buf, 3, 0);
2536 }
2537
2538 static void tcp_chr_accept(void *opaque)
2539 {
2540 CharDriverState *chr = opaque;
2541 TCPCharDriver *s = chr->opaque;
2542 struct sockaddr_in saddr;
2543 #ifndef _WIN32
2544 struct sockaddr_un uaddr;
2545 #endif
2546 struct sockaddr *addr;
2547 socklen_t len;
2548 int fd;
2549
2550 for(;;) {
2551 #ifndef _WIN32
2552 if (s->is_unix) {
2553 len = sizeof(uaddr);
2554 addr = (struct sockaddr *)&uaddr;
2555 } else
2556 #endif
2557 {
2558 len = sizeof(saddr);
2559 addr = (struct sockaddr *)&saddr;
2560 }
2561 fd = accept(s->listen_fd, addr, &len);
2562 if (fd < 0 && errno != EINTR) {
2563 return;
2564 } else if (fd >= 0) {
2565 if (s->do_telnetopt)
2566 tcp_chr_telnet_init(fd);
2567 break;
2568 }
2569 }
2570 socket_set_nonblock(fd);
2571 s->fd = fd;
2572 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
2573 tcp_chr_connect(chr);
2574 }
2575
2576 static void tcp_chr_close(CharDriverState *chr)
2577 {
2578 TCPCharDriver *s = chr->opaque;
2579 if (s->fd >= 0)
2580 closesocket(s->fd);
2581 if (s->listen_fd >= 0)
2582 closesocket(s->listen_fd);
2583 qemu_free(s);
2584 }
2585
2586 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
2587 int is_telnet,
2588 int is_unix)
2589 {
2590 CharDriverState *chr = NULL;
2591 TCPCharDriver *s = NULL;
2592 int fd = -1, ret, err, val;
2593 int is_listen = 0;
2594 int is_waitconnect = 1;
2595 const char *ptr;
2596 struct sockaddr_in saddr;
2597 #ifndef _WIN32
2598 struct sockaddr_un uaddr;
2599 #endif
2600 struct sockaddr *addr;
2601 socklen_t addrlen;
2602
2603 #ifndef _WIN32
2604 if (is_unix) {
2605 addr = (struct sockaddr *)&uaddr;
2606 addrlen = sizeof(uaddr);
2607 if (parse_unix_path(&uaddr, host_str) < 0)
2608 goto fail;
2609 } else
2610 #endif
2611 {
2612 addr = (struct sockaddr *)&saddr;
2613 addrlen = sizeof(saddr);
2614 if (parse_host_port(&saddr, host_str) < 0)
2615 goto fail;
2616 }
2617
2618 ptr = host_str;
2619 while((ptr = strchr(ptr,','))) {
2620 ptr++;
2621 if (!strncmp(ptr,"server",6)) {
2622 is_listen = 1;
2623 } else if (!strncmp(ptr,"nowait",6)) {
2624 is_waitconnect = 0;
2625 } else {
2626 printf("Unknown option: %s\n", ptr);
2627 goto fail;
2628 }
2629 }
2630 if (!is_listen)
2631 is_waitconnect = 0;
2632
2633 chr = qemu_mallocz(sizeof(CharDriverState));
2634 if (!chr)
2635 goto fail;
2636 s = qemu_mallocz(sizeof(TCPCharDriver));
2637 if (!s)
2638 goto fail;
2639
2640 #ifndef _WIN32
2641 if (is_unix)
2642 fd = socket(PF_UNIX, SOCK_STREAM, 0);
2643 else
2644 #endif
2645 fd = socket(PF_INET, SOCK_STREAM, 0);
2646
2647 if (fd < 0)
2648 goto fail;
2649
2650 if (!is_waitconnect)
2651 socket_set_nonblock(fd);
2652
2653 s->connected = 0;
2654 s->fd = -1;
2655 s->listen_fd = -1;
2656 s->is_unix = is_unix;
2657
2658 chr->opaque = s;
2659 chr->chr_write = tcp_chr_write;
2660 chr->chr_add_read_handler = tcp_chr_add_read_handler;
2661 chr->chr_close = tcp_chr_close;
2662
2663 if (is_listen) {
2664 /* allow fast reuse */
2665 #ifndef _WIN32
2666 if (is_unix) {
2667 char path[109];
2668 strncpy(path, uaddr.sun_path, 108);
2669 path[108] = 0;
2670 unlink(path);
2671 } else
2672 #endif
2673 {
2674 val = 1;
2675 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
2676 }
2677
2678 ret = bind(fd, addr, addrlen);
2679 if (ret < 0)
2680 goto fail;
2681
2682 ret = listen(fd, 0);
2683 if (ret < 0)
2684 goto fail;
2685
2686 s->listen_fd = fd;
2687 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
2688 if (is_telnet)
2689 s->do_telnetopt = 1;
2690 } else {
2691 for(;;) {
2692 ret = connect(fd, addr, addrlen);
2693 if (ret < 0) {
2694 err = socket_error();
2695 if (err == EINTR || err == EWOULDBLOCK) {
2696 } else if (err == EINPROGRESS) {
2697 break;
2698 } else {
2699 goto fail;
2700 }
2701 } else {
2702 s->connected = 1;
2703 break;
2704 }
2705 }
2706 s->fd = fd;
2707 if (s->connected)
2708 tcp_chr_connect(chr);
2709 else
2710 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
2711 }
2712
2713 if (is_listen && is_waitconnect) {
2714 printf("QEMU waiting for connection on: %s\n", host_str);
2715 tcp_chr_accept(chr);
2716 socket_set_nonblock(s->listen_fd);
2717 }
2718
2719 return chr;
2720 fail:
2721 if (fd >= 0)
2722 closesocket(fd);
2723 qemu_free(s);
2724 qemu_free(chr);
2725 return NULL;
2726 }
2727
2728 CharDriverState *qemu_chr_open(const char *filename)
2729 {
2730 const char *p;
2731
2732 if (!strcmp(filename, "vc")) {
2733 return text_console_init(&display_state);
2734 } else if (!strcmp(filename, "null")) {
2735 return qemu_chr_open_null();
2736 } else
2737 if (strstart(filename, "tcp:", &p)) {
2738 return qemu_chr_open_tcp(p, 0, 0);
2739 } else
2740 if (strstart(filename, "telnet:", &p)) {
2741 return qemu_chr_open_tcp(p, 1, 0);
2742 } else
2743 if (strstart(filename, "udp:", &p)) {
2744 return qemu_chr_open_udp(p);
2745 } else
2746 #ifndef _WIN32
2747 if (strstart(filename, "unix:", &p)) {
2748 return qemu_chr_open_tcp(p, 0, 1);
2749 } else if (strstart(filename, "file:", &p)) {
2750 return qemu_chr_open_file_out(p);
2751 } else if (strstart(filename, "pipe:", &p)) {
2752 return qemu_chr_open_pipe(p);
2753 } else if (!strcmp(filename, "pty")) {
2754 return qemu_chr_open_pty();
2755 } else if (!strcmp(filename, "stdio")) {
2756 return qemu_chr_open_stdio();
2757 } else
2758 #endif
2759 #if defined(__linux__)
2760 if (strstart(filename, "/dev/parport", NULL)) {
2761 return qemu_chr_open_pp(filename);
2762 } else
2763 if (strstart(filename, "/dev/", NULL)) {
2764 return qemu_chr_open_tty(filename);
2765 } else
2766 #endif
2767 #ifdef _WIN32
2768 if (strstart(filename, "COM", NULL)) {
2769 return qemu_chr_open_win(filename);
2770 } else
2771 if (strstart(filename, "pipe:", &p)) {
2772 return qemu_chr_open_win_pipe(p);
2773 } else
2774 if (strstart(filename, "file:", &p)) {
2775 return qemu_chr_open_win_file_out(p);
2776 }
2777 #endif
2778 {
2779 return NULL;
2780 }
2781 }
2782
2783 void qemu_chr_close(CharDriverState *chr)
2784 {
2785 if (chr->chr_close)
2786 chr->chr_close(chr);
2787 }
2788
2789 /***********************************************************/
2790 /* network device redirectors */
2791
2792 void hex_dump(FILE *f, const uint8_t *buf, int size)
2793 {
2794 int len, i, j, c;
2795
2796 for(i=0;i<size;i+=16) {
2797 len = size - i;
2798 if (len > 16)
2799 len = 16;
2800 fprintf(f, "%08x ", i);
2801 for(j=0;j<16;j++) {
2802 if (j < len)
2803 fprintf(f, " %02x", buf[i+j]);
2804 else
2805 fprintf(f, " ");
2806 }
2807 fprintf(f, " ");
2808 for(j=0;j<len;j++) {
2809 c = buf[i+j];
2810 if (c < ' ' || c > '~')
2811 c = '.';
2812 fprintf(f, "%c", c);
2813 }
2814 fprintf(f, "\n");
2815 }
2816 }
2817
2818 static int parse_macaddr(uint8_t *macaddr, const char *p)
2819 {
2820 int i;
2821 for(i = 0; i < 6; i++) {
2822 macaddr[i] = strtol(p, (char **)&p, 16);
2823 if (i == 5) {
2824 if (*p != '\0')
2825 return -1;
2826 } else {
2827 if (*p != ':')
2828 return -1;
2829 p++;
2830 }
2831 }
2832 return 0;
2833 }
2834
2835 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
2836 {
2837 const char *p, *p1;
2838 int len;
2839 p = *pp;
2840 p1 = strchr(p, sep);
2841 if (!p1)
2842 return -1;
2843 len = p1 - p;
2844 p1++;
2845 if (buf_size > 0) {
2846 if (len > buf_size - 1)
2847 len = buf_size - 1;
2848 memcpy(buf, p, len);
2849 buf[len] = '\0';
2850 }
2851 *pp = p1;
2852 return 0;
2853 }
2854
2855 int parse_host_src_port(struct sockaddr_in *haddr,
2856 struct sockaddr_in *saddr,
2857 const char *input_str)
2858 {
2859 char *str = strdup(input_str);
2860 char *host_str = str;
2861 char *src_str;
2862 char *ptr;
2863
2864 /*
2865 * Chop off any extra arguments at the end of the string which
2866 * would start with a comma, then fill in the src port information
2867 * if it was provided else use the "any address" and "any port".
2868 */
2869 if ((ptr = strchr(str,',')))
2870 *ptr = '\0';
2871
2872 if ((src_str = strchr(input_str,'@'))) {
2873 *src_str = '\0';
2874 src_str++;
2875 }
2876
2877 if (parse_host_port(haddr, host_str) < 0)
2878 goto fail;
2879
2880 if (!src_str || *src_str == '\0')
2881 src_str = ":0";
2882
2883 if (parse_host_port(saddr, src_str) < 0)
2884 goto fail;
2885
2886 free(str);
2887 return(0);
2888
2889 fail:
2890 free(str);
2891 return -1;
2892 }
2893
2894 int parse_host_port(struct sockaddr_in *saddr, const char *str)
2895 {
2896 char buf[512];
2897 struct hostent *he;
2898 const char *p, *r;
2899 int port;
2900
2901 p = str;
2902 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
2903 return -1;
2904 saddr->sin_family = AF_INET;
2905 if (buf[0] == '\0') {
2906 saddr->sin_addr.s_addr = 0;
2907 } else {
2908 if (isdigit(buf[0])) {
2909 if (!inet_aton(buf, &saddr->sin_addr))
2910 return -1;
2911 } else {
2912 if ((he = gethostbyname(buf)) == NULL)
2913 return - 1;
2914 saddr->sin_addr = *(struct in_addr *)he->h_addr;
2915 }
2916 }
2917 port = strtol(p, (char **)&r, 0);
2918 if (r == p)
2919 return -1;
2920 saddr->sin_port = htons(port);
2921 return 0;
2922 }
2923
2924 #ifndef _WIN32
2925 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
2926 {
2927 const char *p;
2928 int len;
2929
2930 len = MIN(108, strlen(str));
2931 p = strchr(str, ',');
2932 if (p)
2933 len = MIN(len, p - str);
2934
2935 memset(uaddr, 0, sizeof(*uaddr));
2936
2937 uaddr->sun_family = AF_UNIX;
2938 memcpy(uaddr->sun_path, str, len);
2939
2940 return 0;
2941 }
2942 #endif
2943
2944 /* find or alloc a new VLAN */
2945 VLANState *qemu_find_vlan(int id)
2946 {
2947 VLANState **pvlan, *vlan;
2948 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
2949 if (vlan->id == id)
2950 return vlan;
2951 }
2952 vlan = qemu_mallocz(sizeof(VLANState));
2953 if (!vlan)
2954 return NULL;
2955 vlan->id = id;
2956 vlan->next = NULL;
2957 pvlan = &first_vlan;
2958 while (*pvlan != NULL)
2959 pvlan = &(*pvlan)->next;
2960 *pvlan = vlan;
2961 return vlan;
2962 }
2963
2964 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
2965 IOReadHandler *fd_read,
2966 IOCanRWHandler *fd_can_read,
2967 void *opaque)
2968 {
2969 VLANClientState *vc, **pvc;
2970 vc = qemu_mallocz(sizeof(VLANClientState));
2971 if (!vc)
2972 return NULL;
2973 vc->fd_read = fd_read;
2974 vc->fd_can_read = fd_can_read;
2975 vc->opaque = opaque;
2976 vc->vlan = vlan;
2977
2978 vc->next = NULL;
2979 pvc = &vlan->first_client;
2980 while (*pvc != NULL)
2981 pvc = &(*pvc)->next;
2982 *pvc = vc;
2983 return vc;
2984 }
2985
2986 int qemu_can_send_packet(VLANClientState *vc1)
2987 {
2988 VLANState *vlan = vc1->vlan;
2989 VLANClientState *vc;
2990
2991 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
2992 if (vc != vc1) {
2993 if (vc->fd_can_read && !vc->fd_can_read(vc->opaque))
2994 return 0;
2995 }
2996 }
2997 return 1;
2998 }
2999
3000 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3001 {
3002 VLANState *vlan = vc1->vlan;
3003 VLANClientState *vc;
3004
3005 #if 0
3006 printf("vlan %d send:\n", vlan->id);
3007 hex_dump(stdout, buf, size);
3008 #endif
3009 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3010 if (vc != vc1) {
3011 vc->fd_read(vc->opaque, buf, size);
3012 }
3013 }
3014 }
3015
3016 #if defined(CONFIG_SLIRP)
3017
3018 /* slirp network adapter */
3019
3020 static int slirp_inited;
3021 static VLANClientState *slirp_vc;
3022
3023 int slirp_can_output(void)
3024 {
3025 return !slirp_vc || qemu_can_send_packet(slirp_vc);
3026 }
3027
3028 void slirp_output(const uint8_t *pkt, int pkt_len)
3029 {
3030 #if 0
3031 printf("slirp output:\n");
3032 hex_dump(stdout, pkt, pkt_len);
3033 #endif
3034 if (!slirp_vc)
3035 return;
3036 qemu_send_packet(slirp_vc, pkt, pkt_len);
3037 }
3038
3039 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3040 {
3041 #if 0
3042 printf("slirp input:\n");
3043 hex_dump(stdout, buf, size);
3044 #endif
3045 slirp_input(buf, size);
3046 }
3047
3048 static int net_slirp_init(VLANState *vlan)
3049 {
3050 if (!slirp_inited) {
3051 slirp_inited = 1;
3052 slirp_init();
3053 }
3054 slirp_vc = qemu_new_vlan_client(vlan,
3055 slirp_receive, NULL, NULL);
3056 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3057 return 0;
3058 }
3059
3060 static void net_slirp_redir(const char *redir_str)
3061 {
3062 int is_udp;
3063 char buf[256], *r;
3064 const char *p;
3065 struct in_addr guest_addr;
3066 int host_port, guest_port;
3067
3068 if (!slirp_inited) {
3069 slirp_inited = 1;
3070 slirp_init();
3071 }
3072
3073 p = redir_str;
3074 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3075 goto fail;
3076 if (!strcmp(buf, "tcp")) {
3077 is_udp = 0;
3078 } else if (!strcmp(buf, "udp")) {
3079 is_udp = 1;
3080 } else {
3081 goto fail;
3082 }
3083
3084 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3085 goto fail;
3086 host_port = strtol(buf, &r, 0);
3087 if (r == buf)
3088 goto fail;
3089
3090 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3091 goto fail;
3092 if (buf[0] == '\0') {
3093 pstrcpy(buf, sizeof(buf), "10.0.2.15");
3094 }
3095 if (!inet_aton(buf, &guest_addr))
3096 goto fail;
3097
3098 guest_port = strtol(p, &r, 0);
3099 if (r == p)
3100 goto fail;
3101
3102 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3103 fprintf(stderr, "qemu: could not set up redirection\n");
3104 exit(1);
3105 }
3106 return;
3107 fail:
3108 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3109 exit(1);
3110 }
3111
3112 #ifndef _WIN32
3113
3114 char smb_dir[1024];
3115
3116 static void smb_exit(void)
3117 {
3118 DIR *d;
3119 struct dirent *de;
3120 char filename[1024];
3121
3122 /* erase all the files in the directory */
3123 d = opendir(smb_dir);
3124 for(;;) {
3125 de = readdir(d);
3126 if (!de)
3127 break;
3128 if (strcmp(de->d_name, ".") != 0 &&
3129 strcmp(de->d_name, "..") != 0) {
3130 snprintf(filename, sizeof(filename), "%s/%s",
3131 smb_dir, de->d_name);
3132 unlink(filename);
3133 }
3134 }
3135 closedir(d);
3136 rmdir(smb_dir);
3137 }
3138
3139 /* automatic user mode samba server configuration */
3140 void net_slirp_smb(const char *exported_dir)
3141 {
3142 char smb_conf[1024];
3143 char smb_cmdline[1024];
3144 FILE *f;
3145
3146 if (!slirp_inited) {
3147 slirp_inited = 1;
3148 slirp_init();
3149 }
3150
3151 /* XXX: better tmp dir construction */
3152 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3153 if (mkdir(smb_dir, 0700) < 0) {
3154 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3155 exit(1);
3156 }
3157 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3158
3159 f = fopen(smb_conf, "w");
3160 if (!f) {
3161 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3162 exit(1);
3163 }
3164 fprintf(f,
3165 "[global]\n"
3166 "private dir=%s\n"
3167 "smb ports=0\n"
3168 "socket address=127.0.0.1\n"
3169 "pid directory=%s\n"
3170 "lock directory=%s\n"
3171 "log file=%s/log.smbd\n"
3172 "smb passwd file=%s/smbpasswd\n"
3173 "security = share\n"
3174 "[qemu]\n"
3175 "path=%s\n"
3176 "read only=no\n"
3177 "guest ok=yes\n",
3178 smb_dir,
3179 smb_dir,
3180 smb_dir,
3181 smb_dir,
3182 smb_dir,
3183 exported_dir
3184 );
3185 fclose(f);
3186 atexit(smb_exit);
3187
3188 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3189 SMBD_COMMAND, smb_conf);
3190
3191 slirp_add_exec(0, smb_cmdline, 4, 139);
3192 }
3193
3194 #endif /* !defined(_WIN32) */
3195
3196 #endif /* CONFIG_SLIRP */
3197
3198 #if !defined(_WIN32)
3199
3200 typedef struct TAPState {
3201 VLANClientState *vc;
3202 int fd;
3203 } TAPState;
3204
3205 static void tap_receive(void *opaque, const uint8_t *buf, int size)
3206 {
3207 TAPState *s = opaque;
3208 int ret;
3209 for(;;) {
3210 ret = write(s->fd, buf, size);
3211 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3212 } else {
3213 break;
3214 }
3215 }
3216 }
3217
3218 static void tap_send(void *opaque)
3219 {
3220 TAPState *s = opaque;
3221 uint8_t buf[4096];
3222 int size;
3223
3224 size = read(s->fd, buf, sizeof(buf));
3225 if (size > 0) {
3226 qemu_send_packet(s->vc, buf, size);
3227 }
3228 }
3229
3230 /* fd support */
3231
3232 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3233 {
3234 TAPState *s;
3235
3236 s = qemu_mallocz(sizeof(TAPState));
3237 if (!s)
3238 return NULL;
3239 s->fd = fd;
3240 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3241 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3242 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3243 return s;
3244 }
3245
3246 #ifdef _BSD
3247 static int tap_open(char *ifname, int ifname_size)
3248 {
3249 int fd;
3250 char *dev;
3251 struct stat s;
3252
3253 fd = open("/dev/tap", O_RDWR);
3254 if (fd < 0) {
3255 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3256 return -1;
3257 }
3258
3259 fstat(fd, &s);
3260 dev = devname(s.st_rdev, S_IFCHR);
3261 pstrcpy(ifname, ifname_size, dev);
3262
3263 fcntl(fd, F_SETFL, O_NONBLOCK);
3264 return fd;
3265 }
3266 #elif defined(__sun__)
3267 static int tap_open(char *ifname, int ifname_size)
3268 {
3269 fprintf(stderr, "warning: tap_open not yet implemented\n");
3270 return -1;
3271 }
3272 #else
3273 static int tap_open(char *ifname, int ifname_size)
3274 {
3275 struct ifreq ifr;
3276 int fd, ret;
3277
3278 fd = open("/dev/net/tun", O_RDWR);
3279 if (fd < 0) {
3280 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
3281 return -1;
3282 }
3283 memset(&ifr, 0, sizeof(ifr));
3284 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
3285 if (ifname[0] != '\0')
3286 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
3287 else
3288 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
3289 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
3290 if (ret != 0) {
3291 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
3292 close(fd);
3293 return -1;
3294 }
3295 pstrcpy(ifname, ifname_size, ifr.ifr_name);
3296 fcntl(fd, F_SETFL, O_NONBLOCK);
3297 return fd;
3298 }
3299 #endif
3300
3301 static int net_tap_init(VLANState *vlan, const char *ifname1,
3302 const char *setup_script)
3303 {
3304 TAPState *s;
3305 int pid, status, fd;
3306 char *args[3];
3307 char **parg;
3308 char ifname[128];
3309
3310 if (ifname1 != NULL)
3311 pstrcpy(ifname, sizeof(ifname), ifname1);
3312 else
3313 ifname[0] = '\0';
3314 fd = tap_open(ifname, sizeof(ifname));
3315 if (fd < 0)
3316 return -1;
3317
3318 if (!setup_script)
3319 setup_script = "";
3320 if (setup_script[0] != '\0') {
3321 /* try to launch network init script */
3322 pid = fork();
3323 if (pid >= 0) {
3324 if (pid == 0) {
3325 parg = args;
3326 *parg++ = (char *)setup_script;
3327 *parg++ = ifname;
3328 *parg++ = NULL;
3329 execv(setup_script, args);
3330 _exit(1);
3331 }
3332 while (waitpid(pid, &status, 0) != pid);
3333 if (!WIFEXITED(status) ||
3334 WEXITSTATUS(status) != 0) {
3335 fprintf(stderr, "%s: could not launch network script\n",
3336 setup_script);
3337 return -1;
3338 }
3339 }
3340 }
3341 s = net_tap_fd_init(vlan, fd);
3342 if (!s)
3343 return -1;
3344 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3345 "tap: ifname=%s setup_script=%s", ifname, setup_script);
3346 return 0;
3347 }
3348
3349 #endif /* !_WIN32 */
3350
3351 /* network connection */
3352 typedef struct NetSocketState {
3353 VLANClientState *vc;
3354 int fd;
3355 int state; /* 0 = getting length, 1 = getting data */
3356 int index;
3357 int packet_len;
3358 uint8_t buf[4096];
3359 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
3360 } NetSocketState;
3361
3362 typedef struct NetSocketListenState {
3363 VLANState *vlan;
3364 int fd;
3365 } NetSocketListenState;
3366
3367 /* XXX: we consider we can send the whole packet without blocking */
3368 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
3369 {
3370 NetSocketState *s = opaque;
3371 uint32_t len;
3372 len = htonl(size);
3373
3374 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
3375 send_all(s->fd, buf, size);
3376 }
3377
3378 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
3379 {
3380 NetSocketState *s = opaque;
3381 sendto(s->fd, buf, size, 0,
3382 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
3383 }
3384
3385 static void net_socket_send(void *opaque)
3386 {
3387 NetSocketState *s = opaque;
3388 int l, size, err;
3389 uint8_t buf1[4096];
3390 const uint8_t *buf;
3391
3392 size = recv(s->fd, buf1, sizeof(buf1), 0);
3393 if (size < 0) {
3394 err = socket_error();
3395 if (err != EWOULDBLOCK)
3396 goto eoc;
3397 } else if (size == 0) {
3398 /* end of connection */
3399 eoc:
3400 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3401 closesocket(s->fd);
3402 return;
3403 }
3404 buf = buf1;
3405 while (size > 0) {
3406 /* reassemble a packet from the network */
3407 switch(s->state) {
3408 case 0:
3409 l = 4 - s->index;
3410 if (l > size)
3411 l = size;
3412 memcpy(s->buf + s->index, buf, l);
3413 buf += l;
3414 size -= l;
3415 s->index += l;
3416 if (s->index == 4) {
3417 /* got length */
3418 s->packet_len = ntohl(*(uint32_t *)s->buf);
3419 s->index = 0;
3420 s->state = 1;
3421 }
3422 break;
3423 case 1:
3424 l = s->packet_len - s->index;
3425 if (l > size)
3426 l = size;
3427 memcpy(s->buf + s->index, buf, l);
3428 s->index += l;
3429 buf += l;
3430 size -= l;
3431 if (s->index >= s->packet_len) {
3432 qemu_send_packet(s->vc, s->buf, s->packet_len);
3433 s->index = 0;
3434 s->state = 0;
3435 }
3436 break;
3437 }
3438 }
3439 }
3440
3441 static void net_socket_send_dgram(void *opaque)
3442 {
3443 NetSocketState *s = opaque;
3444 int size;
3445
3446 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
3447 if (size < 0)
3448 return;
3449 if (size == 0) {
3450 /* end of connection */
3451 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3452 return;
3453 }
3454 qemu_send_packet(s->vc, s->buf, size);
3455 }
3456
3457 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
3458 {
3459 struct ip_mreq imr;
3460 int fd;
3461 int val, ret;
3462 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
3463 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
3464 inet_ntoa(mcastaddr->sin_addr),
3465 (int)ntohl(mcastaddr->sin_addr.s_addr));
3466 return -1;
3467
3468 }
3469 fd = socket(PF_INET, SOCK_DGRAM, 0);
3470 if (fd < 0) {
3471 perror("socket(PF_INET, SOCK_DGRAM)");
3472 return -1;
3473 }
3474
3475 val = 1;
3476 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
3477 (const char *)&val, sizeof(val));
3478 if (ret < 0) {
3479 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
3480 goto fail;
3481 }
3482
3483 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
3484 if (ret < 0) {
3485 perror("bind");
3486 goto fail;
3487 }
3488
3489 /* Add host to multicast group */
3490 imr.imr_multiaddr = mcastaddr->sin_addr;
3491 imr.imr_interface.s_addr = htonl(INADDR_ANY);
3492
3493 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
3494 (const char *)&imr, sizeof(struct ip_mreq));
3495 if (ret < 0) {
3496 perror("setsockopt(IP_ADD_MEMBERSHIP)");
3497 goto fail;
3498 }
3499
3500 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
3501 val = 1;
3502 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
3503 (const char *)&val, sizeof(val));
3504 if (ret < 0) {
3505 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
3506 goto fail;
3507 }
3508
3509 socket_set_nonblock(fd);
3510 return fd;
3511 fail:
3512 if (fd >= 0)
3513 closesocket(fd);
3514 return -1;
3515 }
3516
3517 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
3518 int is_connected)
3519 {
3520 struct sockaddr_in saddr;
3521 int newfd;
3522 socklen_t saddr_len;
3523 NetSocketState *s;
3524
3525 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
3526 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
3527 * by ONLY ONE process: we must "clone" this dgram socket --jjo
3528 */
3529
3530 if (is_connected) {
3531 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
3532 /* must be bound */
3533 if (saddr.sin_addr.s_addr==0) {
3534 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
3535 fd);
3536 return NULL;
3537 }
3538 /* clone dgram socket */
3539 newfd = net_socket_mcast_create(&saddr);
3540 if (newfd < 0) {
3541 /* error already reported by net_socket_mcast_create() */
3542 close(fd);
3543 return NULL;
3544 }
3545 /* clone newfd to fd, close newfd */
3546 dup2(newfd, fd);
3547 close(newfd);
3548
3549 } else {
3550 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
3551 fd, strerror(errno));
3552 return NULL;
3553 }
3554 }
3555
3556 s = qemu_mallocz(sizeof(NetSocketState));
3557 if (!s)
3558 return NULL;
3559 s->fd = fd;
3560
3561 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
3562 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
3563
3564 /* mcast: save bound address as dst */
3565 if (is_connected) s->dgram_dst=saddr;
3566
3567 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3568 "socket: fd=%d (%s mcast=%s:%d)",
3569 fd, is_connected? "cloned" : "",
3570 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3571 return s;
3572 }
3573
3574 static void net_socket_connect(void *opaque)
3575 {
3576 NetSocketState *s = opaque;
3577 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
3578 }
3579
3580 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
3581 int is_connected)
3582 {
3583 NetSocketState *s;
3584 s = qemu_mallocz(sizeof(NetSocketState));
3585 if (!s)
3586 return NULL;
3587 s->fd = fd;
3588 s->vc = qemu_new_vlan_client(vlan,
3589 net_socket_receive, NULL, s);
3590 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3591 "socket: fd=%d", fd);
3592 if (is_connected) {
3593 net_socket_connect(s);
3594 } else {
3595 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
3596 }
3597 return s;
3598 }
3599
3600 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
3601 int is_connected)
3602 {
3603 int so_type=-1, optlen=sizeof(so_type);
3604
3605 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type, &optlen)< 0) {
3606 fprintf(stderr, "qemu: error: setsockopt(SO_TYPE) for fd=%d failed\n", fd);
3607 return NULL;
3608 }
3609 switch(so_type) {
3610 case SOCK_DGRAM:
3611 return net_socket_fd_init_dgram(vlan, fd, is_connected);
3612 case SOCK_STREAM:
3613 return net_socket_fd_init_stream(vlan, fd, is_connected);
3614 default:
3615 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
3616 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
3617 return net_socket_fd_init_stream(vlan, fd, is_connected);
3618 }
3619 return NULL;
3620 }
3621
3622 static void net_socket_accept(void *opaque)
3623 {
3624 NetSocketListenState *s = opaque;
3625 NetSocketState *s1;
3626 struct sockaddr_in saddr;
3627 socklen_t len;
3628 int fd;
3629
3630 for(;;) {
3631 len = sizeof(saddr);
3632 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
3633 if (fd < 0 && errno != EINTR) {
3634 return;
3635 } else if (fd >= 0) {
3636 break;
3637 }
3638 }
3639 s1 = net_socket_fd_init(s->vlan, fd, 1);
3640 if (!s1) {
3641 closesocket(fd);
3642 } else {
3643 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
3644 "socket: connection from %s:%d",
3645 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3646 }
3647 }
3648
3649 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
3650 {
3651 NetSocketListenState *s;
3652 int fd, val, ret;
3653 struct sockaddr_in saddr;
3654
3655 if (parse_host_port(&saddr, host_str) < 0)
3656 return -1;
3657
3658 s = qemu_mallocz(sizeof(NetSocketListenState));
3659 if (!s)
3660 return -1;
3661
3662 fd = socket(PF_INET, SOCK_STREAM, 0);
3663 if (fd < 0) {
3664 perror("socket");
3665 return -1;
3666 }
3667 socket_set_nonblock(fd);
3668
3669 /* allow fast reuse */
3670 val = 1;
3671 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3672
3673 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
3674 if (ret < 0) {
3675 perror("bind");
3676 return -1;
3677 }
3678 ret = listen(fd, 0);
3679 if (ret < 0) {
3680 perror("listen");
3681 return -1;
3682 }
3683 s->vlan = vlan;
3684 s->fd = fd;
3685 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
3686 return 0;
3687 }
3688
3689 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
3690 {
3691 NetSocketState *s;
3692 int fd, connected, ret, err;
3693 struct sockaddr_in saddr;
3694
3695 if (parse_host_port(&saddr, host_str) < 0)
3696 return -1;
3697
3698 fd = socket(PF_INET, SOCK_STREAM, 0);
3699 if (fd < 0) {
3700 perror("socket");
3701 return -1;
3702 }
3703 socket_set_nonblock(fd);
3704
3705 connected = 0;
3706 for(;;) {
3707 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
3708 if (ret < 0) {
3709 err = socket_error();
3710 if (err == EINTR || err == EWOULDBLOCK) {
3711 } else if (err == EINPROGRESS) {
3712 break;
3713 } else {
3714 perror("connect");
3715 closesocket(fd);
3716 return -1;
3717 }
3718 } else {
3719 connected = 1;
3720 break;
3721 }
3722 }
3723 s = net_socket_fd_init(vlan, fd, connected);
3724 if (!s)
3725 return -1;
3726 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3727 "socket: connect to %s:%d",
3728 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3729 return 0;
3730 }
3731
3732 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
3733 {
3734 NetSocketState *s;
3735 int fd;
3736 struct sockaddr_in saddr;
3737
3738 if (parse_host_port(&saddr, host_str) < 0)
3739 return -1;
3740
3741
3742 fd = net_socket_mcast_create(&saddr);
3743 if (fd < 0)
3744 return -1;
3745
3746 s = net_socket_fd_init(vlan, fd, 0);
3747 if (!s)
3748 return -1;
3749
3750 s->dgram_dst = saddr;
3751
3752 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
3753 "socket: mcast=%s:%d",
3754 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
3755 return 0;
3756
3757 }
3758
3759 static int get_param_value(char *buf, int buf_size,
3760 const char *tag, const char *str)
3761 {
3762 const char *p;
3763 char *q;
3764 char option[128];
3765
3766 p = str;
3767 for(;;) {
3768 q = option;
3769 while (*p != '\0' && *p != '=') {
3770 if ((q - option) < sizeof(option) - 1)
3771 *q++ = *p;
3772 p++;
3773 }
3774 *q = '\0';
3775 if (*p != '=')
3776 break;
3777 p++;
3778 if (!strcmp(tag, option)) {
3779 q = buf;
3780 while (*p != '\0' && *p != ',') {
3781 if ((q - buf) < buf_size - 1)
3782 *q++ = *p;
3783 p++;
3784 }
3785 *q = '\0';
3786 return q - buf;
3787 } else {
3788 while (*p != '\0' && *p != ',') {
3789 p++;
3790 }
3791 }
3792 if (*p != ',')
3793 break;
3794 p++;
3795 }
3796 return 0;
3797 }
3798
3799 static int net_client_init(const char *str)
3800 {
3801 const char *p;
3802 char *q;
3803 char device[64];
3804 char buf[1024];
3805 int vlan_id, ret;
3806 VLANState *vlan;
3807
3808 p = str;
3809 q = device;
3810 while (*p != '\0' && *p != ',') {
3811 if ((q - device) < sizeof(device) - 1)
3812 *q++ = *p;
3813 p++;
3814 }
3815 *q = '\0';
3816 if (*p == ',')
3817 p++;
3818 vlan_id = 0;
3819 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
3820 vlan_id = strtol(buf, NULL, 0);
3821 }
3822 vlan = qemu_find_vlan(vlan_id);
3823 if (!vlan) {
3824 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
3825 return -1;
3826 }
3827 if (!strcmp(device, "nic")) {
3828 NICInfo *nd;
3829 uint8_t *macaddr;
3830
3831 if (nb_nics >= MAX_NICS) {
3832 fprintf(stderr, "Too Many NICs\n");
3833 return -1;
3834 }
3835 nd = &nd_table[nb_nics];
3836 macaddr = nd->macaddr;
3837 macaddr[0] = 0x52;
3838 macaddr[1] = 0x54;
3839 macaddr[2] = 0x00;
3840 macaddr[3] = 0x12;
3841 macaddr[4] = 0x34;
3842 macaddr[5] = 0x56 + nb_nics;
3843
3844 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
3845 if (parse_macaddr(macaddr, buf) < 0) {
3846 fprintf(stderr, "invalid syntax for ethernet address\n");
3847 return -1;
3848 }
3849 }
3850 if (get_param_value(buf, sizeof(buf), "model", p)) {
3851 nd->model = strdup(buf);
3852 }
3853 nd->vlan = vlan;
3854 nb_nics++;
3855 ret = 0;
3856 } else
3857 if (!strcmp(device, "none")) {
3858 /* does nothing. It is needed to signal that no network cards
3859 are wanted */
3860 ret = 0;
3861 } else
3862 #ifdef CONFIG_SLIRP
3863 if (!strcmp(device, "user")) {
3864 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
3865 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
3866 }
3867 ret = net_slirp_init(vlan);
3868 } else
3869 #endif
3870 #ifdef _WIN32
3871 if (!strcmp(device, "tap")) {
3872 char ifname[64];
3873 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
3874 fprintf(stderr, "tap: no interface name\n");
3875 return -1;
3876 }
3877 ret = tap_win32_init(vlan, ifname);
3878 } else
3879 #else
3880 if (!strcmp(device, "tap")) {
3881 char ifname[64];
3882 char setup_script[1024];
3883 int fd;
3884 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
3885 fd = strtol(buf, NULL, 0);
3886 ret = -1;
3887 if (net_tap_fd_init(vlan, fd))
3888 ret = 0;
3889 } else {
3890 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
3891 ifname[0] = '\0';
3892 }
3893 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
3894 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
3895 }
3896 ret = net_tap_init(vlan, ifname, setup_script);
3897 }
3898 } else
3899 #endif
3900 if (!strcmp(device, "socket")) {
3901 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
3902 int fd;
3903 fd = strtol(buf, NULL, 0);
3904 ret = -1;
3905 if (net_socket_fd_init(vlan, fd, 1))
3906 ret = 0;
3907 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
3908 ret = net_socket_listen_init(vlan, buf);
3909 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
3910 ret = net_socket_connect_init(vlan, buf);
3911 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
3912 ret = net_socket_mcast_init(vlan, buf);
3913 } else {
3914 fprintf(stderr, "Unknown socket options: %s\n", p);
3915 return -1;
3916 }
3917 } else
3918 {
3919 fprintf(stderr, "Unknown network device: %s\n", device);
3920 return -1;
3921 }
3922 if (ret < 0) {
3923 fprintf(stderr, "Could not initialize device '%s'\n", device);
3924 }
3925
3926 return ret;
3927 }
3928
3929 void do_info_network(void)
3930 {
3931 VLANState *vlan;
3932 VLANClientState *vc;
3933
3934 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3935 term_printf("VLAN %d devices:\n", vlan->id);
3936 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
3937 term_printf(" %s\n", vc->info_str);
3938 }
3939 }
3940
3941 /***********************************************************/
3942 /* USB devices */
3943
3944 static USBPort *used_usb_ports;
3945 static USBPort *free_usb_ports;
3946
3947 /* ??? Maybe change this to register a hub to keep track of the topology. */
3948 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
3949 usb_attachfn attach)
3950 {
3951 port->opaque = opaque;
3952 port->index = index;
3953 port->attach = attach;
3954 port->next = free_usb_ports;
3955 free_usb_ports = port;
3956 }
3957
3958 static int usb_device_add(const char *devname)
3959 {
3960 const char *p;
3961 USBDevice *dev;
3962 USBPort *port;
3963
3964 if (!free_usb_ports)
3965 return -1;
3966
3967 if (strstart(devname, "host:", &p)) {
3968 dev = usb_host_device_open(p);
3969 } else if (!strcmp(devname, "mouse")) {
3970 dev = usb_mouse_init();
3971 } else if (!strcmp(devname, "tablet")) {
3972 dev = usb_tablet_init();
3973 } else if (strstart(devname, "disk:", &p)) {
3974 dev = usb_msd_init(p);
3975 } else {
3976 return -1;
3977 }
3978 if (!dev)
3979 return -1;
3980
3981 /* Find a USB port to add the device to. */
3982 port = free_usb_ports;
3983 if (!port->next) {
3984 USBDevice *hub;
3985
3986 /* Create a new hub and chain it on. */
3987 free_usb_ports = NULL;
3988 port->next = used_usb_ports;
3989 used_usb_ports = port;
3990
3991 hub = usb_hub_init(VM_USB_HUB_SIZE);
3992 usb_attach(port, hub);
3993 port = free_usb_ports;
3994 }
3995
3996 free_usb_ports = port->next;
3997 port->next = used_usb_ports;
3998 used_usb_ports = port;
3999 usb_attach(port, dev);
4000 return 0;
4001 }
4002
4003 static int usb_device_del(const char *devname)
4004 {
4005 USBPort *port;
4006 USBPort **lastp;
4007 USBDevice *dev;
4008 int bus_num, addr;
4009 const char *p;
4010
4011 if (!used_usb_ports)
4012 return -1;
4013
4014 p = strchr(devname, '.');
4015 if (!p)
4016 return -1;
4017 bus_num = strtoul(devname, NULL, 0);
4018 addr = strtoul(p + 1, NULL, 0);
4019 if (bus_num != 0)
4020 return -1;
4021
4022 lastp = &used_usb_ports;
4023 port = used_usb_ports;
4024 while (port && port->dev->addr != addr) {
4025 lastp = &port->next;
4026 port = port->next;
4027 }
4028
4029 if (!port)
4030 return -1;
4031
4032 dev = port->dev;
4033 *lastp = port->next;
4034 usb_attach(port, NULL);
4035 dev->handle_destroy(dev);
4036 port->next = free_usb_ports;
4037 free_usb_ports = port;
4038 return 0;
4039 }
4040
4041 void do_usb_add(const char *devname)
4042 {
4043 int ret;
4044 ret = usb_device_add(devname);
4045 if (ret < 0)
4046 term_printf("Could not add USB device '%s'\n", devname);
4047 }
4048
4049 void do_usb_del(const char *devname)
4050 {
4051 int ret;
4052 ret = usb_device_del(devname);
4053 if (ret < 0)
4054 term_printf("Could not remove USB device '%s'\n", devname);
4055 }
4056
4057 void usb_info(void)
4058 {
4059 USBDevice *dev;
4060 USBPort *port;
4061 const char *speed_str;
4062
4063 if (!usb_enabled) {
4064 term_printf("USB support not enabled\n");
4065 return;
4066 }
4067
4068 for (port = used_usb_ports; port; port = port->next) {
4069 dev = port->dev;
4070 if (!dev)
4071 continue;
4072 switch(dev->speed) {
4073 case USB_SPEED_LOW:
4074 speed_str = "1.5";
4075 break;
4076 case USB_SPEED_FULL:
4077 speed_str = "12";
4078 break;
4079 case USB_SPEED_HIGH:
4080 speed_str = "480";
4081 break;
4082 default:
4083 speed_str = "?";
4084 break;
4085 }
4086 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
4087 0, dev->addr, speed_str, dev->devname);
4088 }
4089 }
4090
4091 /***********************************************************/
4092 /* pid file */
4093
4094 static char *pid_filename;
4095
4096 /* Remove PID file. Called on normal exit */
4097
4098 static void remove_pidfile(void)
4099 {
4100 unlink (pid_filename);
4101 }
4102
4103 static void create_pidfile(const char *filename)
4104 {
4105 struct stat pidstat;
4106 FILE *f;
4107
4108 /* Try to write our PID to the named file */
4109 if (stat(filename, &pidstat) < 0) {
4110 if (errno == ENOENT) {
4111 if ((f = fopen (filename, "w")) == NULL) {
4112 perror("Opening pidfile");
4113 exit(1);
4114 }
4115 fprintf(f, "%d\n", getpid());
4116 fclose(f);
4117 pid_filename = qemu_strdup(filename);
4118 if (!pid_filename) {
4119 fprintf(stderr, "Could not save PID filename");
4120 exit(1);
4121 }
4122 atexit(remove_pidfile);
4123 }
4124 } else {
4125 fprintf(stderr, "%s already exists. Remove it and try again.\n",
4126 filename);
4127 exit(1);
4128 }
4129 }
4130
4131 /***********************************************************/
4132 /* dumb display */
4133
4134 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
4135 {
4136 }
4137
4138 static void dumb_resize(DisplayState *ds, int w, int h)
4139 {
4140 }
4141
4142 static void dumb_refresh(DisplayState *ds)
4143 {
4144 vga_hw_update();
4145 }
4146
4147 void dumb_display_init(DisplayState *ds)
4148 {
4149 ds->data = NULL;
4150 ds->linesize = 0;
4151 ds->depth = 0;
4152 ds->dpy_update = dumb_update;
4153 ds->dpy_resize = dumb_resize;
4154 ds->dpy_refresh = dumb_refresh;
4155 }
4156
4157 /***********************************************************/
4158 /* I/O handling */
4159
4160 #define MAX_IO_HANDLERS 64
4161
4162 typedef struct IOHandlerRecord {
4163 int fd;
4164 IOCanRWHandler *fd_read_poll;
4165 IOHandler *fd_read;
4166 IOHandler *fd_write;
4167 void *opaque;
4168 /* temporary data */
4169 struct pollfd *ufd;
4170 struct IOHandlerRecord *next;
4171 } IOHandlerRecord;
4172
4173 static IOHandlerRecord *first_io_handler;
4174
4175 /* XXX: fd_read_poll should be suppressed, but an API change is
4176 necessary in the character devices to suppress fd_can_read(). */
4177 int qemu_set_fd_handler2(int fd,
4178 IOCanRWHandler *fd_read_poll,
4179 IOHandler *fd_read,
4180 IOHandler *fd_write,
4181 void *opaque)
4182 {
4183 IOHandlerRecord **pioh, *ioh;
4184
4185 if (!fd_read && !fd_write) {
4186 pioh = &first_io_handler;
4187 for(;;) {
4188 ioh = *pioh;
4189 if (ioh == NULL)
4190 break;
4191 if (ioh->fd == fd) {
4192 *pioh = ioh->next;
4193 qemu_free(ioh);
4194 break;
4195 }
4196 pioh = &ioh->next;
4197 }
4198 } else {
4199 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4200 if (ioh->fd == fd)
4201 goto found;
4202 }
4203 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
4204 if (!ioh)
4205 return -1;
4206 ioh->next = first_io_handler;
4207 first_io_handler = ioh;
4208 found:
4209 ioh->fd = fd;
4210 ioh->fd_read_poll = fd_read_poll;
4211 ioh->fd_read = fd_read;
4212 ioh->fd_write = fd_write;
4213 ioh->opaque = opaque;
4214 }
4215 return 0;
4216 }
4217
4218 int qemu_set_fd_handler(int fd,
4219 IOHandler *fd_read,
4220 IOHandler *fd_write,
4221 void *opaque)
4222 {
4223 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
4224 }
4225
4226 /***********************************************************/
4227 /* Polling handling */
4228
4229 typedef struct PollingEntry {
4230 PollingFunc *func;
4231 void *opaque;
4232 struct PollingEntry *next;
4233 } PollingEntry;
4234
4235 static PollingEntry *first_polling_entry;
4236
4237 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
4238 {
4239 PollingEntry **ppe, *pe;
4240 pe = qemu_mallocz(sizeof(PollingEntry));
4241 if (!pe)
4242 return -1;
4243 pe->func = func;
4244 pe->opaque = opaque;
4245 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
4246 *ppe = pe;
4247 return 0;
4248 }
4249
4250 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
4251 {
4252 PollingEntry **ppe, *pe;
4253 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
4254 pe = *ppe;
4255 if (pe->func == func && pe->opaque == opaque) {
4256 *ppe = pe->next;
4257 qemu_free(pe);
4258 break;
4259 }
4260 }
4261 }
4262
4263 #ifdef _WIN32
4264 /***********************************************************/
4265 /* Wait objects support */
4266 typedef struct WaitObjects {
4267 int num;
4268 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
4269 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
4270 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
4271 } WaitObjects;
4272
4273 static WaitObjects wait_objects = {0};
4274
4275 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
4276 {
4277 WaitObjects *w = &wait_objects;
4278
4279 if (w->num >= MAXIMUM_WAIT_OBJECTS)
4280 return -1;
4281 w->events[w->num] = handle;
4282 w->func[w->num] = func;
4283 w->opaque[w->num] = opaque;
4284 w->num++;
4285 return 0;
4286 }
4287
4288 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
4289 {
4290 int i, found;
4291 WaitObjects *w = &wait_objects;
4292
4293 found = 0;
4294 for (i = 0; i < w->num; i++) {
4295 if (w->events[i] == handle)
4296 found = 1;
4297 if (found) {
4298 w->events[i] = w->events[i + 1];
4299 w->func[i] = w->func[i + 1];
4300 w->opaque[i] = w->opaque[i + 1];
4301 }
4302 }
4303 if (found)
4304 w->num--;
4305 }
4306 #endif
4307
4308 /***********************************************************/
4309 /* savevm/loadvm support */
4310
4311 #define IO_BUF_SIZE 32768
4312
4313 struct QEMUFile {
4314 FILE *outfile;
4315 BlockDriverState *bs;
4316 int is_file;
4317 int is_writable;
4318 int64_t base_offset;
4319 int64_t buf_offset; /* start of buffer when writing, end of buffer
4320 when reading */
4321 int buf_index;
4322 int buf_size; /* 0 when writing */
4323 uint8_t buf[IO_BUF_SIZE];
4324 };
4325
4326 QEMUFile *qemu_fopen(const char *filename, const char *mode)
4327 {
4328 QEMUFile *f;
4329
4330 f = qemu_mallocz(sizeof(QEMUFile));
4331 if (!f)
4332 return NULL;
4333 if (!strcmp(mode, "wb")) {
4334 f->is_writable = 1;
4335 } else if (!strcmp(mode, "rb")) {
4336 f->is_writable = 0;
4337 } else {
4338 goto fail;
4339 }
4340 f->outfile = fopen(filename, mode);
4341 if (!f->outfile)
4342 goto fail;
4343 f->is_file = 1;
4344 return f;
4345 fail:
4346 if (f->outfile)
4347 fclose(f->outfile);
4348 qemu_free(f);
4349 return NULL;
4350 }
4351
4352 QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
4353 {
4354 QEMUFile *f;
4355
4356 f = qemu_mallocz(sizeof(QEMUFile));
4357 if (!f)
4358 return NULL;
4359 f->is_file = 0;
4360 f->bs = bs;
4361 f->is_writable = is_writable;
4362 f->base_offset = offset;
4363 return f;
4364 }
4365
4366 void qemu_fflush(QEMUFile *f)
4367 {
4368 if (!f->is_writable)
4369 return;
4370 if (f->buf_index > 0) {
4371 if (f->is_file) {
4372 fseek(f->outfile, f->buf_offset, SEEK_SET);
4373 fwrite(f->buf, 1, f->buf_index, f->outfile);
4374 } else {
4375 bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
4376 f->buf, f->buf_index);
4377 }
4378 f->buf_offset += f->buf_index;
4379 f->buf_index = 0;
4380 }
4381 }
4382
4383 static void qemu_fill_buffer(QEMUFile *f)
4384 {
4385 int len;
4386
4387 if (f->is_writable)
4388 return;
4389 if (f->is_file) {
4390 fseek(f->outfile, f->buf_offset, SEEK_SET);
4391 len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
4392 if (len < 0)
4393 len = 0;
4394 } else {
4395 len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
4396 f->buf, IO_BUF_SIZE);
4397 if (len < 0)
4398 len = 0;
4399 }
4400 f->buf_index = 0;
4401 f->buf_size = len;
4402 f->buf_offset += len;
4403 }
4404
4405 void qemu_fclose(QEMUFile *f)
4406 {
4407 if (f->is_writable)
4408 qemu_fflush(f);
4409 if (f->is_file) {
4410 fclose(f->outfile);
4411 }
4412 qemu_free(f);
4413 }
4414
4415 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
4416 {
4417 int l;
4418 while (size > 0) {
4419 l = IO_BUF_SIZE - f->buf_index;
4420 if (l > size)
4421 l = size;
4422 memcpy(f->buf + f->buf_index, buf, l);
4423 f->buf_index += l;
4424 buf += l;
4425 size -= l;
4426 if (f->buf_index >= IO_BUF_SIZE)
4427 qemu_fflush(f);
4428 }
4429 }
4430
4431 void qemu_put_byte(QEMUFile *f, int v)
4432 {
4433 f->buf[f->buf_index++] = v;
4434 if (f->buf_index >= IO_BUF_SIZE)
4435 qemu_fflush(f);
4436 }
4437
4438 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
4439 {
4440 int size, l;
4441
4442 size = size1;
4443 while (size > 0) {
4444 l = f->buf_size - f->buf_index;
4445 if (l == 0) {
4446 qemu_fill_buffer(f);
4447 l = f->buf_size - f->buf_index;
4448 if (l == 0)
4449 break;
4450 }
4451 if (l > size)
4452 l = size;
4453 memcpy(buf, f->buf + f->buf_index, l);
4454 f->buf_index += l;
4455 buf += l;
4456 size -= l;
4457 }
4458 return size1 - size;
4459 }
4460
4461 int qemu_get_byte(QEMUFile *f)
4462 {
4463 if (f->buf_index >= f->buf_size) {
4464 qemu_fill_buffer(f);
4465 if (f->buf_index >= f->buf_size)
4466 return 0;
4467 }
4468 return f->buf[f->buf_index++];
4469 }
4470
4471 int64_t qemu_ftell(QEMUFile *f)
4472 {
4473 return f->buf_offset - f->buf_size + f->buf_index;
4474 }
4475
4476 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
4477 {
4478 if (whence == SEEK_SET) {
4479 /* nothing to do */
4480 } else if (whence == SEEK_CUR) {
4481 pos += qemu_ftell(f);
4482 } else {
4483 /* SEEK_END not supported */
4484 return -1;
4485 }
4486 if (f->is_writable) {
4487 qemu_fflush(f);
4488 f->buf_offset = pos;
4489 } else {
4490 f->buf_offset = pos;
4491 f->buf_index = 0;
4492 f->buf_size = 0;
4493 }
4494 return pos;
4495 }
4496
4497 void qemu_put_be16(QEMUFile *f, unsigned int v)
4498 {
4499 qemu_put_byte(f, v >> 8);
4500 qemu_put_byte(f, v);
4501 }
4502
4503 void qemu_put_be32(QEMUFile *f, unsigned int v)
4504 {
4505 qemu_put_byte(f, v >> 24);
4506 qemu_put_byte(f, v >> 16);
4507 qemu_put_byte(f, v >> 8);
4508 qemu_put_byte(f, v);
4509 }
4510
4511 void qemu_put_be64(QEMUFile *f, uint64_t v)
4512 {
4513 qemu_put_be32(f, v >> 32);
4514 qemu_put_be32(f, v);
4515 }
4516
4517 unsigned int qemu_get_be16(QEMUFile *f)
4518 {
4519 unsigned int v;
4520 v = qemu_get_byte(f) << 8;
4521 v |= qemu_get_byte(f);
4522 return v;
4523 }
4524
4525 unsigned int qemu_get_be32(QEMUFile *f)
4526 {
4527 unsigned int v;
4528 v = qemu_get_byte(f) << 24;
4529 v |= qemu_get_byte(f) << 16;
4530 v |= qemu_get_byte(f) << 8;
4531 v |= qemu_get_byte(f);
4532 return v;
4533 }
4534
4535 uint64_t qemu_get_be64(QEMUFile *f)
4536 {
4537 uint64_t v;
4538 v = (uint64_t)qemu_get_be32(f) << 32;
4539 v |= qemu_get_be32(f);
4540 return v;
4541 }
4542
4543 typedef struct SaveStateEntry {
4544 char idstr[256];
4545 int instance_id;
4546 int version_id;
4547 SaveStateHandler *save_state;
4548 LoadStateHandler *load_state;
4549 void *opaque;
4550 struct SaveStateEntry *next;
4551 } SaveStateEntry;
4552
4553 static SaveStateEntry *first_se;
4554
4555 int register_savevm(const char *idstr,
4556 int instance_id,
4557 int version_id,
4558 SaveStateHandler *save_state,
4559 LoadStateHandler *load_state,
4560 void *opaque)
4561 {
4562 SaveStateEntry *se, **pse;
4563
4564 se = qemu_malloc(sizeof(SaveStateEntry));
4565 if (!se)
4566 return -1;
4567 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
4568 se->instance_id = instance_id;
4569 se->version_id = version_id;
4570 se->save_state = save_state;
4571 se->load_state = load_state;
4572 se->opaque = opaque;
4573 se->next = NULL;
4574
4575 /* add at the end of list */
4576 pse = &first_se;
4577 while (*pse != NULL)
4578 pse = &(*pse)->next;
4579 *pse = se;
4580 return 0;
4581 }
4582
4583 #define QEMU_VM_FILE_MAGIC 0x5145564d
4584 #define QEMU_VM_FILE_VERSION 0x00000002
4585
4586 int qemu_savevm_state(QEMUFile *f)
4587 {
4588 SaveStateEntry *se;
4589 int len, ret;
4590 int64_t cur_pos, len_pos, total_len_pos;
4591
4592 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
4593 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
4594 total_len_pos = qemu_ftell(f);
4595 qemu_put_be64(f, 0); /* total size */
4596
4597 for(se = first_se; se != NULL; se = se->next) {
4598 /* ID string */
4599 len = strlen(se->idstr);
4600 qemu_put_byte(f, len);
4601 qemu_put_buffer(f, se->idstr, len);
4602
4603 qemu_put_be32(f, se->instance_id);
4604 qemu_put_be32(f, se->version_id);
4605
4606 /* record size: filled later */
4607 len_pos = qemu_ftell(f);
4608 qemu_put_be32(f, 0);
4609
4610 se->save_state(f, se->opaque);
4611
4612 /* fill record size */
4613 cur_pos = qemu_ftell(f);
4614 len = cur_pos - len_pos - 4;
4615 qemu_fseek(f, len_pos, SEEK_SET);
4616 qemu_put_be32(f, len);
4617 qemu_fseek(f, cur_pos, SEEK_SET);
4618 }
4619 cur_pos = qemu_ftell(f);
4620 qemu_fseek(f, total_len_pos, SEEK_SET);
4621 qemu_put_be64(f, cur_pos - total_len_pos - 8);
4622 qemu_fseek(f, cur_pos, SEEK_SET);
4623
4624 ret = 0;
4625 return ret;
4626 }
4627
4628 static SaveStateEntry *find_se(const char *idstr, int instance_id)
4629 {
4630 SaveStateEntry *se;
4631
4632 for(se = first_se; se != NULL; se = se->next) {
4633 if (!strcmp(se->idstr, idstr) &&
4634 instance_id == se->instance_id)
4635 return se;
4636 }
4637 return NULL;
4638 }
4639
4640 int qemu_loadvm_state(QEMUFile *f)
4641 {
4642 SaveStateEntry *se;
4643 int len, ret, instance_id, record_len, version_id;
4644 int64_t total_len, end_pos, cur_pos;
4645 unsigned int v;
4646 char idstr[256];
4647
4648 v = qemu_get_be32(f);
4649 if (v != QEMU_VM_FILE_MAGIC)
4650 goto fail;
4651 v = qemu_get_be32(f);
4652 if (v != QEMU_VM_FILE_VERSION) {
4653 fail:
4654 ret = -1;
4655 goto the_end;
4656 }
4657 total_len = qemu_get_be64(f);
4658 end_pos = total_len + qemu_ftell(f);
4659 for(;;) {
4660 if (qemu_ftell(f) >= end_pos)
4661 break;
4662 len = qemu_get_byte(f);
4663 qemu_get_buffer(f, idstr, len);
4664 idstr[len] = '\0';
4665 instance_id = qemu_get_be32(f);
4666 version_id = qemu_get_be32(f);
4667 record_len = qemu_get_be32(f);
4668 #if 0
4669 printf("idstr=%s instance=0x%x version=%d len=%d\n",
4670 idstr, instance_id, version_id, record_len);
4671 #endif
4672 cur_pos = qemu_ftell(f);
4673 se = find_se(idstr, instance_id);
4674 if (!se) {
4675 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
4676 instance_id, idstr);
4677 } else {
4678 ret = se->load_state(f, se->opaque, version_id);
4679 if (ret < 0) {
4680 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
4681 instance_id, idstr);
4682 }
4683 }
4684 /* always seek to exact end of record */
4685 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
4686 }
4687 ret = 0;
4688 the_end:
4689 return ret;
4690 }
4691
4692 /* device can contain snapshots */
4693 static int bdrv_can_snapshot(BlockDriverState *bs)
4694 {
4695 return (bs &&
4696 !bdrv_is_removable(bs) &&
4697 !bdrv_is_read_only(bs));
4698 }
4699
4700 /* device must be snapshots in order to have a reliable snapshot */
4701 static int bdrv_has_snapshot(BlockDriverState *bs)
4702 {
4703 return (bs &&
4704 !bdrv_is_removable(bs) &&
4705 !bdrv_is_read_only(bs));
4706 }
4707
4708 static BlockDriverState *get_bs_snapshots(void)
4709 {
4710 BlockDriverState *bs;
4711 int i;
4712
4713 if (bs_snapshots)
4714 return bs_snapshots;
4715 for(i = 0; i <= MAX_DISKS; i++) {
4716 bs = bs_table[i];
4717 if (bdrv_can_snapshot(bs))
4718 goto ok;
4719 }
4720 return NULL;
4721 ok:
4722 bs_snapshots = bs;
4723 return bs;
4724 }
4725
4726 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
4727 const char *name)
4728 {
4729 QEMUSnapshotInfo *sn_tab, *sn;
4730 int nb_sns, i, ret;
4731
4732 ret = -ENOENT;
4733 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
4734 if (nb_sns < 0)
4735 return ret;
4736 for(i = 0; i < nb_sns; i++) {
4737 sn = &sn_tab[i];
4738 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
4739 *sn_info = *sn;
4740 ret = 0;
4741 break;
4742 }
4743 }
4744 qemu_free(sn_tab);
4745 return ret;
4746 }
4747
4748 void do_savevm(const char *name)
4749 {
4750 BlockDriverState *bs, *bs1;
4751 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
4752 int must_delete, ret, i;
4753 BlockDriverInfo bdi1, *bdi = &bdi1;
4754 QEMUFile *f;
4755 int saved_vm_running;
4756 #ifdef _WIN32
4757 struct _timeb tb;
4758 #else
4759 struct timeval tv;
4760 #endif
4761
4762 bs = get_bs_snapshots();
4763 if (!bs) {
4764 term_printf("No block device can accept snapshots\n");
4765 return;
4766 }
4767
4768 /* ??? Should this occur after vm_stop? */
4769 qemu_aio_flush();
4770
4771 saved_vm_running = vm_running;
4772 vm_stop(0);
4773
4774 must_delete = 0;
4775 if (name) {
4776 ret = bdrv_snapshot_find(bs, old_sn, name);
4777 if (ret >= 0) {
4778 must_delete = 1;
4779 }
4780 }
4781 memset(sn, 0, sizeof(*sn));
4782 if (must_delete) {
4783 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
4784 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
4785 } else {
4786 if (name)
4787 pstrcpy(sn->name, sizeof(sn->name), name);
4788 }
4789
4790 /* fill auxiliary fields */
4791 #ifdef _WIN32
4792 _ftime(&tb);
4793 sn->date_sec = tb.time;
4794 sn->date_nsec = tb.millitm * 1000000;
4795 #else
4796 gettimeofday(&tv, NULL);
4797 sn->date_sec = tv.tv_sec;
4798 sn->date_nsec = tv.tv_usec * 1000;
4799 #endif
4800 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
4801
4802 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
4803 term_printf("Device %s does not support VM state snapshots\n",
4804 bdrv_get_device_name(bs));
4805 goto the_end;
4806 }
4807
4808 /* save the VM state */
4809 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
4810 if (!f) {
4811 term_printf("Could not open VM state file\n");
4812 goto the_end;
4813 }
4814 ret = qemu_savevm_state(f);
4815 sn->vm_state_size = qemu_ftell(f);
4816 qemu_fclose(f);
4817 if (ret < 0) {
4818 term_printf("Error %d while writing VM\n", ret);
4819 goto the_end;
4820 }
4821
4822 /* create the snapshots */
4823
4824 for(i = 0; i < MAX_DISKS; i++) {
4825 bs1 = bs_table[i];
4826 if (bdrv_has_snapshot(bs1)) {
4827 if (must_delete) {
4828 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
4829 if (ret < 0) {
4830 term_printf("Error while deleting snapshot on '%s'\n",
4831 bdrv_get_device_name(bs1));
4832 }
4833 }
4834 ret = bdrv_snapshot_create(bs1, sn);
4835 if (ret < 0) {
4836 term_printf("Error while creating snapshot on '%s'\n",
4837 bdrv_get_device_name(bs1));
4838 }
4839 }
4840 }
4841
4842 the_end:
4843 if (saved_vm_running)
4844 vm_start();
4845 }
4846
4847 void do_loadvm(const char *name)
4848 {
4849 BlockDriverState *bs, *bs1;
4850 BlockDriverInfo bdi1, *bdi = &bdi1;
4851 QEMUFile *f;
4852 int i, ret;
4853 int saved_vm_running;
4854
4855 bs = get_bs_snapshots();
4856 if (!bs) {
4857 term_printf("No block device supports snapshots\n");
4858 return;
4859 }
4860
4861 /* Flush all IO requests so they don't interfere with the new state. */
4862 qemu_aio_flush();
4863
4864 saved_vm_running = vm_running;
4865 vm_stop(0);
4866
4867 for(i = 0; i <= MAX_DISKS; i++) {
4868 bs1 = bs_table[i];
4869 if (bdrv_has_snapshot(bs1)) {
4870 ret = bdrv_snapshot_goto(bs1, name);
4871 if (ret < 0) {
4872 if (bs != bs1)
4873 term_printf("Warning: ");
4874 switch(ret) {
4875 case -ENOTSUP:
4876 term_printf("Snapshots not supported on device '%s'\n",
4877 bdrv_get_device_name(bs1));
4878 break;
4879 case -ENOENT:
4880 term_printf("Could not find snapshot '%s' on device '%s'\n",
4881 name, bdrv_get_device_name(bs1));
4882 break;
4883 default:
4884 term_printf("Error %d while activating snapshot on '%s'\n",
4885 ret, bdrv_get_device_name(bs1));
4886 break;
4887 }
4888 /* fatal on snapshot block device */
4889 if (bs == bs1)
4890 goto the_end;
4891 }
4892 }
4893 }
4894
4895 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
4896 term_printf("Device %s does not support VM state snapshots\n",
4897 bdrv_get_device_name(bs));
4898 return;
4899 }
4900
4901 /* restore the VM state */
4902 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
4903 if (!f) {
4904 term_printf("Could not open VM state file\n");
4905 goto the_end;
4906 }
4907 ret = qemu_loadvm_state(f);
4908 qemu_fclose(f);
4909 if (ret < 0) {
4910 term_printf("Error %d while loading VM state\n", ret);
4911 }
4912 the_end:
4913 if (saved_vm_running)
4914 vm_start();
4915 }
4916
4917 void do_delvm(const char *name)
4918 {
4919 BlockDriverState *bs, *bs1;
4920 int i, ret;
4921
4922 bs = get_bs_snapshots();
4923 if (!bs) {
4924 term_printf("No block device supports snapshots\n");
4925 return;
4926 }
4927
4928 for(i = 0; i <= MAX_DISKS; i++) {
4929 bs1 = bs_table[i];
4930 if (bdrv_has_snapshot(bs1)) {
4931 ret = bdrv_snapshot_delete(bs1, name);
4932 if (ret < 0) {
4933 if (ret == -ENOTSUP)
4934 term_printf("Snapshots not supported on device '%s'\n",
4935 bdrv_get_device_name(bs1));
4936 else
4937 term_printf("Error %d while deleting snapshot on '%s'\n",
4938 ret, bdrv_get_device_name(bs1));
4939 }
4940 }
4941 }
4942 }
4943
4944 void do_info_snapshots(void)
4945 {
4946 BlockDriverState *bs, *bs1;
4947 QEMUSnapshotInfo *sn_tab, *sn;
4948 int nb_sns, i;
4949 char buf[256];
4950
4951 bs = get_bs_snapshots();
4952 if (!bs) {
4953 term_printf("No available block device supports snapshots\n");
4954 return;
4955 }
4956 term_printf("Snapshot devices:");
4957 for(i = 0; i <= MAX_DISKS; i++) {
4958 bs1 = bs_table[i];
4959 if (bdrv_has_snapshot(bs1)) {
4960 if (bs == bs1)
4961 term_printf(" %s", bdrv_get_device_name(bs1));
4962 }
4963 }
4964 term_printf("\n");
4965
4966 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
4967 if (nb_sns < 0) {
4968 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
4969 return;
4970 }
4971 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
4972 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
4973 for(i = 0; i < nb_sns; i++) {
4974 sn = &sn_tab[i];
4975 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
4976 }
4977 qemu_free(sn_tab);
4978 }
4979
4980 /***********************************************************/
4981 /* cpu save/restore */
4982
4983 #if defined(TARGET_I386)
4984
4985 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
4986 {
4987 qemu_put_be32(f, dt->selector);
4988 qemu_put_betl(f, dt->base);
4989 qemu_put_be32(f, dt->limit);
4990 qemu_put_be32(f, dt->flags);
4991 }
4992
4993 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
4994 {
4995 dt->selector = qemu_get_be32(f);
4996 dt->base = qemu_get_betl(f);
4997 dt->limit = qemu_get_be32(f);
4998 dt->flags = qemu_get_be32(f);
4999 }
5000
5001 void cpu_save(QEMUFile *f, void *opaque)
5002 {
5003 CPUState *env = opaque;
5004 uint16_t fptag, fpus, fpuc, fpregs_format;
5005 uint32_t hflags;
5006 int i;
5007
5008 for(i = 0; i < CPU_NB_REGS; i++)
5009 qemu_put_betls(f, &env->regs[i]);
5010 qemu_put_betls(f, &env->eip);
5011 qemu_put_betls(f, &env->eflags);
5012 hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
5013 qemu_put_be32s(f, &hflags);
5014
5015 /* FPU */
5016 fpuc = env->fpuc;
5017 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
5018 fptag = 0;
5019 for(i = 0; i < 8; i++) {
5020 fptag |= ((!env->fptags[i]) << i);
5021 }
5022
5023 qemu_put_be16s(f, &fpuc);
5024 qemu_put_be16s(f, &fpus);
5025 qemu_put_be16s(f, &fptag);
5026
5027 #ifdef USE_X86LDOUBLE
5028 fpregs_format = 0;
5029 #else
5030 fpregs_format = 1;
5031 #endif
5032 qemu_put_be16s(f, &fpregs_format);
5033
5034 for(i = 0; i < 8; i++) {
5035 #ifdef USE_X86LDOUBLE
5036 {
5037 uint64_t mant;
5038 uint16_t exp;
5039 /* we save the real CPU data (in case of MMX usage only 'mant'
5040 contains the MMX register */
5041 cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
5042 qemu_put_be64(f, mant);
5043 qemu_put_be16(f, exp);
5044 }
5045 #else
5046 /* if we use doubles for float emulation, we save the doubles to
5047 avoid losing information in case of MMX usage. It can give
5048 problems if the image is restored on a CPU where long
5049 doubles are used instead. */
5050 qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
5051 #endif
5052 }
5053
5054 for(i = 0; i < 6; i++)
5055 cpu_put_seg(f, &env->segs[i]);
5056 cpu_put_seg(f, &env->ldt);
5057 cpu_put_seg(f, &env->tr);
5058 cpu_put_seg(f, &env->gdt);
5059 cpu_put_seg(f, &env->idt);
5060
5061 qemu_put_be32s(f, &env->sysenter_cs);
5062 qemu_put_be32s(f, &env->sysenter_esp);
5063 qemu_put_be32s(f, &env->sysenter_eip);
5064
5065 qemu_put_betls(f, &env->cr[0]);
5066 qemu_put_betls(f, &env->cr[2]);
5067 qemu_put_betls(f, &env->cr[3]);
5068 qemu_put_betls(f, &env->cr[4]);
5069
5070 for(i = 0; i < 8; i++)
5071 qemu_put_betls(f, &env->dr[i]);
5072
5073 /* MMU */
5074 qemu_put_be32s(f, &env->a20_mask);
5075
5076 /* XMM */
5077 qemu_put_be32s(f, &env->mxcsr);
5078 for(i = 0; i < CPU_NB_REGS; i++) {
5079 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
5080 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
5081 }
5082
5083 #ifdef TARGET_X86_64
5084 qemu_put_be64s(f, &env->efer);
5085 qemu_put_be64s(f, &env->star);
5086 qemu_put_be64s(f, &env->lstar);
5087 qemu_put_be64s(f, &env->cstar);
5088 qemu_put_be64s(f, &env->fmask);
5089 qemu_put_be64s(f, &env->kernelgsbase);
5090 #endif
5091 qemu_put_be32s(f, &env->smbase);
5092 }
5093
5094 #ifdef USE_X86LDOUBLE
5095 /* XXX: add that in a FPU generic layer */
5096 union x86_longdouble {
5097 uint64_t mant;
5098 uint16_t exp;
5099 };
5100
5101 #define MANTD1(fp) (fp & ((1LL << 52) - 1))
5102 #define EXPBIAS1 1023
5103 #define EXPD1(fp) ((fp >> 52) & 0x7FF)
5104 #define SIGND1(fp) ((fp >> 32) & 0x80000000)
5105
5106 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
5107 {
5108 int e;
5109 /* mantissa */
5110 p->mant = (MANTD1(temp) << 11) | (1LL << 63);
5111 /* exponent + sign */
5112 e = EXPD1(temp) - EXPBIAS1 + 16383;
5113 e |= SIGND1(temp) >> 16;
5114 p->exp = e;
5115 }
5116 #endif
5117
5118 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5119 {
5120 CPUState *env = opaque;
5121 int i, guess_mmx;
5122 uint32_t hflags;
5123 uint16_t fpus, fpuc, fptag, fpregs_format;
5124
5125 if (version_id != 3 && version_id != 4)
5126 return -EINVAL;
5127 for(i = 0; i < CPU_NB_REGS; i++)
5128 qemu_get_betls(f, &env->regs[i]);
5129 qemu_get_betls(f, &env->eip);
5130 qemu_get_betls(f, &env->eflags);
5131 qemu_get_be32s(f, &hflags);
5132
5133 qemu_get_be16s(f, &fpuc);
5134 qemu_get_be16s(f, &fpus);
5135 qemu_get_be16s(f, &fptag);
5136 qemu_get_be16s(f, &fpregs_format);
5137
5138 /* NOTE: we cannot always restore the FPU state if the image come
5139 from a host with a different 'USE_X86LDOUBLE' define. We guess
5140 if we are in an MMX state to restore correctly in that case. */
5141 guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
5142 for(i = 0; i < 8; i++) {
5143 uint64_t mant;
5144 uint16_t exp;
5145
5146 switch(fpregs_format) {
5147 case 0:
5148 mant = qemu_get_be64(f);
5149 exp = qemu_get_be16(f);
5150 #ifdef USE_X86LDOUBLE
5151 env->fpregs[i].d = cpu_set_fp80(mant, exp);
5152 #else
5153 /* difficult case */
5154 if (guess_mmx)
5155 env->fpregs[i].mmx.MMX_Q(0) = mant;
5156 else
5157 env->fpregs[i].d = cpu_set_fp80(mant, exp);
5158 #endif
5159 break;
5160 case 1:
5161 mant = qemu_get_be64(f);
5162 #ifdef USE_X86LDOUBLE
5163 {
5164 union x86_longdouble *p;
5165 /* difficult case */
5166 p = (void *)&env->fpregs[i];
5167 if (guess_mmx) {
5168 p->mant = mant;
5169 p->exp = 0xffff;
5170 } else {
5171 fp64_to_fp80(p, mant);
5172 }
5173 }
5174 #else
5175 env->fpregs[i].mmx.MMX_Q(0) = mant;
5176 #endif
5177 break;
5178 default:
5179 return -EINVAL;
5180 }
5181 }
5182
5183 env->fpuc = fpuc;
5184 /* XXX: restore FPU round state */
5185 env->fpstt = (fpus >> 11) & 7;
5186 env->fpus = fpus & ~0x3800;
5187 fptag ^= 0xff;
5188 for(i = 0; i < 8; i++) {
5189 env->fptags[i] = (fptag >> i) & 1;
5190 }
5191
5192 for(i = 0; i < 6; i++)
5193 cpu_get_seg(f, &env->segs[i]);
5194 cpu_get_seg(f, &env->ldt);
5195 cpu_get_seg(f, &env->tr);
5196 cpu_get_seg(f, &env->gdt);
5197 cpu_get_seg(f, &env->idt);
5198
5199 qemu_get_be32s(f, &env->sysenter_cs);
5200 qemu_get_be32s(f, &env->sysenter_esp);
5201 qemu_get_be32s(f, &env->sysenter_eip);
5202
5203 qemu_get_betls(f, &env->cr[0]);
5204 qemu_get_betls(f, &env->cr[2]);
5205 qemu_get_betls(f, &env->cr[3]);
5206 qemu_get_betls(f, &env->cr[4]);
5207
5208 for(i = 0; i < 8; i++)
5209 qemu_get_betls(f, &env->dr[i]);
5210
5211 /* MMU */
5212 qemu_get_be32s(f, &env->a20_mask);
5213
5214 qemu_get_be32s(f, &env->mxcsr);
5215 for(i = 0; i < CPU_NB_REGS; i++) {
5216 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
5217 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
5218 }
5219
5220 #ifdef TARGET_X86_64
5221 qemu_get_be64s(f, &env->efer);
5222 qemu_get_be64s(f, &env->star);
5223 qemu_get_be64s(f, &env->lstar);
5224 qemu_get_be64s(f, &env->cstar);
5225 qemu_get_be64s(f, &env->fmask);
5226 qemu_get_be64s(f, &env->kernelgsbase);
5227 #endif
5228 if (version_id >= 4)
5229 qemu_get_be32s(f, &env->smbase);
5230
5231 /* XXX: compute hflags from scratch, except for CPL and IIF */
5232 env->hflags = hflags;
5233 tlb_flush(env, 1);
5234 return 0;
5235 }
5236
5237 #elif defined(TARGET_PPC)
5238 void cpu_save(QEMUFile *f, void *opaque)
5239 {
5240 }
5241
5242 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5243 {
5244 return 0;
5245 }
5246
5247 #elif defined(TARGET_MIPS)
5248 void cpu_save(QEMUFile *f, void *opaque)
5249 {
5250 }
5251
5252 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5253 {
5254 return 0;
5255 }
5256
5257 #elif defined(TARGET_SPARC)
5258 void cpu_save(QEMUFile *f, void *opaque)
5259 {
5260 CPUState *env = opaque;
5261 int i;
5262 uint32_t tmp;
5263
5264 for(i = 0; i < 8; i++)
5265 qemu_put_betls(f, &env->gregs[i]);
5266 for(i = 0; i < NWINDOWS * 16; i++)
5267 qemu_put_betls(f, &env->regbase[i]);
5268
5269 /* FPU */
5270 for(i = 0; i < TARGET_FPREGS; i++) {
5271 union {
5272 float32 f;
5273 uint32_t i;
5274 } u;
5275 u.f = env->fpr[i];
5276 qemu_put_be32(f, u.i);
5277 }
5278
5279 qemu_put_betls(f, &env->pc);
5280 qemu_put_betls(f, &env->npc);
5281 qemu_put_betls(f, &env->y);
5282 tmp = GET_PSR(env);
5283 qemu_put_be32(f, tmp);
5284 qemu_put_betls(f, &env->fsr);
5285 qemu_put_betls(f, &env->tbr);
5286 #ifndef TARGET_SPARC64
5287 qemu_put_be32s(f, &env->wim);
5288 /* MMU */
5289 for(i = 0; i < 16; i++)
5290 qemu_put_be32s(f, &env->mmuregs[i]);
5291 #endif
5292 }
5293
5294 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5295 {
5296 CPUState *env = opaque;
5297 int i;
5298 uint32_t tmp;
5299
5300 for(i = 0; i < 8; i++)
5301 qemu_get_betls(f, &env->gregs[i]);
5302 for(i = 0; i < NWINDOWS * 16; i++)
5303 qemu_get_betls(f, &env->regbase[i]);
5304
5305 /* FPU */
5306 for(i = 0; i < TARGET_FPREGS; i++) {
5307 union {
5308 float32 f;
5309 uint32_t i;
5310 } u;
5311 u.i = qemu_get_be32(f);
5312 env->fpr[i] = u.f;
5313 }
5314
5315 qemu_get_betls(f, &env->pc);
5316 qemu_get_betls(f, &env->npc);
5317 qemu_get_betls(f, &env->y);
5318 tmp = qemu_get_be32(f);
5319 env->cwp = 0; /* needed to ensure that the wrapping registers are
5320 correctly updated */
5321 PUT_PSR(env, tmp);
5322 qemu_get_betls(f, &env->fsr);
5323 qemu_get_betls(f, &env->tbr);
5324 #ifndef TARGET_SPARC64
5325 qemu_get_be32s(f, &env->wim);
5326 /* MMU */
5327 for(i = 0; i < 16; i++)
5328 qemu_get_be32s(f, &env->mmuregs[i]);
5329 #endif
5330 tlb_flush(env, 1);
5331 return 0;
5332 }
5333
5334 #elif defined(TARGET_ARM)
5335
5336 /* ??? Need to implement these. */
5337 void cpu_save(QEMUFile *f, void *opaque)
5338 {
5339 }
5340
5341 int cpu_load(QEMUFile *f, void *opaque, int version_id)
5342 {
5343 return 0;
5344 }
5345
5346 #else
5347
5348 #warning No CPU save/restore functions
5349
5350 #endif
5351
5352 /***********************************************************/
5353 /* ram save/restore */
5354
5355 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
5356 {
5357 int v;
5358
5359 v = qemu_get_byte(f);
5360 switch(v) {
5361 case 0:
5362 if (qemu_get_buffer(f, buf, len) != len)
5363 return -EIO;
5364 break;
5365 case 1:
5366 v = qemu_get_byte(f);
5367 memset(buf, v, len);
5368 break;
5369 default:
5370 return -EINVAL;
5371 }
5372 return 0;
5373 }
5374
5375 static int ram_load_v1(QEMUFile *f, void *opaque)
5376 {
5377 int i, ret;
5378
5379 if (qemu_get_be32(f) != phys_ram_size)
5380 return -EINVAL;
5381 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
5382 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
5383 if (ret)
5384 return ret;
5385 }
5386 return 0;
5387 }
5388
5389 #define BDRV_HASH_BLOCK_SIZE 1024
5390 #define IOBUF_SIZE 4096
5391 #define RAM_CBLOCK_MAGIC 0xfabe
5392
5393 typedef struct RamCompressState {
5394 z_stream zstream;
5395 QEMUFile *f;
5396 uint8_t buf[IOBUF_SIZE];
5397 } RamCompressState;
5398
5399 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
5400 {
5401 int ret;
5402 memset(s, 0, sizeof(*s));
5403 s->f = f;
5404 ret = deflateInit2(&s->zstream, 1,
5405 Z_DEFLATED, 15,
5406 9, Z_DEFAULT_STRATEGY);
5407 if (ret != Z_OK)
5408 return -1;
5409 s->zstream.avail_out = IOBUF_SIZE;
5410 s->zstream.next_out = s->buf;
5411 return 0;
5412 }
5413
5414 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
5415 {
5416 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
5417 qemu_put_be16(s->f, len);
5418 qemu_put_buffer(s->f, buf, len);
5419 }
5420
5421 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
5422 {
5423 int ret;
5424
5425 s->zstream.avail_in = len;
5426 s->zstream.next_in = (uint8_t *)buf;
5427 while (s->zstream.avail_in > 0) {
5428 ret = deflate(&s->zstream, Z_NO_FLUSH);
5429 if (ret != Z_OK)
5430 return -1;
5431 if (s->zstream.avail_out == 0) {
5432 ram_put_cblock(s, s->buf, IOBUF_SIZE);
5433 s->zstream.avail_out = IOBUF_SIZE;
5434 s->zstream.next_out = s->buf;
5435 }
5436 }
5437 return 0;
5438 }
5439
5440 static void ram_compress_close(RamCompressState *s)
5441 {
5442 int len, ret;
5443
5444 /* compress last bytes */
5445 for(;;) {
5446 ret = deflate(&s->zstream, Z_FINISH);
5447 if (ret == Z_OK || ret == Z_STREAM_END) {
5448 len = IOBUF_SIZE - s->zstream.avail_out;
5449 if (len > 0) {
5450 ram_put_cblock(s, s->buf, len);
5451 }
5452 s->zstream.avail_out = IOBUF_SIZE;
5453 s->zstream.next_out = s->buf;
5454 if (ret == Z_STREAM_END)
5455 break;
5456 } else {
5457 goto fail;
5458 }
5459 }
5460 fail:
5461 deflateEnd(&s->zstream);
5462 }
5463
5464 typedef struct RamDecompressState {
5465 z_stream zstream;
5466 QEMUFile *f;
5467 uint8_t buf[IOBUF_SIZE];
5468 } RamDecompressState;
5469
5470 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
5471 {
5472 int ret;
5473 memset(s, 0, sizeof(*s));
5474 s->f = f;
5475 ret = inflateInit(&s->zstream);
5476 if (ret != Z_OK)
5477 return -1;
5478 return 0;
5479 }
5480
5481 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
5482 {
5483 int ret, clen;
5484
5485 s->zstream.avail_out = len;
5486 s->zstream.next_out = buf;
5487 while (s->zstream.avail_out > 0) {
5488 if (s->zstream.avail_in == 0) {
5489 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
5490 return -1;
5491 clen = qemu_get_be16(s->f);
5492 if (clen > IOBUF_SIZE)
5493 return -1;
5494 qemu_get_buffer(s->f, s->buf, clen);
5495 s->zstream.avail_in = clen;
5496 s->zstream.next_in = s->buf;
5497 }
5498 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
5499 if (ret != Z_OK && ret != Z_STREAM_END) {
5500 return -1;
5501 }
5502 }
5503 return 0;
5504 }
5505
5506 static void ram_decompress_close(RamDecompressState *s)
5507 {
5508 inflateEnd(&s->zstream);
5509 }
5510
5511 static void ram_save(QEMUFile *f, void *opaque)
5512 {
5513 int i;
5514 RamCompressState s1, *s = &s1;
5515 uint8_t buf[10];
5516
5517 qemu_put_be32(f, phys_ram_size);
5518 if (ram_compress_open(s, f) < 0)
5519 return;
5520 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
5521 #if 0
5522 if (tight_savevm_enabled) {
5523 int64_t sector_num;
5524 int j;
5525
5526 /* find if the memory block is available on a virtual
5527 block device */
5528 sector_num = -1;
5529 for(j = 0; j < MAX_DISKS; j++) {
5530 if (bs_table[j]) {
5531 sector_num = bdrv_hash_find(bs_table[j],
5532 phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
5533 if (sector_num >= 0)
5534 break;
5535 }
5536 }
5537 if (j == MAX_DISKS)
5538 goto normal_compress;
5539 buf[0] = 1;
5540 buf[1] = j;
5541 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
5542 ram_compress_buf(s, buf, 10);
5543 } else
5544 #endif
5545 {
5546 // normal_compress:
5547 buf[0] = 0;
5548 ram_compress_buf(s, buf, 1);
5549 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
5550 }
5551 }
5552 ram_compress_close(s);
5553 }
5554
5555 static int ram_load(QEMUFile *f, void *opaque, int version_id)
5556 {
5557 RamDecompressState s1, *s = &s1;
5558 uint8_t buf[10];
5559 int i;
5560
5561 if (version_id == 1)
5562 return ram_load_v1(f, opaque);
5563 if (version_id != 2)
5564 return -EINVAL;
5565 if (qemu_get_be32(f) != phys_ram_size)
5566 return -EINVAL;
5567 if (ram_decompress_open(s, f) < 0)
5568 return -EINVAL;
5569 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
5570 if (ram_decompress_buf(s, buf, 1) < 0) {
5571 fprintf(stderr, "Error while reading ram block header\n");
5572 goto error;
5573 }
5574 if (buf[0] == 0) {
5575 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
5576 fprintf(stderr, "Error while reading ram block address=0x%08x", i);
5577 goto error;
5578 }
5579 } else
5580 #if 0
5581 if (buf[0] == 1) {
5582 int bs_index;
5583 int64_t sector_num;
5584
5585 ram_decompress_buf(s, buf + 1, 9);
5586 bs_index = buf[1];
5587 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
5588 if (bs_index >= MAX_DISKS || bs_table[bs_index] == NULL) {
5589 fprintf(stderr, "Invalid block device index %d\n", bs_index);
5590 goto error;
5591 }
5592 if (bdrv_read(bs_table[bs_index], sector_num, phys_ram_base + i,
5593 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
5594 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
5595 bs_index, sector_num);
5596 goto error;
5597 }
5598 } else
5599 #endif
5600 {
5601 error:
5602 printf("Error block header\n");
5603 return -EINVAL;
5604 }
5605 }
5606 ram_decompress_close(s);
5607 return 0;
5608 }
5609
5610 /***********************************************************/
5611 /* bottom halves (can be seen as timers which expire ASAP) */
5612
5613 struct QEMUBH {
5614 QEMUBHFunc *cb;
5615 void *opaque;
5616 int scheduled;
5617 QEMUBH *next;
5618 };
5619
5620 static QEMUBH *first_bh = NULL;
5621
5622 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
5623 {
5624 QEMUBH *bh;
5625 bh = qemu_mallocz(sizeof(QEMUBH));
5626 if (!bh)
5627 return NULL;
5628 bh->cb = cb;
5629 bh->opaque = opaque;
5630 return bh;
5631 }
5632
5633 int qemu_bh_poll(void)
5634 {
5635 QEMUBH *bh, **pbh;
5636 int ret;
5637
5638 ret = 0;
5639 for(;;) {
5640 pbh = &first_bh;
5641 bh = *pbh;
5642 if (!bh)
5643 break;
5644 ret = 1;
5645 *pbh = bh->next;
5646 bh->scheduled = 0;
5647 bh->cb(bh->opaque);
5648 }
5649 return ret;
5650 }
5651
5652 void qemu_bh_schedule(QEMUBH *bh)
5653 {
5654 CPUState *env = cpu_single_env;
5655 if (bh->scheduled)
5656 return;
5657 bh->scheduled = 1;
5658 bh->next = first_bh;
5659 first_bh = bh;
5660
5661 /* stop the currently executing CPU to execute the BH ASAP */
5662 if (env) {
5663 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
5664 }
5665 }
5666
5667 void qemu_bh_cancel(QEMUBH *bh)
5668 {
5669 QEMUBH **pbh;
5670 if (bh->scheduled) {
5671 pbh = &first_bh;
5672 while (*pbh != bh)
5673 pbh = &(*pbh)->next;
5674 *pbh = bh->next;
5675 bh->scheduled = 0;
5676 }
5677 }
5678
5679 void qemu_bh_delete(QEMUBH *bh)
5680 {
5681 qemu_bh_cancel(bh);
5682 qemu_free(bh);
5683 }
5684
5685 /***********************************************************/
5686 /* machine registration */
5687
5688 QEMUMachine *first_machine = NULL;
5689
5690 int qemu_register_machine(QEMUMachine *m)
5691 {
5692 QEMUMachine **pm;
5693 pm = &first_machine;
5694 while (*pm != NULL)
5695 pm = &(*pm)->next;
5696 m->next = NULL;
5697 *pm = m;
5698 return 0;
5699 }
5700
5701 QEMUMachine *find_machine(const char *name)
5702 {
5703 QEMUMachine *m;
5704
5705 for(m = first_machine; m != NULL; m = m->next) {
5706 if (!strcmp(m->name, name))
5707 return m;
5708 }
5709 return NULL;
5710 }
5711
5712 /***********************************************************/
5713 /* main execution loop */
5714
5715 void gui_update(void *opaque)
5716 {
5717 display_state.dpy_refresh(&display_state);
5718 qemu_mod_timer(gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
5719 }
5720
5721 struct vm_change_state_entry {
5722 VMChangeStateHandler *cb;
5723 void *opaque;
5724 LIST_ENTRY (vm_change_state_entry) entries;
5725 };
5726
5727 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
5728
5729 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
5730 void *opaque)
5731 {
5732 VMChangeStateEntry *e;
5733
5734 e = qemu_mallocz(sizeof (*e));
5735 if (!e)
5736 return NULL;
5737
5738 e->cb = cb;
5739 e->opaque = opaque;
5740 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
5741 return e;
5742 }
5743
5744 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
5745 {
5746 LIST_REMOVE (e, entries);
5747 qemu_free (e);
5748 }
5749
5750 static void vm_state_notify(int running)
5751 {
5752 VMChangeStateEntry *e;
5753
5754 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
5755 e->cb(e->opaque, running);
5756 }
5757 }
5758
5759 /* XXX: support several handlers */
5760 static VMStopHandler *vm_stop_cb;
5761 static void *vm_stop_opaque;
5762
5763 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
5764 {
5765 vm_stop_cb = cb;
5766 vm_stop_opaque = opaque;
5767 return 0;
5768 }
5769
5770 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
5771 {
5772 vm_stop_cb = NULL;
5773 }
5774
5775 void vm_start(void)
5776 {
5777 if (!vm_running) {
5778 cpu_enable_ticks();
5779 vm_running = 1;
5780 vm_state_notify(1);
5781 }
5782 }
5783
5784 void vm_stop(int reason)
5785 {
5786 if (vm_running) {
5787 cpu_disable_ticks();
5788 vm_running = 0;
5789 if (reason != 0) {
5790 if (vm_stop_cb) {
5791 vm_stop_cb(vm_stop_opaque, reason);
5792 }
5793 }
5794 vm_state_notify(0);
5795 }
5796 }
5797
5798 /* reset/shutdown handler */
5799
5800 typedef struct QEMUResetEntry {
5801 QEMUResetHandler *func;
5802 void *opaque;
5803 struct QEMUResetEntry *next;
5804 } QEMUResetEntry;
5805
5806 static QEMUResetEntry *first_reset_entry;
5807 static int reset_requested;
5808 static int shutdown_requested;
5809 static int powerdown_requested;
5810
5811 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
5812 {
5813 QEMUResetEntry **pre, *re;
5814
5815 pre = &first_reset_entry;
5816 while (*pre != NULL)
5817 pre = &(*pre)->next;
5818 re = qemu_mallocz(sizeof(QEMUResetEntry));
5819 re->func = func;
5820 re->opaque = opaque;
5821 re->next = NULL;
5822 *pre = re;
5823 }
5824
5825 static void qemu_system_reset(void)
5826 {
5827 QEMUResetEntry *re;
5828
5829 /* reset all devices */
5830 for(re = first_reset_entry; re != NULL; re = re->next) {
5831 re->func(re->opaque);
5832 }
5833 }
5834
5835 void qemu_system_reset_request(void)
5836 {
5837 if (no_reboot) {
5838 shutdown_requested = 1;
5839 } else {
5840 reset_requested = 1;
5841 }
5842 if (cpu_single_env)
5843 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5844 }
5845
5846 void qemu_system_shutdown_request(void)
5847 {
5848 shutdown_requested = 1;
5849 if (cpu_single_env)
5850 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5851 }
5852
5853 void qemu_system_powerdown_request(void)
5854 {
5855 powerdown_requested = 1;
5856 if (cpu_single_env)
5857 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
5858 }
5859
5860 void main_loop_wait(int timeout)
5861 {
5862 IOHandlerRecord *ioh, *ioh_next;
5863 fd_set rfds, wfds, xfds;
5864 int ret, nfds;
5865 struct timeval tv;
5866 PollingEntry *pe;
5867
5868
5869 /* XXX: need to suppress polling by better using win32 events */
5870 ret = 0;
5871 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
5872 ret |= pe->func(pe->opaque);
5873 }
5874 #ifdef _WIN32
5875 if (ret == 0 && timeout > 0) {
5876 int err;
5877 WaitObjects *w = &wait_objects;
5878
5879 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
5880 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
5881 if (w->func[ret - WAIT_OBJECT_0])
5882 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
5883 } else if (ret == WAIT_TIMEOUT) {
5884 } else {
5885 err = GetLastError();
5886 fprintf(stderr, "Wait error %d %d\n", ret, err);
5887 }
5888 }
5889 #endif
5890 /* poll any events */
5891 /* XXX: separate device handlers from system ones */
5892 nfds = -1;
5893 FD_ZERO(&rfds);
5894 FD_ZERO(&wfds);
5895 FD_ZERO(&xfds);
5896 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5897 if (ioh->fd_read &&
5898 (!ioh->fd_read_poll ||
5899 ioh->fd_read_poll(ioh->opaque) != 0)) {
5900 FD_SET(ioh->fd, &rfds);
5901 if (ioh->fd > nfds)
5902 nfds = ioh->fd;
5903 }
5904 if (ioh->fd_write) {
5905 FD_SET(ioh->fd, &wfds);
5906 if (ioh->fd > nfds)
5907 nfds = ioh->fd;
5908 }
5909 }
5910
5911 tv.tv_sec = 0;
5912 #ifdef _WIN32
5913 tv.tv_usec = 0;
5914 #else
5915 tv.tv_usec = timeout * 1000;
5916 #endif
5917 #if defined(CONFIG_SLIRP)
5918 if (slirp_inited) {
5919 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
5920 }
5921 #endif
5922 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
5923 if (ret > 0) {
5924 /* XXX: better handling of removal */
5925 for(ioh = first_io_handler; ioh != NULL; ioh = ioh_next) {
5926 ioh_next = ioh->next;
5927 if (FD_ISSET(ioh->fd, &rfds)) {
5928 ioh->fd_read(ioh->opaque);
5929 }
5930 if (FD_ISSET(ioh->fd, &wfds)) {
5931 ioh->fd_write(ioh->opaque);
5932 }
5933 }
5934 }
5935 #if defined(CONFIG_SLIRP)
5936 if (slirp_inited) {
5937 if (ret < 0) {
5938 FD_ZERO(&rfds);
5939 FD_ZERO(&wfds);
5940 FD_ZERO(&xfds);
5941 }
5942 slirp_select_poll(&rfds, &wfds, &xfds);
5943 }
5944 #endif
5945 qemu_aio_poll();
5946 qemu_bh_poll();
5947
5948 if (vm_running) {
5949 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
5950 qemu_get_clock(vm_clock));
5951 /* run dma transfers, if any */
5952 DMA_run();
5953 }
5954
5955 /* real time timers */
5956 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
5957 qemu_get_clock(rt_clock));
5958 }
5959
5960 static CPUState *cur_cpu;
5961
5962 int main_loop(void)
5963 {
5964 int ret, timeout;
5965 #ifdef CONFIG_PROFILER
5966 int64_t ti;
5967 #endif
5968 CPUState *env;
5969
5970 cur_cpu = first_cpu;
5971 for(;;) {
5972 if (vm_running) {
5973
5974 env = cur_cpu;
5975 for(;;) {
5976 /* get next cpu */
5977 env = env->next_cpu;
5978 if (!env)
5979 env = first_cpu;
5980 #ifdef CONFIG_PROFILER
5981 ti = profile_getclock();
5982 #endif
5983 ret = cpu_exec(env);
5984 #ifdef CONFIG_PROFILER
5985 qemu_time += profile_getclock() - ti;
5986 #endif
5987 if (ret != EXCP_HALTED)
5988 break;
5989 /* all CPUs are halted ? */
5990 if (env == cur_cpu) {
5991 ret = EXCP_HLT;
5992 break;
5993 }
5994 }
5995 cur_cpu = env;
5996
5997 if (shutdown_requested) {
5998 ret = EXCP_INTERRUPT;
5999 break;
6000 }
6001 if (reset_requested) {
6002 reset_requested = 0;
6003 qemu_system_reset();
6004 ret = EXCP_INTERRUPT;
6005 }
6006 if (powerdown_requested) {
6007 powerdown_requested = 0;
6008 qemu_system_powerdown();
6009 ret = EXCP_INTERRUPT;
6010 }
6011 if (ret == EXCP_DEBUG) {
6012 vm_stop(EXCP_DEBUG);
6013 }
6014 /* if hlt instruction, we wait until the next IRQ */
6015 /* XXX: use timeout computed from timers */
6016 if (ret == EXCP_HLT)
6017 timeout = 10;
6018 else
6019 timeout = 0;
6020 } else {
6021 timeout = 10;
6022 }
6023 #ifdef CONFIG_PROFILER
6024 ti = profile_getclock();
6025 #endif
6026 main_loop_wait(timeout);
6027 #ifdef CONFIG_PROFILER
6028 dev_time += profile_getclock() - ti;
6029 #endif
6030 }
6031 cpu_disable_ticks();
6032 return ret;
6033 }
6034
6035 void help(void)
6036 {
6037 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2006 Fabrice Bellard\n"
6038 "usage: %s [options] [disk_image]\n"
6039 "\n"
6040 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
6041 "\n"
6042 "Standard options:\n"
6043 "-M machine select emulated machine (-M ? for list)\n"
6044 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
6045 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
6046 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
6047 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
6048 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
6049 "-snapshot write to temporary files instead of disk image files\n"
6050 #ifdef CONFIG_SDL
6051 "-no-quit disable SDL window close capability\n"
6052 #endif
6053 #ifdef TARGET_I386
6054 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
6055 #endif
6056 "-m megs set virtual RAM size to megs MB [default=%d]\n"
6057 "-smp n set the number of CPUs to 'n' [default=1]\n"
6058 "-nographic disable graphical output and redirect serial I/Os to console\n"
6059 #ifndef _WIN32
6060 "-k language use keyboard layout (for example \"fr\" for French)\n"
6061 #endif
6062 #ifdef HAS_AUDIO
6063 "-audio-help print list of audio drivers and their options\n"
6064 "-soundhw c1,... enable audio support\n"
6065 " and only specified sound cards (comma separated list)\n"
6066 " use -soundhw ? to get the list of supported cards\n"
6067 " use -soundhw all to enable all of them\n"
6068 #endif
6069 "-localtime set the real time clock to local time [default=utc]\n"
6070 "-full-screen start in full screen\n"
6071 #ifdef TARGET_I386
6072 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
6073 #endif
6074 "-usb enable the USB driver (will be the default soon)\n"
6075 "-usbdevice name add the host or guest USB device 'name'\n"
6076 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
6077 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
6078 #endif
6079 "\n"
6080 "Network options:\n"
6081 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
6082 " create a new Network Interface Card and connect it to VLAN 'n'\n"
6083 #ifdef CONFIG_SLIRP
6084 "-net user[,vlan=n][,hostname=host]\n"
6085 " connect the user mode network stack to VLAN 'n' and send\n"
6086 " hostname 'host' to DHCP clients\n"
6087 #endif
6088 #ifdef _WIN32
6089 "-net tap[,vlan=n],ifname=name\n"
6090 " connect the host TAP network interface to VLAN 'n'\n"
6091 #else
6092 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file]\n"
6093 " connect the host TAP network interface to VLAN 'n' and use\n"
6094 " the network script 'file' (default=%s);\n"
6095 " use 'fd=h' to connect to an already opened TAP interface\n"
6096 #endif
6097 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
6098 " connect the vlan 'n' to another VLAN using a socket connection\n"
6099 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
6100 " connect the vlan 'n' to multicast maddr and port\n"
6101 "-net none use it alone to have zero network devices; if no -net option\n"
6102 " is provided, the default is '-net nic -net user'\n"
6103 "\n"
6104 #ifdef CONFIG_SLIRP
6105 "-tftp prefix allow tftp access to files starting with prefix [-net user]\n"
6106 #ifndef _WIN32
6107 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
6108 #endif
6109 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
6110 " redirect TCP or UDP connections from host to guest [-net user]\n"
6111 #endif
6112 "\n"
6113 "Linux boot specific:\n"
6114 "-kernel bzImage use 'bzImage' as kernel image\n"
6115 "-append cmdline use 'cmdline' as kernel command line\n"
6116 "-initrd file use 'file' as initial ram disk\n"
6117 "\n"
6118 "Debug/Expert options:\n"
6119 "-monitor dev redirect the monitor to char device 'dev'\n"
6120 "-serial dev redirect the serial port to char device 'dev'\n"
6121 "-parallel dev redirect the parallel port to char device 'dev'\n"
6122 "-pidfile file Write PID to 'file'\n"
6123 "-S freeze CPU at startup (use 'c' to start execution)\n"
6124 "-s wait gdb connection to port %d\n"
6125 "-p port change gdb connection port\n"
6126 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
6127 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
6128 " translation (t=none or lba) (usually qemu can guess them)\n"
6129 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
6130 #ifdef USE_KQEMU
6131 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
6132 "-no-kqemu disable KQEMU kernel module usage\n"
6133 #endif
6134 #ifdef USE_CODE_COPY
6135 "-no-code-copy disable code copy acceleration\n"
6136 #endif
6137 #ifdef TARGET_I386
6138 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
6139 " (default is CL-GD5446 PCI VGA)\n"
6140 "-no-acpi disable ACPI\n"
6141 #endif
6142 "-no-reboot exit instead of rebooting\n"
6143 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
6144 "-vnc display start a VNC server on display\n"
6145 #ifndef _WIN32
6146 "-daemonize daemonize QEMU after initializing\n"
6147 #endif
6148 "-option-rom rom load a file, rom, into the option ROM space\n"
6149 "\n"
6150 "During emulation, the following keys are useful:\n"
6151 "ctrl-alt-f toggle full screen\n"
6152 "ctrl-alt-n switch to virtual console 'n'\n"
6153 "ctrl-alt toggle mouse and keyboard grab\n"
6154 "\n"
6155 "When using -nographic, press 'ctrl-a h' to get some help.\n"
6156 ,
6157 "qemu",
6158 DEFAULT_RAM_SIZE,
6159 #ifndef _WIN32
6160 DEFAULT_NETWORK_SCRIPT,
6161 #endif
6162 DEFAULT_GDBSTUB_PORT,
6163 "/tmp/qemu.log");
6164 exit(1);
6165 }
6166
6167 #define HAS_ARG 0x0001
6168
6169 enum {
6170 QEMU_OPTION_h,
6171
6172 QEMU_OPTION_M,
6173 QEMU_OPTION_fda,
6174 QEMU_OPTION_fdb,
6175 QEMU_OPTION_hda,
6176 QEMU_OPTION_hdb,
6177 QEMU_OPTION_hdc,
6178 QEMU_OPTION_hdd,
6179 QEMU_OPTION_cdrom,
6180 QEMU_OPTION_boot,
6181 QEMU_OPTION_snapshot,
6182 #ifdef TARGET_I386
6183 QEMU_OPTION_no_fd_bootchk,
6184 #endif
6185 QEMU_OPTION_m,
6186 QEMU_OPTION_nographic,
6187 #ifdef HAS_AUDIO
6188 QEMU_OPTION_audio_help,
6189 QEMU_OPTION_soundhw,
6190 #endif
6191
6192 QEMU_OPTION_net,
6193 QEMU_OPTION_tftp,
6194 QEMU_OPTION_smb,
6195 QEMU_OPTION_redir,
6196
6197 QEMU_OPTION_kernel,
6198 QEMU_OPTION_append,
6199 QEMU_OPTION_initrd,
6200
6201 QEMU_OPTION_S,
6202 QEMU_OPTION_s,
6203 QEMU_OPTION_p,
6204 QEMU_OPTION_d,
6205 QEMU_OPTION_hdachs,
6206 QEMU_OPTION_L,
6207 QEMU_OPTION_no_code_copy,
6208 QEMU_OPTION_k,
6209 QEMU_OPTION_localtime,
6210 QEMU_OPTION_cirrusvga,
6211 QEMU_OPTION_g,
6212 QEMU_OPTION_std_vga,
6213 QEMU_OPTION_monitor,
6214 QEMU_OPTION_serial,
6215 QEMU_OPTION_parallel,
6216 QEMU_OPTION_loadvm,
6217 QEMU_OPTION_full_screen,
6218 QEMU_OPTION_no_quit,
6219 QEMU_OPTION_pidfile,
6220 QEMU_OPTION_no_kqemu,
6221 QEMU_OPTION_kernel_kqemu,
6222 QEMU_OPTION_win2k_hack,
6223 QEMU_OPTION_usb,
6224 QEMU_OPTION_usbdevice,
6225 QEMU_OPTION_smp,
6226 QEMU_OPTION_vnc,
6227 QEMU_OPTION_no_acpi,
6228 QEMU_OPTION_no_reboot,
6229 QEMU_OPTION_daemonize,
6230 QEMU_OPTION_option_rom,
6231 QEMU_OPTION_semihosting
6232 };
6233
6234 typedef struct QEMUOption {
6235 const char *name;
6236 int flags;
6237 int index;
6238 } QEMUOption;
6239
6240 const QEMUOption qemu_options[] = {
6241 { "h", 0, QEMU_OPTION_h },
6242
6243 { "M", HAS_ARG, QEMU_OPTION_M },
6244 { "fda", HAS_ARG, QEMU_OPTION_fda },
6245 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
6246 { "hda", HAS_ARG, QEMU_OPTION_hda },
6247 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
6248 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
6249 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
6250 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
6251 { "boot", HAS_ARG, QEMU_OPTION_boot },
6252 { "snapshot", 0, QEMU_OPTION_snapshot },
6253 #ifdef TARGET_I386
6254 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
6255 #endif
6256 { "m", HAS_ARG, QEMU_OPTION_m },
6257 { "nographic", 0, QEMU_OPTION_nographic },
6258 { "k", HAS_ARG, QEMU_OPTION_k },
6259 #ifdef HAS_AUDIO
6260 { "audio-help", 0, QEMU_OPTION_audio_help },
6261 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
6262 #endif
6263
6264 { "net", HAS_ARG, QEMU_OPTION_net},
6265 #ifdef CONFIG_SLIRP
6266 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
6267 #ifndef _WIN32
6268 { "smb", HAS_ARG, QEMU_OPTION_smb },
6269 #endif
6270 { "redir", HAS_ARG, QEMU_OPTION_redir },
6271 #endif
6272
6273 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
6274 { "append", HAS_ARG, QEMU_OPTION_append },
6275 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
6276
6277 { "S", 0, QEMU_OPTION_S },
6278 { "s", 0, QEMU_OPTION_s },
6279 { "p", HAS_ARG, QEMU_OPTION_p },
6280 { "d", HAS_ARG, QEMU_OPTION_d },
6281 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
6282 { "L", HAS_ARG, QEMU_OPTION_L },
6283 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
6284 #ifdef USE_KQEMU
6285 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
6286 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
6287 #endif
6288 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
6289 { "g", 1, QEMU_OPTION_g },
6290 #endif
6291 { "localtime", 0, QEMU_OPTION_localtime },
6292 { "std-vga", 0, QEMU_OPTION_std_vga },
6293 { "monitor", 1, QEMU_OPTION_monitor },
6294 { "serial", 1, QEMU_OPTION_serial },
6295 { "parallel", 1, QEMU_OPTION_parallel },
6296 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
6297 { "full-screen", 0, QEMU_OPTION_full_screen },
6298 #ifdef CONFIG_SDL
6299 { "no-quit", 0, QEMU_OPTION_no_quit },
6300 #endif
6301 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
6302 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
6303 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
6304 { "smp", HAS_ARG, QEMU_OPTION_smp },
6305 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
6306
6307 /* temporary options */
6308 { "usb", 0, QEMU_OPTION_usb },
6309 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
6310 { "no-acpi", 0, QEMU_OPTION_no_acpi },
6311 { "no-reboot", 0, QEMU_OPTION_no_reboot },
6312 { "daemonize", 0, QEMU_OPTION_daemonize },
6313 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
6314 #if defined(TARGET_ARM)
6315 { "semihosting", 0, QEMU_OPTION_semihosting },
6316 #endif
6317 { NULL },
6318 };
6319
6320 #if defined (TARGET_I386) && defined(USE_CODE_COPY)
6321
6322 /* this stack is only used during signal handling */
6323 #define SIGNAL_STACK_SIZE 32768
6324
6325 static uint8_t *signal_stack;
6326
6327 #endif
6328
6329 /* password input */
6330
6331 static BlockDriverState *get_bdrv(int index)
6332 {
6333 BlockDriverState *bs;
6334
6335 if (index < 4) {
6336 bs = bs_table[index];
6337 } else if (index < 6) {
6338 bs = fd_table[index - 4];
6339 } else {
6340 bs = NULL;
6341 }
6342 return bs;
6343 }
6344
6345 static void read_passwords(void)
6346 {
6347 BlockDriverState *bs;
6348 int i, j;
6349 char password[256];
6350
6351 for(i = 0; i < 6; i++) {
6352 bs = get_bdrv(i);
6353 if (bs && bdrv_is_encrypted(bs)) {
6354 term_printf("%s is encrypted.\n", bdrv_get_device_name(bs));
6355 for(j = 0; j < 3; j++) {
6356 monitor_readline("Password: ",
6357 1, password, sizeof(password));
6358 if (bdrv_set_key(bs, password) == 0)
6359 break;
6360 term_printf("invalid password\n");
6361 }
6362 }
6363 }
6364 }
6365
6366 /* XXX: currently we cannot use simultaneously different CPUs */
6367 void register_machines(void)
6368 {
6369 #if defined(TARGET_I386)
6370 qemu_register_machine(&pc_machine);
6371 qemu_register_machine(&isapc_machine);
6372 #elif defined(TARGET_PPC)
6373 qemu_register_machine(&heathrow_machine);
6374 qemu_register_machine(&core99_machine);
6375 qemu_register_machine(&prep_machine);
6376 #elif defined(TARGET_MIPS)
6377 qemu_register_machine(&mips_machine);
6378 qemu_register_machine(&mips_malta_machine);
6379 #elif defined(TARGET_SPARC)
6380 #ifdef TARGET_SPARC64
6381 qemu_register_machine(&sun4u_machine);
6382 #else
6383 qemu_register_machine(&sun4m_machine);
6384 #endif
6385 #elif defined(TARGET_ARM)
6386 qemu_register_machine(&integratorcp926_machine);
6387 qemu_register_machine(&integratorcp1026_machine);
6388 qemu_register_machine(&versatilepb_machine);
6389 qemu_register_machine(&versatileab_machine);
6390 qemu_register_machine(&realview_machine);
6391 #elif defined(TARGET_SH4)
6392 qemu_register_machine(&shix_machine);
6393 #else
6394 #error unsupported CPU
6395 #endif
6396 }
6397
6398 #ifdef HAS_AUDIO
6399 struct soundhw soundhw[] = {
6400 #ifdef TARGET_I386
6401 {
6402 "pcspk",
6403 "PC speaker",
6404 0,
6405 1,
6406 { .init_isa = pcspk_audio_init }
6407 },
6408 #endif
6409 {
6410 "sb16",
6411 "Creative Sound Blaster 16",
6412 0,
6413 1,
6414 { .init_isa = SB16_init }
6415 },
6416
6417 #ifdef CONFIG_ADLIB
6418 {
6419 "adlib",
6420 #ifdef HAS_YMF262
6421 "Yamaha YMF262 (OPL3)",
6422 #else
6423 "Yamaha YM3812 (OPL2)",
6424 #endif
6425 0,
6426 1,
6427 { .init_isa = Adlib_init }
6428 },
6429 #endif
6430
6431 #ifdef CONFIG_GUS
6432 {
6433 "gus",
6434 "Gravis Ultrasound GF1",
6435 0,
6436 1,
6437 { .init_isa = GUS_init }
6438 },
6439 #endif
6440
6441 {
6442 "es1370",
6443 "ENSONIQ AudioPCI ES1370",
6444 0,
6445 0,
6446 { .init_pci = es1370_init }
6447 },
6448
6449 { NULL, NULL, 0, 0, { NULL } }
6450 };
6451
6452 static void select_soundhw (const char *optarg)
6453 {
6454 struct soundhw *c;
6455
6456 if (*optarg == '?') {
6457 show_valid_cards:
6458
6459 printf ("Valid sound card names (comma separated):\n");
6460 for (c = soundhw; c->name; ++c) {
6461 printf ("%-11s %s\n", c->name, c->descr);
6462 }
6463 printf ("\n-soundhw all will enable all of the above\n");
6464 exit (*optarg != '?');
6465 }
6466 else {
6467 size_t l;
6468 const char *p;
6469 char *e;
6470 int bad_card = 0;
6471
6472 if (!strcmp (optarg, "all")) {
6473 for (c = soundhw; c->name; ++c) {
6474 c->enabled = 1;
6475 }
6476 return;
6477 }
6478
6479 p = optarg;
6480 while (*p) {
6481 e = strchr (p, ',');
6482 l = !e ? strlen (p) : (size_t) (e - p);
6483
6484 for (c = soundhw; c->name; ++c) {
6485 if (!strncmp (c->name, p, l)) {
6486 c->enabled = 1;
6487 break;
6488 }
6489 }
6490
6491 if (!c->name) {
6492 if (l > 80) {
6493 fprintf (stderr,
6494 "Unknown sound card name (too big to show)\n");
6495 }
6496 else {
6497 fprintf (stderr, "Unknown sound card name `%.*s'\n",
6498 (int) l, p);
6499 }
6500 bad_card = 1;
6501 }
6502 p += l + (e != NULL);
6503 }
6504
6505 if (bad_card)
6506 goto show_valid_cards;
6507 }
6508 }
6509 #endif
6510
6511 #ifdef _WIN32
6512 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
6513 {
6514 exit(STATUS_CONTROL_C_EXIT);
6515 return TRUE;
6516 }
6517 #endif
6518
6519 #define MAX_NET_CLIENTS 32
6520
6521 int main(int argc, char **argv)
6522 {
6523 #ifdef CONFIG_GDBSTUB
6524 int use_gdbstub, gdbstub_port;
6525 #endif
6526 int i, cdrom_index;
6527 int snapshot, linux_boot;
6528 const char *initrd_filename;
6529 const char *hd_filename[MAX_DISKS], *fd_filename[MAX_FD];
6530 const char *kernel_filename, *kernel_cmdline;
6531 DisplayState *ds = &display_state;
6532 int cyls, heads, secs, translation;
6533 int start_emulation = 1;
6534 char net_clients[MAX_NET_CLIENTS][256];
6535 int nb_net_clients;
6536 int optind;
6537 const char *r, *optarg;
6538 CharDriverState *monitor_hd;
6539 char monitor_device[128];
6540 char serial_devices[MAX_SERIAL_PORTS][128];
6541 int serial_device_index;
6542 char parallel_devices[MAX_PARALLEL_PORTS][128];
6543 int parallel_device_index;
6544 const char *loadvm = NULL;
6545 QEMUMachine *machine;
6546 char usb_devices[MAX_USB_CMDLINE][128];
6547 int usb_devices_index;
6548 int fds[2];
6549
6550 LIST_INIT (&vm_change_state_head);
6551 #ifndef _WIN32
6552 {
6553 struct sigaction act;
6554 sigfillset(&act.sa_mask);
6555 act.sa_flags = 0;
6556 act.sa_handler = SIG_IGN;
6557 sigaction(SIGPIPE, &act, NULL);
6558 }
6559 #else
6560 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
6561 /* Note: cpu_interrupt() is currently not SMP safe, so we force
6562 QEMU to run on a single CPU */
6563 {
6564 HANDLE h;
6565 DWORD mask, smask;
6566 int i;
6567 h = GetCurrentProcess();
6568 if (GetProcessAffinityMask(h, &mask, &smask)) {
6569 for(i = 0; i < 32; i++) {
6570 if (mask & (1 << i))
6571 break;
6572 }
6573 if (i != 32) {
6574 mask = 1 << i;
6575 SetProcessAffinityMask(h, mask);
6576 }
6577 }
6578 }
6579 #endif
6580
6581 register_machines();
6582 machine = first_machine;
6583 initrd_filename = NULL;
6584 for(i = 0; i < MAX_FD; i++)
6585 fd_filename[i] = NULL;
6586 for(i = 0; i < MAX_DISKS; i++)
6587 hd_filename[i] = NULL;
6588 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
6589 vga_ram_size = VGA_RAM_SIZE;
6590 bios_size = BIOS_SIZE;
6591 #ifdef CONFIG_GDBSTUB
6592 use_gdbstub = 0;
6593 gdbstub_port = DEFAULT_GDBSTUB_PORT;
6594 #endif
6595 snapshot = 0;
6596 nographic = 0;
6597 kernel_filename = NULL;
6598 kernel_cmdline = "";
6599 #ifdef TARGET_PPC
6600 cdrom_index = 1;
6601 #else
6602 cdrom_index = 2;
6603 #endif
6604 cyls = heads = secs = 0;
6605 translation = BIOS_ATA_TRANSLATION_AUTO;
6606 pstrcpy(monitor_device, sizeof(monitor_device), "vc");
6607
6608 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
6609 for(i = 1; i < MAX_SERIAL_PORTS; i++)
6610 serial_devices[i][0] = '\0';
6611 serial_device_index = 0;
6612
6613 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
6614 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
6615 parallel_devices[i][0] = '\0';
6616 parallel_device_index = 0;
6617
6618 usb_devices_index = 0;
6619
6620 nb_net_clients = 0;
6621
6622 nb_nics = 0;
6623 /* default mac address of the first network interface */
6624
6625 optind = 1;
6626 for(;;) {
6627 if (optind >= argc)
6628 break;
6629 r = argv[optind];
6630 if (r[0] != '-') {
6631 hd_filename[0] = argv[optind++];
6632 } else {
6633 const QEMUOption *popt;
6634
6635 optind++;
6636 popt = qemu_options;
6637 for(;;) {
6638 if (!popt->name) {
6639 fprintf(stderr, "%s: invalid option -- '%s'\n",
6640 argv[0], r);
6641 exit(1);
6642 }
6643 if (!strcmp(popt->name, r + 1))
6644 break;
6645 popt++;
6646 }
6647 if (popt->flags & HAS_ARG) {
6648 if (optind >= argc) {
6649 fprintf(stderr, "%s: option '%s' requires an argument\n",
6650 argv[0], r);
6651 exit(1);
6652 }
6653 optarg = argv[optind++];
6654 } else {
6655 optarg = NULL;
6656 }
6657
6658 switch(popt->index) {
6659 case QEMU_OPTION_M:
6660 machine = find_machine(optarg);
6661 if (!machine) {
6662 QEMUMachine *m;
6663 printf("Supported machines are:\n");
6664 for(m = first_machine; m != NULL; m = m->next) {
6665 printf("%-10s %s%s\n",
6666 m->name, m->desc,
6667 m == first_machine ? " (default)" : "");
6668 }
6669 exit(1);
6670 }
6671 break;
6672 case QEMU_OPTION_initrd:
6673 initrd_filename = optarg;
6674 break;
6675 case QEMU_OPTION_hda:
6676 case QEMU_OPTION_hdb:
6677 case QEMU_OPTION_hdc:
6678 case QEMU_OPTION_hdd:
6679 {
6680 int hd_index;
6681 hd_index = popt->index - QEMU_OPTION_hda;
6682 hd_filename[hd_index] = optarg;
6683 if (hd_index == cdrom_index)
6684 cdrom_index = -1;
6685 }
6686 break;
6687 case QEMU_OPTION_snapshot:
6688 snapshot = 1;
6689 break;
6690 case QEMU_OPTION_hdachs:
6691 {
6692 const char *p;
6693 p = optarg;
6694 cyls = strtol(p, (char **)&p, 0);
6695 if (cyls < 1 || cyls > 16383)
6696 goto chs_fail;
6697 if (*p != ',')
6698 goto chs_fail;
6699 p++;
6700 heads = strtol(p, (char **)&p, 0);
6701 if (heads < 1 || heads > 16)
6702 goto chs_fail;
6703 if (*p != ',')
6704 goto chs_fail;
6705 p++;
6706 secs = strtol(p, (char **)&p, 0);
6707 if (secs < 1 || secs > 63)
6708 goto chs_fail;
6709 if (*p == ',') {
6710 p++;
6711 if (!strcmp(p, "none"))
6712 translation = BIOS_ATA_TRANSLATION_NONE;
6713 else if (!strcmp(p, "lba"))
6714 translation = BIOS_ATA_TRANSLATION_LBA;
6715 else if (!strcmp(p, "auto"))
6716 translation = BIOS_ATA_TRANSLATION_AUTO;
6717 else
6718 goto chs_fail;
6719 } else if (*p != '\0') {
6720 chs_fail:
6721 fprintf(stderr, "qemu: invalid physical CHS format\n");
6722 exit(1);
6723 }
6724 }
6725 break;
6726 case QEMU_OPTION_nographic:
6727 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
6728 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
6729 nographic = 1;
6730 break;
6731 case QEMU_OPTION_kernel:
6732 kernel_filename = optarg;
6733 break;
6734 case QEMU_OPTION_append:
6735 kernel_cmdline = optarg;
6736 break;
6737 case QEMU_OPTION_cdrom:
6738 if (cdrom_index >= 0) {
6739 hd_filename[cdrom_index] = optarg;
6740 }
6741 break;
6742 case QEMU_OPTION_boot:
6743 boot_device = optarg[0];
6744 if (boot_device != 'a' &&
6745 #if defined(TARGET_SPARC) || defined(TARGET_I386)
6746 // Network boot
6747 boot_device != 'n' &&
6748 #endif
6749 boot_device != 'c' && boot_device != 'd') {
6750 fprintf(stderr, "qemu: invalid boot device '%c'\n", boot_device);
6751 exit(1);
6752 }
6753 break;
6754 case QEMU_OPTION_fda:
6755 fd_filename[0] = optarg;
6756 break;
6757 case QEMU_OPTION_fdb:
6758 fd_filename[1] = optarg;
6759 break;
6760 #ifdef TARGET_I386
6761 case QEMU_OPTION_no_fd_bootchk:
6762 fd_bootchk = 0;
6763 break;
6764 #endif
6765 case QEMU_OPTION_no_code_copy:
6766 code_copy_enabled = 0;
6767 break;
6768 case QEMU_OPTION_net:
6769 if (nb_net_clients >= MAX_NET_CLIENTS) {
6770 fprintf(stderr, "qemu: too many network clients\n");
6771 exit(1);
6772 }
6773 pstrcpy(net_clients[nb_net_clients],
6774 sizeof(net_clients[0]),
6775 optarg);
6776 nb_net_clients++;
6777 break;
6778 #ifdef CONFIG_SLIRP
6779 case QEMU_OPTION_tftp:
6780 tftp_prefix = optarg;
6781 break;
6782 #ifndef _WIN32
6783 case QEMU_OPTION_smb:
6784 net_slirp_smb(optarg);
6785 break;
6786 #endif
6787 case QEMU_OPTION_redir:
6788 net_slirp_redir(optarg);
6789 break;
6790 #endif
6791 #ifdef HAS_AUDIO
6792 case QEMU_OPTION_audio_help:
6793 AUD_help ();
6794 exit (0);
6795 break;
6796 case QEMU_OPTION_soundhw:
6797 select_soundhw (optarg);
6798 break;
6799 #endif
6800 case QEMU_OPTION_h:
6801 help();
6802 break;
6803 case QEMU_OPTION_m:
6804 ram_size = atoi(optarg) * 1024 * 1024;
6805 if (ram_size <= 0)
6806 help();
6807 if (ram_size > PHYS_RAM_MAX_SIZE) {
6808 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
6809 PHYS_RAM_MAX_SIZE / (1024 * 1024));
6810 exit(1);
6811 }
6812 break;
6813 case QEMU_OPTION_d:
6814 {
6815 int mask;
6816 CPULogItem *item;
6817
6818 mask = cpu_str_to_log_mask(optarg);
6819 if (!mask) {
6820 printf("Log items (comma separated):\n");
6821 for(item = cpu_log_items; item->mask != 0; item++) {
6822 printf("%-10s %s\n", item->name, item->help);
6823 }
6824 exit(1);
6825 }
6826 cpu_set_log(mask);
6827 }
6828 break;
6829 #ifdef CONFIG_GDBSTUB
6830 case QEMU_OPTION_s:
6831 use_gdbstub = 1;
6832 break;
6833 case QEMU_OPTION_p:
6834 gdbstub_port = atoi(optarg);
6835 break;
6836 #endif
6837 case QEMU_OPTION_L:
6838 bios_dir = optarg;
6839 break;
6840 case QEMU_OPTION_S:
6841 start_emulation = 0;
6842 break;
6843 case QEMU_OPTION_k:
6844 keyboard_layout = optarg;
6845 break;
6846 case QEMU_OPTION_localtime:
6847 rtc_utc = 0;
6848 break;
6849 case QEMU_OPTION_cirrusvga:
6850 cirrus_vga_enabled = 1;
6851 break;
6852 case QEMU_OPTION_std_vga:
6853 cirrus_vga_enabled = 0;
6854 break;
6855 case QEMU_OPTION_g:
6856 {
6857 const char *p;
6858 int w, h, depth;
6859 p = optarg;
6860 w = strtol(p, (char **)&p, 10);
6861 if (w <= 0) {
6862 graphic_error:
6863 fprintf(stderr, "qemu: invalid resolution or depth\n");
6864 exit(1);
6865 }
6866 if (*p != 'x')
6867 goto graphic_error;
6868 p++;
6869 h = strtol(p, (char **)&p, 10);
6870 if (h <= 0)
6871 goto graphic_error;
6872 if (*p == 'x') {
6873 p++;
6874 depth = strtol(p, (char **)&p, 10);
6875 if (depth != 8 && depth != 15 && depth != 16 &&
6876 depth != 24 && depth != 32)
6877 goto graphic_error;
6878 } else if (*p == '\0') {
6879 depth = graphic_depth;
6880 } else {
6881 goto graphic_error;
6882 }
6883
6884 graphic_width = w;
6885 graphic_height = h;
6886 graphic_depth = depth;
6887 }
6888 break;
6889 case QEMU_OPTION_monitor:
6890 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
6891 break;
6892 case QEMU_OPTION_serial:
6893 if (serial_device_index >= MAX_SERIAL_PORTS) {
6894 fprintf(stderr, "qemu: too many serial ports\n");
6895 exit(1);
6896 }
6897 pstrcpy(serial_devices[serial_device_index],
6898 sizeof(serial_devices[0]), optarg);
6899 serial_device_index++;
6900 break;
6901 case QEMU_OPTION_parallel:
6902 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
6903 fprintf(stderr, "qemu: too many parallel ports\n");
6904 exit(1);
6905 }
6906 pstrcpy(parallel_devices[parallel_device_index],
6907 sizeof(parallel_devices[0]), optarg);
6908 parallel_device_index++;
6909 break;
6910 case QEMU_OPTION_loadvm:
6911 loadvm = optarg;
6912 break;
6913 case QEMU_OPTION_full_screen:
6914 full_screen = 1;
6915 break;
6916 #ifdef CONFIG_SDL
6917 case QEMU_OPTION_no_quit:
6918 no_quit = 1;
6919 break;
6920 #endif
6921 case QEMU_OPTION_pidfile:
6922 create_pidfile(optarg);
6923 break;
6924 #ifdef TARGET_I386
6925 case QEMU_OPTION_win2k_hack:
6926 win2k_install_hack = 1;
6927 break;
6928 #endif
6929 #ifdef USE_KQEMU
6930 case QEMU_OPTION_no_kqemu:
6931 kqemu_allowed = 0;
6932 break;
6933 case QEMU_OPTION_kernel_kqemu:
6934 kqemu_allowed = 2;
6935 break;
6936 #endif
6937 case QEMU_OPTION_usb:
6938 usb_enabled = 1;
6939 break;
6940 case QEMU_OPTION_usbdevice:
6941 usb_enabled = 1;
6942 if (usb_devices_index >= MAX_USB_CMDLINE) {
6943 fprintf(stderr, "Too many USB devices\n");
6944 exit(1);
6945 }
6946 pstrcpy(usb_devices[usb_devices_index],
6947 sizeof(usb_devices[usb_devices_index]),
6948 optarg);
6949 usb_devices_index++;
6950 break;
6951 case QEMU_OPTION_smp:
6952 smp_cpus = atoi(optarg);
6953 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
6954 fprintf(stderr, "Invalid number of CPUs\n");
6955 exit(1);
6956 }
6957 break;
6958 case QEMU_OPTION_vnc:
6959 vnc_display = optarg;
6960 break;
6961 case QEMU_OPTION_no_acpi:
6962 acpi_enabled = 0;
6963 break;
6964 case QEMU_OPTION_no_reboot:
6965 no_reboot = 1;
6966 break;
6967 case QEMU_OPTION_daemonize:
6968 daemonize = 1;
6969 break;
6970 case QEMU_OPTION_option_rom:
6971 if (nb_option_roms >= MAX_OPTION_ROMS) {
6972 fprintf(stderr, "Too many option ROMs\n");
6973 exit(1);
6974 }
6975 option_rom[nb_option_roms] = optarg;
6976 nb_option_roms++;
6977 break;
6978 case QEMU_OPTION_semihosting:
6979 semihosting_enabled = 1;
6980 break;
6981 }
6982 }
6983 }
6984
6985 #ifndef _WIN32
6986 if (daemonize && !nographic && vnc_display == NULL) {
6987 fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
6988 daemonize = 0;
6989 }
6990
6991 if (daemonize) {
6992 pid_t pid;
6993
6994 if (pipe(fds) == -1)
6995 exit(1);
6996
6997 pid = fork();
6998 if (pid > 0) {
6999 uint8_t status;
7000 ssize_t len;
7001
7002 close(fds[1]);
7003
7004 again:
7005 len = read(fds[0], &status, 1);
7006 if (len == -1 && (errno == EINTR))
7007 goto again;
7008
7009 if (len != 1 || status != 0)
7010 exit(1);
7011 else
7012 exit(0);
7013 } else if (pid < 0)
7014 exit(1);
7015
7016 setsid();
7017
7018 pid = fork();
7019 if (pid > 0)
7020 exit(0);
7021 else if (pid < 0)
7022 exit(1);
7023
7024 umask(027);
7025 chdir("/");
7026
7027 signal(SIGTSTP, SIG_IGN);
7028 signal(SIGTTOU, SIG_IGN);
7029 signal(SIGTTIN, SIG_IGN);
7030 }
7031 #endif
7032
7033 #ifdef USE_KQEMU
7034 if (smp_cpus > 1)
7035 kqemu_allowed = 0;
7036 #endif
7037 linux_boot = (kernel_filename != NULL);
7038
7039 if (!linux_boot &&
7040 hd_filename[0] == '\0' &&
7041 (cdrom_index >= 0 && hd_filename[cdrom_index] == '\0') &&
7042 fd_filename[0] == '\0')
7043 help();
7044
7045 /* boot to floppy or the default cd if no hard disk defined yet */
7046 if (hd_filename[0] == '\0' && boot_device == 'c') {
7047 if (fd_filename[0] != '\0')
7048 boot_device = 'a';
7049 else
7050 boot_device = 'd';
7051 }
7052
7053 setvbuf(stdout, NULL, _IOLBF, 0);
7054
7055 init_timers();
7056 init_timer_alarm();
7057 qemu_aio_init();
7058
7059 #ifdef _WIN32
7060 socket_init();
7061 #endif
7062
7063 /* init network clients */
7064 if (nb_net_clients == 0) {
7065 /* if no clients, we use a default config */
7066 pstrcpy(net_clients[0], sizeof(net_clients[0]),
7067 "nic");
7068 pstrcpy(net_clients[1], sizeof(net_clients[0]),
7069 "user");
7070 nb_net_clients = 2;
7071 }
7072
7073 for(i = 0;i < nb_net_clients; i++) {
7074 if (net_client_init(net_clients[i]) < 0)
7075 exit(1);
7076 }
7077
7078 #ifdef TARGET_I386
7079 if (boot_device == 'n') {
7080 for (i = 0; i < nb_nics; i++) {
7081 const char *model = nd_table[i].model;
7082 char buf[1024];
7083 if (model == NULL)
7084 model = "ne2k_pci";
7085 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
7086 if (get_image_size(buf) > 0) {
7087 option_rom[nb_option_roms] = strdup(buf);
7088 nb_option_roms++;
7089 break;
7090 }
7091 }
7092 if (i == nb_nics) {
7093 fprintf(stderr, "No valid PXE rom found for network device\n");
7094 exit(1);
7095 }
7096 boot_device = 'c'; /* to prevent confusion by the BIOS */
7097 }
7098 #endif
7099
7100 /* init the memory */
7101 phys_ram_size = ram_size + vga_ram_size + bios_size;
7102
7103 for (i = 0; i < nb_option_roms; i++) {
7104 int ret = get_image_size(option_rom[i]);
7105 if (ret == -1) {
7106 fprintf(stderr, "Could not load option rom '%s'\n", option_rom[i]);
7107 exit(1);
7108 }
7109 phys_ram_size += ret;
7110 }
7111
7112 phys_ram_base = qemu_vmalloc(phys_ram_size);
7113 if (!phys_ram_base) {
7114 fprintf(stderr, "Could not allocate physical memory\n");
7115 exit(1);
7116 }
7117
7118 /* we always create the cdrom drive, even if no disk is there */
7119 bdrv_init();
7120 if (cdrom_index >= 0) {
7121 bs_table[cdrom_index] = bdrv_new("cdrom");
7122 bdrv_set_type_hint(bs_table[cdrom_index], BDRV_TYPE_CDROM);
7123 }
7124
7125 /* open the virtual block devices */
7126 for(i = 0; i < MAX_DISKS; i++) {
7127 if (hd_filename[i]) {
7128 if (!bs_table[i]) {
7129 char buf[64];
7130 snprintf(buf, sizeof(buf), "hd%c", i + 'a');
7131 bs_table[i] = bdrv_new(buf);
7132 }
7133 if (bdrv_open(bs_table[i], hd_filename[i], snapshot ? BDRV_O_SNAPSHOT : 0) < 0) {
7134 fprintf(stderr, "qemu: could not open hard disk image '%s'\n",
7135 hd_filename[i]);
7136 exit(1);
7137 }
7138 if (i == 0 && cyls != 0) {
7139 bdrv_set_geometry_hint(bs_table[i], cyls, heads, secs);
7140 bdrv_set_translation_hint(bs_table[i], translation);
7141 }
7142 }
7143 }
7144
7145 /* we always create at least one floppy disk */
7146 fd_table[0] = bdrv_new("fda");
7147 bdrv_set_type_hint(fd_table[0], BDRV_TYPE_FLOPPY);
7148
7149 for(i = 0; i < MAX_FD; i++) {
7150 if (fd_filename[i]) {
7151 if (!fd_table[i]) {
7152 char buf[64];
7153 snprintf(buf, sizeof(buf), "fd%c", i + 'a');
7154 fd_table[i] = bdrv_new(buf);
7155 bdrv_set_type_hint(fd_table[i], BDRV_TYPE_FLOPPY);
7156 }
7157 if (fd_filename[i] != '\0') {
7158 if (bdrv_open(fd_table[i], fd_filename[i],
7159 snapshot ? BDRV_O_SNAPSHOT : 0) < 0) {
7160 fprintf(stderr, "qemu: could not open floppy disk image '%s'\n",
7161 fd_filename[i]);
7162 exit(1);
7163 }
7164 }
7165 }
7166 }
7167
7168 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
7169 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
7170
7171 init_ioports();
7172
7173 /* terminal init */
7174 if (nographic) {
7175 dumb_display_init(ds);
7176 } else if (vnc_display != NULL) {
7177 vnc_display_init(ds, vnc_display);
7178 } else {
7179 #if defined(CONFIG_SDL)
7180 sdl_display_init(ds, full_screen);
7181 #elif defined(CONFIG_COCOA)
7182 cocoa_display_init(ds, full_screen);
7183 #else
7184 dumb_display_init(ds);
7185 #endif
7186 }
7187
7188 monitor_hd = qemu_chr_open(monitor_device);
7189 if (!monitor_hd) {
7190 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
7191 exit(1);
7192 }
7193 monitor_init(monitor_hd, !nographic);
7194
7195 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
7196 const char *devname = serial_devices[i];
7197 if (devname[0] != '\0' && strcmp(devname, "none")) {
7198 serial_hds[i] = qemu_chr_open(devname);
7199 if (!serial_hds[i]) {
7200 fprintf(stderr, "qemu: could not open serial device '%s'\n",
7201 devname);
7202 exit(1);
7203 }
7204 if (!strcmp(devname, "vc"))
7205 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
7206 }
7207 }
7208
7209 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
7210 const char *devname = parallel_devices[i];
7211 if (devname[0] != '\0' && strcmp(devname, "none")) {
7212 parallel_hds[i] = qemu_chr_open(devname);
7213 if (!parallel_hds[i]) {
7214 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
7215 devname);
7216 exit(1);
7217 }
7218 if (!strcmp(devname, "vc"))
7219 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
7220 }
7221 }
7222
7223 machine->init(ram_size, vga_ram_size, boot_device,
7224 ds, fd_filename, snapshot,
7225 kernel_filename, kernel_cmdline, initrd_filename);
7226
7227 /* init USB devices */
7228 if (usb_enabled) {
7229 for(i = 0; i < usb_devices_index; i++) {
7230 if (usb_device_add(usb_devices[i]) < 0) {
7231 fprintf(stderr, "Warning: could not add USB device %s\n",
7232 usb_devices[i]);
7233 }
7234 }
7235 }
7236
7237 gui_timer = qemu_new_timer(rt_clock, gui_update, NULL);
7238 qemu_mod_timer(gui_timer, qemu_get_clock(rt_clock));
7239
7240 #ifdef CONFIG_GDBSTUB
7241 if (use_gdbstub) {
7242 if (gdbserver_start(gdbstub_port) < 0) {
7243 fprintf(stderr, "Could not open gdbserver socket on port %d\n",
7244 gdbstub_port);
7245 exit(1);
7246 } else {
7247 printf("Waiting gdb connection on port %d\n", gdbstub_port);
7248 }
7249 } else
7250 #endif
7251 if (loadvm)
7252 do_loadvm(loadvm);
7253
7254 {
7255 /* XXX: simplify init */
7256 read_passwords();
7257 if (start_emulation) {
7258 vm_start();
7259 }
7260 }
7261
7262 if (daemonize) {
7263 uint8_t status = 0;
7264 ssize_t len;
7265 int fd;
7266
7267 again1:
7268 len = write(fds[1], &status, 1);
7269 if (len == -1 && (errno == EINTR))
7270 goto again1;
7271
7272 if (len != 1)
7273 exit(1);
7274
7275 fd = open("/dev/null", O_RDWR);
7276 if (fd == -1)
7277 exit(1);
7278
7279 dup2(fd, 0);
7280 dup2(fd, 1);
7281 dup2(fd, 2);
7282
7283 close(fd);
7284 }
7285
7286 main_loop();
7287 quit_timers();
7288 return 0;
7289 }
Samsung s3c2440 and arm920t support for the mini2440 dev board