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 HOST_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>
72 /* For the benefit of older linux systems which don't supply it,
73 we use a local copy of hpet.h. */
74 /* #include <linux/hpet.h> */
77 #include <linux/ppdev.h>
78 #include <linux/parport.h>
82 #include <sys/ethernet.h>
83 #include <sys/sockio.h>
84 #include <netinet/arp.h>
85 #include <netinet/in.h>
86 #include <netinet/in_systm.h>
87 #include <netinet/ip.h>
88 #include <netinet/ip_icmp.h> // must come after ip.h
89 #include <netinet/udp.h>
90 #include <netinet/tcp.h>
98 #if defined(__OpenBSD__)
102 #if defined(CONFIG_VDE)
103 #include <libvdeplug.h>
109 #include <sys/timeb.h>
110 #include <mmsystem.h>
111 #define getopt_long_only getopt_long
112 #define memalign(align, size) malloc(size)
118 int qemu_main(int argc
, char **argv
, char **envp
);
119 int main(int argc
, char **argv
)
121 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"
151 #include "qemu-timer.h"
152 #include "qemu-char.h"
153 #include "cache-utils.h"
156 #include "audio/audio.h"
157 #include "migration.h"
160 #include "qemu-option.h"
164 #include "exec-all.h"
166 #include "qemu_socket.h"
168 #if defined(CONFIG_SLIRP)
169 #include "libslirp.h"
172 //#define DEBUG_UNUSED_IOPORT
173 //#define DEBUG_IOPORT
175 //#define DEBUG_SLIRP
179 # define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
181 # define LOG_IOPORT(...) do { } while (0)
184 #define DEFAULT_RAM_SIZE 128
186 /* Max number of USB devices that can be specified on the commandline. */
187 #define MAX_USB_CMDLINE 8
189 /* Max number of bluetooth switches on the commandline. */
190 #define MAX_BT_CMDLINE 10
192 /* XXX: use a two level table to limit memory usage */
193 #define MAX_IOPORTS 65536
195 static const char *data_dir
;
196 const char *bios_name
= NULL
;
197 static void *ioport_opaque
[MAX_IOPORTS
];
198 static IOPortReadFunc
*ioport_read_table
[3][MAX_IOPORTS
];
199 static IOPortWriteFunc
*ioport_write_table
[3][MAX_IOPORTS
];
200 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
201 to store the VM snapshots */
202 DriveInfo drives_table
[MAX_DRIVES
+1];
204 enum vga_retrace_method vga_retrace_method
= VGA_RETRACE_DUMB
;
205 static DisplayState
*display_state
;
206 DisplayType display_type
= DT_DEFAULT
;
207 const char* keyboard_layout
= NULL
;
208 int64_t ticks_per_sec
;
211 NICInfo nd_table
[MAX_NICS
];
213 static int autostart
;
214 static int rtc_utc
= 1;
215 static int rtc_date_offset
= -1; /* -1 means no change */
216 int cirrus_vga_enabled
= 1;
217 int std_vga_enabled
= 0;
218 int vmsvga_enabled
= 0;
219 int xenfb_enabled
= 0;
221 int graphic_width
= 1024;
222 int graphic_height
= 768;
223 int graphic_depth
= 8;
225 int graphic_width
= 800;
226 int graphic_height
= 600;
227 int graphic_depth
= 15;
229 static int full_screen
= 0;
231 static int no_frame
= 0;
234 CharDriverState
*serial_hds
[MAX_SERIAL_PORTS
];
235 CharDriverState
*parallel_hds
[MAX_PARALLEL_PORTS
];
236 CharDriverState
*virtcon_hds
[MAX_VIRTIO_CONSOLES
];
238 int win2k_install_hack
= 0;
244 const char *vnc_display
;
245 int acpi_enabled
= 1;
251 int graphic_rotate
= 0;
255 WatchdogTimerModel
*watchdog
= NULL
;
256 int watchdog_action
= WDT_RESET
;
257 const char *option_rom
[MAX_OPTION_ROMS
];
259 int semihosting_enabled
= 0;
263 const char *qemu_name
;
265 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
266 unsigned int nb_prom_envs
= 0;
267 const char *prom_envs
[MAX_PROM_ENVS
];
270 struct drive_opt drives_opt
[MAX_DRIVES
];
273 uint64_t node_mem
[MAX_NODES
];
274 uint64_t node_cpumask
[MAX_NODES
];
276 static CPUState
*cur_cpu
;
277 static CPUState
*next_cpu
;
278 static int timer_alarm_pending
= 1;
279 /* Conversion factor from emulated instructions to virtual clock ticks. */
280 static int icount_time_shift
;
281 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
282 #define MAX_ICOUNT_SHIFT 10
283 /* Compensate for varying guest execution speed. */
284 static int64_t qemu_icount_bias
;
285 static QEMUTimer
*icount_rt_timer
;
286 static QEMUTimer
*icount_vm_timer
;
287 static QEMUTimer
*nographic_timer
;
289 uint8_t qemu_uuid
[16];
291 /***********************************************************/
292 /* x86 ISA bus support */
294 target_phys_addr_t isa_mem_base
= 0;
297 static IOPortReadFunc default_ioport_readb
, default_ioport_readw
, default_ioport_readl
;
298 static IOPortWriteFunc default_ioport_writeb
, default_ioport_writew
, default_ioport_writel
;
300 static uint32_t ioport_read(int index
, uint32_t address
)
302 static IOPortReadFunc
*default_func
[3] = {
303 default_ioport_readb
,
304 default_ioport_readw
,
307 IOPortReadFunc
*func
= ioport_read_table
[index
][address
];
309 func
= default_func
[index
];
310 return func(ioport_opaque
[address
], address
);
313 static void ioport_write(int index
, uint32_t address
, uint32_t data
)
315 static IOPortWriteFunc
*default_func
[3] = {
316 default_ioport_writeb
,
317 default_ioport_writew
,
318 default_ioport_writel
320 IOPortWriteFunc
*func
= ioport_write_table
[index
][address
];
322 func
= default_func
[index
];
323 func(ioport_opaque
[address
], address
, data
);
326 static uint32_t default_ioport_readb(void *opaque
, uint32_t address
)
328 #ifdef DEBUG_UNUSED_IOPORT
329 fprintf(stderr
, "unused inb: port=0x%04x\n", address
);
334 static void default_ioport_writeb(void *opaque
, uint32_t address
, uint32_t data
)
336 #ifdef DEBUG_UNUSED_IOPORT
337 fprintf(stderr
, "unused outb: port=0x%04x data=0x%02x\n", address
, data
);
341 /* default is to make two byte accesses */
342 static uint32_t default_ioport_readw(void *opaque
, uint32_t address
)
345 data
= ioport_read(0, address
);
346 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
347 data
|= ioport_read(0, address
) << 8;
351 static void default_ioport_writew(void *opaque
, uint32_t address
, uint32_t data
)
353 ioport_write(0, address
, data
& 0xff);
354 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
355 ioport_write(0, address
, (data
>> 8) & 0xff);
358 static uint32_t default_ioport_readl(void *opaque
, uint32_t address
)
360 #ifdef DEBUG_UNUSED_IOPORT
361 fprintf(stderr
, "unused inl: port=0x%04x\n", address
);
366 static void default_ioport_writel(void *opaque
, uint32_t address
, uint32_t data
)
368 #ifdef DEBUG_UNUSED_IOPORT
369 fprintf(stderr
, "unused outl: port=0x%04x data=0x%02x\n", address
, data
);
373 /* size is the word size in byte */
374 int register_ioport_read(int start
, int length
, int size
,
375 IOPortReadFunc
*func
, void *opaque
)
381 } else if (size
== 2) {
383 } else if (size
== 4) {
386 hw_error("register_ioport_read: invalid size");
389 for(i
= start
; i
< start
+ length
; i
+= size
) {
390 ioport_read_table
[bsize
][i
] = func
;
391 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
392 hw_error("register_ioport_read: invalid opaque");
393 ioport_opaque
[i
] = opaque
;
398 /* size is the word size in byte */
399 int register_ioport_write(int start
, int length
, int size
,
400 IOPortWriteFunc
*func
, void *opaque
)
406 } else if (size
== 2) {
408 } else if (size
== 4) {
411 hw_error("register_ioport_write: invalid size");
414 for(i
= start
; i
< start
+ length
; i
+= size
) {
415 ioport_write_table
[bsize
][i
] = func
;
416 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
417 hw_error("register_ioport_write: invalid opaque");
418 ioport_opaque
[i
] = opaque
;
423 void isa_unassign_ioport(int start
, int length
)
427 for(i
= start
; i
< start
+ length
; i
++) {
428 ioport_read_table
[0][i
] = default_ioport_readb
;
429 ioport_read_table
[1][i
] = default_ioport_readw
;
430 ioport_read_table
[2][i
] = default_ioport_readl
;
432 ioport_write_table
[0][i
] = default_ioport_writeb
;
433 ioport_write_table
[1][i
] = default_ioport_writew
;
434 ioport_write_table
[2][i
] = default_ioport_writel
;
436 ioport_opaque
[i
] = NULL
;
440 /***********************************************************/
442 void cpu_outb(CPUState
*env
, int addr
, int val
)
444 LOG_IOPORT("outb: %04x %02x\n", addr
, val
);
445 ioport_write(0, addr
, val
);
448 env
->last_io_time
= cpu_get_time_fast();
452 void cpu_outw(CPUState
*env
, int addr
, int val
)
454 LOG_IOPORT("outw: %04x %04x\n", addr
, val
);
455 ioport_write(1, addr
, val
);
458 env
->last_io_time
= cpu_get_time_fast();
462 void cpu_outl(CPUState
*env
, int addr
, int val
)
464 LOG_IOPORT("outl: %04x %08x\n", addr
, val
);
465 ioport_write(2, addr
, val
);
468 env
->last_io_time
= cpu_get_time_fast();
472 int cpu_inb(CPUState
*env
, int addr
)
475 val
= ioport_read(0, addr
);
476 LOG_IOPORT("inb : %04x %02x\n", addr
, val
);
479 env
->last_io_time
= cpu_get_time_fast();
484 int cpu_inw(CPUState
*env
, int addr
)
487 val
= ioport_read(1, addr
);
488 LOG_IOPORT("inw : %04x %04x\n", addr
, val
);
491 env
->last_io_time
= cpu_get_time_fast();
496 int cpu_inl(CPUState
*env
, int addr
)
499 val
= ioport_read(2, addr
);
500 LOG_IOPORT("inl : %04x %08x\n", addr
, val
);
503 env
->last_io_time
= cpu_get_time_fast();
508 /***********************************************************/
509 void hw_error(const char *fmt
, ...)
515 fprintf(stderr
, "qemu: hardware error: ");
516 vfprintf(stderr
, fmt
, ap
);
517 fprintf(stderr
, "\n");
518 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
519 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
521 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
523 cpu_dump_state(env
, stderr
, fprintf
, 0);
533 static QEMUBalloonEvent
*qemu_balloon_event
;
534 void *qemu_balloon_event_opaque
;
536 void qemu_add_balloon_handler(QEMUBalloonEvent
*func
, void *opaque
)
538 qemu_balloon_event
= func
;
539 qemu_balloon_event_opaque
= opaque
;
542 void qemu_balloon(ram_addr_t target
)
544 if (qemu_balloon_event
)
545 qemu_balloon_event(qemu_balloon_event_opaque
, target
);
548 ram_addr_t
qemu_balloon_status(void)
550 if (qemu_balloon_event
)
551 return qemu_balloon_event(qemu_balloon_event_opaque
, 0);
555 /***********************************************************/
558 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
559 static void *qemu_put_kbd_event_opaque
;
560 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
561 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
563 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
565 qemu_put_kbd_event_opaque
= opaque
;
566 qemu_put_kbd_event
= func
;
569 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
570 void *opaque
, int absolute
,
573 QEMUPutMouseEntry
*s
, *cursor
;
575 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
577 s
->qemu_put_mouse_event
= func
;
578 s
->qemu_put_mouse_event_opaque
= opaque
;
579 s
->qemu_put_mouse_event_absolute
= absolute
;
580 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
583 if (!qemu_put_mouse_event_head
) {
584 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
588 cursor
= qemu_put_mouse_event_head
;
589 while (cursor
->next
!= NULL
)
590 cursor
= cursor
->next
;
593 qemu_put_mouse_event_current
= s
;
598 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
600 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
602 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
605 cursor
= qemu_put_mouse_event_head
;
606 while (cursor
!= NULL
&& cursor
!= entry
) {
608 cursor
= cursor
->next
;
611 if (cursor
== NULL
) // does not exist or list empty
613 else if (prev
== NULL
) { // entry is head
614 qemu_put_mouse_event_head
= cursor
->next
;
615 if (qemu_put_mouse_event_current
== entry
)
616 qemu_put_mouse_event_current
= cursor
->next
;
617 qemu_free(entry
->qemu_put_mouse_event_name
);
622 prev
->next
= entry
->next
;
624 if (qemu_put_mouse_event_current
== entry
)
625 qemu_put_mouse_event_current
= prev
;
627 qemu_free(entry
->qemu_put_mouse_event_name
);
631 void kbd_put_keycode(int keycode
)
633 if (qemu_put_kbd_event
) {
634 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
638 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
640 QEMUPutMouseEvent
*mouse_event
;
641 void *mouse_event_opaque
;
644 if (!qemu_put_mouse_event_current
) {
649 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
651 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
654 if (graphic_rotate
) {
655 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
658 width
= graphic_width
- 1;
659 mouse_event(mouse_event_opaque
,
660 width
- dy
, dx
, dz
, buttons_state
);
662 mouse_event(mouse_event_opaque
,
663 dx
, dy
, dz
, buttons_state
);
667 int kbd_mouse_is_absolute(void)
669 if (!qemu_put_mouse_event_current
)
672 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
675 void do_info_mice(Monitor
*mon
)
677 QEMUPutMouseEntry
*cursor
;
680 if (!qemu_put_mouse_event_head
) {
681 monitor_printf(mon
, "No mouse devices connected\n");
685 monitor_printf(mon
, "Mouse devices available:\n");
686 cursor
= qemu_put_mouse_event_head
;
687 while (cursor
!= NULL
) {
688 monitor_printf(mon
, "%c Mouse #%d: %s\n",
689 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
690 index
, cursor
->qemu_put_mouse_event_name
);
692 cursor
= cursor
->next
;
696 void do_mouse_set(Monitor
*mon
, int index
)
698 QEMUPutMouseEntry
*cursor
;
701 if (!qemu_put_mouse_event_head
) {
702 monitor_printf(mon
, "No mouse devices connected\n");
706 cursor
= qemu_put_mouse_event_head
;
707 while (cursor
!= NULL
&& index
!= i
) {
709 cursor
= cursor
->next
;
713 qemu_put_mouse_event_current
= cursor
;
715 monitor_printf(mon
, "Mouse at given index not found\n");
718 /* compute with 96 bit intermediate result: (a*b)/c */
719 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
724 #ifdef WORDS_BIGENDIAN
734 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
735 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
738 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
742 /***********************************************************/
743 /* real time host monotonic timer */
745 #define QEMU_TIMER_BASE 1000000000LL
749 static int64_t clock_freq
;
751 static void init_get_clock(void)
755 ret
= QueryPerformanceFrequency(&freq
);
757 fprintf(stderr
, "Could not calibrate ticks\n");
760 clock_freq
= freq
.QuadPart
;
763 static int64_t get_clock(void)
766 QueryPerformanceCounter(&ti
);
767 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
772 static int use_rt_clock
;
774 static void init_get_clock(void)
777 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
778 || defined(__DragonFly__)
781 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
788 static int64_t get_clock(void)
790 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
791 || defined(__DragonFly__)
794 clock_gettime(CLOCK_MONOTONIC
, &ts
);
795 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
799 /* XXX: using gettimeofday leads to problems if the date
800 changes, so it should be avoided. */
802 gettimeofday(&tv
, NULL
);
803 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
808 /* Return the virtual CPU time, based on the instruction counter. */
809 static int64_t cpu_get_icount(void)
812 CPUState
*env
= cpu_single_env
;;
813 icount
= qemu_icount
;
816 fprintf(stderr
, "Bad clock read\n");
817 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
819 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
822 /***********************************************************/
823 /* guest cycle counter */
825 static int64_t cpu_ticks_prev
;
826 static int64_t cpu_ticks_offset
;
827 static int64_t cpu_clock_offset
;
828 static int cpu_ticks_enabled
;
830 /* return the host CPU cycle counter and handle stop/restart */
831 int64_t cpu_get_ticks(void)
834 return cpu_get_icount();
836 if (!cpu_ticks_enabled
) {
837 return cpu_ticks_offset
;
840 ticks
= cpu_get_real_ticks();
841 if (cpu_ticks_prev
> ticks
) {
842 /* Note: non increasing ticks may happen if the host uses
844 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
846 cpu_ticks_prev
= ticks
;
847 return ticks
+ cpu_ticks_offset
;
851 /* return the host CPU monotonic timer and handle stop/restart */
852 static int64_t cpu_get_clock(void)
855 if (!cpu_ticks_enabled
) {
856 return cpu_clock_offset
;
859 return ti
+ cpu_clock_offset
;
863 /* enable cpu_get_ticks() */
864 void cpu_enable_ticks(void)
866 if (!cpu_ticks_enabled
) {
867 cpu_ticks_offset
-= cpu_get_real_ticks();
868 cpu_clock_offset
-= get_clock();
869 cpu_ticks_enabled
= 1;
873 /* disable cpu_get_ticks() : the clock is stopped. You must not call
874 cpu_get_ticks() after that. */
875 void cpu_disable_ticks(void)
877 if (cpu_ticks_enabled
) {
878 cpu_ticks_offset
= cpu_get_ticks();
879 cpu_clock_offset
= cpu_get_clock();
880 cpu_ticks_enabled
= 0;
884 /***********************************************************/
887 #define QEMU_TIMER_REALTIME 0
888 #define QEMU_TIMER_VIRTUAL 1
892 /* XXX: add frequency */
900 struct QEMUTimer
*next
;
903 struct qemu_alarm_timer
{
907 int (*start
)(struct qemu_alarm_timer
*t
);
908 void (*stop
)(struct qemu_alarm_timer
*t
);
909 void (*rearm
)(struct qemu_alarm_timer
*t
);
913 #define ALARM_FLAG_DYNTICKS 0x1
914 #define ALARM_FLAG_EXPIRED 0x2
916 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
918 return t
&& (t
->flags
& ALARM_FLAG_DYNTICKS
);
921 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
923 if (!alarm_has_dynticks(t
))
929 /* TODO: MIN_TIMER_REARM_US should be optimized */
930 #define MIN_TIMER_REARM_US 250
932 static struct qemu_alarm_timer
*alarm_timer
;
936 struct qemu_alarm_win32
{
939 } alarm_win32_data
= {0, -1};
941 static int win32_start_timer(struct qemu_alarm_timer
*t
);
942 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
943 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
947 static int unix_start_timer(struct qemu_alarm_timer
*t
);
948 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
952 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
953 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
954 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
956 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
957 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
959 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
960 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
962 #endif /* __linux__ */
966 /* Correlation between real and virtual time is always going to be
967 fairly approximate, so ignore small variation.
968 When the guest is idle real and virtual time will be aligned in
970 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
972 static void icount_adjust(void)
977 static int64_t last_delta
;
978 /* If the VM is not running, then do nothing. */
982 cur_time
= cpu_get_clock();
983 cur_icount
= qemu_get_clock(vm_clock
);
984 delta
= cur_icount
- cur_time
;
985 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
987 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
988 && icount_time_shift
> 0) {
989 /* The guest is getting too far ahead. Slow time down. */
993 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
994 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
995 /* The guest is getting too far behind. Speed time up. */
999 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
1002 static void icount_adjust_rt(void * opaque
)
1004 qemu_mod_timer(icount_rt_timer
,
1005 qemu_get_clock(rt_clock
) + 1000);
1009 static void icount_adjust_vm(void * opaque
)
1011 qemu_mod_timer(icount_vm_timer
,
1012 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
1016 static void init_icount_adjust(void)
1018 /* Have both realtime and virtual time triggers for speed adjustment.
1019 The realtime trigger catches emulated time passing too slowly,
1020 the virtual time trigger catches emulated time passing too fast.
1021 Realtime triggers occur even when idle, so use them less frequently
1022 than VM triggers. */
1023 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
1024 qemu_mod_timer(icount_rt_timer
,
1025 qemu_get_clock(rt_clock
) + 1000);
1026 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
1027 qemu_mod_timer(icount_vm_timer
,
1028 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
1031 static struct qemu_alarm_timer alarm_timers
[] = {
1034 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
1035 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
1036 /* HPET - if available - is preferred */
1037 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
1038 /* ...otherwise try RTC */
1039 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
1041 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
1043 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
1044 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
1045 {"win32", 0, win32_start_timer
,
1046 win32_stop_timer
, NULL
, &alarm_win32_data
},
1051 static void show_available_alarms(void)
1055 printf("Available alarm timers, in order of precedence:\n");
1056 for (i
= 0; alarm_timers
[i
].name
; i
++)
1057 printf("%s\n", alarm_timers
[i
].name
);
1060 static void configure_alarms(char const *opt
)
1064 int count
= ARRAY_SIZE(alarm_timers
) - 1;
1067 struct qemu_alarm_timer tmp
;
1069 if (!strcmp(opt
, "?")) {
1070 show_available_alarms();
1076 /* Reorder the array */
1077 name
= strtok(arg
, ",");
1079 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
1080 if (!strcmp(alarm_timers
[i
].name
, name
))
1085 fprintf(stderr
, "Unknown clock %s\n", name
);
1094 tmp
= alarm_timers
[i
];
1095 alarm_timers
[i
] = alarm_timers
[cur
];
1096 alarm_timers
[cur
] = tmp
;
1100 name
= strtok(NULL
, ",");
1106 /* Disable remaining timers */
1107 for (i
= cur
; i
< count
; i
++)
1108 alarm_timers
[i
].name
= NULL
;
1110 show_available_alarms();
1115 QEMUClock
*rt_clock
;
1116 QEMUClock
*vm_clock
;
1118 static QEMUTimer
*active_timers
[2];
1120 static QEMUClock
*qemu_new_clock(int type
)
1123 clock
= qemu_mallocz(sizeof(QEMUClock
));
1128 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
1132 ts
= qemu_mallocz(sizeof(QEMUTimer
));
1135 ts
->opaque
= opaque
;
1139 void qemu_free_timer(QEMUTimer
*ts
)
1144 /* stop a timer, but do not dealloc it */
1145 void qemu_del_timer(QEMUTimer
*ts
)
1149 /* NOTE: this code must be signal safe because
1150 qemu_timer_expired() can be called from a signal. */
1151 pt
= &active_timers
[ts
->clock
->type
];
1164 /* modify the current timer so that it will be fired when current_time
1165 >= expire_time. The corresponding callback will be called. */
1166 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
1172 /* add the timer in the sorted list */
1173 /* NOTE: this code must be signal safe because
1174 qemu_timer_expired() can be called from a signal. */
1175 pt
= &active_timers
[ts
->clock
->type
];
1180 if (t
->expire_time
> expire_time
)
1184 ts
->expire_time
= expire_time
;
1188 /* Rearm if necessary */
1189 if (pt
== &active_timers
[ts
->clock
->type
]) {
1190 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
1191 qemu_rearm_alarm_timer(alarm_timer
);
1193 /* Interrupt execution to force deadline recalculation. */
1195 qemu_notify_event();
1199 int qemu_timer_pending(QEMUTimer
*ts
)
1202 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1209 static inline int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1213 return (timer_head
->expire_time
<= current_time
);
1216 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1222 if (!ts
|| ts
->expire_time
> current_time
)
1224 /* remove timer from the list before calling the callback */
1225 *ptimer_head
= ts
->next
;
1228 /* run the callback (the timer list can be modified) */
1233 int64_t qemu_get_clock(QEMUClock
*clock
)
1235 switch(clock
->type
) {
1236 case QEMU_TIMER_REALTIME
:
1237 return get_clock() / 1000000;
1239 case QEMU_TIMER_VIRTUAL
:
1241 return cpu_get_icount();
1243 return cpu_get_clock();
1248 static void init_timers(void)
1251 ticks_per_sec
= QEMU_TIMER_BASE
;
1252 rt_clock
= qemu_new_clock(QEMU_TIMER_REALTIME
);
1253 vm_clock
= qemu_new_clock(QEMU_TIMER_VIRTUAL
);
1257 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1259 uint64_t expire_time
;
1261 if (qemu_timer_pending(ts
)) {
1262 expire_time
= ts
->expire_time
;
1266 qemu_put_be64(f
, expire_time
);
1269 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1271 uint64_t expire_time
;
1273 expire_time
= qemu_get_be64(f
);
1274 if (expire_time
!= -1) {
1275 qemu_mod_timer(ts
, expire_time
);
1281 static void timer_save(QEMUFile
*f
, void *opaque
)
1283 if (cpu_ticks_enabled
) {
1284 hw_error("cannot save state if virtual timers are running");
1286 qemu_put_be64(f
, cpu_ticks_offset
);
1287 qemu_put_be64(f
, ticks_per_sec
);
1288 qemu_put_be64(f
, cpu_clock_offset
);
1291 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1293 if (version_id
!= 1 && version_id
!= 2)
1295 if (cpu_ticks_enabled
) {
1298 cpu_ticks_offset
=qemu_get_be64(f
);
1299 ticks_per_sec
=qemu_get_be64(f
);
1300 if (version_id
== 2) {
1301 cpu_clock_offset
=qemu_get_be64(f
);
1306 static void qemu_event_increment(void);
1309 static void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1310 DWORD_PTR dwUser
, DWORD_PTR dw1
,
1313 static void host_alarm_handler(int host_signum
)
1317 #define DISP_FREQ 1000
1319 static int64_t delta_min
= INT64_MAX
;
1320 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1322 ti
= qemu_get_clock(vm_clock
);
1323 if (last_clock
!= 0) {
1324 delta
= ti
- last_clock
;
1325 if (delta
< delta_min
)
1327 if (delta
> delta_max
)
1330 if (++count
== DISP_FREQ
) {
1331 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1332 muldiv64(delta_min
, 1000000, ticks_per_sec
),
1333 muldiv64(delta_max
, 1000000, ticks_per_sec
),
1334 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, ticks_per_sec
),
1335 (double)ticks_per_sec
/ ((double)delta_cum
/ DISP_FREQ
));
1337 delta_min
= INT64_MAX
;
1345 if (alarm_has_dynticks(alarm_timer
) ||
1347 qemu_timer_expired(active_timers
[QEMU_TIMER_VIRTUAL
],
1348 qemu_get_clock(vm_clock
))) ||
1349 qemu_timer_expired(active_timers
[QEMU_TIMER_REALTIME
],
1350 qemu_get_clock(rt_clock
))) {
1351 qemu_event_increment();
1352 if (alarm_timer
) alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1354 #ifndef CONFIG_IOTHREAD
1356 /* stop the currently executing cpu because a timer occured */
1359 if (next_cpu
->kqemu_enabled
) {
1360 kqemu_cpu_interrupt(next_cpu
);
1365 timer_alarm_pending
= 1;
1366 qemu_notify_event();
1370 static int64_t qemu_next_deadline(void)
1374 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1375 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1376 qemu_get_clock(vm_clock
);
1378 /* To avoid problems with overflow limit this to 2^32. */
1388 #if defined(__linux__) || defined(_WIN32)
1389 static uint64_t qemu_next_deadline_dyntick(void)
1397 delta
= (qemu_next_deadline() + 999) / 1000;
1399 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1400 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1401 qemu_get_clock(rt_clock
))*1000;
1402 if (rtdelta
< delta
)
1406 if (delta
< MIN_TIMER_REARM_US
)
1407 delta
= MIN_TIMER_REARM_US
;
1415 /* Sets a specific flag */
1416 static int fcntl_setfl(int fd
, int flag
)
1420 flags
= fcntl(fd
, F_GETFL
);
1424 if (fcntl(fd
, F_SETFL
, flags
| flag
) == -1)
1430 #if defined(__linux__)
1432 #define RTC_FREQ 1024
1434 static void enable_sigio_timer(int fd
)
1436 struct sigaction act
;
1439 sigfillset(&act
.sa_mask
);
1441 act
.sa_handler
= host_alarm_handler
;
1443 sigaction(SIGIO
, &act
, NULL
);
1444 fcntl_setfl(fd
, O_ASYNC
);
1445 fcntl(fd
, F_SETOWN
, getpid());
1448 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1450 struct hpet_info info
;
1453 fd
= open("/dev/hpet", O_RDONLY
);
1458 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1460 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1461 "error, but for better emulation accuracy type:\n"
1462 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1466 /* Check capabilities */
1467 r
= ioctl(fd
, HPET_INFO
, &info
);
1471 /* Enable periodic mode */
1472 r
= ioctl(fd
, HPET_EPI
, 0);
1473 if (info
.hi_flags
&& (r
< 0))
1476 /* Enable interrupt */
1477 r
= ioctl(fd
, HPET_IE_ON
, 0);
1481 enable_sigio_timer(fd
);
1482 t
->priv
= (void *)(long)fd
;
1490 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1492 int fd
= (long)t
->priv
;
1497 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1500 unsigned long current_rtc_freq
= 0;
1502 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1505 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1506 if (current_rtc_freq
!= RTC_FREQ
&&
1507 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1508 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1509 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1510 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1513 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1519 enable_sigio_timer(rtc_fd
);
1521 t
->priv
= (void *)(long)rtc_fd
;
1526 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1528 int rtc_fd
= (long)t
->priv
;
1533 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1537 struct sigaction act
;
1539 sigfillset(&act
.sa_mask
);
1541 act
.sa_handler
= host_alarm_handler
;
1543 sigaction(SIGALRM
, &act
, NULL
);
1546 * Initialize ev struct to 0 to avoid valgrind complaining
1547 * about uninitialized data in timer_create call
1549 memset(&ev
, 0, sizeof(ev
));
1550 ev
.sigev_value
.sival_int
= 0;
1551 ev
.sigev_notify
= SIGEV_SIGNAL
;
1552 ev
.sigev_signo
= SIGALRM
;
1554 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1555 perror("timer_create");
1557 /* disable dynticks */
1558 fprintf(stderr
, "Dynamic Ticks disabled\n");
1563 t
->priv
= (void *)(long)host_timer
;
1568 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1570 timer_t host_timer
= (timer_t
)(long)t
->priv
;
1572 timer_delete(host_timer
);
1575 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1577 timer_t host_timer
= (timer_t
)(long)t
->priv
;
1578 struct itimerspec timeout
;
1579 int64_t nearest_delta_us
= INT64_MAX
;
1582 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1583 !active_timers
[QEMU_TIMER_VIRTUAL
])
1586 nearest_delta_us
= qemu_next_deadline_dyntick();
1588 /* check whether a timer is already running */
1589 if (timer_gettime(host_timer
, &timeout
)) {
1591 fprintf(stderr
, "Internal timer error: aborting\n");
1594 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1595 if (current_us
&& current_us
<= nearest_delta_us
)
1598 timeout
.it_interval
.tv_sec
= 0;
1599 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1600 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1601 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1602 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1604 fprintf(stderr
, "Internal timer error: aborting\n");
1609 #endif /* defined(__linux__) */
1611 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1613 struct sigaction act
;
1614 struct itimerval itv
;
1618 sigfillset(&act
.sa_mask
);
1620 act
.sa_handler
= host_alarm_handler
;
1622 sigaction(SIGALRM
, &act
, NULL
);
1624 itv
.it_interval
.tv_sec
= 0;
1625 /* for i386 kernel 2.6 to get 1 ms */
1626 itv
.it_interval
.tv_usec
= 999;
1627 itv
.it_value
.tv_sec
= 0;
1628 itv
.it_value
.tv_usec
= 10 * 1000;
1630 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1637 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1639 struct itimerval itv
;
1641 memset(&itv
, 0, sizeof(itv
));
1642 setitimer(ITIMER_REAL
, &itv
, NULL
);
1645 #endif /* !defined(_WIN32) */
1650 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1653 struct qemu_alarm_win32
*data
= t
->priv
;
1656 memset(&tc
, 0, sizeof(tc
));
1657 timeGetDevCaps(&tc
, sizeof(tc
));
1659 if (data
->period
< tc
.wPeriodMin
)
1660 data
->period
= tc
.wPeriodMin
;
1662 timeBeginPeriod(data
->period
);
1664 flags
= TIME_CALLBACK_FUNCTION
;
1665 if (alarm_has_dynticks(t
))
1666 flags
|= TIME_ONESHOT
;
1668 flags
|= TIME_PERIODIC
;
1670 data
->timerId
= timeSetEvent(1, // interval (ms)
1671 data
->period
, // resolution
1672 host_alarm_handler
, // function
1673 (DWORD
)t
, // parameter
1676 if (!data
->timerId
) {
1677 perror("Failed to initialize win32 alarm timer");
1678 timeEndPeriod(data
->period
);
1685 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1687 struct qemu_alarm_win32
*data
= t
->priv
;
1689 timeKillEvent(data
->timerId
);
1690 timeEndPeriod(data
->period
);
1693 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1695 struct qemu_alarm_win32
*data
= t
->priv
;
1696 uint64_t nearest_delta_us
;
1698 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1699 !active_timers
[QEMU_TIMER_VIRTUAL
])
1702 nearest_delta_us
= qemu_next_deadline_dyntick();
1703 nearest_delta_us
/= 1000;
1705 timeKillEvent(data
->timerId
);
1707 data
->timerId
= timeSetEvent(1,
1711 TIME_ONESHOT
| TIME_PERIODIC
);
1713 if (!data
->timerId
) {
1714 perror("Failed to re-arm win32 alarm timer");
1716 timeEndPeriod(data
->period
);
1723 static int init_timer_alarm(void)
1725 struct qemu_alarm_timer
*t
= NULL
;
1728 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1729 t
= &alarm_timers
[i
];
1749 static void quit_timers(void)
1751 alarm_timer
->stop(alarm_timer
);
1755 /***********************************************************/
1756 /* host time/date access */
1757 void qemu_get_timedate(struct tm
*tm
, int offset
)
1764 if (rtc_date_offset
== -1) {
1768 ret
= localtime(&ti
);
1770 ti
-= rtc_date_offset
;
1774 memcpy(tm
, ret
, sizeof(struct tm
));
1777 int qemu_timedate_diff(struct tm
*tm
)
1781 if (rtc_date_offset
== -1)
1783 seconds
= mktimegm(tm
);
1785 seconds
= mktime(tm
);
1787 seconds
= mktimegm(tm
) + rtc_date_offset
;
1789 return seconds
- time(NULL
);
1793 static void socket_cleanup(void)
1798 static int socket_init(void)
1803 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
1805 err
= WSAGetLastError();
1806 fprintf(stderr
, "WSAStartup: %d\n", err
);
1809 atexit(socket_cleanup
);
1814 int get_param_value(char *buf
, int buf_size
,
1815 const char *tag
, const char *str
)
1822 p
= get_opt_name(option
, sizeof(option
), p
, '=');
1826 if (!strcmp(tag
, option
)) {
1827 (void)get_opt_value(buf
, buf_size
, p
);
1830 p
= get_opt_value(NULL
, 0, p
);
1839 int check_params(const char * const *params
, const char *str
)
1841 int name_buf_size
= 1;
1847 for (i
= 0; params
[i
] != NULL
; i
++) {
1848 len
= strlen(params
[i
]) + 1;
1849 if (len
> name_buf_size
) {
1850 name_buf_size
= len
;
1853 name_buf
= qemu_malloc(name_buf_size
);
1856 while (*p
!= '\0') {
1857 p
= get_opt_name(name_buf
, name_buf_size
, p
, '=');
1863 for(i
= 0; params
[i
] != NULL
; i
++)
1864 if (!strcmp(params
[i
], name_buf
))
1866 if (params
[i
] == NULL
) {
1870 p
= get_opt_value(NULL
, 0, p
);
1876 qemu_free(name_buf
);
1880 /***********************************************************/
1881 /* Bluetooth support */
1884 static struct HCIInfo
*hci_table
[MAX_NICS
];
1886 static struct bt_vlan_s
{
1887 struct bt_scatternet_s net
;
1889 struct bt_vlan_s
*next
;
1892 /* find or alloc a new bluetooth "VLAN" */
1893 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
1895 struct bt_vlan_s
**pvlan
, *vlan
;
1896 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
1900 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
1902 pvlan
= &first_bt_vlan
;
1903 while (*pvlan
!= NULL
)
1904 pvlan
= &(*pvlan
)->next
;
1909 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
1913 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
1918 static struct HCIInfo null_hci
= {
1919 .cmd_send
= null_hci_send
,
1920 .sco_send
= null_hci_send
,
1921 .acl_send
= null_hci_send
,
1922 .bdaddr_set
= null_hci_addr_set
,
1925 struct HCIInfo
*qemu_next_hci(void)
1927 if (cur_hci
== nb_hcis
)
1930 return hci_table
[cur_hci
++];
1933 static struct HCIInfo
*hci_init(const char *str
)
1936 struct bt_scatternet_s
*vlan
= 0;
1938 if (!strcmp(str
, "null"))
1941 else if (!strncmp(str
, "host", 4) && (str
[4] == '\0' || str
[4] == ':'))
1943 return bt_host_hci(str
[4] ? str
+ 5 : "hci0");
1944 else if (!strncmp(str
, "hci", 3)) {
1947 if (!strncmp(str
+ 3, ",vlan=", 6)) {
1948 vlan
= qemu_find_bt_vlan(strtol(str
+ 9, &endp
, 0));
1953 vlan
= qemu_find_bt_vlan(0);
1955 return bt_new_hci(vlan
);
1958 fprintf(stderr
, "qemu: Unknown bluetooth HCI `%s'.\n", str
);
1963 static int bt_hci_parse(const char *str
)
1965 struct HCIInfo
*hci
;
1968 if (nb_hcis
>= MAX_NICS
) {
1969 fprintf(stderr
, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS
);
1973 hci
= hci_init(str
);
1982 bdaddr
.b
[5] = 0x56 + nb_hcis
;
1983 hci
->bdaddr_set(hci
, bdaddr
.b
);
1985 hci_table
[nb_hcis
++] = hci
;
1990 static void bt_vhci_add(int vlan_id
)
1992 struct bt_scatternet_s
*vlan
= qemu_find_bt_vlan(vlan_id
);
1995 fprintf(stderr
, "qemu: warning: adding a VHCI to "
1996 "an empty scatternet %i\n", vlan_id
);
1998 bt_vhci_init(bt_new_hci(vlan
));
2001 static struct bt_device_s
*bt_device_add(const char *opt
)
2003 struct bt_scatternet_s
*vlan
;
2005 char *endp
= strstr(opt
, ",vlan=");
2006 int len
= (endp
? endp
- opt
: strlen(opt
)) + 1;
2009 pstrcpy(devname
, MIN(sizeof(devname
), len
), opt
);
2012 vlan_id
= strtol(endp
+ 6, &endp
, 0);
2014 fprintf(stderr
, "qemu: unrecognised bluetooth vlan Id\n");
2019 vlan
= qemu_find_bt_vlan(vlan_id
);
2022 fprintf(stderr
, "qemu: warning: adding a slave device to "
2023 "an empty scatternet %i\n", vlan_id
);
2025 if (!strcmp(devname
, "keyboard"))
2026 return bt_keyboard_init(vlan
);
2028 fprintf(stderr
, "qemu: unsupported bluetooth device `%s'\n", devname
);
2032 static int bt_parse(const char *opt
)
2034 const char *endp
, *p
;
2037 if (strstart(opt
, "hci", &endp
)) {
2038 if (!*endp
|| *endp
== ',') {
2040 if (!strstart(endp
, ",vlan=", 0))
2043 return bt_hci_parse(opt
);
2045 } else if (strstart(opt
, "vhci", &endp
)) {
2046 if (!*endp
|| *endp
== ',') {
2048 if (strstart(endp
, ",vlan=", &p
)) {
2049 vlan
= strtol(p
, (char **) &endp
, 0);
2051 fprintf(stderr
, "qemu: bad scatternet '%s'\n", p
);
2055 fprintf(stderr
, "qemu: bad parameter '%s'\n", endp
+ 1);
2064 } else if (strstart(opt
, "device:", &endp
))
2065 return !bt_device_add(endp
);
2067 fprintf(stderr
, "qemu: bad bluetooth parameter '%s'\n", opt
);
2071 /***********************************************************/
2072 /* QEMU Block devices */
2074 #define HD_ALIAS "index=%d,media=disk"
2075 #define CDROM_ALIAS "index=2,media=cdrom"
2076 #define FD_ALIAS "index=%d,if=floppy"
2077 #define PFLASH_ALIAS "if=pflash"
2078 #define MTD_ALIAS "if=mtd"
2079 #define SD_ALIAS "index=0,if=sd"
2081 static int drive_opt_get_free_idx(void)
2085 for (index
= 0; index
< MAX_DRIVES
; index
++)
2086 if (!drives_opt
[index
].used
) {
2087 drives_opt
[index
].used
= 1;
2094 static int drive_get_free_idx(void)
2098 for (index
= 0; index
< MAX_DRIVES
; index
++)
2099 if (!drives_table
[index
].used
) {
2100 drives_table
[index
].used
= 1;
2107 int drive_add(const char *file
, const char *fmt
, ...)
2110 int index
= drive_opt_get_free_idx();
2112 if (nb_drives_opt
>= MAX_DRIVES
|| index
== -1) {
2113 fprintf(stderr
, "qemu: too many drives\n");
2117 drives_opt
[index
].file
= file
;
2119 vsnprintf(drives_opt
[index
].opt
,
2120 sizeof(drives_opt
[0].opt
), fmt
, ap
);
2127 void drive_remove(int index
)
2129 drives_opt
[index
].used
= 0;
2133 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
2137 /* seek interface, bus and unit */
2139 for (index
= 0; index
< MAX_DRIVES
; index
++)
2140 if (drives_table
[index
].type
== type
&&
2141 drives_table
[index
].bus
== bus
&&
2142 drives_table
[index
].unit
== unit
&&
2143 drives_table
[index
].used
)
2149 int drive_get_max_bus(BlockInterfaceType type
)
2155 for (index
= 0; index
< nb_drives
; index
++) {
2156 if(drives_table
[index
].type
== type
&&
2157 drives_table
[index
].bus
> max_bus
)
2158 max_bus
= drives_table
[index
].bus
;
2163 const char *drive_get_serial(BlockDriverState
*bdrv
)
2167 for (index
= 0; index
< nb_drives
; index
++)
2168 if (drives_table
[index
].bdrv
== bdrv
)
2169 return drives_table
[index
].serial
;
2174 BlockInterfaceErrorAction
drive_get_onerror(BlockDriverState
*bdrv
)
2178 for (index
= 0; index
< nb_drives
; index
++)
2179 if (drives_table
[index
].bdrv
== bdrv
)
2180 return drives_table
[index
].onerror
;
2182 return BLOCK_ERR_STOP_ENOSPC
;
2185 static void bdrv_format_print(void *opaque
, const char *name
)
2187 fprintf(stderr
, " %s", name
);
2190 void drive_uninit(BlockDriverState
*bdrv
)
2194 for (i
= 0; i
< MAX_DRIVES
; i
++)
2195 if (drives_table
[i
].bdrv
== bdrv
) {
2196 drives_table
[i
].bdrv
= NULL
;
2197 drives_table
[i
].used
= 0;
2198 drive_remove(drives_table
[i
].drive_opt_idx
);
2204 int drive_init(struct drive_opt
*arg
, int snapshot
, void *opaque
)
2210 const char *mediastr
= "";
2211 BlockInterfaceType type
;
2212 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
2213 int bus_id
, unit_id
;
2214 int cyls
, heads
, secs
, translation
;
2215 BlockDriverState
*bdrv
;
2216 BlockDriver
*drv
= NULL
;
2217 QEMUMachine
*machine
= opaque
;
2221 int bdrv_flags
, onerror
;
2222 int drives_table_idx
;
2223 char *str
= arg
->opt
;
2224 static const char * const params
[] = { "bus", "unit", "if", "index",
2225 "cyls", "heads", "secs", "trans",
2226 "media", "snapshot", "file",
2227 "cache", "format", "serial", "werror",
2230 if (check_params(params
, str
) < 0) {
2231 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
2237 cyls
= heads
= secs
= 0;
2240 translation
= BIOS_ATA_TRANSLATION_AUTO
;
2244 if (machine
->use_scsi
) {
2246 max_devs
= MAX_SCSI_DEVS
;
2247 pstrcpy(devname
, sizeof(devname
), "scsi");
2250 max_devs
= MAX_IDE_DEVS
;
2251 pstrcpy(devname
, sizeof(devname
), "ide");
2255 /* extract parameters */
2257 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
2258 bus_id
= strtol(buf
, NULL
, 0);
2260 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
2265 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
2266 unit_id
= strtol(buf
, NULL
, 0);
2268 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
2273 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
2274 pstrcpy(devname
, sizeof(devname
), buf
);
2275 if (!strcmp(buf
, "ide")) {
2277 max_devs
= MAX_IDE_DEVS
;
2278 } else if (!strcmp(buf
, "scsi")) {
2280 max_devs
= MAX_SCSI_DEVS
;
2281 } else if (!strcmp(buf
, "floppy")) {
2284 } else if (!strcmp(buf
, "pflash")) {
2287 } else if (!strcmp(buf
, "mtd")) {
2290 } else if (!strcmp(buf
, "sd")) {
2293 } else if (!strcmp(buf
, "virtio")) {
2296 } else if (!strcmp(buf
, "xen")) {
2300 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
2305 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
2306 index
= strtol(buf
, NULL
, 0);
2308 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
2313 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
2314 cyls
= strtol(buf
, NULL
, 0);
2317 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
2318 heads
= strtol(buf
, NULL
, 0);
2321 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
2322 secs
= strtol(buf
, NULL
, 0);
2325 if (cyls
|| heads
|| secs
) {
2326 if (cyls
< 1 || cyls
> 16383) {
2327 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
2330 if (heads
< 1 || heads
> 16) {
2331 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
2334 if (secs
< 1 || secs
> 63) {
2335 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
2340 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
2343 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2347 if (!strcmp(buf
, "none"))
2348 translation
= BIOS_ATA_TRANSLATION_NONE
;
2349 else if (!strcmp(buf
, "lba"))
2350 translation
= BIOS_ATA_TRANSLATION_LBA
;
2351 else if (!strcmp(buf
, "auto"))
2352 translation
= BIOS_ATA_TRANSLATION_AUTO
;
2354 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
2359 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
2360 if (!strcmp(buf
, "disk")) {
2362 } else if (!strcmp(buf
, "cdrom")) {
2363 if (cyls
|| secs
|| heads
) {
2365 "qemu: '%s' invalid physical CHS format\n", str
);
2368 media
= MEDIA_CDROM
;
2370 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
2375 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
2376 if (!strcmp(buf
, "on"))
2378 else if (!strcmp(buf
, "off"))
2381 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
2386 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
2387 if (!strcmp(buf
, "off") || !strcmp(buf
, "none"))
2389 else if (!strcmp(buf
, "writethrough"))
2391 else if (!strcmp(buf
, "writeback"))
2394 fprintf(stderr
, "qemu: invalid cache option\n");
2399 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
2400 if (strcmp(buf
, "?") == 0) {
2401 fprintf(stderr
, "qemu: Supported formats:");
2402 bdrv_iterate_format(bdrv_format_print
, NULL
);
2403 fprintf(stderr
, "\n");
2406 drv
= bdrv_find_format(buf
);
2408 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
2413 if (arg
->file
== NULL
)
2414 get_param_value(file
, sizeof(file
), "file", str
);
2416 pstrcpy(file
, sizeof(file
), arg
->file
);
2418 if (!get_param_value(serial
, sizeof(serial
), "serial", str
))
2419 memset(serial
, 0, sizeof(serial
));
2421 onerror
= BLOCK_ERR_STOP_ENOSPC
;
2422 if (get_param_value(buf
, sizeof(serial
), "werror", str
)) {
2423 if (type
!= IF_IDE
&& type
!= IF_SCSI
&& type
!= IF_VIRTIO
) {
2424 fprintf(stderr
, "werror is no supported by this format\n");
2427 if (!strcmp(buf
, "ignore"))
2428 onerror
= BLOCK_ERR_IGNORE
;
2429 else if (!strcmp(buf
, "enospc"))
2430 onerror
= BLOCK_ERR_STOP_ENOSPC
;
2431 else if (!strcmp(buf
, "stop"))
2432 onerror
= BLOCK_ERR_STOP_ANY
;
2433 else if (!strcmp(buf
, "report"))
2434 onerror
= BLOCK_ERR_REPORT
;
2436 fprintf(stderr
, "qemu: '%s' invalid write error action\n", buf
);
2441 /* compute bus and unit according index */
2444 if (bus_id
!= 0 || unit_id
!= -1) {
2446 "qemu: '%s' index cannot be used with bus and unit\n", str
);
2454 unit_id
= index
% max_devs
;
2455 bus_id
= index
/ max_devs
;
2459 /* if user doesn't specify a unit_id,
2460 * try to find the first free
2463 if (unit_id
== -1) {
2465 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
2467 if (max_devs
&& unit_id
>= max_devs
) {
2468 unit_id
-= max_devs
;
2476 if (max_devs
&& unit_id
>= max_devs
) {
2477 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
2478 str
, unit_id
, max_devs
- 1);
2483 * ignore multiple definitions
2486 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
2491 if (type
== IF_IDE
|| type
== IF_SCSI
)
2492 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
2494 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
2495 devname
, bus_id
, mediastr
, unit_id
);
2497 snprintf(buf
, sizeof(buf
), "%s%s%i",
2498 devname
, mediastr
, unit_id
);
2499 bdrv
= bdrv_new(buf
);
2500 drives_table_idx
= drive_get_free_idx();
2501 drives_table
[drives_table_idx
].bdrv
= bdrv
;
2502 drives_table
[drives_table_idx
].type
= type
;
2503 drives_table
[drives_table_idx
].bus
= bus_id
;
2504 drives_table
[drives_table_idx
].unit
= unit_id
;
2505 drives_table
[drives_table_idx
].onerror
= onerror
;
2506 drives_table
[drives_table_idx
].drive_opt_idx
= arg
- drives_opt
;
2507 strncpy(drives_table
[drives_table_idx
].serial
, serial
, sizeof(serial
));
2517 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
2518 bdrv_set_translation_hint(bdrv
, translation
);
2522 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
2527 /* FIXME: This isn't really a floppy, but it's a reasonable
2530 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
2543 bdrv_flags
|= BDRV_O_SNAPSHOT
;
2544 cache
= 2; /* always use write-back with snapshot */
2546 if (cache
== 0) /* no caching */
2547 bdrv_flags
|= BDRV_O_NOCACHE
;
2548 else if (cache
== 2) /* write-back */
2549 bdrv_flags
|= BDRV_O_CACHE_WB
;
2550 else if (cache
== 3) /* not specified */
2551 bdrv_flags
|= BDRV_O_CACHE_DEF
;
2552 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0) {
2553 fprintf(stderr
, "qemu: could not open disk image %s\n",
2557 if (bdrv_key_required(bdrv
))
2559 return drives_table_idx
;
2562 static void numa_add(const char *optarg
)
2566 unsigned long long value
, endvalue
;
2569 optarg
= get_opt_name(option
, 128, optarg
, ',') + 1;
2570 if (!strcmp(option
, "node")) {
2571 if (get_param_value(option
, 128, "nodeid", optarg
) == 0) {
2572 nodenr
= nb_numa_nodes
;
2574 nodenr
= strtoull(option
, NULL
, 10);
2577 if (get_param_value(option
, 128, "mem", optarg
) == 0) {
2578 node_mem
[nodenr
] = 0;
2580 value
= strtoull(option
, &endptr
, 0);
2582 case 0: case 'M': case 'm':
2589 node_mem
[nodenr
] = value
;
2591 if (get_param_value(option
, 128, "cpus", optarg
) == 0) {
2592 node_cpumask
[nodenr
] = 0;
2594 value
= strtoull(option
, &endptr
, 10);
2597 fprintf(stderr
, "only 64 CPUs in NUMA mode supported.\n");
2599 if (*endptr
== '-') {
2600 endvalue
= strtoull(endptr
+1, &endptr
, 10);
2601 if (endvalue
>= 63) {
2604 "only 63 CPUs in NUMA mode supported.\n");
2606 value
= (1 << (endvalue
+ 1)) - (1 << value
);
2611 node_cpumask
[nodenr
] = value
;
2618 /***********************************************************/
2621 static USBPort
*used_usb_ports
;
2622 static USBPort
*free_usb_ports
;
2624 /* ??? Maybe change this to register a hub to keep track of the topology. */
2625 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
2626 usb_attachfn attach
)
2628 port
->opaque
= opaque
;
2629 port
->index
= index
;
2630 port
->attach
= attach
;
2631 port
->next
= free_usb_ports
;
2632 free_usb_ports
= port
;
2635 int usb_device_add_dev(USBDevice
*dev
)
2639 /* Find a USB port to add the device to. */
2640 port
= free_usb_ports
;
2644 /* Create a new hub and chain it on. */
2645 free_usb_ports
= NULL
;
2646 port
->next
= used_usb_ports
;
2647 used_usb_ports
= port
;
2649 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
2650 usb_attach(port
, hub
);
2651 port
= free_usb_ports
;
2654 free_usb_ports
= port
->next
;
2655 port
->next
= used_usb_ports
;
2656 used_usb_ports
= port
;
2657 usb_attach(port
, dev
);
2661 static void usb_msd_password_cb(void *opaque
, int err
)
2663 USBDevice
*dev
= opaque
;
2666 usb_device_add_dev(dev
);
2668 dev
->handle_destroy(dev
);
2671 static int usb_device_add(const char *devname
, int is_hotplug
)
2676 if (!free_usb_ports
)
2679 if (strstart(devname
, "host:", &p
)) {
2680 dev
= usb_host_device_open(p
);
2681 } else if (!strcmp(devname
, "mouse")) {
2682 dev
= usb_mouse_init();
2683 } else if (!strcmp(devname
, "tablet")) {
2684 dev
= usb_tablet_init();
2685 } else if (!strcmp(devname
, "keyboard")) {
2686 dev
= usb_keyboard_init();
2687 } else if (strstart(devname
, "disk:", &p
)) {
2688 BlockDriverState
*bs
;
2690 dev
= usb_msd_init(p
);
2693 bs
= usb_msd_get_bdrv(dev
);
2694 if (bdrv_key_required(bs
)) {
2697 monitor_read_bdrv_key_start(cur_mon
, bs
, usb_msd_password_cb
,
2702 } else if (!strcmp(devname
, "wacom-tablet")) {
2703 dev
= usb_wacom_init();
2704 } else if (strstart(devname
, "serial:", &p
)) {
2705 dev
= usb_serial_init(p
);
2706 #ifdef CONFIG_BRLAPI
2707 } else if (!strcmp(devname
, "braille")) {
2708 dev
= usb_baum_init();
2710 } else if (strstart(devname
, "net:", &p
)) {
2713 if (net_client_init("nic", p
) < 0)
2715 nd_table
[nic
].model
= "usb";
2716 dev
= usb_net_init(&nd_table
[nic
]);
2717 } else if (!strcmp(devname
, "bt") || strstart(devname
, "bt:", &p
)) {
2718 dev
= usb_bt_init(devname
[2] ? hci_init(p
) :
2719 bt_new_hci(qemu_find_bt_vlan(0)));
2726 return usb_device_add_dev(dev
);
2729 int usb_device_del_addr(int bus_num
, int addr
)
2735 if (!used_usb_ports
)
2741 lastp
= &used_usb_ports
;
2742 port
= used_usb_ports
;
2743 while (port
&& port
->dev
->addr
!= addr
) {
2744 lastp
= &port
->next
;
2752 *lastp
= port
->next
;
2753 usb_attach(port
, NULL
);
2754 dev
->handle_destroy(dev
);
2755 port
->next
= free_usb_ports
;
2756 free_usb_ports
= port
;
2760 static int usb_device_del(const char *devname
)
2765 if (strstart(devname
, "host:", &p
))
2766 return usb_host_device_close(p
);
2768 if (!used_usb_ports
)
2771 p
= strchr(devname
, '.');
2774 bus_num
= strtoul(devname
, NULL
, 0);
2775 addr
= strtoul(p
+ 1, NULL
, 0);
2777 return usb_device_del_addr(bus_num
, addr
);
2780 void do_usb_add(Monitor
*mon
, const char *devname
)
2782 usb_device_add(devname
, 1);
2785 void do_usb_del(Monitor
*mon
, const char *devname
)
2787 usb_device_del(devname
);
2790 void usb_info(Monitor
*mon
)
2794 const char *speed_str
;
2797 monitor_printf(mon
, "USB support not enabled\n");
2801 for (port
= used_usb_ports
; port
; port
= port
->next
) {
2805 switch(dev
->speed
) {
2809 case USB_SPEED_FULL
:
2812 case USB_SPEED_HIGH
:
2819 monitor_printf(mon
, " Device %d.%d, Speed %s Mb/s, Product %s\n",
2820 0, dev
->addr
, speed_str
, dev
->devname
);
2824 /***********************************************************/
2825 /* PCMCIA/Cardbus */
2827 static struct pcmcia_socket_entry_s
{
2828 PCMCIASocket
*socket
;
2829 struct pcmcia_socket_entry_s
*next
;
2830 } *pcmcia_sockets
= 0;
2832 void pcmcia_socket_register(PCMCIASocket
*socket
)
2834 struct pcmcia_socket_entry_s
*entry
;
2836 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
2837 entry
->socket
= socket
;
2838 entry
->next
= pcmcia_sockets
;
2839 pcmcia_sockets
= entry
;
2842 void pcmcia_socket_unregister(PCMCIASocket
*socket
)
2844 struct pcmcia_socket_entry_s
*entry
, **ptr
;
2846 ptr
= &pcmcia_sockets
;
2847 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
2848 if (entry
->socket
== socket
) {
2854 void pcmcia_info(Monitor
*mon
)
2856 struct pcmcia_socket_entry_s
*iter
;
2858 if (!pcmcia_sockets
)
2859 monitor_printf(mon
, "No PCMCIA sockets\n");
2861 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
2862 monitor_printf(mon
, "%s: %s\n", iter
->socket
->slot_string
,
2863 iter
->socket
->attached
? iter
->socket
->card_string
:
2867 /***********************************************************/
2868 /* register display */
2870 struct DisplayAllocator default_allocator
= {
2871 defaultallocator_create_displaysurface
,
2872 defaultallocator_resize_displaysurface
,
2873 defaultallocator_free_displaysurface
2876 void register_displaystate(DisplayState
*ds
)
2886 DisplayState
*get_displaystate(void)
2888 return display_state
;
2891 DisplayAllocator
*register_displayallocator(DisplayState
*ds
, DisplayAllocator
*da
)
2893 if(ds
->allocator
== &default_allocator
) ds
->allocator
= da
;
2894 return ds
->allocator
;
2899 static void dumb_display_init(void)
2901 DisplayState
*ds
= qemu_mallocz(sizeof(DisplayState
));
2902 ds
->allocator
= &default_allocator
;
2903 ds
->surface
= qemu_create_displaysurface(ds
, 640, 480);
2904 register_displaystate(ds
);
2907 /***********************************************************/
2910 typedef struct IOHandlerRecord
{
2912 IOCanRWHandler
*fd_read_poll
;
2914 IOHandler
*fd_write
;
2917 /* temporary data */
2919 struct IOHandlerRecord
*next
;
2922 static IOHandlerRecord
*first_io_handler
;
2924 /* XXX: fd_read_poll should be suppressed, but an API change is
2925 necessary in the character devices to suppress fd_can_read(). */
2926 int qemu_set_fd_handler2(int fd
,
2927 IOCanRWHandler
*fd_read_poll
,
2929 IOHandler
*fd_write
,
2932 IOHandlerRecord
**pioh
, *ioh
;
2934 if (!fd_read
&& !fd_write
) {
2935 pioh
= &first_io_handler
;
2940 if (ioh
->fd
== fd
) {
2947 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
2951 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
2952 ioh
->next
= first_io_handler
;
2953 first_io_handler
= ioh
;
2956 ioh
->fd_read_poll
= fd_read_poll
;
2957 ioh
->fd_read
= fd_read
;
2958 ioh
->fd_write
= fd_write
;
2959 ioh
->opaque
= opaque
;
2965 int qemu_set_fd_handler(int fd
,
2967 IOHandler
*fd_write
,
2970 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
2974 /***********************************************************/
2975 /* Polling handling */
2977 typedef struct PollingEntry
{
2980 struct PollingEntry
*next
;
2983 static PollingEntry
*first_polling_entry
;
2985 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
2987 PollingEntry
**ppe
, *pe
;
2988 pe
= qemu_mallocz(sizeof(PollingEntry
));
2990 pe
->opaque
= opaque
;
2991 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
2996 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
2998 PollingEntry
**ppe
, *pe
;
2999 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
3001 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
3009 /***********************************************************/
3010 /* Wait objects support */
3011 typedef struct WaitObjects
{
3013 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
3014 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
3015 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
3018 static WaitObjects wait_objects
= {0};
3020 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
3022 WaitObjects
*w
= &wait_objects
;
3024 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
3026 w
->events
[w
->num
] = handle
;
3027 w
->func
[w
->num
] = func
;
3028 w
->opaque
[w
->num
] = opaque
;
3033 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
3036 WaitObjects
*w
= &wait_objects
;
3039 for (i
= 0; i
< w
->num
; i
++) {
3040 if (w
->events
[i
] == handle
)
3043 w
->events
[i
] = w
->events
[i
+ 1];
3044 w
->func
[i
] = w
->func
[i
+ 1];
3045 w
->opaque
[i
] = w
->opaque
[i
+ 1];
3053 /***********************************************************/
3054 /* ram save/restore */
3056 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
3060 v
= qemu_get_byte(f
);
3063 if (qemu_get_buffer(f
, buf
, len
) != len
)
3067 v
= qemu_get_byte(f
);
3068 memset(buf
, v
, len
);
3074 if (qemu_file_has_error(f
))
3080 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
3085 if (qemu_get_be32(f
) != last_ram_offset
)
3087 for(i
= 0; i
< last_ram_offset
; i
+= TARGET_PAGE_SIZE
) {
3088 ret
= ram_get_page(f
, qemu_get_ram_ptr(i
), TARGET_PAGE_SIZE
);
3095 #define BDRV_HASH_BLOCK_SIZE 1024
3096 #define IOBUF_SIZE 4096
3097 #define RAM_CBLOCK_MAGIC 0xfabe
3099 typedef struct RamDecompressState
{
3102 uint8_t buf
[IOBUF_SIZE
];
3103 } RamDecompressState
;
3105 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
3108 memset(s
, 0, sizeof(*s
));
3110 ret
= inflateInit(&s
->zstream
);
3116 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
3120 s
->zstream
.avail_out
= len
;
3121 s
->zstream
.next_out
= buf
;
3122 while (s
->zstream
.avail_out
> 0) {
3123 if (s
->zstream
.avail_in
== 0) {
3124 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
3126 clen
= qemu_get_be16(s
->f
);
3127 if (clen
> IOBUF_SIZE
)
3129 qemu_get_buffer(s
->f
, s
->buf
, clen
);
3130 s
->zstream
.avail_in
= clen
;
3131 s
->zstream
.next_in
= s
->buf
;
3133 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
3134 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
3141 static void ram_decompress_close(RamDecompressState
*s
)
3143 inflateEnd(&s
->zstream
);
3146 #define RAM_SAVE_FLAG_FULL 0x01
3147 #define RAM_SAVE_FLAG_COMPRESS 0x02
3148 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
3149 #define RAM_SAVE_FLAG_PAGE 0x08
3150 #define RAM_SAVE_FLAG_EOS 0x10
3152 static int is_dup_page(uint8_t *page
, uint8_t ch
)
3154 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
3155 uint32_t *array
= (uint32_t *)page
;
3158 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
3159 if (array
[i
] != val
)
3166 static int ram_save_block(QEMUFile
*f
)
3168 static ram_addr_t current_addr
= 0;
3169 ram_addr_t saved_addr
= current_addr
;
3170 ram_addr_t addr
= 0;
3173 while (addr
< last_ram_offset
) {
3174 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
3177 cpu_physical_memory_reset_dirty(current_addr
,
3178 current_addr
+ TARGET_PAGE_SIZE
,
3179 MIGRATION_DIRTY_FLAG
);
3181 p
= qemu_get_ram_ptr(current_addr
);
3183 if (is_dup_page(p
, *p
)) {
3184 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_COMPRESS
);
3185 qemu_put_byte(f
, *p
);
3187 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_PAGE
);
3188 qemu_put_buffer(f
, p
, TARGET_PAGE_SIZE
);
3194 addr
+= TARGET_PAGE_SIZE
;
3195 current_addr
= (saved_addr
+ addr
) % last_ram_offset
;
3201 static ram_addr_t ram_save_threshold
= 10;
3202 static uint64_t bytes_transferred
= 0;
3204 static ram_addr_t
ram_save_remaining(void)
3207 ram_addr_t count
= 0;
3209 for (addr
= 0; addr
< last_ram_offset
; addr
+= TARGET_PAGE_SIZE
) {
3210 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
3217 uint64_t ram_bytes_remaining(void)
3219 return ram_save_remaining() * TARGET_PAGE_SIZE
;
3222 uint64_t ram_bytes_transferred(void)
3224 return bytes_transferred
;
3227 uint64_t ram_bytes_total(void)
3229 return last_ram_offset
;
3232 static int ram_save_live(QEMUFile
*f
, int stage
, void *opaque
)
3236 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX
) != 0) {
3237 qemu_file_set_error(f
);
3242 /* Make sure all dirty bits are set */
3243 for (addr
= 0; addr
< last_ram_offset
; addr
+= TARGET_PAGE_SIZE
) {
3244 if (!cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
3245 cpu_physical_memory_set_dirty(addr
);
3248 /* Enable dirty memory tracking */
3249 cpu_physical_memory_set_dirty_tracking(1);
3251 qemu_put_be64(f
, last_ram_offset
| RAM_SAVE_FLAG_MEM_SIZE
);
3254 while (!qemu_file_rate_limit(f
)) {
3257 ret
= ram_save_block(f
);
3258 bytes_transferred
+= ret
* TARGET_PAGE_SIZE
;
3259 if (ret
== 0) /* no more blocks */
3263 /* try transferring iterative blocks of memory */
3267 /* flush all remaining blocks regardless of rate limiting */
3268 while (ram_save_block(f
) != 0) {
3269 bytes_transferred
+= TARGET_PAGE_SIZE
;
3271 cpu_physical_memory_set_dirty_tracking(0);
3274 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
3276 return (stage
== 2) && (ram_save_remaining() < ram_save_threshold
);
3279 static int ram_load_dead(QEMUFile
*f
, void *opaque
)
3281 RamDecompressState s1
, *s
= &s1
;
3285 if (ram_decompress_open(s
, f
) < 0)
3287 for(i
= 0; i
< last_ram_offset
; i
+= BDRV_HASH_BLOCK_SIZE
) {
3288 if (ram_decompress_buf(s
, buf
, 1) < 0) {
3289 fprintf(stderr
, "Error while reading ram block header\n");
3293 if (ram_decompress_buf(s
, qemu_get_ram_ptr(i
),
3294 BDRV_HASH_BLOCK_SIZE
) < 0) {
3295 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
3300 printf("Error block header\n");
3304 ram_decompress_close(s
);
3309 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
3314 if (version_id
== 1)
3315 return ram_load_v1(f
, opaque
);
3317 if (version_id
== 2) {
3318 if (qemu_get_be32(f
) != last_ram_offset
)
3320 return ram_load_dead(f
, opaque
);
3323 if (version_id
!= 3)
3327 addr
= qemu_get_be64(f
);
3329 flags
= addr
& ~TARGET_PAGE_MASK
;
3330 addr
&= TARGET_PAGE_MASK
;
3332 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
3333 if (addr
!= last_ram_offset
)
3337 if (flags
& RAM_SAVE_FLAG_FULL
) {
3338 if (ram_load_dead(f
, opaque
) < 0)
3342 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
3343 uint8_t ch
= qemu_get_byte(f
);
3344 memset(qemu_get_ram_ptr(addr
), ch
, TARGET_PAGE_SIZE
);
3345 } else if (flags
& RAM_SAVE_FLAG_PAGE
)
3346 qemu_get_buffer(f
, qemu_get_ram_ptr(addr
), TARGET_PAGE_SIZE
);
3347 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
3352 void qemu_service_io(void)
3354 qemu_notify_event();
3357 /***********************************************************/
3358 /* bottom halves (can be seen as timers which expire ASAP) */
3369 static QEMUBH
*first_bh
= NULL
;
3371 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
3374 bh
= qemu_mallocz(sizeof(QEMUBH
));
3376 bh
->opaque
= opaque
;
3377 bh
->next
= first_bh
;
3382 int qemu_bh_poll(void)
3388 for (bh
= first_bh
; bh
; bh
= bh
->next
) {
3389 if (!bh
->deleted
&& bh
->scheduled
) {
3398 /* remove deleted bhs */
3412 void qemu_bh_schedule_idle(QEMUBH
*bh
)
3420 void qemu_bh_schedule(QEMUBH
*bh
)
3426 /* stop the currently executing CPU to execute the BH ASAP */
3427 qemu_notify_event();
3430 void qemu_bh_cancel(QEMUBH
*bh
)
3435 void qemu_bh_delete(QEMUBH
*bh
)
3441 static void qemu_bh_update_timeout(int *timeout
)
3445 for (bh
= first_bh
; bh
; bh
= bh
->next
) {
3446 if (!bh
->deleted
&& bh
->scheduled
) {
3448 /* idle bottom halves will be polled at least
3450 *timeout
= MIN(10, *timeout
);
3452 /* non-idle bottom halves will be executed
3461 /***********************************************************/
3462 /* machine registration */
3464 static QEMUMachine
*first_machine
= NULL
;
3465 QEMUMachine
*current_machine
= NULL
;
3467 int qemu_register_machine(QEMUMachine
*m
)
3470 pm
= &first_machine
;
3478 static QEMUMachine
*find_machine(const char *name
)
3482 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
3483 if (!strcmp(m
->name
, name
))
3489 static QEMUMachine
*find_default_machine(void)
3493 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
3494 if (m
->is_default
) {
3501 /***********************************************************/
3502 /* main execution loop */
3504 static void gui_update(void *opaque
)
3506 uint64_t interval
= GUI_REFRESH_INTERVAL
;
3507 DisplayState
*ds
= opaque
;
3508 DisplayChangeListener
*dcl
= ds
->listeners
;
3512 while (dcl
!= NULL
) {
3513 if (dcl
->gui_timer_interval
&&
3514 dcl
->gui_timer_interval
< interval
)
3515 interval
= dcl
->gui_timer_interval
;
3518 qemu_mod_timer(ds
->gui_timer
, interval
+ qemu_get_clock(rt_clock
));
3521 static void nographic_update(void *opaque
)
3523 uint64_t interval
= GUI_REFRESH_INTERVAL
;
3525 qemu_mod_timer(nographic_timer
, interval
+ qemu_get_clock(rt_clock
));
3528 struct vm_change_state_entry
{
3529 VMChangeStateHandler
*cb
;
3531 LIST_ENTRY (vm_change_state_entry
) entries
;
3534 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
3536 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
3539 VMChangeStateEntry
*e
;
3541 e
= qemu_mallocz(sizeof (*e
));
3545 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
3549 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
3551 LIST_REMOVE (e
, entries
);
3555 static void vm_state_notify(int running
, int reason
)
3557 VMChangeStateEntry
*e
;
3559 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
3560 e
->cb(e
->opaque
, running
, reason
);
3564 static void resume_all_vcpus(void);
3565 static void pause_all_vcpus(void);
3572 vm_state_notify(1, 0);
3573 qemu_rearm_alarm_timer(alarm_timer
);
3578 /* reset/shutdown handler */
3580 typedef struct QEMUResetEntry
{
3581 QEMUResetHandler
*func
;
3584 struct QEMUResetEntry
*next
;
3587 static QEMUResetEntry
*first_reset_entry
;
3588 static int reset_requested
;
3589 static int shutdown_requested
;
3590 static int powerdown_requested
;
3591 static int debug_requested
;
3592 static int vmstop_requested
;
3594 int qemu_shutdown_requested(void)
3596 int r
= shutdown_requested
;
3597 shutdown_requested
= 0;
3601 int qemu_reset_requested(void)
3603 int r
= reset_requested
;
3604 reset_requested
= 0;
3608 int qemu_powerdown_requested(void)
3610 int r
= powerdown_requested
;
3611 powerdown_requested
= 0;
3615 static int qemu_debug_requested(void)
3617 int r
= debug_requested
;
3618 debug_requested
= 0;
3622 static int qemu_vmstop_requested(void)
3624 int r
= vmstop_requested
;
3625 vmstop_requested
= 0;
3629 static void do_vm_stop(int reason
)
3632 cpu_disable_ticks();
3635 vm_state_notify(0, reason
);
3639 void qemu_register_reset(QEMUResetHandler
*func
, int order
, void *opaque
)
3641 QEMUResetEntry
**pre
, *re
;
3643 pre
= &first_reset_entry
;
3644 while (*pre
!= NULL
&& (*pre
)->order
>= order
) {
3645 pre
= &(*pre
)->next
;
3647 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
3649 re
->opaque
= opaque
;
3655 void qemu_system_reset(void)
3659 /* reset all devices */
3660 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
3661 re
->func(re
->opaque
);
3665 void qemu_system_reset_request(void)
3668 shutdown_requested
= 1;
3670 reset_requested
= 1;
3672 qemu_notify_event();
3675 void qemu_system_shutdown_request(void)
3677 shutdown_requested
= 1;
3678 qemu_notify_event();
3681 void qemu_system_powerdown_request(void)
3683 powerdown_requested
= 1;
3684 qemu_notify_event();
3687 #ifdef CONFIG_IOTHREAD
3688 static void qemu_system_vmstop_request(int reason
)
3690 vmstop_requested
= reason
;
3691 qemu_notify_event();
3696 static int io_thread_fd
= -1;
3698 static void qemu_event_increment(void)
3700 static const char byte
= 0;
3702 if (io_thread_fd
== -1)
3705 write(io_thread_fd
, &byte
, sizeof(byte
));
3708 static void qemu_event_read(void *opaque
)
3710 int fd
= (unsigned long)opaque
;
3713 /* Drain the notify pipe */
3716 len
= read(fd
, buffer
, sizeof(buffer
));
3717 } while ((len
== -1 && errno
== EINTR
) || len
> 0);
3720 static int qemu_event_init(void)
3729 err
= fcntl_setfl(fds
[0], O_NONBLOCK
);
3733 err
= fcntl_setfl(fds
[1], O_NONBLOCK
);
3737 qemu_set_fd_handler2(fds
[0], NULL
, qemu_event_read
, NULL
,
3738 (void *)(unsigned long)fds
[0]);
3740 io_thread_fd
= fds
[1];
3749 HANDLE qemu_event_handle
;
3751 static void dummy_event_handler(void *opaque
)
3755 static int qemu_event_init(void)
3757 qemu_event_handle
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
3758 if (!qemu_event_handle
) {
3759 perror("Failed CreateEvent");
3762 qemu_add_wait_object(qemu_event_handle
, dummy_event_handler
, NULL
);
3766 static void qemu_event_increment(void)
3768 SetEvent(qemu_event_handle
);
3772 static int cpu_can_run(CPUState
*env
)
3781 #ifndef CONFIG_IOTHREAD
3782 static int qemu_init_main_loop(void)
3784 return qemu_event_init();
3787 void qemu_init_vcpu(void *_env
)
3789 CPUState
*env
= _env
;
3796 int qemu_cpu_self(void *env
)
3801 static void resume_all_vcpus(void)
3805 static void pause_all_vcpus(void)
3809 void qemu_cpu_kick(void *env
)
3814 void qemu_notify_event(void)
3816 CPUState
*env
= cpu_single_env
;
3821 if (env
->kqemu_enabled
)
3822 kqemu_cpu_interrupt(env
);
3827 #define qemu_mutex_lock_iothread() do { } while (0)
3828 #define qemu_mutex_unlock_iothread() do { } while (0)
3830 void vm_stop(int reason
)
3835 #else /* CONFIG_IOTHREAD */
3837 #include "qemu-thread.h"
3839 QemuMutex qemu_global_mutex
;
3840 static QemuMutex qemu_fair_mutex
;
3842 static QemuThread io_thread
;
3844 static QemuThread
*tcg_cpu_thread
;
3845 static QemuCond
*tcg_halt_cond
;
3847 static int qemu_system_ready
;
3849 static QemuCond qemu_cpu_cond
;
3851 static QemuCond qemu_system_cond
;
3852 static QemuCond qemu_pause_cond
;
3854 static void block_io_signals(void);
3855 static void unblock_io_signals(void);
3856 static int tcg_has_work(void);
3858 static int qemu_init_main_loop(void)
3862 ret
= qemu_event_init();
3866 qemu_cond_init(&qemu_pause_cond
);
3867 qemu_mutex_init(&qemu_fair_mutex
);
3868 qemu_mutex_init(&qemu_global_mutex
);
3869 qemu_mutex_lock(&qemu_global_mutex
);
3871 unblock_io_signals();
3872 qemu_thread_self(&io_thread
);
3877 static void qemu_wait_io_event(CPUState
*env
)
3879 while (!tcg_has_work())
3880 qemu_cond_timedwait(env
->halt_cond
, &qemu_global_mutex
, 1000);
3882 qemu_mutex_unlock(&qemu_global_mutex
);
3885 * Users of qemu_global_mutex can be starved, having no chance
3886 * to acquire it since this path will get to it first.
3887 * So use another lock to provide fairness.
3889 qemu_mutex_lock(&qemu_fair_mutex
);
3890 qemu_mutex_unlock(&qemu_fair_mutex
);
3892 qemu_mutex_lock(&qemu_global_mutex
);
3896 qemu_cond_signal(&qemu_pause_cond
);
3900 static int qemu_cpu_exec(CPUState
*env
);
3902 static void *kvm_cpu_thread_fn(void *arg
)
3904 CPUState
*env
= arg
;
3907 qemu_thread_self(env
->thread
);
3909 /* signal CPU creation */
3910 qemu_mutex_lock(&qemu_global_mutex
);
3912 qemu_cond_signal(&qemu_cpu_cond
);
3914 /* and wait for machine initialization */
3915 while (!qemu_system_ready
)
3916 qemu_cond_timedwait(&qemu_system_cond
, &qemu_global_mutex
, 100);
3919 if (cpu_can_run(env
))
3921 qemu_wait_io_event(env
);
3927 static void tcg_cpu_exec(void);
3929 static void *tcg_cpu_thread_fn(void *arg
)
3931 CPUState
*env
= arg
;
3934 qemu_thread_self(env
->thread
);
3936 /* signal CPU creation */
3937 qemu_mutex_lock(&qemu_global_mutex
);
3938 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
3940 qemu_cond_signal(&qemu_cpu_cond
);
3942 /* and wait for machine initialization */
3943 while (!qemu_system_ready
)
3944 qemu_cond_timedwait(&qemu_system_cond
, &qemu_global_mutex
, 100);
3948 qemu_wait_io_event(cur_cpu
);
3954 void qemu_cpu_kick(void *_env
)
3956 CPUState
*env
= _env
;
3957 qemu_cond_broadcast(env
->halt_cond
);
3959 qemu_thread_signal(env
->thread
, SIGUSR1
);
3962 int qemu_cpu_self(void *env
)
3964 return (cpu_single_env
!= NULL
);
3967 static void cpu_signal(int sig
)
3970 cpu_exit(cpu_single_env
);
3973 static void block_io_signals(void)
3976 struct sigaction sigact
;
3979 sigaddset(&set
, SIGUSR2
);
3980 sigaddset(&set
, SIGIO
);
3981 sigaddset(&set
, SIGALRM
);
3982 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
3985 sigaddset(&set
, SIGUSR1
);
3986 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
3988 memset(&sigact
, 0, sizeof(sigact
));
3989 sigact
.sa_handler
= cpu_signal
;
3990 sigaction(SIGUSR1
, &sigact
, NULL
);
3993 static void unblock_io_signals(void)
3998 sigaddset(&set
, SIGUSR2
);
3999 sigaddset(&set
, SIGIO
);
4000 sigaddset(&set
, SIGALRM
);
4001 pthread_sigmask(SIG_UNBLOCK
, &set
, NULL
);
4004 sigaddset(&set
, SIGUSR1
);
4005 pthread_sigmask(SIG_BLOCK
, &set
, NULL
);
4008 static void qemu_signal_lock(unsigned int msecs
)
4010 qemu_mutex_lock(&qemu_fair_mutex
);
4012 while (qemu_mutex_trylock(&qemu_global_mutex
)) {
4013 qemu_thread_signal(tcg_cpu_thread
, SIGUSR1
);
4014 if (!qemu_mutex_timedlock(&qemu_global_mutex
, msecs
))
4017 qemu_mutex_unlock(&qemu_fair_mutex
);
4020 static void qemu_mutex_lock_iothread(void)
4022 if (kvm_enabled()) {
4023 qemu_mutex_lock(&qemu_fair_mutex
);
4024 qemu_mutex_lock(&qemu_global_mutex
);
4025 qemu_mutex_unlock(&qemu_fair_mutex
);
4027 qemu_signal_lock(100);
4030 static void qemu_mutex_unlock_iothread(void)
4032 qemu_mutex_unlock(&qemu_global_mutex
);
4035 static int all_vcpus_paused(void)
4037 CPUState
*penv
= first_cpu
;
4042 penv
= (CPUState
*)penv
->next_cpu
;
4048 static void pause_all_vcpus(void)
4050 CPUState
*penv
= first_cpu
;
4054 qemu_thread_signal(penv
->thread
, SIGUSR1
);
4055 qemu_cpu_kick(penv
);
4056 penv
= (CPUState
*)penv
->next_cpu
;
4059 while (!all_vcpus_paused()) {
4060 qemu_cond_timedwait(&qemu_pause_cond
, &qemu_global_mutex
, 100);
4063 qemu_thread_signal(penv
->thread
, SIGUSR1
);
4064 penv
= (CPUState
*)penv
->next_cpu
;
4069 static void resume_all_vcpus(void)
4071 CPUState
*penv
= first_cpu
;
4076 qemu_thread_signal(penv
->thread
, SIGUSR1
);
4077 qemu_cpu_kick(penv
);
4078 penv
= (CPUState
*)penv
->next_cpu
;
4082 static void tcg_init_vcpu(void *_env
)
4084 CPUState
*env
= _env
;
4085 /* share a single thread for all cpus with TCG */
4086 if (!tcg_cpu_thread
) {
4087 env
->thread
= qemu_mallocz(sizeof(QemuThread
));
4088 env
->halt_cond
= qemu_mallocz(sizeof(QemuCond
));
4089 qemu_cond_init(env
->halt_cond
);
4090 qemu_thread_create(env
->thread
, tcg_cpu_thread_fn
, env
);
4091 while (env
->created
== 0)
4092 qemu_cond_timedwait(&qemu_cpu_cond
, &qemu_global_mutex
, 100);
4093 tcg_cpu_thread
= env
->thread
;
4094 tcg_halt_cond
= env
->halt_cond
;
4096 env
->thread
= tcg_cpu_thread
;
4097 env
->halt_cond
= tcg_halt_cond
;
4101 static void kvm_start_vcpu(CPUState
*env
)
4104 env
->thread
= qemu_mallocz(sizeof(QemuThread
));
4105 env
->halt_cond
= qemu_mallocz(sizeof(QemuCond
));
4106 qemu_cond_init(env
->halt_cond
);
4107 qemu_thread_create(env
->thread
, kvm_cpu_thread_fn
, env
);
4108 while (env
->created
== 0)
4109 qemu_cond_timedwait(&qemu_cpu_cond
, &qemu_global_mutex
, 100);
4112 void qemu_init_vcpu(void *_env
)
4114 CPUState
*env
= _env
;
4117 kvm_start_vcpu(env
);
4122 void qemu_notify_event(void)
4124 qemu_event_increment();
4127 void vm_stop(int reason
)
4130 qemu_thread_self(&me
);
4132 if (!qemu_thread_equal(&me
, &io_thread
)) {
4133 qemu_system_vmstop_request(reason
);
4135 * FIXME: should not return to device code in case
4136 * vm_stop() has been requested.
4138 if (cpu_single_env
) {
4139 cpu_exit(cpu_single_env
);
4140 cpu_single_env
->stop
= 1;
4151 static void host_main_loop_wait(int *timeout
)
4157 /* XXX: need to suppress polling by better using win32 events */
4159 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
4160 ret
|= pe
->func(pe
->opaque
);
4164 WaitObjects
*w
= &wait_objects
;
4166 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, *timeout
);
4167 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
4168 if (w
->func
[ret
- WAIT_OBJECT_0
])
4169 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
4171 /* Check for additional signaled events */
4172 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
4174 /* Check if event is signaled */
4175 ret2
= WaitForSingleObject(w
->events
[i
], 0);
4176 if(ret2
== WAIT_OBJECT_0
) {
4178 w
->func
[i
](w
->opaque
[i
]);
4179 } else if (ret2
== WAIT_TIMEOUT
) {
4181 err
= GetLastError();
4182 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
4185 } else if (ret
== WAIT_TIMEOUT
) {
4187 err
= GetLastError();
4188 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
4195 static void host_main_loop_wait(int *timeout
)
4200 void main_loop_wait(int timeout
)
4202 IOHandlerRecord
*ioh
;
4203 fd_set rfds
, wfds
, xfds
;
4207 qemu_bh_update_timeout(&timeout
);
4209 host_main_loop_wait(&timeout
);
4211 /* poll any events */
4212 /* XXX: separate device handlers from system ones */
4217 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
4221 (!ioh
->fd_read_poll
||
4222 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
4223 FD_SET(ioh
->fd
, &rfds
);
4227 if (ioh
->fd_write
) {
4228 FD_SET(ioh
->fd
, &wfds
);
4234 tv
.tv_sec
= timeout
/ 1000;
4235 tv
.tv_usec
= (timeout
% 1000) * 1000;
4237 #if defined(CONFIG_SLIRP)
4238 if (slirp_is_inited()) {
4239 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
4242 qemu_mutex_unlock_iothread();
4243 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
4244 qemu_mutex_lock_iothread();
4246 IOHandlerRecord
**pioh
;
4248 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
4249 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
4250 ioh
->fd_read(ioh
->opaque
);
4252 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
4253 ioh
->fd_write(ioh
->opaque
);
4257 /* remove deleted IO handlers */
4258 pioh
= &first_io_handler
;
4268 #if defined(CONFIG_SLIRP)
4269 if (slirp_is_inited()) {
4275 slirp_select_poll(&rfds
, &wfds
, &xfds
);
4279 /* rearm timer, if not periodic */
4280 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
4281 alarm_timer
->flags
&= ~ALARM_FLAG_EXPIRED
;
4282 qemu_rearm_alarm_timer(alarm_timer
);
4285 /* vm time timers */
4287 if (!cur_cpu
|| likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
4288 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
4289 qemu_get_clock(vm_clock
));
4292 /* real time timers */
4293 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
4294 qemu_get_clock(rt_clock
));
4296 /* Check bottom-halves last in case any of the earlier events triggered
4302 static int qemu_cpu_exec(CPUState
*env
)
4305 #ifdef CONFIG_PROFILER
4309 #ifdef CONFIG_PROFILER
4310 ti
= profile_getclock();
4315 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
4316 env
->icount_decr
.u16
.low
= 0;
4317 env
->icount_extra
= 0;
4318 count
= qemu_next_deadline();
4319 count
= (count
+ (1 << icount_time_shift
) - 1)
4320 >> icount_time_shift
;
4321 qemu_icount
+= count
;
4322 decr
= (count
> 0xffff) ? 0xffff : count
;
4324 env
->icount_decr
.u16
.low
= decr
;
4325 env
->icount_extra
= count
;
4327 ret
= cpu_exec(env
);
4328 #ifdef CONFIG_PROFILER
4329 qemu_time
+= profile_getclock() - ti
;
4332 /* Fold pending instructions back into the
4333 instruction counter, and clear the interrupt flag. */
4334 qemu_icount
-= (env
->icount_decr
.u16
.low
4335 + env
->icount_extra
);
4336 env
->icount_decr
.u32
= 0;
4337 env
->icount_extra
= 0;
4342 static void tcg_cpu_exec(void)
4346 if (next_cpu
== NULL
)
4347 next_cpu
= first_cpu
;
4348 for (; next_cpu
!= NULL
; next_cpu
= next_cpu
->next_cpu
) {
4349 CPUState
*env
= cur_cpu
= next_cpu
;
4353 if (timer_alarm_pending
) {
4354 timer_alarm_pending
= 0;
4357 if (cpu_can_run(env
))
4358 ret
= qemu_cpu_exec(env
);
4359 if (ret
== EXCP_DEBUG
) {
4360 gdb_set_stop_cpu(env
);
4361 debug_requested
= 1;
4367 static int cpu_has_work(CPUState
*env
)
4375 if (qemu_cpu_has_work(env
))
4380 static int tcg_has_work(void)
4384 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
)
4385 if (cpu_has_work(env
))
4390 static int qemu_calculate_timeout(void)
4396 else if (tcg_has_work())
4398 else if (!use_icount
)
4401 /* XXX: use timeout computed from timers */
4404 /* Advance virtual time to the next event. */
4405 if (use_icount
== 1) {
4406 /* When not using an adaptive execution frequency
4407 we tend to get badly out of sync with real time,
4408 so just delay for a reasonable amount of time. */
4411 delta
= cpu_get_icount() - cpu_get_clock();
4414 /* If virtual time is ahead of real time then just
4416 timeout
= (delta
/ 1000000) + 1;
4418 /* Wait for either IO to occur or the next
4420 add
= qemu_next_deadline();
4421 /* We advance the timer before checking for IO.
4422 Limit the amount we advance so that early IO
4423 activity won't get the guest too far ahead. */
4427 add
= (add
+ (1 << icount_time_shift
) - 1)
4428 >> icount_time_shift
;
4430 timeout
= delta
/ 1000000;
4439 static int vm_can_run(void)
4441 if (powerdown_requested
)
4443 if (reset_requested
)
4445 if (shutdown_requested
)
4447 if (debug_requested
)
4452 static void main_loop(void)
4456 #ifdef CONFIG_IOTHREAD
4457 qemu_system_ready
= 1;
4458 qemu_cond_broadcast(&qemu_system_cond
);
4463 #ifdef CONFIG_PROFILER
4466 #ifndef CONFIG_IOTHREAD
4469 #ifdef CONFIG_PROFILER
4470 ti
= profile_getclock();
4472 #ifdef CONFIG_IOTHREAD
4473 main_loop_wait(1000);
4475 main_loop_wait(qemu_calculate_timeout());
4477 #ifdef CONFIG_PROFILER
4478 dev_time
+= profile_getclock() - ti
;
4480 } while (vm_can_run());
4482 if (qemu_debug_requested())
4483 vm_stop(EXCP_DEBUG
);
4484 if (qemu_shutdown_requested()) {
4491 if (qemu_reset_requested()) {
4493 qemu_system_reset();
4496 if (qemu_powerdown_requested())
4497 qemu_system_powerdown();
4498 if ((r
= qemu_vmstop_requested()))
4504 static void version(void)
4506 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n");
4509 static void help(int exitcode
)
4512 printf("usage: %s [options] [disk_image]\n"
4514 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4516 #define DEF(option, opt_arg, opt_enum, opt_help) \
4518 #define DEFHEADING(text) stringify(text) "\n"
4519 #include "qemu-options.h"
4524 "During emulation, the following keys are useful:\n"
4525 "ctrl-alt-f toggle full screen\n"
4526 "ctrl-alt-n switch to virtual console 'n'\n"
4527 "ctrl-alt toggle mouse and keyboard grab\n"
4529 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4534 DEFAULT_NETWORK_SCRIPT
,
4535 DEFAULT_NETWORK_DOWN_SCRIPT
,
4537 DEFAULT_GDBSTUB_PORT
,
4542 #define HAS_ARG 0x0001
4545 #define DEF(option, opt_arg, opt_enum, opt_help) \
4547 #define DEFHEADING(text)
4548 #include "qemu-options.h"
4554 typedef struct QEMUOption
{
4560 static const QEMUOption qemu_options
[] = {
4561 { "h", 0, QEMU_OPTION_h
},
4562 #define DEF(option, opt_arg, opt_enum, opt_help) \
4563 { option, opt_arg, opt_enum },
4564 #define DEFHEADING(text)
4565 #include "qemu-options.h"
4573 struct soundhw soundhw
[] = {
4574 #ifdef HAS_AUDIO_CHOICE
4575 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4581 { .init_isa
= pcspk_audio_init
}
4588 "Creative Sound Blaster 16",
4591 { .init_isa
= SB16_init
}
4595 #ifdef CONFIG_CS4231A
4601 { .init_isa
= cs4231a_init
}
4609 "Yamaha YMF262 (OPL3)",
4611 "Yamaha YM3812 (OPL2)",
4615 { .init_isa
= Adlib_init
}
4622 "Gravis Ultrasound GF1",
4625 { .init_isa
= GUS_init
}
4632 "Intel 82801AA AC97 Audio",
4635 { .init_pci
= ac97_init
}
4639 #ifdef CONFIG_ES1370
4642 "ENSONIQ AudioPCI ES1370",
4645 { .init_pci
= es1370_init
}
4649 #endif /* HAS_AUDIO_CHOICE */
4651 { NULL
, NULL
, 0, 0, { NULL
} }
4654 static void select_soundhw (const char *optarg
)
4658 if (*optarg
== '?') {
4661 printf ("Valid sound card names (comma separated):\n");
4662 for (c
= soundhw
; c
->name
; ++c
) {
4663 printf ("%-11s %s\n", c
->name
, c
->descr
);
4665 printf ("\n-soundhw all will enable all of the above\n");
4666 exit (*optarg
!= '?');
4674 if (!strcmp (optarg
, "all")) {
4675 for (c
= soundhw
; c
->name
; ++c
) {
4683 e
= strchr (p
, ',');
4684 l
= !e
? strlen (p
) : (size_t) (e
- p
);
4686 for (c
= soundhw
; c
->name
; ++c
) {
4687 if (!strncmp (c
->name
, p
, l
)) {
4696 "Unknown sound card name (too big to show)\n");
4699 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
4704 p
+= l
+ (e
!= NULL
);
4708 goto show_valid_cards
;
4713 static void select_vgahw (const char *p
)
4717 cirrus_vga_enabled
= 0;
4718 std_vga_enabled
= 0;
4721 if (strstart(p
, "std", &opts
)) {
4722 std_vga_enabled
= 1;
4723 } else if (strstart(p
, "cirrus", &opts
)) {
4724 cirrus_vga_enabled
= 1;
4725 } else if (strstart(p
, "vmware", &opts
)) {
4727 } else if (strstart(p
, "xenfb", &opts
)) {
4729 } else if (!strstart(p
, "none", &opts
)) {
4731 fprintf(stderr
, "Unknown vga type: %s\n", p
);
4735 const char *nextopt
;
4737 if (strstart(opts
, ",retrace=", &nextopt
)) {
4739 if (strstart(opts
, "dumb", &nextopt
))
4740 vga_retrace_method
= VGA_RETRACE_DUMB
;
4741 else if (strstart(opts
, "precise", &nextopt
))
4742 vga_retrace_method
= VGA_RETRACE_PRECISE
;
4743 else goto invalid_vga
;
4744 } else goto invalid_vga
;
4750 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
4752 exit(STATUS_CONTROL_C_EXIT
);
4757 int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
4761 if(strlen(str
) != 36)
4764 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
4765 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
4766 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
4772 smbios_add_field(1, offsetof(struct smbios_type_1
, uuid
), 16, uuid
);
4778 #define MAX_NET_CLIENTS 32
4782 static void termsig_handler(int signal
)
4784 qemu_system_shutdown_request();
4787 static void sigchld_handler(int signal
)
4789 waitpid(-1, NULL
, WNOHANG
);
4792 static void sighandler_setup(void)
4794 struct sigaction act
;
4796 memset(&act
, 0, sizeof(act
));
4797 act
.sa_handler
= termsig_handler
;
4798 sigaction(SIGINT
, &act
, NULL
);
4799 sigaction(SIGHUP
, &act
, NULL
);
4800 sigaction(SIGTERM
, &act
, NULL
);
4802 act
.sa_handler
= sigchld_handler
;
4803 act
.sa_flags
= SA_NOCLDSTOP
;
4804 sigaction(SIGCHLD
, &act
, NULL
);
4810 /* Look for support files in the same directory as the executable. */
4811 static char *find_datadir(const char *argv0
)
4817 len
= GetModuleFileName(NULL
, buf
, sizeof(buf
) - 1);
4824 while (p
!= buf
&& *p
!= '\\')
4827 if (access(buf
, R_OK
) == 0) {
4828 return qemu_strdup(buf
);
4834 /* Find a likely location for support files using the location of the binary.
4835 For installed binaries this will be "$bindir/../share/qemu". When
4836 running from the build tree this will be "$bindir/../pc-bios". */
4837 #define SHARE_SUFFIX "/share/qemu"
4838 #define BUILD_SUFFIX "/pc-bios"
4839 static char *find_datadir(const char *argv0
)
4848 #if defined(__linux__)
4851 len
= readlink("/proc/self/exe", buf
, sizeof(buf
) - 1);
4857 #elif defined(__FreeBSD__)
4860 len
= readlink("/proc/curproc/file", buf
, sizeof(buf
) - 1);
4867 /* If we don't have any way of figuring out the actual executable
4868 location then try argv[0]. */
4873 p
= realpath(argv0
, p
);
4881 res
= qemu_mallocz(strlen(dir
) +
4882 MAX(strlen(SHARE_SUFFIX
), strlen(BUILD_SUFFIX
)) + 1);
4883 sprintf(res
, "%s%s", dir
, SHARE_SUFFIX
);
4884 if (access(res
, R_OK
)) {
4885 sprintf(res
, "%s%s", dir
, BUILD_SUFFIX
);
4886 if (access(res
, R_OK
)) {
4900 char *qemu_find_file(int type
, const char *name
)
4906 /* If name contains path separators then try it as a straight path. */
4907 if ((strchr(name
, '/') || strchr(name
, '\\'))
4908 && access(name
, R_OK
) == 0) {
4909 return strdup(name
);
4912 case QEMU_FILE_TYPE_BIOS
:
4915 case QEMU_FILE_TYPE_KEYMAP
:
4916 subdir
= "keymaps/";
4921 len
= strlen(data_dir
) + strlen(name
) + strlen(subdir
) + 2;
4922 buf
= qemu_mallocz(len
);
4923 sprintf(buf
, "%s/%s%s", data_dir
, subdir
, name
);
4924 if (access(buf
, R_OK
)) {
4931 int main(int argc
, char **argv
, char **envp
)
4933 const char *gdbstub_dev
= NULL
;
4934 uint32_t boot_devices_bitmap
= 0;
4936 int snapshot
, linux_boot
, net_boot
;
4937 const char *initrd_filename
;
4938 const char *kernel_filename
, *kernel_cmdline
;
4939 const char *boot_devices
= "";
4941 DisplayChangeListener
*dcl
;
4942 int cyls
, heads
, secs
, translation
;
4943 const char *net_clients
[MAX_NET_CLIENTS
];
4945 const char *bt_opts
[MAX_BT_CMDLINE
];
4949 const char *r
, *optarg
;
4950 CharDriverState
*monitor_hd
= NULL
;
4951 const char *monitor_device
;
4952 const char *serial_devices
[MAX_SERIAL_PORTS
];
4953 int serial_device_index
;
4954 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
4955 int parallel_device_index
;
4956 const char *virtio_consoles
[MAX_VIRTIO_CONSOLES
];
4957 int virtio_console_index
;
4958 const char *loadvm
= NULL
;
4959 QEMUMachine
*machine
;
4960 const char *cpu_model
;
4961 const char *usb_devices
[MAX_USB_CMDLINE
];
4962 int usb_devices_index
;
4967 const char *pid_file
= NULL
;
4968 const char *incoming
= NULL
;
4971 struct passwd
*pwd
= NULL
;
4972 const char *chroot_dir
= NULL
;
4973 const char *run_as
= NULL
;
4976 int show_vnc_port
= 0;
4978 qemu_cache_utils_init(envp
);
4980 LIST_INIT (&vm_change_state_head
);
4983 struct sigaction act
;
4984 sigfillset(&act
.sa_mask
);
4986 act
.sa_handler
= SIG_IGN
;
4987 sigaction(SIGPIPE
, &act
, NULL
);
4990 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
4991 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4992 QEMU to run on a single CPU */
4997 h
= GetCurrentProcess();
4998 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
4999 for(i
= 0; i
< 32; i
++) {
5000 if (mask
& (1 << i
))
5005 SetProcessAffinityMask(h
, mask
);
5011 module_call_init(MODULE_INIT_MACHINE
);
5012 machine
= find_default_machine();
5014 initrd_filename
= NULL
;
5017 kernel_filename
= NULL
;
5018 kernel_cmdline
= "";
5019 cyls
= heads
= secs
= 0;
5020 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5021 monitor_device
= "vc:80Cx24C";
5023 serial_devices
[0] = "vc:80Cx24C";
5024 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
5025 serial_devices
[i
] = NULL
;
5026 serial_device_index
= 0;
5028 parallel_devices
[0] = "vc:80Cx24C";
5029 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
5030 parallel_devices
[i
] = NULL
;
5031 parallel_device_index
= 0;
5033 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++)
5034 virtio_consoles
[i
] = NULL
;
5035 virtio_console_index
= 0;
5037 for (i
= 0; i
< MAX_NODES
; i
++) {
5039 node_cpumask
[i
] = 0;
5042 usb_devices_index
= 0;
5056 register_watchdogs();
5064 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
5066 const QEMUOption
*popt
;
5069 /* Treat --foo the same as -foo. */
5072 popt
= qemu_options
;
5075 fprintf(stderr
, "%s: invalid option -- '%s'\n",
5079 if (!strcmp(popt
->name
, r
+ 1))
5083 if (popt
->flags
& HAS_ARG
) {
5084 if (optind
>= argc
) {
5085 fprintf(stderr
, "%s: option '%s' requires an argument\n",
5089 optarg
= argv
[optind
++];
5094 switch(popt
->index
) {
5096 machine
= find_machine(optarg
);
5099 printf("Supported machines are:\n");
5100 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
5101 printf("%-10s %s%s\n",
5103 m
->is_default
? " (default)" : "");
5105 exit(*optarg
!= '?');
5108 case QEMU_OPTION_cpu
:
5109 /* hw initialization will check this */
5110 if (*optarg
== '?') {
5111 /* XXX: implement xxx_cpu_list for targets that still miss it */
5112 #if defined(cpu_list)
5113 cpu_list(stdout
, &fprintf
);
5120 case QEMU_OPTION_initrd
:
5121 initrd_filename
= optarg
;
5123 case QEMU_OPTION_hda
:
5125 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
5127 hda_index
= drive_add(optarg
, HD_ALIAS
5128 ",cyls=%d,heads=%d,secs=%d%s",
5129 0, cyls
, heads
, secs
,
5130 translation
== BIOS_ATA_TRANSLATION_LBA
?
5132 translation
== BIOS_ATA_TRANSLATION_NONE
?
5133 ",trans=none" : "");
5135 case QEMU_OPTION_hdb
:
5136 case QEMU_OPTION_hdc
:
5137 case QEMU_OPTION_hdd
:
5138 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
5140 case QEMU_OPTION_drive
:
5141 drive_add(NULL
, "%s", optarg
);
5143 case QEMU_OPTION_mtdblock
:
5144 drive_add(optarg
, MTD_ALIAS
);
5146 case QEMU_OPTION_sd
:
5147 drive_add(optarg
, SD_ALIAS
);
5149 case QEMU_OPTION_pflash
:
5150 drive_add(optarg
, PFLASH_ALIAS
);
5152 case QEMU_OPTION_snapshot
:
5155 case QEMU_OPTION_hdachs
:
5159 cyls
= strtol(p
, (char **)&p
, 0);
5160 if (cyls
< 1 || cyls
> 16383)
5165 heads
= strtol(p
, (char **)&p
, 0);
5166 if (heads
< 1 || heads
> 16)
5171 secs
= strtol(p
, (char **)&p
, 0);
5172 if (secs
< 1 || secs
> 63)
5176 if (!strcmp(p
, "none"))
5177 translation
= BIOS_ATA_TRANSLATION_NONE
;
5178 else if (!strcmp(p
, "lba"))
5179 translation
= BIOS_ATA_TRANSLATION_LBA
;
5180 else if (!strcmp(p
, "auto"))
5181 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5184 } else if (*p
!= '\0') {
5186 fprintf(stderr
, "qemu: invalid physical CHS format\n");
5189 if (hda_index
!= -1)
5190 snprintf(drives_opt
[hda_index
].opt
,
5191 sizeof(drives_opt
[hda_index
].opt
),
5192 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
5193 0, cyls
, heads
, secs
,
5194 translation
== BIOS_ATA_TRANSLATION_LBA
?
5196 translation
== BIOS_ATA_TRANSLATION_NONE
?
5197 ",trans=none" : "");
5200 case QEMU_OPTION_numa
:
5201 if (nb_numa_nodes
>= MAX_NODES
) {
5202 fprintf(stderr
, "qemu: too many NUMA nodes\n");
5207 case QEMU_OPTION_nographic
:
5208 display_type
= DT_NOGRAPHIC
;
5210 #ifdef CONFIG_CURSES
5211 case QEMU_OPTION_curses
:
5212 display_type
= DT_CURSES
;
5215 case QEMU_OPTION_portrait
:
5218 case QEMU_OPTION_kernel
:
5219 kernel_filename
= optarg
;
5221 case QEMU_OPTION_append
:
5222 kernel_cmdline
= optarg
;
5224 case QEMU_OPTION_cdrom
:
5225 drive_add(optarg
, CDROM_ALIAS
);
5227 case QEMU_OPTION_boot
:
5228 boot_devices
= optarg
;
5229 /* We just do some generic consistency checks */
5231 /* Could easily be extended to 64 devices if needed */
5234 boot_devices_bitmap
= 0;
5235 for (p
= boot_devices
; *p
!= '\0'; p
++) {
5236 /* Allowed boot devices are:
5237 * a b : floppy disk drives
5238 * c ... f : IDE disk drives
5239 * g ... m : machine implementation dependant drives
5240 * n ... p : network devices
5241 * It's up to each machine implementation to check
5242 * if the given boot devices match the actual hardware
5243 * implementation and firmware features.
5245 if (*p
< 'a' || *p
> 'q') {
5246 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
5249 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
5251 "Boot device '%c' was given twice\n",*p
);
5254 boot_devices_bitmap
|= 1 << (*p
- 'a');
5258 case QEMU_OPTION_fda
:
5259 case QEMU_OPTION_fdb
:
5260 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
5263 case QEMU_OPTION_no_fd_bootchk
:
5267 case QEMU_OPTION_net
:
5268 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
5269 fprintf(stderr
, "qemu: too many network clients\n");
5272 net_clients
[nb_net_clients
] = optarg
;
5276 case QEMU_OPTION_tftp
:
5277 tftp_prefix
= optarg
;
5279 case QEMU_OPTION_bootp
:
5280 bootp_filename
= optarg
;
5283 case QEMU_OPTION_smb
:
5284 net_slirp_smb(optarg
);
5287 case QEMU_OPTION_redir
:
5288 net_slirp_redir(NULL
, optarg
, NULL
);
5291 case QEMU_OPTION_bt
:
5292 if (nb_bt_opts
>= MAX_BT_CMDLINE
) {
5293 fprintf(stderr
, "qemu: too many bluetooth options\n");
5296 bt_opts
[nb_bt_opts
++] = optarg
;
5299 case QEMU_OPTION_audio_help
:
5303 case QEMU_OPTION_soundhw
:
5304 select_soundhw (optarg
);
5310 case QEMU_OPTION_version
:
5314 case QEMU_OPTION_m
: {
5318 value
= strtoul(optarg
, &ptr
, 10);
5320 case 0: case 'M': case 'm':
5327 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
5331 /* On 32-bit hosts, QEMU is limited by virtual address space */
5332 if (value
> (2047 << 20)
5333 #ifndef CONFIG_KQEMU
5334 && HOST_LONG_BITS
== 32
5337 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
5340 if (value
!= (uint64_t)(ram_addr_t
)value
) {
5341 fprintf(stderr
, "qemu: ram size too large\n");
5350 const CPULogItem
*item
;
5352 mask
= cpu_str_to_log_mask(optarg
);
5354 printf("Log items (comma separated):\n");
5355 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
5356 printf("%-10s %s\n", item
->name
, item
->help
);
5364 gdbstub_dev
= "tcp::" DEFAULT_GDBSTUB_PORT
;
5366 case QEMU_OPTION_gdb
:
5367 gdbstub_dev
= optarg
;
5372 case QEMU_OPTION_bios
:
5375 case QEMU_OPTION_singlestep
:
5383 keyboard_layout
= optarg
;
5386 case QEMU_OPTION_localtime
:
5389 case QEMU_OPTION_vga
:
5390 select_vgahw (optarg
);
5392 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5398 w
= strtol(p
, (char **)&p
, 10);
5401 fprintf(stderr
, "qemu: invalid resolution or depth\n");
5407 h
= strtol(p
, (char **)&p
, 10);
5412 depth
= strtol(p
, (char **)&p
, 10);
5413 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
5414 depth
!= 24 && depth
!= 32)
5416 } else if (*p
== '\0') {
5417 depth
= graphic_depth
;
5424 graphic_depth
= depth
;
5428 case QEMU_OPTION_echr
:
5431 term_escape_char
= strtol(optarg
, &r
, 0);
5433 printf("Bad argument to echr\n");
5436 case QEMU_OPTION_monitor
:
5437 monitor_device
= optarg
;
5439 case QEMU_OPTION_serial
:
5440 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
5441 fprintf(stderr
, "qemu: too many serial ports\n");
5444 serial_devices
[serial_device_index
] = optarg
;
5445 serial_device_index
++;
5447 case QEMU_OPTION_watchdog
:
5448 i
= select_watchdog(optarg
);
5450 exit (i
== 1 ? 1 : 0);
5452 case QEMU_OPTION_watchdog_action
:
5453 if (select_watchdog_action(optarg
) == -1) {
5454 fprintf(stderr
, "Unknown -watchdog-action parameter\n");
5458 case QEMU_OPTION_virtiocon
:
5459 if (virtio_console_index
>= MAX_VIRTIO_CONSOLES
) {
5460 fprintf(stderr
, "qemu: too many virtio consoles\n");
5463 virtio_consoles
[virtio_console_index
] = optarg
;
5464 virtio_console_index
++;
5466 case QEMU_OPTION_parallel
:
5467 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
5468 fprintf(stderr
, "qemu: too many parallel ports\n");
5471 parallel_devices
[parallel_device_index
] = optarg
;
5472 parallel_device_index
++;
5474 case QEMU_OPTION_loadvm
:
5477 case QEMU_OPTION_full_screen
:
5481 case QEMU_OPTION_no_frame
:
5484 case QEMU_OPTION_alt_grab
:
5487 case QEMU_OPTION_no_quit
:
5490 case QEMU_OPTION_sdl
:
5491 display_type
= DT_SDL
;
5494 case QEMU_OPTION_pidfile
:
5498 case QEMU_OPTION_win2k_hack
:
5499 win2k_install_hack
= 1;
5501 case QEMU_OPTION_rtc_td_hack
:
5504 case QEMU_OPTION_acpitable
:
5505 if(acpi_table_add(optarg
) < 0) {
5506 fprintf(stderr
, "Wrong acpi table provided\n");
5510 case QEMU_OPTION_smbios
:
5511 if(smbios_entry_add(optarg
) < 0) {
5512 fprintf(stderr
, "Wrong smbios provided\n");
5518 case QEMU_OPTION_no_kqemu
:
5521 case QEMU_OPTION_kernel_kqemu
:
5526 case QEMU_OPTION_enable_kvm
:
5533 case QEMU_OPTION_usb
:
5536 case QEMU_OPTION_usbdevice
:
5538 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
5539 fprintf(stderr
, "Too many USB devices\n");
5542 usb_devices
[usb_devices_index
] = optarg
;
5543 usb_devices_index
++;
5545 case QEMU_OPTION_smp
:
5546 smp_cpus
= atoi(optarg
);
5548 fprintf(stderr
, "Invalid number of CPUs\n");
5552 case QEMU_OPTION_vnc
:
5553 display_type
= DT_VNC
;
5554 vnc_display
= optarg
;
5557 case QEMU_OPTION_no_acpi
:
5560 case QEMU_OPTION_no_hpet
:
5564 case QEMU_OPTION_no_reboot
:
5567 case QEMU_OPTION_no_shutdown
:
5570 case QEMU_OPTION_show_cursor
:
5573 case QEMU_OPTION_uuid
:
5574 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
5575 fprintf(stderr
, "Fail to parse UUID string."
5576 " Wrong format.\n");
5581 case QEMU_OPTION_daemonize
:
5585 case QEMU_OPTION_option_rom
:
5586 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
5587 fprintf(stderr
, "Too many option ROMs\n");
5590 option_rom
[nb_option_roms
] = optarg
;
5593 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5594 case QEMU_OPTION_semihosting
:
5595 semihosting_enabled
= 1;
5598 case QEMU_OPTION_name
:
5601 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5602 case QEMU_OPTION_prom_env
:
5603 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
5604 fprintf(stderr
, "Too many prom variables\n");
5607 prom_envs
[nb_prom_envs
] = optarg
;
5612 case QEMU_OPTION_old_param
:
5616 case QEMU_OPTION_clock
:
5617 configure_alarms(optarg
);
5619 case QEMU_OPTION_startdate
:
5622 time_t rtc_start_date
;
5623 if (!strcmp(optarg
, "now")) {
5624 rtc_date_offset
= -1;
5626 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
5634 } else if (sscanf(optarg
, "%d-%d-%d",
5637 &tm
.tm_mday
) == 3) {
5646 rtc_start_date
= mktimegm(&tm
);
5647 if (rtc_start_date
== -1) {
5649 fprintf(stderr
, "Invalid date format. Valid format are:\n"
5650 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5653 rtc_date_offset
= time(NULL
) - rtc_start_date
;
5657 case QEMU_OPTION_tb_size
:
5658 tb_size
= strtol(optarg
, NULL
, 0);
5662 case QEMU_OPTION_icount
:
5664 if (strcmp(optarg
, "auto") == 0) {
5665 icount_time_shift
= -1;
5667 icount_time_shift
= strtol(optarg
, NULL
, 0);
5670 case QEMU_OPTION_incoming
:
5674 case QEMU_OPTION_chroot
:
5675 chroot_dir
= optarg
;
5677 case QEMU_OPTION_runas
:
5682 case QEMU_OPTION_xen_domid
:
5683 xen_domid
= atoi(optarg
);
5685 case QEMU_OPTION_xen_create
:
5686 xen_mode
= XEN_CREATE
;
5688 case QEMU_OPTION_xen_attach
:
5689 xen_mode
= XEN_ATTACH
;
5696 /* If no data_dir is specified then try to find it relative to the
5699 data_dir
= find_datadir(argv
[0]);
5701 /* If all else fails use the install patch specified when building. */
5703 data_dir
= CONFIG_QEMU_SHAREDIR
;
5706 #if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
5707 if (kvm_allowed
&& kqemu_allowed
) {
5709 "You can not enable both KVM and kqemu at the same time\n");
5714 machine
->max_cpus
= machine
->max_cpus
?: 1; /* Default to UP */
5715 if (smp_cpus
> machine
->max_cpus
) {
5716 fprintf(stderr
, "Number of SMP cpus requested (%d), exceeds max cpus "
5717 "supported by machine `%s' (%d)\n", smp_cpus
, machine
->name
,
5722 if (display_type
== DT_NOGRAPHIC
) {
5723 if (serial_device_index
== 0)
5724 serial_devices
[0] = "stdio";
5725 if (parallel_device_index
== 0)
5726 parallel_devices
[0] = "null";
5727 if (strncmp(monitor_device
, "vc", 2) == 0)
5728 monitor_device
= "stdio";
5735 if (pipe(fds
) == -1)
5746 len
= read(fds
[0], &status
, 1);
5747 if (len
== -1 && (errno
== EINTR
))
5752 else if (status
== 1) {
5753 fprintf(stderr
, "Could not acquire pidfile\n");
5770 signal(SIGTSTP
, SIG_IGN
);
5771 signal(SIGTTOU
, SIG_IGN
);
5772 signal(SIGTTIN
, SIG_IGN
);
5775 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
5778 write(fds
[1], &status
, 1);
5780 fprintf(stderr
, "Could not acquire pid file\n");
5789 if (qemu_init_main_loop()) {
5790 fprintf(stderr
, "qemu_init_main_loop failed\n");
5793 linux_boot
= (kernel_filename
!= NULL
);
5794 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
5796 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
5797 fprintf(stderr
, "-append only allowed with -kernel option\n");
5801 if (!linux_boot
&& initrd_filename
!= NULL
) {
5802 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
5806 /* boot to floppy or the default cd if no hard disk defined yet */
5807 if (!boot_devices
[0]) {
5808 boot_devices
= "cad";
5810 setvbuf(stdout
, NULL
, _IOLBF
, 0);
5813 if (init_timer_alarm() < 0) {
5814 fprintf(stderr
, "could not initialize alarm timer\n");
5817 if (use_icount
&& icount_time_shift
< 0) {
5819 /* 125MIPS seems a reasonable initial guess at the guest speed.
5820 It will be corrected fairly quickly anyway. */
5821 icount_time_shift
= 3;
5822 init_icount_adjust();
5829 /* init network clients */
5830 if (nb_net_clients
== 0) {
5831 /* if no clients, we use a default config */
5832 net_clients
[nb_net_clients
++] = "nic";
5834 net_clients
[nb_net_clients
++] = "user";
5838 for(i
= 0;i
< nb_net_clients
; i
++) {
5839 if (net_client_parse(net_clients
[i
]) < 0)
5845 /* XXX: this should be moved in the PC machine instantiation code */
5846 if (net_boot
!= 0) {
5848 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
5849 const char *model
= nd_table
[i
].model
;
5852 if (net_boot
& (1 << i
)) {
5855 snprintf(buf
, sizeof(buf
), "pxe-%s.bin", model
);
5856 filename
= qemu_find_file(QEMU_FILE_TYPE_BIOS
, buf
);
5857 if (filename
&& get_image_size(filename
) > 0) {
5858 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
5859 fprintf(stderr
, "Too many option ROMs\n");
5862 option_rom
[nb_option_roms
] = qemu_strdup(buf
);
5867 qemu_free(filename
);
5872 fprintf(stderr
, "No valid PXE rom found for network device\n");
5878 /* init the bluetooth world */
5879 for (i
= 0; i
< nb_bt_opts
; i
++)
5880 if (bt_parse(bt_opts
[i
]))
5883 /* init the memory */
5885 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
5888 /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5889 guest ram allocation. It needs to go away. */
5890 if (kqemu_allowed
) {
5891 kqemu_phys_ram_size
= ram_size
+ 8 * 1024 * 1024 + 4 * 1024 * 1024;
5892 kqemu_phys_ram_base
= qemu_vmalloc(kqemu_phys_ram_size
);
5893 if (!kqemu_phys_ram_base
) {
5894 fprintf(stderr
, "Could not allocate physical memory\n");
5900 /* init the dynamic translator */
5901 cpu_exec_init_all(tb_size
* 1024 * 1024);
5905 /* we always create the cdrom drive, even if no disk is there */
5907 if (nb_drives_opt
< MAX_DRIVES
)
5908 drive_add(NULL
, CDROM_ALIAS
);
5910 /* we always create at least one floppy */
5912 if (nb_drives_opt
< MAX_DRIVES
)
5913 drive_add(NULL
, FD_ALIAS
, 0);
5915 /* we always create one sd slot, even if no card is in it */
5917 if (nb_drives_opt
< MAX_DRIVES
)
5918 drive_add(NULL
, SD_ALIAS
);
5920 /* open the virtual block devices */
5922 for(i
= 0; i
< nb_drives_opt
; i
++)
5923 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
5926 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
5927 register_savevm_live("ram", 0, 3, ram_save_live
, NULL
, ram_load
, NULL
);
5930 /* must be after terminal init, SDL library changes signal handlers */
5934 /* Maintain compatibility with multiple stdio monitors */
5935 if (!strcmp(monitor_device
,"stdio")) {
5936 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
5937 const char *devname
= serial_devices
[i
];
5938 if (devname
&& !strcmp(devname
,"mon:stdio")) {
5939 monitor_device
= NULL
;
5941 } else if (devname
&& !strcmp(devname
,"stdio")) {
5942 monitor_device
= NULL
;
5943 serial_devices
[i
] = "mon:stdio";
5949 if (nb_numa_nodes
> 0) {
5952 if (nb_numa_nodes
> smp_cpus
) {
5953 nb_numa_nodes
= smp_cpus
;
5956 /* If no memory size if given for any node, assume the default case
5957 * and distribute the available memory equally across all nodes
5959 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5960 if (node_mem
[i
] != 0)
5963 if (i
== nb_numa_nodes
) {
5964 uint64_t usedmem
= 0;
5966 /* On Linux, the each node's border has to be 8MB aligned,
5967 * the final node gets the rest.
5969 for (i
= 0; i
< nb_numa_nodes
- 1; i
++) {
5970 node_mem
[i
] = (ram_size
/ nb_numa_nodes
) & ~((1 << 23UL) - 1);
5971 usedmem
+= node_mem
[i
];
5973 node_mem
[i
] = ram_size
- usedmem
;
5976 for (i
= 0; i
< nb_numa_nodes
; i
++) {
5977 if (node_cpumask
[i
] != 0)
5980 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5981 * must cope with this anyway, because there are BIOSes out there in
5982 * real machines which also use this scheme.
5984 if (i
== nb_numa_nodes
) {
5985 for (i
= 0; i
< smp_cpus
; i
++) {
5986 node_cpumask
[i
% nb_numa_nodes
] |= 1 << i
;
5991 if (kvm_enabled()) {
5994 ret
= kvm_init(smp_cpus
);
5996 fprintf(stderr
, "failed to initialize KVM\n");
6001 if (monitor_device
) {
6002 monitor_hd
= qemu_chr_open("monitor", monitor_device
, NULL
);
6004 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
6009 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
6010 const char *devname
= serial_devices
[i
];
6011 if (devname
&& strcmp(devname
, "none")) {
6013 snprintf(label
, sizeof(label
), "serial%d", i
);
6014 serial_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
6015 if (!serial_hds
[i
]) {
6016 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
6023 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
6024 const char *devname
= parallel_devices
[i
];
6025 if (devname
&& strcmp(devname
, "none")) {
6027 snprintf(label
, sizeof(label
), "parallel%d", i
);
6028 parallel_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
6029 if (!parallel_hds
[i
]) {
6030 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
6037 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++) {
6038 const char *devname
= virtio_consoles
[i
];
6039 if (devname
&& strcmp(devname
, "none")) {
6041 snprintf(label
, sizeof(label
), "virtcon%d", i
);
6042 virtcon_hds
[i
] = qemu_chr_open(label
, devname
, NULL
);
6043 if (!virtcon_hds
[i
]) {
6044 fprintf(stderr
, "qemu: could not open virtio console '%s'\n",
6051 module_call_init(MODULE_INIT_DEVICE
);
6053 machine
->init(ram_size
, boot_devices
,
6054 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
6057 for (env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
6058 for (i
= 0; i
< nb_numa_nodes
; i
++) {
6059 if (node_cpumask
[i
] & (1 << env
->cpu_index
)) {
6065 current_machine
= machine
;
6067 /* Set KVM's vcpu state to qemu's initial CPUState. */
6068 if (kvm_enabled()) {
6071 ret
= kvm_sync_vcpus();
6073 fprintf(stderr
, "failed to initialize vcpus\n");
6078 /* init USB devices */
6080 for(i
= 0; i
< usb_devices_index
; i
++) {
6081 if (usb_device_add(usb_devices
[i
], 0) < 0) {
6082 fprintf(stderr
, "Warning: could not add USB device %s\n",
6089 dumb_display_init();
6090 /* just use the first displaystate for the moment */
6093 if (display_type
== DT_DEFAULT
) {
6094 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
6095 display_type
= DT_SDL
;
6097 display_type
= DT_VNC
;
6098 vnc_display
= "localhost:0,to=99";
6104 switch (display_type
) {
6107 #if defined(CONFIG_CURSES)
6109 curses_display_init(ds
, full_screen
);
6112 #if defined(CONFIG_SDL)
6114 sdl_display_init(ds
, full_screen
, no_frame
);
6116 #elif defined(CONFIG_COCOA)
6118 cocoa_display_init(ds
, full_screen
);
6122 vnc_display_init(ds
);
6123 if (vnc_display_open(ds
, vnc_display
) < 0)
6126 if (show_vnc_port
) {
6127 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds
));
6135 dcl
= ds
->listeners
;
6136 while (dcl
!= NULL
) {
6137 if (dcl
->dpy_refresh
!= NULL
) {
6138 ds
->gui_timer
= qemu_new_timer(rt_clock
, gui_update
, ds
);
6139 qemu_mod_timer(ds
->gui_timer
, qemu_get_clock(rt_clock
));
6144 if (display_type
== DT_NOGRAPHIC
|| display_type
== DT_VNC
) {
6145 nographic_timer
= qemu_new_timer(rt_clock
, nographic_update
, NULL
);
6146 qemu_mod_timer(nographic_timer
, qemu_get_clock(rt_clock
));
6149 text_consoles_set_display(display_state
);
6150 qemu_chr_initial_reset();
6152 if (monitor_device
&& monitor_hd
)
6153 monitor_init(monitor_hd
, MONITOR_USE_READLINE
| MONITOR_IS_DEFAULT
);
6155 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
6156 const char *devname
= serial_devices
[i
];
6157 if (devname
&& strcmp(devname
, "none")) {
6159 snprintf(label
, sizeof(label
), "serial%d", i
);
6160 if (strstart(devname
, "vc", 0))
6161 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
6165 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
6166 const char *devname
= parallel_devices
[i
];
6167 if (devname
&& strcmp(devname
, "none")) {
6169 snprintf(label
, sizeof(label
), "parallel%d", i
);
6170 if (strstart(devname
, "vc", 0))
6171 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
6175 for(i
= 0; i
< MAX_VIRTIO_CONSOLES
; i
++) {
6176 const char *devname
= virtio_consoles
[i
];
6177 if (virtcon_hds
[i
] && devname
) {
6179 snprintf(label
, sizeof(label
), "virtcon%d", i
);
6180 if (strstart(devname
, "vc", 0))
6181 qemu_chr_printf(virtcon_hds
[i
], "virtio console%d\r\n", i
);
6185 if (gdbstub_dev
&& gdbserver_start(gdbstub_dev
) < 0) {
6186 fprintf(stderr
, "qemu: could not open gdbserver on device '%s'\n",
6192 do_loadvm(cur_mon
, loadvm
);
6195 autostart
= 0; /* fixme how to deal with -daemonize */
6196 qemu_start_incoming_migration(incoming
);
6208 len
= write(fds
[1], &status
, 1);
6209 if (len
== -1 && (errno
== EINTR
))
6216 TFR(fd
= open("/dev/null", O_RDWR
));
6222 pwd
= getpwnam(run_as
);
6224 fprintf(stderr
, "User \"%s\" doesn't exist\n", run_as
);
6230 if (chroot(chroot_dir
) < 0) {
6231 fprintf(stderr
, "chroot failed\n");
6238 if (setgid(pwd
->pw_gid
) < 0) {
6239 fprintf(stderr
, "Failed to setgid(%d)\n", pwd
->pw_gid
);
6242 if (setuid(pwd
->pw_uid
) < 0) {
6243 fprintf(stderr
, "Failed to setuid(%d)\n", pwd
->pw_uid
);
6246 if (setuid(0) != -1) {
6247 fprintf(stderr
, "Dropping privileges failed\n");