4 * Copyright (c) 2003-2008 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
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"
40 #include <sys/times.h>
44 #include <sys/ioctl.h>
45 #include <sys/resource.h>
46 #include <sys/socket.h>
47 #include <netinet/in.h>
49 #if defined(__NetBSD__)
50 #include <net/if_tap.h>
53 #include <linux/if_tun.h>
55 #include <arpa/inet.h>
58 #include <sys/select.h>
61 #if defined(__FreeBSD__) || defined(__DragonFly__)
66 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
67 #include <freebsd/stdlib.h>
72 #include <linux/rtc.h>
73 #include <sys/prctl.h>
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> */
80 #include <linux/ppdev.h>
81 #include <linux/parport.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>
101 #if defined(__OpenBSD__)
105 #if defined(CONFIG_VDE)
106 #include <libvdeplug.h>
111 #include <mmsystem.h>
115 #if defined(__APPLE__) || defined(main)
117 int qemu_main(int argc
, char **argv
, char **envp
);
118 int main(int argc
, char **argv
)
120 return qemu_main(argc
, argv
, NULL
);
123 #define main qemu_main
125 #endif /* CONFIG_SDL */
129 #define main qemu_main
130 #endif /* CONFIG_COCOA */
133 #include "hw/boards.h"
135 #include "hw/pcmcia.h"
137 #include "hw/audiodev.h"
141 #include "hw/watchdog.h"
142 #include "hw/smbios.h"
151 #include "qemu-timer.h"
152 #include "qemu-char.h"
153 #include "cache-utils.h"
156 #include "audio/audio.h"
157 #include "migration.h"
160 #include "qemu-option.h"
161 #include "qemu-config.h"
165 #include "exec-all.h"
167 #include "qemu_socket.h"
169 #include "slirp/libslirp.h"
172 //#define DEBUG_SLIRP
174 #define DEFAULT_RAM_SIZE 128
176 /* Maximum number of monitor devices */
177 #define MAX_MONITOR_DEVICES 10
179 static const char *data_dir
;
180 const char *bios_name
= NULL
;
181 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
182 to store the VM snapshots */
183 struct drivelist drives
= TAILQ_HEAD_INITIALIZER(drives
);
184 struct driveoptlist driveopts
= TAILQ_HEAD_INITIALIZER(driveopts
);
185 enum vga_retrace_method vga_retrace_method
= VGA_RETRACE_DUMB
;
186 static DisplayState
*display_state
;
187 DisplayType display_type
= DT_DEFAULT
;
188 const char* keyboard_layout
= NULL
;
189 int64_t ticks_per_sec
;
192 NICInfo nd_table
[MAX_NICS
];
195 static int rtc_utc
= 1;
196 static int rtc_date_offset
= -1; /* -1 means no change */
197 int vga_interface_type
= VGA_CIRRUS
;
199 int graphic_width
= 1024;
200 int graphic_height
= 768;
201 int graphic_depth
= 8;
203 int graphic_width
= 800;
204 int graphic_height
= 600;
205 int graphic_depth
= 15;
207 static int full_screen
= 0;
209 static int no_frame
= 0;
212 CharDriverState
*serial_hds
[MAX_SERIAL_PORTS
];
213 CharDriverState
*parallel_hds
[MAX_PARALLEL_PORTS
];
214 CharDriverState
*virtcon_hds
[MAX_VIRTIO_CONSOLES
];
216 int win2k_install_hack
= 0;
225 const char *vnc_display
;
226 int acpi_enabled
= 1;
232 int graphic_rotate
= 0;
233 uint8_t irq0override
= 1;
237 const char *watchdog
;
238 const char *option_rom
[MAX_OPTION_ROMS
];
240 int semihosting_enabled
= 0;
244 const char *qemu_name
;
246 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
247 unsigned int nb_prom_envs
= 0;
248 const char *prom_envs
[MAX_PROM_ENVS
];
253 uint64_t node_mem
[MAX_NODES
];
254 uint64_t node_cpumask
[MAX_NODES
];
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
;
269 uint8_t qemu_uuid
[16];
271 static QEMUBootSetHandler
*boot_set_handler
;
272 static void *boot_set_opaque
;
274 /***********************************************************/
275 /* x86 ISA bus support */
277 target_phys_addr_t isa_mem_base
= 0;
280 /***********************************************************/
281 void hw_error(const char *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
);
293 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
295 cpu_dump_state(env
, stderr
, fprintf
, 0);
302 static void set_proc_name(const char *s
)
304 #if defined(__linux__) && defined(PR_SET_NAME)
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
);
319 static QEMUBalloonEvent
*qemu_balloon_event
;
320 void *qemu_balloon_event_opaque
;
322 void qemu_add_balloon_handler(QEMUBalloonEvent
*func
, void *opaque
)
324 qemu_balloon_event
= func
;
325 qemu_balloon_event_opaque
= opaque
;
328 void qemu_balloon(ram_addr_t target
)
330 if (qemu_balloon_event
)
331 qemu_balloon_event(qemu_balloon_event_opaque
, target
);
334 ram_addr_t
qemu_balloon_status(void)
336 if (qemu_balloon_event
)
337 return qemu_balloon_event(qemu_balloon_event_opaque
, 0);
341 /***********************************************************/
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
;
349 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
351 qemu_put_kbd_event_opaque
= opaque
;
352 qemu_put_kbd_event
= func
;
355 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
356 void *opaque
, int absolute
,
359 QEMUPutMouseEntry
*s
, *cursor
;
361 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
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
);
369 if (!qemu_put_mouse_event_head
) {
370 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
374 cursor
= qemu_put_mouse_event_head
;
375 while (cursor
->next
!= NULL
)
376 cursor
= cursor
->next
;
379 qemu_put_mouse_event_current
= s
;
384 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
386 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
388 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
391 cursor
= qemu_put_mouse_event_head
;
392 while (cursor
!= NULL
&& cursor
!= entry
) {
394 cursor
= cursor
->next
;
397 if (cursor
== NULL
) // does not exist or list empty
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
);
408 prev
->next
= entry
->next
;
410 if (qemu_put_mouse_event_current
== entry
)
411 qemu_put_mouse_event_current
= prev
;
413 qemu_free(entry
->qemu_put_mouse_event_name
);
417 void kbd_put_keycode(int keycode
)
419 if (qemu_put_kbd_event
) {
420 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
424 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
426 QEMUPutMouseEvent
*mouse_event
;
427 void *mouse_event_opaque
;
430 if (!qemu_put_mouse_event_current
) {
435 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
437 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
440 if (graphic_rotate
) {
441 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
444 width
= graphic_width
- 1;
445 mouse_event(mouse_event_opaque
,
446 width
- dy
, dx
, dz
, buttons_state
);
448 mouse_event(mouse_event_opaque
,
449 dx
, dy
, dz
, buttons_state
);
453 int kbd_mouse_is_absolute(void)
455 if (!qemu_put_mouse_event_current
)
458 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
461 void do_info_mice(Monitor
*mon
)
463 QEMUPutMouseEntry
*cursor
;
466 if (!qemu_put_mouse_event_head
) {
467 monitor_printf(mon
, "No mouse devices connected\n");
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
);
478 cursor
= cursor
->next
;
482 void do_mouse_set(Monitor
*mon
, int index
)
484 QEMUPutMouseEntry
*cursor
;
487 if (!qemu_put_mouse_event_head
) {
488 monitor_printf(mon
, "No mouse devices connected\n");
492 cursor
= qemu_put_mouse_event_head
;
493 while (cursor
!= NULL
&& index
!= i
) {
495 cursor
= cursor
->next
;
499 qemu_put_mouse_event_current
= cursor
;
501 monitor_printf(mon
, "Mouse at given index not found\n");
504 /* compute with 96 bit intermediate result: (a*b)/c */
505 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
510 #ifdef HOST_WORDS_BIGENDIAN
520 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
521 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
524 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
528 /***********************************************************/
529 /* real time host monotonic timer */
531 #define QEMU_TIMER_BASE 1000000000LL
535 static int64_t clock_freq
;
537 static void init_get_clock(void)
541 ret
= QueryPerformanceFrequency(&freq
);
543 fprintf(stderr
, "Could not calibrate ticks\n");
546 clock_freq
= freq
.QuadPart
;
549 static int64_t get_clock(void)
552 QueryPerformanceCounter(&ti
);
553 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
558 static int use_rt_clock
;
560 static void init_get_clock(void)
563 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
564 || defined(__DragonFly__)
567 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
574 static int64_t get_clock(void)
576 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
577 || defined(__DragonFly__)
580 clock_gettime(CLOCK_MONOTONIC
, &ts
);
581 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
585 /* XXX: using gettimeofday leads to problems if the date
586 changes, so it should be avoided. */
588 gettimeofday(&tv
, NULL
);
589 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
594 /* Return the virtual CPU time, based on the instruction counter. */
595 static int64_t cpu_get_icount(void)
598 CPUState
*env
= cpu_single_env
;;
599 icount
= qemu_icount
;
602 fprintf(stderr
, "Bad clock read\n");
603 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
605 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
608 /***********************************************************/
609 /* guest cycle counter */
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
;
616 /* return the host CPU cycle counter and handle stop/restart */
617 int64_t cpu_get_ticks(void)
620 return cpu_get_icount();
622 if (!cpu_ticks_enabled
) {
623 return cpu_ticks_offset
;
626 ticks
= cpu_get_real_ticks();
627 if (cpu_ticks_prev
> ticks
) {
628 /* Note: non increasing ticks may happen if the host uses
630 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
632 cpu_ticks_prev
= ticks
;
633 return ticks
+ cpu_ticks_offset
;
637 /* return the host CPU monotonic timer and handle stop/restart */
638 static int64_t cpu_get_clock(void)
641 if (!cpu_ticks_enabled
) {
642 return cpu_clock_offset
;
645 return ti
+ cpu_clock_offset
;
649 /* enable cpu_get_ticks() */
650 void cpu_enable_ticks(void)
652 if (!cpu_ticks_enabled
) {
653 cpu_ticks_offset
-= cpu_get_real_ticks();
654 cpu_clock_offset
-= get_clock();
655 cpu_ticks_enabled
= 1;
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)
663 if (cpu_ticks_enabled
) {
664 cpu_ticks_offset
= cpu_get_ticks();
665 cpu_clock_offset
= cpu_get_clock();
666 cpu_ticks_enabled
= 0;
670 /***********************************************************/
673 #define QEMU_TIMER_REALTIME 0
674 #define QEMU_TIMER_VIRTUAL 1
678 /* XXX: add frequency */
686 struct QEMUTimer
*next
;
689 struct qemu_alarm_timer
{
693 int (*start
)(struct qemu_alarm_timer
*t
);
694 void (*stop
)(struct qemu_alarm_timer
*t
);
695 void (*rearm
)(struct qemu_alarm_timer
*t
);
699 #define ALARM_FLAG_DYNTICKS 0x1
700 #define ALARM_FLAG_EXPIRED 0x2
702 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
704 return t
&& (t
->flags
& ALARM_FLAG_DYNTICKS
);
707 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
709 if (!alarm_has_dynticks(t
))
715 /* TODO: MIN_TIMER_REARM_US should be optimized */
716 #define MIN_TIMER_REARM_US 250
718 static struct qemu_alarm_timer
*alarm_timer
;
722 struct qemu_alarm_win32
{
725 } alarm_win32_data
= {0, -1};
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
);
733 static int unix_start_timer(struct qemu_alarm_timer
*t
);
734 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
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
);
742 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
743 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
745 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
746 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
748 #endif /* __linux__ */
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
756 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
758 static void icount_adjust(void)
763 static int64_t last_delta
;
764 /* If the VM is not running, then do nothing. */
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. */
773 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
774 && icount_time_shift
> 0) {
775 /* The guest is getting too far ahead. Slow time down. */
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. */
785 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
788 static void icount_adjust_rt(void * opaque
)
790 qemu_mod_timer(icount_rt_timer
,
791 qemu_get_clock(rt_clock
) + 1000);
795 static void icount_adjust_vm(void * opaque
)
797 qemu_mod_timer(icount_vm_timer
,
798 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
802 static void init_icount_adjust(void)
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
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);
817 static struct qemu_alarm_timer alarm_timers
[] = {
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
},
827 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
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
},
837 static void show_available_alarms(void)
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
);
846 static void configure_alarms(char const *opt
)
850 int count
= ARRAY_SIZE(alarm_timers
) - 1;
853 struct qemu_alarm_timer tmp
;
855 if (!strcmp(opt
, "?")) {
856 show_available_alarms();
862 /* Reorder the array */
863 name
= strtok(arg
, ",");
865 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
866 if (!strcmp(alarm_timers
[i
].name
, name
))
871 fprintf(stderr
, "Unknown clock %s\n", name
);
880 tmp
= alarm_timers
[i
];
881 alarm_timers
[i
] = alarm_timers
[cur
];
882 alarm_timers
[cur
] = tmp
;
886 name
= strtok(NULL
, ",");
892 /* Disable remaining timers */
893 for (i
= cur
; i
< count
; i
++)
894 alarm_timers
[i
].name
= NULL
;
896 show_available_alarms();
904 static QEMUTimer
*active_timers
[2];
906 static QEMUClock
*qemu_new_clock(int type
)
909 clock
= qemu_mallocz(sizeof(QEMUClock
));
914 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
918 ts
= qemu_mallocz(sizeof(QEMUTimer
));
925 void qemu_free_timer(QEMUTimer
*ts
)
930 /* stop a timer, but do not dealloc it */
931 void qemu_del_timer(QEMUTimer
*ts
)
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
];
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
)
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
];
966 if (t
->expire_time
> expire_time
)
970 ts
->expire_time
= expire_time
;
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
);
979 /* Interrupt execution to force deadline recalculation. */
985 int qemu_timer_pending(QEMUTimer
*ts
)
988 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
995 int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
999 return (timer_head
->expire_time
<= current_time
);
1002 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1008 if (!ts
|| ts
->expire_time
> current_time
)
1010 /* remove timer from the list before calling the callback */
1011 *ptimer_head
= ts
->next
;
1014 /* run the callback (the timer list can be modified) */
1019 int64_t qemu_get_clock(QEMUClock
*clock
)
1021 switch(clock
->type
) {
1022 case QEMU_TIMER_REALTIME
:
1023 return get_clock() / 1000000;
1025 case QEMU_TIMER_VIRTUAL
:
1027 return cpu_get_icount();
1029 return cpu_get_clock();
1034 static void init_timers(void)
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
);
1043 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1045 uint64_t expire_time
;
1047 if (qemu_timer_pending(ts
)) {
1048 expire_time
= ts
->expire_time
;
1052 qemu_put_be64(f
, expire_time
);
1055 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1057 uint64_t expire_time
;
1059 expire_time
= qemu_get_be64(f
);
1060 if (expire_time
!= -1) {
1061 qemu_mod_timer(ts
, expire_time
);
1067 static void timer_save(QEMUFile
*f
, void *opaque
)
1069 if (cpu_ticks_enabled
) {
1070 hw_error("cannot save state if virtual timers are running");
1072 qemu_put_be64(f
, cpu_ticks_offset
);
1073 qemu_put_be64(f
, ticks_per_sec
);
1074 qemu_put_be64(f
, cpu_clock_offset
);
1077 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1079 if (version_id
!= 1 && version_id
!= 2)
1081 if (cpu_ticks_enabled
) {
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
);
1092 static void qemu_event_increment(void);
1095 static void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1096 DWORD_PTR dwUser
, DWORD_PTR dw1
,
1099 static void host_alarm_handler(int host_signum
)
1103 #define DISP_FREQ 1000
1105 static int64_t delta_min
= INT64_MAX
;
1106 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1108 ti
= qemu_get_clock(vm_clock
);
1109 if (last_clock
!= 0) {
1110 delta
= ti
- last_clock
;
1111 if (delta
< delta_min
)
1113 if (delta
> delta_max
)
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
));
1123 delta_min
= INT64_MAX
;
1131 if (alarm_has_dynticks(alarm_timer
) ||
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
;
1140 #ifndef CONFIG_IOTHREAD
1142 /* stop the currently executing cpu because a timer occured */
1146 timer_alarm_pending
= 1;
1147 qemu_notify_event();
1151 static int64_t qemu_next_deadline(void)
1155 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1156 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1157 qemu_get_clock(vm_clock
);
1159 /* To avoid problems with overflow limit this to 2^32. */
1169 #if defined(__linux__) || defined(_WIN32)
1170 static uint64_t qemu_next_deadline_dyntick(void)
1178 delta
= (qemu_next_deadline() + 999) / 1000;
1180 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1181 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1182 qemu_get_clock(rt_clock
))*1000;
1183 if (rtdelta
< delta
)
1187 if (delta
< MIN_TIMER_REARM_US
)
1188 delta
= MIN_TIMER_REARM_US
;
1196 /* Sets a specific flag */
1197 static int fcntl_setfl(int fd
, int flag
)
1201 flags
= fcntl(fd
, F_GETFL
);
1205 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
1211 #if defined(__linux__)
1213 #define RTC_FREQ 1024
1215 static void enable_sigio_timer(int fd
)
1217 struct sigaction act
;
1220 sigfillset(&act
.sa_mask
);
1222 act
.sa_handler
= host_alarm_handler
;
1224 sigaction(SIGIO
, &act
, NULL
);
1225 fcntl_setfl(fd
, O_ASYNC
);
1226 fcntl(fd
, F_SETOWN
, getpid());
1229 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1231 struct hpet_info info
;
1234 fd
= open("/dev/hpet", O_RDONLY
);
1239 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1241 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1242 "error, but for better emulation accuracy type:\n"
1243 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1247 /* Check capabilities */
1248 r
= ioctl(fd
, HPET_INFO
, &info
);
1252 /* Enable periodic mode */
1253 r
= ioctl(fd
, HPET_EPI
, 0);
1254 if (info
.hi_flags
&& (r
< 0))
1257 /* Enable interrupt */
1258 r
= ioctl(fd
, HPET_IE_ON
, 0);
1262 enable_sigio_timer(fd
);
1263 t
->priv
= (void *)(long)fd
;
1271 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1273 int fd
= (long)t
->priv
;
1278 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1281 unsigned long current_rtc_freq
= 0;
1283 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1286 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1287 if (current_rtc_freq
!= RTC_FREQ
&&
1288 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1289 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1290 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1291 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1294 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1300 enable_sigio_timer(rtc_fd
);
1302 t
->priv
= (void *)(long)rtc_fd
;
1307 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1309 int rtc_fd
= (long)t
->priv
;
1314 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1318 struct sigaction act
;
1320 sigfillset(&act
.sa_mask
);
1322 act
.sa_handler
= host_alarm_handler
;
1324 sigaction(SIGALRM
, &act
, NULL
);
1327 * Initialize ev struct to 0 to avoid valgrind complaining
1328 * about uninitialized data in timer_create call
1330 memset(&ev
, 0, sizeof(ev
));
1331 ev
.sigev_value
.sival_int
= 0;
1332 ev
.sigev_notify
= SIGEV_SIGNAL
;
1333 ev
.sigev_signo
= SIGALRM
;
1335 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1336 perror("timer_create");
1338 /* disable dynticks */
1339 fprintf(stderr
, "Dynamic Ticks disabled\n");
1344 t
->priv
= (void *)(long)host_timer
;
1349 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1351 timer_t host_timer
= (timer_t
)(long)t
->priv
;
1353 timer_delete(host_timer
);
1356 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1358 timer_t host_timer
= (timer_t
)(long)t
->priv
;
1359 struct itimerspec timeout
;
1360 int64_t nearest_delta_us
= INT64_MAX
;
1363 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1364 !active_timers
[QEMU_TIMER_VIRTUAL
])
1367 nearest_delta_us
= qemu_next_deadline_dyntick();
1369 /* check whether a timer is already running */
1370 if (timer_gettime(host_timer
, &timeout
)) {
1372 fprintf(stderr
, "Internal timer error: aborting\n");
1375 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1376 if (current_us
&& current_us
<= nearest_delta_us
)
1379 timeout
.it_interval
.tv_sec
= 0;
1380 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1381 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1382 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1383 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1385 fprintf(stderr
, "Internal timer error: aborting\n");
1390 #endif /* defined(__linux__) */
1392 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1394 struct sigaction act
;
1395 struct itimerval itv
;
1399 sigfillset(&act
.sa_mask
);
1401 act
.sa_handler
= host_alarm_handler
;
1403 sigaction(SIGALRM
, &act
, NULL
);
1405 itv
.it_interval
.tv_sec
= 0;
1406 /* for i386 kernel 2.6 to get 1 ms */
1407 itv
.it_interval
.tv_usec
= 999;
1408 itv
.it_value
.tv_sec
= 0;
1409 itv
.it_value
.tv_usec
= 10 * 1000;
1411 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1418 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1420 struct itimerval itv
;
1422 memset(&itv
, 0, sizeof(itv
));
1423 setitimer(ITIMER_REAL
, &itv
, NULL
);
1426 #endif /* !defined(_WIN32) */
1431 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1434 struct qemu_alarm_win32
*data
= t
->priv
;
1437 memset(&tc
, 0, sizeof(tc
));
1438 timeGetDevCaps(&tc
, sizeof(tc
));
1440 if (data
->period
< tc
.wPeriodMin
)
1441 data
->period
= tc
.wPeriodMin
;
1443 timeBeginPeriod(data
->period
);
1445 flags
= TIME_CALLBACK_FUNCTION
;
1446 if (alarm_has_dynticks(t
))
1447 flags
|= TIME_ONESHOT
;
1449 flags
|= TIME_PERIODIC
;
1451 data
->timerId
= timeSetEvent(1, // interval (ms)
1452 data
->period
, // resolution
1453 host_alarm_handler
, // function
1454 (DWORD
)t
, // parameter
1457 if (!data
->timerId
) {
1458 perror("Failed to initialize win32 alarm timer");
1459 timeEndPeriod(data
->period
);
1466 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1468 struct qemu_alarm_win32
*data
= t
->priv
;
1470 timeKillEvent(data
->timerId
);
1471 timeEndPeriod(data
->period
);
1474 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1476 struct qemu_alarm_win32
*data
= t
->priv
;
1477 uint64_t nearest_delta_us
;
1479 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1480 !active_timers
[QEMU_TIMER_VIRTUAL
])
1483 nearest_delta_us
= qemu_next_deadline_dyntick();
1484 nearest_delta_us
/= 1000;
1486 timeKillEvent(data
->timerId
);
1488 data
->timerId
= timeSetEvent(1,
1492 TIME_ONESHOT
| TIME_PERIODIC
);
1494 if (!data
->timerId
) {
1495 perror("Failed to re-arm win32 alarm timer");
1497 timeEndPeriod(data
->period
);
1504 static int init_timer_alarm(void)
1506 struct qemu_alarm_timer
*t
= NULL
;
1509 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1510 t
= &alarm_timers
[i
];
1530 static void quit_timers(void)
1532 alarm_timer
->stop(alarm_timer
);
1536 /***********************************************************/
1537 /* host time/date access */
1538 void qemu_get_timedate(struct tm
*tm
, int offset
)
1545 if (rtc_date_offset
== -1) {
1549 ret
= localtime(&ti
);
1551 ti
-= rtc_date_offset
;
1555 memcpy(tm
, ret
, sizeof(struct tm
));
1558 int qemu_timedate_diff(struct tm
*tm
)
1562 if (rtc_date_offset
== -1)
1564 seconds
= mktimegm(tm
);
1566 seconds
= mktime(tm
);
1568 seconds
= mktimegm(tm
) + rtc_date_offset
;
1570 return seconds
- time(NULL
);
1574 static void socket_cleanup(void)
1579 static int socket_init(void)
1584 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
1586 err
= WSAGetLastError();
1587 fprintf(stderr
, "WSAStartup: %d\n", err
);
1590 atexit(socket_cleanup
);
1595 /***********************************************************/
1596 /* Bluetooth support */
1599 static struct HCIInfo
*hci_table
[MAX_NICS
];
1601 static struct bt_vlan_s
{
1602 struct bt_scatternet_s net
;
1604 struct bt_vlan_s
*next
;
1607 /* find or alloc a new bluetooth "VLAN" */
1608 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
1610 struct bt_vlan_s
**pvlan
, *vlan
;
1611 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
1615 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
1617 pvlan
= &first_bt_vlan
;
1618 while (*pvlan
!= NULL
)
1619 pvlan
= &(*pvlan
)->next
;
1624 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
1628 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
1633 static struct HCIInfo null_hci
= {
1634 .cmd_send
= null_hci_send
,
1635 .sco_send
= null_hci_send
,
1636 .acl_send
= null_hci_send
,
1637 .bdaddr_set
= null_hci_addr_set
,
1640 struct HCIInfo
*qemu_next_hci(void)
1642 if (cur_hci
== nb_hcis
)
1645 return hci_table
[cur_hci
++];
1648 static struct HCIInfo
*hci_init(const char *str
)
1651 struct bt_scatternet_s
*vlan
= 0;
1653 if (!strcmp(str
, "null"))
1656 else if (!strncmp(str
, "host", 4) && (str
[4] == '\0' || str
[4] == ':'))
1658 return bt_host_hci(str
[4] ? str
+ 5 : "hci0");
1659 else if (!strncmp(str
, "hci", 3)) {
1662 if (!strncmp(str
+ 3, ",vlan=", 6)) {
1663 vlan
= qemu_find_bt_vlan(strtol(str
+ 9, &endp
, 0));
1668 vlan
= qemu_find_bt_vlan(0);
1670 return bt_new_hci(vlan
);
1673 fprintf(stderr
, "qemu: Unknown bluetooth HCI `%s'.\n", str
);
1678 static int bt_hci_parse(const char *str
)
1680 struct HCIInfo
*hci
;
1683 if (nb_hcis
>= MAX_NICS
) {
1684 fprintf(stderr
, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS
);
1688 hci
= hci_init(str
);
1697 bdaddr
.b
[5] = 0x56 + nb_hcis
;
1698 hci
->bdaddr_set(hci
, bdaddr
.b
);
1700 hci_table
[nb_hcis
++] = hci
;
1705 static void bt_vhci_add(int vlan_id
)
1707 struct bt_scatternet_s
*vlan
= qemu_find_bt_vlan(vlan_id
);
1710 fprintf(stderr
, "qemu: warning: adding a VHCI to "
1711 "an empty scatternet %i\n", vlan_id
);
1713 bt_vhci_init(bt_new_hci(vlan
));
1716 static struct bt_device_s
*bt_device_add(const char *opt
)
1718 struct bt_scatternet_s
*vlan
;
1720 char *endp
= strstr(opt
, ",vlan=");
1721 int len
= (endp
? endp
- opt
: strlen(opt
)) + 1;
1724 pstrcpy(devname
, MIN(sizeof(devname
), len
), opt
);
1727 vlan_id
= strtol(endp
+ 6, &endp
, 0);
1729 fprintf(stderr
, "qemu: unrecognised bluetooth vlan Id\n");
1734 vlan
= qemu_find_bt_vlan(vlan_id
);
1737 fprintf(stderr
, "qemu: warning: adding a slave device to "
1738 "an empty scatternet %i\n", vlan_id
);
1740 if (!strcmp(devname
, "keyboard"))
1741 return bt_keyboard_init(vlan
);
1743 fprintf(stderr
, "qemu: unsupported bluetooth device `%s'\n", devname
);
1747 static int bt_parse(const char *opt
)
1749 const char *endp
, *p
;
1752 if (strstart(opt
, "hci", &endp
)) {
1753 if (!*endp
|| *endp
== ',') {
1755 if (!strstart(endp
, ",vlan=", 0))
1758 return bt_hci_parse(opt
);
1760 } else if (strstart(opt
, "vhci", &endp
)) {
1761 if (!*endp
|| *endp
== ',') {
1763 if (strstart(endp
, ",vlan=", &p
)) {
1764 vlan
= strtol(p
, (char **) &endp
, 0);
1766 fprintf(stderr
, "qemu: bad scatternet '%s'\n", p
);
1770 fprintf(stderr
, "qemu: bad parameter '%s'\n", endp
+ 1);
1779 } else if (strstart(opt
, "device:", &endp
))
1780 return !bt_device_add(endp
);
1782 fprintf(stderr
, "qemu: bad bluetooth parameter '%s'\n", opt
);
1786 /***********************************************************/
1787 /* QEMU Block devices */
1789 #define HD_ALIAS "index=%d,media=disk"
1790 #define CDROM_ALIAS "index=2,media=cdrom"
1791 #define FD_ALIAS "index=%d,if=floppy"
1792 #define PFLASH_ALIAS "if=pflash"
1793 #define MTD_ALIAS "if=mtd"
1794 #define SD_ALIAS "index=0,if=sd"
1796 QemuOpts
*drive_add(const char *file
, const char *fmt
, ...)
1803 vsnprintf(optstr
, sizeof(optstr
), fmt
, ap
);
1806 opts
= qemu_opts_parse(&qemu_drive_opts
, optstr
, NULL
);
1808 fprintf(stderr
, "%s: huh? duplicate? (%s)\n",
1809 __FUNCTION__
, optstr
);
1813 qemu_opt_set(opts
, "file", file
);
1817 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
1821 /* seek interface, bus and unit */
1823 TAILQ_FOREACH(dinfo
, &drives
, next
) {
1824 if (dinfo
->type
== type
&&
1825 dinfo
->bus
== bus
&&
1826 dinfo
->unit
== unit
)
1833 DriveInfo
*drive_get_by_id(const char *id
)
1837 TAILQ_FOREACH(dinfo
, &drives
, next
) {
1838 if (strcmp(id
, dinfo
->id
))
1845 int drive_get_max_bus(BlockInterfaceType type
)
1851 TAILQ_FOREACH(dinfo
, &drives
, next
) {
1852 if(dinfo
->type
== type
&&
1853 dinfo
->bus
> max_bus
)
1854 max_bus
= dinfo
->bus
;
1859 const char *drive_get_serial(BlockDriverState
*bdrv
)
1863 TAILQ_FOREACH(dinfo
, &drives
, next
) {
1864 if (dinfo
->bdrv
== bdrv
)
1865 return dinfo
->serial
;
1871 BlockInterfaceErrorAction
drive_get_onerror(BlockDriverState
*bdrv
)
1875 TAILQ_FOREACH(dinfo
, &drives
, next
) {
1876 if (dinfo
->bdrv
== bdrv
)
1877 return dinfo
->onerror
;
1880 return BLOCK_ERR_STOP_ENOSPC
;
1883 static void bdrv_format_print(void *opaque
, const char *name
)
1885 fprintf(stderr
, " %s", name
);
1888 void drive_uninit(BlockDriverState
*bdrv
)
1892 TAILQ_FOREACH(dinfo
, &drives
, next
) {
1893 if (dinfo
->bdrv
!= bdrv
)
1895 qemu_opts_del(dinfo
->opts
);
1896 TAILQ_REMOVE(&drives
, dinfo
, next
);
1902 DriveInfo
*drive_init(QemuOpts
*opts
, void *opaque
,
1906 const char *file
= NULL
;
1909 const char *mediastr
= "";
1910 BlockInterfaceType type
;
1911 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
1912 int bus_id
, unit_id
;
1913 int cyls
, heads
, secs
, translation
;
1914 BlockDriver
*drv
= NULL
;
1915 QEMUMachine
*machine
= opaque
;
1920 int bdrv_flags
, onerror
;
1921 const char *devaddr
;
1927 translation
= BIOS_ATA_TRANSLATION_AUTO
;
1930 if (machine
->use_scsi
) {
1932 max_devs
= MAX_SCSI_DEVS
;
1933 pstrcpy(devname
, sizeof(devname
), "scsi");
1936 max_devs
= MAX_IDE_DEVS
;
1937 pstrcpy(devname
, sizeof(devname
), "ide");
1941 /* extract parameters */
1942 bus_id
= qemu_opt_get_number(opts
, "bus", 0);
1943 unit_id
= qemu_opt_get_number(opts
, "unit", -1);
1944 index
= qemu_opt_get_number(opts
, "index", -1);
1946 cyls
= qemu_opt_get_number(opts
, "cyls", 0);
1947 heads
= qemu_opt_get_number(opts
, "heads", 0);
1948 secs
= qemu_opt_get_number(opts
, "secs", 0);
1950 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
1952 file
= qemu_opt_get(opts
, "file");
1953 serial
= qemu_opt_get(opts
, "serial");
1955 if ((buf
= qemu_opt_get(opts
, "if")) != NULL
) {
1956 pstrcpy(devname
, sizeof(devname
), buf
);
1957 if (!strcmp(buf
, "ide")) {
1959 max_devs
= MAX_IDE_DEVS
;
1960 } else if (!strcmp(buf
, "scsi")) {
1962 max_devs
= MAX_SCSI_DEVS
;
1963 } else if (!strcmp(buf
, "floppy")) {
1966 } else if (!strcmp(buf
, "pflash")) {
1969 } else if (!strcmp(buf
, "mtd")) {
1972 } else if (!strcmp(buf
, "sd")) {
1975 } else if (!strcmp(buf
, "virtio")) {
1978 } else if (!strcmp(buf
, "xen")) {
1981 } else if (!strcmp(buf
, "none")) {
1985 fprintf(stderr
, "qemu: unsupported bus type '%s'\n", buf
);
1990 if (cyls
|| heads
|| secs
) {
1991 if (cyls
< 1 || cyls
> 16383) {
1992 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", buf
);
1995 if (heads
< 1 || heads
> 16) {
1996 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", buf
);
1999 if (secs
< 1 || secs
> 63) {
2000 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", buf
);
2005 if ((buf
= qemu_opt_get(opts
, "trans")) != NULL
) {
2008 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2012 if (!strcmp(buf
, "none"))
2013 translation
= BIOS_ATA_TRANSLATION_NONE
;
2014 else if (!strcmp(buf
, "lba"))
2015 translation
= BIOS_ATA_TRANSLATION_LBA
;
2016 else if (!strcmp(buf
, "auto"))
2017 translation
= BIOS_ATA_TRANSLATION_AUTO
;
2019 fprintf(stderr
, "qemu: '%s' invalid translation type\n", buf
);
2024 if ((buf
= qemu_opt_get(opts
, "media")) != NULL
) {
2025 if (!strcmp(buf
, "disk")) {
2027 } else if (!strcmp(buf
, "cdrom")) {
2028 if (cyls
|| secs
|| heads
) {
2030 "qemu: '%s' invalid physical CHS format\n", buf
);
2033 media
= MEDIA_CDROM
;
2035 fprintf(stderr
, "qemu: '%s' invalid media\n", buf
);
2040 if ((buf
= qemu_opt_get(opts
, "cache")) != NULL
) {
2041 if (!strcmp(buf
, "off") || !strcmp(buf
, "none"))
2043 else if (!strcmp(buf
, "writethrough"))
2045 else if (!strcmp(buf
, "writeback"))
2048 fprintf(stderr
, "qemu: invalid cache option\n");
2053 #ifdef CONFIG_LINUX_AIO
2054 if ((buf
= qemu_opt_get(opts
, "aio")) != NULL
) {
2055 if (!strcmp(buf
, "threads"))
2057 else if (!strcmp(buf
, "native"))
2060 fprintf(stderr
, "qemu: invalid aio option\n");
2066 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
2067 if (strcmp(buf
, "?") == 0) {
2068 fprintf(stderr
, "qemu: Supported formats:");
2069 bdrv_iterate_format(bdrv_format_print
, NULL
);
2070 fprintf(stderr
, "\n");
2073 drv
= bdrv_find_format(buf
);
2075 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
2080 onerror
= BLOCK_ERR_STOP_ENOSPC
;
2081 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
2082 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
) {
2083 fprintf(stderr
, "werror is no supported by this format\n");
2086 if (!strcmp(buf
, "ignore"))
2087 onerror
= BLOCK_ERR_IGNORE
;
2088 else if (!strcmp(buf
, "enospc"))
2089 onerror
= BLOCK_ERR_STOP_ENOSPC
;
2090 else if (!strcmp(buf
, "stop"))
2091 onerror
= BLOCK_ERR_STOP_ANY
;
2092 else if (!strcmp(buf
, "report"))
2093 onerror
= BLOCK_ERR_REPORT
;
2095 fprintf(stderr
, "qemu: '%s' invalid write error action\n", buf
);
2100 if ((devaddr
= qemu_opt_get(opts
, "addr")) != NULL
) {
2101 if (type
!= IF_VIRTIO
) {
2102 fprintf(stderr
, "addr is not supported\n");
2107 /* compute bus and unit according index */
2110 if (bus_id
!= 0 || unit_id
!= -1) {
2112 "qemu: index cannot be used with bus and unit\n");
2120 unit_id
= index
% max_devs
;
2121 bus_id
= index
/ max_devs
;
2125 /* if user doesn't specify a unit_id,
2126 * try to find the first free
2129 if (unit_id
== -1) {
2131 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
2133 if (max_devs
&& unit_id
>= max_devs
) {
2134 unit_id
-= max_devs
;
2142 if (max_devs
&& unit_id
>= max_devs
) {
2143 fprintf(stderr
, "qemu: unit %d too big (max is %d)\n",
2144 unit_id
, max_devs
- 1);
2149 * ignore multiple definitions
2152 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
2159 dinfo
= qemu_mallocz(sizeof(*dinfo
));
2160 if ((buf
= qemu_opts_id(opts
)) != NULL
) {
2161 dinfo
->id
= qemu_strdup(buf
);
2163 /* no id supplied -> create one */
2164 dinfo
->id
= qemu_mallocz(32);
2165 if (type
== IF_IDE
|| type
== IF_SCSI
)
2166 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
2168 snprintf(dinfo
->id
, 32, "%s%i%s%i",
2169 devname
, bus_id
, mediastr
, unit_id
);
2171 snprintf(dinfo
->id
, 32, "%s%s%i",
2172 devname
, mediastr
, unit_id
);
2174 dinfo
->bdrv
= bdrv_new(dinfo
->id
);
2175 dinfo
->devaddr
= devaddr
;
2177 dinfo
->bus
= bus_id
;
2178 dinfo
->unit
= unit_id
;
2179 dinfo
->onerror
= onerror
;
2182 strncpy(dinfo
->serial
, serial
, sizeof(serial
));
2183 TAILQ_INSERT_TAIL(&drives
, dinfo
, next
);
2192 bdrv_set_geometry_hint(dinfo
->bdrv
, cyls
, heads
, secs
);
2193 bdrv_set_translation_hint(dinfo
->bdrv
, translation
);
2197 bdrv_set_type_hint(dinfo
->bdrv
, BDRV_TYPE_CDROM
);
2202 /* FIXME: This isn't really a floppy, but it's a reasonable
2205 bdrv_set_type_hint(dinfo
->bdrv
, BDRV_TYPE_FLOPPY
);
2212 /* add virtio block device */
2213 opts
= qemu_opts_create(&qemu_device_opts
, NULL
, 0);
2214 qemu_opt_set(opts
, "driver", "virtio-blk-pci");
2215 qemu_opt_set(opts
, "drive", dinfo
->id
);
2217 qemu_opt_set(opts
, "addr", devaddr
);
2228 bdrv_flags
|= BDRV_O_SNAPSHOT
;
2229 cache
= 2; /* always use write-back with snapshot */
2231 if (cache
== 0) /* no caching */
2232 bdrv_flags
|= BDRV_O_NOCACHE
;
2233 else if (cache
== 2) /* write-back */
2234 bdrv_flags
|= BDRV_O_CACHE_WB
;
2237 bdrv_flags
|= BDRV_O_NATIVE_AIO
;
2239 bdrv_flags
&= ~BDRV_O_NATIVE_AIO
;
2242 if (bdrv_open2(dinfo
->bdrv
, file
, bdrv_flags
, drv
) < 0) {
2243 fprintf(stderr
, "qemu: could not open disk image %s\n",
2248 if (bdrv_key_required(dinfo
->bdrv
))
2254 static int drive_init_func(QemuOpts
*opts
, void *opaque
)
2256 QEMUMachine
*machine
= opaque
;
2257 int fatal_error
= 0;
2259 if (drive_init(opts
, machine
, &fatal_error
) == NULL
) {
2266 static int drive_enable_snapshot(QemuOpts
*opts
, void *opaque
)
2268 if (NULL
== qemu_opt_get(opts
, "snapshot")) {
2269 qemu_opt_set(opts
, "snapshot", "on");
2274 void qemu_register_boot_set(QEMUBootSetHandler
*func
, void *opaque
)
2276 boot_set_handler
= func
;
2277 boot_set_opaque
= opaque
;
2280 int qemu_boot_set(const char *boot_devices
)
2282 if (!boot_set_handler
) {
2285 return boot_set_handler(boot_set_opaque
, boot_devices
);
2288 static int parse_bootdevices(char *devices
)
2290 /* We just do some generic consistency checks */
2294 for (p
= devices
; *p
!= '\0'; p
++) {
2295 /* Allowed boot devices are:
2296 * a-b: floppy disk drives
2297 * c-f: IDE disk drives
2298 * g-m: machine implementation dependant drives
2299 * n-p: network devices
2300 * It's up to each machine implementation to check if the given boot
2301 * devices match the actual hardware implementation and firmware
2304 if (*p
< 'a' || *p
> 'p') {
2305 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
2308 if (bitmap
& (1 << (*p
- 'a'))) {
2309 fprintf(stderr
, "Boot device '%c' was given twice\n", *p
);
2312 bitmap
|= 1 << (*p
- 'a');
2317 static void restore_boot_devices(void *opaque
)
2319 char *standard_boot_devices
= opaque
;
2321 qemu_boot_set(standard_boot_devices
);
2323 qemu_unregister_reset(restore_boot_devices
, standard_boot_devices
);
2324 qemu_free(standard_boot_devices
);
2327 static void numa_add(const char *optarg
)
2331 unsigned long long value
, endvalue
;
2334 optarg
= get_opt_name(option
, 128, optarg
, ',') + 1;
2335 if (!strcmp(option
, "node")) {
2336 if (get_param_value(option
, 128, "nodeid", optarg
) == 0) {
2337 nodenr
= nb_numa_nodes
;
2339 nodenr
= strtoull(option
, NULL
, 10);
2342 if (get_param_value(option
, 128, "mem", optarg
) == 0) {
2343 node_mem
[nodenr
] = 0;
2345 value
= strtoull(option
, &endptr
, 0);
2347 case 0: case 'M': case 'm':
2354 node_mem
[nodenr
] = value
;
2356 if (get_param_value(option
, 128, "cpus", optarg
) == 0) {
2357 node_cpumask
[nodenr
] = 0;
2359 value
= strtoull(option
, &endptr
, 10);
2362 fprintf(stderr
, "only 64 CPUs in NUMA mode supported.\n");
2364 if (*endptr
== '-') {
2365 endvalue
= strtoull(endptr
+1, &endptr
, 10);
2366 if (endvalue
>= 63) {
2369 "only 63 CPUs in NUMA mode supported.\n");
2371 value
= (1 << (endvalue
+ 1)) - (1 << value
);
2376 node_cpumask
[nodenr
] = value
;
2383 static void smp_parse(const char *optarg
)
2385 int smp
, sockets
= 0, threads
= 0, cores
= 0;
2389 smp
= strtoul(optarg
, &endptr
, 10);
2390 if (endptr
!= optarg
) {
2391 if (*endptr
== ',') {
2395 if (get_param_value(option
, 128, "sockets", endptr
) != 0)
2396 sockets
= strtoull(option
, NULL
, 10);
2397 if (get_param_value(option
, 128, "cores", endptr
) != 0)
2398 cores
= strtoull(option
, NULL
, 10);
2399 if (get_param_value(option
, 128, "threads", endptr
) != 0)
2400 threads
= strtoull(option
, NULL
, 10);
2401 if (get_param_value(option
, 128, "maxcpus", endptr
) != 0)
2402 max_cpus
= strtoull(option
, NULL
, 10);
2404 /* compute missing values, prefer sockets over cores over threads */
2405 if (smp
== 0 || sockets
== 0) {
2406 sockets
= sockets
> 0 ? sockets
: 1;
2407 cores
= cores
> 0 ? cores
: 1;
2408 threads
= threads
> 0 ? threads
: 1;
2410 smp
= cores
* threads
* sockets
;
2412 sockets
= smp
/ (cores
* threads
);
2416 threads
= threads
> 0 ? threads
: 1;
2417 cores
= smp
/ (sockets
* threads
);
2420 sockets
= smp
/ (cores
* threads
);
2422 threads
= smp
/ (cores
* sockets
);
2427 smp_cores
= cores
> 0 ? cores
: 1;
2428 smp_threads
= threads
> 0 ? threads
: 1;
2430 max_cpus
= smp_cpus
;
2433 /***********************************************************/
2436 static USBPort
*used_usb_ports
;
2437 static USBPort
*free_usb_ports
;
2439 /* ??? Maybe change this to register a hub to keep track of the topology. */
2440 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
2441 usb_attachfn attach
)
2443 port
->opaque
= opaque
;
2444 port
->index
= index
;
2445 port
->attach
= attach
;
2446 port
->next
= free_usb_ports
;
2447 free_usb_ports
= port
;
2450 int usb_device_add_dev(USBDevice
*dev
)
2454 /* Find a USB port to add the device to. */
2455 port
= free_usb_ports
;
2459 /* Create a new hub and chain it on. */
2460 free_usb_ports
= NULL
;
2461 port
->next
= used_usb_ports
;
2462 used_usb_ports
= port
;
2464 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
2465 usb_attach(port
, hub
);
2466 port
= free_usb_ports
;
2469 free_usb_ports
= port
->next
;
2470 port
->next
= used_usb_ports
;
2471 used_usb_ports
= port
;
2472 usb_attach(port
, dev
);
2476 static void usb_msd_password_cb(void *opaque
, int err
)
2478 USBDevice
*dev
= opaque
;
2481 usb_device_add_dev(dev
);
2483 dev
->handle_destroy(dev
);
2486 static int usb_device_add(const char *devname
, int is_hotplug
)
2491 if (!free_usb_ports
)
2494 if (strstart(devname
, "host:", &p
)) {
2495 dev
= usb_host_device_open(p
);
2496 } else if (!strcmp(devname
, "mouse")) {
2497 dev
= usb_mouse_init();
2498 } else if (!strcmp(devname
, "tablet")) {
2499 dev
= usb_tablet_init();
2500 } else if (!strcmp(devname
, "keyboard")) {
2501 dev
= usb_keyboard_init();
2502 } else if (strstart(devname
, "disk:", &p
)) {
2503 BlockDriverState
*bs
;
2505 dev
= usb_msd_init(p
);
2508 bs
= usb_msd_get_bdrv(dev
);
2509 if (bdrv_key_required(bs
)) {
2512 monitor_read_bdrv_key_start(cur_mon
, bs
, usb_msd_password_cb
,
2517 } else if (!strcmp(devname
, "wacom-tablet")) {
2518 dev
= usb_wacom_init();
2519 } else if (strstart(devname
, "serial:", &p
)) {
2520 dev
= usb_serial_init(p
);
2521 #ifdef CONFIG_BRLAPI
2522 } else if (!strcmp(devname
, "braille")) {
2523 dev
= usb_baum_init();
2525 } else if (strstart(devname
, "net:", &p
)) {
2528 if (net_client_init(NULL
, "nic", p
) < 0)
2530 nd_table
[nic
].model
= "usb";
2531 dev
= usb_net_init(&nd_table
[nic
]);
2532 } else if (!strcmp(devname
, "bt") || strstart(devname
, "bt:", &p
)) {
2533 dev
= usb_bt_init(devname
[2] ? hci_init(p
) :
2534 bt_new_hci(qemu_find_bt_vlan(0)));
2541 return usb_device_add_dev(dev
);
2544 int usb_device_del_addr(int bus_num
, int addr
)
2550 if (!used_usb_ports
)
2556 lastp
= &used_usb_ports
;
2557 port
= used_usb_ports
;
2558 while (port
&& port
->dev
->addr
!= addr
) {
2559 lastp
= &port
->next
;
2567 *lastp
= port
->next
;
2568 usb_attach(port
, NULL
);
2569 dev
->handle_destroy(dev
);
2570 port
->next
= free_usb_ports
;
2571 free_usb_ports
= port
;
2575 static int usb_device_del(const char *devname
)
2580 if (strstart(devname
, "host:", &p
))
2581 return usb_host_device_close(p
);
2583 if (!used_usb_ports
)
2586 p
= strchr(devname
, '.');
2589 bus_num
= strtoul(devname
, NULL
, 0);
2590 addr
= strtoul(p
+ 1, NULL
, 0);
2592 return usb_device_del_addr(bus_num
, addr
);
2595 static int usb_parse(const char *cmdline
)
2597 return usb_device_add(cmdline
, 0);
2600 void do_usb_add(Monitor
*mon
, const char *devname
)
2602 usb_device_add(devname
, 1);
2605 void do_usb_del(Monitor
*mon
, const char *devname
)
2607 usb_device_del(devname
);
2610 void usb_info(Monitor
*mon
)
2614 const char *speed_str
;
2617 monitor_printf(mon
, "USB support not enabled\n");
2621 for (port
= used_usb_ports
; port
; port
= port
->next
) {
2625 switch(dev
->speed
) {
2629 case USB_SPEED_FULL
:
2632 case USB_SPEED_HIGH
:
2639 monitor_printf(mon
, " Device %d.%d, Speed %s Mb/s, Product %s\n",
2640 0, dev
->addr
, speed_str
, dev
->devname
);
2644 /***********************************************************/
2645 /* PCMCIA/Cardbus */
2647 static struct pcmcia_socket_entry_s
{
2648 PCMCIASocket
*socket
;
2649 struct pcmcia_socket_entry_s
*next
;
2650 } *pcmcia_sockets
= 0;
2652 void pcmcia_socket_register(PCMCIASocket
*socket
)
2654 struct pcmcia_socket_entry_s
*entry
;
2656 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
2657 entry
->socket
= socket
;
2658 entry
->next
= pcmcia_sockets
;
2659 pcmcia_sockets
= entry
;
2662 void pcmcia_socket_unregister(PCMCIASocket
*socket
)
2664 struct pcmcia_socket_entry_s
*entry
, **ptr
;
2666 ptr
= &pcmcia_sockets
;
2667 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
2668 if (entry
->socket
== socket
) {
2674 void pcmcia_info(Monitor
*mon
)
2676 struct pcmcia_socket_entry_s
*iter
;
2678 if (!pcmcia_sockets
)
2679 monitor_printf(mon
, "No PCMCIA sockets\n");
2681 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
2682 monitor_printf(mon
, "%s: %s\n", iter
->socket
->slot_string
,
2683 iter
->socket
->attached
? iter
->socket
->card_string
:
2687 /***********************************************************/
2688 /* register display */
2690 struct DisplayAllocator default_allocator
= {
2691 defaultallocator_create_displaysurface
,
2692 defaultallocator_resize_displaysurface
,
2693 defaultallocator_free_displaysurface
2696 void register_displaystate(DisplayState
*ds
)
2706 DisplayState
*get_displaystate(void)
2708 return display_state
;
2711 DisplayAllocator
*register_displayallocator(DisplayState
*ds
, DisplayAllocator
*da
)
2713 if(ds
->allocator
== &default_allocator
) ds
->allocator
= da
;
2714 return ds
->allocator
;
2719 static void dumb_display_init(void)
2721 DisplayState
*ds
= qemu_mallocz(sizeof(DisplayState
));
2722 ds
->allocator
= &default_allocator
;
2723 ds
->surface
= qemu_create_displaysurface(ds
, 640, 480);
2724 register_displaystate(ds
);
2727 /***********************************************************/
2730 typedef struct IOHandlerRecord
{
2732 IOCanRWHandler
*fd_read_poll
;
2734 IOHandler
*fd_write
;
2737 /* temporary data */
2739 struct IOHandlerRecord
*next
;
2742 static IOHandlerRecord
*first_io_handler
;
2744 /* XXX: fd_read_poll should be suppressed, but an API change is
2745 necessary in the character devices to suppress fd_can_read(). */
2746 int qemu_set_fd_handler2(int fd
,
2747 IOCanRWHandler
*fd_read_poll
,
2749 IOHandler
*fd_write
,
2752 IOHandlerRecord
**pioh
, *ioh
;
2754 if (!fd_read
&& !fd_write
) {
2755 pioh
= &first_io_handler
;
2760 if (ioh
->fd
== fd
) {
2767 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
2771 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
2772 ioh
->next
= first_io_handler
;
2773 first_io_handler
= ioh
;
2776 ioh
->fd_read_poll
= fd_read_poll
;
2777 ioh
->fd_read
= fd_read
;
2778 ioh
->fd_write
= fd_write
;
2779 ioh
->opaque
= opaque
;
2785 int qemu_set_fd_handler(int fd
,
2787 IOHandler
*fd_write
,
2790 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
2794 /***********************************************************/
2795 /* Polling handling */
2797 typedef struct PollingEntry
{
2800 struct PollingEntry
*next
;
2803 static PollingEntry
*first_polling_entry
;
2805 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
2807 PollingEntry
**ppe
, *pe
;
2808 pe
= qemu_mallocz(sizeof(PollingEntry
));
2810 pe
->opaque
= opaque
;
2811 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
2816 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
2818 PollingEntry
**ppe
, *pe
;
2819 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
2821 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
2829 /***********************************************************/
2830 /* Wait objects support */
2831 typedef struct WaitObjects
{
2833 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
2834 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
2835 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
2838 static WaitObjects wait_objects
= {0};
2840 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
2842 WaitObjects
*w
= &wait_objects
;
2844 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
2846 w
->events
[w
->num
] = handle
;
2847 w
->func
[w
->num
] = func
;
2848 w
->opaque
[w
->num
] = opaque
;
2853 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
2856 WaitObjects
*w
= &wait_objects
;
2859 for (i
= 0; i
< w
->num
; i
++) {
2860 if (w
->events
[i
] == handle
)
2863 w
->events
[i
] = w
->events
[i
+ 1];
2864 w
->func
[i
] = w
->func
[i
+ 1];
2865 w
->opaque
[i
] = w
->opaque
[i
+ 1];
2873 /***********************************************************/
2874 /* ram save/restore */
2876 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
2880 v
= qemu_get_byte(f
);
2883 if (qemu_get_buffer(f
, buf
, len
) != len
)
2887 v
= qemu_get_byte(f
);
2888 memset(buf
, v
, len
);
2894 if (qemu_file_has_error(f
))
2900 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
2905 if (qemu_get_be32(f
) != last_ram_offset
)
2907 for(i
= 0; i
< last_ram_offset
; i
+= TARGET_PAGE_SIZE
) {
2908 ret
= ram_get_page(f
, qemu_get_ram_ptr(i
), TARGET_PAGE_SIZE
);
2915 #define BDRV_HASH_BLOCK_SIZE 1024
2916 #define IOBUF_SIZE 4096
2917 #define RAM_CBLOCK_MAGIC 0xfabe
2919 typedef struct RamDecompressState
{
2922 uint8_t buf
[IOBUF_SIZE
];
2923 } RamDecompressState
;
2925 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
2928 memset(s
, 0, sizeof(*s
));
2930 ret
= inflateInit(&s
->zstream
);
2936 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
2940 s
->zstream
.avail_out
= len
;
2941 s
->zstream
.next_out
= buf
;
2942 while (s
->zstream
.avail_out
> 0) {
2943 if (s
->zstream
.avail_in
== 0) {
2944 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
2946 clen
= qemu_get_be16(s
->f
);
2947 if (clen
> IOBUF_SIZE
)
2949 qemu_get_buffer(s
->f
, s
->buf
, clen
);
2950 s
->zstream
.avail_in
= clen
;
2951 s
->zstream
.next_in
= s
->buf
;
2953 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
2954 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
2961 static void ram_decompress_close(RamDecompressState
*s
)
2963 inflateEnd(&s
->zstream
);
2966 #define RAM_SAVE_FLAG_FULL 0x01
2967 #define RAM_SAVE_FLAG_COMPRESS 0x02
2968 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
2969 #define RAM_SAVE_FLAG_PAGE 0x08
2970 #define RAM_SAVE_FLAG_EOS 0x10
2972 static int is_dup_page(uint8_t *page
, uint8_t ch
)
2974 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
2975 uint32_t *array
= (uint32_t *)page
;
2978 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
2979 if (array
[i
] != val
)
2986 static int ram_save_block(QEMUFile
*f
)
2988 static ram_addr_t current_addr
= 0;
2989 ram_addr_t saved_addr
= current_addr
;
2990 ram_addr_t addr
= 0;
2993 while (addr
< last_ram_offset
) {
2994 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
2997 cpu_physical_memory_reset_dirty(current_addr
,
2998 current_addr
+ TARGET_PAGE_SIZE
,
2999 MIGRATION_DIRTY_FLAG
);
3001 p
= qemu_get_ram_ptr(current_addr
);
3003 if (is_dup_page(p
, *p
)) {
3004 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_COMPRESS
);
3005 qemu_put_byte(f
, *p
);
3007 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_PAGE
);
3008 qemu_put_buffer(f
, p
, TARGET_PAGE_SIZE
);
3014 addr
+= TARGET_PAGE_SIZE
;
3015 current_addr
= (saved_addr
+ addr
) % last_ram_offset
;
3021 static uint64_t bytes_transferred
= 0;
3023 static ram_addr_t
ram_save_remaining(void)
3026 ram_addr_t count
= 0;
3028 for (addr
= 0; addr
< last_ram_offset
; addr
+= TARGET_PAGE_SIZE
) {
3029 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
3036 uint64_t ram_bytes_remaining(void)
3038 return ram_save_remaining() * TARGET_PAGE_SIZE
;
3041 uint64_t ram_bytes_transferred(void)
3043 return bytes_transferred
;
3046 uint64_t ram_bytes_total(void)
3048 return last_ram_offset
;
3051 static int ram_save_live(QEMUFile
*f
, int stage
, void *opaque
)
3054 uint64_t bytes_transferred_last
;
3056 uint64_t expected_time
= 0;
3058 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX
) != 0) {
3059 qemu_file_set_error(f
);
3064 /* Make sure all dirty bits are set */
3065 for (addr
= 0; addr
< last_ram_offset
; addr
+= TARGET_PAGE_SIZE
) {
3066 if (!cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
3067 cpu_physical_memory_set_dirty(addr
);
3070 /* Enable dirty memory tracking */
3071 cpu_physical_memory_set_dirty_tracking(1);
3073 qemu_put_be64(f
, last_ram_offset
| RAM_SAVE_FLAG_MEM_SIZE
);
3076 bytes_transferred_last
= bytes_transferred
;
3077 bwidth
= get_clock();
3079 while (!qemu_file_rate_limit(f
)) {
3082 ret
= ram_save_block(f
);
3083 bytes_transferred
+= ret
* TARGET_PAGE_SIZE
;
3084 if (ret
== 0) /* no more blocks */
3088 bwidth
= get_clock() - bwidth
;
3089 bwidth
= (bytes_transferred
- bytes_transferred_last
) / bwidth
;
3091 /* if we haven't transferred anything this round, force expected_time to a
3092 * a very high value, but without crashing */
3096 /* try transferring iterative blocks of memory */
3100 /* flush all remaining blocks regardless of rate limiting */
3101 while (ram_save_block(f
) != 0) {
3102 bytes_transferred
+= TARGET_PAGE_SIZE
;
3104 cpu_physical_memory_set_dirty_tracking(0);
3107 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
3109 expected_time
= ram_save_remaining() * TARGET_PAGE_SIZE
/ bwidth
;
3111 return (stage
== 2) && (expected_time
<= migrate_max_downtime());
3114 static int ram_load_dead(QEMUFile
*f
, void *opaque
)
3116 RamDecompressState s1
, *s
= &s1
;
3120 if (ram_decompress_open(s
, f
) < 0)
3122 for(i
= 0; i
< last_ram_offset
; i
+= BDRV_HASH_BLOCK_SIZE
) {
3123 if (ram_decompress_buf(s
, buf
, 1) < 0) {
3124 fprintf(stderr
, "Error while reading ram block header\n");
3128 if (ram_decompress_buf(s
, qemu_get_ram_ptr(i
),
3129 BDRV_HASH_BLOCK_SIZE
) < 0) {
3130 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
3135 printf("Error block header\n");
3139 ram_decompress_close(s
);
3144 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
3149 if (version_id
== 1)
3150 return ram_load_v1(f
, opaque
);
3152 if (version_id
== 2) {
3153 if (qemu_get_be32(f
) != last_ram_offset
)
3155 return ram_load_dead(f
, opaque
);
3158 if (version_id
!= 3)
3162 addr
= qemu_get_be64(f
);
3164 flags
= addr
& ~TARGET_PAGE_MASK
;
3165 addr
&= TARGET_PAGE_MASK
;
3167 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
3168 if (addr
!= last_ram_offset
)
3172 if (flags
& RAM_SAVE_FLAG_FULL
) {
3173 if (ram_load_dead(f
, opaque
) < 0)
3177 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
3178 uint8_t ch
= qemu_get_byte(f
);
3179 memset(qemu_get_ram_ptr(addr
), ch
, TARGET_PAGE_SIZE
);
3182 (!kvm_enabled() || kvm_has_sync_mmu())) {
3183 madvise(qemu_get_ram_ptr(addr
), TARGET_PAGE_SIZE
, MADV_DONTNEED
);
3186 } else if (flags
& RAM_SAVE_FLAG_PAGE
)
3187 qemu_get_buffer(f
, qemu_get_ram_ptr(addr
), TARGET_PAGE_SIZE
);
3188 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
3193 void qemu_service_io(void)
3195 qemu_notify_event();
3198 /***********************************************************/
3199 /* bottom halves (can be seen as timers which expire ASAP) */
3210 static QEMUBH
*first_bh
= NULL
;
3212 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
3215 bh
= qemu_mallocz(sizeof(QEMUBH
));
3217 bh
->opaque
= opaque
;
3218 bh
->next
= first_bh
;
3223 int qemu_bh_poll(void)
3229 for (bh
= first_bh
; bh
; bh
= bh
->next
) {
3230 if (!bh
->deleted
&& bh
->scheduled
) {
3239 /* remove deleted bhs */
3253 void qemu_bh_schedule_idle(QEMUBH
*bh
)
3261 void qemu_bh_schedule(QEMUBH
*bh
)
3267 /* stop the currently executing CPU to execute the BH ASAP */
3268 qemu_notify_event();
3271 void qemu_bh_cancel(QEMUBH
*bh
)
3276 void qemu_bh_delete(QEMUBH
*bh
)
3282 static void qemu_bh_update_timeout(int *timeout
)
3286 for (bh
= first_bh
; bh
; bh
= bh
->next
) {
3287 if (!bh
->deleted
&& bh
->scheduled
) {
3289 /* idle bottom halves will be polled at least
3291 *timeout
= MIN(10, *timeout
);
3293 /* non-idle bottom halves will be executed
3302 /***********************************************************/
3303 /* machine registration */
3305 static QEMUMachine
*first_machine
= NULL
;
3306 QEMUMachine
*current_machine
= NULL
;
3308 int qemu_register_machine(QEMUMachine
*m
)
3311 pm
= &first_machine
;
3319 static QEMUMachine
*find_machine(const char *name
)
3323 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
3324 if (!strcmp(m
->name
, name
))
3326 if (m
->alias
&& !strcmp(m
->alias
, name
))
3332 static QEMUMachine
*find_default_machine(void)
3336 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
3337 if (m
->is_default
) {
3344 /***********************************************************/
3345 /* main execution loop */
3347 static void gui_update(void *opaque
)
3349 uint64_t interval
= GUI_REFRESH_INTERVAL
;
3350 DisplayState
*ds
= opaque
;
3351 DisplayChangeListener
*dcl
= ds
->listeners
;
3355 while (dcl
!= NULL
) {
3356 if (dcl
->gui_timer_interval
&&
3357 dcl
->gui_timer_interval
< interval
)
3358 interval
= dcl
->gui_timer_interval
;
3361 qemu_mod_timer(ds
->gui_timer
, interval
+ qemu_get_clock(rt_clock
));
3364 static void nographic_update(void *opaque
)
3366 uint64_t interval
= GUI_REFRESH_INTERVAL
;
3368 qemu_mod_timer(nographic_timer
, interval
+ qemu_get_clock(rt_clock
));
3371 struct vm_change_state_entry
{
3372 VMChangeStateHandler
*cb
;
3374 LIST_ENTRY (vm_change_state_entry
) entries
;
3377 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
3379 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
3382 VMChangeStateEntry
*e
;
3384 e
= qemu_mallocz(sizeof (*e
));
3388 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
3392 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
3394 LIST_REMOVE (e
, entries
);
3398 static void vm_state_notify(int running
, int reason
)
3400 VMChangeStateEntry
*e
;
3402 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
3403 e
->cb(e
->opaque
, running
, reason
);
3407 static void resume_all_vcpus(void);
3408 static void pause_all_vcpus(void);
3415 vm_state_notify(1, 0);
3416 qemu_rearm_alarm_timer(alarm_timer
);
3421 /* reset/shutdown handler */
3423 typedef struct QEMUResetEntry
{
3424 TAILQ_ENTRY(QEMUResetEntry
) entry
;
3425 QEMUResetHandler
*func
;
3429 static TAILQ_HEAD(reset_handlers
, QEMUResetEntry
) reset_handlers
=
3430 TAILQ_HEAD_INITIALIZER(reset_handlers
);
3431 static int reset_requested
;
3432 static int shutdown_requested
;
3433 static int powerdown_requested
;
3434 static int debug_requested
;
3435 static int vmstop_requested
;
3437 int qemu_shutdown_requested(void)
3439 int r
= shutdown_requested
;
3440 shutdown_requested
= 0;
3444 int qemu_reset_requested(void)
3446 int r
= reset_requested
;
3447 reset_requested
= 0;
3451 int qemu_powerdown_requested(void)
3453 int r
= powerdown_requested
;
3454 powerdown_requested
= 0;
3458 static int qemu_debug_requested(void)
3460 int r
= debug_requested
;
3461 debug_requested
= 0;
3465 static int qemu_vmstop_requested(void)
3467 int r
= vmstop_requested
;
3468 vmstop_requested
= 0;
3472 static void do_vm_stop(int reason
)
3475 cpu_disable_ticks();
3478 vm_state_notify(0, reason
);
3482 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
3484 QEMUResetEntry
*re
= qemu_mallocz(sizeof(QEMUResetEntry
));
3487 re
->opaque
= opaque
;
3488 TAILQ_INSERT_TAIL(&reset_handlers
, re
, entry
);
3491 void qemu_unregister_reset(QEMUResetHandler
*func
, void *opaque
)
3495 TAILQ_FOREACH(re
, &reset_handlers
, entry
) {
3496 if (re
->func
== func
&& re
->opaque
== opaque
) {
3497 TAILQ_REMOVE(&reset_handlers
, re
, entry
);
3504 void qemu_system_reset(void)
3506 QEMUResetEntry
*re
, *nre
;
3508 /* reset all devices */
3509 TAILQ_FOREACH_SAFE(re
, &reset_handlers
, entry
, nre
) {
3510 re
->func(re
->opaque
);
3514 void qemu_system_reset_request(void)
3517 shutdown_requested
= 1;
3519 reset_requested
= 1;
3521 qemu_notify_event();
3524 void qemu_system_shutdown_request(void)
3526 shutdown_requested
= 1;
3527 qemu_notify_event();
3530 void qemu_system_powerdown_request(void)
3532 powerdown_requested
= 1;
3533 qemu_notify_event();
3536 #ifdef CONFIG_IOTHREAD
3537 static void qemu_system_vmstop_request(int reason
)
3539 vmstop_requested
= reason
;
3540 qemu_notify_event();
3545 static int io_thread_fd
= -1;
3547 static void qemu_event_increment(void)
3549 static const char byte
= 0;
3551 if (io_thread_fd
== -1)
3554 write(io_thread_fd
, &byte
, sizeof(byte
));
3557 static void qemu_event_read(void *opaque
)
3559 int fd
= (unsigned long)opaque
;
3562 /* Drain the notify pipe */
3565 len
= read(fd
, buffer
, sizeof(buffer
));
3566 } while ((len
== -1 && errno
== EINTR
) || len
> 0);
3569 static int qemu_event_init(void)
3578 err
= fcntl_setfl(fds
[0], O_NONBLOCK
);
3582 err
= fcntl_setfl(fds
[1], O_NONBLOCK
);
3586 qemu_set_fd_handler2(fds
[0], NULL
, qemu_event_read
, NULL
,
3587 (void *)(unsigned long)fds
[0]);
3589 io_thread_fd
= fds
[1];
3598 HANDLE qemu_event_handle
;
3600 static void dummy_event_handler(void *opaque
)
3604 static int qemu_event_init(void)
3606 qemu_event_handle
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3607 if (!qemu_event_handle
) {
3608 perror("Failed CreateEvent");
3611 qemu_add_wait_object(qemu_event_handle
, dummy_event_handler
, NULL
);
3615 static void qemu_event_increment(void)
3617 SetEvent(qemu_event_handle
);
3621 static int cpu_can_run(CPUState
*env
)
3630 #ifndef CONFIG_IOTHREAD
3631 static int qemu_init_main_loop(void)
3633 return qemu_event_init();
3636 void qemu_init_vcpu(void *_env
)
3638 CPUState
*env
= _env
;
3642 env
->nr_cores
= smp_cores
;
3643 env
->nr_threads
= smp_threads
;
3647 int qemu_cpu_self(void *env
)
3652 static void resume_all_vcpus(void)
3656 static void pause_all_vcpus(void)
3660 void qemu_cpu_kick(void *env
)
3665 void qemu_notify_event(void)
3667 CPUState
*env
= cpu_single_env
;
3674 #define qemu_mutex_lock_iothread() do { } while (0)
3675 #define qemu_mutex_unlock_iothread() do { } while (0)
3677 void vm_stop(int reason
)
3682 #else /* CONFIG_IOTHREAD */
3684 #include "qemu-thread.h"
3686 QemuMutex qemu_global_mutex
;
3687 static QemuMutex qemu_fair_mutex
;
3689 static QemuThread io_thread
;
3691 static QemuThread
*tcg_cpu_thread
;
3692 static QemuCond
*tcg_halt_cond
;
3694 static int qemu_system_ready
;
3696 static QemuCond qemu_cpu_cond
;
3698 static QemuCond qemu_system_cond
;
3699 static QemuCond qemu_pause_cond
;
3701 static void block_io_signals(void);
3702 static void unblock_io_signals(void);
3703 static int tcg_has_work(void);
3705 static int qemu_init_main_loop(void)
3709 ret
= qemu_event_init();
3713 qemu_cond_init(&qemu_pause_cond
);
3714 qemu_mutex_init(&qemu_fair_mutex
);
3715 qemu_mutex_init(&qemu_global_mutex
);
3716 qemu_mutex_lock(&qemu_global_mutex
);
3718 unblock_io_signals();
3719 qemu_thread_self(&io_thread
);
3724 static void qemu_wait_io_event(CPUState
*env
)
3726 while (!tcg_has_work())
3727 qemu_cond_timedwait(env
->halt_cond
, &qemu_global_mutex
, 1000);
3729 qemu_mutex_unlock(&qemu_global_mutex
);
3732 * Users of qemu_global_mutex can be starved, having no chance
3733 * to acquire it since this path will get to it first.
3734 * So use another lock to provide fairness.
3736 qemu_mutex_lock(&qemu_fair_mutex
);
3737 qemu_mutex_unlock(&qemu_fair_mutex
);
3739 qemu_mutex_lock(&qemu_global_mutex
);
3743 qemu_cond_signal(&qemu_pause_cond
);
3747 static int qemu_cpu_exec(CPUState
*env
);
3749 static void *kvm_cpu_thread_fn(void *arg
)
3751 CPUState
*env
= arg
;
3754 qemu_thread_self(env
->thread
);
3757 /* signal CPU creation */
3758 qemu_mutex_lock(&qemu_global_mutex
);
3760 qemu_cond_signal(&qemu_cpu_cond
);
3762 /* and wait for machine initialization */
3763 while (!qemu_system_ready
)
3764 qemu_cond_timedwait(&qemu_system_cond
, &qemu_global_mutex
, 100);
3767 if (cpu_can_run(env
))
3769 qemu_wait_io_event(env
);
3775 static void tcg_cpu_exec(void);
3777 static void *tcg_cpu_thread_fn(void *arg
)
3779 CPUState
*env
= arg
;
3782 qemu_thread_self(env
->thread
);
3784 /* signal CPU creation */
3785 qemu_mutex_lock(&qemu_global_mutex
);
3786 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
3788 qemu_cond_signal(&qemu_cpu_cond
);
3790 /* and wait for machine initialization */
3791 while (!qemu_system_ready
)
3792 qemu_cond_timedwait(&qemu_system_cond
, &qemu_global_mutex
, 100);
3796 qemu_wait_io_event(cur_cpu
);
3802 void qemu_cpu_kick(void *_env
)
3804 CPUState
*env
= _env
;
3805 qemu_cond_broadcast(env
->halt_cond
);
3807 qemu_thread_signal(env
->thread
, SIGUSR1
);
3810 int qemu_cpu_self(void *env
)
3812 return (cpu_single_env
!= NULL
);
3815 static void cpu_signal(int sig
)
3818 cpu_exit(cpu_single_env
);
3821 static void block_io_signals(void)
3824 struct sigaction sigact
;
3827 sigaddset(&set
, SIGUSR2
);
3828 sigaddset(&set
, SIGIO
);
3829 sigaddset(&set
, SIGALRM
);
3830 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
3833 sigaddset(&set
, SIGUSR1
);
3834 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
3836 memset(&sigact
, 0, sizeof(sigact
));
3837 sigact
.sa_handler
= cpu_signal
;
3838 sigaction(SIGUSR1
, &sigact
, NULL
);
3841 static void unblock_io_signals(void)
3846 sigaddset(&set
, SIGUSR2
);
3847 sigaddset(&set
, SIGIO
);
3848 sigaddset(&set
, SIGALRM
);
3849 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
3852 sigaddset(&set
, SIGUSR1
);
3853 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
3856 static void qemu_signal_lock(unsigned int msecs
)
3858 qemu_mutex_lock(&qemu_fair_mutex
);
3860 while (qemu_mutex_trylock(&qemu_global_mutex
)) {
3861 qemu_thread_signal(tcg_cpu_thread
, SIGUSR1
);
3862 if (!qemu_mutex_timedlock(&qemu_global_mutex
, msecs
))
3865 qemu_mutex_unlock(&qemu_fair_mutex
);
3868 static void qemu_mutex_lock_iothread(void)
3870 if (kvm_enabled()) {
3871 qemu_mutex_lock(&qemu_fair_mutex
);
3872 qemu_mutex_lock(&qemu_global_mutex
);
3873 qemu_mutex_unlock(&qemu_fair_mutex
);
3875 qemu_signal_lock(100);
3878 static void qemu_mutex_unlock_iothread(void)
3880 qemu_mutex_unlock(&qemu_global_mutex
);
3883 static int all_vcpus_paused(void)
3885 CPUState
*penv
= first_cpu
;
3890 penv
= (CPUState
*)penv
->next_cpu
;
3896 static void pause_all_vcpus(void)
3898 CPUState
*penv
= first_cpu
;
3902 qemu_thread_signal(penv
->thread
, SIGUSR1
);
3903 qemu_cpu_kick(penv
);
3904 penv
= (CPUState
*)penv
->next_cpu
;
3907 while (!all_vcpus_paused()) {
3908 qemu_cond_timedwait(&qemu_pause_cond
, &qemu_global_mutex
, 100);
3911 qemu_thread_signal(penv
->thread
, SIGUSR1
);
3912 penv
= (CPUState
*)penv
->next_cpu
;
3917 static void resume_all_vcpus(void)
3919 CPUState
*penv
= first_cpu
;
3924 qemu_thread_signal(penv
->thread
, SIGUSR1
);
3925 qemu_cpu_kick(penv
);
3926 penv
= (CPUState
*)penv
->next_cpu
;
3930 static void tcg_init_vcpu(void *_env
)
3932 CPUState
*env
= _env
;
3933 /* share a single thread for all cpus with TCG */
3934 if (!tcg_cpu_thread
) {
3935 env
->thread
= qemu_mallocz(sizeof(QemuThread
));
3936 env
->halt_cond
= qemu_mallocz(sizeof(QemuCond
));
3937 qemu_cond_init(env
->halt_cond
);
3938 qemu_thread_create(env
->thread
, tcg_cpu_thread_fn
, env
);
3939 while (env
->created
== 0)
3940 qemu_cond_timedwait(&qemu_cpu_cond
, &qemu_global_mutex
, 100);
3941 tcg_cpu_thread
= env
->thread
;
3942 tcg_halt_cond
= env
->halt_cond
;
3944 env
->thread
= tcg_cpu_thread
;
3945 env
->halt_cond
= tcg_halt_cond
;
3949 static void kvm_start_vcpu(CPUState
*env
)
3951 env
->thread
= qemu_mallocz(sizeof(QemuThread
));
3952 env
->halt_cond
= qemu_mallocz(sizeof(QemuCond
));
3953 qemu_cond_init(env
->halt_cond
);
3954 qemu_thread_create(env
->thread
, kvm_cpu_thread_fn
, env
);
3955 while (env
->created
== 0)
3956 qemu_cond_timedwait(&qemu_cpu_cond
, &qemu_global_mutex
, 100);
3959 void qemu_init_vcpu(void *_env
)
3961 CPUState
*env
= _env
;
3964 kvm_start_vcpu(env
);
3967 env
->nr_cores
= smp_cores
;
3968 env
->nr_threads
= smp_threads
;
3971 void qemu_notify_event(void)
3973 qemu_event_increment();
3976 void vm_stop(int reason
)
3979 qemu_thread_self(&me
);
3981 if (!qemu_thread_equal(&me
, &io_thread
)) {
3982 qemu_system_vmstop_request(reason
);
3984 * FIXME: should not return to device code in case
3985 * vm_stop() has been requested.
3987 if (cpu_single_env
) {
3988 cpu_exit(cpu_single_env
);
3989 cpu_single_env
->stop
= 1;
4000 static void host_main_loop_wait(int *timeout
)
4006 /* XXX: need to suppress polling by better using win32 events */
4008 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
4009 ret
|= pe
->func(pe
->opaque
);
4013 WaitObjects
*w
= &wait_objects
;
4015 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, *timeout
);
4016 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
4017 if (w
->func
[ret
- WAIT_OBJECT_0
])
4018 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
4020 /* Check for additional signaled events */
4021 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
4023 /* Check if event is signaled */
4024 ret2
= WaitForSingleObject(w
->events
[i
], 0);
4025 if(ret2
== WAIT_OBJECT_0
) {
4027 w
->func
[i
](w
->opaque
[i
]);
4028 } else if (ret2
== WAIT_TIMEOUT
) {
4030 err
= GetLastError();
4031 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
4034 } else if (ret
== WAIT_TIMEOUT
) {
4036 err
= GetLastError();
4037 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
4044 static void host_main_loop_wait(int *timeout
)
4049 void main_loop_wait(int timeout
)
4051 IOHandlerRecord
*ioh
;
4052 fd_set rfds
, wfds
, xfds
;
4056 qemu_bh_update_timeout(&timeout
);
4058 host_main_loop_wait(&timeout
);
4060 /* poll any events */
4061 /* XXX: separate device handlers from system ones */
4066 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
4070 (!ioh
->fd_read_poll
||
4071 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
4072 FD_SET(ioh
->fd
, &rfds
);
4076 if (ioh
->fd_write
) {
4077 FD_SET(ioh
->fd
, &wfds
);
4083 tv
.tv_sec
= timeout
/ 1000;
4084 tv
.tv_usec
= (timeout
% 1000) * 1000;
4086 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
4088 qemu_mutex_unlock_iothread();
4089 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
4090 qemu_mutex_lock_iothread();
4092 IOHandlerRecord
**pioh
;
4094 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
4095 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
4096 ioh
->fd_read(ioh
->opaque
);
4098 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
4099 ioh
->fd_write(ioh
->opaque
);
4103 /* remove deleted IO handlers */
4104 pioh
= &first_io_handler
;
4115 slirp_select_poll(&rfds
, &wfds
, &xfds
, (ret
< 0));
4117 /* rearm timer, if not periodic */
4118 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
4119 alarm_timer
->flags
&= ~ALARM_FLAG_EXPIRED
;
4120 qemu_rearm_alarm_timer(alarm_timer
);
4123 /* vm time timers */
4125 if (!cur_cpu
|| likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
4126 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
4127 qemu_get_clock(vm_clock
));
4130 /* real time timers */
4131 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
4132 qemu_get_clock(rt_clock
));
4134 /* Check bottom-halves last in case any of the earlier events triggered
4140 static int qemu_cpu_exec(CPUState
*env
)
4143 #ifdef CONFIG_PROFILER
4147 #ifdef CONFIG_PROFILER
4148 ti
= profile_getclock();
4153 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
4154 env
->icount_decr
.u16
.low
= 0;
4155 env
->icount_extra
= 0;
4156 count
= qemu_next_deadline();
4157 count
= (count
+ (1 << icount_time_shift
) - 1)
4158 >> icount_time_shift
;
4159 qemu_icount
+= count
;
4160 decr
= (count
> 0xffff) ? 0xffff : count
;
4162 env
->icount_decr
.u16
.low
= decr
;
4163 env
->icount_extra
= count
;
4165 ret
= cpu_exec(env
);
4166 #ifdef CONFIG_PROFILER
4167 qemu_time
+= profile_getclock() - ti
;
4170 /* Fold pending instructions back into the
4171 instruction counter, and clear the interrupt flag. */
4172 qemu_icount
-= (env
->icount_decr
.u16
.low
4173 + env
->icount_extra
);
4174 env
->icount_decr
.u32
= 0;
4175 env
->icount_extra
= 0;
4180 static void tcg_cpu_exec(void)
4184 if (next_cpu
== NULL
)
4185 next_cpu
= first_cpu
;
4186 for (; next_cpu
!= NULL
; next_cpu
= next_cpu
->next_cpu
) {
4187 CPUState
*env
= cur_cpu
= next_cpu
;
4191 if (timer_alarm_pending
) {
4192 timer_alarm_pending
= 0;
4195 if (cpu_can_run(env
))
4196 ret
= qemu_cpu_exec(env
);
4197 if (ret
== EXCP_DEBUG
) {
4198 gdb_set_stop_cpu(env
);
4199 debug_requested
= 1;
4205 static int cpu_has_work(CPUState
*env
)
4213 if (qemu_cpu_has_work(env
))
4218 static int tcg_has_work(void)
4222 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
4223 if (cpu_has_work(env
))
4228 static int qemu_calculate_timeout(void)
4230 #ifndef CONFIG_IOTHREAD
4235 else if (tcg_has_work())
4237 else if (!use_icount
)
4240 /* XXX: use timeout computed from timers */
4243 /* Advance virtual time to the next event. */
4244 if (use_icount
== 1) {
4245 /* When not using an adaptive execution frequency
4246 we tend to get badly out of sync with real time,
4247 so just delay for a reasonable amount of time. */
4250 delta
= cpu_get_icount() - cpu_get_clock();
4253 /* If virtual time is ahead of real time then just
4255 timeout
= (delta
/ 1000000) + 1;
4257 /* Wait for either IO to occur or the next
4259 add
= qemu_next_deadline();
4260 /* We advance the timer before checking for IO.
4261 Limit the amount we advance so that early IO
4262 activity won't get the guest too far ahead. */
4266 add
= (add
+ (1 << icount_time_shift
) - 1)
4267 >> icount_time_shift
;
4269 timeout
= delta
/ 1000000;
4276 #else /* CONFIG_IOTHREAD */
4281 static int vm_can_run(void)
4283 if (powerdown_requested
)
4285 if (reset_requested
)
4287 if (shutdown_requested
)
4289 if (debug_requested
)
4294 qemu_irq qemu_system_powerdown
;
4296 static void main_loop(void)
4300 #ifdef CONFIG_IOTHREAD
4301 qemu_system_ready
= 1;
4302 qemu_cond_broadcast(&qemu_system_cond
);
4307 #ifdef CONFIG_PROFILER
4310 #ifndef CONFIG_IOTHREAD
4313 #ifdef CONFIG_PROFILER
4314 ti
= profile_getclock();
4316 main_loop_wait(qemu_calculate_timeout());
4317 #ifdef CONFIG_PROFILER
4318 dev_time
+= profile_getclock() - ti
;
4320 } while (vm_can_run());
4322 if (qemu_debug_requested())
4323 vm_stop(EXCP_DEBUG
);
4324 if (qemu_shutdown_requested()) {
4331 if (qemu_reset_requested()) {
4333 qemu_system_reset();
4336 if (qemu_powerdown_requested()) {
4337 qemu_irq_raise(qemu_system_powerdown
);
4339 if ((r
= qemu_vmstop_requested()))
4345 static void version(void)
4347 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n");
4350 static void help(int exitcode
)
4353 printf("usage: %s [options] [disk_image]\n"
4355 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4357 #define DEF(option, opt_arg, opt_enum, opt_help) \
4359 #define DEFHEADING(text) stringify(text) "\n"
4360 #include "qemu-options.h"
4365 "During emulation, the following keys are useful:\n"
4366 "ctrl-alt-f toggle full screen\n"
4367 "ctrl-alt-n switch to virtual console 'n'\n"
4368 "ctrl-alt toggle mouse and keyboard grab\n"
4370 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4375 DEFAULT_NETWORK_SCRIPT
,
4376 DEFAULT_NETWORK_DOWN_SCRIPT
,
4378 DEFAULT_GDBSTUB_PORT
,
4383 #define HAS_ARG 0x0001
4386 #define DEF(option, opt_arg, opt_enum, opt_help) \
4388 #define DEFHEADING(text)
4389 #include "qemu-options.h"
4395 typedef struct QEMUOption
{
4401 static const QEMUOption qemu_options
[] = {
4402 { "h", 0, QEMU_OPTION_h
},
4403 #define DEF(option, opt_arg, opt_enum, opt_help) \
4404 { option, opt_arg, opt_enum },
4405 #define DEFHEADING(text)
4406 #include "qemu-options.h"
4414 struct soundhw soundhw
[] = {
4415 #ifdef HAS_AUDIO_CHOICE
4416 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4422 { .init_isa
= pcspk_audio_init
}
4429 "Creative Sound Blaster 16",
4432 { .init_isa
= SB16_init
}
4436 #ifdef CONFIG_CS4231A
4442 { .init_isa
= cs4231a_init
}
4450 "Yamaha YMF262 (OPL3)",
4452 "Yamaha YM3812 (OPL2)",
4456 { .init_isa
= Adlib_init
}
4463 "Gravis Ultrasound GF1",
4466 { .init_isa
= GUS_init
}
4473 "Intel 82801AA AC97 Audio",
4476 { .init_pci
= ac97_init
}
4480 #ifdef CONFIG_ES1370
4483 "ENSONIQ AudioPCI ES1370",
4486 { .init_pci
= es1370_init
}
4490 #endif /* HAS_AUDIO_CHOICE */
4492 { NULL
, NULL
, 0, 0, { NULL
} }
4495 static void select_soundhw (const char *optarg
)
4499 if (*optarg
== '?') {
4502 printf ("Valid sound card names (comma separated):\n");
4503 for (c
= soundhw
; c
->name
; ++c
) {
4504 printf ("%-11s %s\n", c
->name
, c
->descr
);
4506 printf ("\n-soundhw all will enable all of the above\n");
4507 exit (*optarg
!= '?');
4515 if (!strcmp (optarg
, "all")) {
4516 for (c
= soundhw
; c
->name
; ++c
) {
4524 e
= strchr (p
, ',');
4525 l
= !e
? strlen (p
) : (size_t) (e
- p
);
4527 for (c
= soundhw
; c
->name
; ++c
) {
4528 if (!strncmp (c
->name
, p
, l
)) {
4537 "Unknown sound card name (too big to show)\n");
4540 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
4545 p
+= l
+ (e
!= NULL
);
4549 goto show_valid_cards
;
4554 static void select_vgahw (const char *p
)
4558 vga_interface_type
= VGA_NONE
;
4559 if (strstart(p
, "std", &opts
)) {
4560 vga_interface_type
= VGA_STD
;
4561 } else if (strstart(p
, "cirrus", &opts
)) {
4562 vga_interface_type
= VGA_CIRRUS
;
4563 } else if (strstart(p
, "vmware", &opts
)) {
4564 vga_interface_type
= VGA_VMWARE
;
4565 } else if (strstart(p
, "xenfb", &opts
)) {
4566 vga_interface_type
= VGA_XENFB
;
4567 } else if (!strstart(p
, "none", &opts
)) {
4569 fprintf(stderr
, "Unknown vga type: %s\n", p
);
4573 const char *nextopt
;
4575 if (strstart(opts
, ",retrace=", &nextopt
)) {
4577 if (strstart(opts
, "dumb", &nextopt
))
4578 vga_retrace_method
= VGA_RETRACE_DUMB
;
4579 else if (strstart(opts
, "precise", &nextopt
))
4580 vga_retrace_method
= VGA_RETRACE_PRECISE
;
4581 else goto invalid_vga
;
4582 } else goto invalid_vga
;
4588 static int balloon_parse(const char *arg
)
4592 if (strcmp(arg
, "none") == 0) {
4596 if (!strncmp(arg
, "virtio", 6)) {
4597 if (arg
[6] == ',') {
4598 /* have params -> parse them */
4599 opts
= qemu_opts_parse(&qemu_device_opts
, arg
+7, NULL
);
4603 /* create empty opts */
4604 opts
= qemu_opts_create(&qemu_device_opts
, NULL
, 0);
4606 qemu_opt_set(opts
, "driver", "virtio-balloon-pci");
4615 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
4617 exit(STATUS_CONTROL_C_EXIT
);
4622 int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
4626 if(strlen(str
) != 36)
4629 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
4630 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
4631 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
4637 smbios_add_field(1, offsetof(struct smbios_type_1
, uuid
), 16, uuid
);
4643 #define MAX_NET_CLIENTS 32
4647 static void termsig_handler(int signal
)
4649 qemu_system_shutdown_request();
4652 static void sigchld_handler(int signal
)
4654 waitpid(-1, NULL
, WNOHANG
);
4657 static void sighandler_setup(void)
4659 struct sigaction act
;
4661 memset(&act
, 0, sizeof(act
));
4662 act
.sa_handler
= termsig_handler
;
4663 sigaction(SIGINT
, &act
, NULL
);
4664 sigaction(SIGHUP
, &act
, NULL
);
4665 sigaction(SIGTERM
, &act
, NULL
);
4667 act
.sa_handler
= sigchld_handler
;
4668 act
.sa_flags
= SA_NOCLDSTOP
;
4669 sigaction(SIGCHLD
, &act
, NULL
);
4675 /* Look for support files in the same directory as the executable. */
4676 static char *find_datadir(const char *argv0
)
4682 len
= GetModuleFileName(NULL
, buf
, sizeof(buf
) - 1);
4689 while (p
!= buf
&& *p
!= '\\')
4692 if (access(buf
, R_OK
) == 0) {
4693 return qemu_strdup(buf
);
4699 /* Find a likely location for support files using the location of the binary.
4700 For installed binaries this will be "$bindir/../share/qemu". When
4701 running from the build tree this will be "$bindir/../pc-bios". */
4702 #define SHARE_SUFFIX "/share/qemu"
4703 #define BUILD_SUFFIX "/pc-bios"
4704 static char *find_datadir(const char *argv0
)
4714 #if defined(__linux__)
4717 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
4723 #elif defined(__FreeBSD__)
4726 len
= readlink("/proc/curproc/file", buf
, sizeof(buf
) - 1);
4733 /* If we don't have any way of figuring out the actual executable
4734 location then try argv[0]. */
4739 p
= realpath(argv0
, p
);
4747 max_len
= strlen(dir
) +
4748 MAX(strlen(SHARE_SUFFIX
), strlen(BUILD_SUFFIX
)) + 1;
4749 res
= qemu_mallocz(max_len
);
4750 snprintf(res
, max_len
, "%s%s", dir
, SHARE_SUFFIX
);
4751 if (access(res
, R_OK
)) {
4752 snprintf(res
, max_len
, "%s%s", dir
, BUILD_SUFFIX
);
4753 if (access(res
, R_OK
)) {
4767 char *qemu_find_file(int type
, const char *name
)
4773 /* If name contains path separators then try it as a straight path. */
4774 if ((strchr(name
, '/') || strchr(name
, '\\'))
4775 && access(name
, R_OK
) == 0) {
4776 return strdup(name
);
4779 case QEMU_FILE_TYPE_BIOS
:
4782 case QEMU_FILE_TYPE_KEYMAP
:
4783 subdir
= "keymaps/";
4788 len
= strlen(data_dir
) + strlen(name
) + strlen(subdir
) + 2;
4789 buf
= qemu_mallocz(len
);
4790 snprintf(buf
, len
, "%s/%s%s", data_dir
, subdir
, name
);
4791 if (access(buf
, R_OK
)) {
4798 static int device_init_func(QemuOpts
*opts
, void *opaque
)
4802 dev
= qdev_device_add(opts
);
4808 struct device_config
{
4810 DEV_USB
, /* -usbdevice */
4813 const char *cmdline
;
4814 TAILQ_ENTRY(device_config
) next
;
4816 TAILQ_HEAD(, device_config
) device_configs
= TAILQ_HEAD_INITIALIZER(device_configs
);
4818 static void add_device_config(int type
, const char *cmdline
)
4820 struct device_config
*conf
;
4822 conf
= qemu_mallocz(sizeof(*conf
));
4824 conf
->cmdline
= cmdline
;
4825 TAILQ_INSERT_TAIL(&device_configs
, conf
, next
);
4828 static int foreach_device_config(int type
, int (*func
)(const char *cmdline
))
4830 struct device_config
*conf
;
4833 TAILQ_FOREACH(conf
, &device_configs
, next
) {
4834 if (conf
->type
!= type
)
4836 rc
= func(conf
->cmdline
);
4843 int main(int argc
, char **argv
, char **envp
)
4845 const char *gdbstub_dev
= NULL
;
4846 uint32_t boot_devices_bitmap
= 0;
4848 int snapshot
, linux_boot
, net_boot
;
4849 const char *initrd_filename
;
4850 const char *kernel_filename
, *kernel_cmdline
;
4851 char boot_devices
[33] = "cad"; /* default to HD->floppy->CD-ROM */
4853 DisplayChangeListener
*dcl
;
4854 int cyls
, heads
, secs
, translation
;
4855 const char *net_clients
[MAX_NET_CLIENTS
];
4857 QemuOpts
*hda_opts
= NULL
, *opts
;
4859 const char *r
, *optarg
;
4860 CharDriverState
*monitor_hds
[MAX_MONITOR_DEVICES
];
4861 const char *monitor_devices
[MAX_MONITOR_DEVICES
];
4862 int monitor_device_index
;
4863 const char *serial_devices
[MAX_SERIAL_PORTS
];
4864 int serial_device_index
;
4865 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
4866 int parallel_device_index
;
4867 const char *virtio_consoles
[MAX_VIRTIO_CONSOLES
];
4868 int virtio_console_index
;
4869 const char *loadvm
= NULL
;
4870 QEMUMachine
*machine
;
4871 const char *cpu_model
;
4876 const char *pid_file
= NULL
;
4877 const char *incoming
= NULL
;
4880 struct passwd
*pwd
= NULL
;
4881 const char *chroot_dir
= NULL
;
4882 const char *run_as
= NULL
;
4885 int show_vnc_port
= 0;
4887 qemu_errors_to_file(stderr
);
4888 qemu_cache_utils_init(envp
);
4890 LIST_INIT (&vm_change_state_head
);
4893 struct sigaction act
;
4894 sigfillset(&act
.sa_mask
);
4896 act
.sa_handler
= SIG_IGN
;
4897 sigaction(SIGPIPE
, &act
, NULL
);
4900 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
4901 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4902 QEMU to run on a single CPU */
4907 h
= GetCurrentProcess();
4908 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
4909 for(i
= 0; i
< 32; i
++) {
4910 if (mask
& (1 << i
))
4915 SetProcessAffinityMask(h
, mask
);
4921 module_call_init(MODULE_INIT_MACHINE
);
4922 machine
= find_default_machine();
4924 initrd_filename
= NULL
;
4927 kernel_filename
= NULL
;
4928 kernel_cmdline
= "";
4929 cyls
= heads
= secs
= 0;
4930 translation
= BIOS_ATA_TRANSLATION_AUTO
;
4932 serial_devices
[0] = "vc:80Cx24C";
4933 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
4934 serial_devices
[i
] = NULL
;
4935 serial_device_index
= 0;
4937 parallel_devices
[0] = "vc:80Cx24C";
4938 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
4939 parallel_devices
[i
] = NULL
;
4940 parallel_device_index
= 0;
4942 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++)
4943 virtio_consoles
[i
] = NULL
;
4944 virtio_console_index
= 0;
4946 monitor_devices
[0] = "vc:80Cx24C";
4947 for (i
= 1; i
< MAX_MONITOR_DEVICES
; i
++) {
4948 monitor_devices
[i
] = NULL
;
4950 monitor_device_index
= 0;
4952 for (i
= 0; i
< MAX_NODES
; i
++) {
4954 node_cpumask
[i
] = 0;
4970 hda_opts
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
4972 const QEMUOption
*popt
;
4975 /* Treat --foo the same as -foo. */
4978 popt
= qemu_options
;
4981 fprintf(stderr
, "%s: invalid option -- '%s'\n",
4985 if (!strcmp(popt
->name
, r
+ 1))
4989 if (popt
->flags
& HAS_ARG
) {
4990 if (optind
>= argc
) {
4991 fprintf(stderr
, "%s: option '%s' requires an argument\n",
4995 optarg
= argv
[optind
++];
5000 switch(popt
->index
) {
5002 machine
= find_machine(optarg
);
5005 printf("Supported machines are:\n");
5006 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
5008 printf("%-10s %s (alias of %s)\n",
5009 m
->alias
, m
->desc
, m
->name
);
5010 printf("%-10s %s%s\n",
5012 m
->is_default
? " (default)" : "");
5014 exit(*optarg
!= '?');
5017 case QEMU_OPTION_cpu
:
5018 /* hw initialization will check this */
5019 if (*optarg
== '?') {
5020 /* XXX: implement xxx_cpu_list for targets that still miss it */
5021 #if defined(cpu_list)
5022 cpu_list(stdout
, &fprintf
);
5029 case QEMU_OPTION_initrd
:
5030 initrd_filename
= optarg
;
5032 case QEMU_OPTION_hda
:
5034 hda_opts
= drive_add(optarg
, HD_ALIAS
, 0);
5036 hda_opts
= drive_add(optarg
, HD_ALIAS
5037 ",cyls=%d,heads=%d,secs=%d%s",
5038 0, cyls
, heads
, secs
,
5039 translation
== BIOS_ATA_TRANSLATION_LBA
?
5041 translation
== BIOS_ATA_TRANSLATION_NONE
?
5042 ",trans=none" : "");
5044 case QEMU_OPTION_hdb
:
5045 case QEMU_OPTION_hdc
:
5046 case QEMU_OPTION_hdd
:
5047 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
5049 case QEMU_OPTION_drive
:
5050 drive_add(NULL
, "%s", optarg
);
5052 case QEMU_OPTION_set
:
5053 if (qemu_set_option(optarg
) != 0)
5056 case QEMU_OPTION_mtdblock
:
5057 drive_add(optarg
, MTD_ALIAS
);
5059 case QEMU_OPTION_sd
:
5060 drive_add(optarg
, SD_ALIAS
);
5062 case QEMU_OPTION_pflash
:
5063 drive_add(optarg
, PFLASH_ALIAS
);
5065 case QEMU_OPTION_snapshot
:
5068 case QEMU_OPTION_hdachs
:
5072 cyls
= strtol(p
, (char **)&p
, 0);
5073 if (cyls
< 1 || cyls
> 16383)
5078 heads
= strtol(p
, (char **)&p
, 0);
5079 if (heads
< 1 || heads
> 16)
5084 secs
= strtol(p
, (char **)&p
, 0);
5085 if (secs
< 1 || secs
> 63)
5089 if (!strcmp(p
, "none"))
5090 translation
= BIOS_ATA_TRANSLATION_NONE
;
5091 else if (!strcmp(p
, "lba"))
5092 translation
= BIOS_ATA_TRANSLATION_LBA
;
5093 else if (!strcmp(p
, "auto"))
5094 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5097 } else if (*p
!= '\0') {
5099 fprintf(stderr
, "qemu: invalid physical CHS format\n");
5102 if (hda_opts
!= NULL
) {
5104 snprintf(num
, sizeof(num
), "%d", cyls
);
5105 qemu_opt_set(hda_opts
, "cyls", num
);
5106 snprintf(num
, sizeof(num
), "%d", heads
);
5107 qemu_opt_set(hda_opts
, "heads", num
);
5108 snprintf(num
, sizeof(num
), "%d", secs
);
5109 qemu_opt_set(hda_opts
, "secs", num
);
5110 if (translation
== BIOS_ATA_TRANSLATION_LBA
)
5111 qemu_opt_set(hda_opts
, "trans", "lba");
5112 if (translation
== BIOS_ATA_TRANSLATION_NONE
)
5113 qemu_opt_set(hda_opts
, "trans", "none");
5117 case QEMU_OPTION_numa
:
5118 if (nb_numa_nodes
>= MAX_NODES
) {
5119 fprintf(stderr
, "qemu: too many NUMA nodes\n");
5124 case QEMU_OPTION_nographic
:
5125 display_type
= DT_NOGRAPHIC
;
5127 #ifdef CONFIG_CURSES
5128 case QEMU_OPTION_curses
:
5129 display_type
= DT_CURSES
;
5132 case QEMU_OPTION_portrait
:
5135 case QEMU_OPTION_kernel
:
5136 kernel_filename
= optarg
;
5138 case QEMU_OPTION_append
:
5139 kernel_cmdline
= optarg
;
5141 case QEMU_OPTION_cdrom
:
5142 drive_add(optarg
, CDROM_ALIAS
);
5144 case QEMU_OPTION_boot
:
5146 static const char * const params
[] = {
5147 "order", "once", "menu", NULL
5149 char buf
[sizeof(boot_devices
)];
5150 char *standard_boot_devices
;
5153 if (!strchr(optarg
, '=')) {
5155 pstrcpy(buf
, sizeof(buf
), optarg
);
5156 } else if (check_params(buf
, sizeof(buf
), params
, optarg
) < 0) {
5158 "qemu: unknown boot parameter '%s' in '%s'\n",
5164 get_param_value(buf
, sizeof(buf
), "order", optarg
)) {
5165 boot_devices_bitmap
= parse_bootdevices(buf
);
5166 pstrcpy(boot_devices
, sizeof(boot_devices
), buf
);
5169 if (get_param_value(buf
, sizeof(buf
),
5171 boot_devices_bitmap
|= parse_bootdevices(buf
);
5172 standard_boot_devices
= qemu_strdup(boot_devices
);
5173 pstrcpy(boot_devices
, sizeof(boot_devices
), buf
);
5174 qemu_register_reset(restore_boot_devices
,
5175 standard_boot_devices
);
5177 if (get_param_value(buf
, sizeof(buf
),
5179 if (!strcmp(buf
, "on")) {
5181 } else if (!strcmp(buf
, "off")) {
5185 "qemu: invalid option value '%s'\n",
5193 case QEMU_OPTION_fda
:
5194 case QEMU_OPTION_fdb
:
5195 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
5198 case QEMU_OPTION_no_fd_bootchk
:
5202 case QEMU_OPTION_net
:
5203 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
5204 fprintf(stderr
, "qemu: too many network clients\n");
5207 net_clients
[nb_net_clients
] = optarg
;
5211 case QEMU_OPTION_tftp
:
5212 legacy_tftp_prefix
= optarg
;
5214 case QEMU_OPTION_bootp
:
5215 legacy_bootp_filename
= optarg
;
5218 case QEMU_OPTION_smb
:
5219 net_slirp_smb(optarg
);
5222 case QEMU_OPTION_redir
:
5223 net_slirp_redir(optarg
);
5226 case QEMU_OPTION_bt
:
5227 add_device_config(DEV_BT
, optarg
);
5230 case QEMU_OPTION_audio_help
:
5234 case QEMU_OPTION_soundhw
:
5235 select_soundhw (optarg
);
5241 case QEMU_OPTION_version
:
5245 case QEMU_OPTION_m
: {
5249 value
= strtoul(optarg
, &ptr
, 10);
5251 case 0: case 'M': case 'm':
5258 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
5262 /* On 32-bit hosts, QEMU is limited by virtual address space */
5263 if (value
> (2047 << 20) && HOST_LONG_BITS
== 32) {
5264 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
5267 if (value
!= (uint64_t)(ram_addr_t
)value
) {
5268 fprintf(stderr
, "qemu: ram size too large\n");
5277 const CPULogItem
*item
;
5279 mask
= cpu_str_to_log_mask(optarg
);
5281 printf("Log items (comma separated):\n");
5282 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
5283 printf("%-10s %s\n", item
->name
, item
->help
);
5291 gdbstub_dev
= "tcp::" DEFAULT_GDBSTUB_PORT
;
5293 case QEMU_OPTION_gdb
:
5294 gdbstub_dev
= optarg
;
5299 case QEMU_OPTION_bios
:
5302 case QEMU_OPTION_singlestep
:
5310 keyboard_layout
= optarg
;
5313 case QEMU_OPTION_localtime
:
5316 case QEMU_OPTION_vga
:
5317 select_vgahw (optarg
);
5319 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5325 w
= strtol(p
, (char **)&p
, 10);
5328 fprintf(stderr
, "qemu: invalid resolution or depth\n");
5334 h
= strtol(p
, (char **)&p
, 10);
5339 depth
= strtol(p
, (char **)&p
, 10);
5340 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
5341 depth
!= 24 && depth
!= 32)
5343 } else if (*p
== '\0') {
5344 depth
= graphic_depth
;
5351 graphic_depth
= depth
;
5355 case QEMU_OPTION_echr
:
5358 term_escape_char
= strtol(optarg
, &r
, 0);
5360 printf("Bad argument to echr\n");
5363 case QEMU_OPTION_monitor
:
5364 if (monitor_device_index
>= MAX_MONITOR_DEVICES
) {
5365 fprintf(stderr
, "qemu: too many monitor devices\n");
5368 monitor_devices
[monitor_device_index
] = optarg
;
5369 monitor_device_index
++;
5371 case QEMU_OPTION_serial
:
5372 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
5373 fprintf(stderr
, "qemu: too many serial ports\n");
5376 serial_devices
[serial_device_index
] = optarg
;
5377 serial_device_index
++;
5379 case QEMU_OPTION_watchdog
:
5382 "qemu: only one watchdog option may be given\n");
5387 case QEMU_OPTION_watchdog_action
:
5388 if (select_watchdog_action(optarg
) == -1) {
5389 fprintf(stderr
, "Unknown -watchdog-action parameter\n");
5393 case QEMU_OPTION_virtiocon
:
5394 if (virtio_console_index
>= MAX_VIRTIO_CONSOLES
) {
5395 fprintf(stderr
, "qemu: too many virtio consoles\n");
5398 virtio_consoles
[virtio_console_index
] = optarg
;
5399 virtio_console_index
++;
5401 case QEMU_OPTION_parallel
:
5402 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
5403 fprintf(stderr
, "qemu: too many parallel ports\n");
5406 parallel_devices
[parallel_device_index
] = optarg
;
5407 parallel_device_index
++;
5409 case QEMU_OPTION_loadvm
:
5412 case QEMU_OPTION_full_screen
:
5416 case QEMU_OPTION_no_frame
:
5419 case QEMU_OPTION_alt_grab
:
5422 case QEMU_OPTION_no_quit
:
5425 case QEMU_OPTION_sdl
:
5426 display_type
= DT_SDL
;
5429 case QEMU_OPTION_pidfile
:
5433 case QEMU_OPTION_win2k_hack
:
5434 win2k_install_hack
= 1;
5436 case QEMU_OPTION_rtc_td_hack
:
5439 case QEMU_OPTION_acpitable
:
5440 if(acpi_table_add(optarg
) < 0) {
5441 fprintf(stderr
, "Wrong acpi table provided\n");
5445 case QEMU_OPTION_smbios
:
5446 if(smbios_entry_add(optarg
) < 0) {
5447 fprintf(stderr
, "Wrong smbios provided\n");
5453 case QEMU_OPTION_enable_kvm
:
5457 case QEMU_OPTION_usb
:
5460 case QEMU_OPTION_usbdevice
:
5462 add_device_config(DEV_USB
, optarg
);
5464 case QEMU_OPTION_device
:
5465 opts
= qemu_opts_parse(&qemu_device_opts
, optarg
, "driver");
5467 fprintf(stderr
, "parse error: %s\n", optarg
);
5471 case QEMU_OPTION_smp
:
5474 fprintf(stderr
, "Invalid number of CPUs\n");
5477 if (max_cpus
< smp_cpus
) {
5478 fprintf(stderr
, "maxcpus must be equal to or greater than "
5482 if (max_cpus
> 255) {
5483 fprintf(stderr
, "Unsupported number of maxcpus\n");
5487 case QEMU_OPTION_vnc
:
5488 display_type
= DT_VNC
;
5489 vnc_display
= optarg
;
5492 case QEMU_OPTION_no_acpi
:
5495 case QEMU_OPTION_no_hpet
:
5498 case QEMU_OPTION_balloon
:
5499 if (balloon_parse(optarg
) < 0) {
5500 fprintf(stderr
, "Unknown -balloon argument %s\n", optarg
);
5505 case QEMU_OPTION_no_reboot
:
5508 case QEMU_OPTION_no_shutdown
:
5511 case QEMU_OPTION_show_cursor
:
5514 case QEMU_OPTION_uuid
:
5515 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
5516 fprintf(stderr
, "Fail to parse UUID string."
5517 " Wrong format.\n");
5522 case QEMU_OPTION_daemonize
:
5526 case QEMU_OPTION_option_rom
:
5527 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
5528 fprintf(stderr
, "Too many option ROMs\n");
5531 option_rom
[nb_option_roms
] = optarg
;
5534 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5535 case QEMU_OPTION_semihosting
:
5536 semihosting_enabled
= 1;
5539 case QEMU_OPTION_name
:
5540 qemu_name
= qemu_strdup(optarg
);
5542 char *p
= strchr(qemu_name
, ',');
5545 if (strncmp(p
, "process=", 8)) {
5546 fprintf(stderr
, "Unknown subargument %s to -name", p
);
5554 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5555 case QEMU_OPTION_prom_env
:
5556 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
5557 fprintf(stderr
, "Too many prom variables\n");
5560 prom_envs
[nb_prom_envs
] = optarg
;
5565 case QEMU_OPTION_old_param
:
5569 case QEMU_OPTION_clock
:
5570 configure_alarms(optarg
);
5572 case QEMU_OPTION_startdate
:
5575 time_t rtc_start_date
;
5576 if (!strcmp(optarg
, "now")) {
5577 rtc_date_offset
= -1;
5579 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
5587 } else if (sscanf(optarg
, "%d-%d-%d",
5590 &tm
.tm_mday
) == 3) {
5599 rtc_start_date
= mktimegm(&tm
);
5600 if (rtc_start_date
== -1) {
5602 fprintf(stderr
, "Invalid date format. Valid format are:\n"
5603 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5606 rtc_date_offset
= time(NULL
) - rtc_start_date
;
5610 case QEMU_OPTION_tb_size
:
5611 tb_size
= strtol(optarg
, NULL
, 0);
5615 case QEMU_OPTION_icount
:
5617 if (strcmp(optarg
, "auto") == 0) {
5618 icount_time_shift
= -1;
5620 icount_time_shift
= strtol(optarg
, NULL
, 0);
5623 case QEMU_OPTION_incoming
:
5627 case QEMU_OPTION_chroot
:
5628 chroot_dir
= optarg
;
5630 case QEMU_OPTION_runas
:
5635 case QEMU_OPTION_xen_domid
:
5636 xen_domid
= atoi(optarg
);
5638 case QEMU_OPTION_xen_create
:
5639 xen_mode
= XEN_CREATE
;
5641 case QEMU_OPTION_xen_attach
:
5642 xen_mode
= XEN_ATTACH
;
5649 /* If no data_dir is specified then try to find it relative to the
5652 data_dir
= find_datadir(argv
[0]);
5654 /* If all else fails use the install patch specified when building. */
5656 data_dir
= CONFIG_QEMU_SHAREDIR
;
5660 * Default to max_cpus = smp_cpus, in case the user doesn't
5661 * specify a max_cpus value.
5664 max_cpus
= smp_cpus
;
5666 machine
->max_cpus
= machine
->max_cpus
?: 1; /* Default to UP */
5667 if (smp_cpus
> machine
->max_cpus
) {
5668 fprintf(stderr
, "Number of SMP cpus requested (%d), exceeds max cpus "
5669 "supported by machine `%s' (%d)\n", smp_cpus
, machine
->name
,
5674 if (display_type
== DT_NOGRAPHIC
) {
5675 if (serial_device_index
== 0)
5676 serial_devices
[0] = "stdio";
5677 if (parallel_device_index
== 0)
5678 parallel_devices
[0] = "null";
5679 if (strncmp(monitor_devices
[0], "vc", 2) == 0) {
5680 monitor_devices
[0] = "stdio";
5688 if (pipe(fds
) == -1)
5699 len
= read(fds
[0], &status
, 1);
5700 if (len
== -1 && (errno
== EINTR
))
5705 else if (status
== 1) {
5706 fprintf(stderr
, "Could not acquire pidfile\n");
5723 signal(SIGTSTP
, SIG_IGN
);
5724 signal(SIGTTOU
, SIG_IGN
);
5725 signal(SIGTTIN
, SIG_IGN
);
5728 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
5731 write(fds
[1], &status
, 1);
5733 fprintf(stderr
, "Could not acquire pid file\n");
5738 if (qemu_init_main_loop()) {
5739 fprintf(stderr
, "qemu_init_main_loop failed\n");
5742 linux_boot
= (kernel_filename
!= NULL
);
5744 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
5745 fprintf(stderr
, "-append only allowed with -kernel option\n");
5749 if (!linux_boot
&& initrd_filename
!= NULL
) {
5750 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
5755 /* Win32 doesn't support line-buffering and requires size >= 2 */
5756 setvbuf(stdout
, NULL
, _IOLBF
, 0);
5760 if (init_timer_alarm() < 0) {
5761 fprintf(stderr
, "could not initialize alarm timer\n");
5764 if (use_icount
&& icount_time_shift
< 0) {
5766 /* 125MIPS seems a reasonable initial guess at the guest speed.
5767 It will be corrected fairly quickly anyway. */
5768 icount_time_shift
= 3;
5769 init_icount_adjust();
5776 /* init network clients */
5777 if (nb_net_clients
== 0) {
5778 /* if no clients, we use a default config */
5779 net_clients
[nb_net_clients
++] = "nic";
5781 net_clients
[nb_net_clients
++] = "user";
5785 for(i
= 0;i
< nb_net_clients
; i
++) {
5786 if (net_client_parse(net_clients
[i
]) < 0)
5790 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
5791 net_set_boot_mask(net_boot
);
5795 /* init the bluetooth world */
5796 if (foreach_device_config(DEV_BT
, bt_parse
))
5799 /* init the memory */
5801 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
5803 /* init the dynamic translator */
5804 cpu_exec_init_all(tb_size
* 1024 * 1024);
5808 /* we always create the cdrom drive, even if no disk is there */
5809 drive_add(NULL
, CDROM_ALIAS
);
5811 /* we always create at least one floppy */
5812 drive_add(NULL
, FD_ALIAS
, 0);
5814 /* we always create one sd slot, even if no card is in it */
5815 drive_add(NULL
, SD_ALIAS
);
5817 /* open the virtual block devices */
5819 qemu_opts_foreach(&qemu_drive_opts
, drive_enable_snapshot
, NULL
, 0);
5820 if (qemu_opts_foreach(&qemu_drive_opts
, drive_init_func
, machine
, 1) != 0)
5823 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
5824 register_savevm_live("ram", 0, 3, ram_save_live
, NULL
, ram_load
, NULL
);
5826 /* Maintain compatibility with multiple stdio monitors */
5827 if (!strcmp(monitor_devices
[0],"stdio")) {
5828 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
5829 const char *devname
= serial_devices
[i
];
5830 if (devname
&& !strcmp(devname
,"mon:stdio")) {
5831 monitor_devices
[0] = NULL
;
5833 } else if (devname
&& !strcmp(devname
,"stdio")) {
5834 monitor_devices
[0] = NULL
;
5835 serial_devices
[i
] = "mon:stdio";
5841 if (nb_numa_nodes
> 0) {
5844 if (nb_numa_nodes
> smp_cpus
) {
5845 nb_numa_nodes
= smp_cpus
;
5848 /* If no memory size if given for any node, assume the default case
5849 * and distribute the available memory equally across all nodes
5851 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5852 if (node_mem
[i
] != 0)
5855 if (i
== nb_numa_nodes
) {
5856 uint64_t usedmem
= 0;
5858 /* On Linux, the each node's border has to be 8MB aligned,
5859 * the final node gets the rest.
5861 for (i
= 0; i
< nb_numa_nodes
- 1; i
++) {
5862 node_mem
[i
] = (ram_size
/ nb_numa_nodes
) & ~((1 << 23UL) - 1);
5863 usedmem
+= node_mem
[i
];
5865 node_mem
[i
] = ram_size
- usedmem
;
5868 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5869 if (node_cpumask
[i
] != 0)
5872 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5873 * must cope with this anyway, because there are BIOSes out there in
5874 * real machines which also use this scheme.
5876 if (i
== nb_numa_nodes
) {
5877 for (i
= 0; i
< smp_cpus
; i
++) {
5878 node_cpumask
[i
% nb_numa_nodes
] |= 1 << i
;
5883 if (kvm_enabled()) {
5886 ret
= kvm_init(smp_cpus
);
5888 fprintf(stderr
, "failed to initialize KVM\n");
5893 for (i
= 0; i
< MAX_MONITOR_DEVICES
; i
++) {
5894 const char *devname
= monitor_devices
[i
];
5895 if (devname
&& strcmp(devname
, "none")) {
5898 snprintf(label
, sizeof(label
), "monitor");
5900 snprintf(label
, sizeof(label
), "monitor%d", i
);
5902 monitor_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5903 if (!monitor_hds
[i
]) {
5904 fprintf(stderr
, "qemu: could not open monitor device '%s'\n",
5911 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
5912 const char *devname
= serial_devices
[i
];
5913 if (devname
&& strcmp(devname
, "none")) {
5915 snprintf(label
, sizeof(label
), "serial%d", i
);
5916 serial_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5917 if (!serial_hds
[i
]) {
5918 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
5925 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
5926 const char *devname
= parallel_devices
[i
];
5927 if (devname
&& strcmp(devname
, "none")) {
5929 snprintf(label
, sizeof(label
), "parallel%d", i
);
5930 parallel_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5931 if (!parallel_hds
[i
]) {
5932 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
5939 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++) {
5940 const char *devname
= virtio_consoles
[i
];
5941 if (devname
&& strcmp(devname
, "none")) {
5943 snprintf(label
, sizeof(label
), "virtcon%d", i
);
5944 virtcon_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5945 if (!virtcon_hds
[i
]) {
5946 fprintf(stderr
, "qemu: could not open virtio console '%s'\n",
5953 module_call_init(MODULE_INIT_DEVICE
);
5956 i
= select_watchdog(watchdog
);
5958 exit (i
== 1 ? 1 : 0);
5961 if (machine
->compat_props
) {
5962 qdev_prop_register_compat(machine
->compat_props
);
5964 machine
->init(ram_size
, boot_devices
,
5965 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
5969 /* must be after terminal init, SDL library changes signal handlers */
5973 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
5974 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5975 if (node_cpumask
[i
] & (1 << env
->cpu_index
)) {
5981 current_machine
= machine
;
5983 /* init USB devices */
5985 foreach_device_config(DEV_USB
, usb_parse
);
5988 /* init generic devices */
5989 if (qemu_opts_foreach(&qemu_device_opts
, device_init_func
, NULL
, 1) != 0)
5993 dumb_display_init();
5994 /* just use the first displaystate for the moment */
5997 if (display_type
== DT_DEFAULT
) {
5998 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5999 display_type
= DT_SDL
;
6001 display_type
= DT_VNC
;
6002 vnc_display
= "localhost:0,to=99";
6008 switch (display_type
) {
6011 #if defined(CONFIG_CURSES)
6013 curses_display_init(ds
, full_screen
);
6016 #if defined(CONFIG_SDL)
6018 sdl_display_init(ds
, full_screen
, no_frame
);
6020 #elif defined(CONFIG_COCOA)
6022 cocoa_display_init(ds
, full_screen
);
6026 vnc_display_init(ds
);
6027 if (vnc_display_open(ds
, vnc_display
) < 0)
6030 if (show_vnc_port
) {
6031 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds
));
6039 dcl
= ds
->listeners
;
6040 while (dcl
!= NULL
) {
6041 if (dcl
->dpy_refresh
!= NULL
) {
6042 ds
->gui_timer
= qemu_new_timer(rt_clock
, gui_update
, ds
);
6043 qemu_mod_timer(ds
->gui_timer
, qemu_get_clock(rt_clock
));
6048 if (display_type
== DT_NOGRAPHIC
|| display_type
== DT_VNC
) {
6049 nographic_timer
= qemu_new_timer(rt_clock
, nographic_update
, NULL
);
6050 qemu_mod_timer(nographic_timer
, qemu_get_clock(rt_clock
));
6053 text_consoles_set_display(display_state
);
6054 qemu_chr_initial_reset();
6056 for (i
= 0; i
< MAX_MONITOR_DEVICES
; i
++) {
6057 if (monitor_devices
[i
] && monitor_hds
[i
]) {
6058 monitor_init(monitor_hds
[i
],
6059 MONITOR_USE_READLINE
|
6060 ((i
== 0) ? MONITOR_IS_DEFAULT
: 0));
6064 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
6065 const char *devname
= serial_devices
[i
];
6066 if (devname
&& strcmp(devname
, "none")) {
6067 if (strstart(devname
, "vc", 0))
6068 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
6072 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
6073 const char *devname
= parallel_devices
[i
];
6074 if (devname
&& strcmp(devname
, "none")) {
6075 if (strstart(devname
, "vc", 0))
6076 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
6080 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++) {
6081 const char *devname
= virtio_consoles
[i
];
6082 if (virtcon_hds
[i
] && devname
) {
6083 if (strstart(devname
, "vc", 0))
6084 qemu_chr_printf(virtcon_hds
[i
], "virtio console%d\r\n", i
);
6088 if (gdbstub_dev
&& gdbserver_start(gdbstub_dev
) < 0) {
6089 fprintf(stderr
, "qemu: could not open gdbserver on device '%s'\n",
6095 if (load_vmstate(cur_mon
, loadvm
) < 0) {
6101 qemu_start_incoming_migration(incoming
);
6102 } else if (autostart
) {
6112 len
= write(fds
[1], &status
, 1);
6113 if (len
== -1 && (errno
== EINTR
))
6120 TFR(fd
= open("/dev/null", O_RDWR
));
6126 pwd
= getpwnam(run_as
);
6128 fprintf(stderr
, "User \"%s\" doesn't exist\n", run_as
);
6134 if (chroot(chroot_dir
) < 0) {
6135 fprintf(stderr
, "chroot failed\n");
6142 if (setgid(pwd
->pw_gid
) < 0) {
6143 fprintf(stderr
, "Failed to setgid(%d)\n", pwd
->pw_gid
);
6146 if (setuid(pwd
->pw_uid
) < 0) {
6147 fprintf(stderr
, "Failed to setuid(%d)\n", pwd
->pw_uid
);
6150 if (setuid(0) != -1) {
6151 fprintf(stderr
, "Dropping privileges failed\n");