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