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