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