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"
37 #include <sys/times.h>
41 #include <sys/ioctl.h>
42 #include <sys/resource.h>
43 #include <sys/socket.h>
44 #include <netinet/in.h>
46 #if defined(__NetBSD__)
47 #include <net/if_tap.h>
50 #include <linux/if_tun.h>
52 #include <arpa/inet.h>
55 #include <sys/select.h>
58 #if defined(__FreeBSD__) || defined(__DragonFly__)
63 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
64 #include <freebsd/stdlib.h>
69 #include <linux/rtc.h>
71 /* For the benefit of older linux systems which don't supply it,
72 we use a local copy of hpet.h. */
73 /* #include <linux/hpet.h> */
76 #include <linux/ppdev.h>
77 #include <linux/parport.h>
81 #include <sys/ethernet.h>
82 #include <sys/sockio.h>
83 #include <netinet/arp.h>
84 #include <netinet/in.h>
85 #include <netinet/in_systm.h>
86 #include <netinet/ip.h>
87 #include <netinet/ip_icmp.h> // must come after ip.h
88 #include <netinet/udp.h>
89 #include <netinet/tcp.h>
97 #if defined(__OpenBSD__)
101 #if defined(CONFIG_VDE)
102 #include <libvdeplug.h>
108 #include <sys/timeb.h>
109 #include <mmsystem.h>
110 #define getopt_long_only getopt_long
111 #define memalign(align, size) malloc(size)
117 int qemu_main(int argc, char **argv, char **envp);
118 int main(int argc, char **argv)
120 qemu_main(argc, argv, NULL);
123 #define main qemu_main
125 #endif /* CONFIG_SDL */
129 #define main qemu_main
130 #endif /* CONFIG_COCOA */
133 #include "hw/boards.h"
135 #include "hw/pcmcia.h"
137 #include "hw/audiodev.h"
147 #include "qemu-timer.h"
148 #include "qemu-char.h"
149 #include "cache-utils.h"
152 #include "audio/audio.h"
153 #include "migration.h"
159 #include "exec-all.h"
161 #include "qemu_socket.h"
163 #if defined(CONFIG_SLIRP)
164 #include "libslirp.h"
167 //#define DEBUG_UNUSED_IOPORT
168 //#define DEBUG_IOPORT
170 //#define DEBUG_SLIRP
174 # define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
176 # define LOG_IOPORT(...) do { } while (0)
179 #define DEFAULT_RAM_SIZE 128
181 /* Max number of USB devices that can be specified on the commandline. */
182 #define MAX_USB_CMDLINE 8
184 /* Max number of bluetooth switches on the commandline. */
185 #define MAX_BT_CMDLINE 10
187 /* XXX: use a two level table to limit memory usage */
188 #define MAX_IOPORTS 65536
190 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
191 const char *bios_name = NULL;
192 static void *ioport_opaque[MAX_IOPORTS];
193 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
194 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
195 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
196 to store the VM snapshots */
197 DriveInfo drives_table[MAX_DRIVES+1];
199 static int vga_ram_size;
200 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
201 static DisplayState *display_state;
205 const char* keyboard_layout = NULL;
206 int64_t ticks_per_sec;
209 NICInfo nd_table[MAX_NICS];
211 static int autostart;
212 static int rtc_utc = 1;
213 static int rtc_date_offset = -1; /* -1 means no change */
214 int cirrus_vga_enabled = 1;
215 int std_vga_enabled = 0;
216 int vmsvga_enabled = 0;
218 int graphic_width = 1024;
219 int graphic_height = 768;
220 int graphic_depth = 8;
222 int graphic_width = 800;
223 int graphic_height = 600;
224 int graphic_depth = 15;
226 static int full_screen = 0;
228 static int no_frame = 0;
231 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
232 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
233 CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
235 int win2k_install_hack = 0;
241 const char *vnc_display;
242 int acpi_enabled = 1;
248 int graphic_rotate = 0;
252 const char *option_rom[MAX_OPTION_ROMS];
254 int semihosting_enabled = 0;
258 const char *qemu_name;
260 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
261 unsigned int nb_prom_envs = 0;
262 const char *prom_envs[MAX_PROM_ENVS];
265 struct drive_opt drives_opt[MAX_DRIVES];
267 static CPUState *cur_cpu;
268 static CPUState *next_cpu;
269 static int event_pending = 1;
270 /* Conversion factor from emulated instructions to virtual clock ticks. */
271 static int icount_time_shift;
272 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
273 #define MAX_ICOUNT_SHIFT 10
274 /* Compensate for varying guest execution speed. */
275 static int64_t qemu_icount_bias;
276 static QEMUTimer *icount_rt_timer;
277 static QEMUTimer *icount_vm_timer;
278 static QEMUTimer *nographic_timer;
280 uint8_t qemu_uuid[16];
282 /***********************************************************/
283 /* x86 ISA bus support */
285 target_phys_addr_t isa_mem_base = 0;
288 static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
289 static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
291 static uint32_t ioport_read(int index, uint32_t address)
293 static IOPortReadFunc *default_func[3] = {
294 default_ioport_readb,
295 default_ioport_readw,
298 IOPortReadFunc *func = ioport_read_table[index][address];
300 func = default_func[index];
301 return func(ioport_opaque[address], address);
304 static void ioport_write(int index, uint32_t address, uint32_t data)
306 static IOPortWriteFunc *default_func[3] = {
307 default_ioport_writeb,
308 default_ioport_writew,
309 default_ioport_writel
311 IOPortWriteFunc *func = ioport_write_table[index][address];
313 func = default_func[index];
314 func(ioport_opaque[address], address, data);
317 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
319 #ifdef DEBUG_UNUSED_IOPORT
320 fprintf(stderr, "unused inb: port=0x%04x\n", address);
325 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
327 #ifdef DEBUG_UNUSED_IOPORT
328 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
332 /* default is to make two byte accesses */
333 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
336 data = ioport_read(0, address);
337 address = (address + 1) & (MAX_IOPORTS - 1);
338 data |= ioport_read(0, address) << 8;
342 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
344 ioport_write(0, address, data & 0xff);
345 address = (address + 1) & (MAX_IOPORTS - 1);
346 ioport_write(0, address, (data >> 8) & 0xff);
349 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
351 #ifdef DEBUG_UNUSED_IOPORT
352 fprintf(stderr, "unused inl: port=0x%04x\n", address);
357 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
359 #ifdef DEBUG_UNUSED_IOPORT
360 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
364 /* size is the word size in byte */
365 int register_ioport_read(int start, int length, int size,
366 IOPortReadFunc *func, void *opaque)
372 } else if (size == 2) {
374 } else if (size == 4) {
377 hw_error("register_ioport_read: invalid size");
380 for(i = start; i < start + length; i += size) {
381 ioport_read_table[bsize][i] = func;
382 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
383 hw_error("register_ioport_read: invalid opaque");
384 ioport_opaque[i] = opaque;
389 /* size is the word size in byte */
390 int register_ioport_write(int start, int length, int size,
391 IOPortWriteFunc *func, void *opaque)
397 } else if (size == 2) {
399 } else if (size == 4) {
402 hw_error("register_ioport_write: invalid size");
405 for(i = start; i < start + length; i += size) {
406 ioport_write_table[bsize][i] = func;
407 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
408 hw_error("register_ioport_write: invalid opaque");
409 ioport_opaque[i] = opaque;
414 void isa_unassign_ioport(int start, int length)
418 for(i = start; i < start + length; i++) {
419 ioport_read_table[0][i] = default_ioport_readb;
420 ioport_read_table[1][i] = default_ioport_readw;
421 ioport_read_table[2][i] = default_ioport_readl;
423 ioport_write_table[0][i] = default_ioport_writeb;
424 ioport_write_table[1][i] = default_ioport_writew;
425 ioport_write_table[2][i] = default_ioport_writel;
427 ioport_opaque[i] = NULL;
431 /***********************************************************/
433 void cpu_outb(CPUState *env, int addr, int val)
435 LOG_IOPORT("outb: %04x %02x\n", addr, val);
436 ioport_write(0, addr, val);
439 env->last_io_time = cpu_get_time_fast();
443 void cpu_outw(CPUState *env, int addr, int val)
445 LOG_IOPORT("outw: %04x %04x\n", addr, val);
446 ioport_write(1, addr, val);
449 env->last_io_time = cpu_get_time_fast();
453 void cpu_outl(CPUState *env, int addr, int val)
455 LOG_IOPORT("outl: %04x %08x\n", addr, val);
456 ioport_write(2, addr, val);
459 env->last_io_time = cpu_get_time_fast();
463 int cpu_inb(CPUState *env, int addr)
466 val = ioport_read(0, addr);
467 LOG_IOPORT("inb : %04x %02x\n", addr, val);
470 env->last_io_time = cpu_get_time_fast();
475 int cpu_inw(CPUState *env, int addr)
478 val = ioport_read(1, addr);
479 LOG_IOPORT("inw : %04x %04x\n", addr, val);
482 env->last_io_time = cpu_get_time_fast();
487 int cpu_inl(CPUState *env, int addr)
490 val = ioport_read(2, addr);
491 LOG_IOPORT("inl : %04x %08x\n", addr, val);
494 env->last_io_time = cpu_get_time_fast();
499 /***********************************************************/
500 void hw_error(const char *fmt, ...)
506 fprintf(stderr, "qemu: hardware error: ");
507 vfprintf(stderr, fmt, ap);
508 fprintf(stderr, "\n");
509 for(env = first_cpu; env != NULL; env = env->next_cpu) {
510 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
512 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
514 cpu_dump_state(env, stderr, fprintf, 0);
524 static QEMUBalloonEvent *qemu_balloon_event;
525 void *qemu_balloon_event_opaque;
527 void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
529 qemu_balloon_event = func;
530 qemu_balloon_event_opaque = opaque;
533 void qemu_balloon(ram_addr_t target)
535 if (qemu_balloon_event)
536 qemu_balloon_event(qemu_balloon_event_opaque, target);
539 ram_addr_t qemu_balloon_status(void)
541 if (qemu_balloon_event)
542 return qemu_balloon_event(qemu_balloon_event_opaque, 0);
546 /***********************************************************/
549 static QEMUPutKBDEvent *qemu_put_kbd_event;
550 static void *qemu_put_kbd_event_opaque;
551 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
552 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
554 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
556 qemu_put_kbd_event_opaque = opaque;
557 qemu_put_kbd_event = func;
560 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
561 void *opaque, int absolute,
564 QEMUPutMouseEntry *s, *cursor;
566 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
568 s->qemu_put_mouse_event = func;
569 s->qemu_put_mouse_event_opaque = opaque;
570 s->qemu_put_mouse_event_absolute = absolute;
571 s->qemu_put_mouse_event_name = qemu_strdup(name);
574 if (!qemu_put_mouse_event_head) {
575 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
579 cursor = qemu_put_mouse_event_head;
580 while (cursor->next != NULL)
581 cursor = cursor->next;
584 qemu_put_mouse_event_current = s;
589 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
591 QEMUPutMouseEntry *prev = NULL, *cursor;
593 if (!qemu_put_mouse_event_head || entry == NULL)
596 cursor = qemu_put_mouse_event_head;
597 while (cursor != NULL && cursor != entry) {
599 cursor = cursor->next;
602 if (cursor == NULL) // does not exist or list empty
604 else if (prev == NULL) { // entry is head
605 qemu_put_mouse_event_head = cursor->next;
606 if (qemu_put_mouse_event_current == entry)
607 qemu_put_mouse_event_current = cursor->next;
608 qemu_free(entry->qemu_put_mouse_event_name);
613 prev->next = entry->next;
615 if (qemu_put_mouse_event_current == entry)
616 qemu_put_mouse_event_current = prev;
618 qemu_free(entry->qemu_put_mouse_event_name);
622 void kbd_put_keycode(int keycode)
624 if (qemu_put_kbd_event) {
625 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
629 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
631 QEMUPutMouseEvent *mouse_event;
632 void *mouse_event_opaque;
635 if (!qemu_put_mouse_event_current) {
640 qemu_put_mouse_event_current->qemu_put_mouse_event;
642 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
645 if (graphic_rotate) {
646 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
649 width = graphic_width - 1;
650 mouse_event(mouse_event_opaque,
651 width - dy, dx, dz, buttons_state);
653 mouse_event(mouse_event_opaque,
654 dx, dy, dz, buttons_state);
658 int kbd_mouse_is_absolute(void)
660 if (!qemu_put_mouse_event_current)
663 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
666 void do_info_mice(Monitor *mon)
668 QEMUPutMouseEntry *cursor;
671 if (!qemu_put_mouse_event_head) {
672 monitor_printf(mon, "No mouse devices connected\n");
676 monitor_printf(mon, "Mouse devices available:\n");
677 cursor = qemu_put_mouse_event_head;
678 while (cursor != NULL) {
679 monitor_printf(mon, "%c Mouse #%d: %s\n",
680 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
681 index, cursor->qemu_put_mouse_event_name);
683 cursor = cursor->next;
687 void do_mouse_set(Monitor *mon, int index)
689 QEMUPutMouseEntry *cursor;
692 if (!qemu_put_mouse_event_head) {
693 monitor_printf(mon, "No mouse devices connected\n");
697 cursor = qemu_put_mouse_event_head;
698 while (cursor != NULL && index != i) {
700 cursor = cursor->next;
704 qemu_put_mouse_event_current = cursor;
706 monitor_printf(mon, "Mouse at given index not found\n");
709 /* compute with 96 bit intermediate result: (a*b)/c */
710 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
715 #ifdef WORDS_BIGENDIAN
725 rl = (uint64_t)u.l.low * (uint64_t)b;
726 rh = (uint64_t)u.l.high * (uint64_t)b;
729 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
733 /***********************************************************/
734 /* real time host monotonic timer */
736 #define QEMU_TIMER_BASE 1000000000LL
740 static int64_t clock_freq;
742 static void init_get_clock(void)
746 ret = QueryPerformanceFrequency(&freq);
748 fprintf(stderr, "Could not calibrate ticks\n");
751 clock_freq = freq.QuadPart;
754 static int64_t get_clock(void)
757 QueryPerformanceCounter(&ti);
758 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
763 static int use_rt_clock;
765 static void init_get_clock(void)
768 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
769 || defined(__DragonFly__)
772 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
779 static int64_t get_clock(void)
781 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
782 || defined(__DragonFly__)
785 clock_gettime(CLOCK_MONOTONIC, &ts);
786 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
790 /* XXX: using gettimeofday leads to problems if the date
791 changes, so it should be avoided. */
793 gettimeofday(&tv, NULL);
794 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
799 /* Return the virtual CPU time, based on the instruction counter. */
800 static int64_t cpu_get_icount(void)
803 CPUState *env = cpu_single_env;;
804 icount = qemu_icount;
807 fprintf(stderr, "Bad clock read\n");
808 icount -= (env->icount_decr.u16.low + env->icount_extra);
810 return qemu_icount_bias + (icount << icount_time_shift);
813 /***********************************************************/
814 /* guest cycle counter */
816 static int64_t cpu_ticks_prev;
817 static int64_t cpu_ticks_offset;
818 static int64_t cpu_clock_offset;
819 static int cpu_ticks_enabled;
821 /* return the host CPU cycle counter and handle stop/restart */
822 int64_t cpu_get_ticks(void)
825 return cpu_get_icount();
827 if (!cpu_ticks_enabled) {
828 return cpu_ticks_offset;
831 ticks = cpu_get_real_ticks();
832 if (cpu_ticks_prev > ticks) {
833 /* Note: non increasing ticks may happen if the host uses
835 cpu_ticks_offset += cpu_ticks_prev - ticks;
837 cpu_ticks_prev = ticks;
838 return ticks + cpu_ticks_offset;
842 /* return the host CPU monotonic timer and handle stop/restart */
843 static int64_t cpu_get_clock(void)
846 if (!cpu_ticks_enabled) {
847 return cpu_clock_offset;
850 return ti + cpu_clock_offset;
854 /* enable cpu_get_ticks() */
855 void cpu_enable_ticks(void)
857 if (!cpu_ticks_enabled) {
858 cpu_ticks_offset -= cpu_get_real_ticks();
859 cpu_clock_offset -= get_clock();
860 cpu_ticks_enabled = 1;
864 /* disable cpu_get_ticks() : the clock is stopped. You must not call
865 cpu_get_ticks() after that. */
866 void cpu_disable_ticks(void)
868 if (cpu_ticks_enabled) {
869 cpu_ticks_offset = cpu_get_ticks();
870 cpu_clock_offset = cpu_get_clock();
871 cpu_ticks_enabled = 0;
875 /***********************************************************/
878 #define QEMU_TIMER_REALTIME 0
879 #define QEMU_TIMER_VIRTUAL 1
883 /* XXX: add frequency */
891 struct QEMUTimer *next;
894 struct qemu_alarm_timer {
898 int (*start)(struct qemu_alarm_timer *t);
899 void (*stop)(struct qemu_alarm_timer *t);
900 void (*rearm)(struct qemu_alarm_timer *t);
904 #define ALARM_FLAG_DYNTICKS 0x1
905 #define ALARM_FLAG_EXPIRED 0x2
907 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
909 return t->flags & ALARM_FLAG_DYNTICKS;
912 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
914 if (!alarm_has_dynticks(t))
920 /* TODO: MIN_TIMER_REARM_US should be optimized */
921 #define MIN_TIMER_REARM_US 250
923 static struct qemu_alarm_timer *alarm_timer;
925 static int alarm_timer_rfd, alarm_timer_wfd;
930 struct qemu_alarm_win32 {
934 } alarm_win32_data = {0, NULL, -1};
936 static int win32_start_timer(struct qemu_alarm_timer *t);
937 static void win32_stop_timer(struct qemu_alarm_timer *t);
938 static void win32_rearm_timer(struct qemu_alarm_timer *t);
942 static int unix_start_timer(struct qemu_alarm_timer *t);
943 static void unix_stop_timer(struct qemu_alarm_timer *t);
947 static int dynticks_start_timer(struct qemu_alarm_timer *t);
948 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
949 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
951 static int hpet_start_timer(struct qemu_alarm_timer *t);
952 static void hpet_stop_timer(struct qemu_alarm_timer *t);
954 static int rtc_start_timer(struct qemu_alarm_timer *t);
955 static void rtc_stop_timer(struct qemu_alarm_timer *t);
957 #endif /* __linux__ */
961 /* Correlation between real and virtual time is always going to be
962 fairly approximate, so ignore small variation.
963 When the guest is idle real and virtual time will be aligned in
965 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
967 static void icount_adjust(void)
972 static int64_t last_delta;
973 /* If the VM is not running, then do nothing. */
977 cur_time = cpu_get_clock();
978 cur_icount = qemu_get_clock(vm_clock);
979 delta = cur_icount - cur_time;
980 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
982 && last_delta + ICOUNT_WOBBLE < delta * 2
983 && icount_time_shift > 0) {
984 /* The guest is getting too far ahead. Slow time down. */
988 && last_delta - ICOUNT_WOBBLE > delta * 2
989 && icount_time_shift < MAX_ICOUNT_SHIFT) {
990 /* The guest is getting too far behind. Speed time up. */
994 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
997 static void icount_adjust_rt(void * opaque)
999 qemu_mod_timer(icount_rt_timer,
1000 qemu_get_clock(rt_clock) + 1000);
1004 static void icount_adjust_vm(void * opaque)
1006 qemu_mod_timer(icount_vm_timer,
1007 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1011 static void init_icount_adjust(void)
1013 /* Have both realtime and virtual time triggers for speed adjustment.
1014 The realtime trigger catches emulated time passing too slowly,
1015 the virtual time trigger catches emulated time passing too fast.
1016 Realtime triggers occur even when idle, so use them less frequently
1017 than VM triggers. */
1018 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
1019 qemu_mod_timer(icount_rt_timer,
1020 qemu_get_clock(rt_clock) + 1000);
1021 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
1022 qemu_mod_timer(icount_vm_timer,
1023 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1026 static struct qemu_alarm_timer alarm_timers[] = {
1029 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1030 dynticks_stop_timer, dynticks_rearm_timer, NULL},
1031 /* HPET - if available - is preferred */
1032 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1033 /* ...otherwise try RTC */
1034 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1036 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1038 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1039 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1040 {"win32", 0, win32_start_timer,
1041 win32_stop_timer, NULL, &alarm_win32_data},
1046 static void show_available_alarms(void)
1050 printf("Available alarm timers, in order of precedence:\n");
1051 for (i = 0; alarm_timers[i].name; i++)
1052 printf("%s\n", alarm_timers[i].name);
1055 static void configure_alarms(char const *opt)
1059 int count = ARRAY_SIZE(alarm_timers) - 1;
1062 struct qemu_alarm_timer tmp;
1064 if (!strcmp(opt, "?")) {
1065 show_available_alarms();
1071 /* Reorder the array */
1072 name = strtok(arg, ",");
1074 for (i = 0; i < count && alarm_timers[i].name; i++) {
1075 if (!strcmp(alarm_timers[i].name, name))
1080 fprintf(stderr, "Unknown clock %s\n", name);
1089 tmp = alarm_timers[i];
1090 alarm_timers[i] = alarm_timers[cur];
1091 alarm_timers[cur] = tmp;
1095 name = strtok(NULL, ",");
1101 /* Disable remaining timers */
1102 for (i = cur; i < count; i++)
1103 alarm_timers[i].name = NULL;
1105 show_available_alarms();
1110 QEMUClock *rt_clock;
1111 QEMUClock *vm_clock;
1113 static QEMUTimer *active_timers[2];
1115 static QEMUClock *qemu_new_clock(int type)
1118 clock = qemu_mallocz(sizeof(QEMUClock));
1123 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1127 ts = qemu_mallocz(sizeof(QEMUTimer));
1130 ts->opaque = opaque;
1134 void qemu_free_timer(QEMUTimer *ts)
1139 /* stop a timer, but do not dealloc it */
1140 void qemu_del_timer(QEMUTimer *ts)
1144 /* NOTE: this code must be signal safe because
1145 qemu_timer_expired() can be called from a signal. */
1146 pt = &active_timers[ts->clock->type];
1159 /* modify the current timer so that it will be fired when current_time
1160 >= expire_time. The corresponding callback will be called. */
1161 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1167 /* add the timer in the sorted list */
1168 /* NOTE: this code must be signal safe because
1169 qemu_timer_expired() can be called from a signal. */
1170 pt = &active_timers[ts->clock->type];
1175 if (t->expire_time > expire_time)
1179 ts->expire_time = expire_time;
1183 /* Rearm if necessary */
1184 if (pt == &active_timers[ts->clock->type]) {
1185 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1186 qemu_rearm_alarm_timer(alarm_timer);
1188 /* Interrupt execution to force deadline recalculation. */
1189 if (use_icount && cpu_single_env) {
1190 cpu_exit(cpu_single_env);
1195 int qemu_timer_pending(QEMUTimer *ts)
1198 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1205 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1209 return (timer_head->expire_time <= current_time);
1212 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1218 if (!ts || ts->expire_time > current_time)
1220 /* remove timer from the list before calling the callback */
1221 *ptimer_head = ts->next;
1224 /* run the callback (the timer list can be modified) */
1229 int64_t qemu_get_clock(QEMUClock *clock)
1231 switch(clock->type) {
1232 case QEMU_TIMER_REALTIME:
1233 return get_clock() / 1000000;
1235 case QEMU_TIMER_VIRTUAL:
1237 return cpu_get_icount();
1239 return cpu_get_clock();
1244 static void init_timers(void)
1247 ticks_per_sec = QEMU_TIMER_BASE;
1248 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1249 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1253 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1255 uint64_t expire_time;
1257 if (qemu_timer_pending(ts)) {
1258 expire_time = ts->expire_time;
1262 qemu_put_be64(f, expire_time);
1265 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1267 uint64_t expire_time;
1269 expire_time = qemu_get_be64(f);
1270 if (expire_time != -1) {
1271 qemu_mod_timer(ts, expire_time);
1277 static void timer_save(QEMUFile *f, void *opaque)
1279 if (cpu_ticks_enabled) {
1280 hw_error("cannot save state if virtual timers are running");
1282 qemu_put_be64(f, cpu_ticks_offset);
1283 qemu_put_be64(f, ticks_per_sec);
1284 qemu_put_be64(f, cpu_clock_offset);
1287 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1289 if (version_id != 1 && version_id != 2)
1291 if (cpu_ticks_enabled) {
1294 cpu_ticks_offset=qemu_get_be64(f);
1295 ticks_per_sec=qemu_get_be64(f);
1296 if (version_id == 2) {
1297 cpu_clock_offset=qemu_get_be64(f);
1303 static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1304 DWORD_PTR dwUser, DWORD_PTR dw1,
1307 static void host_alarm_handler(int host_signum)
1311 #define DISP_FREQ 1000
1313 static int64_t delta_min = INT64_MAX;
1314 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1316 ti = qemu_get_clock(vm_clock);
1317 if (last_clock != 0) {
1318 delta = ti - last_clock;
1319 if (delta < delta_min)
1321 if (delta > delta_max)
1324 if (++count == DISP_FREQ) {
1325 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1326 muldiv64(delta_min, 1000000, ticks_per_sec),
1327 muldiv64(delta_max, 1000000, ticks_per_sec),
1328 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1329 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1331 delta_min = INT64_MAX;
1339 if (alarm_has_dynticks(alarm_timer) ||
1341 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1342 qemu_get_clock(vm_clock))) ||
1343 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1344 qemu_get_clock(rt_clock))) {
1345 CPUState *env = next_cpu;
1348 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1349 SetEvent(data->host_alarm);
1351 static const char byte = 0;
1352 write(alarm_timer_wfd, &byte, sizeof(byte));
1354 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1357 /* stop the currently executing cpu because a timer occured */
1360 if (env->kqemu_enabled) {
1361 kqemu_cpu_interrupt(env);
1369 static int64_t qemu_next_deadline(void)
1373 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1374 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1375 qemu_get_clock(vm_clock);
1377 /* To avoid problems with overflow limit this to 2^32. */
1387 #if defined(__linux__) || defined(_WIN32)
1388 static uint64_t qemu_next_deadline_dyntick(void)
1396 delta = (qemu_next_deadline() + 999) / 1000;
1398 if (active_timers[QEMU_TIMER_REALTIME]) {
1399 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1400 qemu_get_clock(rt_clock))*1000;
1401 if (rtdelta < delta)
1405 if (delta < MIN_TIMER_REARM_US)
1406 delta = MIN_TIMER_REARM_US;
1414 /* Sets a specific flag */
1415 static int fcntl_setfl(int fd, int flag)
1419 flags = fcntl(fd, F_GETFL);
1423 if (fcntl(fd, F_SETFL, flags | flag) == -1)
1429 #if defined(__linux__)
1431 #define RTC_FREQ 1024
1433 static void enable_sigio_timer(int fd)
1435 struct sigaction act;
1438 sigfillset(&act.sa_mask);
1440 act.sa_handler = host_alarm_handler;
1442 sigaction(SIGIO, &act, NULL);
1443 fcntl_setfl(fd, O_ASYNC);
1444 fcntl(fd, F_SETOWN, getpid());
1447 static int hpet_start_timer(struct qemu_alarm_timer *t)
1449 struct hpet_info info;
1452 fd = open("/dev/hpet", O_RDONLY);
1457 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1459 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1460 "error, but for better emulation accuracy type:\n"
1461 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1465 /* Check capabilities */
1466 r = ioctl(fd, HPET_INFO, &info);
1470 /* Enable periodic mode */
1471 r = ioctl(fd, HPET_EPI, 0);
1472 if (info.hi_flags && (r < 0))
1475 /* Enable interrupt */
1476 r = ioctl(fd, HPET_IE_ON, 0);
1480 enable_sigio_timer(fd);
1481 t->priv = (void *)(long)fd;
1489 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1491 int fd = (long)t->priv;
1496 static int rtc_start_timer(struct qemu_alarm_timer *t)
1499 unsigned long current_rtc_freq = 0;
1501 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1504 ioctl(rtc_fd, RTC_IRQP_READ, ¤t_rtc_freq);
1505 if (current_rtc_freq != RTC_FREQ &&
1506 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1507 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1508 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1509 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1512 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1518 enable_sigio_timer(rtc_fd);
1520 t->priv = (void *)(long)rtc_fd;
1525 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1527 int rtc_fd = (long)t->priv;
1532 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1536 struct sigaction act;
1538 sigfillset(&act.sa_mask);
1540 act.sa_handler = host_alarm_handler;
1542 sigaction(SIGALRM, &act, NULL);
1544 ev.sigev_value.sival_int = 0;
1545 ev.sigev_notify = SIGEV_SIGNAL;
1546 ev.sigev_signo = SIGALRM;
1548 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1549 perror("timer_create");
1551 /* disable dynticks */
1552 fprintf(stderr, "Dynamic Ticks disabled\n");
1557 t->priv = (void *)(long)host_timer;
1562 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1564 timer_t host_timer = (timer_t)(long)t->priv;
1566 timer_delete(host_timer);
1569 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1571 timer_t host_timer = (timer_t)(long)t->priv;
1572 struct itimerspec timeout;
1573 int64_t nearest_delta_us = INT64_MAX;
1576 if (!active_timers[QEMU_TIMER_REALTIME] &&
1577 !active_timers[QEMU_TIMER_VIRTUAL])
1580 nearest_delta_us = qemu_next_deadline_dyntick();
1582 /* check whether a timer is already running */
1583 if (timer_gettime(host_timer, &timeout)) {
1585 fprintf(stderr, "Internal timer error: aborting\n");
1588 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1589 if (current_us && current_us <= nearest_delta_us)
1592 timeout.it_interval.tv_sec = 0;
1593 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1594 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1595 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1596 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1598 fprintf(stderr, "Internal timer error: aborting\n");
1603 #endif /* defined(__linux__) */
1605 static int unix_start_timer(struct qemu_alarm_timer *t)
1607 struct sigaction act;
1608 struct itimerval itv;
1612 sigfillset(&act.sa_mask);
1614 act.sa_handler = host_alarm_handler;
1616 sigaction(SIGALRM, &act, NULL);
1618 itv.it_interval.tv_sec = 0;
1619 /* for i386 kernel 2.6 to get 1 ms */
1620 itv.it_interval.tv_usec = 999;
1621 itv.it_value.tv_sec = 0;
1622 itv.it_value.tv_usec = 10 * 1000;
1624 err = setitimer(ITIMER_REAL, &itv, NULL);
1631 static void unix_stop_timer(struct qemu_alarm_timer *t)
1633 struct itimerval itv;
1635 memset(&itv, 0, sizeof(itv));
1636 setitimer(ITIMER_REAL, &itv, NULL);
1639 #endif /* !defined(_WIN32) */
1641 static void try_to_rearm_timer(void *opaque)
1643 struct qemu_alarm_timer *t = opaque;
1647 /* Drain the notify pipe */
1650 len = read(alarm_timer_rfd, buffer, sizeof(buffer));
1651 } while ((len == -1 && errno == EINTR) || len > 0);
1654 if (t->flags & ALARM_FLAG_EXPIRED) {
1655 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
1656 qemu_rearm_alarm_timer(alarm_timer);
1662 static int win32_start_timer(struct qemu_alarm_timer *t)
1665 struct qemu_alarm_win32 *data = t->priv;
1668 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1669 if (!data->host_alarm) {
1670 perror("Failed CreateEvent");
1674 memset(&tc, 0, sizeof(tc));
1675 timeGetDevCaps(&tc, sizeof(tc));
1677 if (data->period < tc.wPeriodMin)
1678 data->period = tc.wPeriodMin;
1680 timeBeginPeriod(data->period);
1682 flags = TIME_CALLBACK_FUNCTION;
1683 if (alarm_has_dynticks(t))
1684 flags |= TIME_ONESHOT;
1686 flags |= TIME_PERIODIC;
1688 data->timerId = timeSetEvent(1, // interval (ms)
1689 data->period, // resolution
1690 host_alarm_handler, // function
1691 (DWORD)t, // parameter
1694 if (!data->timerId) {
1695 perror("Failed to initialize win32 alarm timer");
1697 timeEndPeriod(data->period);
1698 CloseHandle(data->host_alarm);
1702 qemu_add_wait_object(data->host_alarm, try_to_rearm_timer, t);
1707 static void win32_stop_timer(struct qemu_alarm_timer *t)
1709 struct qemu_alarm_win32 *data = t->priv;
1711 timeKillEvent(data->timerId);
1712 timeEndPeriod(data->period);
1714 CloseHandle(data->host_alarm);
1717 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1719 struct qemu_alarm_win32 *data = t->priv;
1720 uint64_t nearest_delta_us;
1722 if (!active_timers[QEMU_TIMER_REALTIME] &&
1723 !active_timers[QEMU_TIMER_VIRTUAL])
1726 nearest_delta_us = qemu_next_deadline_dyntick();
1727 nearest_delta_us /= 1000;
1729 timeKillEvent(data->timerId);
1731 data->timerId = timeSetEvent(1,
1735 TIME_ONESHOT | TIME_PERIODIC);
1737 if (!data->timerId) {
1738 perror("Failed to re-arm win32 alarm timer");
1740 timeEndPeriod(data->period);
1741 CloseHandle(data->host_alarm);
1748 static int init_timer_alarm(void)
1750 struct qemu_alarm_timer *t = NULL;
1760 err = fcntl_setfl(fds[0], O_NONBLOCK);
1764 err = fcntl_setfl(fds[1], O_NONBLOCK);
1768 alarm_timer_rfd = fds[0];
1769 alarm_timer_wfd = fds[1];
1772 for (i = 0; alarm_timers[i].name; i++) {
1773 t = &alarm_timers[i];
1786 qemu_set_fd_handler2(alarm_timer_rfd, NULL,
1787 try_to_rearm_timer, NULL, t);
1802 static void quit_timers(void)
1804 alarm_timer->stop(alarm_timer);
1808 /***********************************************************/
1809 /* host time/date access */
1810 void qemu_get_timedate(struct tm *tm, int offset)
1817 if (rtc_date_offset == -1) {
1821 ret = localtime(&ti);
1823 ti -= rtc_date_offset;
1827 memcpy(tm, ret, sizeof(struct tm));
1830 int qemu_timedate_diff(struct tm *tm)
1834 if (rtc_date_offset == -1)
1836 seconds = mktimegm(tm);
1838 seconds = mktime(tm);
1840 seconds = mktimegm(tm) + rtc_date_offset;
1842 return seconds - time(NULL);
1846 static void socket_cleanup(void)
1851 static int socket_init(void)
1856 ret = WSAStartup(MAKEWORD(2,2), &Data);
1858 err = WSAGetLastError();
1859 fprintf(stderr, "WSAStartup: %d\n", err);
1862 atexit(socket_cleanup);
1867 const char *get_opt_name(char *buf, int buf_size, const char *p)
1872 while (*p != '\0' && *p != '=') {
1873 if (q && (q - buf) < buf_size - 1)
1883 const char *get_opt_value(char *buf, int buf_size, const char *p)
1888 while (*p != '\0') {
1890 if (*(p + 1) != ',')
1894 if (q && (q - buf) < buf_size - 1)
1904 int get_param_value(char *buf, int buf_size,
1905 const char *tag, const char *str)
1912 p = get_opt_name(option, sizeof(option), p);
1916 if (!strcmp(tag, option)) {
1917 (void)get_opt_value(buf, buf_size, p);
1920 p = get_opt_value(NULL, 0, p);
1929 int check_params(char *buf, int buf_size,
1930 const char * const *params, const char *str)
1937 p = get_opt_name(buf, buf_size, p);
1941 for(i = 0; params[i] != NULL; i++)
1942 if (!strcmp(params[i], buf))
1944 if (params[i] == NULL)
1946 p = get_opt_value(NULL, 0, p);
1954 /***********************************************************/
1955 /* Bluetooth support */
1958 static struct HCIInfo *hci_table[MAX_NICS];
1960 static struct bt_vlan_s {
1961 struct bt_scatternet_s net;
1963 struct bt_vlan_s *next;
1966 /* find or alloc a new bluetooth "VLAN" */
1967 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1969 struct bt_vlan_s **pvlan, *vlan;
1970 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1974 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1976 pvlan = &first_bt_vlan;
1977 while (*pvlan != NULL)
1978 pvlan = &(*pvlan)->next;
1983 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1987 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1992 static struct HCIInfo null_hci = {
1993 .cmd_send = null_hci_send,
1994 .sco_send = null_hci_send,
1995 .acl_send = null_hci_send,
1996 .bdaddr_set = null_hci_addr_set,
1999 struct HCIInfo *qemu_next_hci(void)
2001 if (cur_hci == nb_hcis)
2004 return hci_table[cur_hci++];
2007 static struct HCIInfo *hci_init(const char *str)
2010 struct bt_scatternet_s *vlan = 0;
2012 if (!strcmp(str, "null"))
2015 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
2017 return bt_host_hci(str[4] ? str + 5 : "hci0");
2018 else if (!strncmp(str, "hci", 3)) {
2021 if (!strncmp(str + 3, ",vlan=", 6)) {
2022 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
2027 vlan = qemu_find_bt_vlan(0);
2029 return bt_new_hci(vlan);
2032 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
2037 static int bt_hci_parse(const char *str)
2039 struct HCIInfo *hci;
2042 if (nb_hcis >= MAX_NICS) {
2043 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
2047 hci = hci_init(str);
2056 bdaddr.b[5] = 0x56 + nb_hcis;
2057 hci->bdaddr_set(hci, bdaddr.b);
2059 hci_table[nb_hcis++] = hci;
2064 static void bt_vhci_add(int vlan_id)
2066 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
2069 fprintf(stderr, "qemu: warning: adding a VHCI to "
2070 "an empty scatternet %i\n", vlan_id);
2072 bt_vhci_init(bt_new_hci(vlan));
2075 static struct bt_device_s *bt_device_add(const char *opt)
2077 struct bt_scatternet_s *vlan;
2079 char *endp = strstr(opt, ",vlan=");
2080 int len = (endp ? endp - opt : strlen(opt)) + 1;
2083 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2086 vlan_id = strtol(endp + 6, &endp, 0);
2088 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2093 vlan = qemu_find_bt_vlan(vlan_id);
2096 fprintf(stderr, "qemu: warning: adding a slave device to "
2097 "an empty scatternet %i\n", vlan_id);
2099 if (!strcmp(devname, "keyboard"))
2100 return bt_keyboard_init(vlan);
2102 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2106 static int bt_parse(const char *opt)
2108 const char *endp, *p;
2111 if (strstart(opt, "hci", &endp)) {
2112 if (!*endp || *endp == ',') {
2114 if (!strstart(endp, ",vlan=", 0))
2117 return bt_hci_parse(opt);
2119 } else if (strstart(opt, "vhci", &endp)) {
2120 if (!*endp || *endp == ',') {
2122 if (strstart(endp, ",vlan=", &p)) {
2123 vlan = strtol(p, (char **) &endp, 0);
2125 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2129 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2138 } else if (strstart(opt, "device:", &endp))
2139 return !bt_device_add(endp);
2141 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2145 /***********************************************************/
2146 /* QEMU Block devices */
2148 #define HD_ALIAS "index=%d,media=disk"
2149 #define CDROM_ALIAS "index=2,media=cdrom"
2150 #define FD_ALIAS "index=%d,if=floppy"
2151 #define PFLASH_ALIAS "if=pflash"
2152 #define MTD_ALIAS "if=mtd"
2153 #define SD_ALIAS "index=0,if=sd"
2155 static int drive_opt_get_free_idx(void)
2159 for (index = 0; index < MAX_DRIVES; index++)
2160 if (!drives_opt[index].used) {
2161 drives_opt[index].used = 1;
2168 static int drive_get_free_idx(void)
2172 for (index = 0; index < MAX_DRIVES; index++)
2173 if (!drives_table[index].used) {
2174 drives_table[index].used = 1;
2181 int drive_add(const char *file, const char *fmt, ...)
2184 int index = drive_opt_get_free_idx();
2186 if (nb_drives_opt >= MAX_DRIVES || index == -1) {
2187 fprintf(stderr, "qemu: too many drives\n");
2191 drives_opt[index].file = file;
2193 vsnprintf(drives_opt[index].opt,
2194 sizeof(drives_opt[0].opt), fmt, ap);
2201 void drive_remove(int index)
2203 drives_opt[index].used = 0;
2207 int drive_get_index(BlockInterfaceType type, int bus, int unit)
2211 /* seek interface, bus and unit */
2213 for (index = 0; index < MAX_DRIVES; index++)
2214 if (drives_table[index].type == type &&
2215 drives_table[index].bus == bus &&
2216 drives_table[index].unit == unit &&
2217 drives_table[index].used)
2223 int drive_get_max_bus(BlockInterfaceType type)
2229 for (index = 0; index < nb_drives; index++) {
2230 if(drives_table[index].type == type &&
2231 drives_table[index].bus > max_bus)
2232 max_bus = drives_table[index].bus;
2237 const char *drive_get_serial(BlockDriverState *bdrv)
2241 for (index = 0; index < nb_drives; index++)
2242 if (drives_table[index].bdrv == bdrv)
2243 return drives_table[index].serial;
2248 BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2252 for (index = 0; index < nb_drives; index++)
2253 if (drives_table[index].bdrv == bdrv)
2254 return drives_table[index].onerror;
2256 return BLOCK_ERR_STOP_ENOSPC;
2259 static void bdrv_format_print(void *opaque, const char *name)
2261 fprintf(stderr, " %s", name);
2264 void drive_uninit(BlockDriverState *bdrv)
2268 for (i = 0; i < MAX_DRIVES; i++)
2269 if (drives_table[i].bdrv == bdrv) {
2270 drives_table[i].bdrv = NULL;
2271 drives_table[i].used = 0;
2272 drive_remove(drives_table[i].drive_opt_idx);
2278 int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
2284 const char *mediastr = "";
2285 BlockInterfaceType type;
2286 enum { MEDIA_DISK, MEDIA_CDROM } media;
2287 int bus_id, unit_id;
2288 int cyls, heads, secs, translation;
2289 BlockDriverState *bdrv;
2290 BlockDriver *drv = NULL;
2291 QEMUMachine *machine = opaque;
2295 int bdrv_flags, onerror;
2296 int drives_table_idx;
2297 char *str = arg->opt;
2298 static const char * const params[] = { "bus", "unit", "if", "index",
2299 "cyls", "heads", "secs", "trans",
2300 "media", "snapshot", "file",
2301 "cache", "format", "serial", "werror",
2304 if (check_params(buf, sizeof(buf), params, str) < 0) {
2305 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
2311 cyls = heads = secs = 0;
2314 translation = BIOS_ATA_TRANSLATION_AUTO;
2318 if (machine->use_scsi) {
2320 max_devs = MAX_SCSI_DEVS;
2321 pstrcpy(devname, sizeof(devname), "scsi");
2324 max_devs = MAX_IDE_DEVS;
2325 pstrcpy(devname, sizeof(devname), "ide");
2329 /* extract parameters */
2331 if (get_param_value(buf, sizeof(buf), "bus", str)) {
2332 bus_id = strtol(buf, NULL, 0);
2334 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2339 if (get_param_value(buf, sizeof(buf), "unit", str)) {
2340 unit_id = strtol(buf, NULL, 0);
2342 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2347 if (get_param_value(buf, sizeof(buf), "if", str)) {
2348 pstrcpy(devname, sizeof(devname), buf);
2349 if (!strcmp(buf, "ide")) {
2351 max_devs = MAX_IDE_DEVS;
2352 } else if (!strcmp(buf, "scsi")) {
2354 max_devs = MAX_SCSI_DEVS;
2355 } else if (!strcmp(buf, "floppy")) {
2358 } else if (!strcmp(buf, "pflash")) {
2361 } else if (!strcmp(buf, "mtd")) {
2364 } else if (!strcmp(buf, "sd")) {
2367 } else if (!strcmp(buf, "virtio")) {
2371 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2376 if (get_param_value(buf, sizeof(buf), "index", str)) {
2377 index = strtol(buf, NULL, 0);
2379 fprintf(stderr, "qemu: '%s' invalid index\n", str);
2384 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2385 cyls = strtol(buf, NULL, 0);
2388 if (get_param_value(buf, sizeof(buf), "heads", str)) {
2389 heads = strtol(buf, NULL, 0);
2392 if (get_param_value(buf, sizeof(buf), "secs", str)) {
2393 secs = strtol(buf, NULL, 0);
2396 if (cyls || heads || secs) {
2397 if (cyls < 1 || cyls > 16383) {
2398 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2401 if (heads < 1 || heads > 16) {
2402 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2405 if (secs < 1 || secs > 63) {
2406 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2411 if (get_param_value(buf, sizeof(buf), "trans", str)) {
2414 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2418 if (!strcmp(buf, "none"))
2419 translation = BIOS_ATA_TRANSLATION_NONE;
2420 else if (!strcmp(buf, "lba"))
2421 translation = BIOS_ATA_TRANSLATION_LBA;
2422 else if (!strcmp(buf, "auto"))
2423 translation = BIOS_ATA_TRANSLATION_AUTO;
2425 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2430 if (get_param_value(buf, sizeof(buf), "media", str)) {
2431 if (!strcmp(buf, "disk")) {
2433 } else if (!strcmp(buf, "cdrom")) {
2434 if (cyls || secs || heads) {
2436 "qemu: '%s' invalid physical CHS format\n", str);
2439 media = MEDIA_CDROM;
2441 fprintf(stderr, "qemu: '%s' invalid media\n", str);
2446 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2447 if (!strcmp(buf, "on"))
2449 else if (!strcmp(buf, "off"))
2452 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2457 if (get_param_value(buf, sizeof(buf), "cache", str)) {
2458 if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2460 else if (!strcmp(buf, "writethrough"))
2462 else if (!strcmp(buf, "writeback"))
2465 fprintf(stderr, "qemu: invalid cache option\n");
2470 if (get_param_value(buf, sizeof(buf), "format", str)) {
2471 if (strcmp(buf, "?") == 0) {
2472 fprintf(stderr, "qemu: Supported formats:");
2473 bdrv_iterate_format(bdrv_format_print, NULL);
2474 fprintf(stderr, "\n");
2477 drv = bdrv_find_format(buf);
2479 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2484 if (arg->file == NULL)
2485 get_param_value(file, sizeof(file), "file", str);
2487 pstrcpy(file, sizeof(file), arg->file);
2489 if (!get_param_value(serial, sizeof(serial), "serial", str))
2490 memset(serial, 0, sizeof(serial));
2492 onerror = BLOCK_ERR_STOP_ENOSPC;
2493 if (get_param_value(buf, sizeof(serial), "werror", str)) {
2494 if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2495 fprintf(stderr, "werror is no supported by this format\n");
2498 if (!strcmp(buf, "ignore"))
2499 onerror = BLOCK_ERR_IGNORE;
2500 else if (!strcmp(buf, "enospc"))
2501 onerror = BLOCK_ERR_STOP_ENOSPC;
2502 else if (!strcmp(buf, "stop"))
2503 onerror = BLOCK_ERR_STOP_ANY;
2504 else if (!strcmp(buf, "report"))
2505 onerror = BLOCK_ERR_REPORT;
2507 fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2512 /* compute bus and unit according index */
2515 if (bus_id != 0 || unit_id != -1) {
2517 "qemu: '%s' index cannot be used with bus and unit\n", str);
2525 unit_id = index % max_devs;
2526 bus_id = index / max_devs;
2530 /* if user doesn't specify a unit_id,
2531 * try to find the first free
2534 if (unit_id == -1) {
2536 while (drive_get_index(type, bus_id, unit_id) != -1) {
2538 if (max_devs && unit_id >= max_devs) {
2539 unit_id -= max_devs;
2547 if (max_devs && unit_id >= max_devs) {
2548 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2549 str, unit_id, max_devs - 1);
2554 * ignore multiple definitions
2557 if (drive_get_index(type, bus_id, unit_id) != -1)
2562 if (type == IF_IDE || type == IF_SCSI)
2563 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2565 snprintf(buf, sizeof(buf), "%s%i%s%i",
2566 devname, bus_id, mediastr, unit_id);
2568 snprintf(buf, sizeof(buf), "%s%s%i",
2569 devname, mediastr, unit_id);
2570 bdrv = bdrv_new(buf);
2571 drives_table_idx = drive_get_free_idx();
2572 drives_table[drives_table_idx].bdrv = bdrv;
2573 drives_table[drives_table_idx].type = type;
2574 drives_table[drives_table_idx].bus = bus_id;
2575 drives_table[drives_table_idx].unit = unit_id;
2576 drives_table[drives_table_idx].onerror = onerror;
2577 drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2578 strncpy(drives_table[nb_drives].serial, serial, sizeof(serial));
2587 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2588 bdrv_set_translation_hint(bdrv, translation);
2592 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2597 /* FIXME: This isn't really a floppy, but it's a reasonable
2600 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2611 bdrv_flags |= BDRV_O_SNAPSHOT;
2612 cache = 2; /* always use write-back with snapshot */
2614 if (cache == 0) /* no caching */
2615 bdrv_flags |= BDRV_O_NOCACHE;
2616 else if (cache == 2) /* write-back */
2617 bdrv_flags |= BDRV_O_CACHE_WB;
2618 else if (cache == 3) /* not specified */
2619 bdrv_flags |= BDRV_O_CACHE_DEF;
2620 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) {
2621 fprintf(stderr, "qemu: could not open disk image %s\n",
2625 if (bdrv_key_required(bdrv))
2627 return drives_table_idx;
2630 /***********************************************************/
2633 static USBPort *used_usb_ports;
2634 static USBPort *free_usb_ports;
2636 /* ??? Maybe change this to register a hub to keep track of the topology. */
2637 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2638 usb_attachfn attach)
2640 port->opaque = opaque;
2641 port->index = index;
2642 port->attach = attach;
2643 port->next = free_usb_ports;
2644 free_usb_ports = port;
2647 int usb_device_add_dev(USBDevice *dev)
2651 /* Find a USB port to add the device to. */
2652 port = free_usb_ports;
2656 /* Create a new hub and chain it on. */
2657 free_usb_ports = NULL;
2658 port->next = used_usb_ports;
2659 used_usb_ports = port;
2661 hub = usb_hub_init(VM_USB_HUB_SIZE);
2662 usb_attach(port, hub);
2663 port = free_usb_ports;
2666 free_usb_ports = port->next;
2667 port->next = used_usb_ports;
2668 used_usb_ports = port;
2669 usb_attach(port, dev);
2673 static void usb_msd_password_cb(void *opaque, int err)
2675 USBDevice *dev = opaque;
2678 usb_device_add_dev(dev);
2680 dev->handle_destroy(dev);
2683 static int usb_device_add(const char *devname, int is_hotplug)
2688 if (!free_usb_ports)
2691 if (strstart(devname, "host:", &p)) {
2692 dev = usb_host_device_open(p);
2693 } else if (!strcmp(devname, "mouse")) {
2694 dev = usb_mouse_init();
2695 } else if (!strcmp(devname, "tablet")) {
2696 dev = usb_tablet_init();
2697 } else if (!strcmp(devname, "keyboard")) {
2698 dev = usb_keyboard_init();
2699 } else if (strstart(devname, "disk:", &p)) {
2700 BlockDriverState *bs;
2702 dev = usb_msd_init(p);
2705 bs = usb_msd_get_bdrv(dev);
2706 if (bdrv_key_required(bs)) {
2709 monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2714 } else if (!strcmp(devname, "wacom-tablet")) {
2715 dev = usb_wacom_init();
2716 } else if (strstart(devname, "serial:", &p)) {
2717 dev = usb_serial_init(p);
2718 #ifdef CONFIG_BRLAPI
2719 } else if (!strcmp(devname, "braille")) {
2720 dev = usb_baum_init();
2722 } else if (strstart(devname, "net:", &p)) {
2725 if (net_client_init("nic", p) < 0)
2727 nd_table[nic].model = "usb";
2728 dev = usb_net_init(&nd_table[nic]);
2729 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2730 dev = usb_bt_init(devname[2] ? hci_init(p) :
2731 bt_new_hci(qemu_find_bt_vlan(0)));
2738 return usb_device_add_dev(dev);
2741 int usb_device_del_addr(int bus_num, int addr)
2747 if (!used_usb_ports)
2753 lastp = &used_usb_ports;
2754 port = used_usb_ports;
2755 while (port && port->dev->addr != addr) {
2756 lastp = &port->next;
2764 *lastp = port->next;
2765 usb_attach(port, NULL);
2766 dev->handle_destroy(dev);
2767 port->next = free_usb_ports;
2768 free_usb_ports = port;
2772 static int usb_device_del(const char *devname)
2777 if (strstart(devname, "host:", &p))
2778 return usb_host_device_close(p);
2780 if (!used_usb_ports)
2783 p = strchr(devname, '.');
2786 bus_num = strtoul(devname, NULL, 0);
2787 addr = strtoul(p + 1, NULL, 0);
2789 return usb_device_del_addr(bus_num, addr);
2792 void do_usb_add(Monitor *mon, const char *devname)
2794 usb_device_add(devname, 1);
2797 void do_usb_del(Monitor *mon, const char *devname)
2799 usb_device_del(devname);
2802 void usb_info(Monitor *mon)
2806 const char *speed_str;
2809 monitor_printf(mon, "USB support not enabled\n");
2813 for (port = used_usb_ports; port; port = port->next) {
2817 switch(dev->speed) {
2821 case USB_SPEED_FULL:
2824 case USB_SPEED_HIGH:
2831 monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n",
2832 0, dev->addr, speed_str, dev->devname);
2836 /***********************************************************/
2837 /* PCMCIA/Cardbus */
2839 static struct pcmcia_socket_entry_s {
2840 struct pcmcia_socket_s *socket;
2841 struct pcmcia_socket_entry_s *next;
2842 } *pcmcia_sockets = 0;
2844 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
2846 struct pcmcia_socket_entry_s *entry;
2848 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2849 entry->socket = socket;
2850 entry->next = pcmcia_sockets;
2851 pcmcia_sockets = entry;
2854 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
2856 struct pcmcia_socket_entry_s *entry, **ptr;
2858 ptr = &pcmcia_sockets;
2859 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2860 if (entry->socket == socket) {
2866 void pcmcia_info(Monitor *mon)
2868 struct pcmcia_socket_entry_s *iter;
2870 if (!pcmcia_sockets)
2871 monitor_printf(mon, "No PCMCIA sockets\n");
2873 for (iter = pcmcia_sockets; iter; iter = iter->next)
2874 monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2875 iter->socket->attached ? iter->socket->card_string :
2879 /***********************************************************/
2880 /* register display */
2882 struct DisplayAllocator default_allocator = {
2883 defaultallocator_create_displaysurface,
2884 defaultallocator_resize_displaysurface,
2885 defaultallocator_free_displaysurface
2888 void register_displaystate(DisplayState *ds)
2898 DisplayState *get_displaystate(void)
2900 return display_state;
2903 DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2905 if(ds->allocator == &default_allocator) ds->allocator = da;
2906 return ds->allocator;
2911 static void dumb_display_init(void)
2913 DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2914 ds->allocator = &default_allocator;
2915 ds->surface = qemu_create_displaysurface(ds, 640, 480);
2916 register_displaystate(ds);
2919 /***********************************************************/
2922 typedef struct IOHandlerRecord {
2924 IOCanRWHandler *fd_read_poll;
2926 IOHandler *fd_write;
2929 /* temporary data */
2931 struct IOHandlerRecord *next;
2934 static IOHandlerRecord *first_io_handler;
2936 /* XXX: fd_read_poll should be suppressed, but an API change is
2937 necessary in the character devices to suppress fd_can_read(). */
2938 int qemu_set_fd_handler2(int fd,
2939 IOCanRWHandler *fd_read_poll,
2941 IOHandler *fd_write,
2944 IOHandlerRecord **pioh, *ioh;
2946 if (!fd_read && !fd_write) {
2947 pioh = &first_io_handler;
2952 if (ioh->fd == fd) {
2959 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2963 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2964 ioh->next = first_io_handler;
2965 first_io_handler = ioh;
2968 ioh->fd_read_poll = fd_read_poll;
2969 ioh->fd_read = fd_read;
2970 ioh->fd_write = fd_write;
2971 ioh->opaque = opaque;
2977 int qemu_set_fd_handler(int fd,
2979 IOHandler *fd_write,
2982 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2986 /***********************************************************/
2987 /* Polling handling */
2989 typedef struct PollingEntry {
2992 struct PollingEntry *next;
2995 static PollingEntry *first_polling_entry;
2997 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2999 PollingEntry **ppe, *pe;
3000 pe = qemu_mallocz(sizeof(PollingEntry));
3002 pe->opaque = opaque;
3003 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
3008 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
3010 PollingEntry **ppe, *pe;
3011 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
3013 if (pe->func == func && pe->opaque == opaque) {
3021 /***********************************************************/
3022 /* Wait objects support */
3023 typedef struct WaitObjects {
3025 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3026 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3027 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3030 static WaitObjects wait_objects = {0};
3032 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3034 WaitObjects *w = &wait_objects;
3036 if (w->num >= MAXIMUM_WAIT_OBJECTS)
3038 w->events[w->num] = handle;
3039 w->func[w->num] = func;
3040 w->opaque[w->num] = opaque;
3045 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3048 WaitObjects *w = &wait_objects;
3051 for (i = 0; i < w->num; i++) {
3052 if (w->events[i] == handle)
3055 w->events[i] = w->events[i + 1];
3056 w->func[i] = w->func[i + 1];
3057 w->opaque[i] = w->opaque[i + 1];
3065 /***********************************************************/
3066 /* ram save/restore */
3068 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3072 v = qemu_get_byte(f);
3075 if (qemu_get_buffer(f, buf, len) != len)
3079 v = qemu_get_byte(f);
3080 memset(buf, v, len);
3086 if (qemu_file_has_error(f))
3092 static int ram_load_v1(QEMUFile *f, void *opaque)
3097 if (qemu_get_be32(f) != phys_ram_size)
3099 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3100 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3107 #define BDRV_HASH_BLOCK_SIZE 1024
3108 #define IOBUF_SIZE 4096
3109 #define RAM_CBLOCK_MAGIC 0xfabe
3111 typedef struct RamDecompressState {
3114 uint8_t buf[IOBUF_SIZE];
3115 } RamDecompressState;
3117 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3120 memset(s, 0, sizeof(*s));
3122 ret = inflateInit(&s->zstream);
3128 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3132 s->zstream.avail_out = len;
3133 s->zstream.next_out = buf;
3134 while (s->zstream.avail_out > 0) {
3135 if (s->zstream.avail_in == 0) {
3136 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3138 clen = qemu_get_be16(s->f);
3139 if (clen > IOBUF_SIZE)
3141 qemu_get_buffer(s->f, s->buf, clen);
3142 s->zstream.avail_in = clen;
3143 s->zstream.next_in = s->buf;
3145 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3146 if (ret != Z_OK && ret != Z_STREAM_END) {
3153 static void ram_decompress_close(RamDecompressState *s)
3155 inflateEnd(&s->zstream);
3158 #define RAM_SAVE_FLAG_FULL 0x01
3159 #define RAM_SAVE_FLAG_COMPRESS 0x02
3160 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
3161 #define RAM_SAVE_FLAG_PAGE 0x08
3162 #define RAM_SAVE_FLAG_EOS 0x10
3164 static int is_dup_page(uint8_t *page, uint8_t ch)
3166 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3167 uint32_t *array = (uint32_t *)page;
3170 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3171 if (array[i] != val)
3178 static int ram_save_block(QEMUFile *f)
3180 static ram_addr_t current_addr = 0;
3181 ram_addr_t saved_addr = current_addr;
3182 ram_addr_t addr = 0;
3185 while (addr < phys_ram_size) {
3186 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3189 cpu_physical_memory_reset_dirty(current_addr,
3190 current_addr + TARGET_PAGE_SIZE,
3191 MIGRATION_DIRTY_FLAG);
3193 ch = *(phys_ram_base + current_addr);
3195 if (is_dup_page(phys_ram_base + current_addr, ch)) {
3196 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3197 qemu_put_byte(f, ch);
3199 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3200 qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
3206 addr += TARGET_PAGE_SIZE;
3207 current_addr = (saved_addr + addr) % phys_ram_size;
3213 static ram_addr_t ram_save_threshold = 10;
3215 static ram_addr_t ram_save_remaining(void)
3218 ram_addr_t count = 0;
3220 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3221 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3228 static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3233 /* Make sure all dirty bits are set */
3234 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3235 if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3236 cpu_physical_memory_set_dirty(addr);
3239 /* Enable dirty memory tracking */
3240 cpu_physical_memory_set_dirty_tracking(1);
3242 qemu_put_be64(f, phys_ram_size | RAM_SAVE_FLAG_MEM_SIZE);
3245 while (!qemu_file_rate_limit(f)) {
3248 ret = ram_save_block(f);
3249 if (ret == 0) /* no more blocks */
3253 /* try transferring iterative blocks of memory */
3257 /* flush all remaining blocks regardless of rate limiting */
3258 while (ram_save_block(f) != 0);
3259 cpu_physical_memory_set_dirty_tracking(0);
3262 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3264 return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3267 static int ram_load_dead(QEMUFile *f, void *opaque)
3269 RamDecompressState s1, *s = &s1;
3273 if (ram_decompress_open(s, f) < 0)
3275 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
3276 if (ram_decompress_buf(s, buf, 1) < 0) {
3277 fprintf(stderr, "Error while reading ram block header\n");
3281 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
3282 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3287 printf("Error block header\n");
3291 ram_decompress_close(s);
3296 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3301 if (version_id == 1)
3302 return ram_load_v1(f, opaque);
3304 if (version_id == 2) {
3305 if (qemu_get_be32(f) != phys_ram_size)
3307 return ram_load_dead(f, opaque);
3310 if (version_id != 3)
3314 addr = qemu_get_be64(f);
3316 flags = addr & ~TARGET_PAGE_MASK;
3317 addr &= TARGET_PAGE_MASK;
3319 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3320 if (addr != phys_ram_size)
3324 if (flags & RAM_SAVE_FLAG_FULL) {
3325 if (ram_load_dead(f, opaque) < 0)
3329 if (flags & RAM_SAVE_FLAG_COMPRESS) {
3330 uint8_t ch = qemu_get_byte(f);
3331 memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3332 } else if (flags & RAM_SAVE_FLAG_PAGE)
3333 qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3334 } while (!(flags & RAM_SAVE_FLAG_EOS));
3339 void qemu_service_io(void)
3341 CPUState *env = cpu_single_env;
3345 if (env->kqemu_enabled) {
3346 kqemu_cpu_interrupt(env);
3352 /***********************************************************/
3353 /* bottom halves (can be seen as timers which expire ASAP) */
3364 static QEMUBH *first_bh = NULL;
3366 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3369 bh = qemu_mallocz(sizeof(QEMUBH));
3371 bh->opaque = opaque;
3372 bh->next = first_bh;
3377 int qemu_bh_poll(void)
3383 for (bh = first_bh; bh; bh = bh->next) {
3384 if (!bh->deleted && bh->scheduled) {
3393 /* remove deleted bhs */
3407 void qemu_bh_schedule_idle(QEMUBH *bh)
3415 void qemu_bh_schedule(QEMUBH *bh)
3417 CPUState *env = cpu_single_env;
3422 /* stop the currently executing CPU to execute the BH ASAP */
3428 void qemu_bh_cancel(QEMUBH *bh)
3433 void qemu_bh_delete(QEMUBH *bh)
3439 static void qemu_bh_update_timeout(int *timeout)
3443 for (bh = first_bh; bh; bh = bh->next) {
3444 if (!bh->deleted && bh->scheduled) {
3446 /* idle bottom halves will be polled at least
3448 *timeout = MIN(10, *timeout);
3450 /* non-idle bottom halves will be executed
3459 /***********************************************************/
3460 /* machine registration */
3462 static QEMUMachine *first_machine = NULL;
3463 QEMUMachine *current_machine = NULL;
3465 int qemu_register_machine(QEMUMachine *m)
3468 pm = &first_machine;
3476 static QEMUMachine *find_machine(const char *name)
3480 for(m = first_machine; m != NULL; m = m->next) {
3481 if (!strcmp(m->name, name))
3487 /***********************************************************/
3488 /* main execution loop */
3490 static void gui_update(void *opaque)
3492 uint64_t interval = GUI_REFRESH_INTERVAL;
3493 DisplayState *ds = opaque;
3494 DisplayChangeListener *dcl = ds->listeners;
3498 while (dcl != NULL) {
3499 if (dcl->gui_timer_interval &&
3500 dcl->gui_timer_interval < interval)
3501 interval = dcl->gui_timer_interval;
3504 qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3507 static void nographic_update(void *opaque)
3509 uint64_t interval = GUI_REFRESH_INTERVAL;
3511 qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3514 struct vm_change_state_entry {
3515 VMChangeStateHandler *cb;
3517 LIST_ENTRY (vm_change_state_entry) entries;
3520 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3522 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3525 VMChangeStateEntry *e;
3527 e = qemu_mallocz(sizeof (*e));
3531 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3535 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3537 LIST_REMOVE (e, entries);
3541 static void vm_state_notify(int running, int reason)
3543 VMChangeStateEntry *e;
3545 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3546 e->cb(e->opaque, running, reason);
3555 vm_state_notify(1, 0);
3556 qemu_rearm_alarm_timer(alarm_timer);
3560 void vm_stop(int reason)
3563 cpu_disable_ticks();
3565 vm_state_notify(0, reason);
3569 /* reset/shutdown handler */
3571 typedef struct QEMUResetEntry {
3572 QEMUResetHandler *func;
3574 struct QEMUResetEntry *next;
3577 static QEMUResetEntry *first_reset_entry;
3578 static int reset_requested;
3579 static int shutdown_requested;
3580 static int powerdown_requested;
3582 int qemu_shutdown_requested(void)
3584 int r = shutdown_requested;
3585 shutdown_requested = 0;
3589 int qemu_reset_requested(void)
3591 int r = reset_requested;
3592 reset_requested = 0;
3596 int qemu_powerdown_requested(void)
3598 int r = powerdown_requested;
3599 powerdown_requested = 0;
3603 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3605 QEMUResetEntry **pre, *re;
3607 pre = &first_reset_entry;
3608 while (*pre != NULL)
3609 pre = &(*pre)->next;
3610 re = qemu_mallocz(sizeof(QEMUResetEntry));
3612 re->opaque = opaque;
3617 void qemu_system_reset(void)
3621 /* reset all devices */
3622 for(re = first_reset_entry; re != NULL; re = re->next) {
3623 re->func(re->opaque);
3627 void qemu_system_reset_request(void)
3630 shutdown_requested = 1;
3632 reset_requested = 1;
3635 cpu_exit(cpu_single_env);
3638 void qemu_system_shutdown_request(void)
3640 shutdown_requested = 1;
3642 cpu_exit(cpu_single_env);
3645 void qemu_system_powerdown_request(void)
3647 powerdown_requested = 1;
3649 cpu_exit(cpu_single_env);
3653 static void host_main_loop_wait(int *timeout)
3659 /* XXX: need to suppress polling by better using win32 events */
3661 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3662 ret |= pe->func(pe->opaque);
3666 WaitObjects *w = &wait_objects;
3668 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3669 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3670 if (w->func[ret - WAIT_OBJECT_0])
3671 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3673 /* Check for additional signaled events */
3674 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3676 /* Check if event is signaled */
3677 ret2 = WaitForSingleObject(w->events[i], 0);
3678 if(ret2 == WAIT_OBJECT_0) {
3680 w->func[i](w->opaque[i]);
3681 } else if (ret2 == WAIT_TIMEOUT) {
3683 err = GetLastError();
3684 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3687 } else if (ret == WAIT_TIMEOUT) {
3689 err = GetLastError();
3690 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3697 static void host_main_loop_wait(int *timeout)
3702 void main_loop_wait(int timeout)
3704 IOHandlerRecord *ioh;
3705 fd_set rfds, wfds, xfds;
3709 qemu_bh_update_timeout(&timeout);
3711 host_main_loop_wait(&timeout);
3713 /* poll any events */
3714 /* XXX: separate device handlers from system ones */
3719 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3723 (!ioh->fd_read_poll ||
3724 ioh->fd_read_poll(ioh->opaque) != 0)) {
3725 FD_SET(ioh->fd, &rfds);
3729 if (ioh->fd_write) {
3730 FD_SET(ioh->fd, &wfds);
3736 tv.tv_sec = timeout / 1000;
3737 tv.tv_usec = (timeout % 1000) * 1000;
3739 #if defined(CONFIG_SLIRP)
3740 if (slirp_is_inited()) {
3741 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3744 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3746 IOHandlerRecord **pioh;
3748 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3749 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3750 ioh->fd_read(ioh->opaque);
3752 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3753 ioh->fd_write(ioh->opaque);
3757 /* remove deleted IO handlers */
3758 pioh = &first_io_handler;
3768 #if defined(CONFIG_SLIRP)
3769 if (slirp_is_inited()) {
3775 slirp_select_poll(&rfds, &wfds, &xfds);
3779 /* vm time timers */
3780 if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3781 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3782 qemu_get_clock(vm_clock));
3784 /* real time timers */
3785 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3786 qemu_get_clock(rt_clock));
3788 /* Check bottom-halves last in case any of the earlier events triggered
3794 static int main_loop(void)
3797 #ifdef CONFIG_PROFILER
3802 cur_cpu = first_cpu;
3803 next_cpu = cur_cpu->next_cpu ?: first_cpu;
3810 #ifdef CONFIG_PROFILER
3811 ti = profile_getclock();
3816 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3817 env->icount_decr.u16.low = 0;
3818 env->icount_extra = 0;
3819 count = qemu_next_deadline();
3820 count = (count + (1 << icount_time_shift) - 1)
3821 >> icount_time_shift;
3822 qemu_icount += count;
3823 decr = (count > 0xffff) ? 0xffff : count;
3825 env->icount_decr.u16.low = decr;
3826 env->icount_extra = count;
3828 ret = cpu_exec(env);
3829 #ifdef CONFIG_PROFILER
3830 qemu_time += profile_getclock() - ti;
3833 /* Fold pending instructions back into the
3834 instruction counter, and clear the interrupt flag. */
3835 qemu_icount -= (env->icount_decr.u16.low
3836 + env->icount_extra);
3837 env->icount_decr.u32 = 0;
3838 env->icount_extra = 0;
3840 next_cpu = env->next_cpu ?: first_cpu;
3841 if (event_pending && likely(ret != EXCP_DEBUG)) {
3842 ret = EXCP_INTERRUPT;
3846 if (ret == EXCP_HLT) {
3847 /* Give the next CPU a chance to run. */
3851 if (ret != EXCP_HALTED)
3853 /* all CPUs are halted ? */
3859 if (shutdown_requested) {
3860 ret = EXCP_INTERRUPT;
3868 if (reset_requested) {
3869 reset_requested = 0;
3870 qemu_system_reset();
3871 ret = EXCP_INTERRUPT;
3873 if (powerdown_requested) {
3874 powerdown_requested = 0;
3875 qemu_system_powerdown();
3876 ret = EXCP_INTERRUPT;
3878 if (unlikely(ret == EXCP_DEBUG)) {
3879 gdb_set_stop_cpu(cur_cpu);
3880 vm_stop(EXCP_DEBUG);
3882 /* If all cpus are halted then wait until the next IRQ */
3883 /* XXX: use timeout computed from timers */
3884 if (ret == EXCP_HALTED) {
3888 /* Advance virtual time to the next event. */
3889 if (use_icount == 1) {
3890 /* When not using an adaptive execution frequency
3891 we tend to get badly out of sync with real time,
3892 so just delay for a reasonable amount of time. */
3895 delta = cpu_get_icount() - cpu_get_clock();
3898 /* If virtual time is ahead of real time then just
3900 timeout = (delta / 1000000) + 1;
3902 /* Wait for either IO to occur or the next
3904 add = qemu_next_deadline();
3905 /* We advance the timer before checking for IO.
3906 Limit the amount we advance so that early IO
3907 activity won't get the guest too far ahead. */
3911 add = (add + (1 << icount_time_shift) - 1)
3912 >> icount_time_shift;
3914 timeout = delta / 1000000;
3925 if (shutdown_requested) {
3926 ret = EXCP_INTERRUPT;
3931 #ifdef CONFIG_PROFILER
3932 ti = profile_getclock();
3934 main_loop_wait(timeout);
3935 #ifdef CONFIG_PROFILER
3936 dev_time += profile_getclock() - ti;
3939 cpu_disable_ticks();
3943 static void help(int exitcode)
3945 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
3946 "usage: %s [options] [disk_image]\n"
3948 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
3950 #define DEF(option, opt_arg, opt_enum, opt_help) \
3952 #define DEFHEADING(text) stringify(text) "\n"
3953 #include "qemu-options.h"
3958 "During emulation, the following keys are useful:\n"
3959 "ctrl-alt-f toggle full screen\n"
3960 "ctrl-alt-n switch to virtual console 'n'\n"
3961 "ctrl-alt toggle mouse and keyboard grab\n"
3963 "When using -nographic, press 'ctrl-a h' to get some help.\n"
3968 DEFAULT_NETWORK_SCRIPT,
3969 DEFAULT_NETWORK_DOWN_SCRIPT,
3971 DEFAULT_GDBSTUB_PORT,
3976 #define HAS_ARG 0x0001
3979 #define DEF(option, opt_arg, opt_enum, opt_help) \
3981 #define DEFHEADING(text)
3982 #include "qemu-options.h"
3988 typedef struct QEMUOption {
3994 static const QEMUOption qemu_options[] = {
3995 { "h", 0, QEMU_OPTION_h },
3996 #define DEF(option, opt_arg, opt_enum, opt_help) \
3997 { option, opt_arg, opt_enum },
3998 #define DEFHEADING(text)
3999 #include "qemu-options.h"
4007 struct soundhw soundhw[] = {
4008 #ifdef HAS_AUDIO_CHOICE
4009 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4015 { .init_isa = pcspk_audio_init }
4022 "Creative Sound Blaster 16",
4025 { .init_isa = SB16_init }
4029 #ifdef CONFIG_CS4231A
4035 { .init_isa = cs4231a_init }
4043 "Yamaha YMF262 (OPL3)",
4045 "Yamaha YM3812 (OPL2)",
4049 { .init_isa = Adlib_init }
4056 "Gravis Ultrasound GF1",
4059 { .init_isa = GUS_init }
4066 "Intel 82801AA AC97 Audio",
4069 { .init_pci = ac97_init }
4073 #ifdef CONFIG_ES1370
4076 "ENSONIQ AudioPCI ES1370",
4079 { .init_pci = es1370_init }
4083 #endif /* HAS_AUDIO_CHOICE */
4085 { NULL, NULL, 0, 0, { NULL } }
4088 static void select_soundhw (const char *optarg)
4092 if (*optarg == '?') {
4095 printf ("Valid sound card names (comma separated):\n");
4096 for (c = soundhw; c->name; ++c) {
4097 printf ("%-11s %s\n", c->name, c->descr);
4099 printf ("\n-soundhw all will enable all of the above\n");
4100 exit (*optarg != '?');
4108 if (!strcmp (optarg, "all")) {
4109 for (c = soundhw; c->name; ++c) {
4117 e = strchr (p, ',');
4118 l = !e ? strlen (p) : (size_t) (e - p);
4120 for (c = soundhw; c->name; ++c) {
4121 if (!strncmp (c->name, p, l)) {
4130 "Unknown sound card name (too big to show)\n");
4133 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4138 p += l + (e != NULL);
4142 goto show_valid_cards;
4147 static void select_vgahw (const char *p)
4151 if (strstart(p, "std", &opts)) {
4152 std_vga_enabled = 1;
4153 cirrus_vga_enabled = 0;
4155 } else if (strstart(p, "cirrus", &opts)) {
4156 cirrus_vga_enabled = 1;
4157 std_vga_enabled = 0;
4159 } else if (strstart(p, "vmware", &opts)) {
4160 cirrus_vga_enabled = 0;
4161 std_vga_enabled = 0;
4163 } else if (strstart(p, "none", &opts)) {
4164 cirrus_vga_enabled = 0;
4165 std_vga_enabled = 0;
4169 fprintf(stderr, "Unknown vga type: %s\n", p);
4173 const char *nextopt;
4175 if (strstart(opts, ",retrace=", &nextopt)) {
4177 if (strstart(opts, "dumb", &nextopt))
4178 vga_retrace_method = VGA_RETRACE_DUMB;
4179 else if (strstart(opts, "precise", &nextopt))
4180 vga_retrace_method = VGA_RETRACE_PRECISE;
4181 else goto invalid_vga;
4182 } else goto invalid_vga;
4188 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4190 exit(STATUS_CONTROL_C_EXIT);
4195 static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4199 if(strlen(str) != 36)
4202 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4203 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4204 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4212 #define MAX_NET_CLIENTS 32
4216 static void termsig_handler(int signal)
4218 qemu_system_shutdown_request();
4221 static void termsig_setup(void)
4223 struct sigaction act;
4225 memset(&act, 0, sizeof(act));
4226 act.sa_handler = termsig_handler;
4227 sigaction(SIGINT, &act, NULL);
4228 sigaction(SIGHUP, &act, NULL);
4229 sigaction(SIGTERM, &act, NULL);
4234 int main(int argc, char **argv, char **envp)
4236 #ifdef CONFIG_GDBSTUB
4237 const char *gdbstub_dev = NULL;
4239 uint32_t boot_devices_bitmap = 0;
4241 int snapshot, linux_boot, net_boot;
4242 const char *initrd_filename;
4243 const char *kernel_filename, *kernel_cmdline;
4244 const char *boot_devices = "";
4246 DisplayChangeListener *dcl;
4247 int cyls, heads, secs, translation;
4248 const char *net_clients[MAX_NET_CLIENTS];
4250 const char *bt_opts[MAX_BT_CMDLINE];
4254 const char *r, *optarg;
4255 CharDriverState *monitor_hd = NULL;
4256 const char *monitor_device;
4257 const char *serial_devices[MAX_SERIAL_PORTS];
4258 int serial_device_index;
4259 const char *parallel_devices[MAX_PARALLEL_PORTS];
4260 int parallel_device_index;
4261 const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4262 int virtio_console_index;
4263 const char *loadvm = NULL;
4264 QEMUMachine *machine;
4265 const char *cpu_model;
4266 const char *usb_devices[MAX_USB_CMDLINE];
4267 int usb_devices_index;
4272 const char *pid_file = NULL;
4273 const char *incoming = NULL;
4276 struct passwd *pwd = NULL;
4277 const char *chroot_dir = NULL;
4278 const char *run_as = NULL;
4281 qemu_cache_utils_init(envp);
4283 LIST_INIT (&vm_change_state_head);
4286 struct sigaction act;
4287 sigfillset(&act.sa_mask);
4289 act.sa_handler = SIG_IGN;
4290 sigaction(SIGPIPE, &act, NULL);
4293 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4294 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4295 QEMU to run on a single CPU */
4300 h = GetCurrentProcess();
4301 if (GetProcessAffinityMask(h, &mask, &smask)) {
4302 for(i = 0; i < 32; i++) {
4303 if (mask & (1 << i))
4308 SetProcessAffinityMask(h, mask);
4314 register_machines();
4315 machine = first_machine;
4317 initrd_filename = NULL;
4319 vga_ram_size = VGA_RAM_SIZE;
4323 kernel_filename = NULL;
4324 kernel_cmdline = "";
4325 cyls = heads = secs = 0;
4326 translation = BIOS_ATA_TRANSLATION_AUTO;
4327 monitor_device = "vc:80Cx24C";
4329 serial_devices[0] = "vc:80Cx24C";
4330 for(i = 1; i < MAX_SERIAL_PORTS; i++)
4331 serial_devices[i] = NULL;
4332 serial_device_index = 0;
4334 parallel_devices[0] = "vc:80Cx24C";
4335 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4336 parallel_devices[i] = NULL;
4337 parallel_device_index = 0;
4339 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4340 virtio_consoles[i] = NULL;
4341 virtio_console_index = 0;
4343 usb_devices_index = 0;
4362 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4364 const QEMUOption *popt;
4367 /* Treat --foo the same as -foo. */
4370 popt = qemu_options;
4373 fprintf(stderr, "%s: invalid option -- '%s'\n",
4377 if (!strcmp(popt->name, r + 1))
4381 if (popt->flags & HAS_ARG) {
4382 if (optind >= argc) {
4383 fprintf(stderr, "%s: option '%s' requires an argument\n",
4387 optarg = argv[optind++];
4392 switch(popt->index) {
4394 machine = find_machine(optarg);
4397 printf("Supported machines are:\n");
4398 for(m = first_machine; m != NULL; m = m->next) {
4399 printf("%-10s %s%s\n",
4401 m == first_machine ? " (default)" : "");
4403 exit(*optarg != '?');
4406 case QEMU_OPTION_cpu:
4407 /* hw initialization will check this */
4408 if (*optarg == '?') {
4409 /* XXX: implement xxx_cpu_list for targets that still miss it */
4410 #if defined(cpu_list)
4411 cpu_list(stdout, &fprintf);
4418 case QEMU_OPTION_initrd:
4419 initrd_filename = optarg;
4421 case QEMU_OPTION_hda:
4423 hda_index = drive_add(optarg, HD_ALIAS, 0);
4425 hda_index = drive_add(optarg, HD_ALIAS
4426 ",cyls=%d,heads=%d,secs=%d%s",
4427 0, cyls, heads, secs,
4428 translation == BIOS_ATA_TRANSLATION_LBA ?
4430 translation == BIOS_ATA_TRANSLATION_NONE ?
4431 ",trans=none" : "");
4433 case QEMU_OPTION_hdb:
4434 case QEMU_OPTION_hdc:
4435 case QEMU_OPTION_hdd:
4436 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4438 case QEMU_OPTION_drive:
4439 drive_add(NULL, "%s", optarg);
4441 case QEMU_OPTION_mtdblock:
4442 drive_add(optarg, MTD_ALIAS);
4444 case QEMU_OPTION_sd:
4445 drive_add(optarg, SD_ALIAS);
4447 case QEMU_OPTION_pflash:
4448 drive_add(optarg, PFLASH_ALIAS);
4450 case QEMU_OPTION_snapshot:
4453 case QEMU_OPTION_hdachs:
4457 cyls = strtol(p, (char **)&p, 0);
4458 if (cyls < 1 || cyls > 16383)
4463 heads = strtol(p, (char **)&p, 0);
4464 if (heads < 1 || heads > 16)
4469 secs = strtol(p, (char **)&p, 0);
4470 if (secs < 1 || secs > 63)
4474 if (!strcmp(p, "none"))
4475 translation = BIOS_ATA_TRANSLATION_NONE;
4476 else if (!strcmp(p, "lba"))
4477 translation = BIOS_ATA_TRANSLATION_LBA;
4478 else if (!strcmp(p, "auto"))
4479 translation = BIOS_ATA_TRANSLATION_AUTO;
4482 } else if (*p != '\0') {
4484 fprintf(stderr, "qemu: invalid physical CHS format\n");
4487 if (hda_index != -1)
4488 snprintf(drives_opt[hda_index].opt,
4489 sizeof(drives_opt[hda_index].opt),
4490 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4491 0, cyls, heads, secs,
4492 translation == BIOS_ATA_TRANSLATION_LBA ?
4494 translation == BIOS_ATA_TRANSLATION_NONE ?
4495 ",trans=none" : "");
4498 case QEMU_OPTION_nographic:
4501 #ifdef CONFIG_CURSES
4502 case QEMU_OPTION_curses:
4506 case QEMU_OPTION_portrait:
4509 case QEMU_OPTION_kernel:
4510 kernel_filename = optarg;
4512 case QEMU_OPTION_append:
4513 kernel_cmdline = optarg;
4515 case QEMU_OPTION_cdrom:
4516 drive_add(optarg, CDROM_ALIAS);
4518 case QEMU_OPTION_boot:
4519 boot_devices = optarg;
4520 /* We just do some generic consistency checks */
4522 /* Could easily be extended to 64 devices if needed */
4525 boot_devices_bitmap = 0;
4526 for (p = boot_devices; *p != '\0'; p++) {
4527 /* Allowed boot devices are:
4528 * a b : floppy disk drives
4529 * c ... f : IDE disk drives
4530 * g ... m : machine implementation dependant drives
4531 * n ... p : network devices
4532 * It's up to each machine implementation to check
4533 * if the given boot devices match the actual hardware
4534 * implementation and firmware features.
4536 if (*p < 'a' || *p > 'q') {
4537 fprintf(stderr, "Invalid boot device '%c'\n", *p);
4540 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4542 "Boot device '%c' was given twice\n",*p);
4545 boot_devices_bitmap |= 1 << (*p - 'a');
4549 case QEMU_OPTION_fda:
4550 case QEMU_OPTION_fdb:
4551 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4554 case QEMU_OPTION_no_fd_bootchk:
4558 case QEMU_OPTION_net:
4559 if (nb_net_clients >= MAX_NET_CLIENTS) {
4560 fprintf(stderr, "qemu: too many network clients\n");
4563 net_clients[nb_net_clients] = optarg;
4567 case QEMU_OPTION_tftp:
4568 tftp_prefix = optarg;
4570 case QEMU_OPTION_bootp:
4571 bootp_filename = optarg;
4574 case QEMU_OPTION_smb:
4575 net_slirp_smb(optarg);
4578 case QEMU_OPTION_redir:
4579 net_slirp_redir(optarg);
4582 case QEMU_OPTION_bt:
4583 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4584 fprintf(stderr, "qemu: too many bluetooth options\n");
4587 bt_opts[nb_bt_opts++] = optarg;
4590 case QEMU_OPTION_audio_help:
4594 case QEMU_OPTION_soundhw:
4595 select_soundhw (optarg);
4601 case QEMU_OPTION_m: {
4605 value = strtoul(optarg, &ptr, 10);
4607 case 0: case 'M': case 'm':
4614 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4618 /* On 32-bit hosts, QEMU is limited by virtual address space */
4619 if (value > (2047 << 20)
4621 && HOST_LONG_BITS == 32
4624 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4627 if (value != (uint64_t)(ram_addr_t)value) {
4628 fprintf(stderr, "qemu: ram size too large\n");
4637 const CPULogItem *item;
4639 mask = cpu_str_to_log_mask(optarg);
4641 printf("Log items (comma separated):\n");
4642 for(item = cpu_log_items; item->mask != 0; item++) {
4643 printf("%-10s %s\n", item->name, item->help);
4650 #ifdef CONFIG_GDBSTUB
4652 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
4654 case QEMU_OPTION_gdb:
4655 gdbstub_dev = optarg;
4661 case QEMU_OPTION_bios:
4664 case QEMU_OPTION_singlestep:
4672 keyboard_layout = optarg;
4675 case QEMU_OPTION_localtime:
4678 case QEMU_OPTION_vga:
4679 select_vgahw (optarg);
4681 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4687 w = strtol(p, (char **)&p, 10);
4690 fprintf(stderr, "qemu: invalid resolution or depth\n");
4696 h = strtol(p, (char **)&p, 10);
4701 depth = strtol(p, (char **)&p, 10);
4702 if (depth != 8 && depth != 15 && depth != 16 &&
4703 depth != 24 && depth != 32)
4705 } else if (*p == '\0') {
4706 depth = graphic_depth;
4713 graphic_depth = depth;
4717 case QEMU_OPTION_echr:
4720 term_escape_char = strtol(optarg, &r, 0);
4722 printf("Bad argument to echr\n");
4725 case QEMU_OPTION_monitor:
4726 monitor_device = optarg;
4728 case QEMU_OPTION_serial:
4729 if (serial_device_index >= MAX_SERIAL_PORTS) {
4730 fprintf(stderr, "qemu: too many serial ports\n");
4733 serial_devices[serial_device_index] = optarg;
4734 serial_device_index++;
4736 case QEMU_OPTION_virtiocon:
4737 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
4738 fprintf(stderr, "qemu: too many virtio consoles\n");
4741 virtio_consoles[virtio_console_index] = optarg;
4742 virtio_console_index++;
4744 case QEMU_OPTION_parallel:
4745 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4746 fprintf(stderr, "qemu: too many parallel ports\n");
4749 parallel_devices[parallel_device_index] = optarg;
4750 parallel_device_index++;
4752 case QEMU_OPTION_loadvm:
4755 case QEMU_OPTION_full_screen:
4759 case QEMU_OPTION_no_frame:
4762 case QEMU_OPTION_alt_grab:
4765 case QEMU_OPTION_no_quit:
4768 case QEMU_OPTION_sdl:
4772 case QEMU_OPTION_pidfile:
4776 case QEMU_OPTION_win2k_hack:
4777 win2k_install_hack = 1;
4779 case QEMU_OPTION_rtc_td_hack:
4782 case QEMU_OPTION_acpitable:
4783 if(acpi_table_add(optarg) < 0) {
4784 fprintf(stderr, "Wrong acpi table provided\n");
4790 case QEMU_OPTION_no_kqemu:
4793 case QEMU_OPTION_kernel_kqemu:
4798 case QEMU_OPTION_enable_kvm:
4805 case QEMU_OPTION_usb:
4808 case QEMU_OPTION_usbdevice:
4810 if (usb_devices_index >= MAX_USB_CMDLINE) {
4811 fprintf(stderr, "Too many USB devices\n");
4814 usb_devices[usb_devices_index] = optarg;
4815 usb_devices_index++;
4817 case QEMU_OPTION_smp:
4818 smp_cpus = atoi(optarg);
4820 fprintf(stderr, "Invalid number of CPUs\n");
4824 case QEMU_OPTION_vnc:
4825 vnc_display = optarg;
4828 case QEMU_OPTION_no_acpi:
4831 case QEMU_OPTION_no_hpet:
4835 case QEMU_OPTION_no_reboot:
4838 case QEMU_OPTION_no_shutdown:
4841 case QEMU_OPTION_show_cursor:
4844 case QEMU_OPTION_uuid:
4845 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
4846 fprintf(stderr, "Fail to parse UUID string."
4847 " Wrong format.\n");
4852 case QEMU_OPTION_daemonize:
4856 case QEMU_OPTION_option_rom:
4857 if (nb_option_roms >= MAX_OPTION_ROMS) {
4858 fprintf(stderr, "Too many option ROMs\n");
4861 option_rom[nb_option_roms] = optarg;
4864 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4865 case QEMU_OPTION_semihosting:
4866 semihosting_enabled = 1;
4869 case QEMU_OPTION_name:
4872 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4873 case QEMU_OPTION_prom_env:
4874 if (nb_prom_envs >= MAX_PROM_ENVS) {
4875 fprintf(stderr, "Too many prom variables\n");
4878 prom_envs[nb_prom_envs] = optarg;
4883 case QEMU_OPTION_old_param:
4887 case QEMU_OPTION_clock:
4888 configure_alarms(optarg);
4890 case QEMU_OPTION_startdate:
4893 time_t rtc_start_date;
4894 if (!strcmp(optarg, "now")) {
4895 rtc_date_offset = -1;
4897 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
4905 } else if (sscanf(optarg, "%d-%d-%d",
4908 &tm.tm_mday) == 3) {
4917 rtc_start_date = mktimegm(&tm);
4918 if (rtc_start_date == -1) {
4920 fprintf(stderr, "Invalid date format. Valid format are:\n"
4921 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
4924 rtc_date_offset = time(NULL) - rtc_start_date;
4928 case QEMU_OPTION_tb_size:
4929 tb_size = strtol(optarg, NULL, 0);
4933 case QEMU_OPTION_icount:
4935 if (strcmp(optarg, "auto") == 0) {
4936 icount_time_shift = -1;
4938 icount_time_shift = strtol(optarg, NULL, 0);
4941 case QEMU_OPTION_incoming:
4945 case QEMU_OPTION_chroot:
4946 chroot_dir = optarg;
4948 case QEMU_OPTION_runas:
4956 #if defined(CONFIG_KVM) && defined(USE_KQEMU)
4957 if (kvm_allowed && kqemu_allowed) {
4959 "You can not enable both KVM and kqemu at the same time\n");
4964 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
4965 if (smp_cpus > machine->max_cpus) {
4966 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
4967 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
4973 if (serial_device_index == 0)
4974 serial_devices[0] = "stdio";
4975 if (parallel_device_index == 0)
4976 parallel_devices[0] = "null";
4977 if (strncmp(monitor_device, "vc", 2) == 0)
4978 monitor_device = "stdio";
4985 if (pipe(fds) == -1)
4996 len = read(fds[0], &status, 1);
4997 if (len == -1 && (errno == EINTR))
5002 else if (status == 1) {
5003 fprintf(stderr, "Could not acquire pidfile\n");
5020 signal(SIGTSTP, SIG_IGN);
5021 signal(SIGTTOU, SIG_IGN);
5022 signal(SIGTTIN, SIG_IGN);
5025 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5028 write(fds[1], &status, 1);
5030 fprintf(stderr, "Could not acquire pid file\n");
5039 linux_boot = (kernel_filename != NULL);
5040 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5042 if (!linux_boot && *kernel_cmdline != '\0') {
5043 fprintf(stderr, "-append only allowed with -kernel option\n");
5047 if (!linux_boot && initrd_filename != NULL) {
5048 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5052 /* boot to floppy or the default cd if no hard disk defined yet */
5053 if (!boot_devices[0]) {
5054 boot_devices = "cad";
5056 setvbuf(stdout, NULL, _IOLBF, 0);
5059 if (init_timer_alarm() < 0) {
5060 fprintf(stderr, "could not initialize alarm timer\n");
5063 if (use_icount && icount_time_shift < 0) {
5065 /* 125MIPS seems a reasonable initial guess at the guest speed.
5066 It will be corrected fairly quickly anyway. */
5067 icount_time_shift = 3;
5068 init_icount_adjust();
5075 /* init network clients */
5076 if (nb_net_clients == 0) {
5077 /* if no clients, we use a default config */
5078 net_clients[nb_net_clients++] = "nic";
5080 net_clients[nb_net_clients++] = "user";
5084 for(i = 0;i < nb_net_clients; i++) {
5085 if (net_client_parse(net_clients[i]) < 0)
5091 /* XXX: this should be moved in the PC machine instantiation code */
5092 if (net_boot != 0) {
5094 for (i = 0; i < nb_nics && i < 4; i++) {
5095 const char *model = nd_table[i].model;
5097 if (net_boot & (1 << i)) {
5100 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5101 if (get_image_size(buf) > 0) {
5102 if (nb_option_roms >= MAX_OPTION_ROMS) {
5103 fprintf(stderr, "Too many option ROMs\n");
5106 option_rom[nb_option_roms] = strdup(buf);
5113 fprintf(stderr, "No valid PXE rom found for network device\n");
5119 /* init the bluetooth world */
5120 for (i = 0; i < nb_bt_opts; i++)
5121 if (bt_parse(bt_opts[i]))
5124 /* init the memory */
5125 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5127 if (machine->ram_require & RAMSIZE_FIXED) {
5129 if (ram_size < phys_ram_size) {
5130 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5131 machine->name, (unsigned long long) phys_ram_size);
5135 phys_ram_size = ram_size;
5137 ram_size = phys_ram_size;
5140 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5142 phys_ram_size += ram_size;
5145 phys_ram_base = qemu_vmalloc(phys_ram_size);
5146 if (!phys_ram_base) {
5147 fprintf(stderr, "Could not allocate physical memory\n");
5151 /* init the dynamic translator */
5152 cpu_exec_init_all(tb_size * 1024 * 1024);
5157 /* we always create the cdrom drive, even if no disk is there */
5159 if (nb_drives_opt < MAX_DRIVES)
5160 drive_add(NULL, CDROM_ALIAS);
5162 /* we always create at least one floppy */
5164 if (nb_drives_opt < MAX_DRIVES)
5165 drive_add(NULL, FD_ALIAS, 0);
5167 /* we always create one sd slot, even if no card is in it */
5169 if (nb_drives_opt < MAX_DRIVES)
5170 drive_add(NULL, SD_ALIAS);
5172 /* open the virtual block devices */
5174 for(i = 0; i < nb_drives_opt; i++)
5175 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5178 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5179 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5182 /* must be after terminal init, SDL library changes signal handlers */
5186 /* Maintain compatibility with multiple stdio monitors */
5187 if (!strcmp(monitor_device,"stdio")) {
5188 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5189 const char *devname = serial_devices[i];
5190 if (devname && !strcmp(devname,"mon:stdio")) {
5191 monitor_device = NULL;
5193 } else if (devname && !strcmp(devname,"stdio")) {
5194 monitor_device = NULL;
5195 serial_devices[i] = "mon:stdio";
5201 if (kvm_enabled()) {
5204 ret = kvm_init(smp_cpus);
5206 fprintf(stderr, "failed to initialize KVM\n");
5211 if (monitor_device) {
5212 monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5214 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5219 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5220 const char *devname = serial_devices[i];
5221 if (devname && strcmp(devname, "none")) {
5223 snprintf(label, sizeof(label), "serial%d", i);
5224 serial_hds[i] = qemu_chr_open(label, devname, NULL);
5225 if (!serial_hds[i]) {
5226 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5233 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5234 const char *devname = parallel_devices[i];
5235 if (devname && strcmp(devname, "none")) {
5237 snprintf(label, sizeof(label), "parallel%d", i);
5238 parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5239 if (!parallel_hds[i]) {
5240 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5247 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5248 const char *devname = virtio_consoles[i];
5249 if (devname && strcmp(devname, "none")) {
5251 snprintf(label, sizeof(label), "virtcon%d", i);
5252 virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5253 if (!virtcon_hds[i]) {
5254 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5261 machine->init(ram_size, vga_ram_size, boot_devices,
5262 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5264 current_machine = machine;
5266 /* Set KVM's vcpu state to qemu's initial CPUState. */
5267 if (kvm_enabled()) {
5270 ret = kvm_sync_vcpus();
5272 fprintf(stderr, "failed to initialize vcpus\n");
5277 /* init USB devices */
5279 for(i = 0; i < usb_devices_index; i++) {
5280 if (usb_device_add(usb_devices[i], 0) < 0) {
5281 fprintf(stderr, "Warning: could not add USB device %s\n",
5288 dumb_display_init();
5289 /* just use the first displaystate for the moment */
5294 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5298 #if defined(CONFIG_CURSES)
5300 /* At the moment curses cannot be used with other displays */
5301 curses_display_init(ds, full_screen);
5305 if (vnc_display != NULL) {
5306 vnc_display_init(ds);
5307 if (vnc_display_open(ds, vnc_display) < 0)
5310 #if defined(CONFIG_SDL)
5311 if (sdl || !vnc_display)
5312 sdl_display_init(ds, full_screen, no_frame);
5313 #elif defined(CONFIG_COCOA)
5314 if (sdl || !vnc_display)
5315 cocoa_display_init(ds, full_screen);
5321 dcl = ds->listeners;
5322 while (dcl != NULL) {
5323 if (dcl->dpy_refresh != NULL) {
5324 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5325 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5330 if (nographic || (vnc_display && !sdl)) {
5331 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5332 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5335 text_consoles_set_display(display_state);
5336 qemu_chr_initial_reset();
5338 if (monitor_device && monitor_hd)
5339 monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
5341 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5342 const char *devname = serial_devices[i];
5343 if (devname && strcmp(devname, "none")) {
5345 snprintf(label, sizeof(label), "serial%d", i);
5346 if (strstart(devname, "vc", 0))
5347 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5351 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5352 const char *devname = parallel_devices[i];
5353 if (devname && strcmp(devname, "none")) {
5355 snprintf(label, sizeof(label), "parallel%d", i);
5356 if (strstart(devname, "vc", 0))
5357 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5361 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5362 const char *devname = virtio_consoles[i];
5363 if (virtcon_hds[i] && devname) {
5365 snprintf(label, sizeof(label), "virtcon%d", i);
5366 if (strstart(devname, "vc", 0))
5367 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5371 #ifdef CONFIG_GDBSTUB
5372 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5373 fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5380 do_loadvm(cur_mon, loadvm);
5383 autostart = 0; /* fixme how to deal with -daemonize */
5384 qemu_start_incoming_migration(incoming);
5396 len = write(fds[1], &status, 1);
5397 if (len == -1 && (errno == EINTR))
5404 TFR(fd = open("/dev/null", O_RDWR));
5410 pwd = getpwnam(run_as);
5412 fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5418 if (chroot(chroot_dir) < 0) {
5419 fprintf(stderr, "chroot failed\n");
5426 if (setgid(pwd->pw_gid) < 0) {
5427 fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5430 if (setuid(pwd->pw_uid) < 0) {
5431 fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5434 if (setuid(0) != -1) {
5435 fprintf(stderr, "Dropping privileges failed\n");