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"
38 #include <sys/times.h>
42 #include <sys/ioctl.h>
43 #include <sys/resource.h>
44 #include <sys/socket.h>
45 #include <netinet/in.h>
47 #if defined(__NetBSD__)
48 #include <net/if_tap.h>
51 #include <linux/if_tun.h>
53 #include <arpa/inet.h>
56 #include <sys/select.h>
59 #if defined(__FreeBSD__) || defined(__DragonFly__)
64 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
65 #include <freebsd/stdlib.h>
70 #include <linux/rtc.h>
71 #include <sys/prctl.h>
73 /* For the benefit of older linux systems which don't supply it,
74 we use a local copy of hpet.h. */
75 /* #include <linux/hpet.h> */
78 #include <linux/ppdev.h>
79 #include <linux/parport.h>
83 #include <sys/ethernet.h>
84 #include <sys/sockio.h>
85 #include <netinet/arp.h>
86 #include <netinet/in.h>
87 #include <netinet/in_systm.h>
88 #include <netinet/ip.h>
89 #include <netinet/ip_icmp.h> // must come after ip.h
90 #include <netinet/udp.h>
91 #include <netinet/tcp.h>
95 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
96 discussion about Solaris header problems */
97 extern int madvise(caddr_t
, size_t, int);
102 #if defined(__OpenBSD__)
106 #if defined(CONFIG_VDE)
107 #include <libvdeplug.h>
112 #include <mmsystem.h>
116 #if defined(__APPLE__) || defined(main)
118 int qemu_main(int argc
, char **argv
, char **envp
);
119 int main(int argc
, char **argv
)
121 return qemu_main(argc
, argv
, NULL
);
124 #define main qemu_main
126 #endif /* CONFIG_SDL */
130 #define main qemu_main
131 #endif /* CONFIG_COCOA */
134 #include "hw/boards.h"
136 #include "hw/pcmcia.h"
138 #include "hw/audiodev.h"
142 #include "hw/watchdog.h"
143 #include "hw/smbios.h"
146 #include "hw/loader.h"
153 #include "qemu-timer.h"
154 #include "qemu-char.h"
155 #include "cache-utils.h"
158 #include "audio/audio.h"
159 #include "migration.h"
162 #include "qemu-option.h"
163 #include "qemu-config.h"
167 #include "exec-all.h"
169 #include "qemu_socket.h"
171 #include "slirp/libslirp.h"
173 #include "qemu-queue.h"
176 //#define DEBUG_SLIRP
178 #define DEFAULT_RAM_SIZE 128
180 /* Maximum number of monitor devices */
181 #define MAX_MONITOR_DEVICES 10
183 static const char *data_dir
;
184 const char *bios_name
= NULL
;
185 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
186 to store the VM snapshots */
187 struct drivelist drives
= QTAILQ_HEAD_INITIALIZER(drives
);
188 struct driveoptlist driveopts
= QTAILQ_HEAD_INITIALIZER(driveopts
);
189 enum vga_retrace_method vga_retrace_method
= VGA_RETRACE_DUMB
;
190 static DisplayState
*display_state
;
191 DisplayType display_type
= DT_DEFAULT
;
192 const char* keyboard_layout
= NULL
;
195 NICInfo nd_table
[MAX_NICS
];
198 static int rtc_utc
= 1;
199 static int rtc_date_offset
= -1; /* -1 means no change */
200 QEMUClock
*rtc_clock
;
201 int vga_interface_type
= VGA_CIRRUS
;
203 int graphic_width
= 1024;
204 int graphic_height
= 768;
205 int graphic_depth
= 8;
207 int graphic_width
= 800;
208 int graphic_height
= 600;
209 int graphic_depth
= 15;
211 static int full_screen
= 0;
213 static int no_frame
= 0;
216 CharDriverState
*serial_hds
[MAX_SERIAL_PORTS
];
217 CharDriverState
*parallel_hds
[MAX_PARALLEL_PORTS
];
218 CharDriverState
*virtcon_hds
[MAX_VIRTIO_CONSOLES
];
220 int win2k_install_hack
= 0;
229 const char *vnc_display
;
230 int acpi_enabled
= 1;
236 int graphic_rotate
= 0;
237 uint8_t irq0override
= 1;
241 const char *watchdog
;
242 const char *option_rom
[MAX_OPTION_ROMS
];
244 int semihosting_enabled
= 0;
248 const char *qemu_name
;
251 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
252 unsigned int nb_prom_envs
= 0;
253 const char *prom_envs
[MAX_PROM_ENVS
];
258 uint64_t node_mem
[MAX_NODES
];
259 uint64_t node_cpumask
[MAX_NODES
];
261 static CPUState
*cur_cpu
;
262 static CPUState
*next_cpu
;
263 static int timer_alarm_pending
= 1;
264 /* Conversion factor from emulated instructions to virtual clock ticks. */
265 static int icount_time_shift
;
266 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
267 #define MAX_ICOUNT_SHIFT 10
268 /* Compensate for varying guest execution speed. */
269 static int64_t qemu_icount_bias
;
270 static QEMUTimer
*icount_rt_timer
;
271 static QEMUTimer
*icount_vm_timer
;
272 static QEMUTimer
*nographic_timer
;
274 uint8_t qemu_uuid
[16];
276 static QEMUBootSetHandler
*boot_set_handler
;
277 static void *boot_set_opaque
;
279 /***********************************************************/
280 /* x86 ISA bus support */
282 target_phys_addr_t isa_mem_base
= 0;
285 /***********************************************************/
286 void hw_error(const char *fmt
, ...)
292 fprintf(stderr
, "qemu: hardware error: ");
293 vfprintf(stderr
, fmt
, ap
);
294 fprintf(stderr
, "\n");
295 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
296 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
298 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
300 cpu_dump_state(env
, stderr
, fprintf
, 0);
307 static void set_proc_name(const char *s
)
309 #if defined(__linux__) && defined(PR_SET_NAME)
313 name
[sizeof(name
) - 1] = 0;
314 strncpy(name
, s
, sizeof(name
));
315 /* Could rewrite argv[0] too, but that's a bit more complicated.
316 This simple way is enough for `top'. */
317 prctl(PR_SET_NAME
, name
);
324 static QEMUBalloonEvent
*qemu_balloon_event
;
325 void *qemu_balloon_event_opaque
;
327 void qemu_add_balloon_handler(QEMUBalloonEvent
*func
, void *opaque
)
329 qemu_balloon_event
= func
;
330 qemu_balloon_event_opaque
= opaque
;
333 void qemu_balloon(ram_addr_t target
)
335 if (qemu_balloon_event
)
336 qemu_balloon_event(qemu_balloon_event_opaque
, target
);
339 ram_addr_t
qemu_balloon_status(void)
341 if (qemu_balloon_event
)
342 return qemu_balloon_event(qemu_balloon_event_opaque
, 0);
346 /***********************************************************/
349 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
350 static void *qemu_put_kbd_event_opaque
;
351 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
352 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
354 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
356 qemu_put_kbd_event_opaque
= opaque
;
357 qemu_put_kbd_event
= func
;
360 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
361 void *opaque
, int absolute
,
364 QEMUPutMouseEntry
*s
, *cursor
;
366 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
368 s
->qemu_put_mouse_event
= func
;
369 s
->qemu_put_mouse_event_opaque
= opaque
;
370 s
->qemu_put_mouse_event_absolute
= absolute
;
371 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
374 if (!qemu_put_mouse_event_head
) {
375 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
379 cursor
= qemu_put_mouse_event_head
;
380 while (cursor
->next
!= NULL
)
381 cursor
= cursor
->next
;
384 qemu_put_mouse_event_current
= s
;
389 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
391 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
393 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
396 cursor
= qemu_put_mouse_event_head
;
397 while (cursor
!= NULL
&& cursor
!= entry
) {
399 cursor
= cursor
->next
;
402 if (cursor
== NULL
) // does not exist or list empty
404 else if (prev
== NULL
) { // entry is head
405 qemu_put_mouse_event_head
= cursor
->next
;
406 if (qemu_put_mouse_event_current
== entry
)
407 qemu_put_mouse_event_current
= cursor
->next
;
408 qemu_free(entry
->qemu_put_mouse_event_name
);
413 prev
->next
= entry
->next
;
415 if (qemu_put_mouse_event_current
== entry
)
416 qemu_put_mouse_event_current
= prev
;
418 qemu_free(entry
->qemu_put_mouse_event_name
);
422 void kbd_put_keycode(int keycode
)
424 if (qemu_put_kbd_event
) {
425 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
429 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
431 QEMUPutMouseEvent
*mouse_event
;
432 void *mouse_event_opaque
;
435 if (!qemu_put_mouse_event_current
) {
440 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
442 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
445 if (graphic_rotate
) {
446 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
449 width
= graphic_width
- 1;
450 mouse_event(mouse_event_opaque
,
451 width
- dy
, dx
, dz
, buttons_state
);
453 mouse_event(mouse_event_opaque
,
454 dx
, dy
, dz
, buttons_state
);
458 int kbd_mouse_is_absolute(void)
460 if (!qemu_put_mouse_event_current
)
463 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
466 void do_info_mice(Monitor
*mon
)
468 QEMUPutMouseEntry
*cursor
;
471 if (!qemu_put_mouse_event_head
) {
472 monitor_printf(mon
, "No mouse devices connected\n");
476 monitor_printf(mon
, "Mouse devices available:\n");
477 cursor
= qemu_put_mouse_event_head
;
478 while (cursor
!= NULL
) {
479 monitor_printf(mon
, "%c Mouse #%d: %s\n",
480 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
481 index
, cursor
->qemu_put_mouse_event_name
);
483 cursor
= cursor
->next
;
487 void do_mouse_set(Monitor
*mon
, const QDict
*qdict
)
489 QEMUPutMouseEntry
*cursor
;
491 int index
= qdict_get_int(qdict
, "index");
493 if (!qemu_put_mouse_event_head
) {
494 monitor_printf(mon
, "No mouse devices connected\n");
498 cursor
= qemu_put_mouse_event_head
;
499 while (cursor
!= NULL
&& index
!= i
) {
501 cursor
= cursor
->next
;
505 qemu_put_mouse_event_current
= cursor
;
507 monitor_printf(mon
, "Mouse at given index not found\n");
510 /* compute with 96 bit intermediate result: (a*b)/c */
511 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
516 #ifdef HOST_WORDS_BIGENDIAN
526 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
527 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
530 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
534 /***********************************************************/
535 /* real time host monotonic timer */
537 static int64_t get_clock_realtime(void)
541 gettimeofday(&tv
, NULL
);
542 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
547 static int64_t clock_freq
;
549 static void init_get_clock(void)
553 ret
= QueryPerformanceFrequency(&freq
);
555 fprintf(stderr
, "Could not calibrate ticks\n");
558 clock_freq
= freq
.QuadPart
;
561 static int64_t get_clock(void)
564 QueryPerformanceCounter(&ti
);
565 return muldiv64(ti
.QuadPart
, get_ticks_per_sec(), clock_freq
);
570 static int use_rt_clock
;
572 static void init_get_clock(void)
575 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
576 || defined(__DragonFly__)
579 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
586 static int64_t get_clock(void)
588 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
589 || defined(__DragonFly__)
592 clock_gettime(CLOCK_MONOTONIC
, &ts
);
593 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
597 /* XXX: using gettimeofday leads to problems if the date
598 changes, so it should be avoided. */
599 return get_clock_realtime();
604 /* Return the virtual CPU time, based on the instruction counter. */
605 static int64_t cpu_get_icount(void)
608 CPUState
*env
= cpu_single_env
;;
609 icount
= qemu_icount
;
612 fprintf(stderr
, "Bad clock read\n");
613 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
615 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
618 /***********************************************************/
619 /* guest cycle counter */
621 typedef struct TimersState
{
622 int64_t cpu_ticks_prev
;
623 int64_t cpu_ticks_offset
;
624 int64_t cpu_clock_offset
;
625 int32_t cpu_ticks_enabled
;
629 TimersState timers_state
;
631 /* return the host CPU cycle counter and handle stop/restart */
632 int64_t cpu_get_ticks(void)
635 return cpu_get_icount();
637 if (!timers_state
.cpu_ticks_enabled
) {
638 return timers_state
.cpu_ticks_offset
;
641 ticks
= cpu_get_real_ticks();
642 if (timers_state
.cpu_ticks_prev
> ticks
) {
643 /* Note: non increasing ticks may happen if the host uses
645 timers_state
.cpu_ticks_offset
+= timers_state
.cpu_ticks_prev
- ticks
;
647 timers_state
.cpu_ticks_prev
= ticks
;
648 return ticks
+ timers_state
.cpu_ticks_offset
;
652 /* return the host CPU monotonic timer and handle stop/restart */
653 static int64_t cpu_get_clock(void)
656 if (!timers_state
.cpu_ticks_enabled
) {
657 return timers_state
.cpu_clock_offset
;
660 return ti
+ timers_state
.cpu_clock_offset
;
664 /* enable cpu_get_ticks() */
665 void cpu_enable_ticks(void)
667 if (!timers_state
.cpu_ticks_enabled
) {
668 timers_state
.cpu_ticks_offset
-= cpu_get_real_ticks();
669 timers_state
.cpu_clock_offset
-= get_clock();
670 timers_state
.cpu_ticks_enabled
= 1;
674 /* disable cpu_get_ticks() : the clock is stopped. You must not call
675 cpu_get_ticks() after that. */
676 void cpu_disable_ticks(void)
678 if (timers_state
.cpu_ticks_enabled
) {
679 timers_state
.cpu_ticks_offset
= cpu_get_ticks();
680 timers_state
.cpu_clock_offset
= cpu_get_clock();
681 timers_state
.cpu_ticks_enabled
= 0;
685 /***********************************************************/
688 #define QEMU_CLOCK_REALTIME 0
689 #define QEMU_CLOCK_VIRTUAL 1
690 #define QEMU_CLOCK_HOST 2
694 /* XXX: add frequency */
702 struct QEMUTimer
*next
;
705 struct qemu_alarm_timer
{
709 int (*start
)(struct qemu_alarm_timer
*t
);
710 void (*stop
)(struct qemu_alarm_timer
*t
);
711 void (*rearm
)(struct qemu_alarm_timer
*t
);
715 #define ALARM_FLAG_DYNTICKS 0x1
716 #define ALARM_FLAG_EXPIRED 0x2
718 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
720 return t
&& (t
->flags
& ALARM_FLAG_DYNTICKS
);
723 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
725 if (!alarm_has_dynticks(t
))
731 /* TODO: MIN_TIMER_REARM_US should be optimized */
732 #define MIN_TIMER_REARM_US 250
734 static struct qemu_alarm_timer
*alarm_timer
;
738 struct qemu_alarm_win32
{
741 } alarm_win32_data
= {0, -1};
743 static int win32_start_timer(struct qemu_alarm_timer
*t
);
744 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
745 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
749 static int unix_start_timer(struct qemu_alarm_timer
*t
);
750 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
754 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
755 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
756 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
758 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
759 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
761 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
762 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
764 #endif /* __linux__ */
768 /* Correlation between real and virtual time is always going to be
769 fairly approximate, so ignore small variation.
770 When the guest is idle real and virtual time will be aligned in
772 #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
774 static void icount_adjust(void)
779 static int64_t last_delta
;
780 /* If the VM is not running, then do nothing. */
784 cur_time
= cpu_get_clock();
785 cur_icount
= qemu_get_clock(vm_clock
);
786 delta
= cur_icount
- cur_time
;
787 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
789 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
790 && icount_time_shift
> 0) {
791 /* The guest is getting too far ahead. Slow time down. */
795 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
796 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
797 /* The guest is getting too far behind. Speed time up. */
801 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
804 static void icount_adjust_rt(void * opaque
)
806 qemu_mod_timer(icount_rt_timer
,
807 qemu_get_clock(rt_clock
) + 1000);
811 static void icount_adjust_vm(void * opaque
)
813 qemu_mod_timer(icount_vm_timer
,
814 qemu_get_clock(vm_clock
) + get_ticks_per_sec() / 10);
818 static void init_icount_adjust(void)
820 /* Have both realtime and virtual time triggers for speed adjustment.
821 The realtime trigger catches emulated time passing too slowly,
822 the virtual time trigger catches emulated time passing too fast.
823 Realtime triggers occur even when idle, so use them less frequently
825 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
826 qemu_mod_timer(icount_rt_timer
,
827 qemu_get_clock(rt_clock
) + 1000);
828 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
829 qemu_mod_timer(icount_vm_timer
,
830 qemu_get_clock(vm_clock
) + get_ticks_per_sec() / 10);
833 static struct qemu_alarm_timer alarm_timers
[] = {
836 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
837 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
838 /* HPET - if available - is preferred */
839 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
840 /* ...otherwise try RTC */
841 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
843 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
845 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
846 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
847 {"win32", 0, win32_start_timer
,
848 win32_stop_timer
, NULL
, &alarm_win32_data
},
853 static void show_available_alarms(void)
857 printf("Available alarm timers, in order of precedence:\n");
858 for (i
= 0; alarm_timers
[i
].name
; i
++)
859 printf("%s\n", alarm_timers
[i
].name
);
862 static void configure_alarms(char const *opt
)
866 int count
= ARRAY_SIZE(alarm_timers
) - 1;
869 struct qemu_alarm_timer tmp
;
871 if (!strcmp(opt
, "?")) {
872 show_available_alarms();
876 arg
= qemu_strdup(opt
);
878 /* Reorder the array */
879 name
= strtok(arg
, ",");
881 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
882 if (!strcmp(alarm_timers
[i
].name
, name
))
887 fprintf(stderr
, "Unknown clock %s\n", name
);
896 tmp
= alarm_timers
[i
];
897 alarm_timers
[i
] = alarm_timers
[cur
];
898 alarm_timers
[cur
] = tmp
;
902 name
= strtok(NULL
, ",");
908 /* Disable remaining timers */
909 for (i
= cur
; i
< count
; i
++)
910 alarm_timers
[i
].name
= NULL
;
912 show_available_alarms();
917 #define QEMU_NUM_CLOCKS 3
921 QEMUClock
*host_clock
;
923 static QEMUTimer
*active_timers
[QEMU_NUM_CLOCKS
];
925 static QEMUClock
*qemu_new_clock(int type
)
928 clock
= qemu_mallocz(sizeof(QEMUClock
));
933 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
937 ts
= qemu_mallocz(sizeof(QEMUTimer
));
944 void qemu_free_timer(QEMUTimer
*ts
)
949 /* stop a timer, but do not dealloc it */
950 void qemu_del_timer(QEMUTimer
*ts
)
954 /* NOTE: this code must be signal safe because
955 qemu_timer_expired() can be called from a signal. */
956 pt
= &active_timers
[ts
->clock
->type
];
969 /* modify the current timer so that it will be fired when current_time
970 >= expire_time. The corresponding callback will be called. */
971 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
977 /* add the timer in the sorted list */
978 /* NOTE: this code must be signal safe because
979 qemu_timer_expired() can be called from a signal. */
980 pt
= &active_timers
[ts
->clock
->type
];
985 if (t
->expire_time
> expire_time
)
989 ts
->expire_time
= expire_time
;
993 /* Rearm if necessary */
994 if (pt
== &active_timers
[ts
->clock
->type
]) {
995 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
996 qemu_rearm_alarm_timer(alarm_timer
);
998 /* Interrupt execution to force deadline recalculation. */
1000 qemu_notify_event();
1004 int qemu_timer_pending(QEMUTimer
*ts
)
1007 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1014 int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1018 return (timer_head
->expire_time
<= current_time
);
1021 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1027 if (!ts
|| ts
->expire_time
> current_time
)
1029 /* remove timer from the list before calling the callback */
1030 *ptimer_head
= ts
->next
;
1033 /* run the callback (the timer list can be modified) */
1038 int64_t qemu_get_clock(QEMUClock
*clock
)
1040 switch(clock
->type
) {
1041 case QEMU_CLOCK_REALTIME
:
1042 return get_clock() / 1000000;
1044 case QEMU_CLOCK_VIRTUAL
:
1046 return cpu_get_icount();
1048 return cpu_get_clock();
1050 case QEMU_CLOCK_HOST
:
1051 return get_clock_realtime();
1055 static void init_clocks(void)
1058 rt_clock
= qemu_new_clock(QEMU_CLOCK_REALTIME
);
1059 vm_clock
= qemu_new_clock(QEMU_CLOCK_VIRTUAL
);
1060 host_clock
= qemu_new_clock(QEMU_CLOCK_HOST
);
1062 rtc_clock
= host_clock
;
1066 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1068 uint64_t expire_time
;
1070 if (qemu_timer_pending(ts
)) {
1071 expire_time
= ts
->expire_time
;
1075 qemu_put_be64(f
, expire_time
);
1078 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1080 uint64_t expire_time
;
1082 expire_time
= qemu_get_be64(f
);
1083 if (expire_time
!= -1) {
1084 qemu_mod_timer(ts
, expire_time
);
1090 static const VMStateDescription vmstate_timers
= {
1093 .minimum_version_id
= 1,
1094 .minimum_version_id_old
= 1,
1095 .fields
= (VMStateField
[]) {
1096 VMSTATE_INT64(cpu_ticks_offset
, TimersState
),
1097 VMSTATE_INT64(dummy
, TimersState
),
1098 VMSTATE_INT64_V(cpu_clock_offset
, TimersState
, 2),
1099 VMSTATE_END_OF_LIST()
1103 static void qemu_event_increment(void);
1106 static void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1107 DWORD_PTR dwUser
, DWORD_PTR dw1
,
1110 static void host_alarm_handler(int host_signum
)
1114 #define DISP_FREQ 1000
1116 static int64_t delta_min
= INT64_MAX
;
1117 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1119 ti
= qemu_get_clock(vm_clock
);
1120 if (last_clock
!= 0) {
1121 delta
= ti
- last_clock
;
1122 if (delta
< delta_min
)
1124 if (delta
> delta_max
)
1127 if (++count
== DISP_FREQ
) {
1128 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1129 muldiv64(delta_min
, 1000000, get_ticks_per_sec()),
1130 muldiv64(delta_max
, 1000000, get_ticks_per_sec()),
1131 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, get_ticks_per_sec()),
1132 (double)get_ticks_per_sec() / ((double)delta_cum
/ DISP_FREQ
));
1134 delta_min
= INT64_MAX
;
1142 if (alarm_has_dynticks(alarm_timer
) ||
1144 qemu_timer_expired(active_timers
[QEMU_CLOCK_VIRTUAL
],
1145 qemu_get_clock(vm_clock
))) ||
1146 qemu_timer_expired(active_timers
[QEMU_CLOCK_REALTIME
],
1147 qemu_get_clock(rt_clock
)) ||
1148 qemu_timer_expired(active_timers
[QEMU_CLOCK_HOST
],
1149 qemu_get_clock(host_clock
))) {
1150 qemu_event_increment();
1151 if (alarm_timer
) alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1153 #ifndef CONFIG_IOTHREAD
1155 /* stop the currently executing cpu because a timer occured */
1159 timer_alarm_pending
= 1;
1160 qemu_notify_event();
1164 static int64_t qemu_next_deadline(void)
1166 /* To avoid problems with overflow limit this to 2^32. */
1167 int64_t delta
= INT32_MAX
;
1169 if (active_timers
[QEMU_CLOCK_VIRTUAL
]) {
1170 delta
= active_timers
[QEMU_CLOCK_VIRTUAL
]->expire_time
-
1171 qemu_get_clock(vm_clock
);
1173 if (active_timers
[QEMU_CLOCK_HOST
]) {
1174 int64_t hdelta
= active_timers
[QEMU_CLOCK_HOST
]->expire_time
-
1175 qemu_get_clock(host_clock
);
1186 #if defined(__linux__)
1187 static uint64_t qemu_next_deadline_dyntick(void)
1195 delta
= (qemu_next_deadline() + 999) / 1000;
1197 if (active_timers
[QEMU_CLOCK_REALTIME
]) {
1198 rtdelta
= (active_timers
[QEMU_CLOCK_REALTIME
]->expire_time
-
1199 qemu_get_clock(rt_clock
))*1000;
1200 if (rtdelta
< delta
)
1204 if (delta
< MIN_TIMER_REARM_US
)
1205 delta
= MIN_TIMER_REARM_US
;
1213 /* Sets a specific flag */
1214 static int fcntl_setfl(int fd
, int flag
)
1218 flags
= fcntl(fd
, F_GETFL
);
1222 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
1228 #if defined(__linux__)
1230 #define RTC_FREQ 1024
1232 static void enable_sigio_timer(int fd
)
1234 struct sigaction act
;
1237 sigfillset(&act
.sa_mask
);
1239 act
.sa_handler
= host_alarm_handler
;
1241 sigaction(SIGIO
, &act
, NULL
);
1242 fcntl_setfl(fd
, O_ASYNC
);
1243 fcntl(fd
, F_SETOWN
, getpid());
1246 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1248 struct hpet_info info
;
1251 fd
= open("/dev/hpet", O_RDONLY
);
1256 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1258 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1259 "error, but for better emulation accuracy type:\n"
1260 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1264 /* Check capabilities */
1265 r
= ioctl(fd
, HPET_INFO
, &info
);
1269 /* Enable periodic mode */
1270 r
= ioctl(fd
, HPET_EPI
, 0);
1271 if (info
.hi_flags
&& (r
< 0))
1274 /* Enable interrupt */
1275 r
= ioctl(fd
, HPET_IE_ON
, 0);
1279 enable_sigio_timer(fd
);
1280 t
->priv
= (void *)(long)fd
;
1288 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1290 int fd
= (long)t
->priv
;
1295 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1298 unsigned long current_rtc_freq
= 0;
1300 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1303 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1304 if (current_rtc_freq
!= RTC_FREQ
&&
1305 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1306 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1307 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1308 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1311 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1317 enable_sigio_timer(rtc_fd
);
1319 t
->priv
= (void *)(long)rtc_fd
;
1324 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1326 int rtc_fd
= (long)t
->priv
;
1331 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1335 struct sigaction act
;
1337 sigfillset(&act
.sa_mask
);
1339 act
.sa_handler
= host_alarm_handler
;
1341 sigaction(SIGALRM
, &act
, NULL
);
1344 * Initialize ev struct to 0 to avoid valgrind complaining
1345 * about uninitialized data in timer_create call
1347 memset(&ev
, 0, sizeof(ev
));
1348 ev
.sigev_value
.sival_int
= 0;
1349 ev
.sigev_notify
= SIGEV_SIGNAL
;
1350 ev
.sigev_signo
= SIGALRM
;
1352 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1353 perror("timer_create");
1355 /* disable dynticks */
1356 fprintf(stderr
, "Dynamic Ticks disabled\n");
1361 t
->priv
= (void *)(long)host_timer
;
1366 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1368 timer_t host_timer
= (timer_t
)(long)t
->priv
;
1370 timer_delete(host_timer
);
1373 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1375 timer_t host_timer
= (timer_t
)(long)t
->priv
;
1376 struct itimerspec timeout
;
1377 int64_t nearest_delta_us
= INT64_MAX
;
1380 if (!active_timers
[QEMU_CLOCK_REALTIME
] &&
1381 !active_timers
[QEMU_CLOCK_VIRTUAL
] &&
1382 !active_timers
[QEMU_CLOCK_HOST
])
1385 nearest_delta_us
= qemu_next_deadline_dyntick();
1387 /* check whether a timer is already running */
1388 if (timer_gettime(host_timer
, &timeout
)) {
1390 fprintf(stderr
, "Internal timer error: aborting\n");
1393 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1394 if (current_us
&& current_us
<= nearest_delta_us
)
1397 timeout
.it_interval
.tv_sec
= 0;
1398 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1399 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1400 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1401 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1403 fprintf(stderr
, "Internal timer error: aborting\n");
1408 #endif /* defined(__linux__) */
1410 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1412 struct sigaction act
;
1413 struct itimerval itv
;
1417 sigfillset(&act
.sa_mask
);
1419 act
.sa_handler
= host_alarm_handler
;
1421 sigaction(SIGALRM
, &act
, NULL
);
1423 itv
.it_interval
.tv_sec
= 0;
1424 /* for i386 kernel 2.6 to get 1 ms */
1425 itv
.it_interval
.tv_usec
= 999;
1426 itv
.it_value
.tv_sec
= 0;
1427 itv
.it_value
.tv_usec
= 10 * 1000;
1429 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1436 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1438 struct itimerval itv
;
1440 memset(&itv
, 0, sizeof(itv
));
1441 setitimer(ITIMER_REAL
, &itv
, NULL
);
1444 #endif /* !defined(_WIN32) */
1449 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1452 struct qemu_alarm_win32
*data
= t
->priv
;
1455 memset(&tc
, 0, sizeof(tc
));
1456 timeGetDevCaps(&tc
, sizeof(tc
));
1458 if (data
->period
< tc
.wPeriodMin
)
1459 data
->period
= tc
.wPeriodMin
;
1461 timeBeginPeriod(data
->period
);
1463 flags
= TIME_CALLBACK_FUNCTION
;
1464 if (alarm_has_dynticks(t
))
1465 flags
|= TIME_ONESHOT
;
1467 flags
|= TIME_PERIODIC
;
1469 data
->timerId
= timeSetEvent(1, // interval (ms)
1470 data
->period
, // resolution
1471 host_alarm_handler
, // function
1472 (DWORD
)t
, // parameter
1475 if (!data
->timerId
) {
1476 fprintf(stderr
, "Failed to initialize win32 alarm timer: %ld\n",
1478 timeEndPeriod(data
->period
);
1485 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1487 struct qemu_alarm_win32
*data
= t
->priv
;
1489 timeKillEvent(data
->timerId
);
1490 timeEndPeriod(data
->period
);
1493 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1495 struct qemu_alarm_win32
*data
= t
->priv
;
1497 if (!active_timers
[QEMU_CLOCK_REALTIME
] &&
1498 !active_timers
[QEMU_CLOCK_VIRTUAL
] &&
1499 !active_timers
[QEMU_CLOCK_HOST
])
1502 timeKillEvent(data
->timerId
);
1504 data
->timerId
= timeSetEvent(1,
1508 TIME_ONESHOT
| TIME_PERIODIC
);
1510 if (!data
->timerId
) {
1511 fprintf(stderr
, "Failed to re-arm win32 alarm timer %ld\n",
1514 timeEndPeriod(data
->period
);
1521 static int init_timer_alarm(void)
1523 struct qemu_alarm_timer
*t
= NULL
;
1526 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1527 t
= &alarm_timers
[i
];
1547 static void quit_timers(void)
1549 alarm_timer
->stop(alarm_timer
);
1553 /***********************************************************/
1554 /* host time/date access */
1555 void qemu_get_timedate(struct tm
*tm
, int offset
)
1562 if (rtc_date_offset
== -1) {
1566 ret
= localtime(&ti
);
1568 ti
-= rtc_date_offset
;
1572 memcpy(tm
, ret
, sizeof(struct tm
));
1575 int qemu_timedate_diff(struct tm
*tm
)
1579 if (rtc_date_offset
== -1)
1581 seconds
= mktimegm(tm
);
1583 seconds
= mktime(tm
);
1585 seconds
= mktimegm(tm
) + rtc_date_offset
;
1587 return seconds
- time(NULL
);
1590 static void configure_rtc_date_offset(const char *startdate
, int legacy
)
1592 time_t rtc_start_date
;
1595 if (!strcmp(startdate
, "now") && legacy
) {
1596 rtc_date_offset
= -1;
1598 if (sscanf(startdate
, "%d-%d-%dT%d:%d:%d",
1606 } else if (sscanf(startdate
, "%d-%d-%d",
1609 &tm
.tm_mday
) == 3) {
1618 rtc_start_date
= mktimegm(&tm
);
1619 if (rtc_start_date
== -1) {
1621 fprintf(stderr
, "Invalid date format. Valid formats are:\n"
1622 "'2006-06-17T16:01:21' or '2006-06-17'\n");
1625 rtc_date_offset
= time(NULL
) - rtc_start_date
;
1629 static void configure_rtc(QemuOpts
*opts
)
1633 value
= qemu_opt_get(opts
, "base");
1635 if (!strcmp(value
, "utc")) {
1637 } else if (!strcmp(value
, "localtime")) {
1640 configure_rtc_date_offset(value
, 0);
1643 value
= qemu_opt_get(opts
, "clock");
1645 if (!strcmp(value
, "host")) {
1646 rtc_clock
= host_clock
;
1647 } else if (!strcmp(value
, "vm")) {
1648 rtc_clock
= vm_clock
;
1650 fprintf(stderr
, "qemu: invalid option value '%s'\n", value
);
1654 #ifdef CONFIG_TARGET_I386
1655 value
= qemu_opt_get(opts
, "driftfix");
1657 if (!strcmp(buf
, "slew")) {
1659 } else if (!strcmp(buf
, "none")) {
1662 fprintf(stderr
, "qemu: invalid option value '%s'\n", value
);
1670 static void socket_cleanup(void)
1675 static int socket_init(void)
1680 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
1682 err
= WSAGetLastError();
1683 fprintf(stderr
, "WSAStartup: %d\n", err
);
1686 atexit(socket_cleanup
);
1691 /***********************************************************/
1692 /* Bluetooth support */
1695 static struct HCIInfo
*hci_table
[MAX_NICS
];
1697 static struct bt_vlan_s
{
1698 struct bt_scatternet_s net
;
1700 struct bt_vlan_s
*next
;
1703 /* find or alloc a new bluetooth "VLAN" */
1704 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
1706 struct bt_vlan_s
**pvlan
, *vlan
;
1707 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
1711 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
1713 pvlan
= &first_bt_vlan
;
1714 while (*pvlan
!= NULL
)
1715 pvlan
= &(*pvlan
)->next
;
1720 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
1724 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
1729 static struct HCIInfo null_hci
= {
1730 .cmd_send
= null_hci_send
,
1731 .sco_send
= null_hci_send
,
1732 .acl_send
= null_hci_send
,
1733 .bdaddr_set
= null_hci_addr_set
,
1736 struct HCIInfo
*qemu_next_hci(void)
1738 if (cur_hci
== nb_hcis
)
1741 return hci_table
[cur_hci
++];
1744 static struct HCIInfo
*hci_init(const char *str
)
1747 struct bt_scatternet_s
*vlan
= 0;
1749 if (!strcmp(str
, "null"))
1752 else if (!strncmp(str
, "host", 4) && (str
[4] == '\0' || str
[4] == ':'))
1754 return bt_host_hci(str
[4] ? str
+ 5 : "hci0");
1755 else if (!strncmp(str
, "hci", 3)) {
1758 if (!strncmp(str
+ 3, ",vlan=", 6)) {
1759 vlan
= qemu_find_bt_vlan(strtol(str
+ 9, &endp
, 0));
1764 vlan
= qemu_find_bt_vlan(0);
1766 return bt_new_hci(vlan
);
1769 fprintf(stderr
, "qemu: Unknown bluetooth HCI `%s'.\n", str
);
1774 static int bt_hci_parse(const char *str
)
1776 struct HCIInfo
*hci
;
1779 if (nb_hcis
>= MAX_NICS
) {
1780 fprintf(stderr
, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS
);
1784 hci
= hci_init(str
);
1793 bdaddr
.b
[5] = 0x56 + nb_hcis
;
1794 hci
->bdaddr_set(hci
, bdaddr
.b
);
1796 hci_table
[nb_hcis
++] = hci
;
1801 static void bt_vhci_add(int vlan_id
)
1803 struct bt_scatternet_s
*vlan
= qemu_find_bt_vlan(vlan_id
);
1806 fprintf(stderr
, "qemu: warning: adding a VHCI to "
1807 "an empty scatternet %i\n", vlan_id
);
1809 bt_vhci_init(bt_new_hci(vlan
));
1812 static struct bt_device_s
*bt_device_add(const char *opt
)
1814 struct bt_scatternet_s
*vlan
;
1816 char *endp
= strstr(opt
, ",vlan=");
1817 int len
= (endp
? endp
- opt
: strlen(opt
)) + 1;
1820 pstrcpy(devname
, MIN(sizeof(devname
), len
), opt
);
1823 vlan_id
= strtol(endp
+ 6, &endp
, 0);
1825 fprintf(stderr
, "qemu: unrecognised bluetooth vlan Id\n");
1830 vlan
= qemu_find_bt_vlan(vlan_id
);
1833 fprintf(stderr
, "qemu: warning: adding a slave device to "
1834 "an empty scatternet %i\n", vlan_id
);
1836 if (!strcmp(devname
, "keyboard"))
1837 return bt_keyboard_init(vlan
);
1839 fprintf(stderr
, "qemu: unsupported bluetooth device `%s'\n", devname
);
1843 static int bt_parse(const char *opt
)
1845 const char *endp
, *p
;
1848 if (strstart(opt
, "hci", &endp
)) {
1849 if (!*endp
|| *endp
== ',') {
1851 if (!strstart(endp
, ",vlan=", 0))
1854 return bt_hci_parse(opt
);
1856 } else if (strstart(opt
, "vhci", &endp
)) {
1857 if (!*endp
|| *endp
== ',') {
1859 if (strstart(endp
, ",vlan=", &p
)) {
1860 vlan
= strtol(p
, (char **) &endp
, 0);
1862 fprintf(stderr
, "qemu: bad scatternet '%s'\n", p
);
1866 fprintf(stderr
, "qemu: bad parameter '%s'\n", endp
+ 1);
1875 } else if (strstart(opt
, "device:", &endp
))
1876 return !bt_device_add(endp
);
1878 fprintf(stderr
, "qemu: bad bluetooth parameter '%s'\n", opt
);
1882 /***********************************************************/
1883 /* QEMU Block devices */
1885 #define HD_ALIAS "index=%d,media=disk"
1886 #define CDROM_ALIAS "index=2,media=cdrom"
1887 #define FD_ALIAS "index=%d,if=floppy"
1888 #define PFLASH_ALIAS "if=pflash"
1889 #define MTD_ALIAS "if=mtd"
1890 #define SD_ALIAS "index=0,if=sd"
1892 QemuOpts
*drive_add(const char *file
, const char *fmt
, ...)
1899 vsnprintf(optstr
, sizeof(optstr
), fmt
, ap
);
1902 opts
= qemu_opts_parse(&qemu_drive_opts
, optstr
, NULL
);
1904 fprintf(stderr
, "%s: huh? duplicate? (%s)\n",
1905 __FUNCTION__
, optstr
);
1909 qemu_opt_set(opts
, "file", file
);
1913 DriveInfo
*drive_get(BlockInterfaceType type
, int bus
, int unit
)
1917 /* seek interface, bus and unit */
1919 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
1920 if (dinfo
->type
== type
&&
1921 dinfo
->bus
== bus
&&
1922 dinfo
->unit
== unit
)
1929 DriveInfo
*drive_get_by_id(const char *id
)
1933 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
1934 if (strcmp(id
, dinfo
->id
))
1941 int drive_get_max_bus(BlockInterfaceType type
)
1947 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
1948 if(dinfo
->type
== type
&&
1949 dinfo
->bus
> max_bus
)
1950 max_bus
= dinfo
->bus
;
1955 const char *drive_get_serial(BlockDriverState
*bdrv
)
1959 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
1960 if (dinfo
->bdrv
== bdrv
)
1961 return dinfo
->serial
;
1967 BlockInterfaceErrorAction
drive_get_onerror(BlockDriverState
*bdrv
)
1971 QTAILQ_FOREACH(dinfo
, &drives
, next
) {
1972 if (dinfo
->bdrv
== bdrv
)
1973 return dinfo
->onerror
;
1976 return BLOCK_ERR_STOP_ENOSPC
;
1979 static void bdrv_format_print(void *opaque
, const char *name
)
1981 fprintf(stderr
, " %s", name
);
1984 void drive_uninit(DriveInfo
*dinfo
)
1986 qemu_opts_del(dinfo
->opts
);
1987 bdrv_delete(dinfo
->bdrv
);
1988 QTAILQ_REMOVE(&drives
, dinfo
, next
);
1992 DriveInfo
*drive_init(QemuOpts
*opts
, void *opaque
,
1996 const char *file
= NULL
;
1999 const char *mediastr
= "";
2000 BlockInterfaceType type
;
2001 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
2002 int bus_id
, unit_id
;
2003 int cyls
, heads
, secs
, translation
;
2004 BlockDriver
*drv
= NULL
;
2005 QEMUMachine
*machine
= opaque
;
2010 int bdrv_flags
, onerror
;
2011 const char *devaddr
;
2017 translation
= BIOS_ATA_TRANSLATION_AUTO
;
2020 if (machine
&& machine
->use_scsi
) {
2022 max_devs
= MAX_SCSI_DEVS
;
2023 pstrcpy(devname
, sizeof(devname
), "scsi");
2026 max_devs
= MAX_IDE_DEVS
;
2027 pstrcpy(devname
, sizeof(devname
), "ide");
2031 /* extract parameters */
2032 bus_id
= qemu_opt_get_number(opts
, "bus", 0);
2033 unit_id
= qemu_opt_get_number(opts
, "unit", -1);
2034 index
= qemu_opt_get_number(opts
, "index", -1);
2036 cyls
= qemu_opt_get_number(opts
, "cyls", 0);
2037 heads
= qemu_opt_get_number(opts
, "heads", 0);
2038 secs
= qemu_opt_get_number(opts
, "secs", 0);
2040 snapshot
= qemu_opt_get_bool(opts
, "snapshot", 0);
2042 file
= qemu_opt_get(opts
, "file");
2043 serial
= qemu_opt_get(opts
, "serial");
2045 if ((buf
= qemu_opt_get(opts
, "if")) != NULL
) {
2046 pstrcpy(devname
, sizeof(devname
), buf
);
2047 if (!strcmp(buf
, "ide")) {
2049 max_devs
= MAX_IDE_DEVS
;
2050 } else if (!strcmp(buf
, "scsi")) {
2052 max_devs
= MAX_SCSI_DEVS
;
2053 } else if (!strcmp(buf
, "floppy")) {
2056 } else if (!strcmp(buf
, "pflash")) {
2059 } else if (!strcmp(buf
, "mtd")) {
2062 } else if (!strcmp(buf
, "sd")) {
2065 } else if (!strcmp(buf
, "virtio")) {
2068 } else if (!strcmp(buf
, "xen")) {
2071 } else if (!strcmp(buf
, "none")) {
2075 fprintf(stderr
, "qemu: unsupported bus type '%s'\n", buf
);
2080 if (cyls
|| heads
|| secs
) {
2081 if (cyls
< 1 || (type
== IF_IDE
&& cyls
> 16383)) {
2082 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", buf
);
2085 if (heads
< 1 || (type
== IF_IDE
&& heads
> 16)) {
2086 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", buf
);
2089 if (secs
< 1 || (type
== IF_IDE
&& secs
> 63)) {
2090 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", buf
);
2095 if ((buf
= qemu_opt_get(opts
, "trans")) != NULL
) {
2098 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2102 if (!strcmp(buf
, "none"))
2103 translation
= BIOS_ATA_TRANSLATION_NONE
;
2104 else if (!strcmp(buf
, "lba"))
2105 translation
= BIOS_ATA_TRANSLATION_LBA
;
2106 else if (!strcmp(buf
, "auto"))
2107 translation
= BIOS_ATA_TRANSLATION_AUTO
;
2109 fprintf(stderr
, "qemu: '%s' invalid translation type\n", buf
);
2114 if ((buf
= qemu_opt_get(opts
, "media")) != NULL
) {
2115 if (!strcmp(buf
, "disk")) {
2117 } else if (!strcmp(buf
, "cdrom")) {
2118 if (cyls
|| secs
|| heads
) {
2120 "qemu: '%s' invalid physical CHS format\n", buf
);
2123 media
= MEDIA_CDROM
;
2125 fprintf(stderr
, "qemu: '%s' invalid media\n", buf
);
2130 if ((buf
= qemu_opt_get(opts
, "cache")) != NULL
) {
2131 if (!strcmp(buf
, "off") || !strcmp(buf
, "none"))
2133 else if (!strcmp(buf
, "writethrough"))
2135 else if (!strcmp(buf
, "writeback"))
2138 fprintf(stderr
, "qemu: invalid cache option\n");
2143 #ifdef CONFIG_LINUX_AIO
2144 if ((buf
= qemu_opt_get(opts
, "aio")) != NULL
) {
2145 if (!strcmp(buf
, "threads"))
2147 else if (!strcmp(buf
, "native"))
2150 fprintf(stderr
, "qemu: invalid aio option\n");
2156 if ((buf
= qemu_opt_get(opts
, "format")) != NULL
) {
2157 if (strcmp(buf
, "?") == 0) {
2158 fprintf(stderr
, "qemu: Supported formats:");
2159 bdrv_iterate_format(bdrv_format_print
, NULL
);
2160 fprintf(stderr
, "\n");
2163 drv
= bdrv_find_format(buf
);
2165 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
2170 onerror
= BLOCK_ERR_STOP_ENOSPC
;
2171 if ((buf
= qemu_opt_get(opts
, "werror")) != NULL
) {
2172 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
) {
2173 fprintf(stderr
, "werror is no supported by this format\n");
2176 if (!strcmp(buf
, "ignore"))
2177 onerror
= BLOCK_ERR_IGNORE
;
2178 else if (!strcmp(buf
, "enospc"))
2179 onerror
= BLOCK_ERR_STOP_ENOSPC
;
2180 else if (!strcmp(buf
, "stop"))
2181 onerror
= BLOCK_ERR_STOP_ANY
;
2182 else if (!strcmp(buf
, "report"))
2183 onerror
= BLOCK_ERR_REPORT
;
2185 fprintf(stderr
, "qemu: '%s' invalid write error action\n", buf
);
2190 if ((devaddr
= qemu_opt_get(opts
, "addr")) != NULL
) {
2191 if (type
!= IF_VIRTIO
) {
2192 fprintf(stderr
, "addr is not supported\n");
2197 /* compute bus and unit according index */
2200 if (bus_id
!= 0 || unit_id
!= -1) {
2202 "qemu: index cannot be used with bus and unit\n");
2210 unit_id
= index
% max_devs
;
2211 bus_id
= index
/ max_devs
;
2215 /* if user doesn't specify a unit_id,
2216 * try to find the first free
2219 if (unit_id
== -1) {
2221 while (drive_get(type
, bus_id
, unit_id
) != NULL
) {
2223 if (max_devs
&& unit_id
>= max_devs
) {
2224 unit_id
-= max_devs
;
2232 if (max_devs
&& unit_id
>= max_devs
) {
2233 fprintf(stderr
, "qemu: unit %d too big (max is %d)\n",
2234 unit_id
, max_devs
- 1);
2239 * ignore multiple definitions
2242 if (drive_get(type
, bus_id
, unit_id
) != NULL
) {
2249 dinfo
= qemu_mallocz(sizeof(*dinfo
));
2250 if ((buf
= qemu_opts_id(opts
)) != NULL
) {
2251 dinfo
->id
= qemu_strdup(buf
);
2253 /* no id supplied -> create one */
2254 dinfo
->id
= qemu_mallocz(32);
2255 if (type
== IF_IDE
|| type
== IF_SCSI
)
2256 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
2258 snprintf(dinfo
->id
, 32, "%s%i%s%i",
2259 devname
, bus_id
, mediastr
, unit_id
);
2261 snprintf(dinfo
->id
, 32, "%s%s%i",
2262 devname
, mediastr
, unit_id
);
2264 dinfo
->bdrv
= bdrv_new(dinfo
->id
);
2265 dinfo
->devaddr
= devaddr
;
2267 dinfo
->bus
= bus_id
;
2268 dinfo
->unit
= unit_id
;
2269 dinfo
->onerror
= onerror
;
2272 strncpy(dinfo
->serial
, serial
, sizeof(serial
));
2273 QTAILQ_INSERT_TAIL(&drives
, dinfo
, next
);
2283 bdrv_set_geometry_hint(dinfo
->bdrv
, cyls
, heads
, secs
);
2284 bdrv_set_translation_hint(dinfo
->bdrv
, translation
);
2288 bdrv_set_type_hint(dinfo
->bdrv
, BDRV_TYPE_CDROM
);
2293 /* FIXME: This isn't really a floppy, but it's a reasonable
2296 bdrv_set_type_hint(dinfo
->bdrv
, BDRV_TYPE_FLOPPY
);
2302 /* add virtio block device */
2303 opts
= qemu_opts_create(&qemu_device_opts
, NULL
, 0);
2304 qemu_opt_set(opts
, "driver", "virtio-blk-pci");
2305 qemu_opt_set(opts
, "drive", dinfo
->id
);
2307 qemu_opt_set(opts
, "addr", devaddr
);
2318 bdrv_flags
|= BDRV_O_SNAPSHOT
;
2319 cache
= 2; /* always use write-back with snapshot */
2321 if (cache
== 0) /* no caching */
2322 bdrv_flags
|= BDRV_O_NOCACHE
;
2323 else if (cache
== 2) /* write-back */
2324 bdrv_flags
|= BDRV_O_CACHE_WB
;
2327 bdrv_flags
|= BDRV_O_NATIVE_AIO
;
2329 bdrv_flags
&= ~BDRV_O_NATIVE_AIO
;
2332 if (bdrv_open2(dinfo
->bdrv
, file
, bdrv_flags
, drv
) < 0) {
2333 fprintf(stderr
, "qemu: could not open disk image %s: %s\n",
2334 file
, strerror(errno
));
2338 if (bdrv_key_required(dinfo
->bdrv
))
2344 static int drive_init_func(QemuOpts
*opts
, void *opaque
)
2346 QEMUMachine
*machine
= opaque
;
2347 int fatal_error
= 0;
2349 if (drive_init(opts
, machine
, &fatal_error
) == NULL
) {
2356 static int drive_enable_snapshot(QemuOpts
*opts
, void *opaque
)
2358 if (NULL
== qemu_opt_get(opts
, "snapshot")) {
2359 qemu_opt_set(opts
, "snapshot", "on");
2364 void qemu_register_boot_set(QEMUBootSetHandler
*func
, void *opaque
)
2366 boot_set_handler
= func
;
2367 boot_set_opaque
= opaque
;
2370 int qemu_boot_set(const char *boot_devices
)
2372 if (!boot_set_handler
) {
2375 return boot_set_handler(boot_set_opaque
, boot_devices
);
2378 static int parse_bootdevices(char *devices
)
2380 /* We just do some generic consistency checks */
2384 for (p
= devices
; *p
!= '\0'; p
++) {
2385 /* Allowed boot devices are:
2386 * a-b: floppy disk drives
2387 * c-f: IDE disk drives
2388 * g-m: machine implementation dependant drives
2389 * n-p: network devices
2390 * It's up to each machine implementation to check if the given boot
2391 * devices match the actual hardware implementation and firmware
2394 if (*p
< 'a' || *p
> 'p') {
2395 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
2398 if (bitmap
& (1 << (*p
- 'a'))) {
2399 fprintf(stderr
, "Boot device '%c' was given twice\n", *p
);
2402 bitmap
|= 1 << (*p
- 'a');
2407 static void restore_boot_devices(void *opaque
)
2409 char *standard_boot_devices
= opaque
;
2411 qemu_boot_set(standard_boot_devices
);
2413 qemu_unregister_reset(restore_boot_devices
, standard_boot_devices
);
2414 qemu_free(standard_boot_devices
);
2417 static void numa_add(const char *optarg
)
2421 unsigned long long value
, endvalue
;
2424 optarg
= get_opt_name(option
, 128, optarg
, ',') + 1;
2425 if (!strcmp(option
, "node")) {
2426 if (get_param_value(option
, 128, "nodeid", optarg
) == 0) {
2427 nodenr
= nb_numa_nodes
;
2429 nodenr
= strtoull(option
, NULL
, 10);
2432 if (get_param_value(option
, 128, "mem", optarg
) == 0) {
2433 node_mem
[nodenr
] = 0;
2435 value
= strtoull(option
, &endptr
, 0);
2437 case 0: case 'M': case 'm':
2444 node_mem
[nodenr
] = value
;
2446 if (get_param_value(option
, 128, "cpus", optarg
) == 0) {
2447 node_cpumask
[nodenr
] = 0;
2449 value
= strtoull(option
, &endptr
, 10);
2452 fprintf(stderr
, "only 64 CPUs in NUMA mode supported.\n");
2454 if (*endptr
== '-') {
2455 endvalue
= strtoull(endptr
+1, &endptr
, 10);
2456 if (endvalue
>= 63) {
2459 "only 63 CPUs in NUMA mode supported.\n");
2461 value
= (1 << (endvalue
+ 1)) - (1 << value
);
2466 node_cpumask
[nodenr
] = value
;
2473 static void smp_parse(const char *optarg
)
2475 int smp
, sockets
= 0, threads
= 0, cores
= 0;
2479 smp
= strtoul(optarg
, &endptr
, 10);
2480 if (endptr
!= optarg
) {
2481 if (*endptr
== ',') {
2485 if (get_param_value(option
, 128, "sockets", endptr
) != 0)
2486 sockets
= strtoull(option
, NULL
, 10);
2487 if (get_param_value(option
, 128, "cores", endptr
) != 0)
2488 cores
= strtoull(option
, NULL
, 10);
2489 if (get_param_value(option
, 128, "threads", endptr
) != 0)
2490 threads
= strtoull(option
, NULL
, 10);
2491 if (get_param_value(option
, 128, "maxcpus", endptr
) != 0)
2492 max_cpus
= strtoull(option
, NULL
, 10);
2494 /* compute missing values, prefer sockets over cores over threads */
2495 if (smp
== 0 || sockets
== 0) {
2496 sockets
= sockets
> 0 ? sockets
: 1;
2497 cores
= cores
> 0 ? cores
: 1;
2498 threads
= threads
> 0 ? threads
: 1;
2500 smp
= cores
* threads
* sockets
;
2502 sockets
= smp
/ (cores
* threads
);
2506 threads
= threads
> 0 ? threads
: 1;
2507 cores
= smp
/ (sockets
* threads
);
2510 sockets
= smp
/ (cores
* threads
);
2512 threads
= smp
/ (cores
* sockets
);
2517 smp_cores
= cores
> 0 ? cores
: 1;
2518 smp_threads
= threads
> 0 ? threads
: 1;
2520 max_cpus
= smp_cpus
;
2523 /***********************************************************/
2526 static void usb_msd_password_cb(void *opaque
, int err
)
2528 USBDevice
*dev
= opaque
;
2531 usb_device_attach(dev
);
2533 dev
->info
->handle_destroy(dev
);
2542 .qdev
= "QEMU USB Mouse",
2545 .qdev
= "QEMU USB Tablet",
2548 .qdev
= "QEMU USB Keyboard",
2550 .name
= "wacom-tablet",
2551 .qdev
= "QEMU PenPartner Tablet",
2555 static int usb_device_add(const char *devname
, int is_hotplug
)
2558 USBBus
*bus
= usb_bus_find(-1 /* any */);
2559 USBDevice
*dev
= NULL
;
2565 /* simple devices which don't need extra care */
2566 for (i
= 0; i
< ARRAY_SIZE(usbdevs
); i
++) {
2567 if (strcmp(devname
, usbdevs
[i
].name
) != 0)
2569 dev
= usb_create_simple(bus
, usbdevs
[i
].qdev
);
2573 /* the other ones */
2574 if (strstart(devname
, "host:", &p
)) {
2575 dev
= usb_host_device_open(p
);
2576 } else if (strstart(devname
, "disk:", &p
)) {
2577 BlockDriverState
*bs
;
2579 dev
= usb_msd_init(p
);
2582 bs
= usb_msd_get_bdrv(dev
);
2583 if (bdrv_key_required(bs
)) {
2586 monitor_read_bdrv_key_start(cur_mon
, bs
, usb_msd_password_cb
,
2591 } else if (strstart(devname
, "serial:", &p
)) {
2592 dev
= usb_serial_init(p
);
2593 #ifdef CONFIG_BRLAPI
2594 } else if (!strcmp(devname
, "braille")) {
2595 dev
= usb_baum_init();
2597 } else if (strstart(devname
, "net:", &p
)) {
2601 opts
= qemu_opts_parse(&qemu_net_opts
, p
, NULL
);
2606 qemu_opt_set(opts
, "type", "nic");
2607 qemu_opt_set(opts
, "model", "usb");
2609 idx
= net_client_init(NULL
, opts
, 0);
2614 dev
= usb_net_init(&nd_table
[idx
]);
2615 } else if (!strcmp(devname
, "bt") || strstart(devname
, "bt:", &p
)) {
2616 dev
= usb_bt_init(devname
[2] ? hci_init(p
) :
2617 bt_new_hci(qemu_find_bt_vlan(0)));
2628 static int usb_device_del(const char *devname
)
2633 if (strstart(devname
, "host:", &p
))
2634 return usb_host_device_close(p
);
2639 p
= strchr(devname
, '.');
2642 bus_num
= strtoul(devname
, NULL
, 0);
2643 addr
= strtoul(p
+ 1, NULL
, 0);
2645 return usb_device_delete_addr(bus_num
, addr
);
2648 static int usb_parse(const char *cmdline
)
2650 return usb_device_add(cmdline
, 0);
2653 void do_usb_add(Monitor
*mon
, const QDict
*qdict
)
2655 usb_device_add(qdict_get_str(qdict
, "devname"), 1);
2658 void do_usb_del(Monitor
*mon
, const QDict
*qdict
)
2660 usb_device_del(qdict_get_str(qdict
, "devname"));
2663 /***********************************************************/
2664 /* PCMCIA/Cardbus */
2666 static struct pcmcia_socket_entry_s
{
2667 PCMCIASocket
*socket
;
2668 struct pcmcia_socket_entry_s
*next
;
2669 } *pcmcia_sockets
= 0;
2671 void pcmcia_socket_register(PCMCIASocket
*socket
)
2673 struct pcmcia_socket_entry_s
*entry
;
2675 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
2676 entry
->socket
= socket
;
2677 entry
->next
= pcmcia_sockets
;
2678 pcmcia_sockets
= entry
;
2681 void pcmcia_socket_unregister(PCMCIASocket
*socket
)
2683 struct pcmcia_socket_entry_s
*entry
, **ptr
;
2685 ptr
= &pcmcia_sockets
;
2686 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
2687 if (entry
->socket
== socket
) {
2693 void pcmcia_info(Monitor
*mon
)
2695 struct pcmcia_socket_entry_s
*iter
;
2697 if (!pcmcia_sockets
)
2698 monitor_printf(mon
, "No PCMCIA sockets\n");
2700 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
2701 monitor_printf(mon
, "%s: %s\n", iter
->socket
->slot_string
,
2702 iter
->socket
->attached
? iter
->socket
->card_string
:
2706 /***********************************************************/
2707 /* register display */
2709 struct DisplayAllocator default_allocator
= {
2710 defaultallocator_create_displaysurface
,
2711 defaultallocator_resize_displaysurface
,
2712 defaultallocator_free_displaysurface
2715 void register_displaystate(DisplayState
*ds
)
2725 DisplayState
*get_displaystate(void)
2727 return display_state
;
2730 DisplayAllocator
*register_displayallocator(DisplayState
*ds
, DisplayAllocator
*da
)
2732 if(ds
->allocator
== &default_allocator
) ds
->allocator
= da
;
2733 return ds
->allocator
;
2738 static void dumb_display_init(void)
2740 DisplayState
*ds
= qemu_mallocz(sizeof(DisplayState
));
2741 ds
->allocator
= &default_allocator
;
2742 ds
->surface
= qemu_create_displaysurface(ds
, 640, 480);
2743 register_displaystate(ds
);
2746 /***********************************************************/
2749 typedef struct IOHandlerRecord
{
2751 IOCanRWHandler
*fd_read_poll
;
2753 IOHandler
*fd_write
;
2756 /* temporary data */
2758 struct IOHandlerRecord
*next
;
2761 static IOHandlerRecord
*first_io_handler
;
2763 /* XXX: fd_read_poll should be suppressed, but an API change is
2764 necessary in the character devices to suppress fd_can_read(). */
2765 int qemu_set_fd_handler2(int fd
,
2766 IOCanRWHandler
*fd_read_poll
,
2768 IOHandler
*fd_write
,
2771 IOHandlerRecord
**pioh
, *ioh
;
2773 if (!fd_read
&& !fd_write
) {
2774 pioh
= &first_io_handler
;
2779 if (ioh
->fd
== fd
) {
2786 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
2790 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
2791 ioh
->next
= first_io_handler
;
2792 first_io_handler
= ioh
;
2795 ioh
->fd_read_poll
= fd_read_poll
;
2796 ioh
->fd_read
= fd_read
;
2797 ioh
->fd_write
= fd_write
;
2798 ioh
->opaque
= opaque
;
2804 int qemu_set_fd_handler(int fd
,
2806 IOHandler
*fd_write
,
2809 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
2813 /***********************************************************/
2814 /* Polling handling */
2816 typedef struct PollingEntry
{
2819 struct PollingEntry
*next
;
2822 static PollingEntry
*first_polling_entry
;
2824 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
2826 PollingEntry
**ppe
, *pe
;
2827 pe
= qemu_mallocz(sizeof(PollingEntry
));
2829 pe
->opaque
= opaque
;
2830 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
2835 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
2837 PollingEntry
**ppe
, *pe
;
2838 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
2840 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
2848 /***********************************************************/
2849 /* Wait objects support */
2850 typedef struct WaitObjects
{
2852 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
2853 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
2854 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
2857 static WaitObjects wait_objects
= {0};
2859 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
2861 WaitObjects
*w
= &wait_objects
;
2863 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
2865 w
->events
[w
->num
] = handle
;
2866 w
->func
[w
->num
] = func
;
2867 w
->opaque
[w
->num
] = opaque
;
2872 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
2875 WaitObjects
*w
= &wait_objects
;
2878 for (i
= 0; i
< w
->num
; i
++) {
2879 if (w
->events
[i
] == handle
)
2882 w
->events
[i
] = w
->events
[i
+ 1];
2883 w
->func
[i
] = w
->func
[i
+ 1];
2884 w
->opaque
[i
] = w
->opaque
[i
+ 1];
2892 /***********************************************************/
2893 /* ram save/restore */
2895 #define RAM_SAVE_FLAG_FULL 0x01 /* Obsolete, not used anymore */
2896 #define RAM_SAVE_FLAG_COMPRESS 0x02
2897 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
2898 #define RAM_SAVE_FLAG_PAGE 0x08
2899 #define RAM_SAVE_FLAG_EOS 0x10
2901 static int is_dup_page(uint8_t *page
, uint8_t ch
)
2903 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
2904 uint32_t *array
= (uint32_t *)page
;
2907 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
2908 if (array
[i
] != val
)
2915 static int ram_save_block(QEMUFile
*f
)
2917 static ram_addr_t current_addr
= 0;
2918 ram_addr_t saved_addr
= current_addr
;
2919 ram_addr_t addr
= 0;
2922 while (addr
< last_ram_offset
) {
2923 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
2926 cpu_physical_memory_reset_dirty(current_addr
,
2927 current_addr
+ TARGET_PAGE_SIZE
,
2928 MIGRATION_DIRTY_FLAG
);
2930 p
= qemu_get_ram_ptr(current_addr
);
2932 if (is_dup_page(p
, *p
)) {
2933 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_COMPRESS
);
2934 qemu_put_byte(f
, *p
);
2936 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_PAGE
);
2937 qemu_put_buffer(f
, p
, TARGET_PAGE_SIZE
);
2943 addr
+= TARGET_PAGE_SIZE
;
2944 current_addr
= (saved_addr
+ addr
) % last_ram_offset
;
2950 static uint64_t bytes_transferred
= 0;
2952 static ram_addr_t
ram_save_remaining(void)
2955 ram_addr_t count
= 0;
2957 for (addr
= 0; addr
< last_ram_offset
; addr
+= TARGET_PAGE_SIZE
) {
2958 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
2965 uint64_t ram_bytes_remaining(void)
2967 return ram_save_remaining() * TARGET_PAGE_SIZE
;
2970 uint64_t ram_bytes_transferred(void)
2972 return bytes_transferred
;
2975 uint64_t ram_bytes_total(void)
2977 return last_ram_offset
;
2980 static int ram_save_live(QEMUFile
*f
, int stage
, void *opaque
)
2983 uint64_t bytes_transferred_last
;
2985 uint64_t expected_time
= 0;
2987 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX
) != 0) {
2988 qemu_file_set_error(f
);
2993 /* Make sure all dirty bits are set */
2994 for (addr
= 0; addr
< last_ram_offset
; addr
+= TARGET_PAGE_SIZE
) {
2995 if (!cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
2996 cpu_physical_memory_set_dirty(addr
);
2999 /* Enable dirty memory tracking */
3000 cpu_physical_memory_set_dirty_tracking(1);
3002 qemu_put_be64(f
, last_ram_offset
| RAM_SAVE_FLAG_MEM_SIZE
);
3005 bytes_transferred_last
= bytes_transferred
;
3006 bwidth
= get_clock();
3008 while (!qemu_file_rate_limit(f
)) {
3011 ret
= ram_save_block(f
);
3012 bytes_transferred
+= ret
* TARGET_PAGE_SIZE
;
3013 if (ret
== 0) /* no more blocks */
3017 bwidth
= get_clock() - bwidth
;
3018 bwidth
= (bytes_transferred
- bytes_transferred_last
) / bwidth
;
3020 /* if we haven't transferred anything this round, force expected_time to a
3021 * a very high value, but without crashing */
3025 /* try transferring iterative blocks of memory */
3029 /* flush all remaining blocks regardless of rate limiting */
3030 while (ram_save_block(f
) != 0) {
3031 bytes_transferred
+= TARGET_PAGE_SIZE
;
3033 cpu_physical_memory_set_dirty_tracking(0);
3036 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
3038 expected_time
= ram_save_remaining() * TARGET_PAGE_SIZE
/ bwidth
;
3040 return (stage
== 2) && (expected_time
<= migrate_max_downtime());
3043 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
3048 if (version_id
!= 3)
3052 addr
= qemu_get_be64(f
);
3054 flags
= addr
& ~TARGET_PAGE_MASK
;
3055 addr
&= TARGET_PAGE_MASK
;
3057 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
3058 if (addr
!= last_ram_offset
)
3062 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
3063 uint8_t ch
= qemu_get_byte(f
);
3064 memset(qemu_get_ram_ptr(addr
), ch
, TARGET_PAGE_SIZE
);
3067 (!kvm_enabled() || kvm_has_sync_mmu())) {
3068 madvise(qemu_get_ram_ptr(addr
), TARGET_PAGE_SIZE
, MADV_DONTNEED
);
3071 } else if (flags
& RAM_SAVE_FLAG_PAGE
)
3072 qemu_get_buffer(f
, qemu_get_ram_ptr(addr
), TARGET_PAGE_SIZE
);
3073 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
3078 void qemu_service_io(void)
3080 qemu_notify_event();
3083 /***********************************************************/
3084 /* machine registration */
3086 static QEMUMachine
*first_machine
= NULL
;
3087 QEMUMachine
*current_machine
= NULL
;
3089 int qemu_register_machine(QEMUMachine
*m
)
3092 pm
= &first_machine
;
3100 static QEMUMachine
*find_machine(const char *name
)
3104 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
3105 if (!strcmp(m
->name
, name
))
3107 if (m
->alias
&& !strcmp(m
->alias
, name
))
3113 static QEMUMachine
*find_default_machine(void)
3117 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
3118 if (m
->is_default
) {
3125 /***********************************************************/
3126 /* main execution loop */
3128 static void gui_update(void *opaque
)
3130 uint64_t interval
= GUI_REFRESH_INTERVAL
;
3131 DisplayState
*ds
= opaque
;
3132 DisplayChangeListener
*dcl
= ds
->listeners
;
3136 while (dcl
!= NULL
) {
3137 if (dcl
->gui_timer_interval
&&
3138 dcl
->gui_timer_interval
< interval
)
3139 interval
= dcl
->gui_timer_interval
;
3142 qemu_mod_timer(ds
->gui_timer
, interval
+ qemu_get_clock(rt_clock
));
3145 static void nographic_update(void *opaque
)
3147 uint64_t interval
= GUI_REFRESH_INTERVAL
;
3149 qemu_mod_timer(nographic_timer
, interval
+ qemu_get_clock(rt_clock
));
3152 struct vm_change_state_entry
{
3153 VMChangeStateHandler
*cb
;
3155 QLIST_ENTRY (vm_change_state_entry
) entries
;
3158 static QLIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
3160 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
3163 VMChangeStateEntry
*e
;
3165 e
= qemu_mallocz(sizeof (*e
));
3169 QLIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
3173 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
3175 QLIST_REMOVE (e
, entries
);
3179 static void vm_state_notify(int running
, int reason
)
3181 VMChangeStateEntry
*e
;
3183 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
3184 e
->cb(e
->opaque
, running
, reason
);
3188 static void resume_all_vcpus(void);
3189 static void pause_all_vcpus(void);
3196 vm_state_notify(1, 0);
3197 qemu_rearm_alarm_timer(alarm_timer
);
3202 /* reset/shutdown handler */
3204 typedef struct QEMUResetEntry
{
3205 QTAILQ_ENTRY(QEMUResetEntry
) entry
;
3206 QEMUResetHandler
*func
;
3210 static QTAILQ_HEAD(reset_handlers
, QEMUResetEntry
) reset_handlers
=
3211 QTAILQ_HEAD_INITIALIZER(reset_handlers
);
3212 static int reset_requested
;
3213 static int shutdown_requested
;
3214 static int powerdown_requested
;
3215 static int debug_requested
;
3216 static int vmstop_requested
;
3218 int qemu_shutdown_requested(void)
3220 int r
= shutdown_requested
;
3221 shutdown_requested
= 0;
3225 int qemu_reset_requested(void)
3227 int r
= reset_requested
;
3228 reset_requested
= 0;
3232 int qemu_powerdown_requested(void)
3234 int r
= powerdown_requested
;
3235 powerdown_requested
= 0;
3239 static int qemu_debug_requested(void)
3241 int r
= debug_requested
;
3242 debug_requested
= 0;
3246 static int qemu_vmstop_requested(void)
3248 int r
= vmstop_requested
;
3249 vmstop_requested
= 0;
3253 static void do_vm_stop(int reason
)
3256 cpu_disable_ticks();
3259 vm_state_notify(0, reason
);
3263 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
3265 QEMUResetEntry
*re
= qemu_mallocz(sizeof(QEMUResetEntry
));
3268 re
->opaque
= opaque
;
3269 QTAILQ_INSERT_TAIL(&reset_handlers
, re
, entry
);
3272 void qemu_unregister_reset(QEMUResetHandler
*func
, void *opaque
)
3276 QTAILQ_FOREACH(re
, &reset_handlers
, entry
) {
3277 if (re
->func
== func
&& re
->opaque
== opaque
) {
3278 QTAILQ_REMOVE(&reset_handlers
, re
, entry
);
3285 void qemu_system_reset(void)
3287 QEMUResetEntry
*re
, *nre
;
3289 /* reset all devices */
3290 QTAILQ_FOREACH_SAFE(re
, &reset_handlers
, entry
, nre
) {
3291 re
->func(re
->opaque
);
3295 void qemu_system_reset_request(void)
3298 shutdown_requested
= 1;
3300 reset_requested
= 1;
3302 qemu_notify_event();
3305 void qemu_system_shutdown_request(void)
3307 shutdown_requested
= 1;
3308 qemu_notify_event();
3311 void qemu_system_powerdown_request(void)
3313 powerdown_requested
= 1;
3314 qemu_notify_event();
3317 #ifdef CONFIG_IOTHREAD
3318 static void qemu_system_vmstop_request(int reason
)
3320 vmstop_requested
= reason
;
3321 qemu_notify_event();
3326 static int io_thread_fd
= -1;
3328 static void qemu_event_increment(void)
3330 static const char byte
= 0;
3332 if (io_thread_fd
== -1)
3335 write(io_thread_fd
, &byte
, sizeof(byte
));
3338 static void qemu_event_read(void *opaque
)
3340 int fd
= (unsigned long)opaque
;
3343 /* Drain the notify pipe */
3346 len
= read(fd
, buffer
, sizeof(buffer
));
3347 } while ((len
== -1 && errno
== EINTR
) || len
> 0);
3350 static int qemu_event_init(void)
3359 err
= fcntl_setfl(fds
[0], O_NONBLOCK
);
3363 err
= fcntl_setfl(fds
[1], O_NONBLOCK
);
3367 qemu_set_fd_handler2(fds
[0], NULL
, qemu_event_read
, NULL
,
3368 (void *)(unsigned long)fds
[0]);
3370 io_thread_fd
= fds
[1];
3379 HANDLE qemu_event_handle
;
3381 static void dummy_event_handler(void *opaque
)
3385 static int qemu_event_init(void)
3387 qemu_event_handle
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3388 if (!qemu_event_handle
) {
3389 fprintf(stderr
, "Failed CreateEvent: %ld\n", GetLastError());
3392 qemu_add_wait_object(qemu_event_handle
, dummy_event_handler
, NULL
);
3396 static void qemu_event_increment(void)
3398 if (!SetEvent(qemu_event_handle
)) {
3399 fprintf(stderr
, "qemu_event_increment: SetEvent failed: %ld\n",
3406 static int cpu_can_run(CPUState
*env
)
3415 #ifndef CONFIG_IOTHREAD
3416 static int qemu_init_main_loop(void)
3418 return qemu_event_init();
3421 void qemu_init_vcpu(void *_env
)
3423 CPUState
*env
= _env
;
3427 env
->nr_cores
= smp_cores
;
3428 env
->nr_threads
= smp_threads
;
3432 int qemu_cpu_self(void *env
)
3437 static void resume_all_vcpus(void)
3441 static void pause_all_vcpus(void)
3445 void qemu_cpu_kick(void *env
)
3450 void qemu_notify_event(void)
3452 CPUState
*env
= cpu_single_env
;
3459 void qemu_mutex_lock_iothread(void) {}
3460 void qemu_mutex_unlock_iothread(void) {}
3462 void vm_stop(int reason
)
3467 #else /* CONFIG_IOTHREAD */
3469 #include "qemu-thread.h"
3471 QemuMutex qemu_global_mutex
;
3472 static QemuMutex qemu_fair_mutex
;
3474 static QemuThread io_thread
;
3476 static QemuThread
*tcg_cpu_thread
;
3477 static QemuCond
*tcg_halt_cond
;
3479 static int qemu_system_ready
;
3481 static QemuCond qemu_cpu_cond
;
3483 static QemuCond qemu_system_cond
;
3484 static QemuCond qemu_pause_cond
;
3486 static void block_io_signals(void);
3487 static void unblock_io_signals(void);
3488 static int tcg_has_work(void);
3490 static int qemu_init_main_loop(void)
3494 ret
= qemu_event_init();
3498 qemu_cond_init(&qemu_pause_cond
);
3499 qemu_mutex_init(&qemu_fair_mutex
);
3500 qemu_mutex_init(&qemu_global_mutex
);
3501 qemu_mutex_lock(&qemu_global_mutex
);
3503 unblock_io_signals();
3504 qemu_thread_self(&io_thread
);
3509 static void qemu_wait_io_event(CPUState
*env
)
3511 while (!tcg_has_work())
3512 qemu_cond_timedwait(env
->halt_cond
, &qemu_global_mutex
, 1000);
3514 qemu_mutex_unlock(&qemu_global_mutex
);
3517 * Users of qemu_global_mutex can be starved, having no chance
3518 * to acquire it since this path will get to it first.
3519 * So use another lock to provide fairness.
3521 qemu_mutex_lock(&qemu_fair_mutex
);
3522 qemu_mutex_unlock(&qemu_fair_mutex
);
3524 qemu_mutex_lock(&qemu_global_mutex
);
3528 qemu_cond_signal(&qemu_pause_cond
);
3532 static int qemu_cpu_exec(CPUState
*env
);
3534 static void *kvm_cpu_thread_fn(void *arg
)
3536 CPUState
*env
= arg
;
3539 qemu_thread_self(env
->thread
);
3543 /* signal CPU creation */
3544 qemu_mutex_lock(&qemu_global_mutex
);
3546 qemu_cond_signal(&qemu_cpu_cond
);
3548 /* and wait for machine initialization */
3549 while (!qemu_system_ready
)
3550 qemu_cond_timedwait(&qemu_system_cond
, &qemu_global_mutex
, 100);
3553 if (cpu_can_run(env
))
3555 qemu_wait_io_event(env
);
3561 static void tcg_cpu_exec(void);
3563 static void *tcg_cpu_thread_fn(void *arg
)
3565 CPUState
*env
= arg
;
3568 qemu_thread_self(env
->thread
);
3570 /* signal CPU creation */
3571 qemu_mutex_lock(&qemu_global_mutex
);
3572 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
3574 qemu_cond_signal(&qemu_cpu_cond
);
3576 /* and wait for machine initialization */
3577 while (!qemu_system_ready
)
3578 qemu_cond_timedwait(&qemu_system_cond
, &qemu_global_mutex
, 100);
3582 qemu_wait_io_event(cur_cpu
);
3588 void qemu_cpu_kick(void *_env
)
3590 CPUState
*env
= _env
;
3591 qemu_cond_broadcast(env
->halt_cond
);
3593 qemu_thread_signal(env
->thread
, SIGUSR1
);
3596 int qemu_cpu_self(void *_env
)
3598 CPUState
*env
= _env
;
3601 qemu_thread_self(&this);
3603 return qemu_thread_equal(&this, env
->thread
);
3606 static void cpu_signal(int sig
)
3609 cpu_exit(cpu_single_env
);
3612 static void block_io_signals(void)
3615 struct sigaction sigact
;
3618 sigaddset(&set
, SIGUSR2
);
3619 sigaddset(&set
, SIGIO
);
3620 sigaddset(&set
, SIGALRM
);
3621 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
3624 sigaddset(&set
, SIGUSR1
);
3625 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
3627 memset(&sigact
, 0, sizeof(sigact
));
3628 sigact
.sa_handler
= cpu_signal
;
3629 sigaction(SIGUSR1
, &sigact
, NULL
);
3632 static void unblock_io_signals(void)
3637 sigaddset(&set
, SIGUSR2
);
3638 sigaddset(&set
, SIGIO
);
3639 sigaddset(&set
, SIGALRM
);
3640 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
3643 sigaddset(&set
, SIGUSR1
);
3644 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
3647 static void qemu_signal_lock(unsigned int msecs
)
3649 qemu_mutex_lock(&qemu_fair_mutex
);
3651 while (qemu_mutex_trylock(&qemu_global_mutex
)) {
3652 qemu_thread_signal(tcg_cpu_thread
, SIGUSR1
);
3653 if (!qemu_mutex_timedlock(&qemu_global_mutex
, msecs
))
3656 qemu_mutex_unlock(&qemu_fair_mutex
);
3659 void qemu_mutex_lock_iothread(void)
3661 if (kvm_enabled()) {
3662 qemu_mutex_lock(&qemu_fair_mutex
);
3663 qemu_mutex_lock(&qemu_global_mutex
);
3664 qemu_mutex_unlock(&qemu_fair_mutex
);
3666 qemu_signal_lock(100);
3669 void qemu_mutex_unlock_iothread(void)
3671 qemu_mutex_unlock(&qemu_global_mutex
);
3674 static int all_vcpus_paused(void)
3676 CPUState
*penv
= first_cpu
;
3681 penv
= (CPUState
*)penv
->next_cpu
;
3687 static void pause_all_vcpus(void)
3689 CPUState
*penv
= first_cpu
;
3693 qemu_thread_signal(penv
->thread
, SIGUSR1
);
3694 qemu_cpu_kick(penv
);
3695 penv
= (CPUState
*)penv
->next_cpu
;
3698 while (!all_vcpus_paused()) {
3699 qemu_cond_timedwait(&qemu_pause_cond
, &qemu_global_mutex
, 100);
3702 qemu_thread_signal(penv
->thread
, SIGUSR1
);
3703 penv
= (CPUState
*)penv
->next_cpu
;
3708 static void resume_all_vcpus(void)
3710 CPUState
*penv
= first_cpu
;
3715 qemu_thread_signal(penv
->thread
, SIGUSR1
);
3716 qemu_cpu_kick(penv
);
3717 penv
= (CPUState
*)penv
->next_cpu
;
3721 static void tcg_init_vcpu(void *_env
)
3723 CPUState
*env
= _env
;
3724 /* share a single thread for all cpus with TCG */
3725 if (!tcg_cpu_thread
) {
3726 env
->thread
= qemu_mallocz(sizeof(QemuThread
));
3727 env
->halt_cond
= qemu_mallocz(sizeof(QemuCond
));
3728 qemu_cond_init(env
->halt_cond
);
3729 qemu_thread_create(env
->thread
, tcg_cpu_thread_fn
, env
);
3730 while (env
->created
== 0)
3731 qemu_cond_timedwait(&qemu_cpu_cond
, &qemu_global_mutex
, 100);
3732 tcg_cpu_thread
= env
->thread
;
3733 tcg_halt_cond
= env
->halt_cond
;
3735 env
->thread
= tcg_cpu_thread
;
3736 env
->halt_cond
= tcg_halt_cond
;
3740 static void kvm_start_vcpu(CPUState
*env
)
3742 env
->thread
= qemu_mallocz(sizeof(QemuThread
));
3743 env
->halt_cond
= qemu_mallocz(sizeof(QemuCond
));
3744 qemu_cond_init(env
->halt_cond
);
3745 qemu_thread_create(env
->thread
, kvm_cpu_thread_fn
, env
);
3746 while (env
->created
== 0)
3747 qemu_cond_timedwait(&qemu_cpu_cond
, &qemu_global_mutex
, 100);
3750 void qemu_init_vcpu(void *_env
)
3752 CPUState
*env
= _env
;
3755 kvm_start_vcpu(env
);
3758 env
->nr_cores
= smp_cores
;
3759 env
->nr_threads
= smp_threads
;
3762 void qemu_notify_event(void)
3764 qemu_event_increment();
3767 void vm_stop(int reason
)
3770 qemu_thread_self(&me
);
3772 if (!qemu_thread_equal(&me
, &io_thread
)) {
3773 qemu_system_vmstop_request(reason
);
3775 * FIXME: should not return to device code in case
3776 * vm_stop() has been requested.
3778 if (cpu_single_env
) {
3779 cpu_exit(cpu_single_env
);
3780 cpu_single_env
->stop
= 1;
3791 static void host_main_loop_wait(int *timeout
)
3797 /* XXX: need to suppress polling by better using win32 events */
3799 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
3800 ret
|= pe
->func(pe
->opaque
);
3804 WaitObjects
*w
= &wait_objects
;
3806 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, *timeout
);
3807 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
3808 if (w
->func
[ret
- WAIT_OBJECT_0
])
3809 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
3811 /* Check for additional signaled events */
3812 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
3814 /* Check if event is signaled */
3815 ret2
= WaitForSingleObject(w
->events
[i
], 0);
3816 if(ret2
== WAIT_OBJECT_0
) {
3818 w
->func
[i
](w
->opaque
[i
]);
3819 } else if (ret2
== WAIT_TIMEOUT
) {
3821 err
= GetLastError();
3822 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
3825 } else if (ret
== WAIT_TIMEOUT
) {
3827 err
= GetLastError();
3828 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
3835 static void host_main_loop_wait(int *timeout
)
3840 void main_loop_wait(int timeout
)
3842 IOHandlerRecord
*ioh
;
3843 fd_set rfds
, wfds
, xfds
;
3847 qemu_bh_update_timeout(&timeout
);
3849 host_main_loop_wait(&timeout
);
3851 /* poll any events */
3852 /* XXX: separate device handlers from system ones */
3857 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
3861 (!ioh
->fd_read_poll
||
3862 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
3863 FD_SET(ioh
->fd
, &rfds
);
3867 if (ioh
->fd_write
) {
3868 FD_SET(ioh
->fd
, &wfds
);
3874 tv
.tv_sec
= timeout
/ 1000;
3875 tv
.tv_usec
= (timeout
% 1000) * 1000;
3877 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
3879 qemu_mutex_unlock_iothread();
3880 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
3881 qemu_mutex_lock_iothread();
3883 IOHandlerRecord
**pioh
;
3885 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
3886 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
3887 ioh
->fd_read(ioh
->opaque
);
3889 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
3890 ioh
->fd_write(ioh
->opaque
);
3894 /* remove deleted IO handlers */
3895 pioh
= &first_io_handler
;
3906 slirp_select_poll(&rfds
, &wfds
, &xfds
, (ret
< 0));
3908 /* rearm timer, if not periodic */
3909 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
3910 alarm_timer
->flags
&= ~ALARM_FLAG_EXPIRED
;
3911 qemu_rearm_alarm_timer(alarm_timer
);
3914 /* vm time timers */
3916 if (!cur_cpu
|| likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
3917 qemu_run_timers(&active_timers
[QEMU_CLOCK_VIRTUAL
],
3918 qemu_get_clock(vm_clock
));
3921 /* real time timers */
3922 qemu_run_timers(&active_timers
[QEMU_CLOCK_REALTIME
],
3923 qemu_get_clock(rt_clock
));
3925 qemu_run_timers(&active_timers
[QEMU_CLOCK_HOST
],
3926 qemu_get_clock(host_clock
));
3928 /* Check bottom-halves last in case any of the earlier events triggered
3934 static int qemu_cpu_exec(CPUState
*env
)
3937 #ifdef CONFIG_PROFILER
3941 #ifdef CONFIG_PROFILER
3942 ti
= profile_getclock();
3947 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
3948 env
->icount_decr
.u16
.low
= 0;
3949 env
->icount_extra
= 0;
3950 count
= qemu_next_deadline();
3951 count
= (count
+ (1 << icount_time_shift
) - 1)
3952 >> icount_time_shift
;
3953 qemu_icount
+= count
;
3954 decr
= (count
> 0xffff) ? 0xffff : count
;
3956 env
->icount_decr
.u16
.low
= decr
;
3957 env
->icount_extra
= count
;
3959 ret
= cpu_exec(env
);
3960 #ifdef CONFIG_PROFILER
3961 qemu_time
+= profile_getclock() - ti
;
3964 /* Fold pending instructions back into the
3965 instruction counter, and clear the interrupt flag. */
3966 qemu_icount
-= (env
->icount_decr
.u16
.low
3967 + env
->icount_extra
);
3968 env
->icount_decr
.u32
= 0;
3969 env
->icount_extra
= 0;
3974 static void tcg_cpu_exec(void)
3978 if (next_cpu
== NULL
)
3979 next_cpu
= first_cpu
;
3980 for (; next_cpu
!= NULL
; next_cpu
= next_cpu
->next_cpu
) {
3981 CPUState
*env
= cur_cpu
= next_cpu
;
3985 if (timer_alarm_pending
) {
3986 timer_alarm_pending
= 0;
3989 if (cpu_can_run(env
))
3990 ret
= qemu_cpu_exec(env
);
3991 if (ret
== EXCP_DEBUG
) {
3992 gdb_set_stop_cpu(env
);
3993 debug_requested
= 1;
3999 static int cpu_has_work(CPUState
*env
)
4007 if (qemu_cpu_has_work(env
))
4012 static int tcg_has_work(void)
4016 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
4017 if (cpu_has_work(env
))
4022 static int qemu_calculate_timeout(void)
4024 #ifndef CONFIG_IOTHREAD
4029 else if (tcg_has_work())
4031 else if (!use_icount
)
4034 /* XXX: use timeout computed from timers */
4037 /* Advance virtual time to the next event. */
4038 if (use_icount
== 1) {
4039 /* When not using an adaptive execution frequency
4040 we tend to get badly out of sync with real time,
4041 so just delay for a reasonable amount of time. */
4044 delta
= cpu_get_icount() - cpu_get_clock();
4047 /* If virtual time is ahead of real time then just
4049 timeout
= (delta
/ 1000000) + 1;
4051 /* Wait for either IO to occur or the next
4053 add
= qemu_next_deadline();
4054 /* We advance the timer before checking for IO.
4055 Limit the amount we advance so that early IO
4056 activity won't get the guest too far ahead. */
4060 add
= (add
+ (1 << icount_time_shift
) - 1)
4061 >> icount_time_shift
;
4063 timeout
= delta
/ 1000000;
4070 #else /* CONFIG_IOTHREAD */
4075 static int vm_can_run(void)
4077 if (powerdown_requested
)
4079 if (reset_requested
)
4081 if (shutdown_requested
)
4083 if (debug_requested
)
4088 qemu_irq qemu_system_powerdown
;
4090 static void main_loop(void)
4094 #ifdef CONFIG_IOTHREAD
4095 qemu_system_ready
= 1;
4096 qemu_cond_broadcast(&qemu_system_cond
);
4101 #ifdef CONFIG_PROFILER
4104 #ifndef CONFIG_IOTHREAD
4107 #ifdef CONFIG_PROFILER
4108 ti
= profile_getclock();
4110 main_loop_wait(qemu_calculate_timeout());
4111 #ifdef CONFIG_PROFILER
4112 dev_time
+= profile_getclock() - ti
;
4114 } while (vm_can_run());
4116 if (qemu_debug_requested())
4117 vm_stop(EXCP_DEBUG
);
4118 if (qemu_shutdown_requested()) {
4125 if (qemu_reset_requested()) {
4127 qemu_system_reset();
4130 if (qemu_powerdown_requested()) {
4131 qemu_irq_raise(qemu_system_powerdown
);
4133 if ((r
= qemu_vmstop_requested()))
4139 static void version(void)
4141 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n");
4144 static void help(int exitcode
)
4147 printf("usage: %s [options] [disk_image]\n"
4149 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4151 #define DEF(option, opt_arg, opt_enum, opt_help) \
4153 #define DEFHEADING(text) stringify(text) "\n"
4154 #include "qemu-options.h"
4159 "During emulation, the following keys are useful:\n"
4160 "ctrl-alt-f toggle full screen\n"
4161 "ctrl-alt-n switch to virtual console 'n'\n"
4162 "ctrl-alt toggle mouse and keyboard grab\n"
4164 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4169 DEFAULT_NETWORK_SCRIPT
,
4170 DEFAULT_NETWORK_DOWN_SCRIPT
,
4172 DEFAULT_GDBSTUB_PORT
,
4177 #define HAS_ARG 0x0001
4180 #define DEF(option, opt_arg, opt_enum, opt_help) \
4182 #define DEFHEADING(text)
4183 #include "qemu-options.h"
4189 typedef struct QEMUOption
{
4195 static const QEMUOption qemu_options
[] = {
4196 { "h", 0, QEMU_OPTION_h
},
4197 #define DEF(option, opt_arg, opt_enum, opt_help) \
4198 { option, opt_arg, opt_enum },
4199 #define DEFHEADING(text)
4200 #include "qemu-options.h"
4208 struct soundhw soundhw
[] = {
4209 #ifdef HAS_AUDIO_CHOICE
4210 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4216 { .init_isa
= pcspk_audio_init
}
4223 "Creative Sound Blaster 16",
4226 { .init_isa
= SB16_init
}
4230 #ifdef CONFIG_CS4231A
4236 { .init_isa
= cs4231a_init
}
4244 "Yamaha YMF262 (OPL3)",
4246 "Yamaha YM3812 (OPL2)",
4250 { .init_isa
= Adlib_init
}
4257 "Gravis Ultrasound GF1",
4260 { .init_isa
= GUS_init
}
4267 "Intel 82801AA AC97 Audio",
4270 { .init_pci
= ac97_init
}
4274 #ifdef CONFIG_ES1370
4277 "ENSONIQ AudioPCI ES1370",
4280 { .init_pci
= es1370_init
}
4284 #endif /* HAS_AUDIO_CHOICE */
4286 { NULL
, NULL
, 0, 0, { NULL
} }
4289 static void select_soundhw (const char *optarg
)
4293 if (*optarg
== '?') {
4296 printf ("Valid sound card names (comma separated):\n");
4297 for (c
= soundhw
; c
->name
; ++c
) {
4298 printf ("%-11s %s\n", c
->name
, c
->descr
);
4300 printf ("\n-soundhw all will enable all of the above\n");
4301 exit (*optarg
!= '?');
4309 if (!strcmp (optarg
, "all")) {
4310 for (c
= soundhw
; c
->name
; ++c
) {
4318 e
= strchr (p
, ',');
4319 l
= !e
? strlen (p
) : (size_t) (e
- p
);
4321 for (c
= soundhw
; c
->name
; ++c
) {
4322 if (!strncmp (c
->name
, p
, l
) && !c
->name
[l
]) {
4331 "Unknown sound card name (too big to show)\n");
4334 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
4339 p
+= l
+ (e
!= NULL
);
4343 goto show_valid_cards
;
4348 static void select_vgahw (const char *p
)
4352 vga_interface_type
= VGA_NONE
;
4353 if (strstart(p
, "std", &opts
)) {
4354 vga_interface_type
= VGA_STD
;
4355 } else if (strstart(p
, "cirrus", &opts
)) {
4356 vga_interface_type
= VGA_CIRRUS
;
4357 } else if (strstart(p
, "vmware", &opts
)) {
4358 vga_interface_type
= VGA_VMWARE
;
4359 } else if (strstart(p
, "xenfb", &opts
)) {
4360 vga_interface_type
= VGA_XENFB
;
4361 } else if (!strstart(p
, "none", &opts
)) {
4363 fprintf(stderr
, "Unknown vga type: %s\n", p
);
4367 const char *nextopt
;
4369 if (strstart(opts
, ",retrace=", &nextopt
)) {
4371 if (strstart(opts
, "dumb", &nextopt
))
4372 vga_retrace_method
= VGA_RETRACE_DUMB
;
4373 else if (strstart(opts
, "precise", &nextopt
))
4374 vga_retrace_method
= VGA_RETRACE_PRECISE
;
4375 else goto invalid_vga
;
4376 } else goto invalid_vga
;
4382 static int balloon_parse(const char *arg
)
4386 if (strcmp(arg
, "none") == 0) {
4390 if (!strncmp(arg
, "virtio", 6)) {
4391 if (arg
[6] == ',') {
4392 /* have params -> parse them */
4393 opts
= qemu_opts_parse(&qemu_device_opts
, arg
+7, NULL
);
4397 /* create empty opts */
4398 opts
= qemu_opts_create(&qemu_device_opts
, NULL
, 0);
4400 qemu_opt_set(opts
, "driver", "virtio-balloon-pci");
4409 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
4411 exit(STATUS_CONTROL_C_EXIT
);
4416 int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
4420 if(strlen(str
) != 36)
4423 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
4424 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
4425 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
4431 smbios_add_field(1, offsetof(struct smbios_type_1
, uuid
), 16, uuid
);
4439 static void termsig_handler(int signal
)
4441 qemu_system_shutdown_request();
4444 static void sigchld_handler(int signal
)
4446 waitpid(-1, NULL
, WNOHANG
);
4449 static void sighandler_setup(void)
4451 struct sigaction act
;
4453 memset(&act
, 0, sizeof(act
));
4454 act
.sa_handler
= termsig_handler
;
4455 sigaction(SIGINT
, &act
, NULL
);
4456 sigaction(SIGHUP
, &act
, NULL
);
4457 sigaction(SIGTERM
, &act
, NULL
);
4459 act
.sa_handler
= sigchld_handler
;
4460 act
.sa_flags
= SA_NOCLDSTOP
;
4461 sigaction(SIGCHLD
, &act
, NULL
);
4467 /* Look for support files in the same directory as the executable. */
4468 static char *find_datadir(const char *argv0
)
4474 len
= GetModuleFileName(NULL
, buf
, sizeof(buf
) - 1);
4481 while (p
!= buf
&& *p
!= '\\')
4484 if (access(buf
, R_OK
) == 0) {
4485 return qemu_strdup(buf
);
4491 /* Find a likely location for support files using the location of the binary.
4492 For installed binaries this will be "$bindir/../share/qemu". When
4493 running from the build tree this will be "$bindir/../pc-bios". */
4494 #define SHARE_SUFFIX "/share/qemu"
4495 #define BUILD_SUFFIX "/pc-bios"
4496 static char *find_datadir(const char *argv0
)
4504 #if defined(__linux__)
4507 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
4513 #elif defined(__FreeBSD__)
4516 len
= readlink("/proc/curproc/file", buf
, sizeof(buf
) - 1);
4523 /* If we don't have any way of figuring out the actual executable
4524 location then try argv[0]. */
4526 p
= realpath(argv0
, buf
);
4534 max_len
= strlen(dir
) +
4535 MAX(strlen(SHARE_SUFFIX
), strlen(BUILD_SUFFIX
)) + 1;
4536 res
= qemu_mallocz(max_len
);
4537 snprintf(res
, max_len
, "%s%s", dir
, SHARE_SUFFIX
);
4538 if (access(res
, R_OK
)) {
4539 snprintf(res
, max_len
, "%s%s", dir
, BUILD_SUFFIX
);
4540 if (access(res
, R_OK
)) {
4552 char *qemu_find_file(int type
, const char *name
)
4558 /* If name contains path separators then try it as a straight path. */
4559 if ((strchr(name
, '/') || strchr(name
, '\\'))
4560 && access(name
, R_OK
) == 0) {
4561 return qemu_strdup(name
);
4564 case QEMU_FILE_TYPE_BIOS
:
4567 case QEMU_FILE_TYPE_KEYMAP
:
4568 subdir
= "keymaps/";
4573 len
= strlen(data_dir
) + strlen(name
) + strlen(subdir
) + 2;
4574 buf
= qemu_mallocz(len
);
4575 snprintf(buf
, len
, "%s/%s%s", data_dir
, subdir
, name
);
4576 if (access(buf
, R_OK
)) {
4583 static int device_init_func(QemuOpts
*opts
, void *opaque
)
4587 dev
= qdev_device_add(opts
);
4593 struct device_config
{
4595 DEV_USB
, /* -usbdevice */
4598 const char *cmdline
;
4599 QTAILQ_ENTRY(device_config
) next
;
4601 QTAILQ_HEAD(, device_config
) device_configs
= QTAILQ_HEAD_INITIALIZER(device_configs
);
4603 static void add_device_config(int type
, const char *cmdline
)
4605 struct device_config
*conf
;
4607 conf
= qemu_mallocz(sizeof(*conf
));
4609 conf
->cmdline
= cmdline
;
4610 QTAILQ_INSERT_TAIL(&device_configs
, conf
, next
);
4613 static int foreach_device_config(int type
, int (*func
)(const char *cmdline
))
4615 struct device_config
*conf
;
4618 QTAILQ_FOREACH(conf
, &device_configs
, next
) {
4619 if (conf
->type
!= type
)
4621 rc
= func(conf
->cmdline
);
4628 int main(int argc
, char **argv
, char **envp
)
4630 const char *gdbstub_dev
= NULL
;
4631 uint32_t boot_devices_bitmap
= 0;
4633 int snapshot
, linux_boot
, net_boot
;
4634 const char *initrd_filename
;
4635 const char *kernel_filename
, *kernel_cmdline
;
4636 char boot_devices
[33] = "cad"; /* default to HD->floppy->CD-ROM */
4638 DisplayChangeListener
*dcl
;
4639 int cyls
, heads
, secs
, translation
;
4640 QemuOpts
*hda_opts
= NULL
, *opts
;
4642 const char *r
, *optarg
;
4643 CharDriverState
*monitor_hds
[MAX_MONITOR_DEVICES
];
4644 const char *monitor_devices
[MAX_MONITOR_DEVICES
];
4645 int monitor_device_index
;
4646 const char *serial_devices
[MAX_SERIAL_PORTS
];
4647 int serial_device_index
;
4648 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
4649 int parallel_device_index
;
4650 const char *virtio_consoles
[MAX_VIRTIO_CONSOLES
];
4651 int virtio_console_index
;
4652 const char *loadvm
= NULL
;
4653 QEMUMachine
*machine
;
4654 const char *cpu_model
;
4659 const char *pid_file
= NULL
;
4660 const char *incoming
= NULL
;
4663 struct passwd
*pwd
= NULL
;
4664 const char *chroot_dir
= NULL
;
4665 const char *run_as
= NULL
;
4668 int show_vnc_port
= 0;
4672 qemu_errors_to_file(stderr
);
4673 qemu_cache_utils_init(envp
);
4675 QLIST_INIT (&vm_change_state_head
);
4678 struct sigaction act
;
4679 sigfillset(&act
.sa_mask
);
4681 act
.sa_handler
= SIG_IGN
;
4682 sigaction(SIGPIPE
, &act
, NULL
);
4685 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
4686 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4687 QEMU to run on a single CPU */
4692 h
= GetCurrentProcess();
4693 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
4694 for(i
= 0; i
< 32; i
++) {
4695 if (mask
& (1 << i
))
4700 SetProcessAffinityMask(h
, mask
);
4706 module_call_init(MODULE_INIT_MACHINE
);
4707 machine
= find_default_machine();
4709 initrd_filename
= NULL
;
4712 kernel_filename
= NULL
;
4713 kernel_cmdline
= "";
4714 cyls
= heads
= secs
= 0;
4715 translation
= BIOS_ATA_TRANSLATION_AUTO
;
4717 serial_devices
[0] = "vc:80Cx24C";
4718 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
4719 serial_devices
[i
] = NULL
;
4720 serial_device_index
= 0;
4722 parallel_devices
[0] = "vc:80Cx24C";
4723 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
4724 parallel_devices
[i
] = NULL
;
4725 parallel_device_index
= 0;
4727 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++)
4728 virtio_consoles
[i
] = NULL
;
4729 virtio_console_index
= 0;
4731 monitor_devices
[0] = "vc:80Cx24C";
4732 for (i
= 1; i
< MAX_MONITOR_DEVICES
; i
++) {
4733 monitor_devices
[i
] = NULL
;
4735 monitor_device_index
= 0;
4737 for (i
= 0; i
< MAX_NODES
; i
++) {
4739 node_cpumask
[i
] = 0;
4754 hda_opts
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
4756 const QEMUOption
*popt
;
4759 /* Treat --foo the same as -foo. */
4762 popt
= qemu_options
;
4765 fprintf(stderr
, "%s: invalid option -- '%s'\n",
4769 if (!strcmp(popt
->name
, r
+ 1))
4773 if (popt
->flags
& HAS_ARG
) {
4774 if (optind
>= argc
) {
4775 fprintf(stderr
, "%s: option '%s' requires an argument\n",
4779 optarg
= argv
[optind
++];
4784 switch(popt
->index
) {
4786 machine
= find_machine(optarg
);
4789 printf("Supported machines are:\n");
4790 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
4792 printf("%-10s %s (alias of %s)\n",
4793 m
->alias
, m
->desc
, m
->name
);
4794 printf("%-10s %s%s\n",
4796 m
->is_default
? " (default)" : "");
4798 exit(*optarg
!= '?');
4801 case QEMU_OPTION_cpu
:
4802 /* hw initialization will check this */
4803 if (*optarg
== '?') {
4804 /* XXX: implement xxx_cpu_list for targets that still miss it */
4805 #if defined(cpu_list)
4806 cpu_list(stdout
, &fprintf
);
4813 case QEMU_OPTION_initrd
:
4814 initrd_filename
= optarg
;
4816 case QEMU_OPTION_hda
:
4818 hda_opts
= drive_add(optarg
, HD_ALIAS
, 0);
4820 hda_opts
= drive_add(optarg
, HD_ALIAS
4821 ",cyls=%d,heads=%d,secs=%d%s",
4822 0, cyls
, heads
, secs
,
4823 translation
== BIOS_ATA_TRANSLATION_LBA
?
4825 translation
== BIOS_ATA_TRANSLATION_NONE
?
4826 ",trans=none" : "");
4828 case QEMU_OPTION_hdb
:
4829 case QEMU_OPTION_hdc
:
4830 case QEMU_OPTION_hdd
:
4831 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
4833 case QEMU_OPTION_drive
:
4834 drive_add(NULL
, "%s", optarg
);
4836 case QEMU_OPTION_set
:
4837 if (qemu_set_option(optarg
) != 0)
4840 case QEMU_OPTION_mtdblock
:
4841 drive_add(optarg
, MTD_ALIAS
);
4843 case QEMU_OPTION_sd
:
4844 drive_add(optarg
, SD_ALIAS
);
4846 case QEMU_OPTION_pflash
:
4847 drive_add(optarg
, PFLASH_ALIAS
);
4849 case QEMU_OPTION_snapshot
:
4852 case QEMU_OPTION_hdachs
:
4856 cyls
= strtol(p
, (char **)&p
, 0);
4857 if (cyls
< 1 || cyls
> 16383)
4862 heads
= strtol(p
, (char **)&p
, 0);
4863 if (heads
< 1 || heads
> 16)
4868 secs
= strtol(p
, (char **)&p
, 0);
4869 if (secs
< 1 || secs
> 63)
4873 if (!strcmp(p
, "none"))
4874 translation
= BIOS_ATA_TRANSLATION_NONE
;
4875 else if (!strcmp(p
, "lba"))
4876 translation
= BIOS_ATA_TRANSLATION_LBA
;
4877 else if (!strcmp(p
, "auto"))
4878 translation
= BIOS_ATA_TRANSLATION_AUTO
;
4881 } else if (*p
!= '\0') {
4883 fprintf(stderr
, "qemu: invalid physical CHS format\n");
4886 if (hda_opts
!= NULL
) {
4888 snprintf(num
, sizeof(num
), "%d", cyls
);
4889 qemu_opt_set(hda_opts
, "cyls", num
);
4890 snprintf(num
, sizeof(num
), "%d", heads
);
4891 qemu_opt_set(hda_opts
, "heads", num
);
4892 snprintf(num
, sizeof(num
), "%d", secs
);
4893 qemu_opt_set(hda_opts
, "secs", num
);
4894 if (translation
== BIOS_ATA_TRANSLATION_LBA
)
4895 qemu_opt_set(hda_opts
, "trans", "lba");
4896 if (translation
== BIOS_ATA_TRANSLATION_NONE
)
4897 qemu_opt_set(hda_opts
, "trans", "none");
4901 case QEMU_OPTION_numa
:
4902 if (nb_numa_nodes
>= MAX_NODES
) {
4903 fprintf(stderr
, "qemu: too many NUMA nodes\n");
4908 case QEMU_OPTION_nographic
:
4909 display_type
= DT_NOGRAPHIC
;
4911 #ifdef CONFIG_CURSES
4912 case QEMU_OPTION_curses
:
4913 display_type
= DT_CURSES
;
4916 case QEMU_OPTION_portrait
:
4919 case QEMU_OPTION_kernel
:
4920 kernel_filename
= optarg
;
4922 case QEMU_OPTION_append
:
4923 kernel_cmdline
= optarg
;
4925 case QEMU_OPTION_cdrom
:
4926 drive_add(optarg
, CDROM_ALIAS
);
4928 case QEMU_OPTION_boot
:
4930 static const char * const params
[] = {
4931 "order", "once", "menu", NULL
4933 char buf
[sizeof(boot_devices
)];
4934 char *standard_boot_devices
;
4937 if (!strchr(optarg
, '=')) {
4939 pstrcpy(buf
, sizeof(buf
), optarg
);
4940 } else if (check_params(buf
, sizeof(buf
), params
, optarg
) < 0) {
4942 "qemu: unknown boot parameter '%s' in '%s'\n",
4948 get_param_value(buf
, sizeof(buf
), "order", optarg
)) {
4949 boot_devices_bitmap
= parse_bootdevices(buf
);
4950 pstrcpy(boot_devices
, sizeof(boot_devices
), buf
);
4953 if (get_param_value(buf
, sizeof(buf
),
4955 boot_devices_bitmap
|= parse_bootdevices(buf
);
4956 standard_boot_devices
= qemu_strdup(boot_devices
);
4957 pstrcpy(boot_devices
, sizeof(boot_devices
), buf
);
4958 qemu_register_reset(restore_boot_devices
,
4959 standard_boot_devices
);
4961 if (get_param_value(buf
, sizeof(buf
),
4963 if (!strcmp(buf
, "on")) {
4965 } else if (!strcmp(buf
, "off")) {
4969 "qemu: invalid option value '%s'\n",
4977 case QEMU_OPTION_fda
:
4978 case QEMU_OPTION_fdb
:
4979 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
4982 case QEMU_OPTION_no_fd_bootchk
:
4986 case QEMU_OPTION_netdev
:
4987 if (net_client_parse(&qemu_netdev_opts
, optarg
) == -1) {
4991 case QEMU_OPTION_net
:
4992 if (net_client_parse(&qemu_net_opts
, optarg
) == -1) {
4997 case QEMU_OPTION_tftp
:
4998 legacy_tftp_prefix
= optarg
;
5000 case QEMU_OPTION_bootp
:
5001 legacy_bootp_filename
= optarg
;
5004 case QEMU_OPTION_smb
:
5005 if (net_slirp_smb(optarg
) < 0)
5009 case QEMU_OPTION_redir
:
5010 if (net_slirp_redir(optarg
) < 0)
5014 case QEMU_OPTION_bt
:
5015 add_device_config(DEV_BT
, optarg
);
5018 case QEMU_OPTION_audio_help
:
5022 case QEMU_OPTION_soundhw
:
5023 select_soundhw (optarg
);
5029 case QEMU_OPTION_version
:
5033 case QEMU_OPTION_m
: {
5037 value
= strtoul(optarg
, &ptr
, 10);
5039 case 0: case 'M': case 'm':
5046 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
5050 /* On 32-bit hosts, QEMU is limited by virtual address space */
5051 if (value
> (2047 << 20) && HOST_LONG_BITS
== 32) {
5052 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
5055 if (value
!= (uint64_t)(ram_addr_t
)value
) {
5056 fprintf(stderr
, "qemu: ram size too large\n");
5065 const CPULogItem
*item
;
5067 mask
= cpu_str_to_log_mask(optarg
);
5069 printf("Log items (comma separated):\n");
5070 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
5071 printf("%-10s %s\n", item
->name
, item
->help
);
5079 gdbstub_dev
= "tcp::" DEFAULT_GDBSTUB_PORT
;
5081 case QEMU_OPTION_gdb
:
5082 gdbstub_dev
= optarg
;
5087 case QEMU_OPTION_bios
:
5090 case QEMU_OPTION_singlestep
:
5098 keyboard_layout
= optarg
;
5101 case QEMU_OPTION_localtime
:
5104 case QEMU_OPTION_vga
:
5105 select_vgahw (optarg
);
5107 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5113 w
= strtol(p
, (char **)&p
, 10);
5116 fprintf(stderr
, "qemu: invalid resolution or depth\n");
5122 h
= strtol(p
, (char **)&p
, 10);
5127 depth
= strtol(p
, (char **)&p
, 10);
5128 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
5129 depth
!= 24 && depth
!= 32)
5131 } else if (*p
== '\0') {
5132 depth
= graphic_depth
;
5139 graphic_depth
= depth
;
5143 case QEMU_OPTION_echr
:
5146 term_escape_char
= strtol(optarg
, &r
, 0);
5148 printf("Bad argument to echr\n");
5151 case QEMU_OPTION_monitor
:
5152 if (monitor_device_index
>= MAX_MONITOR_DEVICES
) {
5153 fprintf(stderr
, "qemu: too many monitor devices\n");
5156 monitor_devices
[monitor_device_index
] = optarg
;
5157 monitor_device_index
++;
5159 case QEMU_OPTION_chardev
:
5160 opts
= qemu_opts_parse(&qemu_chardev_opts
, optarg
, "backend");
5162 fprintf(stderr
, "parse error: %s\n", optarg
);
5165 if (qemu_chr_open_opts(opts
, NULL
) == NULL
) {
5169 case QEMU_OPTION_serial
:
5170 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
5171 fprintf(stderr
, "qemu: too many serial ports\n");
5174 serial_devices
[serial_device_index
] = optarg
;
5175 serial_device_index
++;
5177 case QEMU_OPTION_watchdog
:
5180 "qemu: only one watchdog option may be given\n");
5185 case QEMU_OPTION_watchdog_action
:
5186 if (select_watchdog_action(optarg
) == -1) {
5187 fprintf(stderr
, "Unknown -watchdog-action parameter\n");
5191 case QEMU_OPTION_virtiocon
:
5192 if (virtio_console_index
>= MAX_VIRTIO_CONSOLES
) {
5193 fprintf(stderr
, "qemu: too many virtio consoles\n");
5196 virtio_consoles
[virtio_console_index
] = optarg
;
5197 virtio_console_index
++;
5199 case QEMU_OPTION_parallel
:
5200 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
5201 fprintf(stderr
, "qemu: too many parallel ports\n");
5204 parallel_devices
[parallel_device_index
] = optarg
;
5205 parallel_device_index
++;
5207 case QEMU_OPTION_loadvm
:
5210 case QEMU_OPTION_full_screen
:
5214 case QEMU_OPTION_no_frame
:
5217 case QEMU_OPTION_alt_grab
:
5220 case QEMU_OPTION_ctrl_grab
:
5223 case QEMU_OPTION_no_quit
:
5226 case QEMU_OPTION_sdl
:
5227 display_type
= DT_SDL
;
5230 case QEMU_OPTION_pidfile
:
5234 case QEMU_OPTION_win2k_hack
:
5235 win2k_install_hack
= 1;
5237 case QEMU_OPTION_rtc_td_hack
:
5240 case QEMU_OPTION_acpitable
:
5241 if(acpi_table_add(optarg
) < 0) {
5242 fprintf(stderr
, "Wrong acpi table provided\n");
5246 case QEMU_OPTION_smbios
:
5247 if(smbios_entry_add(optarg
) < 0) {
5248 fprintf(stderr
, "Wrong smbios provided\n");
5254 case QEMU_OPTION_enable_kvm
:
5258 case QEMU_OPTION_usb
:
5261 case QEMU_OPTION_usbdevice
:
5263 add_device_config(DEV_USB
, optarg
);
5265 case QEMU_OPTION_device
:
5266 if (!qemu_opts_parse(&qemu_device_opts
, optarg
, "driver")) {
5270 case QEMU_OPTION_smp
:
5273 fprintf(stderr
, "Invalid number of CPUs\n");
5276 if (max_cpus
< smp_cpus
) {
5277 fprintf(stderr
, "maxcpus must be equal to or greater than "
5281 if (max_cpus
> 255) {
5282 fprintf(stderr
, "Unsupported number of maxcpus\n");
5286 case QEMU_OPTION_vnc
:
5287 display_type
= DT_VNC
;
5288 vnc_display
= optarg
;
5291 case QEMU_OPTION_no_acpi
:
5294 case QEMU_OPTION_no_hpet
:
5297 case QEMU_OPTION_balloon
:
5298 if (balloon_parse(optarg
) < 0) {
5299 fprintf(stderr
, "Unknown -balloon argument %s\n", optarg
);
5304 case QEMU_OPTION_no_reboot
:
5307 case QEMU_OPTION_no_shutdown
:
5310 case QEMU_OPTION_show_cursor
:
5313 case QEMU_OPTION_uuid
:
5314 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
5315 fprintf(stderr
, "Fail to parse UUID string."
5316 " Wrong format.\n");
5321 case QEMU_OPTION_daemonize
:
5325 case QEMU_OPTION_option_rom
:
5326 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
5327 fprintf(stderr
, "Too many option ROMs\n");
5330 option_rom
[nb_option_roms
] = optarg
;
5333 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5334 case QEMU_OPTION_semihosting
:
5335 semihosting_enabled
= 1;
5338 case QEMU_OPTION_name
:
5339 qemu_name
= qemu_strdup(optarg
);
5341 char *p
= strchr(qemu_name
, ',');
5344 if (strncmp(p
, "process=", 8)) {
5345 fprintf(stderr
, "Unknown subargument %s to -name", p
);
5353 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5354 case QEMU_OPTION_prom_env
:
5355 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
5356 fprintf(stderr
, "Too many prom variables\n");
5359 prom_envs
[nb_prom_envs
] = optarg
;
5364 case QEMU_OPTION_old_param
:
5368 case QEMU_OPTION_clock
:
5369 configure_alarms(optarg
);
5371 case QEMU_OPTION_startdate
:
5372 configure_rtc_date_offset(optarg
, 1);
5374 case QEMU_OPTION_rtc
:
5375 opts
= qemu_opts_parse(&qemu_rtc_opts
, optarg
, NULL
);
5377 fprintf(stderr
, "parse error: %s\n", optarg
);
5380 configure_rtc(opts
);
5382 case QEMU_OPTION_tb_size
:
5383 tb_size
= strtol(optarg
, NULL
, 0);
5387 case QEMU_OPTION_icount
:
5389 if (strcmp(optarg
, "auto") == 0) {
5390 icount_time_shift
= -1;
5392 icount_time_shift
= strtol(optarg
, NULL
, 0);
5395 case QEMU_OPTION_incoming
:
5399 case QEMU_OPTION_chroot
:
5400 chroot_dir
= optarg
;
5402 case QEMU_OPTION_runas
:
5407 case QEMU_OPTION_xen_domid
:
5408 xen_domid
= atoi(optarg
);
5410 case QEMU_OPTION_xen_create
:
5411 xen_mode
= XEN_CREATE
;
5413 case QEMU_OPTION_xen_attach
:
5414 xen_mode
= XEN_ATTACH
;
5421 /* If no data_dir is specified then try to find it relative to the
5424 data_dir
= find_datadir(argv
[0]);
5426 /* If all else fails use the install patch specified when building. */
5428 data_dir
= CONFIG_QEMU_SHAREDIR
;
5432 * Default to max_cpus = smp_cpus, in case the user doesn't
5433 * specify a max_cpus value.
5436 max_cpus
= smp_cpus
;
5438 machine
->max_cpus
= machine
->max_cpus
?: 1; /* Default to UP */
5439 if (smp_cpus
> machine
->max_cpus
) {
5440 fprintf(stderr
, "Number of SMP cpus requested (%d), exceeds max cpus "
5441 "supported by machine `%s' (%d)\n", smp_cpus
, machine
->name
,
5446 if (display_type
== DT_NOGRAPHIC
) {
5447 if (serial_device_index
== 0)
5448 serial_devices
[0] = "stdio";
5449 if (parallel_device_index
== 0)
5450 parallel_devices
[0] = "null";
5451 if (strncmp(monitor_devices
[0], "vc", 2) == 0) {
5452 monitor_devices
[0] = "stdio";
5460 if (pipe(fds
) == -1)
5471 len
= read(fds
[0], &status
, 1);
5472 if (len
== -1 && (errno
== EINTR
))
5477 else if (status
== 1) {
5478 fprintf(stderr
, "Could not acquire pidfile: %s\n", strerror(errno
));
5495 signal(SIGTSTP
, SIG_IGN
);
5496 signal(SIGTTOU
, SIG_IGN
);
5497 signal(SIGTTIN
, SIG_IGN
);
5500 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
5503 write(fds
[1], &status
, 1);
5505 fprintf(stderr
, "Could not acquire pid file: %s\n", strerror(errno
));
5510 if (kvm_enabled()) {
5513 ret
= kvm_init(smp_cpus
);
5515 fprintf(stderr
, "failed to initialize KVM\n");
5520 if (qemu_init_main_loop()) {
5521 fprintf(stderr
, "qemu_init_main_loop failed\n");
5524 linux_boot
= (kernel_filename
!= NULL
);
5526 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
5527 fprintf(stderr
, "-append only allowed with -kernel option\n");
5531 if (!linux_boot
&& initrd_filename
!= NULL
) {
5532 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
5537 /* Win32 doesn't support line-buffering and requires size >= 2 */
5538 setvbuf(stdout
, NULL
, _IOLBF
, 0);
5541 if (init_timer_alarm() < 0) {
5542 fprintf(stderr
, "could not initialize alarm timer\n");
5545 if (use_icount
&& icount_time_shift
< 0) {
5547 /* 125MIPS seems a reasonable initial guess at the guest speed.
5548 It will be corrected fairly quickly anyway. */
5549 icount_time_shift
= 3;
5550 init_icount_adjust();
5557 if (net_init_clients() < 0) {
5561 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
5562 net_set_boot_mask(net_boot
);
5564 /* init the bluetooth world */
5565 if (foreach_device_config(DEV_BT
, bt_parse
))
5568 /* init the memory */
5570 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
5572 /* init the dynamic translator */
5573 cpu_exec_init_all(tb_size
* 1024 * 1024);
5577 /* we always create the cdrom drive, even if no disk is there */
5578 drive_add(NULL
, CDROM_ALIAS
);
5580 /* we always create at least one floppy */
5581 drive_add(NULL
, FD_ALIAS
, 0);
5583 /* we always create one sd slot, even if no card is in it */
5584 drive_add(NULL
, SD_ALIAS
);
5586 /* open the virtual block devices */
5588 qemu_opts_foreach(&qemu_drive_opts
, drive_enable_snapshot
, NULL
, 0);
5589 if (qemu_opts_foreach(&qemu_drive_opts
, drive_init_func
, machine
, 1) != 0)
5592 vmstate_register(0, &vmstate_timers
,&timers_state
);
5593 register_savevm_live("ram", 0, 3, ram_save_live
, NULL
, ram_load
, NULL
);
5595 /* Maintain compatibility with multiple stdio monitors */
5596 if (!strcmp(monitor_devices
[0],"stdio")) {
5597 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
5598 const char *devname
= serial_devices
[i
];
5599 if (devname
&& !strcmp(devname
,"mon:stdio")) {
5600 monitor_devices
[0] = NULL
;
5602 } else if (devname
&& !strcmp(devname
,"stdio")) {
5603 monitor_devices
[0] = NULL
;
5604 serial_devices
[i
] = "mon:stdio";
5610 if (nb_numa_nodes
> 0) {
5613 if (nb_numa_nodes
> smp_cpus
) {
5614 nb_numa_nodes
= smp_cpus
;
5617 /* If no memory size if given for any node, assume the default case
5618 * and distribute the available memory equally across all nodes
5620 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5621 if (node_mem
[i
] != 0)
5624 if (i
== nb_numa_nodes
) {
5625 uint64_t usedmem
= 0;
5627 /* On Linux, the each node's border has to be 8MB aligned,
5628 * the final node gets the rest.
5630 for (i
= 0; i
< nb_numa_nodes
- 1; i
++) {
5631 node_mem
[i
] = (ram_size
/ nb_numa_nodes
) & ~((1 << 23UL) - 1);
5632 usedmem
+= node_mem
[i
];
5634 node_mem
[i
] = ram_size
- usedmem
;
5637 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5638 if (node_cpumask
[i
] != 0)
5641 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5642 * must cope with this anyway, because there are BIOSes out there in
5643 * real machines which also use this scheme.
5645 if (i
== nb_numa_nodes
) {
5646 for (i
= 0; i
< smp_cpus
; i
++) {
5647 node_cpumask
[i
% nb_numa_nodes
] |= 1 << i
;
5652 for (i
= 0; i
< MAX_MONITOR_DEVICES
; i
++) {
5653 const char *devname
= monitor_devices
[i
];
5654 if (devname
&& strcmp(devname
, "none")) {
5657 snprintf(label
, sizeof(label
), "monitor");
5659 snprintf(label
, sizeof(label
), "monitor%d", i
);
5661 monitor_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5662 if (!monitor_hds
[i
]) {
5663 fprintf(stderr
, "qemu: could not open monitor device '%s'\n",
5670 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
5671 const char *devname
= serial_devices
[i
];
5672 if (devname
&& strcmp(devname
, "none")) {
5674 snprintf(label
, sizeof(label
), "serial%d", i
);
5675 serial_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5676 if (!serial_hds
[i
]) {
5677 fprintf(stderr
, "qemu: could not open serial device '%s': %s\n",
5678 devname
, strerror(errno
));
5684 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
5685 const char *devname
= parallel_devices
[i
];
5686 if (devname
&& strcmp(devname
, "none")) {
5688 snprintf(label
, sizeof(label
), "parallel%d", i
);
5689 parallel_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5690 if (!parallel_hds
[i
]) {
5691 fprintf(stderr
, "qemu: could not open parallel device '%s': %s\n",
5692 devname
, strerror(errno
));
5698 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++) {
5699 const char *devname
= virtio_consoles
[i
];
5700 if (devname
&& strcmp(devname
, "none")) {
5702 snprintf(label
, sizeof(label
), "virtcon%d", i
);
5703 virtcon_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
5704 if (!virtcon_hds
[i
]) {
5705 fprintf(stderr
, "qemu: could not open virtio console '%s': %s\n",
5706 devname
, strerror(errno
));
5712 module_call_init(MODULE_INIT_DEVICE
);
5715 i
= select_watchdog(watchdog
);
5717 exit (i
== 1 ? 1 : 0);
5720 if (machine
->compat_props
) {
5721 qdev_prop_register_compat(machine
->compat_props
);
5723 machine
->init(ram_size
, boot_devices
,
5724 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
5728 /* must be after terminal init, SDL library changes signal handlers */
5732 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
5733 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5734 if (node_cpumask
[i
] & (1 << env
->cpu_index
)) {
5740 current_machine
= machine
;
5742 /* init USB devices */
5744 if (foreach_device_config(DEV_USB
, usb_parse
) < 0)
5748 /* init generic devices */
5749 if (qemu_opts_foreach(&qemu_device_opts
, device_init_func
, NULL
, 1) != 0)
5753 dumb_display_init();
5754 /* just use the first displaystate for the moment */
5757 if (display_type
== DT_DEFAULT
) {
5758 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5759 display_type
= DT_SDL
;
5761 display_type
= DT_VNC
;
5762 vnc_display
= "localhost:0,to=99";
5768 switch (display_type
) {
5771 #if defined(CONFIG_CURSES)
5773 curses_display_init(ds
, full_screen
);
5776 #if defined(CONFIG_SDL)
5778 sdl_display_init(ds
, full_screen
, no_frame
);
5780 #elif defined(CONFIG_COCOA)
5782 cocoa_display_init(ds
, full_screen
);
5786 vnc_display_init(ds
);
5787 if (vnc_display_open(ds
, vnc_display
) < 0)
5790 if (show_vnc_port
) {
5791 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds
));
5799 dcl
= ds
->listeners
;
5800 while (dcl
!= NULL
) {
5801 if (dcl
->dpy_refresh
!= NULL
) {
5802 ds
->gui_timer
= qemu_new_timer(rt_clock
, gui_update
, ds
);
5803 qemu_mod_timer(ds
->gui_timer
, qemu_get_clock(rt_clock
));
5808 if (display_type
== DT_NOGRAPHIC
|| display_type
== DT_VNC
) {
5809 nographic_timer
= qemu_new_timer(rt_clock
, nographic_update
, NULL
);
5810 qemu_mod_timer(nographic_timer
, qemu_get_clock(rt_clock
));
5813 text_consoles_set_display(display_state
);
5814 qemu_chr_initial_reset();
5816 for (i
= 0; i
< MAX_MONITOR_DEVICES
; i
++) {
5817 if (monitor_devices
[i
] && monitor_hds
[i
]) {
5818 monitor_init(monitor_hds
[i
],
5819 MONITOR_USE_READLINE
|
5820 ((i
== 0) ? MONITOR_IS_DEFAULT
: 0));
5824 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
5825 const char *devname
= serial_devices
[i
];
5826 if (devname
&& strcmp(devname
, "none")) {
5827 if (strstart(devname
, "vc", 0))
5828 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
5832 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
5833 const char *devname
= parallel_devices
[i
];
5834 if (devname
&& strcmp(devname
, "none")) {
5835 if (strstart(devname
, "vc", 0))
5836 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
5840 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++) {
5841 const char *devname
= virtio_consoles
[i
];
5842 if (virtcon_hds
[i
] && devname
) {
5843 if (strstart(devname
, "vc", 0))
5844 qemu_chr_printf(virtcon_hds
[i
], "virtio console%d\r\n", i
);
5848 if (gdbstub_dev
&& gdbserver_start(gdbstub_dev
) < 0) {
5849 fprintf(stderr
, "qemu: could not open gdbserver on device '%s'\n",
5854 qdev_machine_creation_done();
5859 if (load_vmstate(cur_mon
, loadvm
) < 0) {
5865 qemu_start_incoming_migration(incoming
);
5866 } else if (autostart
) {
5876 len
= write(fds
[1], &status
, 1);
5877 if (len
== -1 && (errno
== EINTR
))
5884 TFR(fd
= open("/dev/null", O_RDWR
));
5890 pwd
= getpwnam(run_as
);
5892 fprintf(stderr
, "User \"%s\" doesn't exist\n", run_as
);
5898 if (chroot(chroot_dir
) < 0) {
5899 fprintf(stderr
, "chroot failed\n");
5906 if (setgid(pwd
->pw_gid
) < 0) {
5907 fprintf(stderr
, "Failed to setgid(%d)\n", pwd
->pw_gid
);
5910 if (setuid(pwd
->pw_uid
) < 0) {
5911 fprintf(stderr
, "Failed to setuid(%d)\n", pwd
->pw_uid
);
5914 if (setuid(0) != -1) {
5915 fprintf(stderr
, "Dropping privileges failed\n");