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