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
25 #include "hw/boards.h"
27 #include "hw/pcmcia.h"
29 #include "hw/audiodev.h"
37 #include "qemu-timer.h"
38 #include "qemu-char.h"
39 #include "cache-utils.h"
41 #include "audio/audio.h"
42 #include "migration.h"
55 #include <sys/times.h>
59 #include <sys/ioctl.h>
60 #include <sys/resource.h>
61 #include <sys/socket.h>
62 #include <netinet/in.h>
64 #if defined(__NetBSD__)
65 #include <net/if_tap.h>
68 #include <linux/if_tun.h>
70 #include <arpa/inet.h>
73 #include <sys/select.h>
81 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
82 #include <freebsd/stdlib.h>
87 #include <linux/rtc.h>
89 /* For the benefit of older linux systems which don't supply it,
90 we use a local copy of hpet.h. */
91 /* #include <linux/hpet.h> */
94 #include <linux/ppdev.h>
95 #include <linux/parport.h>
99 #include <sys/ethernet.h>
100 #include <sys/sockio.h>
101 #include <netinet/arp.h>
102 #include <netinet/in.h>
103 #include <netinet/in_systm.h>
104 #include <netinet/ip.h>
105 #include <netinet/ip_icmp.h> // must come after ip.h
106 #include <netinet/udp.h>
107 #include <netinet/tcp.h>
115 #include "qemu_socket.h"
117 #if defined(CONFIG_SLIRP)
118 #include "libslirp.h"
121 #if defined(__OpenBSD__)
125 #if defined(CONFIG_VDE)
126 #include <libvdeplug.h>
131 #include <sys/timeb.h>
132 #include <mmsystem.h>
133 #define getopt_long_only getopt_long
134 #define memalign(align, size) malloc(size)
141 #endif /* CONFIG_SDL */
145 #define main qemu_main
146 #endif /* CONFIG_COCOA */
150 #include "exec-all.h"
152 //#define DEBUG_UNUSED_IOPORT
153 //#define DEBUG_IOPORT
155 //#define DEBUG_SLIRP
159 # define LOG_IOPORT(...) do { \
160 if (loglevel & CPU_LOG_IOPORT) \
161 fprintf(logfile, ## __VA_ARGS__); \
164 # define LOG_IOPORT(...) do { } while (0)
168 #define DEFAULT_RAM_SIZE 144
170 #define DEFAULT_RAM_SIZE 128
173 /* Max number of USB devices that can be specified on the commandline. */
174 #define MAX_USB_CMDLINE 8
176 /* Max number of bluetooth switches on the commandline. */
177 #define MAX_BT_CMDLINE 10
179 /* XXX: use a two level table to limit memory usage */
180 #define MAX_IOPORTS 65536
182 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
183 const char *bios_name = NULL;
184 static void *ioport_opaque[MAX_IOPORTS];
185 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
186 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
187 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
188 to store the VM snapshots */
189 DriveInfo drives_table[MAX_DRIVES+1];
191 static int vga_ram_size;
192 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
193 DisplayState display_state;
196 const char* keyboard_layout = NULL;
197 int64_t ticks_per_sec;
200 NICInfo nd_table[MAX_NICS];
202 static int rtc_utc = 1;
203 static int rtc_date_offset = -1; /* -1 means no change */
204 int cirrus_vga_enabled = 1;
205 int std_vga_enabled = 0;
206 int vmsvga_enabled = 0;
208 int graphic_width = 1024;
209 int graphic_height = 768;
210 int graphic_depth = 8;
212 int graphic_width = 800;
213 int graphic_height = 600;
214 int graphic_depth = 15;
216 static int full_screen = 0;
218 static int no_frame = 0;
221 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
222 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
223 CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
225 int win2k_install_hack = 0;
230 const char *vnc_display;
231 int acpi_enabled = 1;
237 int graphic_rotate = 0;
239 const char *option_rom[MAX_OPTION_ROMS];
241 int semihosting_enabled = 0;
245 const char *qemu_name;
247 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
248 unsigned int nb_prom_envs = 0;
249 const char *prom_envs[MAX_PROM_ENVS];
251 static int nb_drives_opt;
252 static struct drive_opt {
255 } drives_opt[MAX_DRIVES];
257 static CPUState *cur_cpu;
258 static CPUState *next_cpu;
259 static int event_pending = 1;
260 /* Conversion factor from emulated instructions to virtual clock ticks. */
261 static int icount_time_shift;
262 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
263 #define MAX_ICOUNT_SHIFT 10
264 /* Compensate for varying guest execution speed. */
265 static int64_t qemu_icount_bias;
266 static QEMUTimer *icount_rt_timer;
267 static QEMUTimer *icount_vm_timer;
269 uint8_t qemu_uuid[16];
271 /***********************************************************/
272 /* x86 ISA bus support */
274 target_phys_addr_t isa_mem_base = 0;
277 static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
278 static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
280 static uint32_t ioport_read(int index, uint32_t address)
282 static IOPortReadFunc *default_func[3] = {
283 default_ioport_readb,
284 default_ioport_readw,
287 IOPortReadFunc *func = ioport_read_table[index][address];
289 func = default_func[index];
290 return func(ioport_opaque[address], address);
293 static void ioport_write(int index, uint32_t address, uint32_t data)
295 static IOPortWriteFunc *default_func[3] = {
296 default_ioport_writeb,
297 default_ioport_writew,
298 default_ioport_writel
300 IOPortWriteFunc *func = ioport_write_table[index][address];
302 func = default_func[index];
303 func(ioport_opaque[address], address, data);
306 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
308 #ifdef DEBUG_UNUSED_IOPORT
309 fprintf(stderr, "unused inb: port=0x%04x\n", address);
314 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
316 #ifdef DEBUG_UNUSED_IOPORT
317 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
321 /* default is to make two byte accesses */
322 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
325 data = ioport_read(0, address);
326 address = (address + 1) & (MAX_IOPORTS - 1);
327 data |= ioport_read(0, address) << 8;
331 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
333 ioport_write(0, address, data & 0xff);
334 address = (address + 1) & (MAX_IOPORTS - 1);
335 ioport_write(0, address, (data >> 8) & 0xff);
338 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
340 #ifdef DEBUG_UNUSED_IOPORT
341 fprintf(stderr, "unused inl: port=0x%04x\n", address);
346 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
348 #ifdef DEBUG_UNUSED_IOPORT
349 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
353 /* size is the word size in byte */
354 int register_ioport_read(int start, int length, int size,
355 IOPortReadFunc *func, void *opaque)
361 } else if (size == 2) {
363 } else if (size == 4) {
366 hw_error("register_ioport_read: invalid size");
369 for(i = start; i < start + length; i += size) {
370 ioport_read_table[bsize][i] = func;
371 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
372 hw_error("register_ioport_read: invalid opaque");
373 ioport_opaque[i] = opaque;
378 /* size is the word size in byte */
379 int register_ioport_write(int start, int length, int size,
380 IOPortWriteFunc *func, void *opaque)
386 } else if (size == 2) {
388 } else if (size == 4) {
391 hw_error("register_ioport_write: invalid size");
394 for(i = start; i < start + length; i += size) {
395 ioport_write_table[bsize][i] = func;
396 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
397 hw_error("register_ioport_write: invalid opaque");
398 ioport_opaque[i] = opaque;
403 void isa_unassign_ioport(int start, int length)
407 for(i = start; i < start + length; i++) {
408 ioport_read_table[0][i] = default_ioport_readb;
409 ioport_read_table[1][i] = default_ioport_readw;
410 ioport_read_table[2][i] = default_ioport_readl;
412 ioport_write_table[0][i] = default_ioport_writeb;
413 ioport_write_table[1][i] = default_ioport_writew;
414 ioport_write_table[2][i] = default_ioport_writel;
418 /***********************************************************/
420 void cpu_outb(CPUState *env, int addr, int val)
422 LOG_IOPORT("outb: %04x %02x\n", addr, val);
423 ioport_write(0, addr, val);
426 env->last_io_time = cpu_get_time_fast();
430 void cpu_outw(CPUState *env, int addr, int val)
432 LOG_IOPORT("outw: %04x %04x\n", addr, val);
433 ioport_write(1, addr, val);
436 env->last_io_time = cpu_get_time_fast();
440 void cpu_outl(CPUState *env, int addr, int val)
442 LOG_IOPORT("outl: %04x %08x\n", addr, val);
443 ioport_write(2, addr, val);
446 env->last_io_time = cpu_get_time_fast();
450 int cpu_inb(CPUState *env, int addr)
453 val = ioport_read(0, addr);
454 LOG_IOPORT("inb : %04x %02x\n", addr, val);
457 env->last_io_time = cpu_get_time_fast();
462 int cpu_inw(CPUState *env, int addr)
465 val = ioport_read(1, addr);
466 LOG_IOPORT("inw : %04x %04x\n", addr, val);
469 env->last_io_time = cpu_get_time_fast();
474 int cpu_inl(CPUState *env, int addr)
477 val = ioport_read(2, addr);
478 LOG_IOPORT("inl : %04x %08x\n", addr, val);
481 env->last_io_time = cpu_get_time_fast();
486 /***********************************************************/
487 void hw_error(const char *fmt, ...)
493 fprintf(stderr, "qemu: hardware error: ");
494 vfprintf(stderr, fmt, ap);
495 fprintf(stderr, "\n");
496 for(env = first_cpu; env != NULL; env = env->next_cpu) {
497 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
499 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
501 cpu_dump_state(env, stderr, fprintf, 0);
511 static QEMUBalloonEvent *qemu_balloon_event;
512 void *qemu_balloon_event_opaque;
514 void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
516 qemu_balloon_event = func;
517 qemu_balloon_event_opaque = opaque;
520 void qemu_balloon(ram_addr_t target)
522 if (qemu_balloon_event)
523 qemu_balloon_event(qemu_balloon_event_opaque, target);
526 ram_addr_t qemu_balloon_status(void)
528 if (qemu_balloon_event)
529 return qemu_balloon_event(qemu_balloon_event_opaque, 0);
533 /***********************************************************/
536 static QEMUPutKBDEvent *qemu_put_kbd_event;
537 static void *qemu_put_kbd_event_opaque;
538 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
539 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
541 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
543 qemu_put_kbd_event_opaque = opaque;
544 qemu_put_kbd_event = func;
547 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
548 void *opaque, int absolute,
551 QEMUPutMouseEntry *s, *cursor;
553 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
557 s->qemu_put_mouse_event = func;
558 s->qemu_put_mouse_event_opaque = opaque;
559 s->qemu_put_mouse_event_absolute = absolute;
560 s->qemu_put_mouse_event_name = qemu_strdup(name);
563 if (!qemu_put_mouse_event_head) {
564 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
568 cursor = qemu_put_mouse_event_head;
569 while (cursor->next != NULL)
570 cursor = cursor->next;
573 qemu_put_mouse_event_current = s;
578 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
580 QEMUPutMouseEntry *prev = NULL, *cursor;
582 if (!qemu_put_mouse_event_head || entry == NULL)
585 cursor = qemu_put_mouse_event_head;
586 while (cursor != NULL && cursor != entry) {
588 cursor = cursor->next;
591 if (cursor == NULL) // does not exist or list empty
593 else if (prev == NULL) { // entry is head
594 qemu_put_mouse_event_head = cursor->next;
595 if (qemu_put_mouse_event_current == entry)
596 qemu_put_mouse_event_current = cursor->next;
597 qemu_free(entry->qemu_put_mouse_event_name);
602 prev->next = entry->next;
604 if (qemu_put_mouse_event_current == entry)
605 qemu_put_mouse_event_current = prev;
607 qemu_free(entry->qemu_put_mouse_event_name);
611 void kbd_put_keycode(int keycode)
613 if (qemu_put_kbd_event) {
614 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
618 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
620 QEMUPutMouseEvent *mouse_event;
621 void *mouse_event_opaque;
624 if (!qemu_put_mouse_event_current) {
629 qemu_put_mouse_event_current->qemu_put_mouse_event;
631 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
634 if (graphic_rotate) {
635 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
638 width = graphic_width - 1;
639 mouse_event(mouse_event_opaque,
640 width - dy, dx, dz, buttons_state);
642 mouse_event(mouse_event_opaque,
643 dx, dy, dz, buttons_state);
647 int kbd_mouse_is_absolute(void)
649 if (!qemu_put_mouse_event_current)
652 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
655 void do_info_mice(void)
657 QEMUPutMouseEntry *cursor;
660 if (!qemu_put_mouse_event_head) {
661 term_printf("No mouse devices connected\n");
665 term_printf("Mouse devices available:\n");
666 cursor = qemu_put_mouse_event_head;
667 while (cursor != NULL) {
668 term_printf("%c Mouse #%d: %s\n",
669 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
670 index, cursor->qemu_put_mouse_event_name);
672 cursor = cursor->next;
676 void do_mouse_set(int index)
678 QEMUPutMouseEntry *cursor;
681 if (!qemu_put_mouse_event_head) {
682 term_printf("No mouse devices connected\n");
686 cursor = qemu_put_mouse_event_head;
687 while (cursor != NULL && index != i) {
689 cursor = cursor->next;
693 qemu_put_mouse_event_current = cursor;
695 term_printf("Mouse at given index not found\n");
698 /* compute with 96 bit intermediate result: (a*b)/c */
699 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
704 #ifdef WORDS_BIGENDIAN
714 rl = (uint64_t)u.l.low * (uint64_t)b;
715 rh = (uint64_t)u.l.high * (uint64_t)b;
718 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
722 /***********************************************************/
723 /* real time host monotonic timer */
725 #define QEMU_TIMER_BASE 1000000000LL
729 static int64_t clock_freq;
731 static void init_get_clock(void)
735 ret = QueryPerformanceFrequency(&freq);
737 fprintf(stderr, "Could not calibrate ticks\n");
740 clock_freq = freq.QuadPart;
743 static int64_t get_clock(void)
746 QueryPerformanceCounter(&ti);
747 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
752 static int use_rt_clock;
754 static void init_get_clock(void)
757 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
760 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
767 static int64_t get_clock(void)
769 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
772 clock_gettime(CLOCK_MONOTONIC, &ts);
773 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
777 /* XXX: using gettimeofday leads to problems if the date
778 changes, so it should be avoided. */
780 gettimeofday(&tv, NULL);
781 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
786 /* Return the virtual CPU time, based on the instruction counter. */
787 static int64_t cpu_get_icount(void)
790 CPUState *env = cpu_single_env;;
791 icount = qemu_icount;
794 fprintf(stderr, "Bad clock read\n");
795 icount -= (env->icount_decr.u16.low + env->icount_extra);
797 return qemu_icount_bias + (icount << icount_time_shift);
800 /***********************************************************/
801 /* guest cycle counter */
803 static int64_t cpu_ticks_prev;
804 static int64_t cpu_ticks_offset;
805 static int64_t cpu_clock_offset;
806 static int cpu_ticks_enabled;
808 /* return the host CPU cycle counter and handle stop/restart */
809 int64_t cpu_get_ticks(void)
812 return cpu_get_icount();
814 if (!cpu_ticks_enabled) {
815 return cpu_ticks_offset;
818 ticks = cpu_get_real_ticks();
819 if (cpu_ticks_prev > ticks) {
820 /* Note: non increasing ticks may happen if the host uses
822 cpu_ticks_offset += cpu_ticks_prev - ticks;
824 cpu_ticks_prev = ticks;
825 return ticks + cpu_ticks_offset;
829 /* return the host CPU monotonic timer and handle stop/restart */
830 static int64_t cpu_get_clock(void)
833 if (!cpu_ticks_enabled) {
834 return cpu_clock_offset;
837 return ti + cpu_clock_offset;
841 /* enable cpu_get_ticks() */
842 void cpu_enable_ticks(void)
844 if (!cpu_ticks_enabled) {
845 cpu_ticks_offset -= cpu_get_real_ticks();
846 cpu_clock_offset -= get_clock();
847 cpu_ticks_enabled = 1;
851 /* disable cpu_get_ticks() : the clock is stopped. You must not call
852 cpu_get_ticks() after that. */
853 void cpu_disable_ticks(void)
855 if (cpu_ticks_enabled) {
856 cpu_ticks_offset = cpu_get_ticks();
857 cpu_clock_offset = cpu_get_clock();
858 cpu_ticks_enabled = 0;
862 /***********************************************************/
865 #define QEMU_TIMER_REALTIME 0
866 #define QEMU_TIMER_VIRTUAL 1
870 /* XXX: add frequency */
878 struct QEMUTimer *next;
881 struct qemu_alarm_timer {
885 int (*start)(struct qemu_alarm_timer *t);
886 void (*stop)(struct qemu_alarm_timer *t);
887 void (*rearm)(struct qemu_alarm_timer *t);
891 #define ALARM_FLAG_DYNTICKS 0x1
892 #define ALARM_FLAG_EXPIRED 0x2
894 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
896 return t->flags & ALARM_FLAG_DYNTICKS;
899 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
901 if (!alarm_has_dynticks(t))
907 /* TODO: MIN_TIMER_REARM_US should be optimized */
908 #define MIN_TIMER_REARM_US 250
910 static struct qemu_alarm_timer *alarm_timer;
912 static int alarm_timer_rfd, alarm_timer_wfd;
917 struct qemu_alarm_win32 {
921 } alarm_win32_data = {0, NULL, -1};
923 static int win32_start_timer(struct qemu_alarm_timer *t);
924 static void win32_stop_timer(struct qemu_alarm_timer *t);
925 static void win32_rearm_timer(struct qemu_alarm_timer *t);
929 static int unix_start_timer(struct qemu_alarm_timer *t);
930 static void unix_stop_timer(struct qemu_alarm_timer *t);
934 static int dynticks_start_timer(struct qemu_alarm_timer *t);
935 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
936 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
938 static int hpet_start_timer(struct qemu_alarm_timer *t);
939 static void hpet_stop_timer(struct qemu_alarm_timer *t);
941 static int rtc_start_timer(struct qemu_alarm_timer *t);
942 static void rtc_stop_timer(struct qemu_alarm_timer *t);
944 #endif /* __linux__ */
948 /* Correlation between real and virtual time is always going to be
949 fairly approximate, so ignore small variation.
950 When the guest is idle real and virtual time will be aligned in
952 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
954 static void icount_adjust(void)
959 static int64_t last_delta;
960 /* If the VM is not running, then do nothing. */
964 cur_time = cpu_get_clock();
965 cur_icount = qemu_get_clock(vm_clock);
966 delta = cur_icount - cur_time;
967 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
969 && last_delta + ICOUNT_WOBBLE < delta * 2
970 && icount_time_shift > 0) {
971 /* The guest is getting too far ahead. Slow time down. */
975 && last_delta - ICOUNT_WOBBLE > delta * 2
976 && icount_time_shift < MAX_ICOUNT_SHIFT) {
977 /* The guest is getting too far behind. Speed time up. */
981 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
984 static void icount_adjust_rt(void * opaque)
986 qemu_mod_timer(icount_rt_timer,
987 qemu_get_clock(rt_clock) + 1000);
991 static void icount_adjust_vm(void * opaque)
993 qemu_mod_timer(icount_vm_timer,
994 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
998 static void init_icount_adjust(void)
1000 /* Have both realtime and virtual time triggers for speed adjustment.
1001 The realtime trigger catches emulated time passing too slowly,
1002 the virtual time trigger catches emulated time passing too fast.
1003 Realtime triggers occur even when idle, so use them less frequently
1004 than VM triggers. */
1005 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
1006 qemu_mod_timer(icount_rt_timer,
1007 qemu_get_clock(rt_clock) + 1000);
1008 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
1009 qemu_mod_timer(icount_vm_timer,
1010 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1013 static struct qemu_alarm_timer alarm_timers[] = {
1016 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1017 dynticks_stop_timer, dynticks_rearm_timer, NULL},
1018 /* HPET - if available - is preferred */
1019 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
1020 /* ...otherwise try RTC */
1021 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
1023 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
1025 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1026 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1027 {"win32", 0, win32_start_timer,
1028 win32_stop_timer, NULL, &alarm_win32_data},
1033 static void show_available_alarms(void)
1037 printf("Available alarm timers, in order of precedence:\n");
1038 for (i = 0; alarm_timers[i].name; i++)
1039 printf("%s\n", alarm_timers[i].name);
1042 static void configure_alarms(char const *opt)
1046 int count = ARRAY_SIZE(alarm_timers) - 1;
1049 struct qemu_alarm_timer tmp;
1051 if (!strcmp(opt, "?")) {
1052 show_available_alarms();
1058 /* Reorder the array */
1059 name = strtok(arg, ",");
1061 for (i = 0; i < count && alarm_timers[i].name; i++) {
1062 if (!strcmp(alarm_timers[i].name, name))
1067 fprintf(stderr, "Unknown clock %s\n", name);
1076 tmp = alarm_timers[i];
1077 alarm_timers[i] = alarm_timers[cur];
1078 alarm_timers[cur] = tmp;
1082 name = strtok(NULL, ",");
1088 /* Disable remaining timers */
1089 for (i = cur; i < count; i++)
1090 alarm_timers[i].name = NULL;
1092 show_available_alarms();
1097 QEMUClock *rt_clock;
1098 QEMUClock *vm_clock;
1100 static QEMUTimer *active_timers[2];
1102 static QEMUClock *qemu_new_clock(int type)
1105 clock = qemu_mallocz(sizeof(QEMUClock));
1112 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1116 ts = qemu_mallocz(sizeof(QEMUTimer));
1119 ts->opaque = opaque;
1123 void qemu_free_timer(QEMUTimer *ts)
1128 /* stop a timer, but do not dealloc it */
1129 void qemu_del_timer(QEMUTimer *ts)
1133 /* NOTE: this code must be signal safe because
1134 qemu_timer_expired() can be called from a signal. */
1135 pt = &active_timers[ts->clock->type];
1148 /* modify the current timer so that it will be fired when current_time
1149 >= expire_time. The corresponding callback will be called. */
1150 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1156 /* add the timer in the sorted list */
1157 /* NOTE: this code must be signal safe because
1158 qemu_timer_expired() can be called from a signal. */
1159 pt = &active_timers[ts->clock->type];
1164 if (t->expire_time > expire_time)
1168 ts->expire_time = expire_time;
1172 /* Rearm if necessary */
1173 if (pt == &active_timers[ts->clock->type]) {
1174 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1175 qemu_rearm_alarm_timer(alarm_timer);
1177 /* Interrupt execution to force deadline recalculation. */
1178 if (use_icount && cpu_single_env) {
1179 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1184 int qemu_timer_pending(QEMUTimer *ts)
1187 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1194 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1198 return (timer_head->expire_time <= current_time);
1201 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1207 if (!ts || ts->expire_time > current_time)
1209 /* remove timer from the list before calling the callback */
1210 *ptimer_head = ts->next;
1213 /* run the callback (the timer list can be modified) */
1218 int64_t qemu_get_clock(QEMUClock *clock)
1220 switch(clock->type) {
1221 case QEMU_TIMER_REALTIME:
1222 return get_clock() / 1000000;
1224 case QEMU_TIMER_VIRTUAL:
1226 return cpu_get_icount();
1228 return cpu_get_clock();
1233 static void init_timers(void)
1236 ticks_per_sec = QEMU_TIMER_BASE;
1237 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1238 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1242 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1244 uint64_t expire_time;
1246 if (qemu_timer_pending(ts)) {
1247 expire_time = ts->expire_time;
1251 qemu_put_be64(f, expire_time);
1254 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1256 uint64_t expire_time;
1258 expire_time = qemu_get_be64(f);
1259 if (expire_time != -1) {
1260 qemu_mod_timer(ts, expire_time);
1266 static void timer_save(QEMUFile *f, void *opaque)
1268 if (cpu_ticks_enabled) {
1269 hw_error("cannot save state if virtual timers are running");
1271 qemu_put_be64(f, cpu_ticks_offset);
1272 qemu_put_be64(f, ticks_per_sec);
1273 qemu_put_be64(f, cpu_clock_offset);
1276 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1278 if (version_id != 1 && version_id != 2)
1280 if (cpu_ticks_enabled) {
1283 cpu_ticks_offset=qemu_get_be64(f);
1284 ticks_per_sec=qemu_get_be64(f);
1285 if (version_id == 2) {
1286 cpu_clock_offset=qemu_get_be64(f);
1292 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1293 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1295 static void host_alarm_handler(int host_signum)
1299 #define DISP_FREQ 1000
1301 static int64_t delta_min = INT64_MAX;
1302 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1304 ti = qemu_get_clock(vm_clock);
1305 if (last_clock != 0) {
1306 delta = ti - last_clock;
1307 if (delta < delta_min)
1309 if (delta > delta_max)
1312 if (++count == DISP_FREQ) {
1313 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1314 muldiv64(delta_min, 1000000, ticks_per_sec),
1315 muldiv64(delta_max, 1000000, ticks_per_sec),
1316 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1317 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1319 delta_min = INT64_MAX;
1327 if (alarm_has_dynticks(alarm_timer) ||
1329 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1330 qemu_get_clock(vm_clock))) ||
1331 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1332 qemu_get_clock(rt_clock))) {
1333 CPUState *env = next_cpu;
1336 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1337 SetEvent(data->host_alarm);
1339 static const char byte = 0;
1340 write(alarm_timer_wfd, &byte, sizeof(byte));
1342 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1345 /* stop the currently executing cpu because a timer occured */
1346 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1348 if (env->kqemu_enabled) {
1349 kqemu_cpu_interrupt(env);
1357 static int64_t qemu_next_deadline(void)
1361 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1362 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1363 qemu_get_clock(vm_clock);
1365 /* To avoid problems with overflow limit this to 2^32. */
1375 #if defined(__linux__) || defined(_WIN32)
1376 static uint64_t qemu_next_deadline_dyntick(void)
1384 delta = (qemu_next_deadline() + 999) / 1000;
1386 if (active_timers[QEMU_TIMER_REALTIME]) {
1387 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1388 qemu_get_clock(rt_clock))*1000;
1389 if (rtdelta < delta)
1393 if (delta < MIN_TIMER_REARM_US)
1394 delta = MIN_TIMER_REARM_US;
1402 /* Sets a specific flag */
1403 static int fcntl_setfl(int fd, int flag)
1407 flags = fcntl(fd, F_GETFL);
1411 if (fcntl(fd, F_SETFL, flags | flag) == -1)
1417 #if defined(__linux__)
1419 #define RTC_FREQ 1024
1421 static void enable_sigio_timer(int fd)
1423 struct sigaction act;
1426 sigfillset(&act.sa_mask);
1428 act.sa_handler = host_alarm_handler;
1430 sigaction(SIGIO, &act, NULL);
1431 fcntl_setfl(fd, O_ASYNC);
1432 fcntl(fd, F_SETOWN, getpid());
1435 static int hpet_start_timer(struct qemu_alarm_timer *t)
1437 struct hpet_info info;
1440 fd = open("/dev/hpet", O_RDONLY);
1445 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1447 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1448 "error, but for better emulation accuracy type:\n"
1449 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1453 /* Check capabilities */
1454 r = ioctl(fd, HPET_INFO, &info);
1458 /* Enable periodic mode */
1459 r = ioctl(fd, HPET_EPI, 0);
1460 if (info.hi_flags && (r < 0))
1463 /* Enable interrupt */
1464 r = ioctl(fd, HPET_IE_ON, 0);
1468 enable_sigio_timer(fd);
1469 t->priv = (void *)(long)fd;
1477 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1479 int fd = (long)t->priv;
1484 static int rtc_start_timer(struct qemu_alarm_timer *t)
1487 unsigned long current_rtc_freq = 0;
1489 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1492 ioctl(rtc_fd, RTC_IRQP_READ, ¤t_rtc_freq);
1493 if (current_rtc_freq != RTC_FREQ &&
1494 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1495 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1496 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1497 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1500 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1506 enable_sigio_timer(rtc_fd);
1508 t->priv = (void *)(long)rtc_fd;
1513 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1515 int rtc_fd = (long)t->priv;
1520 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1524 struct sigaction act;
1526 sigfillset(&act.sa_mask);
1528 act.sa_handler = host_alarm_handler;
1530 sigaction(SIGALRM, &act, NULL);
1532 ev.sigev_value.sival_int = 0;
1533 ev.sigev_notify = SIGEV_SIGNAL;
1534 ev.sigev_signo = SIGALRM;
1536 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1537 perror("timer_create");
1539 /* disable dynticks */
1540 fprintf(stderr, "Dynamic Ticks disabled\n");
1545 t->priv = (void *)(long)host_timer;
1550 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1552 timer_t host_timer = (timer_t)(long)t->priv;
1554 timer_delete(host_timer);
1557 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1559 timer_t host_timer = (timer_t)(long)t->priv;
1560 struct itimerspec timeout;
1561 int64_t nearest_delta_us = INT64_MAX;
1564 if (!active_timers[QEMU_TIMER_REALTIME] &&
1565 !active_timers[QEMU_TIMER_VIRTUAL])
1568 nearest_delta_us = qemu_next_deadline_dyntick();
1570 /* check whether a timer is already running */
1571 if (timer_gettime(host_timer, &timeout)) {
1573 fprintf(stderr, "Internal timer error: aborting\n");
1576 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1577 if (current_us && current_us <= nearest_delta_us)
1580 timeout.it_interval.tv_sec = 0;
1581 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1582 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1583 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1584 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1586 fprintf(stderr, "Internal timer error: aborting\n");
1591 #endif /* defined(__linux__) */
1593 static int unix_start_timer(struct qemu_alarm_timer *t)
1595 struct sigaction act;
1596 struct itimerval itv;
1600 sigfillset(&act.sa_mask);
1602 act.sa_handler = host_alarm_handler;
1604 sigaction(SIGALRM, &act, NULL);
1606 itv.it_interval.tv_sec = 0;
1607 /* for i386 kernel 2.6 to get 1 ms */
1608 itv.it_interval.tv_usec = 999;
1609 itv.it_value.tv_sec = 0;
1610 itv.it_value.tv_usec = 10 * 1000;
1612 err = setitimer(ITIMER_REAL, &itv, NULL);
1619 static void unix_stop_timer(struct qemu_alarm_timer *t)
1621 struct itimerval itv;
1623 memset(&itv, 0, sizeof(itv));
1624 setitimer(ITIMER_REAL, &itv, NULL);
1627 #endif /* !defined(_WIN32) */
1629 static void try_to_rearm_timer(void *opaque)
1631 struct qemu_alarm_timer *t = opaque;
1635 /* Drain the notify pipe */
1638 len = read(alarm_timer_rfd, buffer, sizeof(buffer));
1639 } while ((len == -1 && errno == EINTR) || len > 0);
1642 if (t->flags & ALARM_FLAG_EXPIRED) {
1643 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
1644 qemu_rearm_alarm_timer(alarm_timer);
1650 static int win32_start_timer(struct qemu_alarm_timer *t)
1653 struct qemu_alarm_win32 *data = t->priv;
1656 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1657 if (!data->host_alarm) {
1658 perror("Failed CreateEvent");
1662 memset(&tc, 0, sizeof(tc));
1663 timeGetDevCaps(&tc, sizeof(tc));
1665 if (data->period < tc.wPeriodMin)
1666 data->period = tc.wPeriodMin;
1668 timeBeginPeriod(data->period);
1670 flags = TIME_CALLBACK_FUNCTION;
1671 if (alarm_has_dynticks(t))
1672 flags |= TIME_ONESHOT;
1674 flags |= TIME_PERIODIC;
1676 data->timerId = timeSetEvent(1, // interval (ms)
1677 data->period, // resolution
1678 host_alarm_handler, // function
1679 (DWORD)t, // parameter
1682 if (!data->timerId) {
1683 perror("Failed to initialize win32 alarm timer");
1685 timeEndPeriod(data->period);
1686 CloseHandle(data->host_alarm);
1690 qemu_add_wait_object(data->host_alarm, try_to_rearm_timer, t);
1695 static void win32_stop_timer(struct qemu_alarm_timer *t)
1697 struct qemu_alarm_win32 *data = t->priv;
1699 timeKillEvent(data->timerId);
1700 timeEndPeriod(data->period);
1702 CloseHandle(data->host_alarm);
1705 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1707 struct qemu_alarm_win32 *data = t->priv;
1708 uint64_t nearest_delta_us;
1710 if (!active_timers[QEMU_TIMER_REALTIME] &&
1711 !active_timers[QEMU_TIMER_VIRTUAL])
1714 nearest_delta_us = qemu_next_deadline_dyntick();
1715 nearest_delta_us /= 1000;
1717 timeKillEvent(data->timerId);
1719 data->timerId = timeSetEvent(1,
1723 TIME_ONESHOT | TIME_PERIODIC);
1725 if (!data->timerId) {
1726 perror("Failed to re-arm win32 alarm timer");
1728 timeEndPeriod(data->period);
1729 CloseHandle(data->host_alarm);
1736 static int init_timer_alarm(void)
1738 struct qemu_alarm_timer *t = NULL;
1748 err = fcntl_setfl(fds[0], O_NONBLOCK);
1752 err = fcntl_setfl(fds[1], O_NONBLOCK);
1756 alarm_timer_rfd = fds[0];
1757 alarm_timer_wfd = fds[1];
1760 for (i = 0; alarm_timers[i].name; i++) {
1761 t = &alarm_timers[i];
1774 qemu_set_fd_handler2(alarm_timer_rfd, NULL,
1775 try_to_rearm_timer, NULL, t);
1790 static void quit_timers(void)
1792 alarm_timer->stop(alarm_timer);
1796 /***********************************************************/
1797 /* host time/date access */
1798 void qemu_get_timedate(struct tm *tm, int offset)
1805 if (rtc_date_offset == -1) {
1809 ret = localtime(&ti);
1811 ti -= rtc_date_offset;
1815 memcpy(tm, ret, sizeof(struct tm));
1818 int qemu_timedate_diff(struct tm *tm)
1822 if (rtc_date_offset == -1)
1824 seconds = mktimegm(tm);
1826 seconds = mktime(tm);
1828 seconds = mktimegm(tm) + rtc_date_offset;
1830 return seconds - time(NULL);
1834 static void socket_cleanup(void)
1839 static int socket_init(void)
1844 ret = WSAStartup(MAKEWORD(2,2), &Data);
1846 err = WSAGetLastError();
1847 fprintf(stderr, "WSAStartup: %d\n", err);
1850 atexit(socket_cleanup);
1855 const char *get_opt_name(char *buf, int buf_size, const char *p)
1860 while (*p != '\0' && *p != '=') {
1861 if (q && (q - buf) < buf_size - 1)
1871 const char *get_opt_value(char *buf, int buf_size, const char *p)
1876 while (*p != '\0') {
1878 if (*(p + 1) != ',')
1882 if (q && (q - buf) < buf_size - 1)
1892 int get_param_value(char *buf, int buf_size,
1893 const char *tag, const char *str)
1900 p = get_opt_name(option, sizeof(option), p);
1904 if (!strcmp(tag, option)) {
1905 (void)get_opt_value(buf, buf_size, p);
1908 p = get_opt_value(NULL, 0, p);
1917 int check_params(char *buf, int buf_size,
1918 const char * const *params, const char *str)
1925 p = get_opt_name(buf, buf_size, p);
1929 for(i = 0; params[i] != NULL; i++)
1930 if (!strcmp(params[i], buf))
1932 if (params[i] == NULL)
1934 p = get_opt_value(NULL, 0, p);
1942 /***********************************************************/
1943 /* Bluetooth support */
1946 static struct HCIInfo *hci_table[MAX_NICS];
1948 static struct bt_vlan_s {
1949 struct bt_scatternet_s net;
1951 struct bt_vlan_s *next;
1954 /* find or alloc a new bluetooth "VLAN" */
1955 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1957 struct bt_vlan_s **pvlan, *vlan;
1958 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1962 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1964 pvlan = &first_bt_vlan;
1965 while (*pvlan != NULL)
1966 pvlan = &(*pvlan)->next;
1971 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1975 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1980 static struct HCIInfo null_hci = {
1981 .cmd_send = null_hci_send,
1982 .sco_send = null_hci_send,
1983 .acl_send = null_hci_send,
1984 .bdaddr_set = null_hci_addr_set,
1987 struct HCIInfo *qemu_next_hci(void)
1989 if (cur_hci == nb_hcis)
1992 return hci_table[cur_hci++];
1995 static struct HCIInfo *hci_init(const char *str)
1998 struct bt_scatternet_s *vlan = 0;
2000 if (!strcmp(str, "null"))
2003 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
2005 return bt_host_hci(str[4] ? str + 5 : "hci0");
2006 else if (!strncmp(str, "hci", 3)) {
2009 if (!strncmp(str + 3, ",vlan=", 6)) {
2010 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
2015 vlan = qemu_find_bt_vlan(0);
2017 return bt_new_hci(vlan);
2020 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
2025 static int bt_hci_parse(const char *str)
2027 struct HCIInfo *hci;
2030 if (nb_hcis >= MAX_NICS) {
2031 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
2035 hci = hci_init(str);
2044 bdaddr.b[5] = 0x56 + nb_hcis;
2045 hci->bdaddr_set(hci, bdaddr.b);
2047 hci_table[nb_hcis++] = hci;
2052 static void bt_vhci_add(int vlan_id)
2054 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
2057 fprintf(stderr, "qemu: warning: adding a VHCI to "
2058 "an empty scatternet %i\n", vlan_id);
2060 bt_vhci_init(bt_new_hci(vlan));
2063 static struct bt_device_s *bt_device_add(const char *opt)
2065 struct bt_scatternet_s *vlan;
2067 char *endp = strstr(opt, ",vlan=");
2068 int len = (endp ? endp - opt : strlen(opt)) + 1;
2071 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2074 vlan_id = strtol(endp + 6, &endp, 0);
2076 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2081 vlan = qemu_find_bt_vlan(vlan_id);
2084 fprintf(stderr, "qemu: warning: adding a slave device to "
2085 "an empty scatternet %i\n", vlan_id);
2087 if (!strcmp(devname, "keyboard"))
2088 return bt_keyboard_init(vlan);
2090 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2094 static int bt_parse(const char *opt)
2096 const char *endp, *p;
2099 if (strstart(opt, "hci", &endp)) {
2100 if (!*endp || *endp == ',') {
2102 if (!strstart(endp, ",vlan=", 0))
2105 return bt_hci_parse(opt);
2107 } else if (strstart(opt, "vhci", &endp)) {
2108 if (!*endp || *endp == ',') {
2110 if (strstart(endp, ",vlan=", &p)) {
2111 vlan = strtol(p, (char **) &endp, 0);
2113 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2117 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2126 } else if (strstart(opt, "device:", &endp))
2127 return !bt_device_add(endp);
2129 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2133 /***********************************************************/
2134 /* QEMU Block devices */
2136 #define HD_ALIAS "index=%d,media=disk"
2138 #define CDROM_ALIAS "index=1,media=cdrom"
2140 #define CDROM_ALIAS "index=2,media=cdrom"
2142 #define FD_ALIAS "index=%d,if=floppy"
2143 #define PFLASH_ALIAS "if=pflash"
2144 #define MTD_ALIAS "if=mtd"
2145 #define SD_ALIAS "index=0,if=sd"
2147 static int drive_add(const char *file, const char *fmt, ...)
2151 if (nb_drives_opt >= MAX_DRIVES) {
2152 fprintf(stderr, "qemu: too many drives\n");
2156 drives_opt[nb_drives_opt].file = file;
2158 vsnprintf(drives_opt[nb_drives_opt].opt,
2159 sizeof(drives_opt[0].opt), fmt, ap);
2162 return nb_drives_opt++;
2165 int drive_get_index(BlockInterfaceType type, int bus, int unit)
2169 /* seek interface, bus and unit */
2171 for (index = 0; index < nb_drives; index++)
2172 if (drives_table[index].type == type &&
2173 drives_table[index].bus == bus &&
2174 drives_table[index].unit == unit)
2180 int drive_get_max_bus(BlockInterfaceType type)
2186 for (index = 0; index < nb_drives; index++) {
2187 if(drives_table[index].type == type &&
2188 drives_table[index].bus > max_bus)
2189 max_bus = drives_table[index].bus;
2194 const char *drive_get_serial(BlockDriverState *bdrv)
2198 for (index = 0; index < nb_drives; index++)
2199 if (drives_table[index].bdrv == bdrv)
2200 return drives_table[index].serial;
2205 static void bdrv_format_print(void *opaque, const char *name)
2207 fprintf(stderr, " %s", name);
2210 static int drive_init(struct drive_opt *arg, int snapshot,
2211 QEMUMachine *machine)
2217 const char *mediastr = "";
2218 BlockInterfaceType type;
2219 enum { MEDIA_DISK, MEDIA_CDROM } media;
2220 int bus_id, unit_id;
2221 int cyls, heads, secs, translation;
2222 BlockDriverState *bdrv;
2223 BlockDriver *drv = NULL;
2228 char *str = arg->opt;
2229 static const char * const params[] = { "bus", "unit", "if", "index",
2230 "cyls", "heads", "secs", "trans",
2231 "media", "snapshot", "file",
2232 "cache", "format", "serial", NULL };
2234 if (check_params(buf, sizeof(buf), params, str) < 0) {
2235 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
2241 cyls = heads = secs = 0;
2244 translation = BIOS_ATA_TRANSLATION_AUTO;
2248 if (machine->use_scsi) {
2250 max_devs = MAX_SCSI_DEVS;
2251 pstrcpy(devname, sizeof(devname), "scsi");
2254 max_devs = MAX_IDE_DEVS;
2255 pstrcpy(devname, sizeof(devname), "ide");
2259 /* extract parameters */
2261 if (get_param_value(buf, sizeof(buf), "bus", str)) {
2262 bus_id = strtol(buf, NULL, 0);
2264 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2269 if (get_param_value(buf, sizeof(buf), "unit", str)) {
2270 unit_id = strtol(buf, NULL, 0);
2272 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2277 if (get_param_value(buf, sizeof(buf), "if", str)) {
2278 pstrcpy(devname, sizeof(devname), buf);
2279 if (!strcmp(buf, "ide")) {
2281 max_devs = MAX_IDE_DEVS;
2282 } else if (!strcmp(buf, "scsi")) {
2284 max_devs = MAX_SCSI_DEVS;
2285 } else if (!strcmp(buf, "floppy")) {
2288 } else if (!strcmp(buf, "pflash")) {
2291 } else if (!strcmp(buf, "mtd")) {
2294 } else if (!strcmp(buf, "sd")) {
2297 } else if (!strcmp(buf, "virtio")) {
2301 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2306 if (get_param_value(buf, sizeof(buf), "index", str)) {
2307 index = strtol(buf, NULL, 0);
2309 fprintf(stderr, "qemu: '%s' invalid index\n", str);
2314 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2315 cyls = strtol(buf, NULL, 0);
2318 if (get_param_value(buf, sizeof(buf), "heads", str)) {
2319 heads = strtol(buf, NULL, 0);
2322 if (get_param_value(buf, sizeof(buf), "secs", str)) {
2323 secs = strtol(buf, NULL, 0);
2326 if (cyls || heads || secs) {
2327 if (cyls < 1 || cyls > 16383) {
2328 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2331 if (heads < 1 || heads > 16) {
2332 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2335 if (secs < 1 || secs > 63) {
2336 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2341 if (get_param_value(buf, sizeof(buf), "trans", str)) {
2344 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2348 if (!strcmp(buf, "none"))
2349 translation = BIOS_ATA_TRANSLATION_NONE;
2350 else if (!strcmp(buf, "lba"))
2351 translation = BIOS_ATA_TRANSLATION_LBA;
2352 else if (!strcmp(buf, "auto"))
2353 translation = BIOS_ATA_TRANSLATION_AUTO;
2355 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2360 if (get_param_value(buf, sizeof(buf), "media", str)) {
2361 if (!strcmp(buf, "disk")) {
2363 } else if (!strcmp(buf, "cdrom")) {
2364 if (cyls || secs || heads) {
2366 "qemu: '%s' invalid physical CHS format\n", str);
2369 media = MEDIA_CDROM;
2371 fprintf(stderr, "qemu: '%s' invalid media\n", str);
2376 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2377 if (!strcmp(buf, "on"))
2379 else if (!strcmp(buf, "off"))
2382 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2387 if (get_param_value(buf, sizeof(buf), "cache", str)) {
2388 if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2390 else if (!strcmp(buf, "writethrough"))
2392 else if (!strcmp(buf, "writeback"))
2395 fprintf(stderr, "qemu: invalid cache option\n");
2400 if (get_param_value(buf, sizeof(buf), "format", str)) {
2401 if (strcmp(buf, "?") == 0) {
2402 fprintf(stderr, "qemu: Supported formats:");
2403 bdrv_iterate_format(bdrv_format_print, NULL);
2404 fprintf(stderr, "\n");
2407 drv = bdrv_find_format(buf);
2409 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2414 if (arg->file == NULL)
2415 get_param_value(file, sizeof(file), "file", str);
2417 pstrcpy(file, sizeof(file), arg->file);
2419 if (!get_param_value(serial, sizeof(serial), "serial", str))
2420 memset(serial, 0, sizeof(serial));
2422 /* compute bus and unit according index */
2425 if (bus_id != 0 || unit_id != -1) {
2427 "qemu: '%s' index cannot be used with bus and unit\n", str);
2435 unit_id = index % max_devs;
2436 bus_id = index / max_devs;
2440 /* if user doesn't specify a unit_id,
2441 * try to find the first free
2444 if (unit_id == -1) {
2446 while (drive_get_index(type, bus_id, unit_id) != -1) {
2448 if (max_devs && unit_id >= max_devs) {
2449 unit_id -= max_devs;
2457 if (max_devs && unit_id >= max_devs) {
2458 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2459 str, unit_id, max_devs - 1);
2464 * ignore multiple definitions
2467 if (drive_get_index(type, bus_id, unit_id) != -1)
2472 if (type == IF_IDE || type == IF_SCSI)
2473 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2475 snprintf(buf, sizeof(buf), "%s%i%s%i",
2476 devname, bus_id, mediastr, unit_id);
2478 snprintf(buf, sizeof(buf), "%s%s%i",
2479 devname, mediastr, unit_id);
2480 bdrv = bdrv_new(buf);
2481 drives_table[nb_drives].bdrv = bdrv;
2482 drives_table[nb_drives].type = type;
2483 drives_table[nb_drives].bus = bus_id;
2484 drives_table[nb_drives].unit = unit_id;
2485 strncpy(drives_table[nb_drives].serial, serial, sizeof(serial));
2494 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2495 bdrv_set_translation_hint(bdrv, translation);
2499 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2504 /* FIXME: This isn't really a floppy, but it's a reasonable
2507 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2518 bdrv_flags |= BDRV_O_SNAPSHOT;
2519 cache = 2; /* always use write-back with snapshot */
2521 if (cache == 0) /* no caching */
2522 bdrv_flags |= BDRV_O_NOCACHE;
2523 else if (cache == 2) /* write-back */
2524 bdrv_flags |= BDRV_O_CACHE_WB;
2525 else if (cache == 3) /* not specified */
2526 bdrv_flags |= BDRV_O_CACHE_DEF;
2527 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
2528 fprintf(stderr, "qemu: could not open disk image %s\n",
2535 /***********************************************************/
2538 static USBPort *used_usb_ports;
2539 static USBPort *free_usb_ports;
2541 /* ??? Maybe change this to register a hub to keep track of the topology. */
2542 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2543 usb_attachfn attach)
2545 port->opaque = opaque;
2546 port->index = index;
2547 port->attach = attach;
2548 port->next = free_usb_ports;
2549 free_usb_ports = port;
2552 int usb_device_add_dev(USBDevice *dev)
2556 /* Find a USB port to add the device to. */
2557 port = free_usb_ports;
2561 /* Create a new hub and chain it on. */
2562 free_usb_ports = NULL;
2563 port->next = used_usb_ports;
2564 used_usb_ports = port;
2566 hub = usb_hub_init(VM_USB_HUB_SIZE);
2567 usb_attach(port, hub);
2568 port = free_usb_ports;
2571 free_usb_ports = port->next;
2572 port->next = used_usb_ports;
2573 used_usb_ports = port;
2574 usb_attach(port, dev);
2578 static int usb_device_add(const char *devname)
2583 if (!free_usb_ports)
2586 if (strstart(devname, "host:", &p)) {
2587 dev = usb_host_device_open(p);
2588 } else if (!strcmp(devname, "mouse")) {
2589 dev = usb_mouse_init();
2590 } else if (!strcmp(devname, "tablet")) {
2591 dev = usb_tablet_init();
2592 } else if (!strcmp(devname, "keyboard")) {
2593 dev = usb_keyboard_init();
2594 } else if (strstart(devname, "disk:", &p)) {
2595 dev = usb_msd_init(p);
2596 } else if (!strcmp(devname, "wacom-tablet")) {
2597 dev = usb_wacom_init();
2598 } else if (strstart(devname, "serial:", &p)) {
2599 dev = usb_serial_init(p);
2600 #ifdef CONFIG_BRLAPI
2601 } else if (!strcmp(devname, "braille")) {
2602 dev = usb_baum_init();
2604 } else if (strstart(devname, "net:", &p)) {
2607 if (net_client_init("nic", p) < 0)
2609 nd_table[nic].model = "usb";
2610 dev = usb_net_init(&nd_table[nic]);
2611 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2612 dev = usb_bt_init(devname[2] ? hci_init(p) :
2613 bt_new_hci(qemu_find_bt_vlan(0)));
2620 return usb_device_add_dev(dev);
2623 int usb_device_del_addr(int bus_num, int addr)
2629 if (!used_usb_ports)
2635 lastp = &used_usb_ports;
2636 port = used_usb_ports;
2637 while (port && port->dev->addr != addr) {
2638 lastp = &port->next;
2646 *lastp = port->next;
2647 usb_attach(port, NULL);
2648 dev->handle_destroy(dev);
2649 port->next = free_usb_ports;
2650 free_usb_ports = port;
2654 static int usb_device_del(const char *devname)
2659 if (strstart(devname, "host:", &p))
2660 return usb_host_device_close(p);
2662 if (!used_usb_ports)
2665 p = strchr(devname, '.');
2668 bus_num = strtoul(devname, NULL, 0);
2669 addr = strtoul(p + 1, NULL, 0);
2671 return usb_device_del_addr(bus_num, addr);
2674 void do_usb_add(const char *devname)
2676 usb_device_add(devname);
2679 void do_usb_del(const char *devname)
2681 usb_device_del(devname);
2688 const char *speed_str;
2691 term_printf("USB support not enabled\n");
2695 for (port = used_usb_ports; port; port = port->next) {
2699 switch(dev->speed) {
2703 case USB_SPEED_FULL:
2706 case USB_SPEED_HIGH:
2713 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
2714 0, dev->addr, speed_str, dev->devname);
2718 /***********************************************************/
2719 /* PCMCIA/Cardbus */
2721 static struct pcmcia_socket_entry_s {
2722 struct pcmcia_socket_s *socket;
2723 struct pcmcia_socket_entry_s *next;
2724 } *pcmcia_sockets = 0;
2726 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
2728 struct pcmcia_socket_entry_s *entry;
2730 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2731 entry->socket = socket;
2732 entry->next = pcmcia_sockets;
2733 pcmcia_sockets = entry;
2736 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
2738 struct pcmcia_socket_entry_s *entry, **ptr;
2740 ptr = &pcmcia_sockets;
2741 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2742 if (entry->socket == socket) {
2748 void pcmcia_info(void)
2750 struct pcmcia_socket_entry_s *iter;
2751 if (!pcmcia_sockets)
2752 term_printf("No PCMCIA sockets\n");
2754 for (iter = pcmcia_sockets; iter; iter = iter->next)
2755 term_printf("%s: %s\n", iter->socket->slot_string,
2756 iter->socket->attached ? iter->socket->card_string :
2760 /***********************************************************/
2763 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
2767 static void dumb_resize(DisplayState *ds, int w, int h)
2771 static void dumb_display_init(DisplayState *ds)
2776 ds->dpy_update = dumb_update;
2777 ds->dpy_resize = dumb_resize;
2778 ds->dpy_refresh = NULL;
2779 ds->gui_timer_interval = 0;
2783 /***********************************************************/
2786 #define MAX_IO_HANDLERS 64
2788 typedef struct IOHandlerRecord {
2790 IOCanRWHandler *fd_read_poll;
2792 IOHandler *fd_write;
2795 /* temporary data */
2797 struct IOHandlerRecord *next;
2800 static IOHandlerRecord *first_io_handler;
2802 /* XXX: fd_read_poll should be suppressed, but an API change is
2803 necessary in the character devices to suppress fd_can_read(). */
2804 int qemu_set_fd_handler2(int fd,
2805 IOCanRWHandler *fd_read_poll,
2807 IOHandler *fd_write,
2810 IOHandlerRecord **pioh, *ioh;
2812 if (!fd_read && !fd_write) {
2813 pioh = &first_io_handler;
2818 if (ioh->fd == fd) {
2825 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2829 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2832 ioh->next = first_io_handler;
2833 first_io_handler = ioh;
2836 ioh->fd_read_poll = fd_read_poll;
2837 ioh->fd_read = fd_read;
2838 ioh->fd_write = fd_write;
2839 ioh->opaque = opaque;
2845 int qemu_set_fd_handler(int fd,
2847 IOHandler *fd_write,
2850 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2854 /***********************************************************/
2855 /* Polling handling */
2857 typedef struct PollingEntry {
2860 struct PollingEntry *next;
2863 static PollingEntry *first_polling_entry;
2865 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2867 PollingEntry **ppe, *pe;
2868 pe = qemu_mallocz(sizeof(PollingEntry));
2872 pe->opaque = opaque;
2873 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2878 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2880 PollingEntry **ppe, *pe;
2881 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2883 if (pe->func == func && pe->opaque == opaque) {
2891 /***********************************************************/
2892 /* Wait objects support */
2893 typedef struct WaitObjects {
2895 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
2896 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
2897 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
2900 static WaitObjects wait_objects = {0};
2902 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2904 WaitObjects *w = &wait_objects;
2906 if (w->num >= MAXIMUM_WAIT_OBJECTS)
2908 w->events[w->num] = handle;
2909 w->func[w->num] = func;
2910 w->opaque[w->num] = opaque;
2915 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2918 WaitObjects *w = &wait_objects;
2921 for (i = 0; i < w->num; i++) {
2922 if (w->events[i] == handle)
2925 w->events[i] = w->events[i + 1];
2926 w->func[i] = w->func[i + 1];
2927 w->opaque[i] = w->opaque[i + 1];
2935 /***********************************************************/
2936 /* ram save/restore */
2938 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
2942 v = qemu_get_byte(f);
2945 if (qemu_get_buffer(f, buf, len) != len)
2949 v = qemu_get_byte(f);
2950 memset(buf, v, len);
2956 if (qemu_file_has_error(f))
2962 static int ram_load_v1(QEMUFile *f, void *opaque)
2967 if (qemu_get_be32(f) != phys_ram_size)
2969 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
2970 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2977 #define BDRV_HASH_BLOCK_SIZE 1024
2978 #define IOBUF_SIZE 4096
2979 #define RAM_CBLOCK_MAGIC 0xfabe
2981 typedef struct RamDecompressState {
2984 uint8_t buf[IOBUF_SIZE];
2985 } RamDecompressState;
2987 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
2990 memset(s, 0, sizeof(*s));
2992 ret = inflateInit(&s->zstream);
2998 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3002 s->zstream.avail_out = len;
3003 s->zstream.next_out = buf;
3004 while (s->zstream.avail_out > 0) {
3005 if (s->zstream.avail_in == 0) {
3006 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3008 clen = qemu_get_be16(s->f);
3009 if (clen > IOBUF_SIZE)
3011 qemu_get_buffer(s->f, s->buf, clen);
3012 s->zstream.avail_in = clen;
3013 s->zstream.next_in = s->buf;
3015 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3016 if (ret != Z_OK && ret != Z_STREAM_END) {
3023 static void ram_decompress_close(RamDecompressState *s)
3025 inflateEnd(&s->zstream);
3028 #define RAM_SAVE_FLAG_FULL 0x01
3029 #define RAM_SAVE_FLAG_COMPRESS 0x02
3030 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
3031 #define RAM_SAVE_FLAG_PAGE 0x08
3032 #define RAM_SAVE_FLAG_EOS 0x10
3034 static int is_dup_page(uint8_t *page, uint8_t ch)
3036 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3037 uint32_t *array = (uint32_t *)page;
3040 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3041 if (array[i] != val)
3048 static int ram_save_block(QEMUFile *f)
3050 static ram_addr_t current_addr = 0;
3051 ram_addr_t saved_addr = current_addr;
3052 ram_addr_t addr = 0;
3055 while (addr < phys_ram_size) {
3056 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3059 cpu_physical_memory_reset_dirty(current_addr,
3060 current_addr + TARGET_PAGE_SIZE,
3061 MIGRATION_DIRTY_FLAG);
3063 ch = *(phys_ram_base + current_addr);
3065 if (is_dup_page(phys_ram_base + current_addr, ch)) {
3066 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3067 qemu_put_byte(f, ch);
3069 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3070 qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
3076 addr += TARGET_PAGE_SIZE;
3077 current_addr = (saved_addr + addr) % phys_ram_size;
3083 static ram_addr_t ram_save_threshold = 10;
3085 static ram_addr_t ram_save_remaining(void)
3088 ram_addr_t count = 0;
3090 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3091 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3098 static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3103 /* Make sure all dirty bits are set */
3104 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3105 if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3106 cpu_physical_memory_set_dirty(addr);
3109 /* Enable dirty memory tracking */
3110 cpu_physical_memory_set_dirty_tracking(1);
3112 qemu_put_be64(f, phys_ram_size | RAM_SAVE_FLAG_MEM_SIZE);
3115 while (!qemu_file_rate_limit(f)) {
3118 ret = ram_save_block(f);
3119 if (ret == 0) /* no more blocks */
3123 /* try transferring iterative blocks of memory */
3126 cpu_physical_memory_set_dirty_tracking(0);
3128 /* flush all remaining blocks regardless of rate limiting */
3129 while (ram_save_block(f) != 0);
3132 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3134 return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3137 static int ram_load_dead(QEMUFile *f, void *opaque)
3139 RamDecompressState s1, *s = &s1;
3143 if (ram_decompress_open(s, f) < 0)
3145 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
3146 if (ram_decompress_buf(s, buf, 1) < 0) {
3147 fprintf(stderr, "Error while reading ram block header\n");
3151 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
3152 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3157 printf("Error block header\n");
3161 ram_decompress_close(s);
3166 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3171 if (version_id == 1)
3172 return ram_load_v1(f, opaque);
3174 if (version_id == 2) {
3175 if (qemu_get_be32(f) != phys_ram_size)
3177 return ram_load_dead(f, opaque);
3180 if (version_id != 3)
3184 addr = qemu_get_be64(f);
3186 flags = addr & ~TARGET_PAGE_MASK;
3187 addr &= TARGET_PAGE_MASK;
3189 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3190 if (addr != phys_ram_size)
3194 if (flags & RAM_SAVE_FLAG_FULL) {
3195 if (ram_load_dead(f, opaque) < 0)
3199 if (flags & RAM_SAVE_FLAG_COMPRESS) {
3200 uint8_t ch = qemu_get_byte(f);
3201 memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3202 } else if (flags & RAM_SAVE_FLAG_PAGE)
3203 qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3204 } while (!(flags & RAM_SAVE_FLAG_EOS));
3209 void qemu_service_io(void)
3211 CPUState *env = cpu_single_env;
3213 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3215 if (env->kqemu_enabled) {
3216 kqemu_cpu_interrupt(env);
3222 /***********************************************************/
3223 /* bottom halves (can be seen as timers which expire ASAP) */
3234 static QEMUBH *first_bh = NULL;
3236 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3239 bh = qemu_mallocz(sizeof(QEMUBH));
3243 bh->opaque = opaque;
3244 bh->next = first_bh;
3249 int qemu_bh_poll(void)
3255 for (bh = first_bh; bh; bh = bh->next) {
3256 if (!bh->deleted && bh->scheduled) {
3265 /* remove deleted bhs */
3279 void qemu_bh_schedule_idle(QEMUBH *bh)
3287 void qemu_bh_schedule(QEMUBH *bh)
3289 CPUState *env = cpu_single_env;
3294 /* stop the currently executing CPU to execute the BH ASAP */
3296 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3300 void qemu_bh_cancel(QEMUBH *bh)
3305 void qemu_bh_delete(QEMUBH *bh)
3311 static void qemu_bh_update_timeout(int *timeout)
3315 for (bh = first_bh; bh; bh = bh->next) {
3316 if (!bh->deleted && bh->scheduled) {
3318 /* idle bottom halves will be polled at least
3320 *timeout = MIN(10, *timeout);
3322 /* non-idle bottom halves will be executed
3331 /***********************************************************/
3332 /* machine registration */
3334 static QEMUMachine *first_machine = NULL;
3336 int qemu_register_machine(QEMUMachine *m)
3339 pm = &first_machine;
3347 static QEMUMachine *find_machine(const char *name)
3351 for(m = first_machine; m != NULL; m = m->next) {
3352 if (!strcmp(m->name, name))
3358 /***********************************************************/
3359 /* main execution loop */
3361 static void gui_update(void *opaque)
3363 DisplayState *ds = opaque;
3364 ds->dpy_refresh(ds);
3365 qemu_mod_timer(ds->gui_timer,
3366 (ds->gui_timer_interval ?
3367 ds->gui_timer_interval :
3368 GUI_REFRESH_INTERVAL)
3369 + qemu_get_clock(rt_clock));
3372 struct vm_change_state_entry {
3373 VMChangeStateHandler *cb;
3375 LIST_ENTRY (vm_change_state_entry) entries;
3378 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3380 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3383 VMChangeStateEntry *e;
3385 e = qemu_mallocz(sizeof (*e));
3391 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3395 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3397 LIST_REMOVE (e, entries);
3401 static void vm_state_notify(int running)
3403 VMChangeStateEntry *e;
3405 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3406 e->cb(e->opaque, running);
3410 /* XXX: support several handlers */
3411 static VMStopHandler *vm_stop_cb;
3412 static void *vm_stop_opaque;
3414 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
3417 vm_stop_opaque = opaque;
3421 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
3432 qemu_rearm_alarm_timer(alarm_timer);
3436 void vm_stop(int reason)
3439 cpu_disable_ticks();
3443 vm_stop_cb(vm_stop_opaque, reason);
3450 /* reset/shutdown handler */
3452 typedef struct QEMUResetEntry {
3453 QEMUResetHandler *func;
3455 struct QEMUResetEntry *next;
3458 static QEMUResetEntry *first_reset_entry;
3459 static int reset_requested;
3460 static int shutdown_requested;
3461 static int powerdown_requested;
3463 int qemu_shutdown_requested(void)
3465 int r = shutdown_requested;
3466 shutdown_requested = 0;
3470 int qemu_reset_requested(void)
3472 int r = reset_requested;
3473 reset_requested = 0;
3477 int qemu_powerdown_requested(void)
3479 int r = powerdown_requested;
3480 powerdown_requested = 0;
3484 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3486 QEMUResetEntry **pre, *re;
3488 pre = &first_reset_entry;
3489 while (*pre != NULL)
3490 pre = &(*pre)->next;
3491 re = qemu_mallocz(sizeof(QEMUResetEntry));
3493 re->opaque = opaque;
3498 void qemu_system_reset(void)
3502 /* reset all devices */
3503 for(re = first_reset_entry; re != NULL; re = re->next) {
3504 re->func(re->opaque);
3508 void qemu_system_reset_request(void)
3511 shutdown_requested = 1;
3513 reset_requested = 1;
3516 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3519 void qemu_system_shutdown_request(void)
3521 shutdown_requested = 1;
3523 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3526 void qemu_system_powerdown_request(void)
3528 powerdown_requested = 1;
3530 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
3534 static void host_main_loop_wait(int *timeout)
3540 /* XXX: need to suppress polling by better using win32 events */
3542 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3543 ret |= pe->func(pe->opaque);
3547 WaitObjects *w = &wait_objects;
3549 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3550 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3551 if (w->func[ret - WAIT_OBJECT_0])
3552 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3554 /* Check for additional signaled events */
3555 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3557 /* Check if event is signaled */
3558 ret2 = WaitForSingleObject(w->events[i], 0);
3559 if(ret2 == WAIT_OBJECT_0) {
3561 w->func[i](w->opaque[i]);
3562 } else if (ret2 == WAIT_TIMEOUT) {
3564 err = GetLastError();
3565 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3568 } else if (ret == WAIT_TIMEOUT) {
3570 err = GetLastError();
3571 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3578 static void host_main_loop_wait(int *timeout)
3583 void main_loop_wait(int timeout)
3585 IOHandlerRecord *ioh;
3586 fd_set rfds, wfds, xfds;
3590 qemu_bh_update_timeout(&timeout);
3592 host_main_loop_wait(&timeout);
3594 /* poll any events */
3595 /* XXX: separate device handlers from system ones */
3600 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3604 (!ioh->fd_read_poll ||
3605 ioh->fd_read_poll(ioh->opaque) != 0)) {
3606 FD_SET(ioh->fd, &rfds);
3610 if (ioh->fd_write) {
3611 FD_SET(ioh->fd, &wfds);
3617 tv.tv_sec = timeout / 1000;
3618 tv.tv_usec = (timeout % 1000) * 1000;
3620 #if defined(CONFIG_SLIRP)
3621 if (slirp_is_inited()) {
3622 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3625 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3627 IOHandlerRecord **pioh;
3629 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3630 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3631 ioh->fd_read(ioh->opaque);
3633 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3634 ioh->fd_write(ioh->opaque);
3638 /* remove deleted IO handlers */
3639 pioh = &first_io_handler;
3649 #if defined(CONFIG_SLIRP)
3650 if (slirp_is_inited()) {
3656 slirp_select_poll(&rfds, &wfds, &xfds);
3660 /* vm time timers */
3661 if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3662 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3663 qemu_get_clock(vm_clock));
3665 /* real time timers */
3666 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3667 qemu_get_clock(rt_clock));
3669 /* Check bottom-halves last in case any of the earlier events triggered
3675 static int main_loop(void)
3678 #ifdef CONFIG_PROFILER
3683 cur_cpu = first_cpu;
3684 next_cpu = cur_cpu->next_cpu ?: first_cpu;
3691 #ifdef CONFIG_PROFILER
3692 ti = profile_getclock();
3697 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3698 env->icount_decr.u16.low = 0;
3699 env->icount_extra = 0;
3700 count = qemu_next_deadline();
3701 count = (count + (1 << icount_time_shift) - 1)
3702 >> icount_time_shift;
3703 qemu_icount += count;
3704 decr = (count > 0xffff) ? 0xffff : count;
3706 env->icount_decr.u16.low = decr;
3707 env->icount_extra = count;
3709 ret = cpu_exec(env);
3710 #ifdef CONFIG_PROFILER
3711 qemu_time += profile_getclock() - ti;
3714 /* Fold pending instructions back into the
3715 instruction counter, and clear the interrupt flag. */
3716 qemu_icount -= (env->icount_decr.u16.low
3717 + env->icount_extra);
3718 env->icount_decr.u32 = 0;
3719 env->icount_extra = 0;
3721 next_cpu = env->next_cpu ?: first_cpu;
3722 if (event_pending && likely(ret != EXCP_DEBUG)) {
3723 ret = EXCP_INTERRUPT;
3727 if (ret == EXCP_HLT) {
3728 /* Give the next CPU a chance to run. */
3732 if (ret != EXCP_HALTED)
3734 /* all CPUs are halted ? */
3740 if (shutdown_requested) {
3741 ret = EXCP_INTERRUPT;
3749 if (reset_requested) {
3750 reset_requested = 0;
3751 qemu_system_reset();
3752 ret = EXCP_INTERRUPT;
3754 if (powerdown_requested) {
3755 powerdown_requested = 0;
3756 qemu_system_powerdown();
3757 ret = EXCP_INTERRUPT;
3759 if (unlikely(ret == EXCP_DEBUG)) {
3760 gdb_set_stop_cpu(cur_cpu);
3761 vm_stop(EXCP_DEBUG);
3763 /* If all cpus are halted then wait until the next IRQ */
3764 /* XXX: use timeout computed from timers */
3765 if (ret == EXCP_HALTED) {
3769 /* Advance virtual time to the next event. */
3770 if (use_icount == 1) {
3771 /* When not using an adaptive execution frequency
3772 we tend to get badly out of sync with real time,
3773 so just delay for a reasonable amount of time. */
3776 delta = cpu_get_icount() - cpu_get_clock();
3779 /* If virtual time is ahead of real time then just
3781 timeout = (delta / 1000000) + 1;
3783 /* Wait for either IO to occur or the next
3785 add = qemu_next_deadline();
3786 /* We advance the timer before checking for IO.
3787 Limit the amount we advance so that early IO
3788 activity won't get the guest too far ahead. */
3792 add = (add + (1 << icount_time_shift) - 1)
3793 >> icount_time_shift;
3795 timeout = delta / 1000000;
3806 if (shutdown_requested) {
3807 ret = EXCP_INTERRUPT;
3812 #ifdef CONFIG_PROFILER
3813 ti = profile_getclock();
3815 main_loop_wait(timeout);
3816 #ifdef CONFIG_PROFILER
3817 dev_time += profile_getclock() - ti;
3820 cpu_disable_ticks();
3824 static void help(int exitcode)
3826 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
3827 "usage: %s [options] [disk_image]\n"
3829 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
3831 "Standard options:\n"
3832 "-M machine select emulated machine (-M ? for list)\n"
3833 "-cpu cpu select CPU (-cpu ? for list)\n"
3834 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
3835 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
3836 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
3837 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
3838 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
3839 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
3840 " [,cache=writethrough|writeback|none][,format=f][,serial=s]\n"
3841 " use 'file' as a drive image\n"
3842 "-mtdblock file use 'file' as on-board Flash memory image\n"
3843 "-sd file use 'file' as SecureDigital card image\n"
3844 "-pflash file use 'file' as a parallel flash image\n"
3845 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
3846 "-snapshot write to temporary files instead of disk image files\n"
3848 "-no-frame open SDL window without a frame and window decorations\n"
3849 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
3850 "-no-quit disable SDL window close capability\n"
3853 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
3855 "-m megs set virtual RAM size to megs MB [default=%d]\n"
3856 "-smp n set the number of CPUs to 'n' [default=1]\n"
3857 "-nographic disable graphical output and redirect serial I/Os to console\n"
3858 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
3860 "-k language use keyboard layout (for example \"fr\" for French)\n"
3863 "-audio-help print list of audio drivers and their options\n"
3864 "-soundhw c1,... enable audio support\n"
3865 " and only specified sound cards (comma separated list)\n"
3866 " use -soundhw ? to get the list of supported cards\n"
3867 " use -soundhw all to enable all of them\n"
3869 "-vga [std|cirrus|vmware|none]\n"
3870 " select video card type\n"
3871 "-localtime set the real time clock to local time [default=utc]\n"
3872 "-full-screen start in full screen\n"
3874 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
3875 "-rtc-td-hack use it to fix time drift in Windows ACPI HAL\n"
3877 "-usb enable the USB driver (will be the default soon)\n"
3878 "-usbdevice name add the host or guest USB device 'name'\n"
3879 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
3880 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
3882 "-name string set the name of the guest\n"
3883 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
3885 "Network options:\n"
3886 "-net nic[,vlan=n][,macaddr=addr][,model=type][,name=str]\n"
3887 " create a new Network Interface Card and connect it to VLAN 'n'\n"
3889 "-net user[,vlan=n][,name=str][,hostname=host]\n"
3890 " connect the user mode network stack to VLAN 'n' and send\n"
3891 " hostname 'host' to DHCP clients\n"
3894 "-net tap[,vlan=n][,name=str],ifname=name\n"
3895 " connect the host TAP network interface to VLAN 'n'\n"
3897 "-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
3898 " connect the host TAP network interface to VLAN 'n' and use the\n"
3899 " network scripts 'file' (default=%s)\n"
3900 " and 'dfile' (default=%s);\n"
3901 " use '[down]script=no' to disable script execution;\n"
3902 " use 'fd=h' to connect to an already opened TAP interface\n"
3904 "-net socket[,vlan=n][,name=str][,fd=h][,listen=[host]:port][,connect=host:port]\n"
3905 " connect the vlan 'n' to another VLAN using a socket connection\n"
3906 "-net socket[,vlan=n][,name=str][,fd=h][,mcast=maddr:port]\n"
3907 " connect the vlan 'n' to multicast maddr and port\n"
3909 "-net vde[,vlan=n][,name=str][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
3910 " connect the vlan 'n' to port 'n' of a vde switch running\n"
3911 " on host and listening for incoming connections on 'socketpath'.\n"
3912 " Use group 'groupname' and mode 'octalmode' to change default\n"
3913 " ownership and permissions for communication port.\n"
3915 "-net none use it alone to have zero network devices; if no -net option\n"
3916 " is provided, the default is '-net nic -net user'\n"
3918 "-bt hci,null Dumb bluetooth HCI - doesn't respond to commands\n"
3919 "-bt hci,host[:id]\n"
3920 " Use host's HCI with the given name\n"
3921 "-bt hci[,vlan=n]\n"
3922 " Emulate a standard HCI in virtual scatternet 'n'\n"
3923 "-bt vhci[,vlan=n]\n"
3924 " Add host computer to virtual scatternet 'n' using VHCI\n"
3925 "-bt device:dev[,vlan=n]\n"
3926 " Emulate a bluetooth device 'dev' in scatternet 'n'\n"
3929 "-tftp dir allow tftp access to files in dir [-net user]\n"
3930 "-bootp file advertise file in BOOTP replies\n"
3932 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
3934 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
3935 " redirect TCP or UDP connections from host to guest [-net user]\n"
3938 "Linux boot specific:\n"
3939 "-kernel bzImage use 'bzImage' as kernel image\n"
3940 "-append cmdline use 'cmdline' as kernel command line\n"
3941 "-initrd file use 'file' as initial ram disk\n"
3943 "Debug/Expert options:\n"
3944 "-monitor dev redirect the monitor to char device 'dev'\n"
3945 "-serial dev redirect the serial port to char device 'dev'\n"
3946 "-parallel dev redirect the parallel port to char device 'dev'\n"
3947 "-pidfile file Write PID to 'file'\n"
3948 "-S freeze CPU at startup (use 'c' to start execution)\n"
3949 "-s wait gdb connection to port\n"
3950 "-p port set gdb connection port [default=%s]\n"
3951 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
3952 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
3953 " translation (t=none or lba) (usually qemu can guess them)\n"
3954 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
3956 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
3957 "-no-kqemu disable KQEMU kernel module usage\n"
3960 "-enable-kvm enable KVM full virtualization support\n"
3963 "-no-acpi disable ACPI\n"
3964 "-no-hpet disable HPET\n"
3966 #ifdef CONFIG_CURSES
3967 "-curses use a curses/ncurses interface instead of SDL\n"
3969 "-no-reboot exit instead of rebooting\n"
3970 "-no-shutdown stop before shutdown\n"
3971 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
3972 "-vnc display start a VNC server on display\n"
3974 "-daemonize daemonize QEMU after initializing\n"
3976 "-option-rom rom load a file, rom, into the option ROM space\n"
3978 "-prom-env variable=value set OpenBIOS nvram variables\n"
3980 "-clock force the use of the given methods for timer alarm.\n"
3981 " To see what timers are available use -clock ?\n"
3982 "-startdate select initial date of the clock\n"
3983 "-icount [N|auto]\n"
3984 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
3986 "During emulation, the following keys are useful:\n"
3987 "ctrl-alt-f toggle full screen\n"
3988 "ctrl-alt-n switch to virtual console 'n'\n"
3989 "ctrl-alt toggle mouse and keyboard grab\n"
3991 "When using -nographic, press 'ctrl-a h' to get some help.\n"
3996 DEFAULT_NETWORK_SCRIPT,
3997 DEFAULT_NETWORK_DOWN_SCRIPT,
3999 DEFAULT_GDBSTUB_PORT,
4004 #define HAS_ARG 0x0001
4019 QEMU_OPTION_mtdblock,
4023 QEMU_OPTION_snapshot,
4025 QEMU_OPTION_no_fd_bootchk,
4028 QEMU_OPTION_nographic,
4029 QEMU_OPTION_portrait,
4031 QEMU_OPTION_audio_help,
4032 QEMU_OPTION_soundhw,
4054 QEMU_OPTION_localtime,
4058 QEMU_OPTION_monitor,
4060 QEMU_OPTION_virtiocon,
4061 QEMU_OPTION_parallel,
4063 QEMU_OPTION_full_screen,
4064 QEMU_OPTION_no_frame,
4065 QEMU_OPTION_alt_grab,
4066 QEMU_OPTION_no_quit,
4067 QEMU_OPTION_pidfile,
4068 QEMU_OPTION_no_kqemu,
4069 QEMU_OPTION_kernel_kqemu,
4070 QEMU_OPTION_enable_kvm,
4071 QEMU_OPTION_win2k_hack,
4072 QEMU_OPTION_rtc_td_hack,
4074 QEMU_OPTION_usbdevice,
4077 QEMU_OPTION_no_acpi,
4078 QEMU_OPTION_no_hpet,
4080 QEMU_OPTION_no_reboot,
4081 QEMU_OPTION_no_shutdown,
4082 QEMU_OPTION_show_cursor,
4083 QEMU_OPTION_daemonize,
4084 QEMU_OPTION_option_rom,
4085 QEMU_OPTION_semihosting,
4087 QEMU_OPTION_prom_env,
4088 QEMU_OPTION_old_param,
4090 QEMU_OPTION_startdate,
4091 QEMU_OPTION_tb_size,
4094 QEMU_OPTION_incoming,
4097 typedef struct QEMUOption {
4103 static const QEMUOption qemu_options[] = {
4104 { "h", 0, QEMU_OPTION_h },
4105 { "help", 0, QEMU_OPTION_h },
4107 { "M", HAS_ARG, QEMU_OPTION_M },
4108 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
4109 { "fda", HAS_ARG, QEMU_OPTION_fda },
4110 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4111 { "hda", HAS_ARG, QEMU_OPTION_hda },
4112 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4113 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4114 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
4115 { "drive", HAS_ARG, QEMU_OPTION_drive },
4116 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
4117 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
4118 { "sd", HAS_ARG, QEMU_OPTION_sd },
4119 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
4120 { "boot", HAS_ARG, QEMU_OPTION_boot },
4121 { "snapshot", 0, QEMU_OPTION_snapshot },
4123 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
4125 { "m", HAS_ARG, QEMU_OPTION_m },
4126 { "nographic", 0, QEMU_OPTION_nographic },
4127 { "portrait", 0, QEMU_OPTION_portrait },
4128 { "k", HAS_ARG, QEMU_OPTION_k },
4130 { "audio-help", 0, QEMU_OPTION_audio_help },
4131 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4134 { "net", HAS_ARG, QEMU_OPTION_net},
4136 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
4137 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
4139 { "smb", HAS_ARG, QEMU_OPTION_smb },
4141 { "redir", HAS_ARG, QEMU_OPTION_redir },
4143 { "bt", HAS_ARG, QEMU_OPTION_bt },
4145 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4146 { "append", HAS_ARG, QEMU_OPTION_append },
4147 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4149 { "S", 0, QEMU_OPTION_S },
4150 { "s", 0, QEMU_OPTION_s },
4151 { "p", HAS_ARG, QEMU_OPTION_p },
4152 { "d", HAS_ARG, QEMU_OPTION_d },
4153 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4154 { "L", HAS_ARG, QEMU_OPTION_L },
4155 { "bios", HAS_ARG, QEMU_OPTION_bios },
4157 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
4158 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
4161 { "enable-kvm", 0, QEMU_OPTION_enable_kvm },
4163 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4164 { "g", 1, QEMU_OPTION_g },
4166 { "localtime", 0, QEMU_OPTION_localtime },
4167 { "vga", HAS_ARG, QEMU_OPTION_vga },
4168 { "echr", HAS_ARG, QEMU_OPTION_echr },
4169 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
4170 { "serial", HAS_ARG, QEMU_OPTION_serial },
4171 { "virtioconsole", HAS_ARG, QEMU_OPTION_virtiocon },
4172 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
4173 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4174 { "full-screen", 0, QEMU_OPTION_full_screen },
4176 { "no-frame", 0, QEMU_OPTION_no_frame },
4177 { "alt-grab", 0, QEMU_OPTION_alt_grab },
4178 { "no-quit", 0, QEMU_OPTION_no_quit },
4180 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
4181 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4182 { "rtc-td-hack", 0, QEMU_OPTION_rtc_td_hack },
4183 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4184 { "smp", HAS_ARG, QEMU_OPTION_smp },
4185 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4186 #ifdef CONFIG_CURSES
4187 { "curses", 0, QEMU_OPTION_curses },
4189 { "uuid", HAS_ARG, QEMU_OPTION_uuid },
4191 /* temporary options */
4192 { "usb", 0, QEMU_OPTION_usb },
4193 { "no-acpi", 0, QEMU_OPTION_no_acpi },
4194 { "no-hpet", 0, QEMU_OPTION_no_hpet },
4195 { "no-reboot", 0, QEMU_OPTION_no_reboot },
4196 { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
4197 { "show-cursor", 0, QEMU_OPTION_show_cursor },
4198 { "daemonize", 0, QEMU_OPTION_daemonize },
4199 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
4200 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4201 { "semihosting", 0, QEMU_OPTION_semihosting },
4203 { "name", HAS_ARG, QEMU_OPTION_name },
4204 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4205 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
4207 #if defined(TARGET_ARM)
4208 { "old-param", 0, QEMU_OPTION_old_param },
4210 { "clock", HAS_ARG, QEMU_OPTION_clock },
4211 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
4212 { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
4213 { "icount", HAS_ARG, QEMU_OPTION_icount },
4214 { "incoming", HAS_ARG, QEMU_OPTION_incoming },
4218 /* password input */
4220 int qemu_key_check(BlockDriverState *bs, const char *name)
4225 if (!bdrv_is_encrypted(bs))
4228 term_printf("%s is encrypted.\n", name);
4229 for(i = 0; i < 3; i++) {
4230 monitor_readline("Password: ", 1, password, sizeof(password));
4231 if (bdrv_set_key(bs, password) == 0)
4233 term_printf("invalid password\n");
4238 static BlockDriverState *get_bdrv(int index)
4240 if (index > nb_drives)
4242 return drives_table[index].bdrv;
4245 static void read_passwords(void)
4247 BlockDriverState *bs;
4250 for(i = 0; i < 6; i++) {
4253 qemu_key_check(bs, bdrv_get_device_name(bs));
4258 struct soundhw soundhw[] = {
4259 #ifdef HAS_AUDIO_CHOICE
4260 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4266 { .init_isa = pcspk_audio_init }
4273 "Creative Sound Blaster 16",
4276 { .init_isa = SB16_init }
4280 #ifdef CONFIG_CS4231A
4286 { .init_isa = cs4231a_init }
4294 "Yamaha YMF262 (OPL3)",
4296 "Yamaha YM3812 (OPL2)",
4300 { .init_isa = Adlib_init }
4307 "Gravis Ultrasound GF1",
4310 { .init_isa = GUS_init }
4317 "Intel 82801AA AC97 Audio",
4320 { .init_pci = ac97_init }
4324 #ifdef CONFIG_ES1370
4327 "ENSONIQ AudioPCI ES1370",
4330 { .init_pci = es1370_init }
4334 #endif /* HAS_AUDIO_CHOICE */
4336 { NULL, NULL, 0, 0, { NULL } }
4339 static void select_soundhw (const char *optarg)
4343 if (*optarg == '?') {
4346 printf ("Valid sound card names (comma separated):\n");
4347 for (c = soundhw; c->name; ++c) {
4348 printf ("%-11s %s\n", c->name, c->descr);
4350 printf ("\n-soundhw all will enable all of the above\n");
4351 exit (*optarg != '?');
4359 if (!strcmp (optarg, "all")) {
4360 for (c = soundhw; c->name; ++c) {
4368 e = strchr (p, ',');
4369 l = !e ? strlen (p) : (size_t) (e - p);
4371 for (c = soundhw; c->name; ++c) {
4372 if (!strncmp (c->name, p, l)) {
4381 "Unknown sound card name (too big to show)\n");
4384 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4389 p += l + (e != NULL);
4393 goto show_valid_cards;
4398 static void select_vgahw (const char *p)
4402 if (strstart(p, "std", &opts)) {
4403 std_vga_enabled = 1;
4404 cirrus_vga_enabled = 0;
4406 } else if (strstart(p, "cirrus", &opts)) {
4407 cirrus_vga_enabled = 1;
4408 std_vga_enabled = 0;
4410 } else if (strstart(p, "vmware", &opts)) {
4411 cirrus_vga_enabled = 0;
4412 std_vga_enabled = 0;
4414 } else if (strstart(p, "none", &opts)) {
4415 cirrus_vga_enabled = 0;
4416 std_vga_enabled = 0;
4420 fprintf(stderr, "Unknown vga type: %s\n", p);
4424 const char *nextopt;
4426 if (strstart(opts, ",retrace=", &nextopt)) {
4428 if (strstart(opts, "dumb", &nextopt))
4429 vga_retrace_method = VGA_RETRACE_DUMB;
4430 else if (strstart(opts, "precise", &nextopt))
4431 vga_retrace_method = VGA_RETRACE_PRECISE;
4432 else goto invalid_vga;
4433 } else goto invalid_vga;
4439 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4441 exit(STATUS_CONTROL_C_EXIT);
4446 static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4450 if(strlen(str) != 36)
4453 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4454 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4455 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4463 #define MAX_NET_CLIENTS 32
4467 static void termsig_handler(int signal)
4469 qemu_system_shutdown_request();
4472 static void termsig_setup(void)
4474 struct sigaction act;
4476 memset(&act, 0, sizeof(act));
4477 act.sa_handler = termsig_handler;
4478 sigaction(SIGINT, &act, NULL);
4479 sigaction(SIGHUP, &act, NULL);
4480 sigaction(SIGTERM, &act, NULL);
4485 int main(int argc, char **argv, char **envp)
4487 #ifdef CONFIG_GDBSTUB
4489 const char *gdbstub_port;
4491 uint32_t boot_devices_bitmap = 0;
4493 int snapshot, linux_boot, net_boot;
4494 const char *initrd_filename;
4495 const char *kernel_filename, *kernel_cmdline;
4496 const char *boot_devices = "";
4497 DisplayState *ds = &display_state;
4498 int cyls, heads, secs, translation;
4499 const char *net_clients[MAX_NET_CLIENTS];
4501 const char *bt_opts[MAX_BT_CMDLINE];
4505 const char *r, *optarg;
4506 CharDriverState *monitor_hd;
4507 const char *monitor_device;
4508 const char *serial_devices[MAX_SERIAL_PORTS];
4509 int serial_device_index;
4510 const char *parallel_devices[MAX_PARALLEL_PORTS];
4511 int parallel_device_index;
4512 const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4513 int virtio_console_index;
4514 const char *loadvm = NULL;
4515 QEMUMachine *machine;
4516 const char *cpu_model;
4517 const char *usb_devices[MAX_USB_CMDLINE];
4518 int usb_devices_index;
4521 const char *pid_file = NULL;
4523 const char *incoming = NULL;
4525 qemu_cache_utils_init(envp);
4527 LIST_INIT (&vm_change_state_head);
4530 struct sigaction act;
4531 sigfillset(&act.sa_mask);
4533 act.sa_handler = SIG_IGN;
4534 sigaction(SIGPIPE, &act, NULL);
4537 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4538 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4539 QEMU to run on a single CPU */
4544 h = GetCurrentProcess();
4545 if (GetProcessAffinityMask(h, &mask, &smask)) {
4546 for(i = 0; i < 32; i++) {
4547 if (mask & (1 << i))
4552 SetProcessAffinityMask(h, mask);
4558 register_machines();
4559 machine = first_machine;
4561 initrd_filename = NULL;
4563 vga_ram_size = VGA_RAM_SIZE;
4564 #ifdef CONFIG_GDBSTUB
4566 gdbstub_port = DEFAULT_GDBSTUB_PORT;
4571 kernel_filename = NULL;
4572 kernel_cmdline = "";
4573 cyls = heads = secs = 0;
4574 translation = BIOS_ATA_TRANSLATION_AUTO;
4575 monitor_device = "vc";
4577 serial_devices[0] = "vc:80Cx24C";
4578 for(i = 1; i < MAX_SERIAL_PORTS; i++)
4579 serial_devices[i] = NULL;
4580 serial_device_index = 0;
4582 parallel_devices[0] = "vc:640x480";
4583 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4584 parallel_devices[i] = NULL;
4585 parallel_device_index = 0;
4587 virtio_consoles[0] = "vc:80Cx24C";
4588 for(i = 1; i < MAX_VIRTIO_CONSOLES; i++)
4589 virtio_consoles[i] = NULL;
4590 virtio_console_index = 0;
4592 usb_devices_index = 0;
4611 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4613 const QEMUOption *popt;
4616 /* Treat --foo the same as -foo. */
4619 popt = qemu_options;
4622 fprintf(stderr, "%s: invalid option -- '%s'\n",
4626 if (!strcmp(popt->name, r + 1))
4630 if (popt->flags & HAS_ARG) {
4631 if (optind >= argc) {
4632 fprintf(stderr, "%s: option '%s' requires an argument\n",
4636 optarg = argv[optind++];
4641 switch(popt->index) {
4643 machine = find_machine(optarg);
4646 printf("Supported machines are:\n");
4647 for(m = first_machine; m != NULL; m = m->next) {
4648 printf("%-10s %s%s\n",
4650 m == first_machine ? " (default)" : "");
4652 exit(*optarg != '?');
4655 case QEMU_OPTION_cpu:
4656 /* hw initialization will check this */
4657 if (*optarg == '?') {
4658 /* XXX: implement xxx_cpu_list for targets that still miss it */
4659 #if defined(cpu_list)
4660 cpu_list(stdout, &fprintf);
4667 case QEMU_OPTION_initrd:
4668 initrd_filename = optarg;
4670 case QEMU_OPTION_hda:
4672 hda_index = drive_add(optarg, HD_ALIAS, 0);
4674 hda_index = drive_add(optarg, HD_ALIAS
4675 ",cyls=%d,heads=%d,secs=%d%s",
4676 0, cyls, heads, secs,
4677 translation == BIOS_ATA_TRANSLATION_LBA ?
4679 translation == BIOS_ATA_TRANSLATION_NONE ?
4680 ",trans=none" : "");
4682 case QEMU_OPTION_hdb:
4683 case QEMU_OPTION_hdc:
4684 case QEMU_OPTION_hdd:
4685 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4687 case QEMU_OPTION_drive:
4688 drive_add(NULL, "%s", optarg);
4690 case QEMU_OPTION_mtdblock:
4691 drive_add(optarg, MTD_ALIAS);
4693 case QEMU_OPTION_sd:
4694 drive_add(optarg, SD_ALIAS);
4696 case QEMU_OPTION_pflash:
4697 drive_add(optarg, PFLASH_ALIAS);
4699 case QEMU_OPTION_snapshot:
4702 case QEMU_OPTION_hdachs:
4706 cyls = strtol(p, (char **)&p, 0);
4707 if (cyls < 1 || cyls > 16383)
4712 heads = strtol(p, (char **)&p, 0);
4713 if (heads < 1 || heads > 16)
4718 secs = strtol(p, (char **)&p, 0);
4719 if (secs < 1 || secs > 63)
4723 if (!strcmp(p, "none"))
4724 translation = BIOS_ATA_TRANSLATION_NONE;
4725 else if (!strcmp(p, "lba"))
4726 translation = BIOS_ATA_TRANSLATION_LBA;
4727 else if (!strcmp(p, "auto"))
4728 translation = BIOS_ATA_TRANSLATION_AUTO;
4731 } else if (*p != '\0') {
4733 fprintf(stderr, "qemu: invalid physical CHS format\n");
4736 if (hda_index != -1)
4737 snprintf(drives_opt[hda_index].opt,
4738 sizeof(drives_opt[hda_index].opt),
4739 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4740 0, cyls, heads, secs,
4741 translation == BIOS_ATA_TRANSLATION_LBA ?
4743 translation == BIOS_ATA_TRANSLATION_NONE ?
4744 ",trans=none" : "");
4747 case QEMU_OPTION_nographic:
4750 #ifdef CONFIG_CURSES
4751 case QEMU_OPTION_curses:
4755 case QEMU_OPTION_portrait:
4758 case QEMU_OPTION_kernel:
4759 kernel_filename = optarg;
4761 case QEMU_OPTION_append:
4762 kernel_cmdline = optarg;
4764 case QEMU_OPTION_cdrom:
4765 drive_add(optarg, CDROM_ALIAS);
4767 case QEMU_OPTION_boot:
4768 boot_devices = optarg;
4769 /* We just do some generic consistency checks */
4771 /* Could easily be extended to 64 devices if needed */
4774 boot_devices_bitmap = 0;
4775 for (p = boot_devices; *p != '\0'; p++) {
4776 /* Allowed boot devices are:
4777 * a b : floppy disk drives
4778 * c ... f : IDE disk drives
4779 * g ... m : machine implementation dependant drives
4780 * n ... p : network devices
4781 * It's up to each machine implementation to check
4782 * if the given boot devices match the actual hardware
4783 * implementation and firmware features.
4785 if (*p < 'a' || *p > 'q') {
4786 fprintf(stderr, "Invalid boot device '%c'\n", *p);
4789 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4791 "Boot device '%c' was given twice\n",*p);
4794 boot_devices_bitmap |= 1 << (*p - 'a');
4798 case QEMU_OPTION_fda:
4799 case QEMU_OPTION_fdb:
4800 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4803 case QEMU_OPTION_no_fd_bootchk:
4807 case QEMU_OPTION_net:
4808 if (nb_net_clients >= MAX_NET_CLIENTS) {
4809 fprintf(stderr, "qemu: too many network clients\n");
4812 net_clients[nb_net_clients] = optarg;
4816 case QEMU_OPTION_tftp:
4817 tftp_prefix = optarg;
4819 case QEMU_OPTION_bootp:
4820 bootp_filename = optarg;
4823 case QEMU_OPTION_smb:
4824 net_slirp_smb(optarg);
4827 case QEMU_OPTION_redir:
4828 net_slirp_redir(optarg);
4831 case QEMU_OPTION_bt:
4832 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4833 fprintf(stderr, "qemu: too many bluetooth options\n");
4836 bt_opts[nb_bt_opts++] = optarg;
4839 case QEMU_OPTION_audio_help:
4843 case QEMU_OPTION_soundhw:
4844 select_soundhw (optarg);
4850 case QEMU_OPTION_m: {
4854 value = strtoul(optarg, &ptr, 10);
4856 case 0: case 'M': case 'm':
4863 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4867 /* On 32-bit hosts, QEMU is limited by virtual address space */
4868 if (value > (2047 << 20)
4870 && HOST_LONG_BITS == 32
4873 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4876 if (value != (uint64_t)(ram_addr_t)value) {
4877 fprintf(stderr, "qemu: ram size too large\n");
4886 const CPULogItem *item;
4888 mask = cpu_str_to_log_mask(optarg);
4890 printf("Log items (comma separated):\n");
4891 for(item = cpu_log_items; item->mask != 0; item++) {
4892 printf("%-10s %s\n", item->name, item->help);
4899 #ifdef CONFIG_GDBSTUB
4904 gdbstub_port = optarg;
4910 case QEMU_OPTION_bios:
4917 keyboard_layout = optarg;
4919 case QEMU_OPTION_localtime:
4922 case QEMU_OPTION_vga:
4923 select_vgahw (optarg);
4930 w = strtol(p, (char **)&p, 10);
4933 fprintf(stderr, "qemu: invalid resolution or depth\n");
4939 h = strtol(p, (char **)&p, 10);
4944 depth = strtol(p, (char **)&p, 10);
4945 if (depth != 8 && depth != 15 && depth != 16 &&
4946 depth != 24 && depth != 32)
4948 } else if (*p == '\0') {
4949 depth = graphic_depth;
4956 graphic_depth = depth;
4959 case QEMU_OPTION_echr:
4962 term_escape_char = strtol(optarg, &r, 0);
4964 printf("Bad argument to echr\n");
4967 case QEMU_OPTION_monitor:
4968 monitor_device = optarg;
4970 case QEMU_OPTION_serial:
4971 if (serial_device_index >= MAX_SERIAL_PORTS) {
4972 fprintf(stderr, "qemu: too many serial ports\n");
4975 serial_devices[serial_device_index] = optarg;
4976 serial_device_index++;
4978 case QEMU_OPTION_virtiocon:
4979 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
4980 fprintf(stderr, "qemu: too many virtio consoles\n");
4983 virtio_consoles[virtio_console_index] = optarg;
4984 virtio_console_index++;
4986 case QEMU_OPTION_parallel:
4987 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4988 fprintf(stderr, "qemu: too many parallel ports\n");
4991 parallel_devices[parallel_device_index] = optarg;
4992 parallel_device_index++;
4994 case QEMU_OPTION_loadvm:
4997 case QEMU_OPTION_full_screen:
5001 case QEMU_OPTION_no_frame:
5004 case QEMU_OPTION_alt_grab:
5007 case QEMU_OPTION_no_quit:
5011 case QEMU_OPTION_pidfile:
5015 case QEMU_OPTION_win2k_hack:
5016 win2k_install_hack = 1;
5018 case QEMU_OPTION_rtc_td_hack:
5023 case QEMU_OPTION_no_kqemu:
5026 case QEMU_OPTION_kernel_kqemu:
5031 case QEMU_OPTION_enable_kvm:
5038 case QEMU_OPTION_usb:
5041 case QEMU_OPTION_usbdevice:
5043 if (usb_devices_index >= MAX_USB_CMDLINE) {
5044 fprintf(stderr, "Too many USB devices\n");
5047 usb_devices[usb_devices_index] = optarg;
5048 usb_devices_index++;
5050 case QEMU_OPTION_smp:
5051 smp_cpus = atoi(optarg);
5053 fprintf(stderr, "Invalid number of CPUs\n");
5057 case QEMU_OPTION_vnc:
5058 vnc_display = optarg;
5060 case QEMU_OPTION_no_acpi:
5063 case QEMU_OPTION_no_hpet:
5066 case QEMU_OPTION_no_reboot:
5069 case QEMU_OPTION_no_shutdown:
5072 case QEMU_OPTION_show_cursor:
5075 case QEMU_OPTION_uuid:
5076 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5077 fprintf(stderr, "Fail to parse UUID string."
5078 " Wrong format.\n");
5082 case QEMU_OPTION_daemonize:
5085 case QEMU_OPTION_option_rom:
5086 if (nb_option_roms >= MAX_OPTION_ROMS) {
5087 fprintf(stderr, "Too many option ROMs\n");
5090 option_rom[nb_option_roms] = optarg;
5093 case QEMU_OPTION_semihosting:
5094 semihosting_enabled = 1;
5096 case QEMU_OPTION_name:
5099 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5100 case QEMU_OPTION_prom_env:
5101 if (nb_prom_envs >= MAX_PROM_ENVS) {
5102 fprintf(stderr, "Too many prom variables\n");
5105 prom_envs[nb_prom_envs] = optarg;
5110 case QEMU_OPTION_old_param:
5114 case QEMU_OPTION_clock:
5115 configure_alarms(optarg);
5117 case QEMU_OPTION_startdate:
5120 time_t rtc_start_date;
5121 if (!strcmp(optarg, "now")) {
5122 rtc_date_offset = -1;
5124 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5132 } else if (sscanf(optarg, "%d-%d-%d",
5135 &tm.tm_mday) == 3) {
5144 rtc_start_date = mktimegm(&tm);
5145 if (rtc_start_date == -1) {
5147 fprintf(stderr, "Invalid date format. Valid format are:\n"
5148 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5151 rtc_date_offset = time(NULL) - rtc_start_date;
5155 case QEMU_OPTION_tb_size:
5156 tb_size = strtol(optarg, NULL, 0);
5160 case QEMU_OPTION_icount:
5162 if (strcmp(optarg, "auto") == 0) {
5163 icount_time_shift = -1;
5165 icount_time_shift = strtol(optarg, NULL, 0);
5168 case QEMU_OPTION_incoming:
5175 #if defined(CONFIG_KVM) && defined(USE_KQEMU)
5176 if (kvm_allowed && kqemu_allowed) {
5178 "You can not enable both KVM and kqemu at the same time\n");
5183 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5184 if (smp_cpus > machine->max_cpus) {
5185 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5186 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5192 if (serial_device_index == 0)
5193 serial_devices[0] = "stdio";
5194 if (parallel_device_index == 0)
5195 parallel_devices[0] = "null";
5196 if (strncmp(monitor_device, "vc", 2) == 0)
5197 monitor_device = "stdio";
5198 if (virtio_console_index == 0)
5199 virtio_consoles[0] = "null";
5206 if (pipe(fds) == -1)
5217 len = read(fds[0], &status, 1);
5218 if (len == -1 && (errno == EINTR))
5223 else if (status == 1) {
5224 fprintf(stderr, "Could not acquire pidfile\n");
5241 signal(SIGTSTP, SIG_IGN);
5242 signal(SIGTTOU, SIG_IGN);
5243 signal(SIGTTIN, SIG_IGN);
5247 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5250 write(fds[1], &status, 1);
5252 fprintf(stderr, "Could not acquire pid file\n");
5260 linux_boot = (kernel_filename != NULL);
5261 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5263 if (!linux_boot && net_boot == 0 &&
5264 !machine->nodisk_ok && nb_drives_opt == 0)
5267 if (!linux_boot && *kernel_cmdline != '\0') {
5268 fprintf(stderr, "-append only allowed with -kernel option\n");
5272 if (!linux_boot && initrd_filename != NULL) {
5273 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5277 /* boot to floppy or the default cd if no hard disk defined yet */
5278 if (!boot_devices[0]) {
5279 boot_devices = "cad";
5281 setvbuf(stdout, NULL, _IOLBF, 0);
5284 if (init_timer_alarm() < 0) {
5285 fprintf(stderr, "could not initialize alarm timer\n");
5288 if (use_icount && icount_time_shift < 0) {
5290 /* 125MIPS seems a reasonable initial guess at the guest speed.
5291 It will be corrected fairly quickly anyway. */
5292 icount_time_shift = 3;
5293 init_icount_adjust();
5300 /* init network clients */
5301 if (nb_net_clients == 0) {
5302 /* if no clients, we use a default config */
5303 net_clients[nb_net_clients++] = "nic";
5305 net_clients[nb_net_clients++] = "user";
5309 for(i = 0;i < nb_net_clients; i++) {
5310 if (net_client_parse(net_clients[i]) < 0)
5316 /* XXX: this should be moved in the PC machine instantiation code */
5317 if (net_boot != 0) {
5319 for (i = 0; i < nb_nics && i < 4; i++) {
5320 const char *model = nd_table[i].model;
5322 if (net_boot & (1 << i)) {
5325 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5326 if (get_image_size(buf) > 0) {
5327 if (nb_option_roms >= MAX_OPTION_ROMS) {
5328 fprintf(stderr, "Too many option ROMs\n");
5331 option_rom[nb_option_roms] = strdup(buf);
5338 fprintf(stderr, "No valid PXE rom found for network device\n");
5344 /* init the bluetooth world */
5345 for (i = 0; i < nb_bt_opts; i++)
5346 if (bt_parse(bt_opts[i]))
5349 /* init the memory */
5350 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5352 if (machine->ram_require & RAMSIZE_FIXED) {
5354 if (ram_size < phys_ram_size) {
5355 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5356 machine->name, (unsigned long long) phys_ram_size);
5360 phys_ram_size = ram_size;
5362 ram_size = phys_ram_size;
5365 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5367 phys_ram_size += ram_size;
5370 phys_ram_base = qemu_vmalloc(phys_ram_size);
5371 if (!phys_ram_base) {
5372 fprintf(stderr, "Could not allocate physical memory\n");
5376 /* init the dynamic translator */
5377 cpu_exec_init_all(tb_size * 1024 * 1024);
5381 /* we always create the cdrom drive, even if no disk is there */
5383 if (nb_drives_opt < MAX_DRIVES)
5384 drive_add(NULL, CDROM_ALIAS);
5386 /* we always create at least one floppy */
5388 if (nb_drives_opt < MAX_DRIVES)
5389 drive_add(NULL, FD_ALIAS, 0);
5391 /* we always create one sd slot, even if no card is in it */
5393 if (nb_drives_opt < MAX_DRIVES)
5394 drive_add(NULL, SD_ALIAS);
5396 /* open the virtual block devices */
5398 for(i = 0; i < nb_drives_opt; i++)
5399 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5402 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5403 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5406 memset(&display_state, 0, sizeof(display_state));
5409 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5412 /* nearly nothing to do */
5413 dumb_display_init(ds);
5414 } else if (vnc_display != NULL) {
5415 vnc_display_init(ds);
5416 if (vnc_display_open(ds, vnc_display) < 0)
5419 #if defined(CONFIG_CURSES)
5421 curses_display_init(ds, full_screen);
5425 #if defined(CONFIG_SDL)
5426 sdl_display_init(ds, full_screen, no_frame);
5427 #elif defined(CONFIG_COCOA)
5428 cocoa_display_init(ds, full_screen);
5430 dumb_display_init(ds);
5435 /* must be after terminal init, SDL library changes signal handlers */
5439 /* Maintain compatibility with multiple stdio monitors */
5440 if (!strcmp(monitor_device,"stdio")) {
5441 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5442 const char *devname = serial_devices[i];
5443 if (devname && !strcmp(devname,"mon:stdio")) {
5444 monitor_device = NULL;
5446 } else if (devname && !strcmp(devname,"stdio")) {
5447 monitor_device = NULL;
5448 serial_devices[i] = "mon:stdio";
5453 if (monitor_device) {
5454 monitor_hd = qemu_chr_open("monitor", monitor_device);
5456 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5459 monitor_init(monitor_hd, !nographic);
5462 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5463 const char *devname = serial_devices[i];
5464 if (devname && strcmp(devname, "none")) {
5466 snprintf(label, sizeof(label), "serial%d", i);
5467 serial_hds[i] = qemu_chr_open(label, devname);
5468 if (!serial_hds[i]) {
5469 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5473 if (strstart(devname, "vc", 0))
5474 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5478 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5479 const char *devname = parallel_devices[i];
5480 if (devname && strcmp(devname, "none")) {
5482 snprintf(label, sizeof(label), "parallel%d", i);
5483 parallel_hds[i] = qemu_chr_open(label, devname);
5484 if (!parallel_hds[i]) {
5485 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5489 if (strstart(devname, "vc", 0))
5490 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5494 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5495 const char *devname = virtio_consoles[i];
5496 if (devname && strcmp(devname, "none")) {
5498 snprintf(label, sizeof(label), "virtcon%d", i);
5499 virtcon_hds[i] = qemu_chr_open(label, devname);
5500 if (!virtcon_hds[i]) {
5501 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5505 if (strstart(devname, "vc", 0))
5506 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5510 if (kvm_enabled()) {
5513 ret = kvm_init(smp_cpus);
5515 fprintf(stderr, "failed to initialize KVM\n");
5520 machine->init(ram_size, vga_ram_size, boot_devices, ds,
5521 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5523 /* Set KVM's vcpu state to qemu's initial CPUState. */
5524 if (kvm_enabled()) {
5527 ret = kvm_sync_vcpus();
5529 fprintf(stderr, "failed to initialize vcpus\n");
5534 /* init USB devices */
5536 for(i = 0; i < usb_devices_index; i++) {
5537 if (usb_device_add(usb_devices[i]) < 0) {
5538 fprintf(stderr, "Warning: could not add USB device %s\n",
5544 if (display_state.dpy_refresh) {
5545 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
5546 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
5549 #ifdef CONFIG_GDBSTUB
5551 /* XXX: use standard host:port notation and modify options
5553 if (gdbserver_start(gdbstub_port) < 0) {
5554 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
5565 autostart = 0; /* fixme how to deal with -daemonize */
5566 qemu_start_incoming_migration(incoming);
5570 /* XXX: simplify init */
5583 len = write(fds[1], &status, 1);
5584 if (len == -1 && (errno == EINTR))
5591 TFR(fd = open("/dev/null", O_RDWR));