?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
qdev: Add help for property value
[qemu/aliguori-queue.git] / vl.c
blob2fb5b581f460661c50582ec27b240ae980b1e1ee
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 ssize_t ret;
3189
3190 if (io_thread_fd == -1)
3191 return;
3192
3193 ret = write(io_thread_fd, &byte, sizeof(byte));
3194 if (ret < 0 && (errno != EINTR && errno != EAGAIN)) {
3195 fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
3196 strerror(errno));
3197 exit (1);
3198 }
3199 }
3200
3201 static void qemu_event_read(void *opaque)
3202 {
3203 int fd = (unsigned long)opaque;
3204 ssize_t len;
3205
3206 /* Drain the notify pipe */
3207 do {
3208 char buffer[512];
3209 len = read(fd, buffer, sizeof(buffer));
3210 } while ((len == -1 && errno == EINTR) || len > 0);
3211 }
3212
3213 static int qemu_event_init(void)
3214 {
3215 int err;
3216 int fds[2];
3217
3218 err = qemu_pipe(fds);
3219 if (err == -1)
3220 return -errno;
3221
3222 err = fcntl_setfl(fds[0], O_NONBLOCK);
3223 if (err < 0)
3224 goto fail;
3225
3226 err = fcntl_setfl(fds[1], O_NONBLOCK);
3227 if (err < 0)
3228 goto fail;
3229
3230 qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3231 (void *)(unsigned long)fds[0]);
3232
3233 io_thread_fd = fds[1];
3234 return 0;
3235
3236 fail:
3237 close(fds[0]);
3238 close(fds[1]);
3239 return err;
3240 }
3241 #else
3242 HANDLE qemu_event_handle;
3243
3244 static void dummy_event_handler(void *opaque)
3245 {
3246 }
3247
3248 static int qemu_event_init(void)
3249 {
3250 qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3251 if (!qemu_event_handle) {
3252 fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
3253 return -1;
3254 }
3255 qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3256 return 0;
3257 }
3258
3259 static void qemu_event_increment(void)
3260 {
3261 if (!SetEvent(qemu_event_handle)) {
3262 fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
3263 GetLastError());
3264 exit (1);
3265 }
3266 }
3267 #endif
3268
3269 static int cpu_can_run(CPUState *env)
3270 {
3271 if (env->stop)
3272 return 0;
3273 if (env->stopped)
3274 return 0;
3275 return 1;
3276 }
3277
3278 #ifndef CONFIG_IOTHREAD
3279 static int qemu_init_main_loop(void)
3280 {
3281 return qemu_event_init();
3282 }
3283
3284 void qemu_init_vcpu(void *_env)
3285 {
3286 CPUState *env = _env;
3287
3288 env->nr_cores = smp_cores;
3289 env->nr_threads = smp_threads;
3290 if (kvm_enabled())
3291 kvm_init_vcpu(env);
3292 return;
3293 }
3294
3295 int qemu_cpu_self(void *env)
3296 {
3297 return 1;
3298 }
3299
3300 static void resume_all_vcpus(void)
3301 {
3302 }
3303
3304 static void pause_all_vcpus(void)
3305 {
3306 }
3307
3308 void qemu_cpu_kick(void *env)
3309 {
3310 return;
3311 }
3312
3313 void qemu_notify_event(void)
3314 {
3315 CPUState *env = cpu_single_env;
3316
3317 if (env) {
3318 cpu_exit(env);
3319 }
3320 }
3321
3322 void qemu_mutex_lock_iothread(void) {}
3323 void qemu_mutex_unlock_iothread(void) {}
3324
3325 void vm_stop(int reason)
3326 {
3327 do_vm_stop(reason);
3328 }
3329
3330 #else /* CONFIG_IOTHREAD */
3331
3332 #include "qemu-thread.h"
3333
3334 QemuMutex qemu_global_mutex;
3335 static QemuMutex qemu_fair_mutex;
3336
3337 static QemuThread io_thread;
3338
3339 static QemuThread *tcg_cpu_thread;
3340 static QemuCond *tcg_halt_cond;
3341
3342 static int qemu_system_ready;
3343 /* cpu creation */
3344 static QemuCond qemu_cpu_cond;
3345 /* system init */
3346 static QemuCond qemu_system_cond;
3347 static QemuCond qemu_pause_cond;
3348
3349 static void block_io_signals(void);
3350 static void unblock_io_signals(void);
3351 static int tcg_has_work(void);
3352
3353 static int qemu_init_main_loop(void)
3354 {
3355 int ret;
3356
3357 ret = qemu_event_init();
3358 if (ret)
3359 return ret;
3360
3361 qemu_cond_init(&qemu_pause_cond);
3362 qemu_mutex_init(&qemu_fair_mutex);
3363 qemu_mutex_init(&qemu_global_mutex);
3364 qemu_mutex_lock(&qemu_global_mutex);
3365
3366 unblock_io_signals();
3367 qemu_thread_self(&io_thread);
3368
3369 return 0;
3370 }
3371
3372 static void qemu_wait_io_event(CPUState *env)
3373 {
3374 while (!tcg_has_work())
3375 qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3376
3377 qemu_mutex_unlock(&qemu_global_mutex);
3378
3379 /*
3380 * Users of qemu_global_mutex can be starved, having no chance
3381 * to acquire it since this path will get to it first.
3382 * So use another lock to provide fairness.
3383 */
3384 qemu_mutex_lock(&qemu_fair_mutex);
3385 qemu_mutex_unlock(&qemu_fair_mutex);
3386
3387 qemu_mutex_lock(&qemu_global_mutex);
3388 if (env->stop) {
3389 env->stop = 0;
3390 env->stopped = 1;
3391 qemu_cond_signal(&qemu_pause_cond);
3392 }
3393 }
3394
3395 static int qemu_cpu_exec(CPUState *env);
3396
3397 static void *kvm_cpu_thread_fn(void *arg)
3398 {
3399 CPUState *env = arg;
3400
3401 block_io_signals();
3402 qemu_thread_self(env->thread);
3403 if (kvm_enabled())
3404 kvm_init_vcpu(env);
3405
3406 /* signal CPU creation */
3407 qemu_mutex_lock(&qemu_global_mutex);
3408 env->created = 1;
3409 qemu_cond_signal(&qemu_cpu_cond);
3410
3411 /* and wait for machine initialization */
3412 while (!qemu_system_ready)
3413 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3414
3415 while (1) {
3416 if (cpu_can_run(env))
3417 qemu_cpu_exec(env);
3418 qemu_wait_io_event(env);
3419 }
3420
3421 return NULL;
3422 }
3423
3424 static void tcg_cpu_exec(void);
3425
3426 static void *tcg_cpu_thread_fn(void *arg)
3427 {
3428 CPUState *env = arg;
3429
3430 block_io_signals();
3431 qemu_thread_self(env->thread);
3432
3433 /* signal CPU creation */
3434 qemu_mutex_lock(&qemu_global_mutex);
3435 for (env = first_cpu; env != NULL; env = env->next_cpu)
3436 env->created = 1;
3437 qemu_cond_signal(&qemu_cpu_cond);
3438
3439 /* and wait for machine initialization */
3440 while (!qemu_system_ready)
3441 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3442
3443 while (1) {
3444 tcg_cpu_exec();
3445 qemu_wait_io_event(cur_cpu);
3446 }
3447
3448 return NULL;
3449 }
3450
3451 void qemu_cpu_kick(void *_env)
3452 {
3453 CPUState *env = _env;
3454 qemu_cond_broadcast(env->halt_cond);
3455 if (kvm_enabled())
3456 qemu_thread_signal(env->thread, SIGUSR1);
3457 }
3458
3459 int qemu_cpu_self(void *_env)
3460 {
3461 CPUState *env = _env;
3462 QemuThread this;
3463
3464 qemu_thread_self(&this);
3465
3466 return qemu_thread_equal(&this, env->thread);
3467 }
3468
3469 static void cpu_signal(int sig)
3470 {
3471 if (cpu_single_env)
3472 cpu_exit(cpu_single_env);
3473 }
3474
3475 static void block_io_signals(void)
3476 {
3477 sigset_t set;
3478 struct sigaction sigact;
3479
3480 sigemptyset(&set);
3481 sigaddset(&set, SIGUSR2);
3482 sigaddset(&set, SIGIO);
3483 sigaddset(&set, SIGALRM);
3484 pthread_sigmask(SIG_BLOCK, &set, NULL);
3485
3486 sigemptyset(&set);
3487 sigaddset(&set, SIGUSR1);
3488 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3489
3490 memset(&sigact, 0, sizeof(sigact));
3491 sigact.sa_handler = cpu_signal;
3492 sigaction(SIGUSR1, &sigact, NULL);
3493 }
3494
3495 static void unblock_io_signals(void)
3496 {
3497 sigset_t set;
3498
3499 sigemptyset(&set);
3500 sigaddset(&set, SIGUSR2);
3501 sigaddset(&set, SIGIO);
3502 sigaddset(&set, SIGALRM);
3503 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3504
3505 sigemptyset(&set);
3506 sigaddset(&set, SIGUSR1);
3507 pthread_sigmask(SIG_BLOCK, &set, NULL);
3508 }
3509
3510 static void qemu_signal_lock(unsigned int msecs)
3511 {
3512 qemu_mutex_lock(&qemu_fair_mutex);
3513
3514 while (qemu_mutex_trylock(&qemu_global_mutex)) {
3515 qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
3516 if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
3517 break;
3518 }
3519 qemu_mutex_unlock(&qemu_fair_mutex);
3520 }
3521
3522 void qemu_mutex_lock_iothread(void)
3523 {
3524 if (kvm_enabled()) {
3525 qemu_mutex_lock(&qemu_fair_mutex);
3526 qemu_mutex_lock(&qemu_global_mutex);
3527 qemu_mutex_unlock(&qemu_fair_mutex);
3528 } else
3529 qemu_signal_lock(100);
3530 }
3531
3532 void qemu_mutex_unlock_iothread(void)
3533 {
3534 qemu_mutex_unlock(&qemu_global_mutex);
3535 }
3536
3537 static int all_vcpus_paused(void)
3538 {
3539 CPUState *penv = first_cpu;
3540
3541 while (penv) {
3542 if (!penv->stopped)
3543 return 0;
3544 penv = (CPUState *)penv->next_cpu;
3545 }
3546
3547 return 1;
3548 }
3549
3550 static void pause_all_vcpus(void)
3551 {
3552 CPUState *penv = first_cpu;
3553
3554 while (penv) {
3555 penv->stop = 1;
3556 qemu_thread_signal(penv->thread, SIGUSR1);
3557 qemu_cpu_kick(penv);
3558 penv = (CPUState *)penv->next_cpu;
3559 }
3560
3561 while (!all_vcpus_paused()) {
3562 qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
3563 penv = first_cpu;
3564 while (penv) {
3565 qemu_thread_signal(penv->thread, SIGUSR1);
3566 penv = (CPUState *)penv->next_cpu;
3567 }
3568 }
3569 }
3570
3571 static void resume_all_vcpus(void)
3572 {
3573 CPUState *penv = first_cpu;
3574
3575 while (penv) {
3576 penv->stop = 0;
3577 penv->stopped = 0;
3578 qemu_thread_signal(penv->thread, SIGUSR1);
3579 qemu_cpu_kick(penv);
3580 penv = (CPUState *)penv->next_cpu;
3581 }
3582 }
3583
3584 static void tcg_init_vcpu(void *_env)
3585 {
3586 CPUState *env = _env;
3587 /* share a single thread for all cpus with TCG */
3588 if (!tcg_cpu_thread) {
3589 env->thread = qemu_mallocz(sizeof(QemuThread));
3590 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3591 qemu_cond_init(env->halt_cond);
3592 qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
3593 while (env->created == 0)
3594 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3595 tcg_cpu_thread = env->thread;
3596 tcg_halt_cond = env->halt_cond;
3597 } else {
3598 env->thread = tcg_cpu_thread;
3599 env->halt_cond = tcg_halt_cond;
3600 }
3601 }
3602
3603 static void kvm_start_vcpu(CPUState *env)
3604 {
3605 env->thread = qemu_mallocz(sizeof(QemuThread));
3606 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3607 qemu_cond_init(env->halt_cond);
3608 qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
3609 while (env->created == 0)
3610 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3611 }
3612
3613 void qemu_init_vcpu(void *_env)
3614 {
3615 CPUState *env = _env;
3616
3617 env->nr_cores = smp_cores;
3618 env->nr_threads = smp_threads;
3619 if (kvm_enabled())
3620 kvm_start_vcpu(env);
3621 else
3622 tcg_init_vcpu(env);
3623 }
3624
3625 void qemu_notify_event(void)
3626 {
3627 qemu_event_increment();
3628 }
3629
3630 void vm_stop(int reason)
3631 {
3632 QemuThread me;
3633 qemu_thread_self(&me);
3634
3635 if (!qemu_thread_equal(&me, &io_thread)) {
3636 qemu_system_vmstop_request(reason);
3637 /*
3638 * FIXME: should not return to device code in case
3639 * vm_stop() has been requested.
3640 */
3641 if (cpu_single_env) {
3642 cpu_exit(cpu_single_env);
3643 cpu_single_env->stop = 1;
3644 }
3645 return;
3646 }
3647 do_vm_stop(reason);
3648 }
3649
3650 #endif
3651
3652
3653 #ifdef _WIN32
3654 static void host_main_loop_wait(int *timeout)
3655 {
3656 int ret, ret2, i;
3657 PollingEntry *pe;
3658
3659
3660 /* XXX: need to suppress polling by better using win32 events */
3661 ret = 0;
3662 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3663 ret |= pe->func(pe->opaque);
3664 }
3665 if (ret == 0) {
3666 int err;
3667 WaitObjects *w = &wait_objects;
3668
3669 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3670 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3671 if (w->func[ret - WAIT_OBJECT_0])
3672 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3673
3674 /* Check for additional signaled events */
3675 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3676
3677 /* Check if event is signaled */
3678 ret2 = WaitForSingleObject(w->events[i], 0);
3679 if(ret2 == WAIT_OBJECT_0) {
3680 if (w->func[i])
3681 w->func[i](w->opaque[i]);
3682 } else if (ret2 == WAIT_TIMEOUT) {
3683 } else {
3684 err = GetLastError();
3685 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3686 }
3687 }
3688 } else if (ret == WAIT_TIMEOUT) {
3689 } else {
3690 err = GetLastError();
3691 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3692 }
3693 }
3694
3695 *timeout = 0;
3696 }
3697 #else
3698 static void host_main_loop_wait(int *timeout)
3699 {
3700 }
3701 #endif
3702
3703 void main_loop_wait(int timeout)
3704 {
3705 IOHandlerRecord *ioh;
3706 fd_set rfds, wfds, xfds;
3707 int ret, nfds;
3708 struct timeval tv;
3709
3710 qemu_bh_update_timeout(&timeout);
3711
3712 host_main_loop_wait(&timeout);
3713
3714 /* poll any events */
3715 /* XXX: separate device handlers from system ones */
3716 nfds = -1;
3717 FD_ZERO(&rfds);
3718 FD_ZERO(&wfds);
3719 FD_ZERO(&xfds);
3720 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3721 if (ioh->deleted)
3722 continue;
3723 if (ioh->fd_read &&
3724 (!ioh->fd_read_poll ||
3725 ioh->fd_read_poll(ioh->opaque) != 0)) {
3726 FD_SET(ioh->fd, &rfds);
3727 if (ioh->fd > nfds)
3728 nfds = ioh->fd;
3729 }
3730 if (ioh->fd_write) {
3731 FD_SET(ioh->fd, &wfds);
3732 if (ioh->fd > nfds)
3733 nfds = ioh->fd;
3734 }
3735 }
3736
3737 tv.tv_sec = timeout / 1000;
3738 tv.tv_usec = (timeout % 1000) * 1000;
3739
3740 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3741
3742 qemu_mutex_unlock_iothread();
3743 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3744 qemu_mutex_lock_iothread();
3745 if (ret > 0) {
3746 IOHandlerRecord **pioh;
3747
3748 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3749 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3750 ioh->fd_read(ioh->opaque);
3751 }
3752 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3753 ioh->fd_write(ioh->opaque);
3754 }
3755 }
3756
3757 /* remove deleted IO handlers */
3758 pioh = &first_io_handler;
3759 while (*pioh) {
3760 ioh = *pioh;
3761 if (ioh->deleted) {
3762 *pioh = ioh->next;
3763 qemu_free(ioh);
3764 } else
3765 pioh = &ioh->next;
3766 }
3767 }
3768
3769 slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
3770
3771 /* rearm timer, if not periodic */
3772 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
3773 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
3774 qemu_rearm_alarm_timer(alarm_timer);
3775 }
3776
3777 /* vm time timers */
3778 if (vm_running) {
3779 if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3780 qemu_run_timers(&active_timers[QEMU_CLOCK_VIRTUAL],
3781 qemu_get_clock(vm_clock));
3782 }
3783
3784 /* real time timers */
3785 qemu_run_timers(&active_timers[QEMU_CLOCK_REALTIME],
3786 qemu_get_clock(rt_clock));
3787
3788 qemu_run_timers(&active_timers[QEMU_CLOCK_HOST],
3789 qemu_get_clock(host_clock));
3790
3791 /* Check bottom-halves last in case any of the earlier events triggered
3792 them. */
3793 qemu_bh_poll();
3794
3795 }
3796
3797 static int qemu_cpu_exec(CPUState *env)
3798 {
3799 int ret;
3800 #ifdef CONFIG_PROFILER
3801 int64_t ti;
3802 #endif
3803
3804 #ifdef CONFIG_PROFILER
3805 ti = profile_getclock();
3806 #endif
3807 if (use_icount) {
3808 int64_t count;
3809 int decr;
3810 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3811 env->icount_decr.u16.low = 0;
3812 env->icount_extra = 0;
3813 count = qemu_next_deadline();
3814 count = (count + (1 << icount_time_shift) - 1)
3815 >> icount_time_shift;
3816 qemu_icount += count;
3817 decr = (count > 0xffff) ? 0xffff : count;
3818 count -= decr;
3819 env->icount_decr.u16.low = decr;
3820 env->icount_extra = count;
3821 }
3822 ret = cpu_exec(env);
3823 #ifdef CONFIG_PROFILER
3824 qemu_time += profile_getclock() - ti;
3825 #endif
3826 if (use_icount) {
3827 /* Fold pending instructions back into the
3828 instruction counter, and clear the interrupt flag. */
3829 qemu_icount -= (env->icount_decr.u16.low
3830 + env->icount_extra);
3831 env->icount_decr.u32 = 0;
3832 env->icount_extra = 0;
3833 }
3834 return ret;
3835 }
3836
3837 static void tcg_cpu_exec(void)
3838 {
3839 int ret = 0;
3840
3841 if (next_cpu == NULL)
3842 next_cpu = first_cpu;
3843 for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
3844 CPUState *env = cur_cpu = next_cpu;
3845
3846 if (!vm_running)
3847 break;
3848 if (timer_alarm_pending) {
3849 timer_alarm_pending = 0;
3850 break;
3851 }
3852 if (cpu_can_run(env))
3853 ret = qemu_cpu_exec(env);
3854 if (ret == EXCP_DEBUG) {
3855 gdb_set_stop_cpu(env);
3856 debug_requested = 1;
3857 break;
3858 }
3859 }
3860 }
3861
3862 static int cpu_has_work(CPUState *env)
3863 {
3864 if (env->stop)
3865 return 1;
3866 if (env->stopped)
3867 return 0;
3868 if (!env->halted)
3869 return 1;
3870 if (qemu_cpu_has_work(env))
3871 return 1;
3872 return 0;
3873 }
3874
3875 static int tcg_has_work(void)
3876 {
3877 CPUState *env;
3878
3879 for (env = first_cpu; env != NULL; env = env->next_cpu)
3880 if (cpu_has_work(env))
3881 return 1;
3882 return 0;
3883 }
3884
3885 static int qemu_calculate_timeout(void)
3886 {
3887 #ifndef CONFIG_IOTHREAD
3888 int timeout;
3889
3890 if (!vm_running)
3891 timeout = 5000;
3892 else if (tcg_has_work())
3893 timeout = 0;
3894 else if (!use_icount)
3895 timeout = 5000;
3896 else {
3897 /* XXX: use timeout computed from timers */
3898 int64_t add;
3899 int64_t delta;
3900 /* Advance virtual time to the next event. */
3901 if (use_icount == 1) {
3902 /* When not using an adaptive execution frequency
3903 we tend to get badly out of sync with real time,
3904 so just delay for a reasonable amount of time. */
3905 delta = 0;
3906 } else {
3907 delta = cpu_get_icount() - cpu_get_clock();
3908 }
3909 if (delta > 0) {
3910 /* If virtual time is ahead of real time then just
3911 wait for IO. */
3912 timeout = (delta / 1000000) + 1;
3913 } else {
3914 /* Wait for either IO to occur or the next
3915 timer event. */
3916 add = qemu_next_deadline();
3917 /* We advance the timer before checking for IO.
3918 Limit the amount we advance so that early IO
3919 activity won't get the guest too far ahead. */
3920 if (add > 10000000)
3921 add = 10000000;
3922 delta += add;
3923 add = (add + (1 << icount_time_shift) - 1)
3924 >> icount_time_shift;
3925 qemu_icount += add;
3926 timeout = delta / 1000000;
3927 if (timeout < 0)
3928 timeout = 0;
3929 }
3930 }
3931
3932 return timeout;
3933 #else /* CONFIG_IOTHREAD */
3934 return 1000;
3935 #endif
3936 }
3937
3938 static int vm_can_run(void)
3939 {
3940 if (powerdown_requested)
3941 return 0;
3942 if (reset_requested)
3943 return 0;
3944 if (shutdown_requested)
3945 return 0;
3946 if (debug_requested)
3947 return 0;
3948 return 1;
3949 }
3950
3951 qemu_irq qemu_system_powerdown;
3952
3953 static void main_loop(void)
3954 {
3955 int r;
3956
3957 #ifdef CONFIG_IOTHREAD
3958 qemu_system_ready = 1;
3959 qemu_cond_broadcast(&qemu_system_cond);
3960 #endif
3961
3962 for (;;) {
3963 do {
3964 #ifdef CONFIG_PROFILER
3965 int64_t ti;
3966 #endif
3967 #ifndef CONFIG_IOTHREAD
3968 tcg_cpu_exec();
3969 #endif
3970 #ifdef CONFIG_PROFILER
3971 ti = profile_getclock();
3972 #endif
3973 main_loop_wait(qemu_calculate_timeout());
3974 #ifdef CONFIG_PROFILER
3975 dev_time += profile_getclock() - ti;
3976 #endif
3977 } while (vm_can_run());
3978
3979 if (qemu_debug_requested()) {
3980 monitor_protocol_event(QEVENT_DEBUG, NULL);
3981 vm_stop(EXCP_DEBUG);
3982 }
3983 if (qemu_shutdown_requested()) {
3984 monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
3985 if (no_shutdown) {
3986 vm_stop(0);
3987 no_shutdown = 0;
3988 } else
3989 break;
3990 }
3991 if (qemu_reset_requested()) {
3992 monitor_protocol_event(QEVENT_RESET, NULL);
3993 pause_all_vcpus();
3994 qemu_system_reset();
3995 resume_all_vcpus();
3996 }
3997 if (qemu_powerdown_requested()) {
3998 monitor_protocol_event(QEVENT_POWERDOWN, NULL);
3999 qemu_irq_raise(qemu_system_powerdown);
4000 }
4001 if ((r = qemu_vmstop_requested())) {
4002 monitor_protocol_event(QEVENT_STOP, NULL);
4003 vm_stop(r);
4004 }
4005 }
4006 pause_all_vcpus();
4007 }
4008
4009 static void version(void)
4010 {
4011 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4012 }
4013
4014 static void help(int exitcode)
4015 {
4016 version();
4017 printf("usage: %s [options] [disk_image]\n"
4018 "\n"
4019 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4020 "\n"
4021 #define DEF(option, opt_arg, opt_enum, opt_help) \
4022 opt_help
4023 #define DEFHEADING(text) stringify(text) "\n"
4024 #include "qemu-options.h"
4025 #undef DEF
4026 #undef DEFHEADING
4027 #undef GEN_DOCS
4028 "\n"
4029 "During emulation, the following keys are useful:\n"
4030 "ctrl-alt-f toggle full screen\n"
4031 "ctrl-alt-n switch to virtual console 'n'\n"
4032 "ctrl-alt toggle mouse and keyboard grab\n"
4033 "\n"
4034 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4035 ,
4036 "qemu",
4037 DEFAULT_RAM_SIZE,
4038 #ifndef _WIN32
4039 DEFAULT_NETWORK_SCRIPT,
4040 DEFAULT_NETWORK_DOWN_SCRIPT,
4041 #endif
4042 DEFAULT_GDBSTUB_PORT,
4043 "/tmp/qemu.log");
4044 exit(exitcode);
4045 }
4046
4047 #define HAS_ARG 0x0001
4048
4049 enum {
4050 #define DEF(option, opt_arg, opt_enum, opt_help) \
4051 opt_enum,
4052 #define DEFHEADING(text)
4053 #include "qemu-options.h"
4054 #undef DEF
4055 #undef DEFHEADING
4056 #undef GEN_DOCS
4057 };
4058
4059 typedef struct QEMUOption {
4060 const char *name;
4061 int flags;
4062 int index;
4063 } QEMUOption;
4064
4065 static const QEMUOption qemu_options[] = {
4066 { "h", 0, QEMU_OPTION_h },
4067 #define DEF(option, opt_arg, opt_enum, opt_help) \
4068 { option, opt_arg, opt_enum },
4069 #define DEFHEADING(text)
4070 #include "qemu-options.h"
4071 #undef DEF
4072 #undef DEFHEADING
4073 #undef GEN_DOCS
4074 { NULL },
4075 };
4076
4077 #ifdef HAS_AUDIO
4078 struct soundhw soundhw[] = {
4079 #ifdef HAS_AUDIO_CHOICE
4080 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4081 {
4082 "pcspk",
4083 "PC speaker",
4084 0,
4085 1,
4086 { .init_isa = pcspk_audio_init }
4087 },
4088 #endif
4089
4090 #ifdef CONFIG_SB16
4091 {
4092 "sb16",
4093 "Creative Sound Blaster 16",
4094 0,
4095 1,
4096 { .init_isa = SB16_init }
4097 },
4098 #endif
4099
4100 #ifdef CONFIG_CS4231A
4101 {
4102 "cs4231a",
4103 "CS4231A",
4104 0,
4105 1,
4106 { .init_isa = cs4231a_init }
4107 },
4108 #endif
4109
4110 #ifdef CONFIG_ADLIB
4111 {
4112 "adlib",
4113 #ifdef HAS_YMF262
4114 "Yamaha YMF262 (OPL3)",
4115 #else
4116 "Yamaha YM3812 (OPL2)",
4117 #endif
4118 0,
4119 1,
4120 { .init_isa = Adlib_init }
4121 },
4122 #endif
4123
4124 #ifdef CONFIG_GUS
4125 {
4126 "gus",
4127 "Gravis Ultrasound GF1",
4128 0,
4129 1,
4130 { .init_isa = GUS_init }
4131 },
4132 #endif
4133
4134 #ifdef CONFIG_AC97
4135 {
4136 "ac97",
4137 "Intel 82801AA AC97 Audio",
4138 0,
4139 0,
4140 { .init_pci = ac97_init }
4141 },
4142 #endif
4143
4144 #ifdef CONFIG_ES1370
4145 {
4146 "es1370",
4147 "ENSONIQ AudioPCI ES1370",
4148 0,
4149 0,
4150 { .init_pci = es1370_init }
4151 },
4152 #endif
4153
4154 #endif /* HAS_AUDIO_CHOICE */
4155
4156 { NULL, NULL, 0, 0, { NULL } }
4157 };
4158
4159 static void select_soundhw (const char *optarg)
4160 {
4161 struct soundhw *c;
4162
4163 if (*optarg == '?') {
4164 show_valid_cards:
4165
4166 printf ("Valid sound card names (comma separated):\n");
4167 for (c = soundhw; c->name; ++c) {
4168 printf ("%-11s %s\n", c->name, c->descr);
4169 }
4170 printf ("\n-soundhw all will enable all of the above\n");
4171 exit (*optarg != '?');
4172 }
4173 else {
4174 size_t l;
4175 const char *p;
4176 char *e;
4177 int bad_card = 0;
4178
4179 if (!strcmp (optarg, "all")) {
4180 for (c = soundhw; c->name; ++c) {
4181 c->enabled = 1;
4182 }
4183 return;
4184 }
4185
4186 p = optarg;
4187 while (*p) {
4188 e = strchr (p, ',');
4189 l = !e ? strlen (p) : (size_t) (e - p);
4190
4191 for (c = soundhw; c->name; ++c) {
4192 if (!strncmp (c->name, p, l) && !c->name[l]) {
4193 c->enabled = 1;
4194 break;
4195 }
4196 }
4197
4198 if (!c->name) {
4199 if (l > 80) {
4200 fprintf (stderr,
4201 "Unknown sound card name (too big to show)\n");
4202 }
4203 else {
4204 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4205 (int) l, p);
4206 }
4207 bad_card = 1;
4208 }
4209 p += l + (e != NULL);
4210 }
4211
4212 if (bad_card)
4213 goto show_valid_cards;
4214 }
4215 }
4216 #endif
4217
4218 static void select_vgahw (const char *p)
4219 {
4220 const char *opts;
4221
4222 default_vga = 0;
4223 vga_interface_type = VGA_NONE;
4224 if (strstart(p, "std", &opts)) {
4225 vga_interface_type = VGA_STD;
4226 } else if (strstart(p, "cirrus", &opts)) {
4227 vga_interface_type = VGA_CIRRUS;
4228 } else if (strstart(p, "vmware", &opts)) {
4229 vga_interface_type = VGA_VMWARE;
4230 } else if (strstart(p, "xenfb", &opts)) {
4231 vga_interface_type = VGA_XENFB;
4232 } else if (!strstart(p, "none", &opts)) {
4233 invalid_vga:
4234 fprintf(stderr, "Unknown vga type: %s\n", p);
4235 exit(1);
4236 }
4237 while (*opts) {
4238 const char *nextopt;
4239
4240 if (strstart(opts, ",retrace=", &nextopt)) {
4241 opts = nextopt;
4242 if (strstart(opts, "dumb", &nextopt))
4243 vga_retrace_method = VGA_RETRACE_DUMB;
4244 else if (strstart(opts, "precise", &nextopt))
4245 vga_retrace_method = VGA_RETRACE_PRECISE;
4246 else goto invalid_vga;
4247 } else goto invalid_vga;
4248 opts = nextopt;
4249 }
4250 }
4251
4252 #ifdef TARGET_I386
4253 static int balloon_parse(const char *arg)
4254 {
4255 QemuOpts *opts;
4256
4257 if (strcmp(arg, "none") == 0) {
4258 return 0;
4259 }
4260
4261 if (!strncmp(arg, "virtio", 6)) {
4262 if (arg[6] == ',') {
4263 /* have params -> parse them */
4264 opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
4265 if (!opts)
4266 return -1;
4267 } else {
4268 /* create empty opts */
4269 opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4270 }
4271 qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4272 return 0;
4273 }
4274
4275 return -1;
4276 }
4277 #endif
4278
4279 #ifdef _WIN32
4280 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4281 {
4282 exit(STATUS_CONTROL_C_EXIT);
4283 return TRUE;
4284 }
4285 #endif
4286
4287 int qemu_uuid_parse(const char *str, uint8_t *uuid)
4288 {
4289 int ret;
4290
4291 if(strlen(str) != 36)
4292 return -1;
4293
4294 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4295 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4296 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4297
4298 if(ret != 16)
4299 return -1;
4300
4301 #ifdef TARGET_I386
4302 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4303 #endif
4304
4305 return 0;
4306 }
4307
4308 #ifndef _WIN32
4309
4310 static void termsig_handler(int signal)
4311 {
4312 qemu_system_shutdown_request();
4313 }
4314
4315 static void sigchld_handler(int signal)
4316 {
4317 waitpid(-1, NULL, WNOHANG);
4318 }
4319
4320 static void sighandler_setup(void)
4321 {
4322 struct sigaction act;
4323
4324 memset(&act, 0, sizeof(act));
4325 act.sa_handler = termsig_handler;
4326 sigaction(SIGINT, &act, NULL);
4327 sigaction(SIGHUP, &act, NULL);
4328 sigaction(SIGTERM, &act, NULL);
4329
4330 act.sa_handler = sigchld_handler;
4331 act.sa_flags = SA_NOCLDSTOP;
4332 sigaction(SIGCHLD, &act, NULL);
4333 }
4334
4335 #endif
4336
4337 #ifdef _WIN32
4338 /* Look for support files in the same directory as the executable. */
4339 static char *find_datadir(const char *argv0)
4340 {
4341 char *p;
4342 char buf[MAX_PATH];
4343 DWORD len;
4344
4345 len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4346 if (len == 0) {
4347 return NULL;
4348 }
4349
4350 buf[len] = 0;
4351 p = buf + len - 1;
4352 while (p != buf && *p != '\\')
4353 p--;
4354 *p = 0;
4355 if (access(buf, R_OK) == 0) {
4356 return qemu_strdup(buf);
4357 }
4358 return NULL;
4359 }
4360 #else /* !_WIN32 */
4361
4362 /* Find a likely location for support files using the location of the binary.
4363 For installed binaries this will be "$bindir/../share/qemu". When
4364 running from the build tree this will be "$bindir/../pc-bios". */
4365 #define SHARE_SUFFIX "/share/qemu"
4366 #define BUILD_SUFFIX "/pc-bios"
4367 static char *find_datadir(const char *argv0)
4368 {
4369 char *dir;
4370 char *p = NULL;
4371 char *res;
4372 char buf[PATH_MAX];
4373 size_t max_len;
4374
4375 #if defined(__linux__)
4376 {
4377 int len;
4378 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4379 if (len > 0) {
4380 buf[len] = 0;
4381 p = buf;
4382 }
4383 }
4384 #elif defined(__FreeBSD__)
4385 {
4386 int len;
4387 len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4388 if (len > 0) {
4389 buf[len] = 0;
4390 p = buf;
4391 }
4392 }
4393 #endif
4394 /* If we don't have any way of figuring out the actual executable
4395 location then try argv[0]. */
4396 if (!p) {
4397 p = realpath(argv0, buf);
4398 if (!p) {
4399 return NULL;
4400 }
4401 }
4402 dir = dirname(p);
4403 dir = dirname(dir);
4404
4405 max_len = strlen(dir) +
4406 MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4407 res = qemu_mallocz(max_len);
4408 snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4409 if (access(res, R_OK)) {
4410 snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4411 if (access(res, R_OK)) {
4412 qemu_free(res);
4413 res = NULL;
4414 }
4415 }
4416
4417 return res;
4418 }
4419 #undef SHARE_SUFFIX
4420 #undef BUILD_SUFFIX
4421 #endif
4422
4423 char *qemu_find_file(int type, const char *name)
4424 {
4425 int len;
4426 const char *subdir;
4427 char *buf;
4428
4429 /* If name contains path separators then try it as a straight path. */
4430 if ((strchr(name, '/') || strchr(name, '\\'))
4431 && access(name, R_OK) == 0) {
4432 return qemu_strdup(name);
4433 }
4434 switch (type) {
4435 case QEMU_FILE_TYPE_BIOS:
4436 subdir = "";
4437 break;
4438 case QEMU_FILE_TYPE_KEYMAP:
4439 subdir = "keymaps/";
4440 break;
4441 default:
4442 abort();
4443 }
4444 len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4445 buf = qemu_mallocz(len);
4446 snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4447 if (access(buf, R_OK)) {
4448 qemu_free(buf);
4449 return NULL;
4450 }
4451 return buf;
4452 }
4453
4454 static int device_init_func(QemuOpts *opts, void *opaque)
4455 {
4456 DeviceState *dev;
4457
4458 dev = qdev_device_add(opts);
4459 if (!dev)
4460 return -1;
4461 return 0;
4462 }
4463
4464 static int chardev_init_func(QemuOpts *opts, void *opaque)
4465 {
4466 CharDriverState *chr;
4467
4468 chr = qemu_chr_open_opts(opts, NULL);
4469 if (!chr)
4470 return -1;
4471 return 0;
4472 }
4473
4474 static int mon_init_func(QemuOpts *opts, void *opaque)
4475 {
4476 CharDriverState *chr;
4477 const char *chardev;
4478 const char *mode;
4479 int flags;
4480
4481 mode = qemu_opt_get(opts, "mode");
4482 if (mode == NULL) {
4483 mode = "readline";
4484 }
4485 if (strcmp(mode, "readline") == 0) {
4486 flags = MONITOR_USE_READLINE;
4487 } else if (strcmp(mode, "control") == 0) {
4488 flags = MONITOR_USE_CONTROL;
4489 } else {
4490 fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
4491 exit(1);
4492 }
4493
4494 if (qemu_opt_get_bool(opts, "default", 0))
4495 flags |= MONITOR_IS_DEFAULT;
4496
4497 chardev = qemu_opt_get(opts, "chardev");
4498 chr = qemu_chr_find(chardev);
4499 if (chr == NULL) {
4500 fprintf(stderr, "chardev \"%s\" not found\n", chardev);
4501 exit(1);
4502 }
4503
4504 monitor_init(chr, flags);
4505 return 0;
4506 }
4507
4508 static void monitor_parse(const char *optarg, const char *mode)
4509 {
4510 static int monitor_device_index = 0;
4511 QemuOpts *opts;
4512 const char *p;
4513 char label[32];
4514 int def = 0;
4515
4516 if (strstart(optarg, "chardev:", &p)) {
4517 snprintf(label, sizeof(label), "%s", p);
4518 } else {
4519 if (monitor_device_index) {
4520 snprintf(label, sizeof(label), "monitor%d",
4521 monitor_device_index);
4522 } else {
4523 snprintf(label, sizeof(label), "monitor");
4524 def = 1;
4525 }
4526 opts = qemu_chr_parse_compat(label, optarg);
4527 if (!opts) {
4528 fprintf(stderr, "parse error: %s\n", optarg);
4529 exit(1);
4530 }
4531 }
4532
4533 opts = qemu_opts_create(&qemu_mon_opts, label, 1);
4534 if (!opts) {
4535 fprintf(stderr, "duplicate chardev: %s\n", label);
4536 exit(1);
4537 }
4538 qemu_opt_set(opts, "mode", mode);
4539 qemu_opt_set(opts, "chardev", label);
4540 if (def)
4541 qemu_opt_set(opts, "default", "on");
4542 monitor_device_index++;
4543 }
4544
4545 struct device_config {
4546 enum {
4547 DEV_USB, /* -usbdevice */
4548 DEV_BT, /* -bt */
4549 DEV_SERIAL, /* -serial */
4550 DEV_PARALLEL, /* -parallel */
4551 DEV_VIRTCON, /* -virtioconsole */
4552 DEV_DEBUGCON, /* -debugcon */
4553 } type;
4554 const char *cmdline;
4555 QTAILQ_ENTRY(device_config) next;
4556 };
4557 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4558
4559 static void add_device_config(int type, const char *cmdline)
4560 {
4561 struct device_config *conf;
4562
4563 conf = qemu_mallocz(sizeof(*conf));
4564 conf->type = type;
4565 conf->cmdline = cmdline;
4566 QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4567 }
4568
4569 static int foreach_device_config(int type, int (*func)(const char *cmdline))
4570 {
4571 struct device_config *conf;
4572 int rc;
4573
4574 QTAILQ_FOREACH(conf, &device_configs, next) {
4575 if (conf->type != type)
4576 continue;
4577 rc = func(conf->cmdline);
4578 if (0 != rc)
4579 return rc;
4580 }
4581 return 0;
4582 }
4583
4584 static int serial_parse(const char *devname)
4585 {
4586 static int index = 0;
4587 char label[32];
4588
4589 if (strcmp(devname, "none") == 0)
4590 return 0;
4591 if (index == MAX_SERIAL_PORTS) {
4592 fprintf(stderr, "qemu: too many serial ports\n");
4593 exit(1);
4594 }
4595 snprintf(label, sizeof(label), "serial%d", index);
4596 serial_hds[index] = qemu_chr_open(label, devname, NULL);
4597 if (!serial_hds[index]) {
4598 fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
4599 devname, strerror(errno));
4600 return -1;
4601 }
4602 index++;
4603 return 0;
4604 }
4605
4606 static int parallel_parse(const char *devname)
4607 {
4608 static int index = 0;
4609 char label[32];
4610
4611 if (strcmp(devname, "none") == 0)
4612 return 0;
4613 if (index == MAX_PARALLEL_PORTS) {
4614 fprintf(stderr, "qemu: too many parallel ports\n");
4615 exit(1);
4616 }
4617 snprintf(label, sizeof(label), "parallel%d", index);
4618 parallel_hds[index] = qemu_chr_open(label, devname, NULL);
4619 if (!parallel_hds[index]) {
4620 fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
4621 devname, strerror(errno));
4622 return -1;
4623 }
4624 index++;
4625 return 0;
4626 }
4627
4628 static int virtcon_parse(const char *devname)
4629 {
4630 static int index = 0;
4631 char label[32];
4632
4633 if (strcmp(devname, "none") == 0)
4634 return 0;
4635 if (index == MAX_VIRTIO_CONSOLES) {
4636 fprintf(stderr, "qemu: too many virtio consoles\n");
4637 exit(1);
4638 }
4639 snprintf(label, sizeof(label), "virtcon%d", index);
4640 virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
4641 if (!virtcon_hds[index]) {
4642 fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
4643 devname, strerror(errno));
4644 return -1;
4645 }
4646 index++;
4647 return 0;
4648 }
4649
4650 static int debugcon_parse(const char *devname)
4651 {
4652 QemuOpts *opts;
4653
4654 if (!qemu_chr_open("debugcon", devname, NULL)) {
4655 exit(1);
4656 }
4657 opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
4658 if (!opts) {
4659 fprintf(stderr, "qemu: already have a debugcon device\n");
4660 exit(1);
4661 }
4662 qemu_opt_set(opts, "driver", "isa-debugcon");
4663 qemu_opt_set(opts, "chardev", "debugcon");
4664 return 0;
4665 }
4666
4667 static const QEMUOption *lookup_opt(int argc, char **argv,
4668 const char **poptarg, int *poptind)
4669 {
4670 const QEMUOption *popt;
4671 int optind = *poptind;
4672 char *r = argv[optind];
4673 const char *optarg;
4674
4675 optind++;
4676 /* Treat --foo the same as -foo. */
4677 if (r[1] == '-')
4678 r++;
4679 popt = qemu_options;
4680 for(;;) {
4681 if (!popt->name) {
4682 fprintf(stderr, "%s: invalid option -- '%s'\n",
4683 argv[0], r);
4684 exit(1);
4685 }
4686 if (!strcmp(popt->name, r + 1))
4687 break;
4688 popt++;
4689 }
4690 if (popt->flags & HAS_ARG) {
4691 if (optind >= argc) {
4692 fprintf(stderr, "%s: option '%s' requires an argument\n",
4693 argv[0], r);
4694 exit(1);
4695 }
4696 optarg = argv[optind++];
4697 } else {
4698 optarg = NULL;
4699 }
4700
4701 *poptarg = optarg;
4702 *poptind = optind;
4703
4704 return popt;
4705 }
4706
4707 int main(int argc, char **argv, char **envp)
4708 {
4709 const char *gdbstub_dev = NULL;
4710 uint32_t boot_devices_bitmap = 0;
4711 int i;
4712 int snapshot, linux_boot, net_boot;
4713 const char *initrd_filename;
4714 const char *kernel_filename, *kernel_cmdline;
4715 char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4716 DisplayState *ds;
4717 DisplayChangeListener *dcl;
4718 int cyls, heads, secs, translation;
4719 QemuOpts *hda_opts = NULL, *opts;
4720 int optind;
4721 const char *optarg;
4722 const char *loadvm = NULL;
4723 QEMUMachine *machine;
4724 const char *cpu_model;
4725 #ifndef _WIN32
4726 int fds[2];
4727 #endif
4728 int tb_size;
4729 const char *pid_file = NULL;
4730 const char *incoming = NULL;
4731 #ifndef _WIN32
4732 int fd = 0;
4733 struct passwd *pwd = NULL;
4734 const char *chroot_dir = NULL;
4735 const char *run_as = NULL;
4736 #endif
4737 CPUState *env;
4738 int show_vnc_port = 0;
4739 int defconfig = 1;
4740
4741 init_clocks();
4742
4743 qemu_errors_to_file(stderr);
4744 qemu_cache_utils_init(envp);
4745
4746 QLIST_INIT (&vm_change_state_head);
4747 #ifndef _WIN32
4748 {
4749 struct sigaction act;
4750 sigfillset(&act.sa_mask);
4751 act.sa_flags = 0;
4752 act.sa_handler = SIG_IGN;
4753 sigaction(SIGPIPE, &act, NULL);
4754 }
4755 #else
4756 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4757 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4758 QEMU to run on a single CPU */
4759 {
4760 HANDLE h;
4761 DWORD mask, smask;
4762 int i;
4763 h = GetCurrentProcess();
4764 if (GetProcessAffinityMask(h, &mask, &smask)) {
4765 for(i = 0; i < 32; i++) {
4766 if (mask & (1 << i))
4767 break;
4768 }
4769 if (i != 32) {
4770 mask = 1 << i;
4771 SetProcessAffinityMask(h, mask);
4772 }
4773 }
4774 }
4775 #endif
4776
4777 module_call_init(MODULE_INIT_MACHINE);
4778 machine = find_default_machine();
4779 cpu_model = NULL;
4780 initrd_filename = NULL;
4781 ram_size = 0;
4782 snapshot = 0;
4783 kernel_filename = NULL;
4784 kernel_cmdline = "";
4785 cyls = heads = secs = 0;
4786 translation = BIOS_ATA_TRANSLATION_AUTO;
4787
4788 for (i = 0; i < MAX_NODES; i++) {
4789 node_mem[i] = 0;
4790 node_cpumask[i] = 0;
4791 }
4792
4793 nb_numa_nodes = 0;
4794 nb_nics = 0;
4795
4796 tb_size = 0;
4797 autostart= 1;
4798
4799 /* first pass of option parsing */
4800 optind = 1;
4801 while (optind < argc) {
4802 if (argv[optind][0] != '-') {
4803 /* disk image */
4804 continue;
4805 } else {
4806 const QEMUOption *popt;
4807
4808 popt = lookup_opt(argc, argv, &optarg, &optind);
4809 switch (popt->index) {
4810 case QEMU_OPTION_nodefconfig:
4811 defconfig=0;
4812 break;
4813 }
4814 }
4815 }
4816
4817 if (defconfig) {
4818 FILE *fp;
4819 fp = fopen(CONFIG_QEMU_CONFDIR "/qemu.conf", "r");
4820 if (fp) {
4821 if (qemu_config_parse(fp) != 0) {
4822 exit(1);
4823 }
4824 fclose(fp);
4825 }
4826
4827 fp = fopen(CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", "r");
4828 if (fp) {
4829 if (qemu_config_parse(fp) != 0) {
4830 exit(1);
4831 }
4832 fclose(fp);
4833 }
4834 }
4835
4836 /* second pass of option parsing */
4837 optind = 1;
4838 for(;;) {
4839 if (optind >= argc)
4840 break;
4841 if (argv[optind][0] != '-') {
4842 hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4843 } else {
4844 const QEMUOption *popt;
4845
4846 popt = lookup_opt(argc, argv, &optarg, &optind);
4847 switch(popt->index) {
4848 case QEMU_OPTION_M:
4849 machine = find_machine(optarg);
4850 if (!machine) {
4851 QEMUMachine *m;
4852 printf("Supported machines are:\n");
4853 for(m = first_machine; m != NULL; m = m->next) {
4854 if (m->alias)
4855 printf("%-10s %s (alias of %s)\n",
4856 m->alias, m->desc, m->name);
4857 printf("%-10s %s%s\n",
4858 m->name, m->desc,
4859 m->is_default ? " (default)" : "");
4860 }
4861 exit(*optarg != '?');
4862 }
4863 break;
4864 case QEMU_OPTION_cpu:
4865 /* hw initialization will check this */
4866 if (*optarg == '?') {
4867 /* XXX: implement xxx_cpu_list for targets that still miss it */
4868 #if defined(cpu_list)
4869 cpu_list(stdout, &fprintf);
4870 #endif
4871 exit(0);
4872 } else {
4873 cpu_model = optarg;
4874 }
4875 break;
4876 case QEMU_OPTION_initrd:
4877 initrd_filename = optarg;
4878 break;
4879 case QEMU_OPTION_hda:
4880 if (cyls == 0)
4881 hda_opts = drive_add(optarg, HD_ALIAS, 0);
4882 else
4883 hda_opts = drive_add(optarg, HD_ALIAS
4884 ",cyls=%d,heads=%d,secs=%d%s",
4885 0, cyls, heads, secs,
4886 translation == BIOS_ATA_TRANSLATION_LBA ?
4887 ",trans=lba" :
4888 translation == BIOS_ATA_TRANSLATION_NONE ?
4889 ",trans=none" : "");
4890 break;
4891 case QEMU_OPTION_hdb:
4892 case QEMU_OPTION_hdc:
4893 case QEMU_OPTION_hdd:
4894 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4895 break;
4896 case QEMU_OPTION_drive:
4897 drive_add(NULL, "%s", optarg);
4898 break;
4899 case QEMU_OPTION_set:
4900 if (qemu_set_option(optarg) != 0)
4901 exit(1);
4902 break;
4903 case QEMU_OPTION_global:
4904 if (qemu_global_option(optarg) != 0)
4905 exit(1);
4906 break;
4907 case QEMU_OPTION_mtdblock:
4908 drive_add(optarg, MTD_ALIAS);
4909 break;
4910 case QEMU_OPTION_sd:
4911 drive_add(optarg, SD_ALIAS);
4912 break;
4913 case QEMU_OPTION_pflash:
4914 drive_add(optarg, PFLASH_ALIAS);
4915 break;
4916 case QEMU_OPTION_snapshot:
4917 snapshot = 1;
4918 break;
4919 case QEMU_OPTION_hdachs:
4920 {
4921 const char *p;
4922 p = optarg;
4923 cyls = strtol(p, (char **)&p, 0);
4924 if (cyls < 1 || cyls > 16383)
4925 goto chs_fail;
4926 if (*p != ',')
4927 goto chs_fail;
4928 p++;
4929 heads = strtol(p, (char **)&p, 0);
4930 if (heads < 1 || heads > 16)
4931 goto chs_fail;
4932 if (*p != ',')
4933 goto chs_fail;
4934 p++;
4935 secs = strtol(p, (char **)&p, 0);
4936 if (secs < 1 || secs > 63)
4937 goto chs_fail;
4938 if (*p == ',') {
4939 p++;
4940 if (!strcmp(p, "none"))
4941 translation = BIOS_ATA_TRANSLATION_NONE;
4942 else if (!strcmp(p, "lba"))
4943 translation = BIOS_ATA_TRANSLATION_LBA;
4944 else if (!strcmp(p, "auto"))
4945 translation = BIOS_ATA_TRANSLATION_AUTO;
4946 else
4947 goto chs_fail;
4948 } else if (*p != '\0') {
4949 chs_fail:
4950 fprintf(stderr, "qemu: invalid physical CHS format\n");
4951 exit(1);
4952 }
4953 if (hda_opts != NULL) {
4954 char num[16];
4955 snprintf(num, sizeof(num), "%d", cyls);
4956 qemu_opt_set(hda_opts, "cyls", num);
4957 snprintf(num, sizeof(num), "%d", heads);
4958 qemu_opt_set(hda_opts, "heads", num);
4959 snprintf(num, sizeof(num), "%d", secs);
4960 qemu_opt_set(hda_opts, "secs", num);
4961 if (translation == BIOS_ATA_TRANSLATION_LBA)
4962 qemu_opt_set(hda_opts, "trans", "lba");
4963 if (translation == BIOS_ATA_TRANSLATION_NONE)
4964 qemu_opt_set(hda_opts, "trans", "none");
4965 }
4966 }
4967 break;
4968 case QEMU_OPTION_numa:
4969 if (nb_numa_nodes >= MAX_NODES) {
4970 fprintf(stderr, "qemu: too many NUMA nodes\n");
4971 exit(1);
4972 }
4973 numa_add(optarg);
4974 break;
4975 case QEMU_OPTION_nographic:
4976 display_type = DT_NOGRAPHIC;
4977 break;
4978 #ifdef CONFIG_CURSES
4979 case QEMU_OPTION_curses:
4980 display_type = DT_CURSES;
4981 break;
4982 #endif
4983 case QEMU_OPTION_portrait:
4984 graphic_rotate = 1;
4985 break;
4986 case QEMU_OPTION_kernel:
4987 kernel_filename = optarg;
4988 break;
4989 case QEMU_OPTION_append:
4990 kernel_cmdline = optarg;
4991 break;
4992 case QEMU_OPTION_cdrom:
4993 drive_add(optarg, CDROM_ALIAS);
4994 break;
4995 case QEMU_OPTION_boot:
4996 {
4997 static const char * const params[] = {
4998 "order", "once", "menu", NULL
4999 };
5000 char buf[sizeof(boot_devices)];
5001 char *standard_boot_devices;
5002 int legacy = 0;
5003
5004 if (!strchr(optarg, '=')) {
5005 legacy = 1;
5006 pstrcpy(buf, sizeof(buf), optarg);
5007 } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
5008 fprintf(stderr,
5009 "qemu: unknown boot parameter '%s' in '%s'\n",
5010 buf, optarg);
5011 exit(1);
5012 }
5013
5014 if (legacy ||
5015 get_param_value(buf, sizeof(buf), "order", optarg)) {
5016 boot_devices_bitmap = parse_bootdevices(buf);
5017 pstrcpy(boot_devices, sizeof(boot_devices), buf);
5018 }
5019 if (!legacy) {
5020 if (get_param_value(buf, sizeof(buf),
5021 "once", optarg)) {
5022 boot_devices_bitmap |= parse_bootdevices(buf);
5023 standard_boot_devices = qemu_strdup(boot_devices);
5024 pstrcpy(boot_devices, sizeof(boot_devices), buf);
5025 qemu_register_reset(restore_boot_devices,
5026 standard_boot_devices);
5027 }
5028 if (get_param_value(buf, sizeof(buf),
5029 "menu", optarg)) {
5030 if (!strcmp(buf, "on")) {
5031 boot_menu = 1;
5032 } else if (!strcmp(buf, "off")) {
5033 boot_menu = 0;
5034 } else {
5035 fprintf(stderr,
5036 "qemu: invalid option value '%s'\n",
5037 buf);
5038 exit(1);
5039 }
5040 }
5041 }
5042 }
5043 break;
5044 case QEMU_OPTION_fda:
5045 case QEMU_OPTION_fdb:
5046 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5047 break;
5048 #ifdef TARGET_I386
5049 case QEMU_OPTION_no_fd_bootchk:
5050 fd_bootchk = 0;
5051 break;
5052 #endif
5053 case QEMU_OPTION_netdev:
5054 if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
5055 exit(1);
5056 }
5057 break;
5058 case QEMU_OPTION_net:
5059 if (net_client_parse(&qemu_net_opts, optarg) == -1) {
5060 exit(1);
5061 }
5062 break;
5063 #ifdef CONFIG_SLIRP
5064 case QEMU_OPTION_tftp:
5065 legacy_tftp_prefix = optarg;
5066 break;
5067 case QEMU_OPTION_bootp:
5068 legacy_bootp_filename = optarg;
5069 break;
5070 #ifndef _WIN32
5071 case QEMU_OPTION_smb:
5072 if (net_slirp_smb(optarg) < 0)
5073 exit(1);
5074 break;
5075 #endif
5076 case QEMU_OPTION_redir:
5077 if (net_slirp_redir(optarg) < 0)
5078 exit(1);
5079 break;
5080 #endif
5081 case QEMU_OPTION_bt:
5082 add_device_config(DEV_BT, optarg);
5083 break;
5084 #ifdef HAS_AUDIO
5085 case QEMU_OPTION_audio_help:
5086 AUD_help ();
5087 exit (0);
5088 break;
5089 case QEMU_OPTION_soundhw:
5090 select_soundhw (optarg);
5091 break;
5092 #endif
5093 case QEMU_OPTION_h:
5094 help(0);
5095 break;
5096 case QEMU_OPTION_version:
5097 version();
5098 exit(0);
5099 break;
5100 case QEMU_OPTION_m: {
5101 uint64_t value;
5102 char *ptr;
5103
5104 value = strtoul(optarg, &ptr, 10);
5105 switch (*ptr) {
5106 case 0: case 'M': case 'm':
5107 value <<= 20;
5108 break;
5109 case 'G': case 'g':
5110 value <<= 30;
5111 break;
5112 default:
5113 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5114 exit(1);
5115 }
5116
5117 /* On 32-bit hosts, QEMU is limited by virtual address space */
5118 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5119 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5120 exit(1);
5121 }
5122 if (value != (uint64_t)(ram_addr_t)value) {
5123 fprintf(stderr, "qemu: ram size too large\n");
5124 exit(1);
5125 }
5126 ram_size = value;
5127 break;
5128 }
5129 case QEMU_OPTION_d:
5130 {
5131 int mask;
5132 const CPULogItem *item;
5133
5134 mask = cpu_str_to_log_mask(optarg);
5135 if (!mask) {
5136 printf("Log items (comma separated):\n");
5137 for(item = cpu_log_items; item->mask != 0; item++) {
5138 printf("%-10s %s\n", item->name, item->help);
5139 }
5140 exit(1);
5141 }
5142 cpu_set_log(mask);
5143 }
5144 break;
5145 case QEMU_OPTION_s:
5146 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5147 break;
5148 case QEMU_OPTION_gdb:
5149 gdbstub_dev = optarg;
5150 break;
5151 case QEMU_OPTION_L:
5152 data_dir = optarg;
5153 break;
5154 case QEMU_OPTION_bios:
5155 bios_name = optarg;
5156 break;
5157 case QEMU_OPTION_singlestep:
5158 singlestep = 1;
5159 break;
5160 case QEMU_OPTION_S:
5161 autostart = 0;
5162 break;
5163 case QEMU_OPTION_k:
5164 keyboard_layout = optarg;
5165 break;
5166 case QEMU_OPTION_localtime:
5167 rtc_utc = 0;
5168 break;
5169 case QEMU_OPTION_vga:
5170 select_vgahw (optarg);
5171 break;
5172 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5173 case QEMU_OPTION_g:
5174 {
5175 const char *p;
5176 int w, h, depth;
5177 p = optarg;
5178 w = strtol(p, (char **)&p, 10);
5179 if (w <= 0) {
5180 graphic_error:
5181 fprintf(stderr, "qemu: invalid resolution or depth\n");
5182 exit(1);
5183 }
5184 if (*p != 'x')
5185 goto graphic_error;
5186 p++;
5187 h = strtol(p, (char **)&p, 10);
5188 if (h <= 0)
5189 goto graphic_error;
5190 if (*p == 'x') {
5191 p++;
5192 depth = strtol(p, (char **)&p, 10);
5193 if (depth != 8 && depth != 15 && depth != 16 &&
5194 depth != 24 && depth != 32)
5195 goto graphic_error;
5196 } else if (*p == '\0') {
5197 depth = graphic_depth;
5198 } else {
5199 goto graphic_error;
5200 }
5201
5202 graphic_width = w;
5203 graphic_height = h;
5204 graphic_depth = depth;
5205 }
5206 break;
5207 #endif
5208 case QEMU_OPTION_echr:
5209 {
5210 char *r;
5211 term_escape_char = strtol(optarg, &r, 0);
5212 if (r == optarg)
5213 printf("Bad argument to echr\n");
5214 break;
5215 }
5216 case QEMU_OPTION_monitor:
5217 monitor_parse(optarg, "readline");
5218 default_monitor = 0;
5219 break;
5220 case QEMU_OPTION_qmp:
5221 monitor_parse(optarg, "control");
5222 default_monitor = 0;
5223 break;
5224 case QEMU_OPTION_mon:
5225 opts = qemu_opts_parse(&qemu_mon_opts, optarg, "chardev");
5226 if (!opts) {
5227 fprintf(stderr, "parse error: %s\n", optarg);
5228 exit(1);
5229 }
5230 default_monitor = 0;
5231 break;
5232 case QEMU_OPTION_chardev:
5233 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend");
5234 if (!opts) {
5235 fprintf(stderr, "parse error: %s\n", optarg);
5236 exit(1);
5237 }
5238 break;
5239 case QEMU_OPTION_serial:
5240 add_device_config(DEV_SERIAL, optarg);
5241 default_serial = 0;
5242 break;
5243 case QEMU_OPTION_watchdog:
5244 if (watchdog) {
5245 fprintf(stderr,
5246 "qemu: only one watchdog option may be given\n");
5247 return 1;
5248 }
5249 watchdog = optarg;
5250 break;
5251 case QEMU_OPTION_watchdog_action:
5252 if (select_watchdog_action(optarg) == -1) {
5253 fprintf(stderr, "Unknown -watchdog-action parameter\n");
5254 exit(1);
5255 }
5256 break;
5257 case QEMU_OPTION_virtiocon:
5258 add_device_config(DEV_VIRTCON, optarg);
5259 default_virtcon = 0;
5260 break;
5261 case QEMU_OPTION_parallel:
5262 add_device_config(DEV_PARALLEL, optarg);
5263 default_parallel = 0;
5264 break;
5265 case QEMU_OPTION_debugcon:
5266 add_device_config(DEV_DEBUGCON, optarg);
5267 break;
5268 case QEMU_OPTION_loadvm:
5269 loadvm = optarg;
5270 break;
5271 case QEMU_OPTION_full_screen:
5272 full_screen = 1;
5273 break;
5274 #ifdef CONFIG_SDL
5275 case QEMU_OPTION_no_frame:
5276 no_frame = 1;
5277 break;
5278 case QEMU_OPTION_alt_grab:
5279 alt_grab = 1;
5280 break;
5281 case QEMU_OPTION_ctrl_grab:
5282 ctrl_grab = 1;
5283 break;
5284 case QEMU_OPTION_no_quit:
5285 no_quit = 1;
5286 break;
5287 case QEMU_OPTION_sdl:
5288 display_type = DT_SDL;
5289 break;
5290 #endif
5291 case QEMU_OPTION_pidfile:
5292 pid_file = optarg;
5293 break;
5294 #ifdef TARGET_I386
5295 case QEMU_OPTION_win2k_hack:
5296 win2k_install_hack = 1;
5297 break;
5298 case QEMU_OPTION_rtc_td_hack:
5299 rtc_td_hack = 1;
5300 break;
5301 case QEMU_OPTION_acpitable:
5302 if(acpi_table_add(optarg) < 0) {
5303 fprintf(stderr, "Wrong acpi table provided\n");
5304 exit(1);
5305 }
5306 break;
5307 case QEMU_OPTION_smbios:
5308 if(smbios_entry_add(optarg) < 0) {
5309 fprintf(stderr, "Wrong smbios provided\n");
5310 exit(1);
5311 }
5312 break;
5313 #endif
5314 #ifdef CONFIG_KVM
5315 case QEMU_OPTION_enable_kvm:
5316 kvm_allowed = 1;
5317 break;
5318 #endif
5319 case QEMU_OPTION_usb:
5320 usb_enabled = 1;
5321 break;
5322 case QEMU_OPTION_usbdevice:
5323 usb_enabled = 1;
5324 add_device_config(DEV_USB, optarg);
5325 break;
5326 case QEMU_OPTION_device:
5327 if (!qemu_opts_parse(&qemu_device_opts, optarg, "driver")) {
5328 exit(1);
5329 }
5330 break;
5331 case QEMU_OPTION_smp:
5332 smp_parse(optarg);
5333 if (smp_cpus < 1) {
5334 fprintf(stderr, "Invalid number of CPUs\n");
5335 exit(1);
5336 }
5337 if (max_cpus < smp_cpus) {
5338 fprintf(stderr, "maxcpus must be equal to or greater than "
5339 "smp\n");
5340 exit(1);
5341 }
5342 if (max_cpus > 255) {
5343 fprintf(stderr, "Unsupported number of maxcpus\n");
5344 exit(1);
5345 }
5346 break;
5347 case QEMU_OPTION_vnc:
5348 display_type = DT_VNC;
5349 vnc_display = optarg;
5350 break;
5351 #ifdef TARGET_I386
5352 case QEMU_OPTION_no_acpi:
5353 acpi_enabled = 0;
5354 break;
5355 case QEMU_OPTION_no_hpet:
5356 no_hpet = 1;
5357 break;
5358 case QEMU_OPTION_balloon:
5359 if (balloon_parse(optarg) < 0) {
5360 fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5361 exit(1);
5362 }
5363 break;
5364 #endif
5365 case QEMU_OPTION_no_reboot:
5366 no_reboot = 1;
5367 break;
5368 case QEMU_OPTION_no_shutdown:
5369 no_shutdown = 1;
5370 break;
5371 case QEMU_OPTION_show_cursor:
5372 cursor_hide = 0;
5373 break;
5374 case QEMU_OPTION_uuid:
5375 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5376 fprintf(stderr, "Fail to parse UUID string."
5377 " Wrong format.\n");
5378 exit(1);
5379 }
5380 break;
5381 #ifndef _WIN32
5382 case QEMU_OPTION_daemonize:
5383 daemonize = 1;
5384 break;
5385 #endif
5386 case QEMU_OPTION_option_rom:
5387 if (nb_option_roms >= MAX_OPTION_ROMS) {
5388 fprintf(stderr, "Too many option ROMs\n");
5389 exit(1);
5390 }
5391 option_rom[nb_option_roms] = optarg;
5392 nb_option_roms++;
5393 break;
5394 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5395 case QEMU_OPTION_semihosting:
5396 semihosting_enabled = 1;
5397 break;
5398 #endif
5399 case QEMU_OPTION_name:
5400 qemu_name = qemu_strdup(optarg);
5401 {
5402 char *p = strchr(qemu_name, ',');
5403 if (p != NULL) {
5404 *p++ = 0;
5405 if (strncmp(p, "process=", 8)) {
5406 fprintf(stderr, "Unknown subargument %s to -name", p);
5407 exit(1);
5408 }
5409 p += 8;
5410 set_proc_name(p);
5411 }
5412 }
5413 break;
5414 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5415 case QEMU_OPTION_prom_env:
5416 if (nb_prom_envs >= MAX_PROM_ENVS) {
5417 fprintf(stderr, "Too many prom variables\n");
5418 exit(1);
5419 }
5420 prom_envs[nb_prom_envs] = optarg;
5421 nb_prom_envs++;
5422 break;
5423 #endif
5424 #ifdef TARGET_ARM
5425 case QEMU_OPTION_old_param:
5426 old_param = 1;
5427 break;
5428 #endif
5429 case QEMU_OPTION_clock:
5430 configure_alarms(optarg);
5431 break;
5432 case QEMU_OPTION_startdate:
5433 configure_rtc_date_offset(optarg, 1);
5434 break;
5435 case QEMU_OPTION_rtc:
5436 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
5437 if (!opts) {
5438 fprintf(stderr, "parse error: %s\n", optarg);
5439 exit(1);
5440 }
5441 configure_rtc(opts);
5442 break;
5443 case QEMU_OPTION_tb_size:
5444 tb_size = strtol(optarg, NULL, 0);
5445 if (tb_size < 0)
5446 tb_size = 0;
5447 break;
5448 case QEMU_OPTION_icount:
5449 use_icount = 1;
5450 if (strcmp(optarg, "auto") == 0) {
5451 icount_time_shift = -1;
5452 } else {
5453 icount_time_shift = strtol(optarg, NULL, 0);
5454 }
5455 break;
5456 case QEMU_OPTION_incoming:
5457 incoming = optarg;
5458 break;
5459 case QEMU_OPTION_nodefaults:
5460 default_serial = 0;
5461 default_parallel = 0;
5462 default_virtcon = 0;
5463 default_monitor = 0;
5464 default_vga = 0;
5465 default_net = 0;
5466 default_floppy = 0;
5467 default_cdrom = 0;
5468 default_sdcard = 0;
5469 break;
5470 #ifndef _WIN32
5471 case QEMU_OPTION_chroot:
5472 chroot_dir = optarg;
5473 break;
5474 case QEMU_OPTION_runas:
5475 run_as = optarg;
5476 break;
5477 #endif
5478 #ifdef CONFIG_XEN
5479 case QEMU_OPTION_xen_domid:
5480 xen_domid = atoi(optarg);
5481 break;
5482 case QEMU_OPTION_xen_create:
5483 xen_mode = XEN_CREATE;
5484 break;
5485 case QEMU_OPTION_xen_attach:
5486 xen_mode = XEN_ATTACH;
5487 break;
5488 #endif
5489 case QEMU_OPTION_readconfig:
5490 {
5491 FILE *fp;
5492 fp = fopen(optarg, "r");
5493 if (fp == NULL) {
5494 fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5495 exit(1);
5496 }
5497 if (qemu_config_parse(fp) != 0) {
5498 exit(1);
5499 }
5500 fclose(fp);
5501 break;
5502 }
5503 case QEMU_OPTION_writeconfig:
5504 {
5505 FILE *fp;
5506 if (strcmp(optarg, "-") == 0) {
5507 fp = stdout;
5508 } else {
5509 fp = fopen(optarg, "w");
5510 if (fp == NULL) {
5511 fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5512 exit(1);
5513 }
5514 }
5515 qemu_config_write(fp);
5516 fclose(fp);
5517 break;
5518 }
5519 }
5520 }
5521 }
5522
5523 /* If no data_dir is specified then try to find it relative to the
5524 executable path. */
5525 if (!data_dir) {
5526 data_dir = find_datadir(argv[0]);
5527 }
5528 /* If all else fails use the install patch specified when building. */
5529 if (!data_dir) {
5530 data_dir = CONFIG_QEMU_SHAREDIR;
5531 }
5532
5533 /*
5534 * Default to max_cpus = smp_cpus, in case the user doesn't
5535 * specify a max_cpus value.
5536 */
5537 if (!max_cpus)
5538 max_cpus = smp_cpus;
5539
5540 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5541 if (smp_cpus > machine->max_cpus) {
5542 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5543 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5544 machine->max_cpus);
5545 exit(1);
5546 }
5547
5548 qemu_opts_foreach(&qemu_device_opts, default_driver_check, NULL, 0);
5549 qemu_opts_foreach(&qemu_global_opts, default_driver_check, NULL, 0);
5550
5551 if (machine->no_serial) {
5552 default_serial = 0;
5553 }
5554 if (machine->no_parallel) {
5555 default_parallel = 0;
5556 }
5557 if (!machine->use_virtcon) {
5558 default_virtcon = 0;
5559 }
5560 if (machine->no_vga) {
5561 default_vga = 0;
5562 }
5563 if (machine->no_floppy) {
5564 default_floppy = 0;
5565 }
5566 if (machine->no_cdrom) {
5567 default_cdrom = 0;
5568 }
5569 if (machine->no_sdcard) {
5570 default_sdcard = 0;
5571 }
5572
5573 if (display_type == DT_NOGRAPHIC) {
5574 if (default_parallel)
5575 add_device_config(DEV_PARALLEL, "null");
5576 if (default_serial && default_monitor) {
5577 add_device_config(DEV_SERIAL, "mon:stdio");
5578 } else if (default_virtcon && default_monitor) {
5579 add_device_config(DEV_VIRTCON, "mon:stdio");
5580 } else {
5581 if (default_serial)
5582 add_device_config(DEV_SERIAL, "stdio");
5583 if (default_virtcon)
5584 add_device_config(DEV_VIRTCON, "stdio");
5585 if (default_monitor)
5586 monitor_parse("stdio", "readline");
5587 }
5588 } else {
5589 if (default_serial)
5590 add_device_config(DEV_SERIAL, "vc:80Cx24C");
5591 if (default_parallel)
5592 add_device_config(DEV_PARALLEL, "vc:80Cx24C");
5593 if (default_monitor)
5594 monitor_parse("vc:80Cx24C", "readline");
5595 if (default_virtcon)
5596 add_device_config(DEV_VIRTCON, "vc:80Cx24C");
5597 }
5598 if (default_vga)
5599 vga_interface_type = VGA_CIRRUS;
5600
5601 if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0)
5602 exit(1);
5603
5604 #ifndef _WIN32
5605 if (daemonize) {
5606 pid_t pid;
5607
5608 if (pipe(fds) == -1)
5609 exit(1);
5610
5611 pid = fork();
5612 if (pid > 0) {
5613 uint8_t status;
5614 ssize_t len;
5615
5616 close(fds[1]);
5617
5618 again:
5619 len = read(fds[0], &status, 1);
5620 if (len == -1 && (errno == EINTR))
5621 goto again;
5622
5623 if (len != 1)
5624 exit(1);
5625 else if (status == 1) {
5626 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
5627 exit(1);
5628 } else
5629 exit(0);
5630 } else if (pid < 0)
5631 exit(1);
5632
5633 close(fds[0]);
5634 qemu_set_cloexec(fds[1]);
5635
5636 setsid();
5637
5638 pid = fork();
5639 if (pid > 0)
5640 exit(0);
5641 else if (pid < 0)
5642 exit(1);
5643
5644 umask(027);
5645
5646 signal(SIGTSTP, SIG_IGN);
5647 signal(SIGTTOU, SIG_IGN);
5648 signal(SIGTTIN, SIG_IGN);
5649 }
5650 #endif
5651
5652 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5653 #ifndef _WIN32
5654 if (daemonize) {
5655 uint8_t status = 1;
5656 if (write(fds[1], &status, 1) != 1) {
5657 perror("daemonize. Writing to pipe\n");
5658 }
5659 } else
5660 #endif
5661 fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
5662 exit(1);
5663 }
5664
5665 if (kvm_enabled()) {
5666 int ret;
5667
5668 ret = kvm_init(smp_cpus);
5669 if (ret < 0) {
5670 fprintf(stderr, "failed to initialize KVM\n");
5671 exit(1);
5672 }
5673 }
5674
5675 if (qemu_init_main_loop()) {
5676 fprintf(stderr, "qemu_init_main_loop failed\n");
5677 exit(1);
5678 }
5679 linux_boot = (kernel_filename != NULL);
5680
5681 if (!linux_boot && *kernel_cmdline != '\0') {
5682 fprintf(stderr, "-append only allowed with -kernel option\n");
5683 exit(1);
5684 }
5685
5686 if (!linux_boot && initrd_filename != NULL) {
5687 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5688 exit(1);
5689 }
5690
5691 #ifndef _WIN32
5692 /* Win32 doesn't support line-buffering and requires size >= 2 */
5693 setvbuf(stdout, NULL, _IOLBF, 0);
5694 #endif
5695
5696 if (init_timer_alarm() < 0) {
5697 fprintf(stderr, "could not initialize alarm timer\n");
5698 exit(1);
5699 }
5700 if (use_icount && icount_time_shift < 0) {
5701 use_icount = 2;
5702 /* 125MIPS seems a reasonable initial guess at the guest speed.
5703 It will be corrected fairly quickly anyway. */
5704 icount_time_shift = 3;
5705 init_icount_adjust();
5706 }
5707
5708 #ifdef _WIN32
5709 socket_init();
5710 #endif
5711
5712 if (net_init_clients() < 0) {
5713 exit(1);
5714 }
5715
5716 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5717 net_set_boot_mask(net_boot);
5718
5719 /* init the bluetooth world */
5720 if (foreach_device_config(DEV_BT, bt_parse))
5721 exit(1);
5722
5723 /* init the memory */
5724 if (ram_size == 0)
5725 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5726
5727 /* init the dynamic translator */
5728 cpu_exec_init_all(tb_size * 1024 * 1024);
5729
5730 bdrv_init_with_whitelist();
5731
5732 blk_mig_init();
5733
5734 if (default_cdrom) {
5735 /* we always create the cdrom drive, even if no disk is there */
5736 drive_add(NULL, CDROM_ALIAS);
5737 }
5738
5739 if (default_floppy) {
5740 /* we always create at least one floppy */
5741 drive_add(NULL, FD_ALIAS, 0);
5742 }
5743
5744 if (default_sdcard) {
5745 /* we always create one sd slot, even if no card is in it */
5746 drive_add(NULL, SD_ALIAS);
5747 }
5748
5749 /* open the virtual block devices */
5750 if (snapshot)
5751 qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5752 if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5753 exit(1);
5754
5755 vmstate_register(0, &vmstate_timers ,&timers_state);
5756 register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
5757 ram_load, NULL);
5758
5759 if (nb_numa_nodes > 0) {
5760 int i;
5761
5762 if (nb_numa_nodes > smp_cpus) {
5763 nb_numa_nodes = smp_cpus;
5764 }
5765
5766 /* If no memory size if given for any node, assume the default case
5767 * and distribute the available memory equally across all nodes
5768 */
5769 for (i = 0; i < nb_numa_nodes; i++) {
5770 if (node_mem[i] != 0)
5771 break;
5772 }
5773 if (i == nb_numa_nodes) {
5774 uint64_t usedmem = 0;
5775
5776 /* On Linux, the each node's border has to be 8MB aligned,
5777 * the final node gets the rest.
5778 */
5779 for (i = 0; i < nb_numa_nodes - 1; i++) {
5780 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5781 usedmem += node_mem[i];
5782 }
5783 node_mem[i] = ram_size - usedmem;
5784 }
5785
5786 for (i = 0; i < nb_numa_nodes; i++) {
5787 if (node_cpumask[i] != 0)
5788 break;
5789 }
5790 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5791 * must cope with this anyway, because there are BIOSes out there in
5792 * real machines which also use this scheme.
5793 */
5794 if (i == nb_numa_nodes) {
5795 for (i = 0; i < smp_cpus; i++) {
5796 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5797 }
5798 }
5799 }
5800
5801 if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
5802 exit(1);
5803 if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
5804 exit(1);
5805 if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
5806 exit(1);
5807 if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
5808 exit(1);
5809
5810 module_call_init(MODULE_INIT_DEVICE);
5811
5812 if (watchdog) {
5813 i = select_watchdog(watchdog);
5814 if (i > 0)
5815 exit (i == 1 ? 1 : 0);
5816 }
5817
5818 if (machine->compat_props) {
5819 qdev_prop_register_global_list(machine->compat_props);
5820 }
5821 qemu_add_globals();
5822
5823 machine->init(ram_size, boot_devices,
5824 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5825
5826
5827 #ifndef _WIN32
5828 /* must be after terminal init, SDL library changes signal handlers */
5829 sighandler_setup();
5830 #endif
5831
5832 for (env = first_cpu; env != NULL; env = env->next_cpu) {
5833 for (i = 0; i < nb_numa_nodes; i++) {
5834 if (node_cpumask[i] & (1 << env->cpu_index)) {
5835 env->numa_node = i;
5836 }
5837 }
5838 }
5839
5840 current_machine = machine;
5841
5842 /* init USB devices */
5843 if (usb_enabled) {
5844 if (foreach_device_config(DEV_USB, usb_parse) < 0)
5845 exit(1);
5846 }
5847
5848 /* init generic devices */
5849 if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5850 exit(1);
5851
5852 if (!display_state)
5853 dumb_display_init();
5854 /* just use the first displaystate for the moment */
5855 ds = display_state;
5856
5857 if (display_type == DT_DEFAULT) {
5858 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5859 display_type = DT_SDL;
5860 #else
5861 display_type = DT_VNC;
5862 vnc_display = "localhost:0,to=99";
5863 show_vnc_port = 1;
5864 #endif
5865 }
5866
5867
5868 switch (display_type) {
5869 case DT_NOGRAPHIC:
5870 break;
5871 #if defined(CONFIG_CURSES)
5872 case DT_CURSES:
5873 curses_display_init(ds, full_screen);
5874 break;
5875 #endif
5876 #if defined(CONFIG_SDL)
5877 case DT_SDL:
5878 sdl_display_init(ds, full_screen, no_frame);
5879 break;
5880 #elif defined(CONFIG_COCOA)
5881 case DT_SDL:
5882 cocoa_display_init(ds, full_screen);
5883 break;
5884 #endif
5885 case DT_VNC:
5886 vnc_display_init(ds);
5887 if (vnc_display_open(ds, vnc_display) < 0)
5888 exit(1);
5889
5890 if (show_vnc_port) {
5891 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
5892 }
5893 break;
5894 default:
5895 break;
5896 }
5897 dpy_resize(ds);
5898
5899 dcl = ds->listeners;
5900 while (dcl != NULL) {
5901 if (dcl->dpy_refresh != NULL) {
5902 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5903 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5904 }
5905 dcl = dcl->next;
5906 }
5907
5908 if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
5909 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5910 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5911 }
5912
5913 text_consoles_set_display(display_state);
5914
5915 if (qemu_opts_foreach(&qemu_mon_opts, mon_init_func, NULL, 1) != 0)
5916 exit(1);
5917
5918 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5919 fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5920 gdbstub_dev);
5921 exit(1);
5922 }
5923
5924 qdev_machine_creation_done();
5925
5926 if (rom_load_all() != 0) {
5927 fprintf(stderr, "rom loading failed\n");
5928 exit(1);
5929 }
5930
5931 qemu_system_reset();
5932 if (loadvm) {
5933 if (load_vmstate(cur_mon, loadvm) < 0) {
5934 autostart = 0;
5935 }
5936 }
5937
5938 if (incoming) {
5939 qemu_start_incoming_migration(incoming);
5940 } else if (autostart) {
5941 vm_start();
5942 }
5943
5944 #ifndef _WIN32
5945 if (daemonize) {
5946 uint8_t status = 0;
5947 ssize_t len;
5948
5949 again1:
5950 len = write(fds[1], &status, 1);
5951 if (len == -1 && (errno == EINTR))
5952 goto again1;
5953
5954 if (len != 1)
5955 exit(1);
5956
5957 if (chdir("/")) {
5958 perror("not able to chdir to /");
5959 exit(1);
5960 }
5961 TFR(fd = qemu_open("/dev/null", O_RDWR));
5962 if (fd == -1)
5963 exit(1);
5964 }
5965
5966 if (run_as) {
5967 pwd = getpwnam(run_as);
5968 if (!pwd) {
5969 fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5970 exit(1);
5971 }
5972 }
5973
5974 if (chroot_dir) {
5975 if (chroot(chroot_dir) < 0) {
5976 fprintf(stderr, "chroot failed\n");
5977 exit(1);
5978 }
5979 if (chdir("/")) {
5980 perror("not able to chdir to /");
5981 exit(1);
5982 }
5983 }
5984
5985 if (run_as) {
5986 if (setgid(pwd->pw_gid) < 0) {
5987 fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5988 exit(1);
5989 }
5990 if (setuid(pwd->pw_uid) < 0) {
5991 fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5992 exit(1);
5993 }
5994 if (setuid(0) != -1) {
5995 fprintf(stderr, "Dropping privileges failed\n");
5996 exit(1);
5997 }
5998 }
5999
6000 if (daemonize) {
6001 dup2(fd, 0);
6002 dup2(fd, 1);
6003 dup2(fd, 2);
6004
6005 close(fd);
6006 }
6007 #endif
6008
6009 main_loop();
6010 quit_timers();
6011 net_cleanup();
6012
6013 return 0;
6014 }
Anthony Liguori's QEMU queue