]> git.proxmox.com Git - qemu.git/blob - vl.c
projects / qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
qemu: move drives_opt for external use (Marcelo Tosatti)
[qemu.git] / vl.c
1 /*
2 * QEMU System Emulator
3 *
4 * Copyright (c) 2003-2008 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 "hw/hw.h"
25 #include "hw/boards.h"
26 #include "hw/usb.h"
27 #include "hw/pcmcia.h"
28 #include "hw/pc.h"
29 #include "hw/audiodev.h"
30 #include "hw/isa.h"
31 #include "hw/baum.h"
32 #include "hw/bt.h"
33 #include "net.h"
34 #include "console.h"
35 #include "sysemu.h"
36 #include "gdbstub.h"
37 #include "qemu-timer.h"
38 #include "qemu-char.h"
39 #include "cache-utils.h"
40 #include "block.h"
41 #include "audio/audio.h"
42 #include "migration.h"
43 #include "kvm.h"
44 #include "balloon.h"
45
46 #include <unistd.h>
47 #include <fcntl.h>
48 #include <signal.h>
49 #include <time.h>
50 #include <errno.h>
51 #include <sys/time.h>
52 #include <zlib.h>
53
54 #ifndef _WIN32
55 #include <sys/times.h>
56 #include <sys/wait.h>
57 #include <termios.h>
58 #include <sys/mman.h>
59 #include <sys/ioctl.h>
60 #include <sys/resource.h>
61 #include <sys/socket.h>
62 #include <netinet/in.h>
63 #include <net/if.h>
64 #if defined(__NetBSD__)
65 #include <net/if_tap.h>
66 #endif
67 #ifdef __linux__
68 #include <linux/if_tun.h>
69 #endif
70 #include <arpa/inet.h>
71 #include <dirent.h>
72 #include <netdb.h>
73 #include <sys/select.h>
74 #ifdef _BSD
75 #include <sys/stat.h>
76 #ifdef __FreeBSD__
77 #include <libutil.h>
78 #else
79 #include <util.h>
80 #endif
81 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
82 #include <freebsd/stdlib.h>
83 #else
84 #ifdef __linux__
85 #include <pty.h>
86 #include <malloc.h>
87 #include <linux/rtc.h>
88
89 /* For the benefit of older linux systems which don't supply it,
90 we use a local copy of hpet.h. */
91 /* #include <linux/hpet.h> */
92 #include "hpet.h"
93
94 #include <linux/ppdev.h>
95 #include <linux/parport.h>
96 #endif
97 #ifdef __sun__
98 #include <sys/stat.h>
99 #include <sys/ethernet.h>
100 #include <sys/sockio.h>
101 #include <netinet/arp.h>
102 #include <netinet/in.h>
103 #include <netinet/in_systm.h>
104 #include <netinet/ip.h>
105 #include <netinet/ip_icmp.h> // must come after ip.h
106 #include <netinet/udp.h>
107 #include <netinet/tcp.h>
108 #include <net/if.h>
109 #include <syslog.h>
110 #include <stropts.h>
111 #endif
112 #endif
113 #endif
114
115 #include "qemu_socket.h"
116
117 #if defined(CONFIG_SLIRP)
118 #include "libslirp.h"
119 #endif
120
121 #if defined(__OpenBSD__)
122 #include <util.h>
123 #endif
124
125 #if defined(CONFIG_VDE)
126 #include <libvdeplug.h>
127 #endif
128
129 #ifdef _WIN32
130 #include <malloc.h>
131 #include <sys/timeb.h>
132 #include <mmsystem.h>
133 #define getopt_long_only getopt_long
134 #define memalign(align, size) malloc(size)
135 #endif
136
137 #ifdef CONFIG_SDL
138 #ifdef __APPLE__
139 #include <SDL/SDL.h>
140 #endif
141 #endif /* CONFIG_SDL */
142
143 #ifdef CONFIG_COCOA
144 #undef main
145 #define main qemu_main
146 #endif /* CONFIG_COCOA */
147
148 #include "disas.h"
149
150 #include "exec-all.h"
151
152 //#define DEBUG_UNUSED_IOPORT
153 //#define DEBUG_IOPORT
154 //#define DEBUG_NET
155 //#define DEBUG_SLIRP
156
157
158 #ifdef DEBUG_IOPORT
159 # define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
160 #else
161 # define LOG_IOPORT(...) do { } while (0)
162 #endif
163
164 #define DEFAULT_RAM_SIZE 128
165
166 /* Max number of USB devices that can be specified on the commandline. */
167 #define MAX_USB_CMDLINE 8
168
169 /* Max number of bluetooth switches on the commandline. */
170 #define MAX_BT_CMDLINE 10
171
172 /* XXX: use a two level table to limit memory usage */
173 #define MAX_IOPORTS 65536
174
175 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
176 const char *bios_name = NULL;
177 static void *ioport_opaque[MAX_IOPORTS];
178 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
179 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
180 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
181 to store the VM snapshots */
182 DriveInfo drives_table[MAX_DRIVES+1];
183 int nb_drives;
184 static int vga_ram_size;
185 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
186 static DisplayState *display_state;
187 int nographic;
188 static int curses;
189 static int sdl;
190 const char* keyboard_layout = NULL;
191 int64_t ticks_per_sec;
192 ram_addr_t ram_size;
193 int nb_nics;
194 NICInfo nd_table[MAX_NICS];
195 int vm_running;
196 static int rtc_utc = 1;
197 static int rtc_date_offset = -1; /* -1 means no change */
198 int cirrus_vga_enabled = 1;
199 int std_vga_enabled = 0;
200 int vmsvga_enabled = 0;
201 #ifdef TARGET_SPARC
202 int graphic_width = 1024;
203 int graphic_height = 768;
204 int graphic_depth = 8;
205 #else
206 int graphic_width = 800;
207 int graphic_height = 600;
208 int graphic_depth = 15;
209 #endif
210 static int full_screen = 0;
211 #ifdef CONFIG_SDL
212 static int no_frame = 0;
213 #endif
214 int no_quit = 0;
215 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
216 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
217 CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
218 #ifdef TARGET_I386
219 int win2k_install_hack = 0;
220 int rtc_td_hack = 0;
221 #endif
222 int usb_enabled = 0;
223 int smp_cpus = 1;
224 const char *vnc_display;
225 int acpi_enabled = 1;
226 int no_hpet = 0;
227 int fd_bootchk = 1;
228 int no_reboot = 0;
229 int no_shutdown = 0;
230 int cursor_hide = 1;
231 int graphic_rotate = 0;
232 int daemonize = 0;
233 const char *option_rom[MAX_OPTION_ROMS];
234 int nb_option_roms;
235 int semihosting_enabled = 0;
236 #ifdef TARGET_ARM
237 int old_param = 0;
238 #endif
239 const char *qemu_name;
240 int alt_grab = 0;
241 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
242 unsigned int nb_prom_envs = 0;
243 const char *prom_envs[MAX_PROM_ENVS];
244 #endif
245 int nb_drives_opt;
246 struct drive_opt drives_opt[MAX_DRIVES];
247
248 static CPUState *cur_cpu;
249 static CPUState *next_cpu;
250 static int event_pending = 1;
251 /* Conversion factor from emulated instructions to virtual clock ticks. */
252 static int icount_time_shift;
253 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
254 #define MAX_ICOUNT_SHIFT 10
255 /* Compensate for varying guest execution speed. */
256 static int64_t qemu_icount_bias;
257 static QEMUTimer *icount_rt_timer;
258 static QEMUTimer *icount_vm_timer;
259 static QEMUTimer *nographic_timer;
260
261 uint8_t qemu_uuid[16];
262
263 /***********************************************************/
264 /* x86 ISA bus support */
265
266 target_phys_addr_t isa_mem_base = 0;
267 PicState2 *isa_pic;
268
269 static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
270 static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
271
272 static uint32_t ioport_read(int index, uint32_t address)
273 {
274 static IOPortReadFunc *default_func[3] = {
275 default_ioport_readb,
276 default_ioport_readw,
277 default_ioport_readl
278 };
279 IOPortReadFunc *func = ioport_read_table[index][address];
280 if (!func)
281 func = default_func[index];
282 return func(ioport_opaque[address], address);
283 }
284
285 static void ioport_write(int index, uint32_t address, uint32_t data)
286 {
287 static IOPortWriteFunc *default_func[3] = {
288 default_ioport_writeb,
289 default_ioport_writew,
290 default_ioport_writel
291 };
292 IOPortWriteFunc *func = ioport_write_table[index][address];
293 if (!func)
294 func = default_func[index];
295 func(ioport_opaque[address], address, data);
296 }
297
298 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
299 {
300 #ifdef DEBUG_UNUSED_IOPORT
301 fprintf(stderr, "unused inb: port=0x%04x\n", address);
302 #endif
303 return 0xff;
304 }
305
306 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
307 {
308 #ifdef DEBUG_UNUSED_IOPORT
309 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
310 #endif
311 }
312
313 /* default is to make two byte accesses */
314 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
315 {
316 uint32_t data;
317 data = ioport_read(0, address);
318 address = (address + 1) & (MAX_IOPORTS - 1);
319 data |= ioport_read(0, address) << 8;
320 return data;
321 }
322
323 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
324 {
325 ioport_write(0, address, data & 0xff);
326 address = (address + 1) & (MAX_IOPORTS - 1);
327 ioport_write(0, address, (data >> 8) & 0xff);
328 }
329
330 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
331 {
332 #ifdef DEBUG_UNUSED_IOPORT
333 fprintf(stderr, "unused inl: port=0x%04x\n", address);
334 #endif
335 return 0xffffffff;
336 }
337
338 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
339 {
340 #ifdef DEBUG_UNUSED_IOPORT
341 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
342 #endif
343 }
344
345 /* size is the word size in byte */
346 int register_ioport_read(int start, int length, int size,
347 IOPortReadFunc *func, void *opaque)
348 {
349 int i, bsize;
350
351 if (size == 1) {
352 bsize = 0;
353 } else if (size == 2) {
354 bsize = 1;
355 } else if (size == 4) {
356 bsize = 2;
357 } else {
358 hw_error("register_ioport_read: invalid size");
359 return -1;
360 }
361 for(i = start; i < start + length; i += size) {
362 ioport_read_table[bsize][i] = func;
363 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
364 hw_error("register_ioport_read: invalid opaque");
365 ioport_opaque[i] = opaque;
366 }
367 return 0;
368 }
369
370 /* size is the word size in byte */
371 int register_ioport_write(int start, int length, int size,
372 IOPortWriteFunc *func, void *opaque)
373 {
374 int i, bsize;
375
376 if (size == 1) {
377 bsize = 0;
378 } else if (size == 2) {
379 bsize = 1;
380 } else if (size == 4) {
381 bsize = 2;
382 } else {
383 hw_error("register_ioport_write: invalid size");
384 return -1;
385 }
386 for(i = start; i < start + length; i += size) {
387 ioport_write_table[bsize][i] = func;
388 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
389 hw_error("register_ioport_write: invalid opaque");
390 ioport_opaque[i] = opaque;
391 }
392 return 0;
393 }
394
395 void isa_unassign_ioport(int start, int length)
396 {
397 int i;
398
399 for(i = start; i < start + length; i++) {
400 ioport_read_table[0][i] = default_ioport_readb;
401 ioport_read_table[1][i] = default_ioport_readw;
402 ioport_read_table[2][i] = default_ioport_readl;
403
404 ioport_write_table[0][i] = default_ioport_writeb;
405 ioport_write_table[1][i] = default_ioport_writew;
406 ioport_write_table[2][i] = default_ioport_writel;
407 }
408 }
409
410 /***********************************************************/
411
412 void cpu_outb(CPUState *env, int addr, int val)
413 {
414 LOG_IOPORT("outb: %04x %02x\n", addr, val);
415 ioport_write(0, addr, val);
416 #ifdef USE_KQEMU
417 if (env)
418 env->last_io_time = cpu_get_time_fast();
419 #endif
420 }
421
422 void cpu_outw(CPUState *env, int addr, int val)
423 {
424 LOG_IOPORT("outw: %04x %04x\n", addr, val);
425 ioport_write(1, addr, val);
426 #ifdef USE_KQEMU
427 if (env)
428 env->last_io_time = cpu_get_time_fast();
429 #endif
430 }
431
432 void cpu_outl(CPUState *env, int addr, int val)
433 {
434 LOG_IOPORT("outl: %04x %08x\n", addr, val);
435 ioport_write(2, addr, val);
436 #ifdef USE_KQEMU
437 if (env)
438 env->last_io_time = cpu_get_time_fast();
439 #endif
440 }
441
442 int cpu_inb(CPUState *env, int addr)
443 {
444 int val;
445 val = ioport_read(0, addr);
446 LOG_IOPORT("inb : %04x %02x\n", addr, val);
447 #ifdef USE_KQEMU
448 if (env)
449 env->last_io_time = cpu_get_time_fast();
450 #endif
451 return val;
452 }
453
454 int cpu_inw(CPUState *env, int addr)
455 {
456 int val;
457 val = ioport_read(1, addr);
458 LOG_IOPORT("inw : %04x %04x\n", addr, val);
459 #ifdef USE_KQEMU
460 if (env)
461 env->last_io_time = cpu_get_time_fast();
462 #endif
463 return val;
464 }
465
466 int cpu_inl(CPUState *env, int addr)
467 {
468 int val;
469 val = ioport_read(2, addr);
470 LOG_IOPORT("inl : %04x %08x\n", addr, val);
471 #ifdef USE_KQEMU
472 if (env)
473 env->last_io_time = cpu_get_time_fast();
474 #endif
475 return val;
476 }
477
478 /***********************************************************/
479 void hw_error(const char *fmt, ...)
480 {
481 va_list ap;
482 CPUState *env;
483
484 va_start(ap, fmt);
485 fprintf(stderr, "qemu: hardware error: ");
486 vfprintf(stderr, fmt, ap);
487 fprintf(stderr, "\n");
488 for(env = first_cpu; env != NULL; env = env->next_cpu) {
489 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
490 #ifdef TARGET_I386
491 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
492 #else
493 cpu_dump_state(env, stderr, fprintf, 0);
494 #endif
495 }
496 va_end(ap);
497 abort();
498 }
499
500 /***************/
501 /* ballooning */
502
503 static QEMUBalloonEvent *qemu_balloon_event;
504 void *qemu_balloon_event_opaque;
505
506 void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
507 {
508 qemu_balloon_event = func;
509 qemu_balloon_event_opaque = opaque;
510 }
511
512 void qemu_balloon(ram_addr_t target)
513 {
514 if (qemu_balloon_event)
515 qemu_balloon_event(qemu_balloon_event_opaque, target);
516 }
517
518 ram_addr_t qemu_balloon_status(void)
519 {
520 if (qemu_balloon_event)
521 return qemu_balloon_event(qemu_balloon_event_opaque, 0);
522 return 0;
523 }
524
525 /***********************************************************/
526 /* keyboard/mouse */
527
528 static QEMUPutKBDEvent *qemu_put_kbd_event;
529 static void *qemu_put_kbd_event_opaque;
530 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
531 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
532
533 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
534 {
535 qemu_put_kbd_event_opaque = opaque;
536 qemu_put_kbd_event = func;
537 }
538
539 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
540 void *opaque, int absolute,
541 const char *name)
542 {
543 QEMUPutMouseEntry *s, *cursor;
544
545 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
546
547 s->qemu_put_mouse_event = func;
548 s->qemu_put_mouse_event_opaque = opaque;
549 s->qemu_put_mouse_event_absolute = absolute;
550 s->qemu_put_mouse_event_name = qemu_strdup(name);
551 s->next = NULL;
552
553 if (!qemu_put_mouse_event_head) {
554 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
555 return s;
556 }
557
558 cursor = qemu_put_mouse_event_head;
559 while (cursor->next != NULL)
560 cursor = cursor->next;
561
562 cursor->next = s;
563 qemu_put_mouse_event_current = s;
564
565 return s;
566 }
567
568 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
569 {
570 QEMUPutMouseEntry *prev = NULL, *cursor;
571
572 if (!qemu_put_mouse_event_head || entry == NULL)
573 return;
574
575 cursor = qemu_put_mouse_event_head;
576 while (cursor != NULL && cursor != entry) {
577 prev = cursor;
578 cursor = cursor->next;
579 }
580
581 if (cursor == NULL) // does not exist or list empty
582 return;
583 else if (prev == NULL) { // entry is head
584 qemu_put_mouse_event_head = cursor->next;
585 if (qemu_put_mouse_event_current == entry)
586 qemu_put_mouse_event_current = cursor->next;
587 qemu_free(entry->qemu_put_mouse_event_name);
588 qemu_free(entry);
589 return;
590 }
591
592 prev->next = entry->next;
593
594 if (qemu_put_mouse_event_current == entry)
595 qemu_put_mouse_event_current = prev;
596
597 qemu_free(entry->qemu_put_mouse_event_name);
598 qemu_free(entry);
599 }
600
601 void kbd_put_keycode(int keycode)
602 {
603 if (qemu_put_kbd_event) {
604 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
605 }
606 }
607
608 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
609 {
610 QEMUPutMouseEvent *mouse_event;
611 void *mouse_event_opaque;
612 int width;
613
614 if (!qemu_put_mouse_event_current) {
615 return;
616 }
617
618 mouse_event =
619 qemu_put_mouse_event_current->qemu_put_mouse_event;
620 mouse_event_opaque =
621 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
622
623 if (mouse_event) {
624 if (graphic_rotate) {
625 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
626 width = 0x7fff;
627 else
628 width = graphic_width - 1;
629 mouse_event(mouse_event_opaque,
630 width - dy, dx, dz, buttons_state);
631 } else
632 mouse_event(mouse_event_opaque,
633 dx, dy, dz, buttons_state);
634 }
635 }
636
637 int kbd_mouse_is_absolute(void)
638 {
639 if (!qemu_put_mouse_event_current)
640 return 0;
641
642 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
643 }
644
645 void do_info_mice(void)
646 {
647 QEMUPutMouseEntry *cursor;
648 int index = 0;
649
650 if (!qemu_put_mouse_event_head) {
651 term_printf("No mouse devices connected\n");
652 return;
653 }
654
655 term_printf("Mouse devices available:\n");
656 cursor = qemu_put_mouse_event_head;
657 while (cursor != NULL) {
658 term_printf("%c Mouse #%d: %s\n",
659 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
660 index, cursor->qemu_put_mouse_event_name);
661 index++;
662 cursor = cursor->next;
663 }
664 }
665
666 void do_mouse_set(int index)
667 {
668 QEMUPutMouseEntry *cursor;
669 int i = 0;
670
671 if (!qemu_put_mouse_event_head) {
672 term_printf("No mouse devices connected\n");
673 return;
674 }
675
676 cursor = qemu_put_mouse_event_head;
677 while (cursor != NULL && index != i) {
678 i++;
679 cursor = cursor->next;
680 }
681
682 if (cursor != NULL)
683 qemu_put_mouse_event_current = cursor;
684 else
685 term_printf("Mouse at given index not found\n");
686 }
687
688 /* compute with 96 bit intermediate result: (a*b)/c */
689 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
690 {
691 union {
692 uint64_t ll;
693 struct {
694 #ifdef WORDS_BIGENDIAN
695 uint32_t high, low;
696 #else
697 uint32_t low, high;
698 #endif
699 } l;
700 } u, res;
701 uint64_t rl, rh;
702
703 u.ll = a;
704 rl = (uint64_t)u.l.low * (uint64_t)b;
705 rh = (uint64_t)u.l.high * (uint64_t)b;
706 rh += (rl >> 32);
707 res.l.high = rh / c;
708 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
709 return res.ll;
710 }
711
712 /***********************************************************/
713 /* real time host monotonic timer */
714
715 #define QEMU_TIMER_BASE 1000000000LL
716
717 #ifdef WIN32
718
719 static int64_t clock_freq;
720
721 static void init_get_clock(void)
722 {
723 LARGE_INTEGER freq;
724 int ret;
725 ret = QueryPerformanceFrequency(&freq);
726 if (ret == 0) {
727 fprintf(stderr, "Could not calibrate ticks\n");
728 exit(1);
729 }
730 clock_freq = freq.QuadPart;
731 }
732
733 static int64_t get_clock(void)
734 {
735 LARGE_INTEGER ti;
736 QueryPerformanceCounter(&ti);
737 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
738 }
739
740 #else
741
742 static int use_rt_clock;
743
744 static void init_get_clock(void)
745 {
746 use_rt_clock = 0;
747 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
748 {
749 struct timespec ts;
750 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
751 use_rt_clock = 1;
752 }
753 }
754 #endif
755 }
756
757 static int64_t get_clock(void)
758 {
759 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
760 if (use_rt_clock) {
761 struct timespec ts;
762 clock_gettime(CLOCK_MONOTONIC, &ts);
763 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
764 } else
765 #endif
766 {
767 /* XXX: using gettimeofday leads to problems if the date
768 changes, so it should be avoided. */
769 struct timeval tv;
770 gettimeofday(&tv, NULL);
771 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
772 }
773 }
774 #endif
775
776 /* Return the virtual CPU time, based on the instruction counter. */
777 static int64_t cpu_get_icount(void)
778 {
779 int64_t icount;
780 CPUState *env = cpu_single_env;;
781 icount = qemu_icount;
782 if (env) {
783 if (!can_do_io(env))
784 fprintf(stderr, "Bad clock read\n");
785 icount -= (env->icount_decr.u16.low + env->icount_extra);
786 }
787 return qemu_icount_bias + (icount << icount_time_shift);
788 }
789
790 /***********************************************************/
791 /* guest cycle counter */
792
793 static int64_t cpu_ticks_prev;
794 static int64_t cpu_ticks_offset;
795 static int64_t cpu_clock_offset;
796 static int cpu_ticks_enabled;
797
798 /* return the host CPU cycle counter and handle stop/restart */
799 int64_t cpu_get_ticks(void)
800 {
801 if (use_icount) {
802 return cpu_get_icount();
803 }
804 if (!cpu_ticks_enabled) {
805 return cpu_ticks_offset;
806 } else {
807 int64_t ticks;
808 ticks = cpu_get_real_ticks();
809 if (cpu_ticks_prev > ticks) {
810 /* Note: non increasing ticks may happen if the host uses
811 software suspend */
812 cpu_ticks_offset += cpu_ticks_prev - ticks;
813 }
814 cpu_ticks_prev = ticks;
815 return ticks + cpu_ticks_offset;
816 }
817 }
818
819 /* return the host CPU monotonic timer and handle stop/restart */
820 static int64_t cpu_get_clock(void)
821 {
822 int64_t ti;
823 if (!cpu_ticks_enabled) {
824 return cpu_clock_offset;
825 } else {
826 ti = get_clock();
827 return ti + cpu_clock_offset;
828 }
829 }
830
831 /* enable cpu_get_ticks() */
832 void cpu_enable_ticks(void)
833 {
834 if (!cpu_ticks_enabled) {
835 cpu_ticks_offset -= cpu_get_real_ticks();
836 cpu_clock_offset -= get_clock();
837 cpu_ticks_enabled = 1;
838 }
839 }
840
841 /* disable cpu_get_ticks() : the clock is stopped. You must not call
842 cpu_get_ticks() after that. */
843 void cpu_disable_ticks(void)
844 {
845 if (cpu_ticks_enabled) {
846 cpu_ticks_offset = cpu_get_ticks();
847 cpu_clock_offset = cpu_get_clock();
848 cpu_ticks_enabled = 0;
849 }
850 }
851
852 /***********************************************************/
853 /* timers */
854
855 #define QEMU_TIMER_REALTIME 0
856 #define QEMU_TIMER_VIRTUAL 1
857
858 struct QEMUClock {
859 int type;
860 /* XXX: add frequency */
861 };
862
863 struct QEMUTimer {
864 QEMUClock *clock;
865 int64_t expire_time;
866 QEMUTimerCB *cb;
867 void *opaque;
868 struct QEMUTimer *next;
869 };
870
871 struct qemu_alarm_timer {
872 char const *name;
873 unsigned int flags;
874
875 int (*start)(struct qemu_alarm_timer *t);
876 void (*stop)(struct qemu_alarm_timer *t);
877 void (*rearm)(struct qemu_alarm_timer *t);
878 void *priv;
879 };
880
881 #define ALARM_FLAG_DYNTICKS 0x1
882 #define ALARM_FLAG_EXPIRED 0x2
883
884 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
885 {
886 return t->flags & ALARM_FLAG_DYNTICKS;
887 }
888
889 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
890 {
891 if (!alarm_has_dynticks(t))
892 return;
893
894 t->rearm(t);
895 }
896
897 /* TODO: MIN_TIMER_REARM_US should be optimized */
898 #define MIN_TIMER_REARM_US 250
899
900 static struct qemu_alarm_timer *alarm_timer;
901 #ifndef _WIN32
902 static int alarm_timer_rfd, alarm_timer_wfd;
903 #endif
904
905 #ifdef _WIN32
906
907 struct qemu_alarm_win32 {
908 MMRESULT timerId;
909 HANDLE host_alarm;
910 unsigned int period;
911 } alarm_win32_data = {0, NULL, -1};
912
913 static int win32_start_timer(struct qemu_alarm_timer *t);
914 static void win32_stop_timer(struct qemu_alarm_timer *t);
915 static void win32_rearm_timer(struct qemu_alarm_timer *t);
916
917 #else
918
919 static int unix_start_timer(struct qemu_alarm_timer *t);
920 static void unix_stop_timer(struct qemu_alarm_timer *t);
921
922 #ifdef __linux__
923
924 static int dynticks_start_timer(struct qemu_alarm_timer *t);
925 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
926 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
927
928 static int hpet_start_timer(struct qemu_alarm_timer *t);
929 static void hpet_stop_timer(struct qemu_alarm_timer *t);
930
931 static int rtc_start_timer(struct qemu_alarm_timer *t);
932 static void rtc_stop_timer(struct qemu_alarm_timer *t);
933
934 #endif /* __linux__ */
935
936 #endif /* _WIN32 */
937
938 /* Correlation between real and virtual time is always going to be
939 fairly approximate, so ignore small variation.
940 When the guest is idle real and virtual time will be aligned in
941 the IO wait loop. */
942 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
943
944 static void icount_adjust(void)
945 {
946 int64_t cur_time;
947 int64_t cur_icount;
948 int64_t delta;
949 static int64_t last_delta;
950 /* If the VM is not running, then do nothing. */
951 if (!vm_running)
952 return;
953
954 cur_time = cpu_get_clock();
955 cur_icount = qemu_get_clock(vm_clock);
956 delta = cur_icount - cur_time;
957 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
958 if (delta > 0
959 && last_delta + ICOUNT_WOBBLE < delta * 2
960 && icount_time_shift > 0) {
961 /* The guest is getting too far ahead. Slow time down. */
962 icount_time_shift--;
963 }
964 if (delta < 0
965 && last_delta - ICOUNT_WOBBLE > delta * 2
966 && icount_time_shift < MAX_ICOUNT_SHIFT) {
967 /* The guest is getting too far behind. Speed time up. */
968 icount_time_shift++;
969 }
970 last_delta = delta;
971 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
972 }
973
974 static void icount_adjust_rt(void * opaque)
975 {
976 qemu_mod_timer(icount_rt_timer,
977 qemu_get_clock(rt_clock) + 1000);
978 icount_adjust();
979 }
980
981 static void icount_adjust_vm(void * opaque)
982 {
983 qemu_mod_timer(icount_vm_timer,
984 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
985 icount_adjust();
986 }
987
988 static void init_icount_adjust(void)
989 {
990 /* Have both realtime and virtual time triggers for speed adjustment.
991 The realtime trigger catches emulated time passing too slowly,
992 the virtual time trigger catches emulated time passing too fast.
993 Realtime triggers occur even when idle, so use them less frequently
994 than VM triggers. */
995 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
996 qemu_mod_timer(icount_rt_timer,
997 qemu_get_clock(rt_clock) + 1000);
998 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
999 qemu_mod_timer(icount_vm_timer,
1000 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1001 }
1002
1003 static struct qemu_alarm_timer alarm_timers[] = {
1004 #ifndef _WIN32
1005 #ifdef __linux__
1006 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1007 dynticks_stop_timer, dynticks_rearm_timer, NULL},
1008 /* HPET - if available - is preferred */
1009 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1010 /* ...otherwise try RTC */
1011 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1012 #endif
1013 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1014 #else
1015 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1016 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1017 {"win32", 0, win32_start_timer,
1018 win32_stop_timer, NULL, &alarm_win32_data},
1019 #endif
1020 {NULL, }
1021 };
1022
1023 static void show_available_alarms(void)
1024 {
1025 int i;
1026
1027 printf("Available alarm timers, in order of precedence:\n");
1028 for (i = 0; alarm_timers[i].name; i++)
1029 printf("%s\n", alarm_timers[i].name);
1030 }
1031
1032 static void configure_alarms(char const *opt)
1033 {
1034 int i;
1035 int cur = 0;
1036 int count = ARRAY_SIZE(alarm_timers) - 1;
1037 char *arg;
1038 char *name;
1039 struct qemu_alarm_timer tmp;
1040
1041 if (!strcmp(opt, "?")) {
1042 show_available_alarms();
1043 exit(0);
1044 }
1045
1046 arg = strdup(opt);
1047
1048 /* Reorder the array */
1049 name = strtok(arg, ",");
1050 while (name) {
1051 for (i = 0; i < count && alarm_timers[i].name; i++) {
1052 if (!strcmp(alarm_timers[i].name, name))
1053 break;
1054 }
1055
1056 if (i == count) {
1057 fprintf(stderr, "Unknown clock %s\n", name);
1058 goto next;
1059 }
1060
1061 if (i < cur)
1062 /* Ignore */
1063 goto next;
1064
1065 /* Swap */
1066 tmp = alarm_timers[i];
1067 alarm_timers[i] = alarm_timers[cur];
1068 alarm_timers[cur] = tmp;
1069
1070 cur++;
1071 next:
1072 name = strtok(NULL, ",");
1073 }
1074
1075 free(arg);
1076
1077 if (cur) {
1078 /* Disable remaining timers */
1079 for (i = cur; i < count; i++)
1080 alarm_timers[i].name = NULL;
1081 } else {
1082 show_available_alarms();
1083 exit(1);
1084 }
1085 }
1086
1087 QEMUClock *rt_clock;
1088 QEMUClock *vm_clock;
1089
1090 static QEMUTimer *active_timers[2];
1091
1092 static QEMUClock *qemu_new_clock(int type)
1093 {
1094 QEMUClock *clock;
1095 clock = qemu_mallocz(sizeof(QEMUClock));
1096 clock->type = type;
1097 return clock;
1098 }
1099
1100 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1101 {
1102 QEMUTimer *ts;
1103
1104 ts = qemu_mallocz(sizeof(QEMUTimer));
1105 ts->clock = clock;
1106 ts->cb = cb;
1107 ts->opaque = opaque;
1108 return ts;
1109 }
1110
1111 void qemu_free_timer(QEMUTimer *ts)
1112 {
1113 qemu_free(ts);
1114 }
1115
1116 /* stop a timer, but do not dealloc it */
1117 void qemu_del_timer(QEMUTimer *ts)
1118 {
1119 QEMUTimer **pt, *t;
1120
1121 /* NOTE: this code must be signal safe because
1122 qemu_timer_expired() can be called from a signal. */
1123 pt = &active_timers[ts->clock->type];
1124 for(;;) {
1125 t = *pt;
1126 if (!t)
1127 break;
1128 if (t == ts) {
1129 *pt = t->next;
1130 break;
1131 }
1132 pt = &t->next;
1133 }
1134 }
1135
1136 /* modify the current timer so that it will be fired when current_time
1137 >= expire_time. The corresponding callback will be called. */
1138 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1139 {
1140 QEMUTimer **pt, *t;
1141
1142 qemu_del_timer(ts);
1143
1144 /* add the timer in the sorted list */
1145 /* NOTE: this code must be signal safe because
1146 qemu_timer_expired() can be called from a signal. */
1147 pt = &active_timers[ts->clock->type];
1148 for(;;) {
1149 t = *pt;
1150 if (!t)
1151 break;
1152 if (t->expire_time > expire_time)
1153 break;
1154 pt = &t->next;
1155 }
1156 ts->expire_time = expire_time;
1157 ts->next = *pt;
1158 *pt = ts;
1159
1160 /* Rearm if necessary */
1161 if (pt == &active_timers[ts->clock->type]) {
1162 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1163 qemu_rearm_alarm_timer(alarm_timer);
1164 }
1165 /* Interrupt execution to force deadline recalculation. */
1166 if (use_icount && cpu_single_env) {
1167 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1168 }
1169 }
1170 }
1171
1172 int qemu_timer_pending(QEMUTimer *ts)
1173 {
1174 QEMUTimer *t;
1175 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1176 if (t == ts)
1177 return 1;
1178 }
1179 return 0;
1180 }
1181
1182 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1183 {
1184 if (!timer_head)
1185 return 0;
1186 return (timer_head->expire_time <= current_time);
1187 }
1188
1189 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1190 {
1191 QEMUTimer *ts;
1192
1193 for(;;) {
1194 ts = *ptimer_head;
1195 if (!ts || ts->expire_time > current_time)
1196 break;
1197 /* remove timer from the list before calling the callback */
1198 *ptimer_head = ts->next;
1199 ts->next = NULL;
1200
1201 /* run the callback (the timer list can be modified) */
1202 ts->cb(ts->opaque);
1203 }
1204 }
1205
1206 int64_t qemu_get_clock(QEMUClock *clock)
1207 {
1208 switch(clock->type) {
1209 case QEMU_TIMER_REALTIME:
1210 return get_clock() / 1000000;
1211 default:
1212 case QEMU_TIMER_VIRTUAL:
1213 if (use_icount) {
1214 return cpu_get_icount();
1215 } else {
1216 return cpu_get_clock();
1217 }
1218 }
1219 }
1220
1221 static void init_timers(void)
1222 {
1223 init_get_clock();
1224 ticks_per_sec = QEMU_TIMER_BASE;
1225 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1226 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1227 }
1228
1229 /* save a timer */
1230 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1231 {
1232 uint64_t expire_time;
1233
1234 if (qemu_timer_pending(ts)) {
1235 expire_time = ts->expire_time;
1236 } else {
1237 expire_time = -1;
1238 }
1239 qemu_put_be64(f, expire_time);
1240 }
1241
1242 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1243 {
1244 uint64_t expire_time;
1245
1246 expire_time = qemu_get_be64(f);
1247 if (expire_time != -1) {
1248 qemu_mod_timer(ts, expire_time);
1249 } else {
1250 qemu_del_timer(ts);
1251 }
1252 }
1253
1254 static void timer_save(QEMUFile *f, void *opaque)
1255 {
1256 if (cpu_ticks_enabled) {
1257 hw_error("cannot save state if virtual timers are running");
1258 }
1259 qemu_put_be64(f, cpu_ticks_offset);
1260 qemu_put_be64(f, ticks_per_sec);
1261 qemu_put_be64(f, cpu_clock_offset);
1262 }
1263
1264 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1265 {
1266 if (version_id != 1 && version_id != 2)
1267 return -EINVAL;
1268 if (cpu_ticks_enabled) {
1269 return -EINVAL;
1270 }
1271 cpu_ticks_offset=qemu_get_be64(f);
1272 ticks_per_sec=qemu_get_be64(f);
1273 if (version_id == 2) {
1274 cpu_clock_offset=qemu_get_be64(f);
1275 }
1276 return 0;
1277 }
1278
1279 #ifdef _WIN32
1280 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1281 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1282 #else
1283 static void host_alarm_handler(int host_signum)
1284 #endif
1285 {
1286 #if 0
1287 #define DISP_FREQ 1000
1288 {
1289 static int64_t delta_min = INT64_MAX;
1290 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1291 static int count;
1292 ti = qemu_get_clock(vm_clock);
1293 if (last_clock != 0) {
1294 delta = ti - last_clock;
1295 if (delta < delta_min)
1296 delta_min = delta;
1297 if (delta > delta_max)
1298 delta_max = delta;
1299 delta_cum += delta;
1300 if (++count == DISP_FREQ) {
1301 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1302 muldiv64(delta_min, 1000000, ticks_per_sec),
1303 muldiv64(delta_max, 1000000, ticks_per_sec),
1304 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1305 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1306 count = 0;
1307 delta_min = INT64_MAX;
1308 delta_max = 0;
1309 delta_cum = 0;
1310 }
1311 }
1312 last_clock = ti;
1313 }
1314 #endif
1315 if (alarm_has_dynticks(alarm_timer) ||
1316 (!use_icount &&
1317 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1318 qemu_get_clock(vm_clock))) ||
1319 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1320 qemu_get_clock(rt_clock))) {
1321 CPUState *env = next_cpu;
1322
1323 #ifdef _WIN32
1324 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1325 SetEvent(data->host_alarm);
1326 #else
1327 static const char byte = 0;
1328 write(alarm_timer_wfd, &byte, sizeof(byte));
1329 #endif
1330 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1331
1332 if (env) {
1333 /* stop the currently executing cpu because a timer occured */
1334 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1335 #ifdef USE_KQEMU
1336 if (env->kqemu_enabled) {
1337 kqemu_cpu_interrupt(env);
1338 }
1339 #endif
1340 }
1341 event_pending = 1;
1342 }
1343 }
1344
1345 static int64_t qemu_next_deadline(void)
1346 {
1347 int64_t delta;
1348
1349 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1350 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1351 qemu_get_clock(vm_clock);
1352 } else {
1353 /* To avoid problems with overflow limit this to 2^32. */
1354 delta = INT32_MAX;
1355 }
1356
1357 if (delta < 0)
1358 delta = 0;
1359
1360 return delta;
1361 }
1362
1363 #if defined(__linux__) || defined(_WIN32)
1364 static uint64_t qemu_next_deadline_dyntick(void)
1365 {
1366 int64_t delta;
1367 int64_t rtdelta;
1368
1369 if (use_icount)
1370 delta = INT32_MAX;
1371 else
1372 delta = (qemu_next_deadline() + 999) / 1000;
1373
1374 if (active_timers[QEMU_TIMER_REALTIME]) {
1375 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1376 qemu_get_clock(rt_clock))*1000;
1377 if (rtdelta < delta)
1378 delta = rtdelta;
1379 }
1380
1381 if (delta < MIN_TIMER_REARM_US)
1382 delta = MIN_TIMER_REARM_US;
1383
1384 return delta;
1385 }
1386 #endif
1387
1388 #ifndef _WIN32
1389
1390 /* Sets a specific flag */
1391 static int fcntl_setfl(int fd, int flag)
1392 {
1393 int flags;
1394
1395 flags = fcntl(fd, F_GETFL);
1396 if (flags == -1)
1397 return -errno;
1398
1399 if (fcntl(fd, F_SETFL, flags | flag) == -1)
1400 return -errno;
1401
1402 return 0;
1403 }
1404
1405 #if defined(__linux__)
1406
1407 #define RTC_FREQ 1024
1408
1409 static void enable_sigio_timer(int fd)
1410 {
1411 struct sigaction act;
1412
1413 /* timer signal */
1414 sigfillset(&act.sa_mask);
1415 act.sa_flags = 0;
1416 act.sa_handler = host_alarm_handler;
1417
1418 sigaction(SIGIO, &act, NULL);
1419 fcntl_setfl(fd, O_ASYNC);
1420 fcntl(fd, F_SETOWN, getpid());
1421 }
1422
1423 static int hpet_start_timer(struct qemu_alarm_timer *t)
1424 {
1425 struct hpet_info info;
1426 int r, fd;
1427
1428 fd = open("/dev/hpet", O_RDONLY);
1429 if (fd < 0)
1430 return -1;
1431
1432 /* Set frequency */
1433 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1434 if (r < 0) {
1435 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1436 "error, but for better emulation accuracy type:\n"
1437 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1438 goto fail;
1439 }
1440
1441 /* Check capabilities */
1442 r = ioctl(fd, HPET_INFO, &info);
1443 if (r < 0)
1444 goto fail;
1445
1446 /* Enable periodic mode */
1447 r = ioctl(fd, HPET_EPI, 0);
1448 if (info.hi_flags && (r < 0))
1449 goto fail;
1450
1451 /* Enable interrupt */
1452 r = ioctl(fd, HPET_IE_ON, 0);
1453 if (r < 0)
1454 goto fail;
1455
1456 enable_sigio_timer(fd);
1457 t->priv = (void *)(long)fd;
1458
1459 return 0;
1460 fail:
1461 close(fd);
1462 return -1;
1463 }
1464
1465 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1466 {
1467 int fd = (long)t->priv;
1468
1469 close(fd);
1470 }
1471
1472 static int rtc_start_timer(struct qemu_alarm_timer *t)
1473 {
1474 int rtc_fd;
1475 unsigned long current_rtc_freq = 0;
1476
1477 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1478 if (rtc_fd < 0)
1479 return -1;
1480 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1481 if (current_rtc_freq != RTC_FREQ &&
1482 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1483 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1484 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1485 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1486 goto fail;
1487 }
1488 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1489 fail:
1490 close(rtc_fd);
1491 return -1;
1492 }
1493
1494 enable_sigio_timer(rtc_fd);
1495
1496 t->priv = (void *)(long)rtc_fd;
1497
1498 return 0;
1499 }
1500
1501 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1502 {
1503 int rtc_fd = (long)t->priv;
1504
1505 close(rtc_fd);
1506 }
1507
1508 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1509 {
1510 struct sigevent ev;
1511 timer_t host_timer;
1512 struct sigaction act;
1513
1514 sigfillset(&act.sa_mask);
1515 act.sa_flags = 0;
1516 act.sa_handler = host_alarm_handler;
1517
1518 sigaction(SIGALRM, &act, NULL);
1519
1520 ev.sigev_value.sival_int = 0;
1521 ev.sigev_notify = SIGEV_SIGNAL;
1522 ev.sigev_signo = SIGALRM;
1523
1524 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1525 perror("timer_create");
1526
1527 /* disable dynticks */
1528 fprintf(stderr, "Dynamic Ticks disabled\n");
1529
1530 return -1;
1531 }
1532
1533 t->priv = (void *)(long)host_timer;
1534
1535 return 0;
1536 }
1537
1538 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1539 {
1540 timer_t host_timer = (timer_t)(long)t->priv;
1541
1542 timer_delete(host_timer);
1543 }
1544
1545 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1546 {
1547 timer_t host_timer = (timer_t)(long)t->priv;
1548 struct itimerspec timeout;
1549 int64_t nearest_delta_us = INT64_MAX;
1550 int64_t current_us;
1551
1552 if (!active_timers[QEMU_TIMER_REALTIME] &&
1553 !active_timers[QEMU_TIMER_VIRTUAL])
1554 return;
1555
1556 nearest_delta_us = qemu_next_deadline_dyntick();
1557
1558 /* check whether a timer is already running */
1559 if (timer_gettime(host_timer, &timeout)) {
1560 perror("gettime");
1561 fprintf(stderr, "Internal timer error: aborting\n");
1562 exit(1);
1563 }
1564 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1565 if (current_us && current_us <= nearest_delta_us)
1566 return;
1567
1568 timeout.it_interval.tv_sec = 0;
1569 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1570 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1571 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1572 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1573 perror("settime");
1574 fprintf(stderr, "Internal timer error: aborting\n");
1575 exit(1);
1576 }
1577 }
1578
1579 #endif /* defined(__linux__) */
1580
1581 static int unix_start_timer(struct qemu_alarm_timer *t)
1582 {
1583 struct sigaction act;
1584 struct itimerval itv;
1585 int err;
1586
1587 /* timer signal */
1588 sigfillset(&act.sa_mask);
1589 act.sa_flags = 0;
1590 act.sa_handler = host_alarm_handler;
1591
1592 sigaction(SIGALRM, &act, NULL);
1593
1594 itv.it_interval.tv_sec = 0;
1595 /* for i386 kernel 2.6 to get 1 ms */
1596 itv.it_interval.tv_usec = 999;
1597 itv.it_value.tv_sec = 0;
1598 itv.it_value.tv_usec = 10 * 1000;
1599
1600 err = setitimer(ITIMER_REAL, &itv, NULL);
1601 if (err)
1602 return -1;
1603
1604 return 0;
1605 }
1606
1607 static void unix_stop_timer(struct qemu_alarm_timer *t)
1608 {
1609 struct itimerval itv;
1610
1611 memset(&itv, 0, sizeof(itv));
1612 setitimer(ITIMER_REAL, &itv, NULL);
1613 }
1614
1615 #endif /* !defined(_WIN32) */
1616
1617 static void try_to_rearm_timer(void *opaque)
1618 {
1619 struct qemu_alarm_timer *t = opaque;
1620 #ifndef _WIN32
1621 ssize_t len;
1622
1623 /* Drain the notify pipe */
1624 do {
1625 char buffer[512];
1626 len = read(alarm_timer_rfd, buffer, sizeof(buffer));
1627 } while ((len == -1 && errno == EINTR) || len > 0);
1628 #endif
1629
1630 if (t->flags & ALARM_FLAG_EXPIRED) {
1631 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
1632 qemu_rearm_alarm_timer(alarm_timer);
1633 }
1634 }
1635
1636 #ifdef _WIN32
1637
1638 static int win32_start_timer(struct qemu_alarm_timer *t)
1639 {
1640 TIMECAPS tc;
1641 struct qemu_alarm_win32 *data = t->priv;
1642 UINT flags;
1643
1644 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1645 if (!data->host_alarm) {
1646 perror("Failed CreateEvent");
1647 return -1;
1648 }
1649
1650 memset(&tc, 0, sizeof(tc));
1651 timeGetDevCaps(&tc, sizeof(tc));
1652
1653 if (data->period < tc.wPeriodMin)
1654 data->period = tc.wPeriodMin;
1655
1656 timeBeginPeriod(data->period);
1657
1658 flags = TIME_CALLBACK_FUNCTION;
1659 if (alarm_has_dynticks(t))
1660 flags |= TIME_ONESHOT;
1661 else
1662 flags |= TIME_PERIODIC;
1663
1664 data->timerId = timeSetEvent(1, // interval (ms)
1665 data->period, // resolution
1666 host_alarm_handler, // function
1667 (DWORD)t, // parameter
1668 flags);
1669
1670 if (!data->timerId) {
1671 perror("Failed to initialize win32 alarm timer");
1672
1673 timeEndPeriod(data->period);
1674 CloseHandle(data->host_alarm);
1675 return -1;
1676 }
1677
1678 qemu_add_wait_object(data->host_alarm, try_to_rearm_timer, t);
1679
1680 return 0;
1681 }
1682
1683 static void win32_stop_timer(struct qemu_alarm_timer *t)
1684 {
1685 struct qemu_alarm_win32 *data = t->priv;
1686
1687 timeKillEvent(data->timerId);
1688 timeEndPeriod(data->period);
1689
1690 CloseHandle(data->host_alarm);
1691 }
1692
1693 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1694 {
1695 struct qemu_alarm_win32 *data = t->priv;
1696 uint64_t nearest_delta_us;
1697
1698 if (!active_timers[QEMU_TIMER_REALTIME] &&
1699 !active_timers[QEMU_TIMER_VIRTUAL])
1700 return;
1701
1702 nearest_delta_us = qemu_next_deadline_dyntick();
1703 nearest_delta_us /= 1000;
1704
1705 timeKillEvent(data->timerId);
1706
1707 data->timerId = timeSetEvent(1,
1708 data->period,
1709 host_alarm_handler,
1710 (DWORD)t,
1711 TIME_ONESHOT | TIME_PERIODIC);
1712
1713 if (!data->timerId) {
1714 perror("Failed to re-arm win32 alarm timer");
1715
1716 timeEndPeriod(data->period);
1717 CloseHandle(data->host_alarm);
1718 exit(1);
1719 }
1720 }
1721
1722 #endif /* _WIN32 */
1723
1724 static int init_timer_alarm(void)
1725 {
1726 struct qemu_alarm_timer *t = NULL;
1727 int i, err = -1;
1728
1729 #ifndef _WIN32
1730 int fds[2];
1731
1732 err = pipe(fds);
1733 if (err == -1)
1734 return -errno;
1735
1736 err = fcntl_setfl(fds[0], O_NONBLOCK);
1737 if (err < 0)
1738 goto fail;
1739
1740 err = fcntl_setfl(fds[1], O_NONBLOCK);
1741 if (err < 0)
1742 goto fail;
1743
1744 alarm_timer_rfd = fds[0];
1745 alarm_timer_wfd = fds[1];
1746 #endif
1747
1748 for (i = 0; alarm_timers[i].name; i++) {
1749 t = &alarm_timers[i];
1750
1751 err = t->start(t);
1752 if (!err)
1753 break;
1754 }
1755
1756 if (err) {
1757 err = -ENOENT;
1758 goto fail;
1759 }
1760
1761 #ifndef _WIN32
1762 qemu_set_fd_handler2(alarm_timer_rfd, NULL,
1763 try_to_rearm_timer, NULL, t);
1764 #endif
1765
1766 alarm_timer = t;
1767
1768 return 0;
1769
1770 fail:
1771 #ifndef _WIN32
1772 close(fds[0]);
1773 close(fds[1]);
1774 #endif
1775 return err;
1776 }
1777
1778 static void quit_timers(void)
1779 {
1780 alarm_timer->stop(alarm_timer);
1781 alarm_timer = NULL;
1782 }
1783
1784 /***********************************************************/
1785 /* host time/date access */
1786 void qemu_get_timedate(struct tm *tm, int offset)
1787 {
1788 time_t ti;
1789 struct tm *ret;
1790
1791 time(&ti);
1792 ti += offset;
1793 if (rtc_date_offset == -1) {
1794 if (rtc_utc)
1795 ret = gmtime(&ti);
1796 else
1797 ret = localtime(&ti);
1798 } else {
1799 ti -= rtc_date_offset;
1800 ret = gmtime(&ti);
1801 }
1802
1803 memcpy(tm, ret, sizeof(struct tm));
1804 }
1805
1806 int qemu_timedate_diff(struct tm *tm)
1807 {
1808 time_t seconds;
1809
1810 if (rtc_date_offset == -1)
1811 if (rtc_utc)
1812 seconds = mktimegm(tm);
1813 else
1814 seconds = mktime(tm);
1815 else
1816 seconds = mktimegm(tm) + rtc_date_offset;
1817
1818 return seconds - time(NULL);
1819 }
1820
1821 #ifdef _WIN32
1822 static void socket_cleanup(void)
1823 {
1824 WSACleanup();
1825 }
1826
1827 static int socket_init(void)
1828 {
1829 WSADATA Data;
1830 int ret, err;
1831
1832 ret = WSAStartup(MAKEWORD(2,2), &Data);
1833 if (ret != 0) {
1834 err = WSAGetLastError();
1835 fprintf(stderr, "WSAStartup: %d\n", err);
1836 return -1;
1837 }
1838 atexit(socket_cleanup);
1839 return 0;
1840 }
1841 #endif
1842
1843 const char *get_opt_name(char *buf, int buf_size, const char *p)
1844 {
1845 char *q;
1846
1847 q = buf;
1848 while (*p != '\0' && *p != '=') {
1849 if (q && (q - buf) < buf_size - 1)
1850 *q++ = *p;
1851 p++;
1852 }
1853 if (q)
1854 *q = '\0';
1855
1856 return p;
1857 }
1858
1859 const char *get_opt_value(char *buf, int buf_size, const char *p)
1860 {
1861 char *q;
1862
1863 q = buf;
1864 while (*p != '\0') {
1865 if (*p == ',') {
1866 if (*(p + 1) != ',')
1867 break;
1868 p++;
1869 }
1870 if (q && (q - buf) < buf_size - 1)
1871 *q++ = *p;
1872 p++;
1873 }
1874 if (q)
1875 *q = '\0';
1876
1877 return p;
1878 }
1879
1880 int get_param_value(char *buf, int buf_size,
1881 const char *tag, const char *str)
1882 {
1883 const char *p;
1884 char option[128];
1885
1886 p = str;
1887 for(;;) {
1888 p = get_opt_name(option, sizeof(option), p);
1889 if (*p != '=')
1890 break;
1891 p++;
1892 if (!strcmp(tag, option)) {
1893 (void)get_opt_value(buf, buf_size, p);
1894 return strlen(buf);
1895 } else {
1896 p = get_opt_value(NULL, 0, p);
1897 }
1898 if (*p != ',')
1899 break;
1900 p++;
1901 }
1902 return 0;
1903 }
1904
1905 int check_params(char *buf, int buf_size,
1906 const char * const *params, const char *str)
1907 {
1908 const char *p;
1909 int i;
1910
1911 p = str;
1912 for(;;) {
1913 p = get_opt_name(buf, buf_size, p);
1914 if (*p != '=')
1915 return -1;
1916 p++;
1917 for(i = 0; params[i] != NULL; i++)
1918 if (!strcmp(params[i], buf))
1919 break;
1920 if (params[i] == NULL)
1921 return -1;
1922 p = get_opt_value(NULL, 0, p);
1923 if (*p != ',')
1924 break;
1925 p++;
1926 }
1927 return 0;
1928 }
1929
1930 /***********************************************************/
1931 /* Bluetooth support */
1932 static int nb_hcis;
1933 static int cur_hci;
1934 static struct HCIInfo *hci_table[MAX_NICS];
1935
1936 static struct bt_vlan_s {
1937 struct bt_scatternet_s net;
1938 int id;
1939 struct bt_vlan_s *next;
1940 } *first_bt_vlan;
1941
1942 /* find or alloc a new bluetooth "VLAN" */
1943 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1944 {
1945 struct bt_vlan_s **pvlan, *vlan;
1946 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1947 if (vlan->id == id)
1948 return &vlan->net;
1949 }
1950 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1951 vlan->id = id;
1952 pvlan = &first_bt_vlan;
1953 while (*pvlan != NULL)
1954 pvlan = &(*pvlan)->next;
1955 *pvlan = vlan;
1956 return &vlan->net;
1957 }
1958
1959 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1960 {
1961 }
1962
1963 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1964 {
1965 return -ENOTSUP;
1966 }
1967
1968 static struct HCIInfo null_hci = {
1969 .cmd_send = null_hci_send,
1970 .sco_send = null_hci_send,
1971 .acl_send = null_hci_send,
1972 .bdaddr_set = null_hci_addr_set,
1973 };
1974
1975 struct HCIInfo *qemu_next_hci(void)
1976 {
1977 if (cur_hci == nb_hcis)
1978 return &null_hci;
1979
1980 return hci_table[cur_hci++];
1981 }
1982
1983 static struct HCIInfo *hci_init(const char *str)
1984 {
1985 char *endp;
1986 struct bt_scatternet_s *vlan = 0;
1987
1988 if (!strcmp(str, "null"))
1989 /* null */
1990 return &null_hci;
1991 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1992 /* host[:hciN] */
1993 return bt_host_hci(str[4] ? str + 5 : "hci0");
1994 else if (!strncmp(str, "hci", 3)) {
1995 /* hci[,vlan=n] */
1996 if (str[3]) {
1997 if (!strncmp(str + 3, ",vlan=", 6)) {
1998 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1999 if (*endp)
2000 vlan = 0;
2001 }
2002 } else
2003 vlan = qemu_find_bt_vlan(0);
2004 if (vlan)
2005 return bt_new_hci(vlan);
2006 }
2007
2008 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
2009
2010 return 0;
2011 }
2012
2013 static int bt_hci_parse(const char *str)
2014 {
2015 struct HCIInfo *hci;
2016 bdaddr_t bdaddr;
2017
2018 if (nb_hcis >= MAX_NICS) {
2019 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
2020 return -1;
2021 }
2022
2023 hci = hci_init(str);
2024 if (!hci)
2025 return -1;
2026
2027 bdaddr.b[0] = 0x52;
2028 bdaddr.b[1] = 0x54;
2029 bdaddr.b[2] = 0x00;
2030 bdaddr.b[3] = 0x12;
2031 bdaddr.b[4] = 0x34;
2032 bdaddr.b[5] = 0x56 + nb_hcis;
2033 hci->bdaddr_set(hci, bdaddr.b);
2034
2035 hci_table[nb_hcis++] = hci;
2036
2037 return 0;
2038 }
2039
2040 static void bt_vhci_add(int vlan_id)
2041 {
2042 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
2043
2044 if (!vlan->slave)
2045 fprintf(stderr, "qemu: warning: adding a VHCI to "
2046 "an empty scatternet %i\n", vlan_id);
2047
2048 bt_vhci_init(bt_new_hci(vlan));
2049 }
2050
2051 static struct bt_device_s *bt_device_add(const char *opt)
2052 {
2053 struct bt_scatternet_s *vlan;
2054 int vlan_id = 0;
2055 char *endp = strstr(opt, ",vlan=");
2056 int len = (endp ? endp - opt : strlen(opt)) + 1;
2057 char devname[10];
2058
2059 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2060
2061 if (endp) {
2062 vlan_id = strtol(endp + 6, &endp, 0);
2063 if (*endp) {
2064 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2065 return 0;
2066 }
2067 }
2068
2069 vlan = qemu_find_bt_vlan(vlan_id);
2070
2071 if (!vlan->slave)
2072 fprintf(stderr, "qemu: warning: adding a slave device to "
2073 "an empty scatternet %i\n", vlan_id);
2074
2075 if (!strcmp(devname, "keyboard"))
2076 return bt_keyboard_init(vlan);
2077
2078 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2079 return 0;
2080 }
2081
2082 static int bt_parse(const char *opt)
2083 {
2084 const char *endp, *p;
2085 int vlan;
2086
2087 if (strstart(opt, "hci", &endp)) {
2088 if (!*endp || *endp == ',') {
2089 if (*endp)
2090 if (!strstart(endp, ",vlan=", 0))
2091 opt = endp + 1;
2092
2093 return bt_hci_parse(opt);
2094 }
2095 } else if (strstart(opt, "vhci", &endp)) {
2096 if (!*endp || *endp == ',') {
2097 if (*endp) {
2098 if (strstart(endp, ",vlan=", &p)) {
2099 vlan = strtol(p, (char **) &endp, 0);
2100 if (*endp) {
2101 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2102 return 1;
2103 }
2104 } else {
2105 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2106 return 1;
2107 }
2108 } else
2109 vlan = 0;
2110
2111 bt_vhci_add(vlan);
2112 return 0;
2113 }
2114 } else if (strstart(opt, "device:", &endp))
2115 return !bt_device_add(endp);
2116
2117 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2118 return 1;
2119 }
2120
2121 /***********************************************************/
2122 /* QEMU Block devices */
2123
2124 #define HD_ALIAS "index=%d,media=disk"
2125 #ifdef TARGET_PPC
2126 #define CDROM_ALIAS "index=1,media=cdrom"
2127 #else
2128 #define CDROM_ALIAS "index=2,media=cdrom"
2129 #endif
2130 #define FD_ALIAS "index=%d,if=floppy"
2131 #define PFLASH_ALIAS "if=pflash"
2132 #define MTD_ALIAS "if=mtd"
2133 #define SD_ALIAS "index=0,if=sd"
2134
2135 static int drive_opt_get_free_idx(void)
2136 {
2137 int index;
2138
2139 for (index = 0; index < MAX_DRIVES; index++)
2140 if (!drives_opt[index].used) {
2141 drives_opt[index].used = 1;
2142 return index;
2143 }
2144
2145 return -1;
2146 }
2147
2148 static int drive_get_free_idx(void)
2149 {
2150 int index;
2151
2152 for (index = 0; index < MAX_DRIVES; index++)
2153 if (!drives_table[index].used) {
2154 drives_table[index].used = 1;
2155 return index;
2156 }
2157
2158 return -1;
2159 }
2160
2161 static int drive_add(const char *file, const char *fmt, ...)
2162 {
2163 va_list ap;
2164 int index = drive_opt_get_free_idx();
2165
2166 if (nb_drives_opt >= MAX_DRIVES || index == -1) {
2167 fprintf(stderr, "qemu: too many drives\n");
2168 exit(1);
2169 }
2170
2171 drives_opt[index].file = file;
2172 va_start(ap, fmt);
2173 vsnprintf(drives_opt[index].opt,
2174 sizeof(drives_opt[0].opt), fmt, ap);
2175 va_end(ap);
2176
2177 nb_drives_opt++;
2178 return index;
2179 }
2180
2181 void drive_remove(int index)
2182 {
2183 drives_opt[index].used = 0;
2184 nb_drives_opt--;
2185 }
2186
2187 int drive_get_index(BlockInterfaceType type, int bus, int unit)
2188 {
2189 int index;
2190
2191 /* seek interface, bus and unit */
2192
2193 for (index = 0; index < MAX_DRIVES; index++)
2194 if (drives_table[index].type == type &&
2195 drives_table[index].bus == bus &&
2196 drives_table[index].unit == unit &&
2197 drives_table[index].used)
2198 return index;
2199
2200 return -1;
2201 }
2202
2203 int drive_get_max_bus(BlockInterfaceType type)
2204 {
2205 int max_bus;
2206 int index;
2207
2208 max_bus = -1;
2209 for (index = 0; index < nb_drives; index++) {
2210 if(drives_table[index].type == type &&
2211 drives_table[index].bus > max_bus)
2212 max_bus = drives_table[index].bus;
2213 }
2214 return max_bus;
2215 }
2216
2217 const char *drive_get_serial(BlockDriverState *bdrv)
2218 {
2219 int index;
2220
2221 for (index = 0; index < nb_drives; index++)
2222 if (drives_table[index].bdrv == bdrv)
2223 return drives_table[index].serial;
2224
2225 return "\0";
2226 }
2227
2228 BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2229 {
2230 int index;
2231
2232 for (index = 0; index < nb_drives; index++)
2233 if (drives_table[index].bdrv == bdrv)
2234 return drives_table[index].onerror;
2235
2236 return BLOCK_ERR_REPORT;
2237 }
2238
2239 static void bdrv_format_print(void *opaque, const char *name)
2240 {
2241 fprintf(stderr, " %s", name);
2242 }
2243
2244 void drive_uninit(BlockDriverState *bdrv)
2245 {
2246 int i;
2247
2248 for (i = 0; i < MAX_DRIVES; i++)
2249 if (drives_table[i].bdrv == bdrv) {
2250 drives_table[i].bdrv = NULL;
2251 drives_table[i].used = 0;
2252 drive_remove(drives_table[i].drive_opt_idx);
2253 nb_drives--;
2254 break;
2255 }
2256 }
2257
2258 static int drive_init(struct drive_opt *arg, int snapshot,
2259 QEMUMachine *machine)
2260 {
2261 char buf[128];
2262 char file[1024];
2263 char devname[128];
2264 char serial[21];
2265 const char *mediastr = "";
2266 BlockInterfaceType type;
2267 enum { MEDIA_DISK, MEDIA_CDROM } media;
2268 int bus_id, unit_id;
2269 int cyls, heads, secs, translation;
2270 BlockDriverState *bdrv;
2271 BlockDriver *drv = NULL;
2272 int max_devs;
2273 int index;
2274 int cache;
2275 int bdrv_flags, onerror;
2276 int drives_table_idx;
2277 char *str = arg->opt;
2278 static const char * const params[] = { "bus", "unit", "if", "index",
2279 "cyls", "heads", "secs", "trans",
2280 "media", "snapshot", "file",
2281 "cache", "format", "serial", "werror",
2282 NULL };
2283
2284 if (check_params(buf, sizeof(buf), params, str) < 0) {
2285 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
2286 buf, str);
2287 return -1;
2288 }
2289
2290 file[0] = 0;
2291 cyls = heads = secs = 0;
2292 bus_id = 0;
2293 unit_id = -1;
2294 translation = BIOS_ATA_TRANSLATION_AUTO;
2295 index = -1;
2296 cache = 3;
2297
2298 if (machine->use_scsi) {
2299 type = IF_SCSI;
2300 max_devs = MAX_SCSI_DEVS;
2301 pstrcpy(devname, sizeof(devname), "scsi");
2302 } else {
2303 type = IF_IDE;
2304 max_devs = MAX_IDE_DEVS;
2305 pstrcpy(devname, sizeof(devname), "ide");
2306 }
2307 media = MEDIA_DISK;
2308
2309 /* extract parameters */
2310
2311 if (get_param_value(buf, sizeof(buf), "bus", str)) {
2312 bus_id = strtol(buf, NULL, 0);
2313 if (bus_id < 0) {
2314 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2315 return -1;
2316 }
2317 }
2318
2319 if (get_param_value(buf, sizeof(buf), "unit", str)) {
2320 unit_id = strtol(buf, NULL, 0);
2321 if (unit_id < 0) {
2322 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2323 return -1;
2324 }
2325 }
2326
2327 if (get_param_value(buf, sizeof(buf), "if", str)) {
2328 pstrcpy(devname, sizeof(devname), buf);
2329 if (!strcmp(buf, "ide")) {
2330 type = IF_IDE;
2331 max_devs = MAX_IDE_DEVS;
2332 } else if (!strcmp(buf, "scsi")) {
2333 type = IF_SCSI;
2334 max_devs = MAX_SCSI_DEVS;
2335 } else if (!strcmp(buf, "floppy")) {
2336 type = IF_FLOPPY;
2337 max_devs = 0;
2338 } else if (!strcmp(buf, "pflash")) {
2339 type = IF_PFLASH;
2340 max_devs = 0;
2341 } else if (!strcmp(buf, "mtd")) {
2342 type = IF_MTD;
2343 max_devs = 0;
2344 } else if (!strcmp(buf, "sd")) {
2345 type = IF_SD;
2346 max_devs = 0;
2347 } else if (!strcmp(buf, "virtio")) {
2348 type = IF_VIRTIO;
2349 max_devs = 0;
2350 } else {
2351 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2352 return -1;
2353 }
2354 }
2355
2356 if (get_param_value(buf, sizeof(buf), "index", str)) {
2357 index = strtol(buf, NULL, 0);
2358 if (index < 0) {
2359 fprintf(stderr, "qemu: '%s' invalid index\n", str);
2360 return -1;
2361 }
2362 }
2363
2364 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2365 cyls = strtol(buf, NULL, 0);
2366 }
2367
2368 if (get_param_value(buf, sizeof(buf), "heads", str)) {
2369 heads = strtol(buf, NULL, 0);
2370 }
2371
2372 if (get_param_value(buf, sizeof(buf), "secs", str)) {
2373 secs = strtol(buf, NULL, 0);
2374 }
2375
2376 if (cyls || heads || secs) {
2377 if (cyls < 1 || cyls > 16383) {
2378 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2379 return -1;
2380 }
2381 if (heads < 1 || heads > 16) {
2382 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2383 return -1;
2384 }
2385 if (secs < 1 || secs > 63) {
2386 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2387 return -1;
2388 }
2389 }
2390
2391 if (get_param_value(buf, sizeof(buf), "trans", str)) {
2392 if (!cyls) {
2393 fprintf(stderr,
2394 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2395 str);
2396 return -1;
2397 }
2398 if (!strcmp(buf, "none"))
2399 translation = BIOS_ATA_TRANSLATION_NONE;
2400 else if (!strcmp(buf, "lba"))
2401 translation = BIOS_ATA_TRANSLATION_LBA;
2402 else if (!strcmp(buf, "auto"))
2403 translation = BIOS_ATA_TRANSLATION_AUTO;
2404 else {
2405 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2406 return -1;
2407 }
2408 }
2409
2410 if (get_param_value(buf, sizeof(buf), "media", str)) {
2411 if (!strcmp(buf, "disk")) {
2412 media = MEDIA_DISK;
2413 } else if (!strcmp(buf, "cdrom")) {
2414 if (cyls || secs || heads) {
2415 fprintf(stderr,
2416 "qemu: '%s' invalid physical CHS format\n", str);
2417 return -1;
2418 }
2419 media = MEDIA_CDROM;
2420 } else {
2421 fprintf(stderr, "qemu: '%s' invalid media\n", str);
2422 return -1;
2423 }
2424 }
2425
2426 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2427 if (!strcmp(buf, "on"))
2428 snapshot = 1;
2429 else if (!strcmp(buf, "off"))
2430 snapshot = 0;
2431 else {
2432 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2433 return -1;
2434 }
2435 }
2436
2437 if (get_param_value(buf, sizeof(buf), "cache", str)) {
2438 if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2439 cache = 0;
2440 else if (!strcmp(buf, "writethrough"))
2441 cache = 1;
2442 else if (!strcmp(buf, "writeback"))
2443 cache = 2;
2444 else {
2445 fprintf(stderr, "qemu: invalid cache option\n");
2446 return -1;
2447 }
2448 }
2449
2450 if (get_param_value(buf, sizeof(buf), "format", str)) {
2451 if (strcmp(buf, "?") == 0) {
2452 fprintf(stderr, "qemu: Supported formats:");
2453 bdrv_iterate_format(bdrv_format_print, NULL);
2454 fprintf(stderr, "\n");
2455 return -1;
2456 }
2457 drv = bdrv_find_format(buf);
2458 if (!drv) {
2459 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2460 return -1;
2461 }
2462 }
2463
2464 if (arg->file == NULL)
2465 get_param_value(file, sizeof(file), "file", str);
2466 else
2467 pstrcpy(file, sizeof(file), arg->file);
2468
2469 if (!get_param_value(serial, sizeof(serial), "serial", str))
2470 memset(serial, 0, sizeof(serial));
2471
2472 onerror = BLOCK_ERR_REPORT;
2473 if (get_param_value(buf, sizeof(serial), "werror", str)) {
2474 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2475 fprintf(stderr, "werror is no supported by this format\n");
2476 return -1;
2477 }
2478 if (!strcmp(buf, "ignore"))
2479 onerror = BLOCK_ERR_IGNORE;
2480 else if (!strcmp(buf, "enospc"))
2481 onerror = BLOCK_ERR_STOP_ENOSPC;
2482 else if (!strcmp(buf, "stop"))
2483 onerror = BLOCK_ERR_STOP_ANY;
2484 else if (!strcmp(buf, "report"))
2485 onerror = BLOCK_ERR_REPORT;
2486 else {
2487 fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2488 return -1;
2489 }
2490 }
2491
2492 /* compute bus and unit according index */
2493
2494 if (index != -1) {
2495 if (bus_id != 0 || unit_id != -1) {
2496 fprintf(stderr,
2497 "qemu: '%s' index cannot be used with bus and unit\n", str);
2498 return -1;
2499 }
2500 if (max_devs == 0)
2501 {
2502 unit_id = index;
2503 bus_id = 0;
2504 } else {
2505 unit_id = index % max_devs;
2506 bus_id = index / max_devs;
2507 }
2508 }
2509
2510 /* if user doesn't specify a unit_id,
2511 * try to find the first free
2512 */
2513
2514 if (unit_id == -1) {
2515 unit_id = 0;
2516 while (drive_get_index(type, bus_id, unit_id) != -1) {
2517 unit_id++;
2518 if (max_devs && unit_id >= max_devs) {
2519 unit_id -= max_devs;
2520 bus_id++;
2521 }
2522 }
2523 }
2524
2525 /* check unit id */
2526
2527 if (max_devs && unit_id >= max_devs) {
2528 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2529 str, unit_id, max_devs - 1);
2530 return -1;
2531 }
2532
2533 /*
2534 * ignore multiple definitions
2535 */
2536
2537 if (drive_get_index(type, bus_id, unit_id) != -1)
2538 return 0;
2539
2540 /* init */
2541
2542 if (type == IF_IDE || type == IF_SCSI)
2543 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2544 if (max_devs)
2545 snprintf(buf, sizeof(buf), "%s%i%s%i",
2546 devname, bus_id, mediastr, unit_id);
2547 else
2548 snprintf(buf, sizeof(buf), "%s%s%i",
2549 devname, mediastr, unit_id);
2550 bdrv = bdrv_new(buf);
2551 drives_table_idx = drive_get_free_idx();
2552 drives_table[drives_table_idx].bdrv = bdrv;
2553 drives_table[drives_table_idx].type = type;
2554 drives_table[drives_table_idx].bus = bus_id;
2555 drives_table[drives_table_idx].unit = unit_id;
2556 drives_table[drives_table_idx].onerror = onerror;
2557 drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2558 strncpy(drives_table[nb_drives].serial, serial, sizeof(serial));
2559 nb_drives++;
2560
2561 switch(type) {
2562 case IF_IDE:
2563 case IF_SCSI:
2564 switch(media) {
2565 case MEDIA_DISK:
2566 if (cyls != 0) {
2567 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2568 bdrv_set_translation_hint(bdrv, translation);
2569 }
2570 break;
2571 case MEDIA_CDROM:
2572 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2573 break;
2574 }
2575 break;
2576 case IF_SD:
2577 /* FIXME: This isn't really a floppy, but it's a reasonable
2578 approximation. */
2579 case IF_FLOPPY:
2580 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2581 break;
2582 case IF_PFLASH:
2583 case IF_MTD:
2584 case IF_VIRTIO:
2585 break;
2586 }
2587 if (!file[0])
2588 return 0;
2589 bdrv_flags = 0;
2590 if (snapshot) {
2591 bdrv_flags |= BDRV_O_SNAPSHOT;
2592 cache = 2; /* always use write-back with snapshot */
2593 }
2594 if (cache == 0) /* no caching */
2595 bdrv_flags |= BDRV_O_NOCACHE;
2596 else if (cache == 2) /* write-back */
2597 bdrv_flags |= BDRV_O_CACHE_WB;
2598 else if (cache == 3) /* not specified */
2599 bdrv_flags |= BDRV_O_CACHE_DEF;
2600 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
2601 fprintf(stderr, "qemu: could not open disk image %s\n",
2602 file);
2603 return -1;
2604 }
2605 return 0;
2606 }
2607
2608 /***********************************************************/
2609 /* USB devices */
2610
2611 static USBPort *used_usb_ports;
2612 static USBPort *free_usb_ports;
2613
2614 /* ??? Maybe change this to register a hub to keep track of the topology. */
2615 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2616 usb_attachfn attach)
2617 {
2618 port->opaque = opaque;
2619 port->index = index;
2620 port->attach = attach;
2621 port->next = free_usb_ports;
2622 free_usb_ports = port;
2623 }
2624
2625 int usb_device_add_dev(USBDevice *dev)
2626 {
2627 USBPort *port;
2628
2629 /* Find a USB port to add the device to. */
2630 port = free_usb_ports;
2631 if (!port->next) {
2632 USBDevice *hub;
2633
2634 /* Create a new hub and chain it on. */
2635 free_usb_ports = NULL;
2636 port->next = used_usb_ports;
2637 used_usb_ports = port;
2638
2639 hub = usb_hub_init(VM_USB_HUB_SIZE);
2640 usb_attach(port, hub);
2641 port = free_usb_ports;
2642 }
2643
2644 free_usb_ports = port->next;
2645 port->next = used_usb_ports;
2646 used_usb_ports = port;
2647 usb_attach(port, dev);
2648 return 0;
2649 }
2650
2651 static int usb_device_add(const char *devname)
2652 {
2653 const char *p;
2654 USBDevice *dev;
2655
2656 if (!free_usb_ports)
2657 return -1;
2658
2659 if (strstart(devname, "host:", &p)) {
2660 dev = usb_host_device_open(p);
2661 } else if (!strcmp(devname, "mouse")) {
2662 dev = usb_mouse_init();
2663 } else if (!strcmp(devname, "tablet")) {
2664 dev = usb_tablet_init();
2665 } else if (!strcmp(devname, "keyboard")) {
2666 dev = usb_keyboard_init();
2667 } else if (strstart(devname, "disk:", &p)) {
2668 dev = usb_msd_init(p);
2669 } else if (!strcmp(devname, "wacom-tablet")) {
2670 dev = usb_wacom_init();
2671 } else if (strstart(devname, "serial:", &p)) {
2672 dev = usb_serial_init(p);
2673 #ifdef CONFIG_BRLAPI
2674 } else if (!strcmp(devname, "braille")) {
2675 dev = usb_baum_init();
2676 #endif
2677 } else if (strstart(devname, "net:", &p)) {
2678 int nic = nb_nics;
2679
2680 if (net_client_init("nic", p) < 0)
2681 return -1;
2682 nd_table[nic].model = "usb";
2683 dev = usb_net_init(&nd_table[nic]);
2684 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2685 dev = usb_bt_init(devname[2] ? hci_init(p) :
2686 bt_new_hci(qemu_find_bt_vlan(0)));
2687 } else {
2688 return -1;
2689 }
2690 if (!dev)
2691 return -1;
2692
2693 return usb_device_add_dev(dev);
2694 }
2695
2696 int usb_device_del_addr(int bus_num, int addr)
2697 {
2698 USBPort *port;
2699 USBPort **lastp;
2700 USBDevice *dev;
2701
2702 if (!used_usb_ports)
2703 return -1;
2704
2705 if (bus_num != 0)
2706 return -1;
2707
2708 lastp = &used_usb_ports;
2709 port = used_usb_ports;
2710 while (port && port->dev->addr != addr) {
2711 lastp = &port->next;
2712 port = port->next;
2713 }
2714
2715 if (!port)
2716 return -1;
2717
2718 dev = port->dev;
2719 *lastp = port->next;
2720 usb_attach(port, NULL);
2721 dev->handle_destroy(dev);
2722 port->next = free_usb_ports;
2723 free_usb_ports = port;
2724 return 0;
2725 }
2726
2727 static int usb_device_del(const char *devname)
2728 {
2729 int bus_num, addr;
2730 const char *p;
2731
2732 if (strstart(devname, "host:", &p))
2733 return usb_host_device_close(p);
2734
2735 if (!used_usb_ports)
2736 return -1;
2737
2738 p = strchr(devname, '.');
2739 if (!p)
2740 return -1;
2741 bus_num = strtoul(devname, NULL, 0);
2742 addr = strtoul(p + 1, NULL, 0);
2743
2744 return usb_device_del_addr(bus_num, addr);
2745 }
2746
2747 void do_usb_add(const char *devname)
2748 {
2749 usb_device_add(devname);
2750 }
2751
2752 void do_usb_del(const char *devname)
2753 {
2754 usb_device_del(devname);
2755 }
2756
2757 void usb_info(void)
2758 {
2759 USBDevice *dev;
2760 USBPort *port;
2761 const char *speed_str;
2762
2763 if (!usb_enabled) {
2764 term_printf("USB support not enabled\n");
2765 return;
2766 }
2767
2768 for (port = used_usb_ports; port; port = port->next) {
2769 dev = port->dev;
2770 if (!dev)
2771 continue;
2772 switch(dev->speed) {
2773 case USB_SPEED_LOW:
2774 speed_str = "1.5";
2775 break;
2776 case USB_SPEED_FULL:
2777 speed_str = "12";
2778 break;
2779 case USB_SPEED_HIGH:
2780 speed_str = "480";
2781 break;
2782 default:
2783 speed_str = "?";
2784 break;
2785 }
2786 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
2787 0, dev->addr, speed_str, dev->devname);
2788 }
2789 }
2790
2791 /***********************************************************/
2792 /* PCMCIA/Cardbus */
2793
2794 static struct pcmcia_socket_entry_s {
2795 struct pcmcia_socket_s *socket;
2796 struct pcmcia_socket_entry_s *next;
2797 } *pcmcia_sockets = 0;
2798
2799 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
2800 {
2801 struct pcmcia_socket_entry_s *entry;
2802
2803 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2804 entry->socket = socket;
2805 entry->next = pcmcia_sockets;
2806 pcmcia_sockets = entry;
2807 }
2808
2809 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
2810 {
2811 struct pcmcia_socket_entry_s *entry, **ptr;
2812
2813 ptr = &pcmcia_sockets;
2814 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2815 if (entry->socket == socket) {
2816 *ptr = entry->next;
2817 qemu_free(entry);
2818 }
2819 }
2820
2821 void pcmcia_info(void)
2822 {
2823 struct pcmcia_socket_entry_s *iter;
2824 if (!pcmcia_sockets)
2825 term_printf("No PCMCIA sockets\n");
2826
2827 for (iter = pcmcia_sockets; iter; iter = iter->next)
2828 term_printf("%s: %s\n", iter->socket->slot_string,
2829 iter->socket->attached ? iter->socket->card_string :
2830 "Empty");
2831 }
2832
2833 /***********************************************************/
2834 /* register display */
2835
2836 void register_displaystate(DisplayState *ds)
2837 {
2838 DisplayState **s;
2839 s = &display_state;
2840 while (*s != NULL)
2841 s = &(*s)->next;
2842 ds->next = NULL;
2843 *s = ds;
2844 }
2845
2846 DisplayState *get_displaystate(void)
2847 {
2848 return display_state;
2849 }
2850
2851 /* dumb display */
2852
2853 static void dumb_display_init(void)
2854 {
2855 DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2856 ds->surface = qemu_create_displaysurface(640, 480, 32, 640 * 4);
2857 register_displaystate(ds);
2858 }
2859
2860 /***********************************************************/
2861 /* I/O handling */
2862
2863 #define MAX_IO_HANDLERS 64
2864
2865 typedef struct IOHandlerRecord {
2866 int fd;
2867 IOCanRWHandler *fd_read_poll;
2868 IOHandler *fd_read;
2869 IOHandler *fd_write;
2870 int deleted;
2871 void *opaque;
2872 /* temporary data */
2873 struct pollfd *ufd;
2874 struct IOHandlerRecord *next;
2875 } IOHandlerRecord;
2876
2877 static IOHandlerRecord *first_io_handler;
2878
2879 /* XXX: fd_read_poll should be suppressed, but an API change is
2880 necessary in the character devices to suppress fd_can_read(). */
2881 int qemu_set_fd_handler2(int fd,
2882 IOCanRWHandler *fd_read_poll,
2883 IOHandler *fd_read,
2884 IOHandler *fd_write,
2885 void *opaque)
2886 {
2887 IOHandlerRecord **pioh, *ioh;
2888
2889 if (!fd_read && !fd_write) {
2890 pioh = &first_io_handler;
2891 for(;;) {
2892 ioh = *pioh;
2893 if (ioh == NULL)
2894 break;
2895 if (ioh->fd == fd) {
2896 ioh->deleted = 1;
2897 break;
2898 }
2899 pioh = &ioh->next;
2900 }
2901 } else {
2902 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2903 if (ioh->fd == fd)
2904 goto found;
2905 }
2906 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2907 ioh->next = first_io_handler;
2908 first_io_handler = ioh;
2909 found:
2910 ioh->fd = fd;
2911 ioh->fd_read_poll = fd_read_poll;
2912 ioh->fd_read = fd_read;
2913 ioh->fd_write = fd_write;
2914 ioh->opaque = opaque;
2915 ioh->deleted = 0;
2916 }
2917 return 0;
2918 }
2919
2920 int qemu_set_fd_handler(int fd,
2921 IOHandler *fd_read,
2922 IOHandler *fd_write,
2923 void *opaque)
2924 {
2925 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2926 }
2927
2928 #ifdef _WIN32
2929 /***********************************************************/
2930 /* Polling handling */
2931
2932 typedef struct PollingEntry {
2933 PollingFunc *func;
2934 void *opaque;
2935 struct PollingEntry *next;
2936 } PollingEntry;
2937
2938 static PollingEntry *first_polling_entry;
2939
2940 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2941 {
2942 PollingEntry **ppe, *pe;
2943 pe = qemu_mallocz(sizeof(PollingEntry));
2944 pe->func = func;
2945 pe->opaque = opaque;
2946 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2947 *ppe = pe;
2948 return 0;
2949 }
2950
2951 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2952 {
2953 PollingEntry **ppe, *pe;
2954 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2955 pe = *ppe;
2956 if (pe->func == func && pe->opaque == opaque) {
2957 *ppe = pe->next;
2958 qemu_free(pe);
2959 break;
2960 }
2961 }
2962 }
2963
2964 /***********************************************************/
2965 /* Wait objects support */
2966 typedef struct WaitObjects {
2967 int num;
2968 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
2969 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
2970 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
2971 } WaitObjects;
2972
2973 static WaitObjects wait_objects = {0};
2974
2975 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2976 {
2977 WaitObjects *w = &wait_objects;
2978
2979 if (w->num >= MAXIMUM_WAIT_OBJECTS)
2980 return -1;
2981 w->events[w->num] = handle;
2982 w->func[w->num] = func;
2983 w->opaque[w->num] = opaque;
2984 w->num++;
2985 return 0;
2986 }
2987
2988 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2989 {
2990 int i, found;
2991 WaitObjects *w = &wait_objects;
2992
2993 found = 0;
2994 for (i = 0; i < w->num; i++) {
2995 if (w->events[i] == handle)
2996 found = 1;
2997 if (found) {
2998 w->events[i] = w->events[i + 1];
2999 w->func[i] = w->func[i + 1];
3000 w->opaque[i] = w->opaque[i + 1];
3001 }
3002 }
3003 if (found)
3004 w->num--;
3005 }
3006 #endif
3007
3008 /***********************************************************/
3009 /* ram save/restore */
3010
3011 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3012 {
3013 int v;
3014
3015 v = qemu_get_byte(f);
3016 switch(v) {
3017 case 0:
3018 if (qemu_get_buffer(f, buf, len) != len)
3019 return -EIO;
3020 break;
3021 case 1:
3022 v = qemu_get_byte(f);
3023 memset(buf, v, len);
3024 break;
3025 default:
3026 return -EINVAL;
3027 }
3028
3029 if (qemu_file_has_error(f))
3030 return -EIO;
3031
3032 return 0;
3033 }
3034
3035 static int ram_load_v1(QEMUFile *f, void *opaque)
3036 {
3037 int ret;
3038 ram_addr_t i;
3039
3040 if (qemu_get_be32(f) != phys_ram_size)
3041 return -EINVAL;
3042 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3043 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3044 if (ret)
3045 return ret;
3046 }
3047 return 0;
3048 }
3049
3050 #define BDRV_HASH_BLOCK_SIZE 1024
3051 #define IOBUF_SIZE 4096
3052 #define RAM_CBLOCK_MAGIC 0xfabe
3053
3054 typedef struct RamDecompressState {
3055 z_stream zstream;
3056 QEMUFile *f;
3057 uint8_t buf[IOBUF_SIZE];
3058 } RamDecompressState;
3059
3060 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3061 {
3062 int ret;
3063 memset(s, 0, sizeof(*s));
3064 s->f = f;
3065 ret = inflateInit(&s->zstream);
3066 if (ret != Z_OK)
3067 return -1;
3068 return 0;
3069 }
3070
3071 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3072 {
3073 int ret, clen;
3074
3075 s->zstream.avail_out = len;
3076 s->zstream.next_out = buf;
3077 while (s->zstream.avail_out > 0) {
3078 if (s->zstream.avail_in == 0) {
3079 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3080 return -1;
3081 clen = qemu_get_be16(s->f);
3082 if (clen > IOBUF_SIZE)
3083 return -1;
3084 qemu_get_buffer(s->f, s->buf, clen);
3085 s->zstream.avail_in = clen;
3086 s->zstream.next_in = s->buf;
3087 }
3088 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3089 if (ret != Z_OK && ret != Z_STREAM_END) {
3090 return -1;
3091 }
3092 }
3093 return 0;
3094 }
3095
3096 static void ram_decompress_close(RamDecompressState *s)
3097 {
3098 inflateEnd(&s->zstream);
3099 }
3100
3101 #define RAM_SAVE_FLAG_FULL 0x01
3102 #define RAM_SAVE_FLAG_COMPRESS 0x02
3103 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
3104 #define RAM_SAVE_FLAG_PAGE 0x08
3105 #define RAM_SAVE_FLAG_EOS 0x10
3106
3107 static int is_dup_page(uint8_t *page, uint8_t ch)
3108 {
3109 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3110 uint32_t *array = (uint32_t *)page;
3111 int i;
3112
3113 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3114 if (array[i] != val)
3115 return 0;
3116 }
3117
3118 return 1;
3119 }
3120
3121 static int ram_save_block(QEMUFile *f)
3122 {
3123 static ram_addr_t current_addr = 0;
3124 ram_addr_t saved_addr = current_addr;
3125 ram_addr_t addr = 0;
3126 int found = 0;
3127
3128 while (addr < phys_ram_size) {
3129 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3130 uint8_t ch;
3131
3132 cpu_physical_memory_reset_dirty(current_addr,
3133 current_addr + TARGET_PAGE_SIZE,
3134 MIGRATION_DIRTY_FLAG);
3135
3136 ch = *(phys_ram_base + current_addr);
3137
3138 if (is_dup_page(phys_ram_base + current_addr, ch)) {
3139 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3140 qemu_put_byte(f, ch);
3141 } else {
3142 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3143 qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
3144 }
3145
3146 found = 1;
3147 break;
3148 }
3149 addr += TARGET_PAGE_SIZE;
3150 current_addr = (saved_addr + addr) % phys_ram_size;
3151 }
3152
3153 return found;
3154 }
3155
3156 static ram_addr_t ram_save_threshold = 10;
3157
3158 static ram_addr_t ram_save_remaining(void)
3159 {
3160 ram_addr_t addr;
3161 ram_addr_t count = 0;
3162
3163 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3164 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3165 count++;
3166 }
3167
3168 return count;
3169 }
3170
3171 static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3172 {
3173 ram_addr_t addr;
3174
3175 if (stage == 1) {
3176 /* Make sure all dirty bits are set */
3177 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3178 if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3179 cpu_physical_memory_set_dirty(addr);
3180 }
3181
3182 /* Enable dirty memory tracking */
3183 cpu_physical_memory_set_dirty_tracking(1);
3184
3185 qemu_put_be64(f, phys_ram_size | RAM_SAVE_FLAG_MEM_SIZE);
3186 }
3187
3188 while (!qemu_file_rate_limit(f)) {
3189 int ret;
3190
3191 ret = ram_save_block(f);
3192 if (ret == 0) /* no more blocks */
3193 break;
3194 }
3195
3196 /* try transferring iterative blocks of memory */
3197
3198 if (stage == 3) {
3199 cpu_physical_memory_set_dirty_tracking(0);
3200
3201 /* flush all remaining blocks regardless of rate limiting */
3202 while (ram_save_block(f) != 0);
3203 }
3204
3205 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3206
3207 return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3208 }
3209
3210 static int ram_load_dead(QEMUFile *f, void *opaque)
3211 {
3212 RamDecompressState s1, *s = &s1;
3213 uint8_t buf[10];
3214 ram_addr_t i;
3215
3216 if (ram_decompress_open(s, f) < 0)
3217 return -EINVAL;
3218 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
3219 if (ram_decompress_buf(s, buf, 1) < 0) {
3220 fprintf(stderr, "Error while reading ram block header\n");
3221 goto error;
3222 }
3223 if (buf[0] == 0) {
3224 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
3225 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3226 goto error;
3227 }
3228 } else {
3229 error:
3230 printf("Error block header\n");
3231 return -EINVAL;
3232 }
3233 }
3234 ram_decompress_close(s);
3235
3236 return 0;
3237 }
3238
3239 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3240 {
3241 ram_addr_t addr;
3242 int flags;
3243
3244 if (version_id == 1)
3245 return ram_load_v1(f, opaque);
3246
3247 if (version_id == 2) {
3248 if (qemu_get_be32(f) != phys_ram_size)
3249 return -EINVAL;
3250 return ram_load_dead(f, opaque);
3251 }
3252
3253 if (version_id != 3)
3254 return -EINVAL;
3255
3256 do {
3257 addr = qemu_get_be64(f);
3258
3259 flags = addr & ~TARGET_PAGE_MASK;
3260 addr &= TARGET_PAGE_MASK;
3261
3262 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3263 if (addr != phys_ram_size)
3264 return -EINVAL;
3265 }
3266
3267 if (flags & RAM_SAVE_FLAG_FULL) {
3268 if (ram_load_dead(f, opaque) < 0)
3269 return -EINVAL;
3270 }
3271
3272 if (flags & RAM_SAVE_FLAG_COMPRESS) {
3273 uint8_t ch = qemu_get_byte(f);
3274 memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3275 } else if (flags & RAM_SAVE_FLAG_PAGE)
3276 qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3277 } while (!(flags & RAM_SAVE_FLAG_EOS));
3278
3279 return 0;
3280 }
3281
3282 void qemu_service_io(void)
3283 {
3284 CPUState *env = cpu_single_env;
3285 if (env) {
3286 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3287 #ifdef USE_KQEMU
3288 if (env->kqemu_enabled) {
3289 kqemu_cpu_interrupt(env);
3290 }
3291 #endif
3292 }
3293 }
3294
3295 /***********************************************************/
3296 /* bottom halves (can be seen as timers which expire ASAP) */
3297
3298 struct QEMUBH {
3299 QEMUBHFunc *cb;
3300 void *opaque;
3301 int scheduled;
3302 int idle;
3303 int deleted;
3304 QEMUBH *next;
3305 };
3306
3307 static QEMUBH *first_bh = NULL;
3308
3309 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3310 {
3311 QEMUBH *bh;
3312 bh = qemu_mallocz(sizeof(QEMUBH));
3313 bh->cb = cb;
3314 bh->opaque = opaque;
3315 bh->next = first_bh;
3316 first_bh = bh;
3317 return bh;
3318 }
3319
3320 int qemu_bh_poll(void)
3321 {
3322 QEMUBH *bh, **bhp;
3323 int ret;
3324
3325 ret = 0;
3326 for (bh = first_bh; bh; bh = bh->next) {
3327 if (!bh->deleted && bh->scheduled) {
3328 bh->scheduled = 0;
3329 if (!bh->idle)
3330 ret = 1;
3331 bh->idle = 0;
3332 bh->cb(bh->opaque);
3333 }
3334 }
3335
3336 /* remove deleted bhs */
3337 bhp = &first_bh;
3338 while (*bhp) {
3339 bh = *bhp;
3340 if (bh->deleted) {
3341 *bhp = bh->next;
3342 qemu_free(bh);
3343 } else
3344 bhp = &bh->next;
3345 }
3346
3347 return ret;
3348 }
3349
3350 void qemu_bh_schedule_idle(QEMUBH *bh)
3351 {
3352 if (bh->scheduled)
3353 return;
3354 bh->scheduled = 1;
3355 bh->idle = 1;
3356 }
3357
3358 void qemu_bh_schedule(QEMUBH *bh)
3359 {
3360 CPUState *env = cpu_single_env;
3361 if (bh->scheduled)
3362 return;
3363 bh->scheduled = 1;
3364 bh->idle = 0;
3365 /* stop the currently executing CPU to execute the BH ASAP */
3366 if (env) {
3367 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3368 }
3369 }
3370
3371 void qemu_bh_cancel(QEMUBH *bh)
3372 {
3373 bh->scheduled = 0;
3374 }
3375
3376 void qemu_bh_delete(QEMUBH *bh)
3377 {
3378 bh->scheduled = 0;
3379 bh->deleted = 1;
3380 }
3381
3382 static void qemu_bh_update_timeout(int *timeout)
3383 {
3384 QEMUBH *bh;
3385
3386 for (bh = first_bh; bh; bh = bh->next) {
3387 if (!bh->deleted && bh->scheduled) {
3388 if (bh->idle) {
3389 /* idle bottom halves will be polled at least
3390 * every 10ms */
3391 *timeout = MIN(10, *timeout);
3392 } else {
3393 /* non-idle bottom halves will be executed
3394 * immediately */
3395 *timeout = 0;
3396 break;
3397 }
3398 }
3399 }
3400 }
3401
3402 /***********************************************************/
3403 /* machine registration */
3404
3405 static QEMUMachine *first_machine = NULL;
3406
3407 int qemu_register_machine(QEMUMachine *m)
3408 {
3409 QEMUMachine **pm;
3410 pm = &first_machine;
3411 while (*pm != NULL)
3412 pm = &(*pm)->next;
3413 m->next = NULL;
3414 *pm = m;
3415 return 0;
3416 }
3417
3418 static QEMUMachine *find_machine(const char *name)
3419 {
3420 QEMUMachine *m;
3421
3422 for(m = first_machine; m != NULL; m = m->next) {
3423 if (!strcmp(m->name, name))
3424 return m;
3425 }
3426 return NULL;
3427 }
3428
3429 /***********************************************************/
3430 /* main execution loop */
3431
3432 static void gui_update(void *opaque)
3433 {
3434 uint64_t interval = GUI_REFRESH_INTERVAL;
3435 DisplayState *ds = opaque;
3436 DisplayChangeListener *dcl = ds->listeners;
3437
3438 dpy_refresh(ds);
3439
3440 while (dcl != NULL) {
3441 if (dcl->gui_timer_interval &&
3442 dcl->gui_timer_interval < interval)
3443 interval = dcl->gui_timer_interval;
3444 dcl = dcl->next;
3445 }
3446 qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3447 }
3448
3449 static void nographic_update(void *opaque)
3450 {
3451 uint64_t interval = GUI_REFRESH_INTERVAL;
3452
3453 qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3454 }
3455
3456 struct vm_change_state_entry {
3457 VMChangeStateHandler *cb;
3458 void *opaque;
3459 LIST_ENTRY (vm_change_state_entry) entries;
3460 };
3461
3462 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3463
3464 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3465 void *opaque)
3466 {
3467 VMChangeStateEntry *e;
3468
3469 e = qemu_mallocz(sizeof (*e));
3470
3471 e->cb = cb;
3472 e->opaque = opaque;
3473 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3474 return e;
3475 }
3476
3477 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3478 {
3479 LIST_REMOVE (e, entries);
3480 qemu_free (e);
3481 }
3482
3483 static void vm_state_notify(int running, int reason)
3484 {
3485 VMChangeStateEntry *e;
3486
3487 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3488 e->cb(e->opaque, running, reason);
3489 }
3490 }
3491
3492 void vm_start(void)
3493 {
3494 if (!vm_running) {
3495 cpu_enable_ticks();
3496 vm_running = 1;
3497 vm_state_notify(1, 0);
3498 qemu_rearm_alarm_timer(alarm_timer);
3499 }
3500 }
3501
3502 void vm_stop(int reason)
3503 {
3504 if (vm_running) {
3505 cpu_disable_ticks();
3506 vm_running = 0;
3507 vm_state_notify(0, reason);
3508 }
3509 }
3510
3511 /* reset/shutdown handler */
3512
3513 typedef struct QEMUResetEntry {
3514 QEMUResetHandler *func;
3515 void *opaque;
3516 struct QEMUResetEntry *next;
3517 } QEMUResetEntry;
3518
3519 static QEMUResetEntry *first_reset_entry;
3520 static int reset_requested;
3521 static int shutdown_requested;
3522 static int powerdown_requested;
3523
3524 int qemu_shutdown_requested(void)
3525 {
3526 int r = shutdown_requested;
3527 shutdown_requested = 0;
3528 return r;
3529 }
3530
3531 int qemu_reset_requested(void)
3532 {
3533 int r = reset_requested;
3534 reset_requested = 0;
3535 return r;
3536 }
3537
3538 int qemu_powerdown_requested(void)
3539 {
3540 int r = powerdown_requested;
3541 powerdown_requested = 0;
3542 return r;
3543 }
3544
3545 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3546 {
3547 QEMUResetEntry **pre, *re;
3548
3549 pre = &first_reset_entry;
3550 while (*pre != NULL)
3551 pre = &(*pre)->next;
3552 re = qemu_mallocz(sizeof(QEMUResetEntry));
3553 re->func = func;
3554 re->opaque = opaque;
3555 re->next = NULL;
3556 *pre = re;
3557 }
3558
3559 void qemu_system_reset(void)
3560 {
3561 QEMUResetEntry *re;
3562
3563 /* reset all devices */
3564 for(re = first_reset_entry; re != NULL; re = re->next) {
3565 re->func(re->opaque);
3566 }
3567 }
3568
3569 void qemu_system_reset_request(void)
3570 {
3571 if (no_reboot) {
3572 shutdown_requested = 1;
3573 } else {
3574 reset_requested = 1;
3575 }
3576 if (cpu_single_env)
3577 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3578 }
3579
3580 void qemu_system_shutdown_request(void)
3581 {
3582 shutdown_requested = 1;
3583 if (cpu_single_env)
3584 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3585 }
3586
3587 void qemu_system_powerdown_request(void)
3588 {
3589 powerdown_requested = 1;
3590 if (cpu_single_env)
3591 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3592 }
3593
3594 #ifdef _WIN32
3595 static void host_main_loop_wait(int *timeout)
3596 {
3597 int ret, ret2, i;
3598 PollingEntry *pe;
3599
3600
3601 /* XXX: need to suppress polling by better using win32 events */
3602 ret = 0;
3603 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3604 ret |= pe->func(pe->opaque);
3605 }
3606 if (ret == 0) {
3607 int err;
3608 WaitObjects *w = &wait_objects;
3609
3610 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3611 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3612 if (w->func[ret - WAIT_OBJECT_0])
3613 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3614
3615 /* Check for additional signaled events */
3616 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3617
3618 /* Check if event is signaled */
3619 ret2 = WaitForSingleObject(w->events[i], 0);
3620 if(ret2 == WAIT_OBJECT_0) {
3621 if (w->func[i])
3622 w->func[i](w->opaque[i]);
3623 } else if (ret2 == WAIT_TIMEOUT) {
3624 } else {
3625 err = GetLastError();
3626 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3627 }
3628 }
3629 } else if (ret == WAIT_TIMEOUT) {
3630 } else {
3631 err = GetLastError();
3632 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3633 }
3634 }
3635
3636 *timeout = 0;
3637 }
3638 #else
3639 static void host_main_loop_wait(int *timeout)
3640 {
3641 }
3642 #endif
3643
3644 void main_loop_wait(int timeout)
3645 {
3646 IOHandlerRecord *ioh;
3647 fd_set rfds, wfds, xfds;
3648 int ret, nfds;
3649 struct timeval tv;
3650
3651 qemu_bh_update_timeout(&timeout);
3652
3653 host_main_loop_wait(&timeout);
3654
3655 /* poll any events */
3656 /* XXX: separate device handlers from system ones */
3657 nfds = -1;
3658 FD_ZERO(&rfds);
3659 FD_ZERO(&wfds);
3660 FD_ZERO(&xfds);
3661 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3662 if (ioh->deleted)
3663 continue;
3664 if (ioh->fd_read &&
3665 (!ioh->fd_read_poll ||
3666 ioh->fd_read_poll(ioh->opaque) != 0)) {
3667 FD_SET(ioh->fd, &rfds);
3668 if (ioh->fd > nfds)
3669 nfds = ioh->fd;
3670 }
3671 if (ioh->fd_write) {
3672 FD_SET(ioh->fd, &wfds);
3673 if (ioh->fd > nfds)
3674 nfds = ioh->fd;
3675 }
3676 }
3677
3678 tv.tv_sec = timeout / 1000;
3679 tv.tv_usec = (timeout % 1000) * 1000;
3680
3681 #if defined(CONFIG_SLIRP)
3682 if (slirp_is_inited()) {
3683 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3684 }
3685 #endif
3686 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3687 if (ret > 0) {
3688 IOHandlerRecord **pioh;
3689
3690 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3691 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3692 ioh->fd_read(ioh->opaque);
3693 }
3694 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3695 ioh->fd_write(ioh->opaque);
3696 }
3697 }
3698
3699 /* remove deleted IO handlers */
3700 pioh = &first_io_handler;
3701 while (*pioh) {
3702 ioh = *pioh;
3703 if (ioh->deleted) {
3704 *pioh = ioh->next;
3705 qemu_free(ioh);
3706 } else
3707 pioh = &ioh->next;
3708 }
3709 }
3710 #if defined(CONFIG_SLIRP)
3711 if (slirp_is_inited()) {
3712 if (ret < 0) {
3713 FD_ZERO(&rfds);
3714 FD_ZERO(&wfds);
3715 FD_ZERO(&xfds);
3716 }
3717 slirp_select_poll(&rfds, &wfds, &xfds);
3718 }
3719 #endif
3720
3721 /* vm time timers */
3722 if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3723 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3724 qemu_get_clock(vm_clock));
3725
3726 /* real time timers */
3727 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3728 qemu_get_clock(rt_clock));
3729
3730 /* Check bottom-halves last in case any of the earlier events triggered
3731 them. */
3732 qemu_bh_poll();
3733
3734 }
3735
3736 static int main_loop(void)
3737 {
3738 int ret, timeout;
3739 #ifdef CONFIG_PROFILER
3740 int64_t ti;
3741 #endif
3742 CPUState *env;
3743
3744 cur_cpu = first_cpu;
3745 next_cpu = cur_cpu->next_cpu ?: first_cpu;
3746 for(;;) {
3747 if (vm_running) {
3748
3749 for(;;) {
3750 /* get next cpu */
3751 env = next_cpu;
3752 #ifdef CONFIG_PROFILER
3753 ti = profile_getclock();
3754 #endif
3755 if (use_icount) {
3756 int64_t count;
3757 int decr;
3758 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3759 env->icount_decr.u16.low = 0;
3760 env->icount_extra = 0;
3761 count = qemu_next_deadline();
3762 count = (count + (1 << icount_time_shift) - 1)
3763 >> icount_time_shift;
3764 qemu_icount += count;
3765 decr = (count > 0xffff) ? 0xffff : count;
3766 count -= decr;
3767 env->icount_decr.u16.low = decr;
3768 env->icount_extra = count;
3769 }
3770 ret = cpu_exec(env);
3771 #ifdef CONFIG_PROFILER
3772 qemu_time += profile_getclock() - ti;
3773 #endif
3774 if (use_icount) {
3775 /* Fold pending instructions back into the
3776 instruction counter, and clear the interrupt flag. */
3777 qemu_icount -= (env->icount_decr.u16.low
3778 + env->icount_extra);
3779 env->icount_decr.u32 = 0;
3780 env->icount_extra = 0;
3781 }
3782 next_cpu = env->next_cpu ?: first_cpu;
3783 if (event_pending && likely(ret != EXCP_DEBUG)) {
3784 ret = EXCP_INTERRUPT;
3785 event_pending = 0;
3786 break;
3787 }
3788 if (ret == EXCP_HLT) {
3789 /* Give the next CPU a chance to run. */
3790 cur_cpu = env;
3791 continue;
3792 }
3793 if (ret != EXCP_HALTED)
3794 break;
3795 /* all CPUs are halted ? */
3796 if (env == cur_cpu)
3797 break;
3798 }
3799 cur_cpu = env;
3800
3801 if (shutdown_requested) {
3802 ret = EXCP_INTERRUPT;
3803 if (no_shutdown) {
3804 vm_stop(0);
3805 no_shutdown = 0;
3806 }
3807 else
3808 break;
3809 }
3810 if (reset_requested) {
3811 reset_requested = 0;
3812 qemu_system_reset();
3813 ret = EXCP_INTERRUPT;
3814 }
3815 if (powerdown_requested) {
3816 powerdown_requested = 0;
3817 qemu_system_powerdown();
3818 ret = EXCP_INTERRUPT;
3819 }
3820 if (unlikely(ret == EXCP_DEBUG)) {
3821 gdb_set_stop_cpu(cur_cpu);
3822 vm_stop(EXCP_DEBUG);
3823 }
3824 /* If all cpus are halted then wait until the next IRQ */
3825 /* XXX: use timeout computed from timers */
3826 if (ret == EXCP_HALTED) {
3827 if (use_icount) {
3828 int64_t add;
3829 int64_t delta;
3830 /* Advance virtual time to the next event. */
3831 if (use_icount == 1) {
3832 /* When not using an adaptive execution frequency
3833 we tend to get badly out of sync with real time,
3834 so just delay for a reasonable amount of time. */
3835 delta = 0;
3836 } else {
3837 delta = cpu_get_icount() - cpu_get_clock();
3838 }
3839 if (delta > 0) {
3840 /* If virtual time is ahead of real time then just
3841 wait for IO. */
3842 timeout = (delta / 1000000) + 1;
3843 } else {
3844 /* Wait for either IO to occur or the next
3845 timer event. */
3846 add = qemu_next_deadline();
3847 /* We advance the timer before checking for IO.
3848 Limit the amount we advance so that early IO
3849 activity won't get the guest too far ahead. */
3850 if (add > 10000000)
3851 add = 10000000;
3852 delta += add;
3853 add = (add + (1 << icount_time_shift) - 1)
3854 >> icount_time_shift;
3855 qemu_icount += add;
3856 timeout = delta / 1000000;
3857 if (timeout < 0)
3858 timeout = 0;
3859 }
3860 } else {
3861 timeout = 5000;
3862 }
3863 } else {
3864 timeout = 0;
3865 }
3866 } else {
3867 if (shutdown_requested) {
3868 ret = EXCP_INTERRUPT;
3869 break;
3870 }
3871 timeout = 5000;
3872 }
3873 #ifdef CONFIG_PROFILER
3874 ti = profile_getclock();
3875 #endif
3876 main_loop_wait(timeout);
3877 #ifdef CONFIG_PROFILER
3878 dev_time += profile_getclock() - ti;
3879 #endif
3880 }
3881 cpu_disable_ticks();
3882 return ret;
3883 }
3884
3885 static void help(int exitcode)
3886 {
3887 /* Please keep in synch with QEMU_OPTION_ enums, qemu_options[]
3888 and qemu-doc.texi */
3889 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
3890 "usage: %s [options] [disk_image]\n"
3891 "\n"
3892 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
3893 "\n"
3894 "Standard options:\n"
3895 "-h or -help display this help and exit\n"
3896 "-M machine select emulated machine (-M ? for list)\n"
3897 "-cpu cpu select CPU (-cpu ? for list)\n"
3898 "-smp n set the number of CPUs to 'n' [default=1]\n"
3899 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
3900 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
3901 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
3902 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
3903 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
3904 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
3905 " [,cache=writethrough|writeback|none][,format=f][,serial=s]\n"
3906 " use 'file' as a drive image\n"
3907 "-mtdblock file use 'file' as on-board Flash memory image\n"
3908 "-sd file use 'file' as SecureDigital card image\n"
3909 "-pflash file use 'file' as a parallel flash image\n"
3910 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
3911 "-snapshot write to temporary files instead of disk image files\n"
3912 "-m megs set virtual RAM size to megs MB [default=%d]\n"
3913 #ifndef _WIN32
3914 "-k language use keyboard layout (for example \"fr\" for French)\n"
3915 #endif
3916 #ifdef HAS_AUDIO
3917 "-audio-help print list of audio drivers and their options\n"
3918 "-soundhw c1,... enable audio support\n"
3919 " and only specified sound cards (comma separated list)\n"
3920 " use -soundhw ? to get the list of supported cards\n"
3921 " use -soundhw all to enable all of them\n"
3922 #endif
3923 "-usb enable the USB driver (will be the default soon)\n"
3924 "-usbdevice name add the host or guest USB device 'name'\n"
3925 "-name string set the name of the guest\n"
3926 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x\n"
3927 " specify machine UUID\n"
3928 "\n"
3929 "Display options:\n"
3930 "-nographic disable graphical output and redirect serial I/Os to console\n"
3931 #ifdef CONFIG_CURSES
3932 "-curses use a curses/ncurses interface instead of SDL\n"
3933 #endif
3934 #ifdef CONFIG_SDL
3935 "-no-frame open SDL window without a frame and window decorations\n"
3936 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
3937 "-no-quit disable SDL window close capability\n"
3938 "-sdl enable SDL\n"
3939 #endif
3940 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
3941 "-vga [std|cirrus|vmware|none]\n"
3942 " select video card type\n"
3943 "-full-screen start in full screen\n"
3944 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
3945 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
3946 #endif
3947 "-vnc display start a VNC server on display\n"
3948 "\n"
3949 "Network options:\n"
3950 "-net nic[,vlan=n][,macaddr=addr][,model=type][,name=str]\n"
3951 " create a new Network Interface Card and connect it to VLAN 'n'\n"
3952 #ifdef CONFIG_SLIRP
3953 "-net user[,vlan=n][,name=str][,hostname=host]\n"
3954 " connect the user mode network stack to VLAN 'n' and send\n"
3955 " hostname 'host' to DHCP clients\n"
3956 #endif
3957 #ifdef _WIN32
3958 "-net tap[,vlan=n][,name=str],ifname=name\n"
3959 " connect the host TAP network interface to VLAN 'n'\n"
3960 #else
3961 "-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
3962 " connect the host TAP network interface to VLAN 'n' and use the\n"
3963 " network scripts 'file' (default=%s)\n"
3964 " and 'dfile' (default=%s);\n"
3965 " use '[down]script=no' to disable script execution;\n"
3966 " use 'fd=h' to connect to an already opened TAP interface\n"
3967 #endif
3968 "-net socket[,vlan=n][,name=str][,fd=h][,listen=[host]:port][,connect=host:port]\n"
3969 " connect the vlan 'n' to another VLAN using a socket connection\n"
3970 "-net socket[,vlan=n][,name=str][,fd=h][,mcast=maddr:port]\n"
3971 " connect the vlan 'n' to multicast maddr and port\n"
3972 #ifdef CONFIG_VDE
3973 "-net vde[,vlan=n][,name=str][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
3974 " connect the vlan 'n' to port 'n' of a vde switch running\n"
3975 " on host and listening for incoming connections on 'socketpath'.\n"
3976 " Use group 'groupname' and mode 'octalmode' to change default\n"
3977 " ownership and permissions for communication port.\n"
3978 #endif
3979 "-net none use it alone to have zero network devices; if no -net option\n"
3980 " is provided, the default is '-net nic -net user'\n"
3981 #ifdef CONFIG_SLIRP
3982 "-tftp dir allow tftp access to files in dir [-net user]\n"
3983 "-bootp file advertise file in BOOTP replies\n"
3984 #ifndef _WIN32
3985 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
3986 #endif
3987 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
3988 " redirect TCP or UDP connections from host to guest [-net user]\n"
3989 #endif
3990 "\n"
3991 "-bt hci,null dumb bluetooth HCI - doesn't respond to commands\n"
3992 "-bt hci,host[:id]\n"
3993 " use host's HCI with the given name\n"
3994 "-bt hci[,vlan=n]\n"
3995 " emulate a standard HCI in virtual scatternet 'n'\n"
3996 "-bt vhci[,vlan=n]\n"
3997 " add host computer to virtual scatternet 'n' using VHCI\n"
3998 "-bt device:dev[,vlan=n]\n"
3999 " emulate a bluetooth device 'dev' in scatternet 'n'\n"
4000 "\n"
4001 #ifdef TARGET_I386
4002 "\n"
4003 "i386 target only:\n"
4004 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
4005 "-rtc-td-hack use it to fix time drift in Windows ACPI HAL\n"
4006 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
4007 "-no-acpi disable ACPI\n"
4008 "-no-hpet disable HPET\n"
4009 #endif
4010 "Linux boot specific:\n"
4011 "-kernel bzImage use 'bzImage' as kernel image\n"
4012 "-append cmdline use 'cmdline' as kernel command line\n"
4013 "-initrd file use 'file' as initial ram disk\n"
4014 "\n"
4015 "Debug/Expert options:\n"
4016 "-serial dev redirect the serial port to char device 'dev'\n"
4017 "-parallel dev redirect the parallel port to char device 'dev'\n"
4018 "-monitor dev redirect the monitor to char device 'dev'\n"
4019 "-pidfile file write PID to 'file'\n"
4020 "-S freeze CPU at startup (use 'c' to start execution)\n"
4021 "-s wait gdb connection to port\n"
4022 "-p port set gdb connection port [default=%s]\n"
4023 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
4024 "-hdachs c,h,s[,t]\n"
4025 " force hard disk 0 physical geometry and the optional BIOS\n"
4026 " translation (t=none or lba) (usually qemu can guess them)\n"
4027 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
4028 "-bios file set the filename for the BIOS\n"
4029 #ifdef USE_KQEMU
4030 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
4031 "-no-kqemu disable KQEMU kernel module usage\n"
4032 #endif
4033 #ifdef CONFIG_KVM
4034 "-enable-kvm enable KVM full virtualization support\n"
4035 #endif
4036 "-no-reboot exit instead of rebooting\n"
4037 "-no-shutdown stop before shutdown\n"
4038 "-loadvm [tag|id]\n"
4039 " start right away with a saved state (loadvm in monitor)\n"
4040 #ifndef _WIN32
4041 "-daemonize daemonize QEMU after initializing\n"
4042 #endif
4043 "-option-rom rom load a file, rom, into the option ROM space\n"
4044 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4045 "-prom-env variable=value\n"
4046 " set OpenBIOS nvram variables\n"
4047 #endif
4048 "-clock force the use of the given methods for timer alarm.\n"
4049 " To see what timers are available use -clock ?\n"
4050 "-localtime set the real time clock to local time [default=utc]\n"
4051 "-startdate select initial date of the clock\n"
4052 "-icount [N|auto]\n"
4053 " enable virtual instruction counter with 2^N clock ticks per instruction\n"
4054 "-echr chr set terminal escape character instead of ctrl-a\n"
4055 "-virtioconsole c\n"
4056 " set virtio console\n"
4057 "-show-cursor show cursor\n"
4058 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4059 "-semihosting semihosting mode\n"
4060 #endif
4061 #if defined(TARGET_ARM)
4062 "-old-param old param mode\n"
4063 #endif
4064 "-tb-size n set TB size\n"
4065 "-incoming p prepare for incoming migration, listen on port p\n"
4066 "\n"
4067 "During emulation, the following keys are useful:\n"
4068 "ctrl-alt-f toggle full screen\n"
4069 "ctrl-alt-n switch to virtual console 'n'\n"
4070 "ctrl-alt toggle mouse and keyboard grab\n"
4071 "\n"
4072 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4073 ,
4074 "qemu",
4075 DEFAULT_RAM_SIZE,
4076 #ifndef _WIN32
4077 DEFAULT_NETWORK_SCRIPT,
4078 DEFAULT_NETWORK_DOWN_SCRIPT,
4079 #endif
4080 DEFAULT_GDBSTUB_PORT,
4081 "/tmp/qemu.log");
4082 exit(exitcode);
4083 }
4084
4085 #define HAS_ARG 0x0001
4086
4087 enum {
4088 /* Please keep in synch with help, qemu_options[] and
4089 qemu-doc.texi */
4090 /* Standard options: */
4091 QEMU_OPTION_h,
4092 QEMU_OPTION_M,
4093 QEMU_OPTION_cpu,
4094 QEMU_OPTION_smp,
4095 QEMU_OPTION_fda,
4096 QEMU_OPTION_fdb,
4097 QEMU_OPTION_hda,
4098 QEMU_OPTION_hdb,
4099 QEMU_OPTION_hdc,
4100 QEMU_OPTION_hdd,
4101 QEMU_OPTION_cdrom,
4102 QEMU_OPTION_drive,
4103 QEMU_OPTION_mtdblock,
4104 QEMU_OPTION_sd,
4105 QEMU_OPTION_pflash,
4106 QEMU_OPTION_boot,
4107 QEMU_OPTION_snapshot,
4108 QEMU_OPTION_m,
4109 QEMU_OPTION_k,
4110 QEMU_OPTION_audio_help,
4111 QEMU_OPTION_soundhw,
4112 QEMU_OPTION_usb,
4113 QEMU_OPTION_usbdevice,
4114 QEMU_OPTION_name,
4115 QEMU_OPTION_uuid,
4116
4117 /* Display options: */
4118 QEMU_OPTION_nographic,
4119 QEMU_OPTION_curses,
4120 QEMU_OPTION_no_frame,
4121 QEMU_OPTION_alt_grab,
4122 QEMU_OPTION_no_quit,
4123 QEMU_OPTION_sdl,
4124 QEMU_OPTION_portrait,
4125 QEMU_OPTION_vga,
4126 QEMU_OPTION_full_screen,
4127 QEMU_OPTION_g,
4128 QEMU_OPTION_vnc,
4129
4130 /* Network options: */
4131 QEMU_OPTION_net,
4132 QEMU_OPTION_tftp,
4133 QEMU_OPTION_bootp,
4134 QEMU_OPTION_smb,
4135 QEMU_OPTION_redir,
4136 QEMU_OPTION_bt,
4137
4138 /* i386 target only: */
4139 QEMU_OPTION_win2k_hack,
4140 QEMU_OPTION_rtc_td_hack,
4141 QEMU_OPTION_no_fd_bootchk,
4142 QEMU_OPTION_no_acpi,
4143 QEMU_OPTION_no_hpet,
4144
4145 /* Linux boot specific: */
4146 QEMU_OPTION_kernel,
4147 QEMU_OPTION_append,
4148 QEMU_OPTION_initrd,
4149
4150 /* Debug/Expert options: */
4151 QEMU_OPTION_serial,
4152 QEMU_OPTION_parallel,
4153 QEMU_OPTION_monitor,
4154 QEMU_OPTION_pidfile,
4155 QEMU_OPTION_S,
4156 QEMU_OPTION_s,
4157 QEMU_OPTION_p,
4158 QEMU_OPTION_d,
4159 QEMU_OPTION_hdachs,
4160 QEMU_OPTION_L,
4161 QEMU_OPTION_bios,
4162 QEMU_OPTION_kernel_kqemu,
4163 QEMU_OPTION_no_kqemu,
4164 QEMU_OPTION_enable_kvm,
4165 QEMU_OPTION_no_reboot,
4166 QEMU_OPTION_no_shutdown,
4167 QEMU_OPTION_loadvm,
4168 QEMU_OPTION_daemonize,
4169 QEMU_OPTION_option_rom,
4170 QEMU_OPTION_prom_env,
4171 QEMU_OPTION_clock,
4172 QEMU_OPTION_localtime,
4173 QEMU_OPTION_startdate,
4174 QEMU_OPTION_icount,
4175 QEMU_OPTION_echr,
4176 QEMU_OPTION_virtiocon,
4177 QEMU_OPTION_show_cursor,
4178 QEMU_OPTION_semihosting,
4179 QEMU_OPTION_old_param,
4180 QEMU_OPTION_tb_size,
4181 QEMU_OPTION_incoming,
4182 };
4183
4184 typedef struct QEMUOption {
4185 const char *name;
4186 int flags;
4187 int index;
4188 } QEMUOption;
4189
4190 static const QEMUOption qemu_options[] = {
4191 /* Please keep in synch with help, QEMU_OPTION_ enums, and
4192 qemu-doc.texi */
4193 /* Standard options: */
4194 { "h", 0, QEMU_OPTION_h },
4195 { "help", 0, QEMU_OPTION_h },
4196 { "M", HAS_ARG, QEMU_OPTION_M },
4197 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
4198 { "smp", HAS_ARG, QEMU_OPTION_smp },
4199 { "fda", HAS_ARG, QEMU_OPTION_fda },
4200 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4201 { "hda", HAS_ARG, QEMU_OPTION_hda },
4202 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4203 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4204 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
4205 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
4206 { "drive", HAS_ARG, QEMU_OPTION_drive },
4207 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
4208 { "sd", HAS_ARG, QEMU_OPTION_sd },
4209 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
4210 { "boot", HAS_ARG, QEMU_OPTION_boot },
4211 { "snapshot", 0, QEMU_OPTION_snapshot },
4212 { "m", HAS_ARG, QEMU_OPTION_m },
4213 #ifndef _WIN32
4214 { "k", HAS_ARG, QEMU_OPTION_k },
4215 #endif
4216 #ifdef HAS_AUDIO
4217 { "audio-help", 0, QEMU_OPTION_audio_help },
4218 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4219 #endif
4220 { "usb", 0, QEMU_OPTION_usb },
4221 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4222 { "name", HAS_ARG, QEMU_OPTION_name },
4223 { "uuid", HAS_ARG, QEMU_OPTION_uuid },
4224
4225 /* Display options: */
4226 { "nographic", 0, QEMU_OPTION_nographic },
4227 #ifdef CONFIG_CURSES
4228 { "curses", 0, QEMU_OPTION_curses },
4229 #endif
4230 #ifdef CONFIG_SDL
4231 { "no-frame", 0, QEMU_OPTION_no_frame },
4232 { "alt-grab", 0, QEMU_OPTION_alt_grab },
4233 { "no-quit", 0, QEMU_OPTION_no_quit },
4234 { "sdl", 0, QEMU_OPTION_sdl },
4235 #endif
4236 { "portrait", 0, QEMU_OPTION_portrait },
4237 { "vga", HAS_ARG, QEMU_OPTION_vga },
4238 { "full-screen", 0, QEMU_OPTION_full_screen },
4239 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4240 { "g", 1, QEMU_OPTION_g },
4241 #endif
4242 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4243
4244 /* Network options: */
4245 { "net", HAS_ARG, QEMU_OPTION_net},
4246 #ifdef CONFIG_SLIRP
4247 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
4248 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
4249 #ifndef _WIN32
4250 { "smb", HAS_ARG, QEMU_OPTION_smb },
4251 #endif
4252 { "redir", HAS_ARG, QEMU_OPTION_redir },
4253 #endif
4254 { "bt", HAS_ARG, QEMU_OPTION_bt },
4255 #ifdef TARGET_I386
4256 /* i386 target only: */
4257 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4258 { "rtc-td-hack", 0, QEMU_OPTION_rtc_td_hack },
4259 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
4260 { "no-acpi", 0, QEMU_OPTION_no_acpi },
4261 { "no-hpet", 0, QEMU_OPTION_no_hpet },
4262 #endif
4263
4264 /* Linux boot specific: */
4265 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4266 { "append", HAS_ARG, QEMU_OPTION_append },
4267 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4268
4269 /* Debug/Expert options: */
4270 { "serial", HAS_ARG, QEMU_OPTION_serial },
4271 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
4272 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
4273 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
4274 { "S", 0, QEMU_OPTION_S },
4275 { "s", 0, QEMU_OPTION_s },
4276 { "p", HAS_ARG, QEMU_OPTION_p },
4277 { "d", HAS_ARG, QEMU_OPTION_d },
4278 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4279 { "L", HAS_ARG, QEMU_OPTION_L },
4280 { "bios", HAS_ARG, QEMU_OPTION_bios },
4281 #ifdef USE_KQEMU
4282 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
4283 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
4284 #endif
4285 #ifdef CONFIG_KVM
4286 { "enable-kvm", 0, QEMU_OPTION_enable_kvm },
4287 #endif
4288 { "no-reboot", 0, QEMU_OPTION_no_reboot },
4289 { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
4290 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4291 { "daemonize", 0, QEMU_OPTION_daemonize },
4292 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
4293 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4294 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
4295 #endif
4296 { "clock", HAS_ARG, QEMU_OPTION_clock },
4297 { "localtime", 0, QEMU_OPTION_localtime },
4298 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
4299 { "icount", HAS_ARG, QEMU_OPTION_icount },
4300 { "echr", HAS_ARG, QEMU_OPTION_echr },
4301 { "virtioconsole", HAS_ARG, QEMU_OPTION_virtiocon },
4302 { "show-cursor", 0, QEMU_OPTION_show_cursor },
4303 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4304 { "semihosting", 0, QEMU_OPTION_semihosting },
4305 #endif
4306 #if defined(TARGET_ARM)
4307 { "old-param", 0, QEMU_OPTION_old_param },
4308 #endif
4309 { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
4310 { "incoming", HAS_ARG, QEMU_OPTION_incoming },
4311 { NULL },
4312 };
4313
4314 /* password input */
4315
4316 int qemu_key_check(BlockDriverState *bs, const char *name)
4317 {
4318 char password[256];
4319 int i;
4320
4321 if (!bdrv_is_encrypted(bs))
4322 return 0;
4323
4324 term_printf("%s is encrypted.\n", name);
4325 for(i = 0; i < 3; i++) {
4326 monitor_readline("Password: ", 1, password, sizeof(password));
4327 if (bdrv_set_key(bs, password) == 0)
4328 return 0;
4329 term_printf("invalid password\n");
4330 }
4331 return -EPERM;
4332 }
4333
4334 static BlockDriverState *get_bdrv(int index)
4335 {
4336 if (index > nb_drives)
4337 return NULL;
4338 return drives_table[index].bdrv;
4339 }
4340
4341 static void read_passwords(void)
4342 {
4343 BlockDriverState *bs;
4344 int i;
4345
4346 for(i = 0; i < 6; i++) {
4347 bs = get_bdrv(i);
4348 if (bs)
4349 qemu_key_check(bs, bdrv_get_device_name(bs));
4350 }
4351 }
4352
4353 #ifdef HAS_AUDIO
4354 struct soundhw soundhw[] = {
4355 #ifdef HAS_AUDIO_CHOICE
4356 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4357 {
4358 "pcspk",
4359 "PC speaker",
4360 0,
4361 1,
4362 { .init_isa = pcspk_audio_init }
4363 },
4364 #endif
4365
4366 #ifdef CONFIG_SB16
4367 {
4368 "sb16",
4369 "Creative Sound Blaster 16",
4370 0,
4371 1,
4372 { .init_isa = SB16_init }
4373 },
4374 #endif
4375
4376 #ifdef CONFIG_CS4231A
4377 {
4378 "cs4231a",
4379 "CS4231A",
4380 0,
4381 1,
4382 { .init_isa = cs4231a_init }
4383 },
4384 #endif
4385
4386 #ifdef CONFIG_ADLIB
4387 {
4388 "adlib",
4389 #ifdef HAS_YMF262
4390 "Yamaha YMF262 (OPL3)",
4391 #else
4392 "Yamaha YM3812 (OPL2)",
4393 #endif
4394 0,
4395 1,
4396 { .init_isa = Adlib_init }
4397 },
4398 #endif
4399
4400 #ifdef CONFIG_GUS
4401 {
4402 "gus",
4403 "Gravis Ultrasound GF1",
4404 0,
4405 1,
4406 { .init_isa = GUS_init }
4407 },
4408 #endif
4409
4410 #ifdef CONFIG_AC97
4411 {
4412 "ac97",
4413 "Intel 82801AA AC97 Audio",
4414 0,
4415 0,
4416 { .init_pci = ac97_init }
4417 },
4418 #endif
4419
4420 #ifdef CONFIG_ES1370
4421 {
4422 "es1370",
4423 "ENSONIQ AudioPCI ES1370",
4424 0,
4425 0,
4426 { .init_pci = es1370_init }
4427 },
4428 #endif
4429
4430 #endif /* HAS_AUDIO_CHOICE */
4431
4432 { NULL, NULL, 0, 0, { NULL } }
4433 };
4434
4435 static void select_soundhw (const char *optarg)
4436 {
4437 struct soundhw *c;
4438
4439 if (*optarg == '?') {
4440 show_valid_cards:
4441
4442 printf ("Valid sound card names (comma separated):\n");
4443 for (c = soundhw; c->name; ++c) {
4444 printf ("%-11s %s\n", c->name, c->descr);
4445 }
4446 printf ("\n-soundhw all will enable all of the above\n");
4447 exit (*optarg != '?');
4448 }
4449 else {
4450 size_t l;
4451 const char *p;
4452 char *e;
4453 int bad_card = 0;
4454
4455 if (!strcmp (optarg, "all")) {
4456 for (c = soundhw; c->name; ++c) {
4457 c->enabled = 1;
4458 }
4459 return;
4460 }
4461
4462 p = optarg;
4463 while (*p) {
4464 e = strchr (p, ',');
4465 l = !e ? strlen (p) : (size_t) (e - p);
4466
4467 for (c = soundhw; c->name; ++c) {
4468 if (!strncmp (c->name, p, l)) {
4469 c->enabled = 1;
4470 break;
4471 }
4472 }
4473
4474 if (!c->name) {
4475 if (l > 80) {
4476 fprintf (stderr,
4477 "Unknown sound card name (too big to show)\n");
4478 }
4479 else {
4480 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4481 (int) l, p);
4482 }
4483 bad_card = 1;
4484 }
4485 p += l + (e != NULL);
4486 }
4487
4488 if (bad_card)
4489 goto show_valid_cards;
4490 }
4491 }
4492 #endif
4493
4494 static void select_vgahw (const char *p)
4495 {
4496 const char *opts;
4497
4498 if (strstart(p, "std", &opts)) {
4499 std_vga_enabled = 1;
4500 cirrus_vga_enabled = 0;
4501 vmsvga_enabled = 0;
4502 } else if (strstart(p, "cirrus", &opts)) {
4503 cirrus_vga_enabled = 1;
4504 std_vga_enabled = 0;
4505 vmsvga_enabled = 0;
4506 } else if (strstart(p, "vmware", &opts)) {
4507 cirrus_vga_enabled = 0;
4508 std_vga_enabled = 0;
4509 vmsvga_enabled = 1;
4510 } else if (strstart(p, "none", &opts)) {
4511 cirrus_vga_enabled = 0;
4512 std_vga_enabled = 0;
4513 vmsvga_enabled = 0;
4514 } else {
4515 invalid_vga:
4516 fprintf(stderr, "Unknown vga type: %s\n", p);
4517 exit(1);
4518 }
4519 while (*opts) {
4520 const char *nextopt;
4521
4522 if (strstart(opts, ",retrace=", &nextopt)) {
4523 opts = nextopt;
4524 if (strstart(opts, "dumb", &nextopt))
4525 vga_retrace_method = VGA_RETRACE_DUMB;
4526 else if (strstart(opts, "precise", &nextopt))
4527 vga_retrace_method = VGA_RETRACE_PRECISE;
4528 else goto invalid_vga;
4529 } else goto invalid_vga;
4530 opts = nextopt;
4531 }
4532 }
4533
4534 #ifdef _WIN32
4535 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4536 {
4537 exit(STATUS_CONTROL_C_EXIT);
4538 return TRUE;
4539 }
4540 #endif
4541
4542 static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4543 {
4544 int ret;
4545
4546 if(strlen(str) != 36)
4547 return -1;
4548
4549 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4550 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4551 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4552
4553 if(ret != 16)
4554 return -1;
4555
4556 return 0;
4557 }
4558
4559 #define MAX_NET_CLIENTS 32
4560
4561 #ifndef _WIN32
4562
4563 static void termsig_handler(int signal)
4564 {
4565 qemu_system_shutdown_request();
4566 }
4567
4568 static void termsig_setup(void)
4569 {
4570 struct sigaction act;
4571
4572 memset(&act, 0, sizeof(act));
4573 act.sa_handler = termsig_handler;
4574 sigaction(SIGINT, &act, NULL);
4575 sigaction(SIGHUP, &act, NULL);
4576 sigaction(SIGTERM, &act, NULL);
4577 }
4578
4579 #endif
4580
4581 int main(int argc, char **argv, char **envp)
4582 {
4583 #ifdef CONFIG_GDBSTUB
4584 int use_gdbstub;
4585 const char *gdbstub_port;
4586 #endif
4587 uint32_t boot_devices_bitmap = 0;
4588 int i;
4589 int snapshot, linux_boot, net_boot;
4590 const char *initrd_filename;
4591 const char *kernel_filename, *kernel_cmdline;
4592 const char *boot_devices = "";
4593 DisplayState *ds;
4594 DisplayChangeListener *dcl;
4595 int cyls, heads, secs, translation;
4596 const char *net_clients[MAX_NET_CLIENTS];
4597 int nb_net_clients;
4598 const char *bt_opts[MAX_BT_CMDLINE];
4599 int nb_bt_opts;
4600 int hda_index;
4601 int optind;
4602 const char *r, *optarg;
4603 CharDriverState *monitor_hd = NULL;
4604 const char *monitor_device;
4605 const char *serial_devices[MAX_SERIAL_PORTS];
4606 int serial_device_index;
4607 const char *parallel_devices[MAX_PARALLEL_PORTS];
4608 int parallel_device_index;
4609 const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4610 int virtio_console_index;
4611 const char *loadvm = NULL;
4612 QEMUMachine *machine;
4613 const char *cpu_model;
4614 const char *usb_devices[MAX_USB_CMDLINE];
4615 int usb_devices_index;
4616 int fds[2];
4617 int tb_size;
4618 const char *pid_file = NULL;
4619 int autostart;
4620 const char *incoming = NULL;
4621
4622 qemu_cache_utils_init(envp);
4623
4624 LIST_INIT (&vm_change_state_head);
4625 #ifndef _WIN32
4626 {
4627 struct sigaction act;
4628 sigfillset(&act.sa_mask);
4629 act.sa_flags = 0;
4630 act.sa_handler = SIG_IGN;
4631 sigaction(SIGPIPE, &act, NULL);
4632 }
4633 #else
4634 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4635 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4636 QEMU to run on a single CPU */
4637 {
4638 HANDLE h;
4639 DWORD mask, smask;
4640 int i;
4641 h = GetCurrentProcess();
4642 if (GetProcessAffinityMask(h, &mask, &smask)) {
4643 for(i = 0; i < 32; i++) {
4644 if (mask & (1 << i))
4645 break;
4646 }
4647 if (i != 32) {
4648 mask = 1 << i;
4649 SetProcessAffinityMask(h, mask);
4650 }
4651 }
4652 }
4653 #endif
4654
4655 register_machines();
4656 machine = first_machine;
4657 cpu_model = NULL;
4658 initrd_filename = NULL;
4659 ram_size = 0;
4660 vga_ram_size = VGA_RAM_SIZE;
4661 #ifdef CONFIG_GDBSTUB
4662 use_gdbstub = 0;
4663 gdbstub_port = DEFAULT_GDBSTUB_PORT;
4664 #endif
4665 snapshot = 0;
4666 nographic = 0;
4667 curses = 0;
4668 kernel_filename = NULL;
4669 kernel_cmdline = "";
4670 cyls = heads = secs = 0;
4671 translation = BIOS_ATA_TRANSLATION_AUTO;
4672 monitor_device = "vc";
4673
4674 serial_devices[0] = "vc:80Cx24C";
4675 for(i = 1; i < MAX_SERIAL_PORTS; i++)
4676 serial_devices[i] = NULL;
4677 serial_device_index = 0;
4678
4679 parallel_devices[0] = "vc:640x480";
4680 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4681 parallel_devices[i] = NULL;
4682 parallel_device_index = 0;
4683
4684 virtio_consoles[0] = "vc:80Cx24C";
4685 for(i = 1; i < MAX_VIRTIO_CONSOLES; i++)
4686 virtio_consoles[i] = NULL;
4687 virtio_console_index = 0;
4688
4689 usb_devices_index = 0;
4690
4691 nb_net_clients = 0;
4692 nb_bt_opts = 0;
4693 nb_drives = 0;
4694 nb_drives_opt = 0;
4695 hda_index = -1;
4696
4697 nb_nics = 0;
4698
4699 tb_size = 0;
4700 autostart= 1;
4701
4702 optind = 1;
4703 for(;;) {
4704 if (optind >= argc)
4705 break;
4706 r = argv[optind];
4707 if (r[0] != '-') {
4708 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4709 } else {
4710 const QEMUOption *popt;
4711
4712 optind++;
4713 /* Treat --foo the same as -foo. */
4714 if (r[1] == '-')
4715 r++;
4716 popt = qemu_options;
4717 for(;;) {
4718 if (!popt->name) {
4719 fprintf(stderr, "%s: invalid option -- '%s'\n",
4720 argv[0], r);
4721 exit(1);
4722 }
4723 if (!strcmp(popt->name, r + 1))
4724 break;
4725 popt++;
4726 }
4727 if (popt->flags & HAS_ARG) {
4728 if (optind >= argc) {
4729 fprintf(stderr, "%s: option '%s' requires an argument\n",
4730 argv[0], r);
4731 exit(1);
4732 }
4733 optarg = argv[optind++];
4734 } else {
4735 optarg = NULL;
4736 }
4737
4738 switch(popt->index) {
4739 case QEMU_OPTION_M:
4740 machine = find_machine(optarg);
4741 if (!machine) {
4742 QEMUMachine *m;
4743 printf("Supported machines are:\n");
4744 for(m = first_machine; m != NULL; m = m->next) {
4745 printf("%-10s %s%s\n",
4746 m->name, m->desc,
4747 m == first_machine ? " (default)" : "");
4748 }
4749 exit(*optarg != '?');
4750 }
4751 break;
4752 case QEMU_OPTION_cpu:
4753 /* hw initialization will check this */
4754 if (*optarg == '?') {
4755 /* XXX: implement xxx_cpu_list for targets that still miss it */
4756 #if defined(cpu_list)
4757 cpu_list(stdout, &fprintf);
4758 #endif
4759 exit(0);
4760 } else {
4761 cpu_model = optarg;
4762 }
4763 break;
4764 case QEMU_OPTION_initrd:
4765 initrd_filename = optarg;
4766 break;
4767 case QEMU_OPTION_hda:
4768 if (cyls == 0)
4769 hda_index = drive_add(optarg, HD_ALIAS, 0);
4770 else
4771 hda_index = drive_add(optarg, HD_ALIAS
4772 ",cyls=%d,heads=%d,secs=%d%s",
4773 0, cyls, heads, secs,
4774 translation == BIOS_ATA_TRANSLATION_LBA ?
4775 ",trans=lba" :
4776 translation == BIOS_ATA_TRANSLATION_NONE ?
4777 ",trans=none" : "");
4778 break;
4779 case QEMU_OPTION_hdb:
4780 case QEMU_OPTION_hdc:
4781 case QEMU_OPTION_hdd:
4782 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4783 break;
4784 case QEMU_OPTION_drive:
4785 drive_add(NULL, "%s", optarg);
4786 break;
4787 case QEMU_OPTION_mtdblock:
4788 drive_add(optarg, MTD_ALIAS);
4789 break;
4790 case QEMU_OPTION_sd:
4791 drive_add(optarg, SD_ALIAS);
4792 break;
4793 case QEMU_OPTION_pflash:
4794 drive_add(optarg, PFLASH_ALIAS);
4795 break;
4796 case QEMU_OPTION_snapshot:
4797 snapshot = 1;
4798 break;
4799 case QEMU_OPTION_hdachs:
4800 {
4801 const char *p;
4802 p = optarg;
4803 cyls = strtol(p, (char **)&p, 0);
4804 if (cyls < 1 || cyls > 16383)
4805 goto chs_fail;
4806 if (*p != ',')
4807 goto chs_fail;
4808 p++;
4809 heads = strtol(p, (char **)&p, 0);
4810 if (heads < 1 || heads > 16)
4811 goto chs_fail;
4812 if (*p != ',')
4813 goto chs_fail;
4814 p++;
4815 secs = strtol(p, (char **)&p, 0);
4816 if (secs < 1 || secs > 63)
4817 goto chs_fail;
4818 if (*p == ',') {
4819 p++;
4820 if (!strcmp(p, "none"))
4821 translation = BIOS_ATA_TRANSLATION_NONE;
4822 else if (!strcmp(p, "lba"))
4823 translation = BIOS_ATA_TRANSLATION_LBA;
4824 else if (!strcmp(p, "auto"))
4825 translation = BIOS_ATA_TRANSLATION_AUTO;
4826 else
4827 goto chs_fail;
4828 } else if (*p != '\0') {
4829 chs_fail:
4830 fprintf(stderr, "qemu: invalid physical CHS format\n");
4831 exit(1);
4832 }
4833 if (hda_index != -1)
4834 snprintf(drives_opt[hda_index].opt,
4835 sizeof(drives_opt[hda_index].opt),
4836 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4837 0, cyls, heads, secs,
4838 translation == BIOS_ATA_TRANSLATION_LBA ?
4839 ",trans=lba" :
4840 translation == BIOS_ATA_TRANSLATION_NONE ?
4841 ",trans=none" : "");
4842 }
4843 break;
4844 case QEMU_OPTION_nographic:
4845 nographic = 1;
4846 break;
4847 #ifdef CONFIG_CURSES
4848 case QEMU_OPTION_curses:
4849 curses = 1;
4850 break;
4851 #endif
4852 case QEMU_OPTION_portrait:
4853 graphic_rotate = 1;
4854 break;
4855 case QEMU_OPTION_kernel:
4856 kernel_filename = optarg;
4857 break;
4858 case QEMU_OPTION_append:
4859 kernel_cmdline = optarg;
4860 break;
4861 case QEMU_OPTION_cdrom:
4862 drive_add(optarg, CDROM_ALIAS);
4863 break;
4864 case QEMU_OPTION_boot:
4865 boot_devices = optarg;
4866 /* We just do some generic consistency checks */
4867 {
4868 /* Could easily be extended to 64 devices if needed */
4869 const char *p;
4870
4871 boot_devices_bitmap = 0;
4872 for (p = boot_devices; *p != '\0'; p++) {
4873 /* Allowed boot devices are:
4874 * a b : floppy disk drives
4875 * c ... f : IDE disk drives
4876 * g ... m : machine implementation dependant drives
4877 * n ... p : network devices
4878 * It's up to each machine implementation to check
4879 * if the given boot devices match the actual hardware
4880 * implementation and firmware features.
4881 */
4882 if (*p < 'a' || *p > 'q') {
4883 fprintf(stderr, "Invalid boot device '%c'\n", *p);
4884 exit(1);
4885 }
4886 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4887 fprintf(stderr,
4888 "Boot device '%c' was given twice\n",*p);
4889 exit(1);
4890 }
4891 boot_devices_bitmap |= 1 << (*p - 'a');
4892 }
4893 }
4894 break;
4895 case QEMU_OPTION_fda:
4896 case QEMU_OPTION_fdb:
4897 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4898 break;
4899 #ifdef TARGET_I386
4900 case QEMU_OPTION_no_fd_bootchk:
4901 fd_bootchk = 0;
4902 break;
4903 #endif
4904 case QEMU_OPTION_net:
4905 if (nb_net_clients >= MAX_NET_CLIENTS) {
4906 fprintf(stderr, "qemu: too many network clients\n");
4907 exit(1);
4908 }
4909 net_clients[nb_net_clients] = optarg;
4910 nb_net_clients++;
4911 break;
4912 #ifdef CONFIG_SLIRP
4913 case QEMU_OPTION_tftp:
4914 tftp_prefix = optarg;
4915 break;
4916 case QEMU_OPTION_bootp:
4917 bootp_filename = optarg;
4918 break;
4919 #ifndef _WIN32
4920 case QEMU_OPTION_smb:
4921 net_slirp_smb(optarg);
4922 break;
4923 #endif
4924 case QEMU_OPTION_redir:
4925 net_slirp_redir(optarg);
4926 break;
4927 #endif
4928 case QEMU_OPTION_bt:
4929 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4930 fprintf(stderr, "qemu: too many bluetooth options\n");
4931 exit(1);
4932 }
4933 bt_opts[nb_bt_opts++] = optarg;
4934 break;
4935 #ifdef HAS_AUDIO
4936 case QEMU_OPTION_audio_help:
4937 AUD_help ();
4938 exit (0);
4939 break;
4940 case QEMU_OPTION_soundhw:
4941 select_soundhw (optarg);
4942 break;
4943 #endif
4944 case QEMU_OPTION_h:
4945 help(0);
4946 break;
4947 case QEMU_OPTION_m: {
4948 uint64_t value;
4949 char *ptr;
4950
4951 value = strtoul(optarg, &ptr, 10);
4952 switch (*ptr) {
4953 case 0: case 'M': case 'm':
4954 value <<= 20;
4955 break;
4956 case 'G': case 'g':
4957 value <<= 30;
4958 break;
4959 default:
4960 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4961 exit(1);
4962 }
4963
4964 /* On 32-bit hosts, QEMU is limited by virtual address space */
4965 if (value > (2047 << 20)
4966 #ifndef USE_KQEMU
4967 && HOST_LONG_BITS == 32
4968 #endif
4969 ) {
4970 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4971 exit(1);
4972 }
4973 if (value != (uint64_t)(ram_addr_t)value) {
4974 fprintf(stderr, "qemu: ram size too large\n");
4975 exit(1);
4976 }
4977 ram_size = value;
4978 break;
4979 }
4980 case QEMU_OPTION_d:
4981 {
4982 int mask;
4983 const CPULogItem *item;
4984
4985 mask = cpu_str_to_log_mask(optarg);
4986 if (!mask) {
4987 printf("Log items (comma separated):\n");
4988 for(item = cpu_log_items; item->mask != 0; item++) {
4989 printf("%-10s %s\n", item->name, item->help);
4990 }
4991 exit(1);
4992 }
4993 cpu_set_log(mask);
4994 }
4995 break;
4996 #ifdef CONFIG_GDBSTUB
4997 case QEMU_OPTION_s:
4998 use_gdbstub = 1;
4999 break;
5000 case QEMU_OPTION_p:
5001 gdbstub_port = optarg;
5002 break;
5003 #endif
5004 case QEMU_OPTION_L:
5005 bios_dir = optarg;
5006 break;
5007 case QEMU_OPTION_bios:
5008 bios_name = optarg;
5009 break;
5010 case QEMU_OPTION_S:
5011 autostart = 0;
5012 break;
5013 case QEMU_OPTION_k:
5014 keyboard_layout = optarg;
5015 break;
5016 case QEMU_OPTION_localtime:
5017 rtc_utc = 0;
5018 break;
5019 case QEMU_OPTION_vga:
5020 select_vgahw (optarg);
5021 break;
5022 case QEMU_OPTION_g:
5023 {
5024 const char *p;
5025 int w, h, depth;
5026 p = optarg;
5027 w = strtol(p, (char **)&p, 10);
5028 if (w <= 0) {
5029 graphic_error:
5030 fprintf(stderr, "qemu: invalid resolution or depth\n");
5031 exit(1);
5032 }
5033 if (*p != 'x')
5034 goto graphic_error;
5035 p++;
5036 h = strtol(p, (char **)&p, 10);
5037 if (h <= 0)
5038 goto graphic_error;
5039 if (*p == 'x') {
5040 p++;
5041 depth = strtol(p, (char **)&p, 10);
5042 if (depth != 8 && depth != 15 && depth != 16 &&
5043 depth != 24 && depth != 32)
5044 goto graphic_error;
5045 } else if (*p == '\0') {
5046 depth = graphic_depth;
5047 } else {
5048 goto graphic_error;
5049 }
5050
5051 graphic_width = w;
5052 graphic_height = h;
5053 graphic_depth = depth;
5054 }
5055 break;
5056 case QEMU_OPTION_echr:
5057 {
5058 char *r;
5059 term_escape_char = strtol(optarg, &r, 0);
5060 if (r == optarg)
5061 printf("Bad argument to echr\n");
5062 break;
5063 }
5064 case QEMU_OPTION_monitor:
5065 monitor_device = optarg;
5066 break;
5067 case QEMU_OPTION_serial:
5068 if (serial_device_index >= MAX_SERIAL_PORTS) {
5069 fprintf(stderr, "qemu: too many serial ports\n");
5070 exit(1);
5071 }
5072 serial_devices[serial_device_index] = optarg;
5073 serial_device_index++;
5074 break;
5075 case QEMU_OPTION_virtiocon:
5076 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5077 fprintf(stderr, "qemu: too many virtio consoles\n");
5078 exit(1);
5079 }
5080 virtio_consoles[virtio_console_index] = optarg;
5081 virtio_console_index++;
5082 break;
5083 case QEMU_OPTION_parallel:
5084 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5085 fprintf(stderr, "qemu: too many parallel ports\n");
5086 exit(1);
5087 }
5088 parallel_devices[parallel_device_index] = optarg;
5089 parallel_device_index++;
5090 break;
5091 case QEMU_OPTION_loadvm:
5092 loadvm = optarg;
5093 break;
5094 case QEMU_OPTION_full_screen:
5095 full_screen = 1;
5096 break;
5097 #ifdef CONFIG_SDL
5098 case QEMU_OPTION_no_frame:
5099 no_frame = 1;
5100 break;
5101 case QEMU_OPTION_alt_grab:
5102 alt_grab = 1;
5103 break;
5104 case QEMU_OPTION_no_quit:
5105 no_quit = 1;
5106 break;
5107 case QEMU_OPTION_sdl:
5108 sdl = 1;
5109 break;
5110 #endif
5111 case QEMU_OPTION_pidfile:
5112 pid_file = optarg;
5113 break;
5114 #ifdef TARGET_I386
5115 case QEMU_OPTION_win2k_hack:
5116 win2k_install_hack = 1;
5117 break;
5118 case QEMU_OPTION_rtc_td_hack:
5119 rtc_td_hack = 1;
5120 break;
5121 #endif
5122 #ifdef USE_KQEMU
5123 case QEMU_OPTION_no_kqemu:
5124 kqemu_allowed = 0;
5125 break;
5126 case QEMU_OPTION_kernel_kqemu:
5127 kqemu_allowed = 2;
5128 break;
5129 #endif
5130 #ifdef CONFIG_KVM
5131 case QEMU_OPTION_enable_kvm:
5132 kvm_allowed = 1;
5133 #ifdef USE_KQEMU
5134 kqemu_allowed = 0;
5135 #endif
5136 break;
5137 #endif
5138 case QEMU_OPTION_usb:
5139 usb_enabled = 1;
5140 break;
5141 case QEMU_OPTION_usbdevice:
5142 usb_enabled = 1;
5143 if (usb_devices_index >= MAX_USB_CMDLINE) {
5144 fprintf(stderr, "Too many USB devices\n");
5145 exit(1);
5146 }
5147 usb_devices[usb_devices_index] = optarg;
5148 usb_devices_index++;
5149 break;
5150 case QEMU_OPTION_smp:
5151 smp_cpus = atoi(optarg);
5152 if (smp_cpus < 1) {
5153 fprintf(stderr, "Invalid number of CPUs\n");
5154 exit(1);
5155 }
5156 break;
5157 case QEMU_OPTION_vnc:
5158 vnc_display = optarg;
5159 break;
5160 case QEMU_OPTION_no_acpi:
5161 acpi_enabled = 0;
5162 break;
5163 case QEMU_OPTION_no_hpet:
5164 no_hpet = 1;
5165 break;
5166 case QEMU_OPTION_no_reboot:
5167 no_reboot = 1;
5168 break;
5169 case QEMU_OPTION_no_shutdown:
5170 no_shutdown = 1;
5171 break;
5172 case QEMU_OPTION_show_cursor:
5173 cursor_hide = 0;
5174 break;
5175 case QEMU_OPTION_uuid:
5176 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5177 fprintf(stderr, "Fail to parse UUID string."
5178 " Wrong format.\n");
5179 exit(1);
5180 }
5181 break;
5182 case QEMU_OPTION_daemonize:
5183 daemonize = 1;
5184 break;
5185 case QEMU_OPTION_option_rom:
5186 if (nb_option_roms >= MAX_OPTION_ROMS) {
5187 fprintf(stderr, "Too many option ROMs\n");
5188 exit(1);
5189 }
5190 option_rom[nb_option_roms] = optarg;
5191 nb_option_roms++;
5192 break;
5193 case QEMU_OPTION_semihosting:
5194 semihosting_enabled = 1;
5195 break;
5196 case QEMU_OPTION_name:
5197 qemu_name = optarg;
5198 break;
5199 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5200 case QEMU_OPTION_prom_env:
5201 if (nb_prom_envs >= MAX_PROM_ENVS) {
5202 fprintf(stderr, "Too many prom variables\n");
5203 exit(1);
5204 }
5205 prom_envs[nb_prom_envs] = optarg;
5206 nb_prom_envs++;
5207 break;
5208 #endif
5209 #ifdef TARGET_ARM
5210 case QEMU_OPTION_old_param:
5211 old_param = 1;
5212 break;
5213 #endif
5214 case QEMU_OPTION_clock:
5215 configure_alarms(optarg);
5216 break;
5217 case QEMU_OPTION_startdate:
5218 {
5219 struct tm tm;
5220 time_t rtc_start_date;
5221 if (!strcmp(optarg, "now")) {
5222 rtc_date_offset = -1;
5223 } else {
5224 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5225 &tm.tm_year,
5226 &tm.tm_mon,
5227 &tm.tm_mday,
5228 &tm.tm_hour,
5229 &tm.tm_min,
5230 &tm.tm_sec) == 6) {
5231 /* OK */
5232 } else if (sscanf(optarg, "%d-%d-%d",
5233 &tm.tm_year,
5234 &tm.tm_mon,
5235 &tm.tm_mday) == 3) {
5236 tm.tm_hour = 0;
5237 tm.tm_min = 0;
5238 tm.tm_sec = 0;
5239 } else {
5240 goto date_fail;
5241 }
5242 tm.tm_year -= 1900;
5243 tm.tm_mon--;
5244 rtc_start_date = mktimegm(&tm);
5245 if (rtc_start_date == -1) {
5246 date_fail:
5247 fprintf(stderr, "Invalid date format. Valid format are:\n"
5248 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5249 exit(1);
5250 }
5251 rtc_date_offset = time(NULL) - rtc_start_date;
5252 }
5253 }
5254 break;
5255 case QEMU_OPTION_tb_size:
5256 tb_size = strtol(optarg, NULL, 0);
5257 if (tb_size < 0)
5258 tb_size = 0;
5259 break;
5260 case QEMU_OPTION_icount:
5261 use_icount = 1;
5262 if (strcmp(optarg, "auto") == 0) {
5263 icount_time_shift = -1;
5264 } else {
5265 icount_time_shift = strtol(optarg, NULL, 0);
5266 }
5267 break;
5268 case QEMU_OPTION_incoming:
5269 incoming = optarg;
5270 break;
5271 }
5272 }
5273 }
5274
5275 #if defined(CONFIG_KVM) && defined(USE_KQEMU)
5276 if (kvm_allowed && kqemu_allowed) {
5277 fprintf(stderr,
5278 "You can not enable both KVM and kqemu at the same time\n");
5279 exit(1);
5280 }
5281 #endif
5282
5283 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5284 if (smp_cpus > machine->max_cpus) {
5285 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5286 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5287 machine->max_cpus);
5288 exit(1);
5289 }
5290
5291 if (nographic) {
5292 if (serial_device_index == 0)
5293 serial_devices[0] = "stdio";
5294 if (parallel_device_index == 0)
5295 parallel_devices[0] = "null";
5296 if (strncmp(monitor_device, "vc", 2) == 0)
5297 monitor_device = "stdio";
5298 if (virtio_console_index == 0)
5299 virtio_consoles[0] = "null";
5300 }
5301
5302 #ifndef _WIN32
5303 if (daemonize) {
5304 pid_t pid;
5305
5306 if (pipe(fds) == -1)
5307 exit(1);
5308
5309 pid = fork();
5310 if (pid > 0) {
5311 uint8_t status;
5312 ssize_t len;
5313
5314 close(fds[1]);
5315
5316 again:
5317 len = read(fds[0], &status, 1);
5318 if (len == -1 && (errno == EINTR))
5319 goto again;
5320
5321 if (len != 1)
5322 exit(1);
5323 else if (status == 1) {
5324 fprintf(stderr, "Could not acquire pidfile\n");
5325 exit(1);
5326 } else
5327 exit(0);
5328 } else if (pid < 0)
5329 exit(1);
5330
5331 setsid();
5332
5333 pid = fork();
5334 if (pid > 0)
5335 exit(0);
5336 else if (pid < 0)
5337 exit(1);
5338
5339 umask(027);
5340
5341 signal(SIGTSTP, SIG_IGN);
5342 signal(SIGTTOU, SIG_IGN);
5343 signal(SIGTTIN, SIG_IGN);
5344 }
5345 #endif
5346
5347 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5348 if (daemonize) {
5349 uint8_t status = 1;
5350 write(fds[1], &status, 1);
5351 } else
5352 fprintf(stderr, "Could not acquire pid file\n");
5353 exit(1);
5354 }
5355
5356 #ifdef USE_KQEMU
5357 if (smp_cpus > 1)
5358 kqemu_allowed = 0;
5359 #endif
5360 linux_boot = (kernel_filename != NULL);
5361 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5362
5363 if (!linux_boot && net_boot == 0 &&
5364 !machine->nodisk_ok && nb_drives_opt == 0)
5365 help(1);
5366
5367 if (!linux_boot && *kernel_cmdline != '\0') {
5368 fprintf(stderr, "-append only allowed with -kernel option\n");
5369 exit(1);
5370 }
5371
5372 if (!linux_boot && initrd_filename != NULL) {
5373 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5374 exit(1);
5375 }
5376
5377 /* boot to floppy or the default cd if no hard disk defined yet */
5378 if (!boot_devices[0]) {
5379 boot_devices = "cad";
5380 }
5381 setvbuf(stdout, NULL, _IOLBF, 0);
5382
5383 init_timers();
5384 if (init_timer_alarm() < 0) {
5385 fprintf(stderr, "could not initialize alarm timer\n");
5386 exit(1);
5387 }
5388 if (use_icount && icount_time_shift < 0) {
5389 use_icount = 2;
5390 /* 125MIPS seems a reasonable initial guess at the guest speed.
5391 It will be corrected fairly quickly anyway. */
5392 icount_time_shift = 3;
5393 init_icount_adjust();
5394 }
5395
5396 #ifdef _WIN32
5397 socket_init();
5398 #endif
5399
5400 /* init network clients */
5401 if (nb_net_clients == 0) {
5402 /* if no clients, we use a default config */
5403 net_clients[nb_net_clients++] = "nic";
5404 #ifdef CONFIG_SLIRP
5405 net_clients[nb_net_clients++] = "user";
5406 #endif
5407 }
5408
5409 for(i = 0;i < nb_net_clients; i++) {
5410 if (net_client_parse(net_clients[i]) < 0)
5411 exit(1);
5412 }
5413 net_client_check();
5414
5415 #ifdef TARGET_I386
5416 /* XXX: this should be moved in the PC machine instantiation code */
5417 if (net_boot != 0) {
5418 int netroms = 0;
5419 for (i = 0; i < nb_nics && i < 4; i++) {
5420 const char *model = nd_table[i].model;
5421 char buf[1024];
5422 if (net_boot & (1 << i)) {
5423 if (model == NULL)
5424 model = "ne2k_pci";
5425 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5426 if (get_image_size(buf) > 0) {
5427 if (nb_option_roms >= MAX_OPTION_ROMS) {
5428 fprintf(stderr, "Too many option ROMs\n");
5429 exit(1);
5430 }
5431 option_rom[nb_option_roms] = strdup(buf);
5432 nb_option_roms++;
5433 netroms++;
5434 }
5435 }
5436 }
5437 if (netroms == 0) {
5438 fprintf(stderr, "No valid PXE rom found for network device\n");
5439 exit(1);
5440 }
5441 }
5442 #endif
5443
5444 /* init the bluetooth world */
5445 for (i = 0; i < nb_bt_opts; i++)
5446 if (bt_parse(bt_opts[i]))
5447 exit(1);
5448
5449 /* init the memory */
5450 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5451
5452 if (machine->ram_require & RAMSIZE_FIXED) {
5453 if (ram_size > 0) {
5454 if (ram_size < phys_ram_size) {
5455 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5456 machine->name, (unsigned long long) phys_ram_size);
5457 exit(-1);
5458 }
5459
5460 phys_ram_size = ram_size;
5461 } else
5462 ram_size = phys_ram_size;
5463 } else {
5464 if (ram_size == 0)
5465 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5466
5467 phys_ram_size += ram_size;
5468 }
5469
5470 phys_ram_base = qemu_vmalloc(phys_ram_size);
5471 if (!phys_ram_base) {
5472 fprintf(stderr, "Could not allocate physical memory\n");
5473 exit(1);
5474 }
5475
5476 /* init the dynamic translator */
5477 cpu_exec_init_all(tb_size * 1024 * 1024);
5478
5479 bdrv_init();
5480
5481 /* we always create the cdrom drive, even if no disk is there */
5482
5483 if (nb_drives_opt < MAX_DRIVES)
5484 drive_add(NULL, CDROM_ALIAS);
5485
5486 /* we always create at least one floppy */
5487
5488 if (nb_drives_opt < MAX_DRIVES)
5489 drive_add(NULL, FD_ALIAS, 0);
5490
5491 /* we always create one sd slot, even if no card is in it */
5492
5493 if (nb_drives_opt < MAX_DRIVES)
5494 drive_add(NULL, SD_ALIAS);
5495
5496 /* open the virtual block devices */
5497
5498 for(i = 0; i < nb_drives_opt; i++)
5499 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5500 exit(1);
5501
5502 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5503 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5504
5505 #ifndef _WIN32
5506 /* must be after terminal init, SDL library changes signal handlers */
5507 termsig_setup();
5508 #endif
5509
5510 /* Maintain compatibility with multiple stdio monitors */
5511 if (!strcmp(monitor_device,"stdio")) {
5512 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5513 const char *devname = serial_devices[i];
5514 if (devname && !strcmp(devname,"mon:stdio")) {
5515 monitor_device = NULL;
5516 break;
5517 } else if (devname && !strcmp(devname,"stdio")) {
5518 monitor_device = NULL;
5519 serial_devices[i] = "mon:stdio";
5520 break;
5521 }
5522 }
5523 }
5524
5525 if (kvm_enabled()) {
5526 int ret;
5527
5528 ret = kvm_init(smp_cpus);
5529 if (ret < 0) {
5530 fprintf(stderr, "failed to initialize KVM\n");
5531 exit(1);
5532 }
5533 }
5534
5535 if (monitor_device) {
5536 monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5537 if (!monitor_hd) {
5538 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5539 exit(1);
5540 }
5541 }
5542
5543 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5544 const char *devname = serial_devices[i];
5545 if (devname && strcmp(devname, "none")) {
5546 char label[32];
5547 snprintf(label, sizeof(label), "serial%d", i);
5548 serial_hds[i] = qemu_chr_open(label, devname, NULL);
5549 if (!serial_hds[i]) {
5550 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5551 devname);
5552 exit(1);
5553 }
5554 }
5555 }
5556
5557 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5558 const char *devname = parallel_devices[i];
5559 if (devname && strcmp(devname, "none")) {
5560 char label[32];
5561 snprintf(label, sizeof(label), "parallel%d", i);
5562 parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5563 if (!parallel_hds[i]) {
5564 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5565 devname);
5566 exit(1);
5567 }
5568 }
5569 }
5570
5571 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5572 const char *devname = virtio_consoles[i];
5573 if (devname && strcmp(devname, "none")) {
5574 char label[32];
5575 snprintf(label, sizeof(label), "virtcon%d", i);
5576 virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5577 if (!virtcon_hds[i]) {
5578 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5579 devname);
5580 exit(1);
5581 }
5582 }
5583 }
5584
5585 machine->init(ram_size, vga_ram_size, boot_devices,
5586 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5587
5588 /* Set KVM's vcpu state to qemu's initial CPUState. */
5589 if (kvm_enabled()) {
5590 int ret;
5591
5592 ret = kvm_sync_vcpus();
5593 if (ret < 0) {
5594 fprintf(stderr, "failed to initialize vcpus\n");
5595 exit(1);
5596 }
5597 }
5598
5599 /* init USB devices */
5600 if (usb_enabled) {
5601 for(i = 0; i < usb_devices_index; i++) {
5602 if (usb_device_add(usb_devices[i]) < 0) {
5603 fprintf(stderr, "Warning: could not add USB device %s\n",
5604 usb_devices[i]);
5605 }
5606 }
5607 }
5608
5609 if (!display_state)
5610 dumb_display_init();
5611 /* just use the first displaystate for the moment */
5612 ds = display_state;
5613 /* terminal init */
5614 if (nographic) {
5615 if (curses) {
5616 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5617 exit(1);
5618 }
5619 } else {
5620 #if defined(CONFIG_CURSES)
5621 if (curses) {
5622 /* At the moment curses cannot be used with other displays */
5623 curses_display_init(ds, full_screen);
5624 } else
5625 #endif
5626 {
5627 if (vnc_display != NULL) {
5628 vnc_display_init(ds);
5629 if (vnc_display_open(ds, vnc_display) < 0)
5630 exit(1);
5631 }
5632 #if defined(CONFIG_SDL)
5633 if (sdl || !vnc_display)
5634 sdl_display_init(ds, full_screen, no_frame);
5635 #elif defined(CONFIG_COCOA)
5636 if (sdl || !vnc_display)
5637 cocoa_display_init(ds, full_screen);
5638 #endif
5639 }
5640 }
5641 dpy_resize(ds);
5642
5643 dcl = ds->listeners;
5644 while (dcl != NULL) {
5645 if (dcl->dpy_refresh != NULL) {
5646 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5647 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5648 }
5649 dcl = dcl->next;
5650 }
5651
5652 if (nographic || (vnc_display && !sdl)) {
5653 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5654 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5655 }
5656
5657 text_consoles_set_display(display_state);
5658
5659 if (monitor_device && monitor_hd)
5660 monitor_init(monitor_hd, !nographic);
5661
5662 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5663 const char *devname = serial_devices[i];
5664 if (devname && strcmp(devname, "none")) {
5665 char label[32];
5666 snprintf(label, sizeof(label), "serial%d", i);
5667 if (strstart(devname, "vc", 0))
5668 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5669 }
5670 }
5671
5672 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5673 const char *devname = parallel_devices[i];
5674 if (devname && strcmp(devname, "none")) {
5675 char label[32];
5676 snprintf(label, sizeof(label), "parallel%d", i);
5677 if (strstart(devname, "vc", 0))
5678 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5679 }
5680 }
5681
5682 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5683 const char *devname = virtio_consoles[i];
5684 if (virtcon_hds[i] && devname) {
5685 char label[32];
5686 snprintf(label, sizeof(label), "virtcon%d", i);
5687 if (strstart(devname, "vc", 0))
5688 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5689 }
5690 }
5691
5692 #ifdef CONFIG_GDBSTUB
5693 if (use_gdbstub) {
5694 /* XXX: use standard host:port notation and modify options
5695 accordingly. */
5696 if (gdbserver_start(gdbstub_port) < 0) {
5697 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
5698 gdbstub_port);
5699 exit(1);
5700 }
5701 }
5702 #endif
5703
5704 if (loadvm)
5705 do_loadvm(loadvm);
5706
5707 if (incoming) {
5708 autostart = 0; /* fixme how to deal with -daemonize */
5709 qemu_start_incoming_migration(incoming);
5710 }
5711
5712 {
5713 /* XXX: simplify init */
5714 read_passwords();
5715 if (autostart) {
5716 vm_start();
5717 }
5718 }
5719
5720 if (daemonize) {
5721 uint8_t status = 0;
5722 ssize_t len;
5723 int fd;
5724
5725 again1:
5726 len = write(fds[1], &status, 1);
5727 if (len == -1 && (errno == EINTR))
5728 goto again1;
5729
5730 if (len != 1)
5731 exit(1);
5732
5733 chdir("/");
5734 TFR(fd = open("/dev/null", O_RDWR));
5735 if (fd == -1)
5736 exit(1);
5737
5738 dup2(fd, 0);
5739 dup2(fd, 1);
5740 dup2(fd, 2);
5741
5742 close(fd);
5743 }
5744
5745 main_loop();
5746 quit_timers();
5747 net_cleanup();
5748
5749 return 0;
5750 }
Qemu copy for testing