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