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"
30 #include "hw/audiodev.h"
36 #include "qemu-timer.h"
37 #include "qemu-char.h"
39 #include "audio/audio.h"
50 #include <sys/times.h>
55 #include <sys/ioctl.h>
56 #include <sys/socket.h>
57 #include <netinet/in.h>
60 #include <sys/select.h>
61 #include <arpa/inet.h>
67 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
68 #include <freebsd/stdlib.h>
72 #include <linux/if_tun.h>
75 #include <linux/rtc.h>
77 /* For the benefit of older linux systems which don't supply it,
78 we use a local copy of hpet.h. */
79 /* #include <linux/hpet.h> */
82 #include <linux/ppdev.h>
83 #include <linux/parport.h>
86 #include <sys/ethernet.h>
87 #include <sys/sockio.h>
88 #include <netinet/arp.h>
89 #include <netinet/in.h>
90 #include <netinet/in_systm.h>
91 #include <netinet/ip.h>
92 #include <netinet/ip_icmp.h> // must come after ip.h
93 #include <netinet/udp.h>
94 #include <netinet/tcp.h>
101 #include <winsock2.h>
102 int inet_aton(const char *cp, struct in_addr *ia);
105 #if defined(CONFIG_SLIRP)
106 #include "libslirp.h"
111 #include <sys/timeb.h>
112 #include <mmsystem.h>
113 #define getopt_long_only getopt_long
114 #define memalign(align, size) malloc(size)
117 #include "qemu_socket.h"
123 #endif /* CONFIG_SDL */
127 #define main qemu_main
128 #endif /* CONFIG_COCOA */
132 #include "exec-all.h"
134 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
135 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
137 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
139 #define SMBD_COMMAND "/usr/sbin/smbd"
142 //#define DEBUG_UNUSED_IOPORT
143 //#define DEBUG_IOPORT
145 #define PHYS_RAM_MAX_SIZE (2047 * 1024 * 1024)
148 #define DEFAULT_RAM_SIZE 144
150 #define DEFAULT_RAM_SIZE 128
153 #define GUI_REFRESH_INTERVAL 30
155 /* Max number of USB devices that can be specified on the commandline. */
156 #define MAX_USB_CMDLINE 8
158 /* XXX: use a two level table to limit memory usage */
159 #define MAX_IOPORTS 65536
161 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
162 const char *bios_name = NULL;
163 void *ioport_opaque[MAX_IOPORTS];
164 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
165 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
166 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
167 to store the VM snapshots */
168 DriveInfo drives_table[MAX_DRIVES+1];
170 /* point to the block driver where the snapshots are managed */
171 BlockDriverState *bs_snapshots;
173 static DisplayState display_state;
175 const char* keyboard_layout = NULL;
176 int64_t ticks_per_sec;
178 int pit_min_timer_count = 0;
180 NICInfo nd_table[MAX_NICS];
183 int rtc_start_date = -1; /* -1 means now */
184 int cirrus_vga_enabled = 1;
185 int vmsvga_enabled = 0;
187 int graphic_width = 1024;
188 int graphic_height = 768;
189 int graphic_depth = 8;
191 int graphic_width = 800;
192 int graphic_height = 600;
193 int graphic_depth = 15;
198 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
199 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
201 int win2k_install_hack = 0;
204 static VLANState *first_vlan;
206 const char *vnc_display;
207 #if defined(TARGET_SPARC)
209 #elif defined(TARGET_I386)
214 int acpi_enabled = 1;
218 int graphic_rotate = 0;
220 const char *option_rom[MAX_OPTION_ROMS];
222 int semihosting_enabled = 0;
227 const char *qemu_name;
230 unsigned int nb_prom_envs = 0;
231 const char *prom_envs[MAX_PROM_ENVS];
237 } drives_opt[MAX_DRIVES];
239 static CPUState *cur_cpu;
240 static CPUState *next_cpu;
241 static int event_pending = 1;
243 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
245 /***********************************************************/
246 /* x86 ISA bus support */
248 target_phys_addr_t isa_mem_base = 0;
251 static uint32_t default_ioport_readb(void *opaque, uint32_t address)
253 #ifdef DEBUG_UNUSED_IOPORT
254 fprintf(stderr, "unused inb: port=0x%04x\n", address);
259 static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
261 #ifdef DEBUG_UNUSED_IOPORT
262 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
266 /* default is to make two byte accesses */
267 static uint32_t default_ioport_readw(void *opaque, uint32_t address)
270 data = ioport_read_table[0][address](ioport_opaque[address], address);
271 address = (address + 1) & (MAX_IOPORTS - 1);
272 data |= ioport_read_table[0][address](ioport_opaque[address], address) << 8;
276 static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
278 ioport_write_table[0][address](ioport_opaque[address], address, data & 0xff);
279 address = (address + 1) & (MAX_IOPORTS - 1);
280 ioport_write_table[0][address](ioport_opaque[address], address, (data >> 8) & 0xff);
283 static uint32_t default_ioport_readl(void *opaque, uint32_t address)
285 #ifdef DEBUG_UNUSED_IOPORT
286 fprintf(stderr, "unused inl: port=0x%04x\n", address);
291 static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
293 #ifdef DEBUG_UNUSED_IOPORT
294 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
298 static void init_ioports(void)
302 for(i = 0; i < MAX_IOPORTS; i++) {
303 ioport_read_table[0][i] = default_ioport_readb;
304 ioport_write_table[0][i] = default_ioport_writeb;
305 ioport_read_table[1][i] = default_ioport_readw;
306 ioport_write_table[1][i] = default_ioport_writew;
307 ioport_read_table[2][i] = default_ioport_readl;
308 ioport_write_table[2][i] = default_ioport_writel;
312 /* size is the word size in byte */
313 int register_ioport_read(int start, int length, int size,
314 IOPortReadFunc *func, void *opaque)
320 } else if (size == 2) {
322 } else if (size == 4) {
325 hw_error("register_ioport_read: invalid size");
328 for(i = start; i < start + length; i += size) {
329 ioport_read_table[bsize][i] = func;
330 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
331 hw_error("register_ioport_read: invalid opaque");
332 ioport_opaque[i] = opaque;
337 /* size is the word size in byte */
338 int register_ioport_write(int start, int length, int size,
339 IOPortWriteFunc *func, void *opaque)
345 } else if (size == 2) {
347 } else if (size == 4) {
350 hw_error("register_ioport_write: invalid size");
353 for(i = start; i < start + length; i += size) {
354 ioport_write_table[bsize][i] = func;
355 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
356 hw_error("register_ioport_write: invalid opaque");
357 ioport_opaque[i] = opaque;
362 void isa_unassign_ioport(int start, int length)
366 for(i = start; i < start + length; i++) {
367 ioport_read_table[0][i] = default_ioport_readb;
368 ioport_read_table[1][i] = default_ioport_readw;
369 ioport_read_table[2][i] = default_ioport_readl;
371 ioport_write_table[0][i] = default_ioport_writeb;
372 ioport_write_table[1][i] = default_ioport_writew;
373 ioport_write_table[2][i] = default_ioport_writel;
377 /***********************************************************/
379 void cpu_outb(CPUState *env, int addr, int val)
382 if (loglevel & CPU_LOG_IOPORT)
383 fprintf(logfile, "outb: %04x %02x\n", addr, val);
385 ioport_write_table[0][addr](ioport_opaque[addr], addr, val);
388 env->last_io_time = cpu_get_time_fast();
392 void cpu_outw(CPUState *env, int addr, int val)
395 if (loglevel & CPU_LOG_IOPORT)
396 fprintf(logfile, "outw: %04x %04x\n", addr, val);
398 ioport_write_table[1][addr](ioport_opaque[addr], addr, val);
401 env->last_io_time = cpu_get_time_fast();
405 void cpu_outl(CPUState *env, int addr, int val)
408 if (loglevel & CPU_LOG_IOPORT)
409 fprintf(logfile, "outl: %04x %08x\n", addr, val);
411 ioport_write_table[2][addr](ioport_opaque[addr], addr, val);
414 env->last_io_time = cpu_get_time_fast();
418 int cpu_inb(CPUState *env, int addr)
421 val = ioport_read_table[0][addr](ioport_opaque[addr], addr);
423 if (loglevel & CPU_LOG_IOPORT)
424 fprintf(logfile, "inb : %04x %02x\n", addr, val);
428 env->last_io_time = cpu_get_time_fast();
433 int cpu_inw(CPUState *env, int addr)
436 val = ioport_read_table[1][addr](ioport_opaque[addr], addr);
438 if (loglevel & CPU_LOG_IOPORT)
439 fprintf(logfile, "inw : %04x %04x\n", addr, val);
443 env->last_io_time = cpu_get_time_fast();
448 int cpu_inl(CPUState *env, int addr)
451 val = ioport_read_table[2][addr](ioport_opaque[addr], addr);
453 if (loglevel & CPU_LOG_IOPORT)
454 fprintf(logfile, "inl : %04x %08x\n", addr, val);
458 env->last_io_time = cpu_get_time_fast();
463 /***********************************************************/
464 void hw_error(const char *fmt, ...)
470 fprintf(stderr, "qemu: hardware error: ");
471 vfprintf(stderr, fmt, ap);
472 fprintf(stderr, "\n");
473 for(env = first_cpu; env != NULL; env = env->next_cpu) {
474 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
476 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
478 cpu_dump_state(env, stderr, fprintf, 0);
485 /***********************************************************/
488 static QEMUPutKBDEvent *qemu_put_kbd_event;
489 static void *qemu_put_kbd_event_opaque;
490 static QEMUPutMouseEntry *qemu_put_mouse_event_head;
491 static QEMUPutMouseEntry *qemu_put_mouse_event_current;
493 void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
495 qemu_put_kbd_event_opaque = opaque;
496 qemu_put_kbd_event = func;
499 QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
500 void *opaque, int absolute,
503 QEMUPutMouseEntry *s, *cursor;
505 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
509 s->qemu_put_mouse_event = func;
510 s->qemu_put_mouse_event_opaque = opaque;
511 s->qemu_put_mouse_event_absolute = absolute;
512 s->qemu_put_mouse_event_name = qemu_strdup(name);
515 if (!qemu_put_mouse_event_head) {
516 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
520 cursor = qemu_put_mouse_event_head;
521 while (cursor->next != NULL)
522 cursor = cursor->next;
525 qemu_put_mouse_event_current = s;
530 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
532 QEMUPutMouseEntry *prev = NULL, *cursor;
534 if (!qemu_put_mouse_event_head || entry == NULL)
537 cursor = qemu_put_mouse_event_head;
538 while (cursor != NULL && cursor != entry) {
540 cursor = cursor->next;
543 if (cursor == NULL) // does not exist or list empty
545 else if (prev == NULL) { // entry is head
546 qemu_put_mouse_event_head = cursor->next;
547 if (qemu_put_mouse_event_current == entry)
548 qemu_put_mouse_event_current = cursor->next;
549 qemu_free(entry->qemu_put_mouse_event_name);
554 prev->next = entry->next;
556 if (qemu_put_mouse_event_current == entry)
557 qemu_put_mouse_event_current = prev;
559 qemu_free(entry->qemu_put_mouse_event_name);
563 void kbd_put_keycode(int keycode)
565 if (qemu_put_kbd_event) {
566 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
570 void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
572 QEMUPutMouseEvent *mouse_event;
573 void *mouse_event_opaque;
576 if (!qemu_put_mouse_event_current) {
581 qemu_put_mouse_event_current->qemu_put_mouse_event;
583 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
586 if (graphic_rotate) {
587 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
590 width = graphic_width;
591 mouse_event(mouse_event_opaque,
592 width - dy, dx, dz, buttons_state);
594 mouse_event(mouse_event_opaque,
595 dx, dy, dz, buttons_state);
599 int kbd_mouse_is_absolute(void)
601 if (!qemu_put_mouse_event_current)
604 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
607 void do_info_mice(void)
609 QEMUPutMouseEntry *cursor;
612 if (!qemu_put_mouse_event_head) {
613 term_printf("No mouse devices connected\n");
617 term_printf("Mouse devices available:\n");
618 cursor = qemu_put_mouse_event_head;
619 while (cursor != NULL) {
620 term_printf("%c Mouse #%d: %s\n",
621 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
622 index, cursor->qemu_put_mouse_event_name);
624 cursor = cursor->next;
628 void do_mouse_set(int index)
630 QEMUPutMouseEntry *cursor;
633 if (!qemu_put_mouse_event_head) {
634 term_printf("No mouse devices connected\n");
638 cursor = qemu_put_mouse_event_head;
639 while (cursor != NULL && index != i) {
641 cursor = cursor->next;
645 qemu_put_mouse_event_current = cursor;
647 term_printf("Mouse at given index not found\n");
650 /* compute with 96 bit intermediate result: (a*b)/c */
651 uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
656 #ifdef WORDS_BIGENDIAN
666 rl = (uint64_t)u.l.low * (uint64_t)b;
667 rh = (uint64_t)u.l.high * (uint64_t)b;
670 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
674 /***********************************************************/
675 /* real time host monotonic timer */
677 #define QEMU_TIMER_BASE 1000000000LL
681 static int64_t clock_freq;
683 static void init_get_clock(void)
687 ret = QueryPerformanceFrequency(&freq);
689 fprintf(stderr, "Could not calibrate ticks\n");
692 clock_freq = freq.QuadPart;
695 static int64_t get_clock(void)
698 QueryPerformanceCounter(&ti);
699 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
704 static int use_rt_clock;
706 static void init_get_clock(void)
709 #if defined(__linux__)
712 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
719 static int64_t get_clock(void)
721 #if defined(__linux__)
724 clock_gettime(CLOCK_MONOTONIC, &ts);
725 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
729 /* XXX: using gettimeofday leads to problems if the date
730 changes, so it should be avoided. */
732 gettimeofday(&tv, NULL);
733 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
739 /***********************************************************/
740 /* guest cycle counter */
742 static int64_t cpu_ticks_prev;
743 static int64_t cpu_ticks_offset;
744 static int64_t cpu_clock_offset;
745 static int cpu_ticks_enabled;
747 /* return the host CPU cycle counter and handle stop/restart */
748 int64_t cpu_get_ticks(void)
750 if (!cpu_ticks_enabled) {
751 return cpu_ticks_offset;
754 ticks = cpu_get_real_ticks();
755 if (cpu_ticks_prev > ticks) {
756 /* Note: non increasing ticks may happen if the host uses
758 cpu_ticks_offset += cpu_ticks_prev - ticks;
760 cpu_ticks_prev = ticks;
761 return ticks + cpu_ticks_offset;
765 /* return the host CPU monotonic timer and handle stop/restart */
766 static int64_t cpu_get_clock(void)
769 if (!cpu_ticks_enabled) {
770 return cpu_clock_offset;
773 return ti + cpu_clock_offset;
777 /* enable cpu_get_ticks() */
778 void cpu_enable_ticks(void)
780 if (!cpu_ticks_enabled) {
781 cpu_ticks_offset -= cpu_get_real_ticks();
782 cpu_clock_offset -= get_clock();
783 cpu_ticks_enabled = 1;
787 /* disable cpu_get_ticks() : the clock is stopped. You must not call
788 cpu_get_ticks() after that. */
789 void cpu_disable_ticks(void)
791 if (cpu_ticks_enabled) {
792 cpu_ticks_offset = cpu_get_ticks();
793 cpu_clock_offset = cpu_get_clock();
794 cpu_ticks_enabled = 0;
798 /***********************************************************/
801 #define QEMU_TIMER_REALTIME 0
802 #define QEMU_TIMER_VIRTUAL 1
806 /* XXX: add frequency */
814 struct QEMUTimer *next;
817 struct qemu_alarm_timer {
821 int (*start)(struct qemu_alarm_timer *t);
822 void (*stop)(struct qemu_alarm_timer *t);
823 void (*rearm)(struct qemu_alarm_timer *t);
827 #define ALARM_FLAG_DYNTICKS 0x1
828 #define ALARM_FLAG_EXPIRED 0x2
830 static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
832 return t->flags & ALARM_FLAG_DYNTICKS;
835 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
837 if (!alarm_has_dynticks(t))
843 /* TODO: MIN_TIMER_REARM_US should be optimized */
844 #define MIN_TIMER_REARM_US 250
846 static struct qemu_alarm_timer *alarm_timer;
850 struct qemu_alarm_win32 {
854 } alarm_win32_data = {0, NULL, -1};
856 static int win32_start_timer(struct qemu_alarm_timer *t);
857 static void win32_stop_timer(struct qemu_alarm_timer *t);
858 static void win32_rearm_timer(struct qemu_alarm_timer *t);
862 static int unix_start_timer(struct qemu_alarm_timer *t);
863 static void unix_stop_timer(struct qemu_alarm_timer *t);
867 static int dynticks_start_timer(struct qemu_alarm_timer *t);
868 static void dynticks_stop_timer(struct qemu_alarm_timer *t);
869 static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
871 static int hpet_start_timer(struct qemu_alarm_timer *t);
872 static void hpet_stop_timer(struct qemu_alarm_timer *t);
874 static int rtc_start_timer(struct qemu_alarm_timer *t);
875 static void rtc_stop_timer(struct qemu_alarm_timer *t);
877 #endif /* __linux__ */
881 static struct qemu_alarm_timer alarm_timers[] = {
884 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
885 dynticks_stop_timer, dynticks_rearm_timer, NULL},
886 /* HPET - if available - is preferred */
887 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
888 /* ...otherwise try RTC */
889 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
891 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
893 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
894 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
895 {"win32", 0, win32_start_timer,
896 win32_stop_timer, NULL, &alarm_win32_data},
901 static void show_available_alarms()
905 printf("Available alarm timers, in order of precedence:\n");
906 for (i = 0; alarm_timers[i].name; i++)
907 printf("%s\n", alarm_timers[i].name);
910 static void configure_alarms(char const *opt)
914 int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
918 if (!strcmp(opt, "help")) {
919 show_available_alarms();
925 /* Reorder the array */
926 name = strtok(arg, ",");
928 struct qemu_alarm_timer tmp;
930 for (i = 0; i < count && alarm_timers[i].name; i++) {
931 if (!strcmp(alarm_timers[i].name, name))
936 fprintf(stderr, "Unknown clock %s\n", name);
945 tmp = alarm_timers[i];
946 alarm_timers[i] = alarm_timers[cur];
947 alarm_timers[cur] = tmp;
951 name = strtok(NULL, ",");
957 /* Disable remaining timers */
958 for (i = cur; i < count; i++)
959 alarm_timers[i].name = NULL;
963 show_available_alarms();
969 static QEMUTimer *active_timers[2];
971 static QEMUClock *qemu_new_clock(int type)
974 clock = qemu_mallocz(sizeof(QEMUClock));
981 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
985 ts = qemu_mallocz(sizeof(QEMUTimer));
992 void qemu_free_timer(QEMUTimer *ts)
997 /* stop a timer, but do not dealloc it */
998 void qemu_del_timer(QEMUTimer *ts)
1002 /* NOTE: this code must be signal safe because
1003 qemu_timer_expired() can be called from a signal. */
1004 pt = &active_timers[ts->clock->type];
1017 /* modify the current timer so that it will be fired when current_time
1018 >= expire_time. The corresponding callback will be called. */
1019 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1025 /* add the timer in the sorted list */
1026 /* NOTE: this code must be signal safe because
1027 qemu_timer_expired() can be called from a signal. */
1028 pt = &active_timers[ts->clock->type];
1033 if (t->expire_time > expire_time)
1037 ts->expire_time = expire_time;
1041 /* Rearm if necessary */
1042 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0 &&
1043 pt == &active_timers[ts->clock->type])
1044 qemu_rearm_alarm_timer(alarm_timer);
1047 int qemu_timer_pending(QEMUTimer *ts)
1050 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1057 static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1061 return (timer_head->expire_time <= current_time);
1064 static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1070 if (!ts || ts->expire_time > current_time)
1072 /* remove timer from the list before calling the callback */
1073 *ptimer_head = ts->next;
1076 /* run the callback (the timer list can be modified) */
1081 int64_t qemu_get_clock(QEMUClock *clock)
1083 switch(clock->type) {
1084 case QEMU_TIMER_REALTIME:
1085 return get_clock() / 1000000;
1087 case QEMU_TIMER_VIRTUAL:
1088 return cpu_get_clock();
1092 static void init_timers(void)
1095 ticks_per_sec = QEMU_TIMER_BASE;
1096 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1097 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1101 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1103 uint64_t expire_time;
1105 if (qemu_timer_pending(ts)) {
1106 expire_time = ts->expire_time;
1110 qemu_put_be64(f, expire_time);
1113 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1115 uint64_t expire_time;
1117 expire_time = qemu_get_be64(f);
1118 if (expire_time != -1) {
1119 qemu_mod_timer(ts, expire_time);
1125 static void timer_save(QEMUFile *f, void *opaque)
1127 if (cpu_ticks_enabled) {
1128 hw_error("cannot save state if virtual timers are running");
1130 qemu_put_be64(f, cpu_ticks_offset);
1131 qemu_put_be64(f, ticks_per_sec);
1132 qemu_put_be64(f, cpu_clock_offset);
1135 static int timer_load(QEMUFile *f, void *opaque, int version_id)
1137 if (version_id != 1 && version_id != 2)
1139 if (cpu_ticks_enabled) {
1142 cpu_ticks_offset=qemu_get_be64(f);
1143 ticks_per_sec=qemu_get_be64(f);
1144 if (version_id == 2) {
1145 cpu_clock_offset=qemu_get_be64(f);
1151 void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1152 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1154 static void host_alarm_handler(int host_signum)
1158 #define DISP_FREQ 1000
1160 static int64_t delta_min = INT64_MAX;
1161 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1163 ti = qemu_get_clock(vm_clock);
1164 if (last_clock != 0) {
1165 delta = ti - last_clock;
1166 if (delta < delta_min)
1168 if (delta > delta_max)
1171 if (++count == DISP_FREQ) {
1172 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
1173 muldiv64(delta_min, 1000000, ticks_per_sec),
1174 muldiv64(delta_max, 1000000, ticks_per_sec),
1175 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1176 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1178 delta_min = INT64_MAX;
1186 if (alarm_has_dynticks(alarm_timer) ||
1187 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1188 qemu_get_clock(vm_clock)) ||
1189 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1190 qemu_get_clock(rt_clock))) {
1192 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1193 SetEvent(data->host_alarm);
1195 CPUState *env = next_cpu;
1197 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1200 /* stop the currently executing cpu because a timer occured */
1201 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
1203 if (env->kqemu_enabled) {
1204 kqemu_cpu_interrupt(env);
1212 static uint64_t qemu_next_deadline(void)
1214 int64_t nearest_delta_us = INT64_MAX;
1217 if (active_timers[QEMU_TIMER_REALTIME])
1218 nearest_delta_us = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1219 qemu_get_clock(rt_clock))*1000;
1221 if (active_timers[QEMU_TIMER_VIRTUAL]) {
1223 vmdelta_us = (active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1224 qemu_get_clock(vm_clock)+999)/1000;
1225 if (vmdelta_us < nearest_delta_us)
1226 nearest_delta_us = vmdelta_us;
1229 /* Avoid arming the timer to negative, zero, or too low values */
1230 if (nearest_delta_us <= MIN_TIMER_REARM_US)
1231 nearest_delta_us = MIN_TIMER_REARM_US;
1233 return nearest_delta_us;
1238 #if defined(__linux__)
1240 #define RTC_FREQ 1024
1242 static void enable_sigio_timer(int fd)
1244 struct sigaction act;
1247 sigfillset(&act.sa_mask);
1249 act.sa_handler = host_alarm_handler;
1251 sigaction(SIGIO, &act, NULL);
1252 fcntl(fd, F_SETFL, O_ASYNC);
1253 fcntl(fd, F_SETOWN, getpid());
1256 static int hpet_start_timer(struct qemu_alarm_timer *t)
1258 struct hpet_info info;
1261 fd = open("/dev/hpet", O_RDONLY);
1266 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1268 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1269 "error, but for better emulation accuracy type:\n"
1270 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1274 /* Check capabilities */
1275 r = ioctl(fd, HPET_INFO, &info);
1279 /* Enable periodic mode */
1280 r = ioctl(fd, HPET_EPI, 0);
1281 if (info.hi_flags && (r < 0))
1284 /* Enable interrupt */
1285 r = ioctl(fd, HPET_IE_ON, 0);
1289 enable_sigio_timer(fd);
1290 t->priv = (void *)(long)fd;
1298 static void hpet_stop_timer(struct qemu_alarm_timer *t)
1300 int fd = (long)t->priv;
1305 static int rtc_start_timer(struct qemu_alarm_timer *t)
1309 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1312 if (ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1313 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1314 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1315 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1318 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1324 enable_sigio_timer(rtc_fd);
1326 t->priv = (void *)(long)rtc_fd;
1331 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1333 int rtc_fd = (long)t->priv;
1338 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1342 struct sigaction act;
1344 sigfillset(&act.sa_mask);
1346 act.sa_handler = host_alarm_handler;
1348 sigaction(SIGALRM, &act, NULL);
1350 ev.sigev_value.sival_int = 0;
1351 ev.sigev_notify = SIGEV_SIGNAL;
1352 ev.sigev_signo = SIGALRM;
1354 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1355 perror("timer_create");
1357 /* disable dynticks */
1358 fprintf(stderr, "Dynamic Ticks disabled\n");
1363 t->priv = (void *)host_timer;
1368 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1370 timer_t host_timer = (timer_t)t->priv;
1372 timer_delete(host_timer);
1375 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1377 timer_t host_timer = (timer_t)t->priv;
1378 struct itimerspec timeout;
1379 int64_t nearest_delta_us = INT64_MAX;
1382 if (!active_timers[QEMU_TIMER_REALTIME] &&
1383 !active_timers[QEMU_TIMER_VIRTUAL])
1386 nearest_delta_us = qemu_next_deadline();
1388 /* check whether a timer is already running */
1389 if (timer_gettime(host_timer, &timeout)) {
1391 fprintf(stderr, "Internal timer error: aborting\n");
1394 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1395 if (current_us && current_us <= nearest_delta_us)
1398 timeout.it_interval.tv_sec = 0;
1399 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1400 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1401 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1402 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1404 fprintf(stderr, "Internal timer error: aborting\n");
1409 #endif /* defined(__linux__) */
1411 static int unix_start_timer(struct qemu_alarm_timer *t)
1413 struct sigaction act;
1414 struct itimerval itv;
1418 sigfillset(&act.sa_mask);
1420 act.sa_handler = host_alarm_handler;
1422 sigaction(SIGALRM, &act, NULL);
1424 itv.it_interval.tv_sec = 0;
1425 /* for i386 kernel 2.6 to get 1 ms */
1426 itv.it_interval.tv_usec = 999;
1427 itv.it_value.tv_sec = 0;
1428 itv.it_value.tv_usec = 10 * 1000;
1430 err = setitimer(ITIMER_REAL, &itv, NULL);
1437 static void unix_stop_timer(struct qemu_alarm_timer *t)
1439 struct itimerval itv;
1441 memset(&itv, 0, sizeof(itv));
1442 setitimer(ITIMER_REAL, &itv, NULL);
1445 #endif /* !defined(_WIN32) */
1449 static int win32_start_timer(struct qemu_alarm_timer *t)
1452 struct qemu_alarm_win32 *data = t->priv;
1455 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1456 if (!data->host_alarm) {
1457 perror("Failed CreateEvent");
1461 memset(&tc, 0, sizeof(tc));
1462 timeGetDevCaps(&tc, sizeof(tc));
1464 if (data->period < tc.wPeriodMin)
1465 data->period = tc.wPeriodMin;
1467 timeBeginPeriod(data->period);
1469 flags = TIME_CALLBACK_FUNCTION;
1470 if (alarm_has_dynticks(t))
1471 flags |= TIME_ONESHOT;
1473 flags |= TIME_PERIODIC;
1475 data->timerId = timeSetEvent(1, // interval (ms)
1476 data->period, // resolution
1477 host_alarm_handler, // function
1478 (DWORD)t, // parameter
1481 if (!data->timerId) {
1482 perror("Failed to initialize win32 alarm timer");
1484 timeEndPeriod(data->period);
1485 CloseHandle(data->host_alarm);
1489 qemu_add_wait_object(data->host_alarm, NULL, NULL);
1494 static void win32_stop_timer(struct qemu_alarm_timer *t)
1496 struct qemu_alarm_win32 *data = t->priv;
1498 timeKillEvent(data->timerId);
1499 timeEndPeriod(data->period);
1501 CloseHandle(data->host_alarm);
1504 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1506 struct qemu_alarm_win32 *data = t->priv;
1507 uint64_t nearest_delta_us;
1509 if (!active_timers[QEMU_TIMER_REALTIME] &&
1510 !active_timers[QEMU_TIMER_VIRTUAL])
1513 nearest_delta_us = qemu_next_deadline();
1514 nearest_delta_us /= 1000;
1516 timeKillEvent(data->timerId);
1518 data->timerId = timeSetEvent(1,
1522 TIME_ONESHOT | TIME_PERIODIC);
1524 if (!data->timerId) {
1525 perror("Failed to re-arm win32 alarm timer");
1527 timeEndPeriod(data->period);
1528 CloseHandle(data->host_alarm);
1535 static void init_timer_alarm(void)
1537 struct qemu_alarm_timer *t;
1540 for (i = 0; alarm_timers[i].name; i++) {
1541 t = &alarm_timers[i];
1549 fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1550 fprintf(stderr, "Terminating\n");
1557 static void quit_timers(void)
1559 alarm_timer->stop(alarm_timer);
1563 /***********************************************************/
1564 /* character device */
1566 static void qemu_chr_event(CharDriverState *s, int event)
1570 s->chr_event(s->handler_opaque, event);
1573 static void qemu_chr_reset_bh(void *opaque)
1575 CharDriverState *s = opaque;
1576 qemu_chr_event(s, CHR_EVENT_RESET);
1577 qemu_bh_delete(s->bh);
1581 void qemu_chr_reset(CharDriverState *s)
1583 if (s->bh == NULL) {
1584 s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1585 qemu_bh_schedule(s->bh);
1589 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1591 return s->chr_write(s, buf, len);
1594 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1598 return s->chr_ioctl(s, cmd, arg);
1601 int qemu_chr_can_read(CharDriverState *s)
1603 if (!s->chr_can_read)
1605 return s->chr_can_read(s->handler_opaque);
1608 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1610 s->chr_read(s->handler_opaque, buf, len);
1613 void qemu_chr_accept_input(CharDriverState *s)
1615 if (s->chr_accept_input)
1616 s->chr_accept_input(s);
1619 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1624 vsnprintf(buf, sizeof(buf), fmt, ap);
1625 qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1629 void qemu_chr_send_event(CharDriverState *s, int event)
1631 if (s->chr_send_event)
1632 s->chr_send_event(s, event);
1635 void qemu_chr_add_handlers(CharDriverState *s,
1636 IOCanRWHandler *fd_can_read,
1637 IOReadHandler *fd_read,
1638 IOEventHandler *fd_event,
1641 s->chr_can_read = fd_can_read;
1642 s->chr_read = fd_read;
1643 s->chr_event = fd_event;
1644 s->handler_opaque = opaque;
1645 if (s->chr_update_read_handler)
1646 s->chr_update_read_handler(s);
1649 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1654 static CharDriverState *qemu_chr_open_null(void)
1656 CharDriverState *chr;
1658 chr = qemu_mallocz(sizeof(CharDriverState));
1661 chr->chr_write = null_chr_write;
1665 /* MUX driver for serial I/O splitting */
1666 static int term_timestamps;
1667 static int64_t term_timestamps_start;
1669 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1670 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1672 IOCanRWHandler *chr_can_read[MAX_MUX];
1673 IOReadHandler *chr_read[MAX_MUX];
1674 IOEventHandler *chr_event[MAX_MUX];
1675 void *ext_opaque[MAX_MUX];
1676 CharDriverState *drv;
1677 unsigned char buffer[MUX_BUFFER_SIZE];
1681 int term_got_escape;
1686 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1688 MuxDriver *d = chr->opaque;
1690 if (!term_timestamps) {
1691 ret = d->drv->chr_write(d->drv, buf, len);
1696 for(i = 0; i < len; i++) {
1697 ret += d->drv->chr_write(d->drv, buf+i, 1);
1698 if (buf[i] == '\n') {
1704 if (term_timestamps_start == -1)
1705 term_timestamps_start = ti;
1706 ti -= term_timestamps_start;
1707 secs = ti / 1000000000;
1708 snprintf(buf1, sizeof(buf1),
1709 "[%02d:%02d:%02d.%03d] ",
1713 (int)((ti / 1000000) % 1000));
1714 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1721 static char *mux_help[] = {
1722 "% h print this help\n\r",
1723 "% x exit emulator\n\r",
1724 "% s save disk data back to file (if -snapshot)\n\r",
1725 "% t toggle console timestamps\n\r"
1726 "% b send break (magic sysrq)\n\r",
1727 "% c switch between console and monitor\n\r",
1732 static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1733 static void mux_print_help(CharDriverState *chr)
1736 char ebuf[15] = "Escape-Char";
1737 char cbuf[50] = "\n\r";
1739 if (term_escape_char > 0 && term_escape_char < 26) {
1740 sprintf(cbuf,"\n\r");
1741 sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1743 sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1746 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1747 for (i = 0; mux_help[i] != NULL; i++) {
1748 for (j=0; mux_help[i][j] != '\0'; j++) {
1749 if (mux_help[i][j] == '%')
1750 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1752 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1757 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1759 if (d->term_got_escape) {
1760 d->term_got_escape = 0;
1761 if (ch == term_escape_char)
1766 mux_print_help(chr);
1770 char *term = "QEMU: Terminated\n\r";
1771 chr->chr_write(chr,(uint8_t *)term,strlen(term));
1778 for (i = 0; i < nb_drives; i++) {
1779 bdrv_commit(drives_table[i].bdrv);
1784 qemu_chr_event(chr, CHR_EVENT_BREAK);
1787 /* Switch to the next registered device */
1789 if (chr->focus >= d->mux_cnt)
1793 term_timestamps = !term_timestamps;
1794 term_timestamps_start = -1;
1797 } else if (ch == term_escape_char) {
1798 d->term_got_escape = 1;
1806 static void mux_chr_accept_input(CharDriverState *chr)
1809 MuxDriver *d = chr->opaque;
1811 while (d->prod != d->cons &&
1812 d->chr_can_read[m] &&
1813 d->chr_can_read[m](d->ext_opaque[m])) {
1814 d->chr_read[m](d->ext_opaque[m],
1815 &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1819 static int mux_chr_can_read(void *opaque)
1821 CharDriverState *chr = opaque;
1822 MuxDriver *d = chr->opaque;
1824 if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1826 if (d->chr_can_read[chr->focus])
1827 return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1831 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1833 CharDriverState *chr = opaque;
1834 MuxDriver *d = chr->opaque;
1838 mux_chr_accept_input (opaque);
1840 for(i = 0; i < size; i++)
1841 if (mux_proc_byte(chr, d, buf[i])) {
1842 if (d->prod == d->cons &&
1843 d->chr_can_read[m] &&
1844 d->chr_can_read[m](d->ext_opaque[m]))
1845 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
1847 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
1851 static void mux_chr_event(void *opaque, int event)
1853 CharDriverState *chr = opaque;
1854 MuxDriver *d = chr->opaque;
1857 /* Send the event to all registered listeners */
1858 for (i = 0; i < d->mux_cnt; i++)
1859 if (d->chr_event[i])
1860 d->chr_event[i](d->ext_opaque[i], event);
1863 static void mux_chr_update_read_handler(CharDriverState *chr)
1865 MuxDriver *d = chr->opaque;
1867 if (d->mux_cnt >= MAX_MUX) {
1868 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1871 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1872 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1873 d->chr_read[d->mux_cnt] = chr->chr_read;
1874 d->chr_event[d->mux_cnt] = chr->chr_event;
1875 /* Fix up the real driver with mux routines */
1876 if (d->mux_cnt == 0) {
1877 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1878 mux_chr_event, chr);
1880 chr->focus = d->mux_cnt;
1884 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1886 CharDriverState *chr;
1889 chr = qemu_mallocz(sizeof(CharDriverState));
1892 d = qemu_mallocz(sizeof(MuxDriver));
1901 chr->chr_write = mux_chr_write;
1902 chr->chr_update_read_handler = mux_chr_update_read_handler;
1903 chr->chr_accept_input = mux_chr_accept_input;
1910 static void socket_cleanup(void)
1915 static int socket_init(void)
1920 ret = WSAStartup(MAKEWORD(2,2), &Data);
1922 err = WSAGetLastError();
1923 fprintf(stderr, "WSAStartup: %d\n", err);
1926 atexit(socket_cleanup);
1930 static int send_all(int fd, const uint8_t *buf, int len1)
1936 ret = send(fd, buf, len, 0);
1939 errno = WSAGetLastError();
1940 if (errno != WSAEWOULDBLOCK) {
1943 } else if (ret == 0) {
1953 void socket_set_nonblock(int fd)
1955 unsigned long opt = 1;
1956 ioctlsocket(fd, FIONBIO, &opt);
1961 static int unix_write(int fd, const uint8_t *buf, int len1)
1967 ret = write(fd, buf, len);
1969 if (errno != EINTR && errno != EAGAIN)
1971 } else if (ret == 0) {
1981 static inline int send_all(int fd, const uint8_t *buf, int len1)
1983 return unix_write(fd, buf, len1);
1986 void socket_set_nonblock(int fd)
1988 fcntl(fd, F_SETFL, O_NONBLOCK);
1990 #endif /* !_WIN32 */
1999 #define STDIO_MAX_CLIENTS 1
2000 static int stdio_nb_clients = 0;
2002 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2004 FDCharDriver *s = chr->opaque;
2005 return unix_write(s->fd_out, buf, len);
2008 static int fd_chr_read_poll(void *opaque)
2010 CharDriverState *chr = opaque;
2011 FDCharDriver *s = chr->opaque;
2013 s->max_size = qemu_chr_can_read(chr);
2017 static void fd_chr_read(void *opaque)
2019 CharDriverState *chr = opaque;
2020 FDCharDriver *s = chr->opaque;
2025 if (len > s->max_size)
2029 size = read(s->fd_in, buf, len);
2031 /* FD has been closed. Remove it from the active list. */
2032 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2036 qemu_chr_read(chr, buf, size);
2040 static void fd_chr_update_read_handler(CharDriverState *chr)
2042 FDCharDriver *s = chr->opaque;
2044 if (s->fd_in >= 0) {
2045 if (nographic && s->fd_in == 0) {
2047 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2048 fd_chr_read, NULL, chr);
2053 static void fd_chr_close(struct CharDriverState *chr)
2055 FDCharDriver *s = chr->opaque;
2057 if (s->fd_in >= 0) {
2058 if (nographic && s->fd_in == 0) {
2060 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2067 /* open a character device to a unix fd */
2068 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2070 CharDriverState *chr;
2073 chr = qemu_mallocz(sizeof(CharDriverState));
2076 s = qemu_mallocz(sizeof(FDCharDriver));
2084 chr->chr_write = fd_chr_write;
2085 chr->chr_update_read_handler = fd_chr_update_read_handler;
2086 chr->chr_close = fd_chr_close;
2088 qemu_chr_reset(chr);
2093 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2097 TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2100 return qemu_chr_open_fd(-1, fd_out);
2103 static CharDriverState *qemu_chr_open_pipe(const char *filename)
2106 char filename_in[256], filename_out[256];
2108 snprintf(filename_in, 256, "%s.in", filename);
2109 snprintf(filename_out, 256, "%s.out", filename);
2110 TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2111 TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2112 if (fd_in < 0 || fd_out < 0) {
2117 TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2121 return qemu_chr_open_fd(fd_in, fd_out);
2125 /* for STDIO, we handle the case where several clients use it
2128 #define TERM_FIFO_MAX_SIZE 1
2130 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2131 static int term_fifo_size;
2133 static int stdio_read_poll(void *opaque)
2135 CharDriverState *chr = opaque;
2137 /* try to flush the queue if needed */
2138 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2139 qemu_chr_read(chr, term_fifo, 1);
2142 /* see if we can absorb more chars */
2143 if (term_fifo_size == 0)
2149 static void stdio_read(void *opaque)
2153 CharDriverState *chr = opaque;
2155 size = read(0, buf, 1);
2157 /* stdin has been closed. Remove it from the active list. */
2158 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2162 if (qemu_chr_can_read(chr) > 0) {
2163 qemu_chr_read(chr, buf, 1);
2164 } else if (term_fifo_size == 0) {
2165 term_fifo[term_fifo_size++] = buf[0];
2170 /* init terminal so that we can grab keys */
2171 static struct termios oldtty;
2172 static int old_fd0_flags;
2173 static int term_atexit_done;
2175 static void term_exit(void)
2177 tcsetattr (0, TCSANOW, &oldtty);
2178 fcntl(0, F_SETFL, old_fd0_flags);
2181 static void term_init(void)
2185 tcgetattr (0, &tty);
2187 old_fd0_flags = fcntl(0, F_GETFL);
2189 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2190 |INLCR|IGNCR|ICRNL|IXON);
2191 tty.c_oflag |= OPOST;
2192 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2193 /* if graphical mode, we allow Ctrl-C handling */
2195 tty.c_lflag &= ~ISIG;
2196 tty.c_cflag &= ~(CSIZE|PARENB);
2199 tty.c_cc[VTIME] = 0;
2201 tcsetattr (0, TCSANOW, &tty);
2203 if (!term_atexit_done++)
2206 fcntl(0, F_SETFL, O_NONBLOCK);
2209 static void qemu_chr_close_stdio(struct CharDriverState *chr)
2213 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2217 static CharDriverState *qemu_chr_open_stdio(void)
2219 CharDriverState *chr;
2221 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2223 chr = qemu_chr_open_fd(0, 1);
2224 chr->chr_close = qemu_chr_close_stdio;
2225 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2232 #if defined(__linux__) || defined(__sun__)
2233 static CharDriverState *qemu_chr_open_pty(void)
2236 char slave_name[1024];
2237 int master_fd, slave_fd;
2239 #if defined(__linux__)
2240 /* Not satisfying */
2241 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
2246 /* Disabling local echo and line-buffered output */
2247 tcgetattr (master_fd, &tty);
2248 tty.c_lflag &= ~(ECHO|ICANON|ISIG);
2250 tty.c_cc[VTIME] = 0;
2251 tcsetattr (master_fd, TCSAFLUSH, &tty);
2253 fprintf(stderr, "char device redirected to %s\n", slave_name);
2254 return qemu_chr_open_fd(master_fd, master_fd);
2257 static void tty_serial_init(int fd, int speed,
2258 int parity, int data_bits, int stop_bits)
2264 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2265 speed, parity, data_bits, stop_bits);
2267 tcgetattr (fd, &tty);
2270 if (speed <= 50 * MARGIN)
2272 else if (speed <= 75 * MARGIN)
2274 else if (speed <= 300 * MARGIN)
2276 else if (speed <= 600 * MARGIN)
2278 else if (speed <= 1200 * MARGIN)
2280 else if (speed <= 2400 * MARGIN)
2282 else if (speed <= 4800 * MARGIN)
2284 else if (speed <= 9600 * MARGIN)
2286 else if (speed <= 19200 * MARGIN)
2288 else if (speed <= 38400 * MARGIN)
2290 else if (speed <= 57600 * MARGIN)
2292 else if (speed <= 115200 * MARGIN)
2297 cfsetispeed(&tty, spd);
2298 cfsetospeed(&tty, spd);
2300 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2301 |INLCR|IGNCR|ICRNL|IXON);
2302 tty.c_oflag |= OPOST;
2303 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2304 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2325 tty.c_cflag |= PARENB;
2328 tty.c_cflag |= PARENB | PARODD;
2332 tty.c_cflag |= CSTOPB;
2334 tcsetattr (fd, TCSANOW, &tty);
2337 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2339 FDCharDriver *s = chr->opaque;
2342 case CHR_IOCTL_SERIAL_SET_PARAMS:
2344 QEMUSerialSetParams *ssp = arg;
2345 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2346 ssp->data_bits, ssp->stop_bits);
2349 case CHR_IOCTL_SERIAL_SET_BREAK:
2351 int enable = *(int *)arg;
2353 tcsendbreak(s->fd_in, 1);
2362 static CharDriverState *qemu_chr_open_tty(const char *filename)
2364 CharDriverState *chr;
2367 TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2368 fcntl(fd, F_SETFL, O_NONBLOCK);
2369 tty_serial_init(fd, 115200, 'N', 8, 1);
2370 chr = qemu_chr_open_fd(fd, fd);
2375 chr->chr_ioctl = tty_serial_ioctl;
2376 qemu_chr_reset(chr);
2379 #else /* ! __linux__ && ! __sun__ */
2380 static CharDriverState *qemu_chr_open_pty(void)
2384 #endif /* __linux__ || __sun__ */
2386 #if defined(__linux__)
2390 } ParallelCharDriver;
2392 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2394 if (s->mode != mode) {
2396 if (ioctl(s->fd, PPSETMODE, &m) < 0)
2403 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2405 ParallelCharDriver *drv = chr->opaque;
2410 case CHR_IOCTL_PP_READ_DATA:
2411 if (ioctl(fd, PPRDATA, &b) < 0)
2413 *(uint8_t *)arg = b;
2415 case CHR_IOCTL_PP_WRITE_DATA:
2416 b = *(uint8_t *)arg;
2417 if (ioctl(fd, PPWDATA, &b) < 0)
2420 case CHR_IOCTL_PP_READ_CONTROL:
2421 if (ioctl(fd, PPRCONTROL, &b) < 0)
2423 /* Linux gives only the lowest bits, and no way to know data
2424 direction! For better compatibility set the fixed upper
2426 *(uint8_t *)arg = b | 0xc0;
2428 case CHR_IOCTL_PP_WRITE_CONTROL:
2429 b = *(uint8_t *)arg;
2430 if (ioctl(fd, PPWCONTROL, &b) < 0)
2433 case CHR_IOCTL_PP_READ_STATUS:
2434 if (ioctl(fd, PPRSTATUS, &b) < 0)
2436 *(uint8_t *)arg = b;
2438 case CHR_IOCTL_PP_EPP_READ_ADDR:
2439 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2440 struct ParallelIOArg *parg = arg;
2441 int n = read(fd, parg->buffer, parg->count);
2442 if (n != parg->count) {
2447 case CHR_IOCTL_PP_EPP_READ:
2448 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2449 struct ParallelIOArg *parg = arg;
2450 int n = read(fd, parg->buffer, parg->count);
2451 if (n != parg->count) {
2456 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2457 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2458 struct ParallelIOArg *parg = arg;
2459 int n = write(fd, parg->buffer, parg->count);
2460 if (n != parg->count) {
2465 case CHR_IOCTL_PP_EPP_WRITE:
2466 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2467 struct ParallelIOArg *parg = arg;
2468 int n = write(fd, parg->buffer, parg->count);
2469 if (n != parg->count) {
2480 static void pp_close(CharDriverState *chr)
2482 ParallelCharDriver *drv = chr->opaque;
2485 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2486 ioctl(fd, PPRELEASE);
2491 static CharDriverState *qemu_chr_open_pp(const char *filename)
2493 CharDriverState *chr;
2494 ParallelCharDriver *drv;
2497 TFR(fd = open(filename, O_RDWR));
2501 if (ioctl(fd, PPCLAIM) < 0) {
2506 drv = qemu_mallocz(sizeof(ParallelCharDriver));
2512 drv->mode = IEEE1284_MODE_COMPAT;
2514 chr = qemu_mallocz(sizeof(CharDriverState));
2520 chr->chr_write = null_chr_write;
2521 chr->chr_ioctl = pp_ioctl;
2522 chr->chr_close = pp_close;
2525 qemu_chr_reset(chr);
2529 #endif /* __linux__ */
2535 HANDLE hcom, hrecv, hsend;
2536 OVERLAPPED orecv, osend;
2541 #define NSENDBUF 2048
2542 #define NRECVBUF 2048
2543 #define MAXCONNECT 1
2544 #define NTIMEOUT 5000
2546 static int win_chr_poll(void *opaque);
2547 static int win_chr_pipe_poll(void *opaque);
2549 static void win_chr_close(CharDriverState *chr)
2551 WinCharState *s = chr->opaque;
2554 CloseHandle(s->hsend);
2558 CloseHandle(s->hrecv);
2562 CloseHandle(s->hcom);
2566 qemu_del_polling_cb(win_chr_pipe_poll, chr);
2568 qemu_del_polling_cb(win_chr_poll, chr);
2571 static int win_chr_init(CharDriverState *chr, const char *filename)
2573 WinCharState *s = chr->opaque;
2575 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2580 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2582 fprintf(stderr, "Failed CreateEvent\n");
2585 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2587 fprintf(stderr, "Failed CreateEvent\n");
2591 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2592 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2593 if (s->hcom == INVALID_HANDLE_VALUE) {
2594 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2599 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2600 fprintf(stderr, "Failed SetupComm\n");
2604 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2605 size = sizeof(COMMCONFIG);
2606 GetDefaultCommConfig(filename, &comcfg, &size);
2607 comcfg.dcb.DCBlength = sizeof(DCB);
2608 CommConfigDialog(filename, NULL, &comcfg);
2610 if (!SetCommState(s->hcom, &comcfg.dcb)) {
2611 fprintf(stderr, "Failed SetCommState\n");
2615 if (!SetCommMask(s->hcom, EV_ERR)) {
2616 fprintf(stderr, "Failed SetCommMask\n");
2620 cto.ReadIntervalTimeout = MAXDWORD;
2621 if (!SetCommTimeouts(s->hcom, &cto)) {
2622 fprintf(stderr, "Failed SetCommTimeouts\n");
2626 if (!ClearCommError(s->hcom, &err, &comstat)) {
2627 fprintf(stderr, "Failed ClearCommError\n");
2630 qemu_add_polling_cb(win_chr_poll, chr);
2638 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2640 WinCharState *s = chr->opaque;
2641 DWORD len, ret, size, err;
2644 ZeroMemory(&s->osend, sizeof(s->osend));
2645 s->osend.hEvent = s->hsend;
2648 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2650 ret = WriteFile(s->hcom, buf, len, &size, NULL);
2652 err = GetLastError();
2653 if (err == ERROR_IO_PENDING) {
2654 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2672 static int win_chr_read_poll(CharDriverState *chr)
2674 WinCharState *s = chr->opaque;
2676 s->max_size = qemu_chr_can_read(chr);
2680 static void win_chr_readfile(CharDriverState *chr)
2682 WinCharState *s = chr->opaque;
2687 ZeroMemory(&s->orecv, sizeof(s->orecv));
2688 s->orecv.hEvent = s->hrecv;
2689 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2691 err = GetLastError();
2692 if (err == ERROR_IO_PENDING) {
2693 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2698 qemu_chr_read(chr, buf, size);
2702 static void win_chr_read(CharDriverState *chr)
2704 WinCharState *s = chr->opaque;
2706 if (s->len > s->max_size)
2707 s->len = s->max_size;
2711 win_chr_readfile(chr);
2714 static int win_chr_poll(void *opaque)
2716 CharDriverState *chr = opaque;
2717 WinCharState *s = chr->opaque;
2721 ClearCommError(s->hcom, &comerr, &status);
2722 if (status.cbInQue > 0) {
2723 s->len = status.cbInQue;
2724 win_chr_read_poll(chr);
2731 static CharDriverState *qemu_chr_open_win(const char *filename)
2733 CharDriverState *chr;
2736 chr = qemu_mallocz(sizeof(CharDriverState));
2739 s = qemu_mallocz(sizeof(WinCharState));
2745 chr->chr_write = win_chr_write;
2746 chr->chr_close = win_chr_close;
2748 if (win_chr_init(chr, filename) < 0) {
2753 qemu_chr_reset(chr);
2757 static int win_chr_pipe_poll(void *opaque)
2759 CharDriverState *chr = opaque;
2760 WinCharState *s = chr->opaque;
2763 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2766 win_chr_read_poll(chr);
2773 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2775 WinCharState *s = chr->opaque;
2783 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2785 fprintf(stderr, "Failed CreateEvent\n");
2788 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2790 fprintf(stderr, "Failed CreateEvent\n");
2794 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2795 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2796 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2798 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2799 if (s->hcom == INVALID_HANDLE_VALUE) {
2800 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2805 ZeroMemory(&ov, sizeof(ov));
2806 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2807 ret = ConnectNamedPipe(s->hcom, &ov);
2809 fprintf(stderr, "Failed ConnectNamedPipe\n");
2813 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2815 fprintf(stderr, "Failed GetOverlappedResult\n");
2817 CloseHandle(ov.hEvent);
2824 CloseHandle(ov.hEvent);
2827 qemu_add_polling_cb(win_chr_pipe_poll, chr);
2836 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2838 CharDriverState *chr;
2841 chr = qemu_mallocz(sizeof(CharDriverState));
2844 s = qemu_mallocz(sizeof(WinCharState));
2850 chr->chr_write = win_chr_write;
2851 chr->chr_close = win_chr_close;
2853 if (win_chr_pipe_init(chr, filename) < 0) {
2858 qemu_chr_reset(chr);
2862 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2864 CharDriverState *chr;
2867 chr = qemu_mallocz(sizeof(CharDriverState));
2870 s = qemu_mallocz(sizeof(WinCharState));
2877 chr->chr_write = win_chr_write;
2878 qemu_chr_reset(chr);
2882 static CharDriverState *qemu_chr_open_win_con(const char *filename)
2884 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2887 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2891 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2892 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2893 if (fd_out == INVALID_HANDLE_VALUE)
2896 return qemu_chr_open_win_file(fd_out);
2898 #endif /* !_WIN32 */
2900 /***********************************************************/
2901 /* UDP Net console */
2905 struct sockaddr_in daddr;
2912 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2914 NetCharDriver *s = chr->opaque;
2916 return sendto(s->fd, buf, len, 0,
2917 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2920 static int udp_chr_read_poll(void *opaque)
2922 CharDriverState *chr = opaque;
2923 NetCharDriver *s = chr->opaque;
2925 s->max_size = qemu_chr_can_read(chr);
2927 /* If there were any stray characters in the queue process them
2930 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2931 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2933 s->max_size = qemu_chr_can_read(chr);
2938 static void udp_chr_read(void *opaque)
2940 CharDriverState *chr = opaque;
2941 NetCharDriver *s = chr->opaque;
2943 if (s->max_size == 0)
2945 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2946 s->bufptr = s->bufcnt;
2951 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2952 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2954 s->max_size = qemu_chr_can_read(chr);
2958 static void udp_chr_update_read_handler(CharDriverState *chr)
2960 NetCharDriver *s = chr->opaque;
2963 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
2964 udp_chr_read, NULL, chr);
2968 int parse_host_port(struct sockaddr_in *saddr, const char *str);
2970 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
2972 int parse_host_src_port(struct sockaddr_in *haddr,
2973 struct sockaddr_in *saddr,
2976 static CharDriverState *qemu_chr_open_udp(const char *def)
2978 CharDriverState *chr = NULL;
2979 NetCharDriver *s = NULL;
2981 struct sockaddr_in saddr;
2983 chr = qemu_mallocz(sizeof(CharDriverState));
2986 s = qemu_mallocz(sizeof(NetCharDriver));
2990 fd = socket(PF_INET, SOCK_DGRAM, 0);
2992 perror("socket(PF_INET, SOCK_DGRAM)");
2996 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
2997 printf("Could not parse: %s\n", def);
3001 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3011 chr->chr_write = udp_chr_write;
3012 chr->chr_update_read_handler = udp_chr_update_read_handler;
3025 /***********************************************************/
3026 /* TCP Net console */
3037 static void tcp_chr_accept(void *opaque);
3039 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3041 TCPCharDriver *s = chr->opaque;
3043 return send_all(s->fd, buf, len);
3045 /* XXX: indicate an error ? */
3050 static int tcp_chr_read_poll(void *opaque)
3052 CharDriverState *chr = opaque;
3053 TCPCharDriver *s = chr->opaque;
3056 s->max_size = qemu_chr_can_read(chr);
3061 #define IAC_BREAK 243
3062 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3064 uint8_t *buf, int *size)
3066 /* Handle any telnet client's basic IAC options to satisfy char by
3067 * char mode with no echo. All IAC options will be removed from
3068 * the buf and the do_telnetopt variable will be used to track the
3069 * state of the width of the IAC information.
3071 * IAC commands come in sets of 3 bytes with the exception of the
3072 * "IAC BREAK" command and the double IAC.
3078 for (i = 0; i < *size; i++) {
3079 if (s->do_telnetopt > 1) {
3080 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3081 /* Double IAC means send an IAC */
3085 s->do_telnetopt = 1;
3087 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3088 /* Handle IAC break commands by sending a serial break */
3089 qemu_chr_event(chr, CHR_EVENT_BREAK);
3094 if (s->do_telnetopt >= 4) {
3095 s->do_telnetopt = 1;
3098 if ((unsigned char)buf[i] == IAC) {
3099 s->do_telnetopt = 2;
3110 static void tcp_chr_read(void *opaque)
3112 CharDriverState *chr = opaque;
3113 TCPCharDriver *s = chr->opaque;
3117 if (!s->connected || s->max_size <= 0)
3120 if (len > s->max_size)
3122 size = recv(s->fd, buf, len, 0);
3124 /* connection closed */
3126 if (s->listen_fd >= 0) {
3127 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3129 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3132 } else if (size > 0) {
3133 if (s->do_telnetopt)
3134 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3136 qemu_chr_read(chr, buf, size);
3140 static void tcp_chr_connect(void *opaque)
3142 CharDriverState *chr = opaque;
3143 TCPCharDriver *s = chr->opaque;
3146 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3147 tcp_chr_read, NULL, chr);
3148 qemu_chr_reset(chr);
3151 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3152 static void tcp_chr_telnet_init(int fd)
3155 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3156 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3157 send(fd, (char *)buf, 3, 0);
3158 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3159 send(fd, (char *)buf, 3, 0);
3160 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3161 send(fd, (char *)buf, 3, 0);
3162 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3163 send(fd, (char *)buf, 3, 0);
3166 static void socket_set_nodelay(int fd)
3169 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3172 static void tcp_chr_accept(void *opaque)
3174 CharDriverState *chr = opaque;
3175 TCPCharDriver *s = chr->opaque;
3176 struct sockaddr_in saddr;
3178 struct sockaddr_un uaddr;
3180 struct sockaddr *addr;
3187 len = sizeof(uaddr);
3188 addr = (struct sockaddr *)&uaddr;
3192 len = sizeof(saddr);
3193 addr = (struct sockaddr *)&saddr;
3195 fd = accept(s->listen_fd, addr, &len);
3196 if (fd < 0 && errno != EINTR) {
3198 } else if (fd >= 0) {
3199 if (s->do_telnetopt)
3200 tcp_chr_telnet_init(fd);
3204 socket_set_nonblock(fd);
3206 socket_set_nodelay(fd);
3208 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3209 tcp_chr_connect(chr);
3212 static void tcp_chr_close(CharDriverState *chr)
3214 TCPCharDriver *s = chr->opaque;
3217 if (s->listen_fd >= 0)
3218 closesocket(s->listen_fd);
3222 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3226 CharDriverState *chr = NULL;
3227 TCPCharDriver *s = NULL;
3228 int fd = -1, ret, err, val;
3230 int is_waitconnect = 1;
3233 struct sockaddr_in saddr;
3235 struct sockaddr_un uaddr;
3237 struct sockaddr *addr;
3242 addr = (struct sockaddr *)&uaddr;
3243 addrlen = sizeof(uaddr);
3244 if (parse_unix_path(&uaddr, host_str) < 0)
3249 addr = (struct sockaddr *)&saddr;
3250 addrlen = sizeof(saddr);
3251 if (parse_host_port(&saddr, host_str) < 0)
3256 while((ptr = strchr(ptr,','))) {
3258 if (!strncmp(ptr,"server",6)) {
3260 } else if (!strncmp(ptr,"nowait",6)) {
3262 } else if (!strncmp(ptr,"nodelay",6)) {
3265 printf("Unknown option: %s\n", ptr);
3272 chr = qemu_mallocz(sizeof(CharDriverState));
3275 s = qemu_mallocz(sizeof(TCPCharDriver));
3281 fd = socket(PF_UNIX, SOCK_STREAM, 0);
3284 fd = socket(PF_INET, SOCK_STREAM, 0);
3289 if (!is_waitconnect)
3290 socket_set_nonblock(fd);
3295 s->is_unix = is_unix;
3296 s->do_nodelay = do_nodelay && !is_unix;
3299 chr->chr_write = tcp_chr_write;
3300 chr->chr_close = tcp_chr_close;
3303 /* allow fast reuse */
3307 strncpy(path, uaddr.sun_path, 108);
3314 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3317 ret = bind(fd, addr, addrlen);
3321 ret = listen(fd, 0);
3326 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3328 s->do_telnetopt = 1;
3331 ret = connect(fd, addr, addrlen);
3333 err = socket_error();
3334 if (err == EINTR || err == EWOULDBLOCK) {
3335 } else if (err == EINPROGRESS) {
3338 } else if (err == WSAEALREADY) {
3350 socket_set_nodelay(fd);
3352 tcp_chr_connect(chr);
3354 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3357 if (is_listen && is_waitconnect) {
3358 printf("QEMU waiting for connection on: %s\n", host_str);
3359 tcp_chr_accept(chr);
3360 socket_set_nonblock(s->listen_fd);
3372 CharDriverState *qemu_chr_open(const char *filename)
3376 if (!strcmp(filename, "vc")) {
3377 return text_console_init(&display_state, 0);
3378 } else if (strstart(filename, "vc:", &p)) {
3379 return text_console_init(&display_state, p);
3380 } else if (!strcmp(filename, "null")) {
3381 return qemu_chr_open_null();
3383 if (strstart(filename, "tcp:", &p)) {
3384 return qemu_chr_open_tcp(p, 0, 0);
3386 if (strstart(filename, "telnet:", &p)) {
3387 return qemu_chr_open_tcp(p, 1, 0);
3389 if (strstart(filename, "udp:", &p)) {
3390 return qemu_chr_open_udp(p);
3392 if (strstart(filename, "mon:", &p)) {
3393 CharDriverState *drv = qemu_chr_open(p);
3395 drv = qemu_chr_open_mux(drv);
3396 monitor_init(drv, !nographic);
3399 printf("Unable to open driver: %s\n", p);
3403 if (strstart(filename, "unix:", &p)) {
3404 return qemu_chr_open_tcp(p, 0, 1);
3405 } else if (strstart(filename, "file:", &p)) {
3406 return qemu_chr_open_file_out(p);
3407 } else if (strstart(filename, "pipe:", &p)) {
3408 return qemu_chr_open_pipe(p);
3409 } else if (!strcmp(filename, "pty")) {
3410 return qemu_chr_open_pty();
3411 } else if (!strcmp(filename, "stdio")) {
3412 return qemu_chr_open_stdio();
3414 #if defined(__linux__)
3415 if (strstart(filename, "/dev/parport", NULL)) {
3416 return qemu_chr_open_pp(filename);
3419 #if defined(__linux__) || defined(__sun__)
3420 if (strstart(filename, "/dev/", NULL)) {
3421 return qemu_chr_open_tty(filename);
3425 if (strstart(filename, "COM", NULL)) {
3426 return qemu_chr_open_win(filename);
3428 if (strstart(filename, "pipe:", &p)) {
3429 return qemu_chr_open_win_pipe(p);
3431 if (strstart(filename, "con:", NULL)) {
3432 return qemu_chr_open_win_con(filename);
3434 if (strstart(filename, "file:", &p)) {
3435 return qemu_chr_open_win_file_out(p);
3443 void qemu_chr_close(CharDriverState *chr)
3446 chr->chr_close(chr);
3450 /***********************************************************/
3451 /* network device redirectors */
3453 __attribute__ (( unused ))
3454 static void hex_dump(FILE *f, const uint8_t *buf, int size)
3458 for(i=0;i<size;i+=16) {
3462 fprintf(f, "%08x ", i);
3465 fprintf(f, " %02x", buf[i+j]);
3470 for(j=0;j<len;j++) {
3472 if (c < ' ' || c > '~')
3474 fprintf(f, "%c", c);
3480 static int parse_macaddr(uint8_t *macaddr, const char *p)
3487 offset = strtol(p, &last_char, 0);
3488 if (0 == errno && '\0' == *last_char &&
3489 offset >= 0 && offset <= 0xFFFFFF) {
3490 macaddr[3] = (offset & 0xFF0000) >> 16;
3491 macaddr[4] = (offset & 0xFF00) >> 8;
3492 macaddr[5] = offset & 0xFF;
3495 for(i = 0; i < 6; i++) {
3496 macaddr[i] = strtol(p, (char **)&p, 16);
3501 if (*p != ':' && *p != '-')
3512 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3517 p1 = strchr(p, sep);
3523 if (len > buf_size - 1)
3525 memcpy(buf, p, len);
3532 int parse_host_src_port(struct sockaddr_in *haddr,
3533 struct sockaddr_in *saddr,
3534 const char *input_str)
3536 char *str = strdup(input_str);
3537 char *host_str = str;
3542 * Chop off any extra arguments at the end of the string which
3543 * would start with a comma, then fill in the src port information
3544 * if it was provided else use the "any address" and "any port".
3546 if ((ptr = strchr(str,',')))
3549 if ((src_str = strchr(input_str,'@'))) {
3554 if (parse_host_port(haddr, host_str) < 0)
3557 if (!src_str || *src_str == '\0')
3560 if (parse_host_port(saddr, src_str) < 0)
3571 int parse_host_port(struct sockaddr_in *saddr, const char *str)
3579 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3581 saddr->sin_family = AF_INET;
3582 if (buf[0] == '\0') {
3583 saddr->sin_addr.s_addr = 0;
3585 if (isdigit(buf[0])) {
3586 if (!inet_aton(buf, &saddr->sin_addr))
3589 if ((he = gethostbyname(buf)) == NULL)
3591 saddr->sin_addr = *(struct in_addr *)he->h_addr;
3594 port = strtol(p, (char **)&r, 0);
3597 saddr->sin_port = htons(port);
3602 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3607 len = MIN(108, strlen(str));
3608 p = strchr(str, ',');
3610 len = MIN(len, p - str);
3612 memset(uaddr, 0, sizeof(*uaddr));
3614 uaddr->sun_family = AF_UNIX;
3615 memcpy(uaddr->sun_path, str, len);
3621 /* find or alloc a new VLAN */
3622 VLANState *qemu_find_vlan(int id)
3624 VLANState **pvlan, *vlan;
3625 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3629 vlan = qemu_mallocz(sizeof(VLANState));
3634 pvlan = &first_vlan;
3635 while (*pvlan != NULL)
3636 pvlan = &(*pvlan)->next;
3641 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3642 IOReadHandler *fd_read,
3643 IOCanRWHandler *fd_can_read,
3646 VLANClientState *vc, **pvc;
3647 vc = qemu_mallocz(sizeof(VLANClientState));
3650 vc->fd_read = fd_read;
3651 vc->fd_can_read = fd_can_read;
3652 vc->opaque = opaque;
3656 pvc = &vlan->first_client;
3657 while (*pvc != NULL)
3658 pvc = &(*pvc)->next;
3663 int qemu_can_send_packet(VLANClientState *vc1)
3665 VLANState *vlan = vc1->vlan;
3666 VLANClientState *vc;
3668 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3670 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3677 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3679 VLANState *vlan = vc1->vlan;
3680 VLANClientState *vc;
3683 printf("vlan %d send:\n", vlan->id);
3684 hex_dump(stdout, buf, size);
3686 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3688 vc->fd_read(vc->opaque, buf, size);
3693 #if defined(CONFIG_SLIRP)
3695 /* slirp network adapter */
3697 static int slirp_inited;
3698 static VLANClientState *slirp_vc;
3700 int slirp_can_output(void)
3702 return !slirp_vc || qemu_can_send_packet(slirp_vc);
3705 void slirp_output(const uint8_t *pkt, int pkt_len)
3708 printf("slirp output:\n");
3709 hex_dump(stdout, pkt, pkt_len);
3713 qemu_send_packet(slirp_vc, pkt, pkt_len);
3716 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3719 printf("slirp input:\n");
3720 hex_dump(stdout, buf, size);
3722 slirp_input(buf, size);
3725 static int net_slirp_init(VLANState *vlan)
3727 if (!slirp_inited) {
3731 slirp_vc = qemu_new_vlan_client(vlan,
3732 slirp_receive, NULL, NULL);
3733 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3737 static void net_slirp_redir(const char *redir_str)
3742 struct in_addr guest_addr;
3743 int host_port, guest_port;
3745 if (!slirp_inited) {
3751 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3753 if (!strcmp(buf, "tcp")) {
3755 } else if (!strcmp(buf, "udp")) {
3761 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3763 host_port = strtol(buf, &r, 0);
3767 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3769 if (buf[0] == '\0') {
3770 pstrcpy(buf, sizeof(buf), "10.0.2.15");
3772 if (!inet_aton(buf, &guest_addr))
3775 guest_port = strtol(p, &r, 0);
3779 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3780 fprintf(stderr, "qemu: could not set up redirection\n");
3785 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3793 static void erase_dir(char *dir_name)
3797 char filename[1024];
3799 /* erase all the files in the directory */
3800 if ((d = opendir(dir_name)) != 0) {
3805 if (strcmp(de->d_name, ".") != 0 &&
3806 strcmp(de->d_name, "..") != 0) {
3807 snprintf(filename, sizeof(filename), "%s/%s",
3808 smb_dir, de->d_name);
3809 if (unlink(filename) != 0) /* is it a directory? */
3810 erase_dir(filename);
3818 /* automatic user mode samba server configuration */
3819 static void smb_exit(void)
3824 /* automatic user mode samba server configuration */
3825 static void net_slirp_smb(const char *exported_dir)
3827 char smb_conf[1024];
3828 char smb_cmdline[1024];
3831 if (!slirp_inited) {
3836 /* XXX: better tmp dir construction */
3837 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3838 if (mkdir(smb_dir, 0700) < 0) {
3839 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3842 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3844 f = fopen(smb_conf, "w");
3846 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3853 "socket address=127.0.0.1\n"
3854 "pid directory=%s\n"
3855 "lock directory=%s\n"
3856 "log file=%s/log.smbd\n"
3857 "smb passwd file=%s/smbpasswd\n"
3858 "security = share\n"
3873 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3874 SMBD_COMMAND, smb_conf);
3876 slirp_add_exec(0, smb_cmdline, 4, 139);
3879 #endif /* !defined(_WIN32) */
3880 void do_info_slirp(void)
3885 #endif /* CONFIG_SLIRP */
3887 #if !defined(_WIN32)
3889 typedef struct TAPState {
3890 VLANClientState *vc;
3892 char down_script[1024];
3895 static void tap_receive(void *opaque, const uint8_t *buf, int size)
3897 TAPState *s = opaque;
3900 ret = write(s->fd, buf, size);
3901 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3908 static void tap_send(void *opaque)
3910 TAPState *s = opaque;
3917 sbuf.maxlen = sizeof(buf);
3919 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
3921 size = read(s->fd, buf, sizeof(buf));
3924 qemu_send_packet(s->vc, buf, size);
3930 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3934 s = qemu_mallocz(sizeof(TAPState));
3938 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3939 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3940 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3944 #if defined (_BSD) || defined (__FreeBSD_kernel__)
3945 static int tap_open(char *ifname, int ifname_size)
3951 TFR(fd = open("/dev/tap", O_RDWR));
3953 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
3958 dev = devname(s.st_rdev, S_IFCHR);
3959 pstrcpy(ifname, ifname_size, dev);
3961 fcntl(fd, F_SETFL, O_NONBLOCK);
3964 #elif defined(__sun__)
3965 #define TUNNEWPPA (('T'<<16) | 0x0001)
3967 * Allocate TAP device, returns opened fd.
3968 * Stores dev name in the first arg(must be large enough).
3970 int tap_alloc(char *dev)
3972 int tap_fd, if_fd, ppa = -1;
3973 static int ip_fd = 0;
3976 static int arp_fd = 0;
3977 int ip_muxid, arp_muxid;
3978 struct strioctl strioc_if, strioc_ppa;
3979 int link_type = I_PLINK;;
3981 char actual_name[32] = "";
3983 memset(&ifr, 0x0, sizeof(ifr));
3987 while( *ptr && !isdigit((int)*ptr) ) ptr++;
3991 /* Check if IP device was opened */
3995 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
3997 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4001 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4003 syslog(LOG_ERR, "Can't open /dev/tap");
4007 /* Assign a new PPA and get its unit number. */
4008 strioc_ppa.ic_cmd = TUNNEWPPA;
4009 strioc_ppa.ic_timout = 0;
4010 strioc_ppa.ic_len = sizeof(ppa);
4011 strioc_ppa.ic_dp = (char *)&ppa;
4012 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4013 syslog (LOG_ERR, "Can't assign new interface");
4015 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4017 syslog(LOG_ERR, "Can't open /dev/tap (2)");
4020 if(ioctl(if_fd, I_PUSH, "ip") < 0){
4021 syslog(LOG_ERR, "Can't push IP module");
4025 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4026 syslog(LOG_ERR, "Can't get flags\n");
4028 snprintf (actual_name, 32, "tap%d", ppa);
4029 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4032 /* Assign ppa according to the unit number returned by tun device */
4034 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4035 syslog (LOG_ERR, "Can't set PPA %d", ppa);
4036 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4037 syslog (LOG_ERR, "Can't get flags\n");
4038 /* Push arp module to if_fd */
4039 if (ioctl (if_fd, I_PUSH, "arp") < 0)
4040 syslog (LOG_ERR, "Can't push ARP module (2)");
4042 /* Push arp module to ip_fd */
4043 if (ioctl (ip_fd, I_POP, NULL) < 0)
4044 syslog (LOG_ERR, "I_POP failed\n");
4045 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4046 syslog (LOG_ERR, "Can't push ARP module (3)\n");
4048 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4050 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4052 /* Set ifname to arp */
4053 strioc_if.ic_cmd = SIOCSLIFNAME;
4054 strioc_if.ic_timout = 0;
4055 strioc_if.ic_len = sizeof(ifr);
4056 strioc_if.ic_dp = (char *)𝔦
4057 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4058 syslog (LOG_ERR, "Can't set ifname to arp\n");
4061 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4062 syslog(LOG_ERR, "Can't link TAP device to IP");
4066 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4067 syslog (LOG_ERR, "Can't link TAP device to ARP");
4071 memset(&ifr, 0x0, sizeof(ifr));
4072 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4073 ifr.lifr_ip_muxid = ip_muxid;
4074 ifr.lifr_arp_muxid = arp_muxid;
4076 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4078 ioctl (ip_fd, I_PUNLINK , arp_muxid);
4079 ioctl (ip_fd, I_PUNLINK, ip_muxid);
4080 syslog (LOG_ERR, "Can't set multiplexor id");
4083 sprintf(dev, "tap%d", ppa);
4087 static int tap_open(char *ifname, int ifname_size)
4091 if( (fd = tap_alloc(dev)) < 0 ){
4092 fprintf(stderr, "Cannot allocate TAP device\n");
4095 pstrcpy(ifname, ifname_size, dev);
4096 fcntl(fd, F_SETFL, O_NONBLOCK);
4100 static int tap_open(char *ifname, int ifname_size)
4105 TFR(fd = open("/dev/net/tun", O_RDWR));
4107 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4110 memset(&ifr, 0, sizeof(ifr));
4111 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4112 if (ifname[0] != '\0')
4113 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4115 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4116 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4118 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4122 pstrcpy(ifname, ifname_size, ifr.ifr_name);
4123 fcntl(fd, F_SETFL, O_NONBLOCK);
4128 static int launch_script(const char *setup_script, const char *ifname, int fd)
4134 /* try to launch network script */
4138 int open_max = sysconf (_SC_OPEN_MAX), i;
4139 for (i = 0; i < open_max; i++)
4140 if (i != STDIN_FILENO &&
4141 i != STDOUT_FILENO &&
4142 i != STDERR_FILENO &&
4147 *parg++ = (char *)setup_script;
4148 *parg++ = (char *)ifname;
4150 execv(setup_script, args);
4153 while (waitpid(pid, &status, 0) != pid);
4154 if (!WIFEXITED(status) ||
4155 WEXITSTATUS(status) != 0) {
4156 fprintf(stderr, "%s: could not launch network script\n",
4164 static int net_tap_init(VLANState *vlan, const char *ifname1,
4165 const char *setup_script, const char *down_script)
4171 if (ifname1 != NULL)
4172 pstrcpy(ifname, sizeof(ifname), ifname1);
4175 TFR(fd = tap_open(ifname, sizeof(ifname)));
4179 if (!setup_script || !strcmp(setup_script, "no"))
4181 if (setup_script[0] != '\0') {
4182 if (launch_script(setup_script, ifname, fd))
4185 s = net_tap_fd_init(vlan, fd);
4188 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4189 "tap: ifname=%s setup_script=%s", ifname, setup_script);
4190 if (down_script && strcmp(down_script, "no"))
4191 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4195 #endif /* !_WIN32 */
4197 /* network connection */
4198 typedef struct NetSocketState {
4199 VLANClientState *vc;
4201 int state; /* 0 = getting length, 1 = getting data */
4205 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4208 typedef struct NetSocketListenState {
4211 } NetSocketListenState;
4213 /* XXX: we consider we can send the whole packet without blocking */
4214 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4216 NetSocketState *s = opaque;
4220 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4221 send_all(s->fd, buf, size);
4224 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4226 NetSocketState *s = opaque;
4227 sendto(s->fd, buf, size, 0,
4228 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4231 static void net_socket_send(void *opaque)
4233 NetSocketState *s = opaque;
4238 size = recv(s->fd, buf1, sizeof(buf1), 0);
4240 err = socket_error();
4241 if (err != EWOULDBLOCK)
4243 } else if (size == 0) {
4244 /* end of connection */
4246 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4252 /* reassemble a packet from the network */
4258 memcpy(s->buf + s->index, buf, l);
4262 if (s->index == 4) {
4264 s->packet_len = ntohl(*(uint32_t *)s->buf);
4270 l = s->packet_len - s->index;
4273 memcpy(s->buf + s->index, buf, l);
4277 if (s->index >= s->packet_len) {
4278 qemu_send_packet(s->vc, s->buf, s->packet_len);
4287 static void net_socket_send_dgram(void *opaque)
4289 NetSocketState *s = opaque;
4292 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4296 /* end of connection */
4297 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4300 qemu_send_packet(s->vc, s->buf, size);
4303 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4308 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4309 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4310 inet_ntoa(mcastaddr->sin_addr),
4311 (int)ntohl(mcastaddr->sin_addr.s_addr));
4315 fd = socket(PF_INET, SOCK_DGRAM, 0);
4317 perror("socket(PF_INET, SOCK_DGRAM)");
4322 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4323 (const char *)&val, sizeof(val));
4325 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4329 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4335 /* Add host to multicast group */
4336 imr.imr_multiaddr = mcastaddr->sin_addr;
4337 imr.imr_interface.s_addr = htonl(INADDR_ANY);
4339 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4340 (const char *)&imr, sizeof(struct ip_mreq));
4342 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4346 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4348 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4349 (const char *)&val, sizeof(val));
4351 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4355 socket_set_nonblock(fd);
4363 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4366 struct sockaddr_in saddr;
4368 socklen_t saddr_len;
4371 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4372 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4373 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4377 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4379 if (saddr.sin_addr.s_addr==0) {
4380 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4384 /* clone dgram socket */
4385 newfd = net_socket_mcast_create(&saddr);
4387 /* error already reported by net_socket_mcast_create() */
4391 /* clone newfd to fd, close newfd */
4396 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4397 fd, strerror(errno));
4402 s = qemu_mallocz(sizeof(NetSocketState));
4407 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4408 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4410 /* mcast: save bound address as dst */
4411 if (is_connected) s->dgram_dst=saddr;
4413 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4414 "socket: fd=%d (%s mcast=%s:%d)",
4415 fd, is_connected? "cloned" : "",
4416 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4420 static void net_socket_connect(void *opaque)
4422 NetSocketState *s = opaque;
4423 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4426 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4430 s = qemu_mallocz(sizeof(NetSocketState));
4434 s->vc = qemu_new_vlan_client(vlan,
4435 net_socket_receive, NULL, s);
4436 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4437 "socket: fd=%d", fd);
4439 net_socket_connect(s);
4441 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4446 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4449 int so_type=-1, optlen=sizeof(so_type);
4451 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4452 (socklen_t *)&optlen)< 0) {
4453 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4458 return net_socket_fd_init_dgram(vlan, fd, is_connected);
4460 return net_socket_fd_init_stream(vlan, fd, is_connected);
4462 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4463 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4464 return net_socket_fd_init_stream(vlan, fd, is_connected);
4469 static void net_socket_accept(void *opaque)
4471 NetSocketListenState *s = opaque;
4473 struct sockaddr_in saddr;
4478 len = sizeof(saddr);
4479 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4480 if (fd < 0 && errno != EINTR) {
4482 } else if (fd >= 0) {
4486 s1 = net_socket_fd_init(s->vlan, fd, 1);
4490 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4491 "socket: connection from %s:%d",
4492 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4496 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4498 NetSocketListenState *s;
4500 struct sockaddr_in saddr;
4502 if (parse_host_port(&saddr, host_str) < 0)
4505 s = qemu_mallocz(sizeof(NetSocketListenState));
4509 fd = socket(PF_INET, SOCK_STREAM, 0);
4514 socket_set_nonblock(fd);
4516 /* allow fast reuse */
4518 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4520 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4525 ret = listen(fd, 0);
4532 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4536 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4539 int fd, connected, ret, err;
4540 struct sockaddr_in saddr;
4542 if (parse_host_port(&saddr, host_str) < 0)
4545 fd = socket(PF_INET, SOCK_STREAM, 0);
4550 socket_set_nonblock(fd);
4554 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4556 err = socket_error();
4557 if (err == EINTR || err == EWOULDBLOCK) {
4558 } else if (err == EINPROGRESS) {
4561 } else if (err == WSAEALREADY) {
4574 s = net_socket_fd_init(vlan, fd, connected);
4577 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4578 "socket: connect to %s:%d",
4579 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4583 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4587 struct sockaddr_in saddr;
4589 if (parse_host_port(&saddr, host_str) < 0)
4593 fd = net_socket_mcast_create(&saddr);
4597 s = net_socket_fd_init(vlan, fd, 0);
4601 s->dgram_dst = saddr;
4603 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4604 "socket: mcast=%s:%d",
4605 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4610 static const char *get_opt_name(char *buf, int buf_size, const char *p)
4615 while (*p != '\0' && *p != '=') {
4616 if (q && (q - buf) < buf_size - 1)
4626 static const char *get_opt_value(char *buf, int buf_size, const char *p)
4631 while (*p != '\0') {
4633 if (*(p + 1) != ',')
4637 if (q && (q - buf) < buf_size - 1)
4647 static int get_param_value(char *buf, int buf_size,
4648 const char *tag, const char *str)
4655 p = get_opt_name(option, sizeof(option), p);
4659 if (!strcmp(tag, option)) {
4660 (void)get_opt_value(buf, buf_size, p);
4663 p = get_opt_value(NULL, 0, p);
4672 static int check_params(char *buf, int buf_size,
4673 char **params, const char *str)
4680 p = get_opt_name(buf, buf_size, p);
4684 for(i = 0; params[i] != NULL; i++)
4685 if (!strcmp(params[i], buf))
4687 if (params[i] == NULL)
4689 p = get_opt_value(NULL, 0, p);
4698 static int net_client_init(const char *str)
4709 while (*p != '\0' && *p != ',') {
4710 if ((q - device) < sizeof(device) - 1)
4718 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4719 vlan_id = strtol(buf, NULL, 0);
4721 vlan = qemu_find_vlan(vlan_id);
4723 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4726 if (!strcmp(device, "nic")) {
4730 if (nb_nics >= MAX_NICS) {
4731 fprintf(stderr, "Too Many NICs\n");
4734 nd = &nd_table[nb_nics];
4735 macaddr = nd->macaddr;
4741 macaddr[5] = 0x56 + nb_nics;
4743 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4744 if (parse_macaddr(macaddr, buf) < 0) {
4745 fprintf(stderr, "invalid syntax for ethernet address\n");
4749 if (get_param_value(buf, sizeof(buf), "model", p)) {
4750 nd->model = strdup(buf);
4754 vlan->nb_guest_devs++;
4757 if (!strcmp(device, "none")) {
4758 /* does nothing. It is needed to signal that no network cards
4763 if (!strcmp(device, "user")) {
4764 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4765 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4767 vlan->nb_host_devs++;
4768 ret = net_slirp_init(vlan);
4772 if (!strcmp(device, "tap")) {
4774 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4775 fprintf(stderr, "tap: no interface name\n");
4778 vlan->nb_host_devs++;
4779 ret = tap_win32_init(vlan, ifname);
4782 if (!strcmp(device, "tap")) {
4784 char setup_script[1024], down_script[1024];
4786 vlan->nb_host_devs++;
4787 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4788 fd = strtol(buf, NULL, 0);
4790 if (net_tap_fd_init(vlan, fd))
4793 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4796 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4797 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4799 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4800 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4802 ret = net_tap_init(vlan, ifname, setup_script, down_script);
4806 if (!strcmp(device, "socket")) {
4807 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4809 fd = strtol(buf, NULL, 0);
4811 if (net_socket_fd_init(vlan, fd, 1))
4813 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4814 ret = net_socket_listen_init(vlan, buf);
4815 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4816 ret = net_socket_connect_init(vlan, buf);
4817 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4818 ret = net_socket_mcast_init(vlan, buf);
4820 fprintf(stderr, "Unknown socket options: %s\n", p);
4823 vlan->nb_host_devs++;
4826 fprintf(stderr, "Unknown network device: %s\n", device);
4830 fprintf(stderr, "Could not initialize device '%s'\n", device);
4836 void do_info_network(void)
4839 VLANClientState *vc;
4841 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4842 term_printf("VLAN %d devices:\n", vlan->id);
4843 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4844 term_printf(" %s\n", vc->info_str);
4848 #define HD_ALIAS "index=%d,media=disk"
4850 #define CDROM_ALIAS "index=1,media=cdrom"
4852 #define CDROM_ALIAS "index=2,media=cdrom"
4854 #define FD_ALIAS "index=%d,if=floppy"
4855 #define PFLASH_ALIAS "if=pflash"
4856 #define MTD_ALIAS "if=mtd"
4857 #define SD_ALIAS "index=0,if=sd"
4859 static int drive_add(const char *file, const char *fmt, ...)
4863 if (nb_drives_opt >= MAX_DRIVES) {
4864 fprintf(stderr, "qemu: too many drives\n");
4868 drives_opt[nb_drives_opt].file = file;
4870 vsnprintf(drives_opt[nb_drives_opt].opt,
4871 sizeof(drives_opt[0].opt), fmt, ap);
4874 return nb_drives_opt++;
4877 int drive_get_index(BlockInterfaceType type, int bus, int unit)
4881 /* seek interface, bus and unit */
4883 for (index = 0; index < nb_drives; index++)
4884 if (drives_table[index].type == type &&
4885 drives_table[index].bus == bus &&
4886 drives_table[index].unit == unit)
4892 int drive_get_max_bus(BlockInterfaceType type)
4898 for (index = 0; index < nb_drives; index++) {
4899 if(drives_table[index].type == type &&
4900 drives_table[index].bus > max_bus)
4901 max_bus = drives_table[index].bus;
4906 static int drive_init(struct drive_opt *arg, int snapshot,
4907 QEMUMachine *machine)
4912 const char *mediastr = "";
4913 BlockInterfaceType type;
4914 enum { MEDIA_DISK, MEDIA_CDROM } media;
4915 int bus_id, unit_id;
4916 int cyls, heads, secs, translation;
4917 BlockDriverState *bdrv;
4922 char *str = arg->opt;
4923 char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
4924 "secs", "trans", "media", "snapshot", "file",
4927 if (check_params(buf, sizeof(buf), params, str) < 0) {
4928 fprintf(stderr, "qemu: unknowm parameter '%s' in '%s'\n",
4934 cyls = heads = secs = 0;
4937 translation = BIOS_ATA_TRANSLATION_AUTO;
4941 if (!strcmp(machine->name, "realview") ||
4942 !strcmp(machine->name, "SS-5") ||
4943 !strcmp(machine->name, "SS-10") ||
4944 !strcmp(machine->name, "SS-600MP") ||
4945 !strcmp(machine->name, "versatilepb") ||
4946 !strcmp(machine->name, "versatileab")) {
4948 max_devs = MAX_SCSI_DEVS;
4949 strcpy(devname, "scsi");
4952 max_devs = MAX_IDE_DEVS;
4953 strcpy(devname, "ide");
4957 /* extract parameters */
4959 if (get_param_value(buf, sizeof(buf), "bus", str)) {
4960 bus_id = strtol(buf, NULL, 0);
4962 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
4967 if (get_param_value(buf, sizeof(buf), "unit", str)) {
4968 unit_id = strtol(buf, NULL, 0);
4970 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
4975 if (get_param_value(buf, sizeof(buf), "if", str)) {
4976 strncpy(devname, buf, sizeof(devname));
4977 if (!strcmp(buf, "ide")) {
4979 max_devs = MAX_IDE_DEVS;
4980 } else if (!strcmp(buf, "scsi")) {
4982 max_devs = MAX_SCSI_DEVS;
4983 } else if (!strcmp(buf, "floppy")) {
4986 } else if (!strcmp(buf, "pflash")) {
4989 } else if (!strcmp(buf, "mtd")) {
4992 } else if (!strcmp(buf, "sd")) {
4996 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5001 if (get_param_value(buf, sizeof(buf), "index", str)) {
5002 index = strtol(buf, NULL, 0);
5004 fprintf(stderr, "qemu: '%s' invalid index\n", str);
5009 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5010 cyls = strtol(buf, NULL, 0);
5013 if (get_param_value(buf, sizeof(buf), "heads", str)) {
5014 heads = strtol(buf, NULL, 0);
5017 if (get_param_value(buf, sizeof(buf), "secs", str)) {
5018 secs = strtol(buf, NULL, 0);
5021 if (cyls || heads || secs) {
5022 if (cyls < 1 || cyls > 16383) {
5023 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5026 if (heads < 1 || heads > 16) {
5027 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5030 if (secs < 1 || secs > 63) {
5031 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5036 if (get_param_value(buf, sizeof(buf), "trans", str)) {
5039 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5043 if (!strcmp(buf, "none"))
5044 translation = BIOS_ATA_TRANSLATION_NONE;
5045 else if (!strcmp(buf, "lba"))
5046 translation = BIOS_ATA_TRANSLATION_LBA;
5047 else if (!strcmp(buf, "auto"))
5048 translation = BIOS_ATA_TRANSLATION_AUTO;
5050 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5055 if (get_param_value(buf, sizeof(buf), "media", str)) {
5056 if (!strcmp(buf, "disk")) {
5058 } else if (!strcmp(buf, "cdrom")) {
5059 if (cyls || secs || heads) {
5061 "qemu: '%s' invalid physical CHS format\n", str);
5064 media = MEDIA_CDROM;
5066 fprintf(stderr, "qemu: '%s' invalid media\n", str);
5071 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5072 if (!strcmp(buf, "on"))
5074 else if (!strcmp(buf, "off"))
5077 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5082 if (get_param_value(buf, sizeof(buf), "cache", str)) {
5083 if (!strcmp(buf, "off"))
5085 else if (!strcmp(buf, "on"))
5088 fprintf(stderr, "qemu: invalid cache option\n");
5093 if (arg->file == NULL)
5094 get_param_value(file, sizeof(file), "file", str);
5096 pstrcpy(file, sizeof(file), arg->file);
5098 /* compute bus and unit according index */
5101 if (bus_id != 0 || unit_id != -1) {
5103 "qemu: '%s' index cannot be used with bus and unit\n", str);
5111 unit_id = index % max_devs;
5112 bus_id = index / max_devs;
5116 /* if user doesn't specify a unit_id,
5117 * try to find the first free
5120 if (unit_id == -1) {
5122 while (drive_get_index(type, bus_id, unit_id) != -1) {
5124 if (max_devs && unit_id >= max_devs) {
5125 unit_id -= max_devs;
5133 if (max_devs && unit_id >= max_devs) {
5134 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5135 str, unit_id, max_devs - 1);
5140 * ignore multiple definitions
5143 if (drive_get_index(type, bus_id, unit_id) != -1)
5148 if (type == IF_IDE || type == IF_SCSI)
5149 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5151 snprintf(buf, sizeof(buf), "%s%i%s%i",
5152 devname, bus_id, mediastr, unit_id);
5154 snprintf(buf, sizeof(buf), "%s%s%i",
5155 devname, mediastr, unit_id);
5156 bdrv = bdrv_new(buf);
5157 drives_table[nb_drives].bdrv = bdrv;
5158 drives_table[nb_drives].type = type;
5159 drives_table[nb_drives].bus = bus_id;
5160 drives_table[nb_drives].unit = unit_id;
5169 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5170 bdrv_set_translation_hint(bdrv, translation);
5174 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5179 /* FIXME: This isn't really a floppy, but it's a reasonable
5182 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5192 bdrv_flags |= BDRV_O_SNAPSHOT;
5194 bdrv_flags |= BDRV_O_DIRECT;
5195 if (bdrv_open(bdrv, file, bdrv_flags) < 0 || qemu_key_check(bdrv, file)) {
5196 fprintf(stderr, "qemu: could not open disk image %s\n",
5203 /***********************************************************/
5206 static USBPort *used_usb_ports;
5207 static USBPort *free_usb_ports;
5209 /* ??? Maybe change this to register a hub to keep track of the topology. */
5210 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5211 usb_attachfn attach)
5213 port->opaque = opaque;
5214 port->index = index;
5215 port->attach = attach;
5216 port->next = free_usb_ports;
5217 free_usb_ports = port;
5220 static int usb_device_add(const char *devname)
5226 if (!free_usb_ports)
5229 if (strstart(devname, "host:", &p)) {
5230 dev = usb_host_device_open(p);
5231 } else if (!strcmp(devname, "mouse")) {
5232 dev = usb_mouse_init();
5233 } else if (!strcmp(devname, "tablet")) {
5234 dev = usb_tablet_init();
5235 } else if (!strcmp(devname, "keyboard")) {
5236 dev = usb_keyboard_init();
5237 } else if (strstart(devname, "disk:", &p)) {
5238 dev = usb_msd_init(p);
5239 } else if (!strcmp(devname, "wacom-tablet")) {
5240 dev = usb_wacom_init();
5241 } else if (strstart(devname, "serial:", &p)) {
5242 dev = usb_serial_init(p);
5249 /* Find a USB port to add the device to. */
5250 port = free_usb_ports;
5254 /* Create a new hub and chain it on. */
5255 free_usb_ports = NULL;
5256 port->next = used_usb_ports;
5257 used_usb_ports = port;
5259 hub = usb_hub_init(VM_USB_HUB_SIZE);
5260 usb_attach(port, hub);
5261 port = free_usb_ports;
5264 free_usb_ports = port->next;
5265 port->next = used_usb_ports;
5266 used_usb_ports = port;
5267 usb_attach(port, dev);
5271 static int usb_device_del(const char *devname)
5279 if (!used_usb_ports)
5282 p = strchr(devname, '.');
5285 bus_num = strtoul(devname, NULL, 0);
5286 addr = strtoul(p + 1, NULL, 0);
5290 lastp = &used_usb_ports;
5291 port = used_usb_ports;
5292 while (port && port->dev->addr != addr) {
5293 lastp = &port->next;
5301 *lastp = port->next;
5302 usb_attach(port, NULL);
5303 dev->handle_destroy(dev);
5304 port->next = free_usb_ports;
5305 free_usb_ports = port;
5309 void do_usb_add(const char *devname)
5312 ret = usb_device_add(devname);
5314 term_printf("Could not add USB device '%s'\n", devname);
5317 void do_usb_del(const char *devname)
5320 ret = usb_device_del(devname);
5322 term_printf("Could not remove USB device '%s'\n", devname);
5329 const char *speed_str;
5332 term_printf("USB support not enabled\n");
5336 for (port = used_usb_ports; port; port = port->next) {
5340 switch(dev->speed) {
5344 case USB_SPEED_FULL:
5347 case USB_SPEED_HIGH:
5354 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5355 0, dev->addr, speed_str, dev->devname);
5359 /***********************************************************/
5360 /* PCMCIA/Cardbus */
5362 static struct pcmcia_socket_entry_s {
5363 struct pcmcia_socket_s *socket;
5364 struct pcmcia_socket_entry_s *next;
5365 } *pcmcia_sockets = 0;
5367 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5369 struct pcmcia_socket_entry_s *entry;
5371 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5372 entry->socket = socket;
5373 entry->next = pcmcia_sockets;
5374 pcmcia_sockets = entry;
5377 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5379 struct pcmcia_socket_entry_s *entry, **ptr;
5381 ptr = &pcmcia_sockets;
5382 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5383 if (entry->socket == socket) {
5389 void pcmcia_info(void)
5391 struct pcmcia_socket_entry_s *iter;
5392 if (!pcmcia_sockets)
5393 term_printf("No PCMCIA sockets\n");
5395 for (iter = pcmcia_sockets; iter; iter = iter->next)
5396 term_printf("%s: %s\n", iter->socket->slot_string,
5397 iter->socket->attached ? iter->socket->card_string :
5401 /***********************************************************/
5404 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5408 static void dumb_resize(DisplayState *ds, int w, int h)
5412 static void dumb_refresh(DisplayState *ds)
5414 #if defined(CONFIG_SDL)
5419 static void dumb_display_init(DisplayState *ds)
5424 ds->dpy_update = dumb_update;
5425 ds->dpy_resize = dumb_resize;
5426 ds->dpy_refresh = dumb_refresh;
5429 /***********************************************************/
5432 #define MAX_IO_HANDLERS 64
5434 typedef struct IOHandlerRecord {
5436 IOCanRWHandler *fd_read_poll;
5438 IOHandler *fd_write;
5441 /* temporary data */
5443 struct IOHandlerRecord *next;
5446 static IOHandlerRecord *first_io_handler;
5448 /* XXX: fd_read_poll should be suppressed, but an API change is
5449 necessary in the character devices to suppress fd_can_read(). */
5450 int qemu_set_fd_handler2(int fd,
5451 IOCanRWHandler *fd_read_poll,
5453 IOHandler *fd_write,
5456 IOHandlerRecord **pioh, *ioh;
5458 if (!fd_read && !fd_write) {
5459 pioh = &first_io_handler;
5464 if (ioh->fd == fd) {
5471 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5475 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5478 ioh->next = first_io_handler;
5479 first_io_handler = ioh;
5482 ioh->fd_read_poll = fd_read_poll;
5483 ioh->fd_read = fd_read;
5484 ioh->fd_write = fd_write;
5485 ioh->opaque = opaque;
5491 int qemu_set_fd_handler(int fd,
5493 IOHandler *fd_write,
5496 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5499 /***********************************************************/
5500 /* Polling handling */
5502 typedef struct PollingEntry {
5505 struct PollingEntry *next;
5508 static PollingEntry *first_polling_entry;
5510 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
5512 PollingEntry **ppe, *pe;
5513 pe = qemu_mallocz(sizeof(PollingEntry));
5517 pe->opaque = opaque;
5518 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5523 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
5525 PollingEntry **ppe, *pe;
5526 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
5528 if (pe->func == func && pe->opaque == opaque) {
5537 /***********************************************************/
5538 /* Wait objects support */
5539 typedef struct WaitObjects {
5541 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
5542 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
5543 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
5546 static WaitObjects wait_objects = {0};
5548 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5550 WaitObjects *w = &wait_objects;
5552 if (w->num >= MAXIMUM_WAIT_OBJECTS)
5554 w->events[w->num] = handle;
5555 w->func[w->num] = func;
5556 w->opaque[w->num] = opaque;
5561 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5564 WaitObjects *w = &wait_objects;
5567 for (i = 0; i < w->num; i++) {
5568 if (w->events[i] == handle)
5571 w->events[i] = w->events[i + 1];
5572 w->func[i] = w->func[i + 1];
5573 w->opaque[i] = w->opaque[i + 1];
5581 /***********************************************************/
5582 /* savevm/loadvm support */
5584 #define IO_BUF_SIZE 32768
5588 BlockDriverState *bs;
5591 int64_t base_offset;
5592 int64_t buf_offset; /* start of buffer when writing, end of buffer
5595 int buf_size; /* 0 when writing */
5596 uint8_t buf[IO_BUF_SIZE];
5599 QEMUFile *qemu_fopen(const char *filename, const char *mode)
5603 f = qemu_mallocz(sizeof(QEMUFile));
5606 if (!strcmp(mode, "wb")) {
5608 } else if (!strcmp(mode, "rb")) {
5613 f->outfile = fopen(filename, mode);
5625 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5629 f = qemu_mallocz(sizeof(QEMUFile));
5634 f->is_writable = is_writable;
5635 f->base_offset = offset;
5639 void qemu_fflush(QEMUFile *f)
5641 if (!f->is_writable)
5643 if (f->buf_index > 0) {
5645 fseek(f->outfile, f->buf_offset, SEEK_SET);
5646 fwrite(f->buf, 1, f->buf_index, f->outfile);
5648 bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
5649 f->buf, f->buf_index);
5651 f->buf_offset += f->buf_index;
5656 static void qemu_fill_buffer(QEMUFile *f)
5663 fseek(f->outfile, f->buf_offset, SEEK_SET);
5664 len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
5668 len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
5669 f->buf, IO_BUF_SIZE);
5675 f->buf_offset += len;
5678 void qemu_fclose(QEMUFile *f)
5688 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5692 l = IO_BUF_SIZE - f->buf_index;
5695 memcpy(f->buf + f->buf_index, buf, l);
5699 if (f->buf_index >= IO_BUF_SIZE)
5704 void qemu_put_byte(QEMUFile *f, int v)
5706 f->buf[f->buf_index++] = v;
5707 if (f->buf_index >= IO_BUF_SIZE)
5711 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5717 l = f->buf_size - f->buf_index;
5719 qemu_fill_buffer(f);
5720 l = f->buf_size - f->buf_index;
5726 memcpy(buf, f->buf + f->buf_index, l);
5731 return size1 - size;
5734 int qemu_get_byte(QEMUFile *f)
5736 if (f->buf_index >= f->buf_size) {
5737 qemu_fill_buffer(f);
5738 if (f->buf_index >= f->buf_size)
5741 return f->buf[f->buf_index++];
5744 int64_t qemu_ftell(QEMUFile *f)
5746 return f->buf_offset - f->buf_size + f->buf_index;
5749 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5751 if (whence == SEEK_SET) {
5753 } else if (whence == SEEK_CUR) {
5754 pos += qemu_ftell(f);
5756 /* SEEK_END not supported */
5759 if (f->is_writable) {
5761 f->buf_offset = pos;
5763 f->buf_offset = pos;
5770 void qemu_put_be16(QEMUFile *f, unsigned int v)
5772 qemu_put_byte(f, v >> 8);
5773 qemu_put_byte(f, v);
5776 void qemu_put_be32(QEMUFile *f, unsigned int v)
5778 qemu_put_byte(f, v >> 24);
5779 qemu_put_byte(f, v >> 16);
5780 qemu_put_byte(f, v >> 8);
5781 qemu_put_byte(f, v);
5784 void qemu_put_be64(QEMUFile *f, uint64_t v)
5786 qemu_put_be32(f, v >> 32);
5787 qemu_put_be32(f, v);
5790 unsigned int qemu_get_be16(QEMUFile *f)
5793 v = qemu_get_byte(f) << 8;
5794 v |= qemu_get_byte(f);
5798 unsigned int qemu_get_be32(QEMUFile *f)
5801 v = qemu_get_byte(f) << 24;
5802 v |= qemu_get_byte(f) << 16;
5803 v |= qemu_get_byte(f) << 8;
5804 v |= qemu_get_byte(f);
5808 uint64_t qemu_get_be64(QEMUFile *f)
5811 v = (uint64_t)qemu_get_be32(f) << 32;
5812 v |= qemu_get_be32(f);
5816 typedef struct SaveStateEntry {
5820 SaveStateHandler *save_state;
5821 LoadStateHandler *load_state;
5823 struct SaveStateEntry *next;
5826 static SaveStateEntry *first_se;
5828 int register_savevm(const char *idstr,
5831 SaveStateHandler *save_state,
5832 LoadStateHandler *load_state,
5835 SaveStateEntry *se, **pse;
5837 se = qemu_malloc(sizeof(SaveStateEntry));
5840 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
5841 se->instance_id = instance_id;
5842 se->version_id = version_id;
5843 se->save_state = save_state;
5844 se->load_state = load_state;
5845 se->opaque = opaque;
5848 /* add at the end of list */
5850 while (*pse != NULL)
5851 pse = &(*pse)->next;
5856 #define QEMU_VM_FILE_MAGIC 0x5145564d
5857 #define QEMU_VM_FILE_VERSION 0x00000002
5859 static int qemu_savevm_state(QEMUFile *f)
5863 int64_t cur_pos, len_pos, total_len_pos;
5865 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
5866 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
5867 total_len_pos = qemu_ftell(f);
5868 qemu_put_be64(f, 0); /* total size */
5870 for(se = first_se; se != NULL; se = se->next) {
5872 len = strlen(se->idstr);
5873 qemu_put_byte(f, len);
5874 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
5876 qemu_put_be32(f, se->instance_id);
5877 qemu_put_be32(f, se->version_id);
5879 /* record size: filled later */
5880 len_pos = qemu_ftell(f);
5881 qemu_put_be32(f, 0);
5882 se->save_state(f, se->opaque);
5884 /* fill record size */
5885 cur_pos = qemu_ftell(f);
5886 len = cur_pos - len_pos - 4;
5887 qemu_fseek(f, len_pos, SEEK_SET);
5888 qemu_put_be32(f, len);
5889 qemu_fseek(f, cur_pos, SEEK_SET);
5891 cur_pos = qemu_ftell(f);
5892 qemu_fseek(f, total_len_pos, SEEK_SET);
5893 qemu_put_be64(f, cur_pos - total_len_pos - 8);
5894 qemu_fseek(f, cur_pos, SEEK_SET);
5900 static SaveStateEntry *find_se(const char *idstr, int instance_id)
5904 for(se = first_se; se != NULL; se = se->next) {
5905 if (!strcmp(se->idstr, idstr) &&
5906 instance_id == se->instance_id)
5912 static int qemu_loadvm_state(QEMUFile *f)
5915 int len, ret, instance_id, record_len, version_id;
5916 int64_t total_len, end_pos, cur_pos;
5920 v = qemu_get_be32(f);
5921 if (v != QEMU_VM_FILE_MAGIC)
5923 v = qemu_get_be32(f);
5924 if (v != QEMU_VM_FILE_VERSION) {
5929 total_len = qemu_get_be64(f);
5930 end_pos = total_len + qemu_ftell(f);
5932 if (qemu_ftell(f) >= end_pos)
5934 len = qemu_get_byte(f);
5935 qemu_get_buffer(f, (uint8_t *)idstr, len);
5937 instance_id = qemu_get_be32(f);
5938 version_id = qemu_get_be32(f);
5939 record_len = qemu_get_be32(f);
5941 printf("idstr=%s instance=0x%x version=%d len=%d\n",
5942 idstr, instance_id, version_id, record_len);
5944 cur_pos = qemu_ftell(f);
5945 se = find_se(idstr, instance_id);
5947 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
5948 instance_id, idstr);
5950 ret = se->load_state(f, se->opaque, version_id);
5952 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
5953 instance_id, idstr);
5956 /* always seek to exact end of record */
5957 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
5964 /* device can contain snapshots */
5965 static int bdrv_can_snapshot(BlockDriverState *bs)
5968 !bdrv_is_removable(bs) &&
5969 !bdrv_is_read_only(bs));
5972 /* device must be snapshots in order to have a reliable snapshot */
5973 static int bdrv_has_snapshot(BlockDriverState *bs)
5976 !bdrv_is_removable(bs) &&
5977 !bdrv_is_read_only(bs));
5980 static BlockDriverState *get_bs_snapshots(void)
5982 BlockDriverState *bs;
5986 return bs_snapshots;
5987 for(i = 0; i <= nb_drives; i++) {
5988 bs = drives_table[i].bdrv;
5989 if (bdrv_can_snapshot(bs))
5998 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6001 QEMUSnapshotInfo *sn_tab, *sn;
6005 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6008 for(i = 0; i < nb_sns; i++) {
6010 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6020 void do_savevm(const char *name)
6022 BlockDriverState *bs, *bs1;
6023 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6024 int must_delete, ret, i;
6025 BlockDriverInfo bdi1, *bdi = &bdi1;
6027 int saved_vm_running;
6034 bs = get_bs_snapshots();
6036 term_printf("No block device can accept snapshots\n");
6040 /* ??? Should this occur after vm_stop? */
6043 saved_vm_running = vm_running;
6048 ret = bdrv_snapshot_find(bs, old_sn, name);
6053 memset(sn, 0, sizeof(*sn));
6055 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6056 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6059 pstrcpy(sn->name, sizeof(sn->name), name);
6062 /* fill auxiliary fields */
6065 sn->date_sec = tb.time;
6066 sn->date_nsec = tb.millitm * 1000000;
6068 gettimeofday(&tv, NULL);
6069 sn->date_sec = tv.tv_sec;
6070 sn->date_nsec = tv.tv_usec * 1000;
6072 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6074 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6075 term_printf("Device %s does not support VM state snapshots\n",
6076 bdrv_get_device_name(bs));
6080 /* save the VM state */
6081 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6083 term_printf("Could not open VM state file\n");
6086 ret = qemu_savevm_state(f);
6087 sn->vm_state_size = qemu_ftell(f);
6090 term_printf("Error %d while writing VM\n", ret);
6094 /* create the snapshots */
6096 for(i = 0; i < nb_drives; i++) {
6097 bs1 = drives_table[i].bdrv;
6098 if (bdrv_has_snapshot(bs1)) {
6100 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6102 term_printf("Error while deleting snapshot on '%s'\n",
6103 bdrv_get_device_name(bs1));
6106 ret = bdrv_snapshot_create(bs1, sn);
6108 term_printf("Error while creating snapshot on '%s'\n",
6109 bdrv_get_device_name(bs1));
6115 if (saved_vm_running)
6119 void do_loadvm(const char *name)
6121 BlockDriverState *bs, *bs1;
6122 BlockDriverInfo bdi1, *bdi = &bdi1;
6125 int saved_vm_running;
6127 bs = get_bs_snapshots();
6129 term_printf("No block device supports snapshots\n");
6133 /* Flush all IO requests so they don't interfere with the new state. */
6136 saved_vm_running = vm_running;
6139 for(i = 0; i <= nb_drives; i++) {
6140 bs1 = drives_table[i].bdrv;
6141 if (bdrv_has_snapshot(bs1)) {
6142 ret = bdrv_snapshot_goto(bs1, name);
6145 term_printf("Warning: ");
6148 term_printf("Snapshots not supported on device '%s'\n",
6149 bdrv_get_device_name(bs1));
6152 term_printf("Could not find snapshot '%s' on device '%s'\n",
6153 name, bdrv_get_device_name(bs1));
6156 term_printf("Error %d while activating snapshot on '%s'\n",
6157 ret, bdrv_get_device_name(bs1));
6160 /* fatal on snapshot block device */
6167 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6168 term_printf("Device %s does not support VM state snapshots\n",
6169 bdrv_get_device_name(bs));
6173 /* restore the VM state */
6174 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6176 term_printf("Could not open VM state file\n");
6179 ret = qemu_loadvm_state(f);
6182 term_printf("Error %d while loading VM state\n", ret);
6185 if (saved_vm_running)
6189 void do_delvm(const char *name)
6191 BlockDriverState *bs, *bs1;
6194 bs = get_bs_snapshots();
6196 term_printf("No block device supports snapshots\n");
6200 for(i = 0; i <= nb_drives; i++) {
6201 bs1 = drives_table[i].bdrv;
6202 if (bdrv_has_snapshot(bs1)) {
6203 ret = bdrv_snapshot_delete(bs1, name);
6205 if (ret == -ENOTSUP)
6206 term_printf("Snapshots not supported on device '%s'\n",
6207 bdrv_get_device_name(bs1));
6209 term_printf("Error %d while deleting snapshot on '%s'\n",
6210 ret, bdrv_get_device_name(bs1));
6216 void do_info_snapshots(void)
6218 BlockDriverState *bs, *bs1;
6219 QEMUSnapshotInfo *sn_tab, *sn;
6223 bs = get_bs_snapshots();
6225 term_printf("No available block device supports snapshots\n");
6228 term_printf("Snapshot devices:");
6229 for(i = 0; i <= nb_drives; i++) {
6230 bs1 = drives_table[i].bdrv;
6231 if (bdrv_has_snapshot(bs1)) {
6233 term_printf(" %s", bdrv_get_device_name(bs1));
6238 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6240 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6243 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6244 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6245 for(i = 0; i < nb_sns; i++) {
6247 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6252 /***********************************************************/
6253 /* cpu save/restore */
6255 #if defined(TARGET_I386)
6257 static void cpu_put_seg(QEMUFile *f, SegmentCache *dt)
6259 qemu_put_be32(f, dt->selector);
6260 qemu_put_betl(f, dt->base);
6261 qemu_put_be32(f, dt->limit);
6262 qemu_put_be32(f, dt->flags);
6265 static void cpu_get_seg(QEMUFile *f, SegmentCache *dt)
6267 dt->selector = qemu_get_be32(f);
6268 dt->base = qemu_get_betl(f);
6269 dt->limit = qemu_get_be32(f);
6270 dt->flags = qemu_get_be32(f);
6273 void cpu_save(QEMUFile *f, void *opaque)
6275 CPUState *env = opaque;
6276 uint16_t fptag, fpus, fpuc, fpregs_format;
6280 for(i = 0; i < CPU_NB_REGS; i++)
6281 qemu_put_betls(f, &env->regs[i]);
6282 qemu_put_betls(f, &env->eip);
6283 qemu_put_betls(f, &env->eflags);
6284 hflags = env->hflags; /* XXX: suppress most of the redundant hflags */
6285 qemu_put_be32s(f, &hflags);
6289 fpus = (env->fpus & ~0x3800) | (env->fpstt & 0x7) << 11;
6291 for(i = 0; i < 8; i++) {
6292 fptag |= ((!env->fptags[i]) << i);
6295 qemu_put_be16s(f, &fpuc);
6296 qemu_put_be16s(f, &fpus);
6297 qemu_put_be16s(f, &fptag);
6299 #ifdef USE_X86LDOUBLE
6304 qemu_put_be16s(f, &fpregs_format);
6306 for(i = 0; i < 8; i++) {
6307 #ifdef USE_X86LDOUBLE
6311 /* we save the real CPU data (in case of MMX usage only 'mant'
6312 contains the MMX register */
6313 cpu_get_fp80(&mant, &exp, env->fpregs[i].d);
6314 qemu_put_be64(f, mant);
6315 qemu_put_be16(f, exp);
6318 /* if we use doubles for float emulation, we save the doubles to
6319 avoid losing information in case of MMX usage. It can give
6320 problems if the image is restored on a CPU where long
6321 doubles are used instead. */
6322 qemu_put_be64(f, env->fpregs[i].mmx.MMX_Q(0));
6326 for(i = 0; i < 6; i++)
6327 cpu_put_seg(f, &env->segs[i]);
6328 cpu_put_seg(f, &env->ldt);
6329 cpu_put_seg(f, &env->tr);
6330 cpu_put_seg(f, &env->gdt);
6331 cpu_put_seg(f, &env->idt);
6333 qemu_put_be32s(f, &env->sysenter_cs);
6334 qemu_put_be32s(f, &env->sysenter_esp);
6335 qemu_put_be32s(f, &env->sysenter_eip);
6337 qemu_put_betls(f, &env->cr[0]);
6338 qemu_put_betls(f, &env->cr[2]);
6339 qemu_put_betls(f, &env->cr[3]);
6340 qemu_put_betls(f, &env->cr[4]);
6342 for(i = 0; i < 8; i++)
6343 qemu_put_betls(f, &env->dr[i]);
6346 qemu_put_be32s(f, &env->a20_mask);
6349 qemu_put_be32s(f, &env->mxcsr);
6350 for(i = 0; i < CPU_NB_REGS; i++) {
6351 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6352 qemu_put_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6355 #ifdef TARGET_X86_64
6356 qemu_put_be64s(f, &env->efer);
6357 qemu_put_be64s(f, &env->star);
6358 qemu_put_be64s(f, &env->lstar);
6359 qemu_put_be64s(f, &env->cstar);
6360 qemu_put_be64s(f, &env->fmask);
6361 qemu_put_be64s(f, &env->kernelgsbase);
6363 qemu_put_be32s(f, &env->smbase);
6366 #ifdef USE_X86LDOUBLE
6367 /* XXX: add that in a FPU generic layer */
6368 union x86_longdouble {
6373 #define MANTD1(fp) (fp & ((1LL << 52) - 1))
6374 #define EXPBIAS1 1023
6375 #define EXPD1(fp) ((fp >> 52) & 0x7FF)
6376 #define SIGND1(fp) ((fp >> 32) & 0x80000000)
6378 static void fp64_to_fp80(union x86_longdouble *p, uint64_t temp)
6382 p->mant = (MANTD1(temp) << 11) | (1LL << 63);
6383 /* exponent + sign */
6384 e = EXPD1(temp) - EXPBIAS1 + 16383;
6385 e |= SIGND1(temp) >> 16;
6390 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6392 CPUState *env = opaque;
6395 uint16_t fpus, fpuc, fptag, fpregs_format;
6397 if (version_id != 3 && version_id != 4)
6399 for(i = 0; i < CPU_NB_REGS; i++)
6400 qemu_get_betls(f, &env->regs[i]);
6401 qemu_get_betls(f, &env->eip);
6402 qemu_get_betls(f, &env->eflags);
6403 qemu_get_be32s(f, &hflags);
6405 qemu_get_be16s(f, &fpuc);
6406 qemu_get_be16s(f, &fpus);
6407 qemu_get_be16s(f, &fptag);
6408 qemu_get_be16s(f, &fpregs_format);
6410 /* NOTE: we cannot always restore the FPU state if the image come
6411 from a host with a different 'USE_X86LDOUBLE' define. We guess
6412 if we are in an MMX state to restore correctly in that case. */
6413 guess_mmx = ((fptag == 0xff) && (fpus & 0x3800) == 0);
6414 for(i = 0; i < 8; i++) {
6418 switch(fpregs_format) {
6420 mant = qemu_get_be64(f);
6421 exp = qemu_get_be16(f);
6422 #ifdef USE_X86LDOUBLE
6423 env->fpregs[i].d = cpu_set_fp80(mant, exp);
6425 /* difficult case */
6427 env->fpregs[i].mmx.MMX_Q(0) = mant;
6429 env->fpregs[i].d = cpu_set_fp80(mant, exp);
6433 mant = qemu_get_be64(f);
6434 #ifdef USE_X86LDOUBLE
6436 union x86_longdouble *p;
6437 /* difficult case */
6438 p = (void *)&env->fpregs[i];
6443 fp64_to_fp80(p, mant);
6447 env->fpregs[i].mmx.MMX_Q(0) = mant;
6456 /* XXX: restore FPU round state */
6457 env->fpstt = (fpus >> 11) & 7;
6458 env->fpus = fpus & ~0x3800;
6460 for(i = 0; i < 8; i++) {
6461 env->fptags[i] = (fptag >> i) & 1;
6464 for(i = 0; i < 6; i++)
6465 cpu_get_seg(f, &env->segs[i]);
6466 cpu_get_seg(f, &env->ldt);
6467 cpu_get_seg(f, &env->tr);
6468 cpu_get_seg(f, &env->gdt);
6469 cpu_get_seg(f, &env->idt);
6471 qemu_get_be32s(f, &env->sysenter_cs);
6472 qemu_get_be32s(f, &env->sysenter_esp);
6473 qemu_get_be32s(f, &env->sysenter_eip);
6475 qemu_get_betls(f, &env->cr[0]);
6476 qemu_get_betls(f, &env->cr[2]);
6477 qemu_get_betls(f, &env->cr[3]);
6478 qemu_get_betls(f, &env->cr[4]);
6480 for(i = 0; i < 8; i++)
6481 qemu_get_betls(f, &env->dr[i]);
6484 qemu_get_be32s(f, &env->a20_mask);
6486 qemu_get_be32s(f, &env->mxcsr);
6487 for(i = 0; i < CPU_NB_REGS; i++) {
6488 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(0));
6489 qemu_get_be64s(f, &env->xmm_regs[i].XMM_Q(1));
6492 #ifdef TARGET_X86_64
6493 qemu_get_be64s(f, &env->efer);
6494 qemu_get_be64s(f, &env->star);
6495 qemu_get_be64s(f, &env->lstar);
6496 qemu_get_be64s(f, &env->cstar);
6497 qemu_get_be64s(f, &env->fmask);
6498 qemu_get_be64s(f, &env->kernelgsbase);
6500 if (version_id >= 4)
6501 qemu_get_be32s(f, &env->smbase);
6503 /* XXX: compute hflags from scratch, except for CPL and IIF */
6504 env->hflags = hflags;
6509 #elif defined(TARGET_PPC)
6510 void cpu_save(QEMUFile *f, void *opaque)
6514 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6519 #elif defined(TARGET_MIPS)
6520 void cpu_save(QEMUFile *f, void *opaque)
6524 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6529 #elif defined(TARGET_SPARC)
6530 void cpu_save(QEMUFile *f, void *opaque)
6532 CPUState *env = opaque;
6536 for(i = 0; i < 8; i++)
6537 qemu_put_betls(f, &env->gregs[i]);
6538 for(i = 0; i < NWINDOWS * 16; i++)
6539 qemu_put_betls(f, &env->regbase[i]);
6542 for(i = 0; i < TARGET_FPREGS; i++) {
6548 qemu_put_be32(f, u.i);
6551 qemu_put_betls(f, &env->pc);
6552 qemu_put_betls(f, &env->npc);
6553 qemu_put_betls(f, &env->y);
6555 qemu_put_be32(f, tmp);
6556 qemu_put_betls(f, &env->fsr);
6557 qemu_put_betls(f, &env->tbr);
6558 #ifndef TARGET_SPARC64
6559 qemu_put_be32s(f, &env->wim);
6561 for(i = 0; i < 16; i++)
6562 qemu_put_be32s(f, &env->mmuregs[i]);
6566 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6568 CPUState *env = opaque;
6572 for(i = 0; i < 8; i++)
6573 qemu_get_betls(f, &env->gregs[i]);
6574 for(i = 0; i < NWINDOWS * 16; i++)
6575 qemu_get_betls(f, &env->regbase[i]);
6578 for(i = 0; i < TARGET_FPREGS; i++) {
6583 u.i = qemu_get_be32(f);
6587 qemu_get_betls(f, &env->pc);
6588 qemu_get_betls(f, &env->npc);
6589 qemu_get_betls(f, &env->y);
6590 tmp = qemu_get_be32(f);
6591 env->cwp = 0; /* needed to ensure that the wrapping registers are
6592 correctly updated */
6594 qemu_get_betls(f, &env->fsr);
6595 qemu_get_betls(f, &env->tbr);
6596 #ifndef TARGET_SPARC64
6597 qemu_get_be32s(f, &env->wim);
6599 for(i = 0; i < 16; i++)
6600 qemu_get_be32s(f, &env->mmuregs[i]);
6606 #elif defined(TARGET_ARM)
6608 void cpu_save(QEMUFile *f, void *opaque)
6611 CPUARMState *env = (CPUARMState *)opaque;
6613 for (i = 0; i < 16; i++) {
6614 qemu_put_be32(f, env->regs[i]);
6616 qemu_put_be32(f, cpsr_read(env));
6617 qemu_put_be32(f, env->spsr);
6618 for (i = 0; i < 6; i++) {
6619 qemu_put_be32(f, env->banked_spsr[i]);
6620 qemu_put_be32(f, env->banked_r13[i]);
6621 qemu_put_be32(f, env->banked_r14[i]);
6623 for (i = 0; i < 5; i++) {
6624 qemu_put_be32(f, env->usr_regs[i]);
6625 qemu_put_be32(f, env->fiq_regs[i]);
6627 qemu_put_be32(f, env->cp15.c0_cpuid);
6628 qemu_put_be32(f, env->cp15.c0_cachetype);
6629 qemu_put_be32(f, env->cp15.c1_sys);
6630 qemu_put_be32(f, env->cp15.c1_coproc);
6631 qemu_put_be32(f, env->cp15.c1_xscaleauxcr);
6632 qemu_put_be32(f, env->cp15.c2_base0);
6633 qemu_put_be32(f, env->cp15.c2_base1);
6634 qemu_put_be32(f, env->cp15.c2_mask);
6635 qemu_put_be32(f, env->cp15.c2_data);
6636 qemu_put_be32(f, env->cp15.c2_insn);
6637 qemu_put_be32(f, env->cp15.c3);
6638 qemu_put_be32(f, env->cp15.c5_insn);
6639 qemu_put_be32(f, env->cp15.c5_data);
6640 for (i = 0; i < 8; i++) {
6641 qemu_put_be32(f, env->cp15.c6_region[i]);
6643 qemu_put_be32(f, env->cp15.c6_insn);
6644 qemu_put_be32(f, env->cp15.c6_data);
6645 qemu_put_be32(f, env->cp15.c9_insn);
6646 qemu_put_be32(f, env->cp15.c9_data);
6647 qemu_put_be32(f, env->cp15.c13_fcse);
6648 qemu_put_be32(f, env->cp15.c13_context);
6649 qemu_put_be32(f, env->cp15.c13_tls1);
6650 qemu_put_be32(f, env->cp15.c13_tls2);
6651 qemu_put_be32(f, env->cp15.c13_tls3);
6652 qemu_put_be32(f, env->cp15.c15_cpar);
6654 qemu_put_be32(f, env->features);
6656 if (arm_feature(env, ARM_FEATURE_VFP)) {
6657 for (i = 0; i < 16; i++) {
6659 u.d = env->vfp.regs[i];
6660 qemu_put_be32(f, u.l.upper);
6661 qemu_put_be32(f, u.l.lower);
6663 for (i = 0; i < 16; i++) {
6664 qemu_put_be32(f, env->vfp.xregs[i]);
6667 /* TODO: Should use proper FPSCR access functions. */
6668 qemu_put_be32(f, env->vfp.vec_len);
6669 qemu_put_be32(f, env->vfp.vec_stride);
6671 if (arm_feature(env, ARM_FEATURE_VFP3)) {
6672 for (i = 16; i < 32; i++) {
6674 u.d = env->vfp.regs[i];
6675 qemu_put_be32(f, u.l.upper);
6676 qemu_put_be32(f, u.l.lower);
6681 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6682 for (i = 0; i < 16; i++) {
6683 qemu_put_be64(f, env->iwmmxt.regs[i]);
6685 for (i = 0; i < 16; i++) {
6686 qemu_put_be32(f, env->iwmmxt.cregs[i]);
6690 if (arm_feature(env, ARM_FEATURE_M)) {
6691 qemu_put_be32(f, env->v7m.other_sp);
6692 qemu_put_be32(f, env->v7m.vecbase);
6693 qemu_put_be32(f, env->v7m.basepri);
6694 qemu_put_be32(f, env->v7m.control);
6695 qemu_put_be32(f, env->v7m.current_sp);
6696 qemu_put_be32(f, env->v7m.exception);
6700 int cpu_load(QEMUFile *f, void *opaque, int version_id)
6702 CPUARMState *env = (CPUARMState *)opaque;
6705 if (version_id != ARM_CPU_SAVE_VERSION)
6708 for (i = 0; i < 16; i++) {
6709 env->regs[i] = qemu_get_be32(f);
6711 cpsr_write(env, qemu_get_be32(f), 0xffffffff);
6712 env->spsr = qemu_get_be32(f);
6713 for (i = 0; i < 6; i++) {
6714 env->banked_spsr[i] = qemu_get_be32(f);
6715 env->banked_r13[i] = qemu_get_be32(f);
6716 env->banked_r14[i] = qemu_get_be32(f);
6718 for (i = 0; i < 5; i++) {
6719 env->usr_regs[i] = qemu_get_be32(f);
6720 env->fiq_regs[i] = qemu_get_be32(f);
6722 env->cp15.c0_cpuid = qemu_get_be32(f);
6723 env->cp15.c0_cachetype = qemu_get_be32(f);
6724 env->cp15.c1_sys = qemu_get_be32(f);
6725 env->cp15.c1_coproc = qemu_get_be32(f);
6726 env->cp15.c1_xscaleauxcr = qemu_get_be32(f);
6727 env->cp15.c2_base0 = qemu_get_be32(f);
6728 env->cp15.c2_base1 = qemu_get_be32(f);
6729 env->cp15.c2_mask = qemu_get_be32(f);
6730 env->cp15.c2_data = qemu_get_be32(f);
6731 env->cp15.c2_insn = qemu_get_be32(f);
6732 env->cp15.c3 = qemu_get_be32(f);
6733 env->cp15.c5_insn = qemu_get_be32(f);
6734 env->cp15.c5_data = qemu_get_be32(f);
6735 for (i = 0; i < 8; i++) {
6736 env->cp15.c6_region[i] = qemu_get_be32(f);
6738 env->cp15.c6_insn = qemu_get_be32(f);
6739 env->cp15.c6_data = qemu_get_be32(f);
6740 env->cp15.c9_insn = qemu_get_be32(f);
6741 env->cp15.c9_data = qemu_get_be32(f);
6742 env->cp15.c13_fcse = qemu_get_be32(f);
6743 env->cp15.c13_context = qemu_get_be32(f);
6744 env->cp15.c13_tls1 = qemu_get_be32(f);
6745 env->cp15.c13_tls2 = qemu_get_be32(f);
6746 env->cp15.c13_tls3 = qemu_get_be32(f);
6747 env->cp15.c15_cpar = qemu_get_be32(f);
6749 env->features = qemu_get_be32(f);
6751 if (arm_feature(env, ARM_FEATURE_VFP)) {
6752 for (i = 0; i < 16; i++) {
6754 u.l.upper = qemu_get_be32(f);
6755 u.l.lower = qemu_get_be32(f);
6756 env->vfp.regs[i] = u.d;
6758 for (i = 0; i < 16; i++) {
6759 env->vfp.xregs[i] = qemu_get_be32(f);
6762 /* TODO: Should use proper FPSCR access functions. */
6763 env->vfp.vec_len = qemu_get_be32(f);
6764 env->vfp.vec_stride = qemu_get_be32(f);
6766 if (arm_feature(env, ARM_FEATURE_VFP3)) {
6767 for (i = 0; i < 16; i++) {
6769 u.l.upper = qemu_get_be32(f);
6770 u.l.lower = qemu_get_be32(f);
6771 env->vfp.regs[i] = u.d;
6776 if (arm_feature(env, ARM_FEATURE_IWMMXT)) {
6777 for (i = 0; i < 16; i++) {
6778 env->iwmmxt.regs[i] = qemu_get_be64(f);
6780 for (i = 0; i < 16; i++) {
6781 env->iwmmxt.cregs[i] = qemu_get_be32(f);
6785 if (arm_feature(env, ARM_FEATURE_M)) {
6786 env->v7m.other_sp = qemu_get_be32(f);
6787 env->v7m.vecbase = qemu_get_be32(f);
6788 env->v7m.basepri = qemu_get_be32(f);
6789 env->v7m.control = qemu_get_be32(f);
6790 env->v7m.current_sp = qemu_get_be32(f);
6791 env->v7m.exception = qemu_get_be32(f);
6799 //#warning No CPU save/restore functions
6803 /***********************************************************/
6804 /* ram save/restore */
6806 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6810 v = qemu_get_byte(f);
6813 if (qemu_get_buffer(f, buf, len) != len)
6817 v = qemu_get_byte(f);
6818 memset(buf, v, len);
6826 static int ram_load_v1(QEMUFile *f, void *opaque)
6830 if (qemu_get_be32(f) != phys_ram_size)
6832 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
6833 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
6840 #define BDRV_HASH_BLOCK_SIZE 1024
6841 #define IOBUF_SIZE 4096
6842 #define RAM_CBLOCK_MAGIC 0xfabe
6844 typedef struct RamCompressState {
6847 uint8_t buf[IOBUF_SIZE];
6850 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
6853 memset(s, 0, sizeof(*s));
6855 ret = deflateInit2(&s->zstream, 1,
6857 9, Z_DEFAULT_STRATEGY);
6860 s->zstream.avail_out = IOBUF_SIZE;
6861 s->zstream.next_out = s->buf;
6865 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
6867 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
6868 qemu_put_be16(s->f, len);
6869 qemu_put_buffer(s->f, buf, len);
6872 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
6876 s->zstream.avail_in = len;
6877 s->zstream.next_in = (uint8_t *)buf;
6878 while (s->zstream.avail_in > 0) {
6879 ret = deflate(&s->zstream, Z_NO_FLUSH);
6882 if (s->zstream.avail_out == 0) {
6883 ram_put_cblock(s, s->buf, IOBUF_SIZE);
6884 s->zstream.avail_out = IOBUF_SIZE;
6885 s->zstream.next_out = s->buf;
6891 static void ram_compress_close(RamCompressState *s)
6895 /* compress last bytes */
6897 ret = deflate(&s->zstream, Z_FINISH);
6898 if (ret == Z_OK || ret == Z_STREAM_END) {
6899 len = IOBUF_SIZE - s->zstream.avail_out;
6901 ram_put_cblock(s, s->buf, len);
6903 s->zstream.avail_out = IOBUF_SIZE;
6904 s->zstream.next_out = s->buf;
6905 if (ret == Z_STREAM_END)
6912 deflateEnd(&s->zstream);
6915 typedef struct RamDecompressState {
6918 uint8_t buf[IOBUF_SIZE];
6919 } RamDecompressState;
6921 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
6924 memset(s, 0, sizeof(*s));
6926 ret = inflateInit(&s->zstream);
6932 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
6936 s->zstream.avail_out = len;
6937 s->zstream.next_out = buf;
6938 while (s->zstream.avail_out > 0) {
6939 if (s->zstream.avail_in == 0) {
6940 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
6942 clen = qemu_get_be16(s->f);
6943 if (clen > IOBUF_SIZE)
6945 qemu_get_buffer(s->f, s->buf, clen);
6946 s->zstream.avail_in = clen;
6947 s->zstream.next_in = s->buf;
6949 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
6950 if (ret != Z_OK && ret != Z_STREAM_END) {
6957 static void ram_decompress_close(RamDecompressState *s)
6959 inflateEnd(&s->zstream);
6962 static void ram_save(QEMUFile *f, void *opaque)
6965 RamCompressState s1, *s = &s1;
6968 qemu_put_be32(f, phys_ram_size);
6969 if (ram_compress_open(s, f) < 0)
6971 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6973 if (tight_savevm_enabled) {
6977 /* find if the memory block is available on a virtual
6980 for(j = 0; j < nb_drives; j++) {
6981 sector_num = bdrv_hash_find(drives_table[j].bdrv,
6983 BDRV_HASH_BLOCK_SIZE);
6984 if (sector_num >= 0)
6988 goto normal_compress;
6991 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
6992 ram_compress_buf(s, buf, 10);
6998 ram_compress_buf(s, buf, 1);
6999 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
7002 ram_compress_close(s);
7005 static int ram_load(QEMUFile *f, void *opaque, int version_id)
7007 RamDecompressState s1, *s = &s1;
7011 if (version_id == 1)
7012 return ram_load_v1(f, opaque);
7013 if (version_id != 2)
7015 if (qemu_get_be32(f) != phys_ram_size)
7017 if (ram_decompress_open(s, f) < 0)
7019 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
7020 if (ram_decompress_buf(s, buf, 1) < 0) {
7021 fprintf(stderr, "Error while reading ram block header\n");
7025 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
7026 fprintf(stderr, "Error while reading ram block address=0x%08x", i);
7035 ram_decompress_buf(s, buf + 1, 9);
7037 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
7038 if (bs_index >= nb_drives) {
7039 fprintf(stderr, "Invalid block device index %d\n", bs_index);
7042 if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
7044 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
7045 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
7046 bs_index, sector_num);
7053 printf("Error block header\n");
7057 ram_decompress_close(s);
7061 /***********************************************************/
7062 /* bottom halves (can be seen as timers which expire ASAP) */
7071 static QEMUBH *first_bh = NULL;
7073 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
7076 bh = qemu_mallocz(sizeof(QEMUBH));
7080 bh->opaque = opaque;
7084 int qemu_bh_poll(void)
7103 void qemu_bh_schedule(QEMUBH *bh)
7105 CPUState *env = cpu_single_env;
7109 bh->next = first_bh;
7112 /* stop the currently executing CPU to execute the BH ASAP */
7114 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
7118 void qemu_bh_cancel(QEMUBH *bh)
7121 if (bh->scheduled) {
7124 pbh = &(*pbh)->next;
7130 void qemu_bh_delete(QEMUBH *bh)
7136 /***********************************************************/
7137 /* machine registration */
7139 QEMUMachine *first_machine = NULL;
7141 int qemu_register_machine(QEMUMachine *m)
7144 pm = &first_machine;
7152 static QEMUMachine *find_machine(const char *name)
7156 for(m = first_machine; m != NULL; m = m->next) {
7157 if (!strcmp(m->name, name))
7163 /***********************************************************/
7164 /* main execution loop */
7166 static void gui_update(void *opaque)
7168 DisplayState *ds = opaque;
7169 ds->dpy_refresh(ds);
7170 qemu_mod_timer(ds->gui_timer, GUI_REFRESH_INTERVAL + qemu_get_clock(rt_clock));
7173 struct vm_change_state_entry {
7174 VMChangeStateHandler *cb;
7176 LIST_ENTRY (vm_change_state_entry) entries;
7179 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
7181 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
7184 VMChangeStateEntry *e;
7186 e = qemu_mallocz(sizeof (*e));
7192 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
7196 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
7198 LIST_REMOVE (e, entries);
7202 static void vm_state_notify(int running)
7204 VMChangeStateEntry *e;
7206 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
7207 e->cb(e->opaque, running);
7211 /* XXX: support several handlers */
7212 static VMStopHandler *vm_stop_cb;
7213 static void *vm_stop_opaque;
7215 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
7218 vm_stop_opaque = opaque;
7222 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
7233 qemu_rearm_alarm_timer(alarm_timer);
7237 void vm_stop(int reason)
7240 cpu_disable_ticks();
7244 vm_stop_cb(vm_stop_opaque, reason);
7251 /* reset/shutdown handler */
7253 typedef struct QEMUResetEntry {
7254 QEMUResetHandler *func;
7256 struct QEMUResetEntry *next;
7259 static QEMUResetEntry *first_reset_entry;
7260 static int reset_requested;
7261 static int shutdown_requested;
7262 static int powerdown_requested;
7264 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
7266 QEMUResetEntry **pre, *re;
7268 pre = &first_reset_entry;
7269 while (*pre != NULL)
7270 pre = &(*pre)->next;
7271 re = qemu_mallocz(sizeof(QEMUResetEntry));
7273 re->opaque = opaque;
7278 static void qemu_system_reset(void)
7282 /* reset all devices */
7283 for(re = first_reset_entry; re != NULL; re = re->next) {
7284 re->func(re->opaque);
7288 void qemu_system_reset_request(void)
7291 shutdown_requested = 1;
7293 reset_requested = 1;
7296 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7299 void qemu_system_shutdown_request(void)
7301 shutdown_requested = 1;
7303 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7306 void qemu_system_powerdown_request(void)
7308 powerdown_requested = 1;
7310 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
7313 void main_loop_wait(int timeout)
7315 IOHandlerRecord *ioh;
7316 fd_set rfds, wfds, xfds;
7325 /* XXX: need to suppress polling by better using win32 events */
7327 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
7328 ret |= pe->func(pe->opaque);
7333 WaitObjects *w = &wait_objects;
7335 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
7336 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
7337 if (w->func[ret - WAIT_OBJECT_0])
7338 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
7340 /* Check for additional signaled events */
7341 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
7343 /* Check if event is signaled */
7344 ret2 = WaitForSingleObject(w->events[i], 0);
7345 if(ret2 == WAIT_OBJECT_0) {
7347 w->func[i](w->opaque[i]);
7348 } else if (ret2 == WAIT_TIMEOUT) {
7350 err = GetLastError();
7351 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
7354 } else if (ret == WAIT_TIMEOUT) {
7356 err = GetLastError();
7357 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
7361 /* poll any events */
7362 /* XXX: separate device handlers from system ones */
7367 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7371 (!ioh->fd_read_poll ||
7372 ioh->fd_read_poll(ioh->opaque) != 0)) {
7373 FD_SET(ioh->fd, &rfds);
7377 if (ioh->fd_write) {
7378 FD_SET(ioh->fd, &wfds);
7388 tv.tv_usec = timeout * 1000;
7390 #if defined(CONFIG_SLIRP)
7392 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
7395 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
7397 IOHandlerRecord **pioh;
7399 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
7400 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
7401 ioh->fd_read(ioh->opaque);
7403 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
7404 ioh->fd_write(ioh->opaque);
7408 /* remove deleted IO handlers */
7409 pioh = &first_io_handler;
7419 #if defined(CONFIG_SLIRP)
7426 slirp_select_poll(&rfds, &wfds, &xfds);
7432 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
7433 qemu_get_clock(vm_clock));
7434 /* run dma transfers, if any */
7438 /* real time timers */
7439 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
7440 qemu_get_clock(rt_clock));
7442 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
7443 alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
7444 qemu_rearm_alarm_timer(alarm_timer);
7447 /* Check bottom-halves last in case any of the earlier events triggered
7453 static int main_loop(void)
7456 #ifdef CONFIG_PROFILER
7461 cur_cpu = first_cpu;
7462 next_cpu = cur_cpu->next_cpu ?: first_cpu;
7469 #ifdef CONFIG_PROFILER
7470 ti = profile_getclock();
7472 ret = cpu_exec(env);
7473 #ifdef CONFIG_PROFILER
7474 qemu_time += profile_getclock() - ti;
7476 next_cpu = env->next_cpu ?: first_cpu;
7477 if (event_pending) {
7478 ret = EXCP_INTERRUPT;
7482 if (ret == EXCP_HLT) {
7483 /* Give the next CPU a chance to run. */
7487 if (ret != EXCP_HALTED)
7489 /* all CPUs are halted ? */
7495 if (shutdown_requested) {
7496 ret = EXCP_INTERRUPT;
7499 if (reset_requested) {
7500 reset_requested = 0;
7501 qemu_system_reset();
7502 ret = EXCP_INTERRUPT;
7504 if (powerdown_requested) {
7505 powerdown_requested = 0;
7506 qemu_system_powerdown();
7507 ret = EXCP_INTERRUPT;
7509 if (ret == EXCP_DEBUG) {
7510 vm_stop(EXCP_DEBUG);
7512 /* If all cpus are halted then wait until the next IRQ */
7513 /* XXX: use timeout computed from timers */
7514 if (ret == EXCP_HALTED)
7521 #ifdef CONFIG_PROFILER
7522 ti = profile_getclock();
7524 main_loop_wait(timeout);
7525 #ifdef CONFIG_PROFILER
7526 dev_time += profile_getclock() - ti;
7529 cpu_disable_ticks();
7533 static void help(int exitcode)
7535 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7536 "usage: %s [options] [disk_image]\n"
7538 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7540 "Standard options:\n"
7541 "-M machine select emulated machine (-M ? for list)\n"
7542 "-cpu cpu select CPU (-cpu ? for list)\n"
7543 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7544 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7545 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7546 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7547 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][index=i]\n"
7548 " [,cyls=c,heads=h,secs=s[,trans=t]][snapshot=on|off]"
7549 " [,cache=on|off]\n"
7550 " use 'file' as a drive image\n"
7551 "-mtdblock file use 'file' as on-board Flash memory image\n"
7552 "-sd file use 'file' as SecureDigital card image\n"
7553 "-pflash file use 'file' as a parallel flash image\n"
7554 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7555 "-snapshot write to temporary files instead of disk image files\n"
7557 "-no-frame open SDL window without a frame and window decorations\n"
7558 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7559 "-no-quit disable SDL window close capability\n"
7562 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7564 "-m megs set virtual RAM size to megs MB [default=%d]\n"
7565 "-smp n set the number of CPUs to 'n' [default=1]\n"
7566 "-nographic disable graphical output and redirect serial I/Os to console\n"
7567 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7569 "-k language use keyboard layout (for example \"fr\" for French)\n"
7572 "-audio-help print list of audio drivers and their options\n"
7573 "-soundhw c1,... enable audio support\n"
7574 " and only specified sound cards (comma separated list)\n"
7575 " use -soundhw ? to get the list of supported cards\n"
7576 " use -soundhw all to enable all of them\n"
7578 "-localtime set the real time clock to local time [default=utc]\n"
7579 "-full-screen start in full screen\n"
7581 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7583 "-usb enable the USB driver (will be the default soon)\n"
7584 "-usbdevice name add the host or guest USB device 'name'\n"
7585 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7586 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7588 "-name string set the name of the guest\n"
7590 "Network options:\n"
7591 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7592 " create a new Network Interface Card and connect it to VLAN 'n'\n"
7594 "-net user[,vlan=n][,hostname=host]\n"
7595 " connect the user mode network stack to VLAN 'n' and send\n"
7596 " hostname 'host' to DHCP clients\n"
7599 "-net tap[,vlan=n],ifname=name\n"
7600 " connect the host TAP network interface to VLAN 'n'\n"
7602 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7603 " connect the host TAP network interface to VLAN 'n' and use the\n"
7604 " network scripts 'file' (default=%s)\n"
7605 " and 'dfile' (default=%s);\n"
7606 " use '[down]script=no' to disable script execution;\n"
7607 " use 'fd=h' to connect to an already opened TAP interface\n"
7609 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7610 " connect the vlan 'n' to another VLAN using a socket connection\n"
7611 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7612 " connect the vlan 'n' to multicast maddr and port\n"
7613 "-net none use it alone to have zero network devices; if no -net option\n"
7614 " is provided, the default is '-net nic -net user'\n"
7617 "-tftp dir allow tftp access to files in dir [-net user]\n"
7618 "-bootp file advertise file in BOOTP replies\n"
7620 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
7622 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7623 " redirect TCP or UDP connections from host to guest [-net user]\n"
7626 "Linux boot specific:\n"
7627 "-kernel bzImage use 'bzImage' as kernel image\n"
7628 "-append cmdline use 'cmdline' as kernel command line\n"
7629 "-initrd file use 'file' as initial ram disk\n"
7631 "Debug/Expert options:\n"
7632 "-monitor dev redirect the monitor to char device 'dev'\n"
7633 "-serial dev redirect the serial port to char device 'dev'\n"
7634 "-parallel dev redirect the parallel port to char device 'dev'\n"
7635 "-pidfile file Write PID to 'file'\n"
7636 "-S freeze CPU at startup (use 'c' to start execution)\n"
7637 "-s wait gdb connection to port\n"
7638 "-p port set gdb connection port [default=%s]\n"
7639 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
7640 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7641 " translation (t=none or lba) (usually qemu can guess them)\n"
7642 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7644 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7645 "-no-kqemu disable KQEMU kernel module usage\n"
7648 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7649 " (default is CL-GD5446 PCI VGA)\n"
7650 "-no-acpi disable ACPI\n"
7652 "-no-reboot exit instead of rebooting\n"
7653 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
7654 "-vnc display start a VNC server on display\n"
7656 "-daemonize daemonize QEMU after initializing\n"
7658 "-option-rom rom load a file, rom, into the option ROM space\n"
7660 "-prom-env variable=value set OpenBIOS nvram variables\n"
7662 "-clock force the use of the given methods for timer alarm.\n"
7663 " To see what timers are available use -clock help\n"
7664 "-startdate select initial date of the clock\n"
7666 "During emulation, the following keys are useful:\n"
7667 "ctrl-alt-f toggle full screen\n"
7668 "ctrl-alt-n switch to virtual console 'n'\n"
7669 "ctrl-alt toggle mouse and keyboard grab\n"
7671 "When using -nographic, press 'ctrl-a h' to get some help.\n"
7676 DEFAULT_NETWORK_SCRIPT,
7677 DEFAULT_NETWORK_DOWN_SCRIPT,
7679 DEFAULT_GDBSTUB_PORT,
7684 #define HAS_ARG 0x0001
7699 QEMU_OPTION_mtdblock,
7703 QEMU_OPTION_snapshot,
7705 QEMU_OPTION_no_fd_bootchk,
7708 QEMU_OPTION_nographic,
7709 QEMU_OPTION_portrait,
7711 QEMU_OPTION_audio_help,
7712 QEMU_OPTION_soundhw,
7732 QEMU_OPTION_no_code_copy,
7734 QEMU_OPTION_localtime,
7735 QEMU_OPTION_cirrusvga,
7738 QEMU_OPTION_std_vga,
7740 QEMU_OPTION_monitor,
7742 QEMU_OPTION_parallel,
7744 QEMU_OPTION_full_screen,
7745 QEMU_OPTION_no_frame,
7746 QEMU_OPTION_alt_grab,
7747 QEMU_OPTION_no_quit,
7748 QEMU_OPTION_pidfile,
7749 QEMU_OPTION_no_kqemu,
7750 QEMU_OPTION_kernel_kqemu,
7751 QEMU_OPTION_win2k_hack,
7753 QEMU_OPTION_usbdevice,
7756 QEMU_OPTION_no_acpi,
7757 QEMU_OPTION_no_reboot,
7758 QEMU_OPTION_show_cursor,
7759 QEMU_OPTION_daemonize,
7760 QEMU_OPTION_option_rom,
7761 QEMU_OPTION_semihosting,
7763 QEMU_OPTION_prom_env,
7764 QEMU_OPTION_old_param,
7766 QEMU_OPTION_startdate,
7769 typedef struct QEMUOption {
7775 const QEMUOption qemu_options[] = {
7776 { "h", 0, QEMU_OPTION_h },
7777 { "help", 0, QEMU_OPTION_h },
7779 { "M", HAS_ARG, QEMU_OPTION_M },
7780 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
7781 { "fda", HAS_ARG, QEMU_OPTION_fda },
7782 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
7783 { "hda", HAS_ARG, QEMU_OPTION_hda },
7784 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
7785 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
7786 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
7787 { "drive", HAS_ARG, QEMU_OPTION_drive },
7788 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7789 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
7790 { "sd", HAS_ARG, QEMU_OPTION_sd },
7791 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
7792 { "boot", HAS_ARG, QEMU_OPTION_boot },
7793 { "snapshot", 0, QEMU_OPTION_snapshot },
7795 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
7797 { "m", HAS_ARG, QEMU_OPTION_m },
7798 { "nographic", 0, QEMU_OPTION_nographic },
7799 { "portrait", 0, QEMU_OPTION_portrait },
7800 { "k", HAS_ARG, QEMU_OPTION_k },
7802 { "audio-help", 0, QEMU_OPTION_audio_help },
7803 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
7806 { "net", HAS_ARG, QEMU_OPTION_net},
7808 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
7809 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
7811 { "smb", HAS_ARG, QEMU_OPTION_smb },
7813 { "redir", HAS_ARG, QEMU_OPTION_redir },
7816 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
7817 { "append", HAS_ARG, QEMU_OPTION_append },
7818 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
7820 { "S", 0, QEMU_OPTION_S },
7821 { "s", 0, QEMU_OPTION_s },
7822 { "p", HAS_ARG, QEMU_OPTION_p },
7823 { "d", HAS_ARG, QEMU_OPTION_d },
7824 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
7825 { "L", HAS_ARG, QEMU_OPTION_L },
7826 { "bios", HAS_ARG, QEMU_OPTION_bios },
7827 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
7829 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
7830 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7832 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7833 { "g", 1, QEMU_OPTION_g },
7835 { "localtime", 0, QEMU_OPTION_localtime },
7836 { "std-vga", 0, QEMU_OPTION_std_vga },
7837 { "echr", HAS_ARG, QEMU_OPTION_echr },
7838 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
7839 { "serial", HAS_ARG, QEMU_OPTION_serial },
7840 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
7841 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
7842 { "full-screen", 0, QEMU_OPTION_full_screen },
7844 { "no-frame", 0, QEMU_OPTION_no_frame },
7845 { "alt-grab", 0, QEMU_OPTION_alt_grab },
7846 { "no-quit", 0, QEMU_OPTION_no_quit },
7848 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7849 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
7850 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
7851 { "smp", HAS_ARG, QEMU_OPTION_smp },
7852 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
7854 /* temporary options */
7855 { "usb", 0, QEMU_OPTION_usb },
7856 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
7857 { "vmwarevga", 0, QEMU_OPTION_vmsvga },
7858 { "no-acpi", 0, QEMU_OPTION_no_acpi },
7859 { "no-reboot", 0, QEMU_OPTION_no_reboot },
7860 { "show-cursor", 0, QEMU_OPTION_show_cursor },
7861 { "daemonize", 0, QEMU_OPTION_daemonize },
7862 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
7863 #if defined(TARGET_ARM) || defined(TARGET_M68K)
7864 { "semihosting", 0, QEMU_OPTION_semihosting },
7866 { "name", HAS_ARG, QEMU_OPTION_name },
7867 #if defined(TARGET_SPARC)
7868 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
7870 #if defined(TARGET_ARM)
7871 { "old-param", 0, QEMU_OPTION_old_param },
7873 { "clock", HAS_ARG, QEMU_OPTION_clock },
7874 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
7878 /* password input */
7880 int qemu_key_check(BlockDriverState *bs, const char *name)
7885 if (!bdrv_is_encrypted(bs))
7888 term_printf("%s is encrypted.\n", name);
7889 for(i = 0; i < 3; i++) {
7890 monitor_readline("Password: ", 1, password, sizeof(password));
7891 if (bdrv_set_key(bs, password) == 0)
7893 term_printf("invalid password\n");
7898 static BlockDriverState *get_bdrv(int index)
7900 if (index > nb_drives)
7902 return drives_table[index].bdrv;
7905 static void read_passwords(void)
7907 BlockDriverState *bs;
7910 for(i = 0; i < 6; i++) {
7913 qemu_key_check(bs, bdrv_get_device_name(bs));
7917 /* XXX: currently we cannot use simultaneously different CPUs */
7918 static void register_machines(void)
7920 #if defined(TARGET_I386)
7921 qemu_register_machine(&pc_machine);
7922 qemu_register_machine(&isapc_machine);
7923 #elif defined(TARGET_PPC)
7924 qemu_register_machine(&heathrow_machine);
7925 qemu_register_machine(&core99_machine);
7926 qemu_register_machine(&prep_machine);
7927 qemu_register_machine(&ref405ep_machine);
7928 qemu_register_machine(&taihu_machine);
7929 #elif defined(TARGET_MIPS)
7930 qemu_register_machine(&mips_machine);
7931 qemu_register_machine(&mips_malta_machine);
7932 qemu_register_machine(&mips_pica61_machine);
7933 qemu_register_machine(&mips_mipssim_machine);
7934 #elif defined(TARGET_SPARC)
7935 #ifdef TARGET_SPARC64
7936 qemu_register_machine(&sun4u_machine);
7938 qemu_register_machine(&ss5_machine);
7939 qemu_register_machine(&ss10_machine);
7940 qemu_register_machine(&ss600mp_machine);
7941 qemu_register_machine(&ss20_machine);
7942 qemu_register_machine(&ss2_machine);
7943 qemu_register_machine(&ss1000_machine);
7944 qemu_register_machine(&ss2000_machine);
7946 #elif defined(TARGET_ARM)
7947 qemu_register_machine(&integratorcp_machine);
7948 qemu_register_machine(&versatilepb_machine);
7949 qemu_register_machine(&versatileab_machine);
7950 qemu_register_machine(&realview_machine);
7951 qemu_register_machine(&akitapda_machine);
7952 qemu_register_machine(&spitzpda_machine);
7953 qemu_register_machine(&borzoipda_machine);
7954 qemu_register_machine(&terrierpda_machine);
7955 qemu_register_machine(&palmte_machine);
7956 qemu_register_machine(&lm3s811evb_machine);
7957 qemu_register_machine(&lm3s6965evb_machine);
7958 qemu_register_machine(&connex_machine);
7959 qemu_register_machine(&verdex_machine);
7960 qemu_register_machine(&mainstone2_machine);
7961 #elif defined(TARGET_SH4)
7962 qemu_register_machine(&shix_machine);
7963 qemu_register_machine(&r2d_machine);
7964 #elif defined(TARGET_ALPHA)
7966 #elif defined(TARGET_M68K)
7967 qemu_register_machine(&mcf5208evb_machine);
7968 qemu_register_machine(&an5206_machine);
7969 qemu_register_machine(&dummy_m68k_machine);
7970 #elif defined(TARGET_CRIS)
7971 qemu_register_machine(&bareetraxfs_machine);
7973 #error unsupported CPU
7978 struct soundhw soundhw[] = {
7979 #ifdef HAS_AUDIO_CHOICE
7986 { .init_isa = pcspk_audio_init }
7991 "Creative Sound Blaster 16",
7994 { .init_isa = SB16_init }
8001 "Yamaha YMF262 (OPL3)",
8003 "Yamaha YM3812 (OPL2)",
8007 { .init_isa = Adlib_init }
8014 "Gravis Ultrasound GF1",
8017 { .init_isa = GUS_init }
8024 "Intel 82801AA AC97 Audio",
8027 { .init_pci = ac97_init }
8033 "ENSONIQ AudioPCI ES1370",
8036 { .init_pci = es1370_init }
8040 { NULL, NULL, 0, 0, { NULL } }
8043 static void select_soundhw (const char *optarg)
8047 if (*optarg == '?') {
8050 printf ("Valid sound card names (comma separated):\n");
8051 for (c = soundhw; c->name; ++c) {
8052 printf ("%-11s %s\n", c->name, c->descr);
8054 printf ("\n-soundhw all will enable all of the above\n");
8055 exit (*optarg != '?');
8063 if (!strcmp (optarg, "all")) {
8064 for (c = soundhw; c->name; ++c) {
8072 e = strchr (p, ',');
8073 l = !e ? strlen (p) : (size_t) (e - p);
8075 for (c = soundhw; c->name; ++c) {
8076 if (!strncmp (c->name, p, l)) {
8085 "Unknown sound card name (too big to show)\n");
8088 fprintf (stderr, "Unknown sound card name `%.*s'\n",
8093 p += l + (e != NULL);
8097 goto show_valid_cards;
8103 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
8105 exit(STATUS_CONTROL_C_EXIT);
8110 #define MAX_NET_CLIENTS 32
8112 int main(int argc, char **argv)
8114 #ifdef CONFIG_GDBSTUB
8116 const char *gdbstub_port;
8118 uint32_t boot_devices_bitmap = 0;
8120 int snapshot, linux_boot, net_boot;
8121 const char *initrd_filename;
8122 const char *kernel_filename, *kernel_cmdline;
8123 const char *boot_devices = "";
8124 DisplayState *ds = &display_state;
8125 int cyls, heads, secs, translation;
8126 char net_clients[MAX_NET_CLIENTS][256];
8130 const char *r, *optarg;
8131 CharDriverState *monitor_hd;
8132 char monitor_device[128];
8133 char serial_devices[MAX_SERIAL_PORTS][128];
8134 int serial_device_index;
8135 char parallel_devices[MAX_PARALLEL_PORTS][128];
8136 int parallel_device_index;
8137 const char *loadvm = NULL;
8138 QEMUMachine *machine;
8139 const char *cpu_model;
8140 char usb_devices[MAX_USB_CMDLINE][128];
8141 int usb_devices_index;
8143 const char *pid_file = NULL;
8146 LIST_INIT (&vm_change_state_head);
8149 struct sigaction act;
8150 sigfillset(&act.sa_mask);
8152 act.sa_handler = SIG_IGN;
8153 sigaction(SIGPIPE, &act, NULL);
8156 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
8157 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8158 QEMU to run on a single CPU */
8163 h = GetCurrentProcess();
8164 if (GetProcessAffinityMask(h, &mask, &smask)) {
8165 for(i = 0; i < 32; i++) {
8166 if (mask & (1 << i))
8171 SetProcessAffinityMask(h, mask);
8177 register_machines();
8178 machine = first_machine;
8180 initrd_filename = NULL;
8181 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8182 vga_ram_size = VGA_RAM_SIZE;
8183 #ifdef CONFIG_GDBSTUB
8185 gdbstub_port = DEFAULT_GDBSTUB_PORT;
8189 kernel_filename = NULL;
8190 kernel_cmdline = "";
8191 cyls = heads = secs = 0;
8192 translation = BIOS_ATA_TRANSLATION_AUTO;
8193 pstrcpy(monitor_device, sizeof(monitor_device), "vc");
8195 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "vc");
8196 for(i = 1; i < MAX_SERIAL_PORTS; i++)
8197 serial_devices[i][0] = '\0';
8198 serial_device_index = 0;
8200 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "vc");
8201 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
8202 parallel_devices[i][0] = '\0';
8203 parallel_device_index = 0;
8205 usb_devices_index = 0;
8213 /* default mac address of the first network interface */
8221 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
8223 const QEMUOption *popt;
8226 /* Treat --foo the same as -foo. */
8229 popt = qemu_options;
8232 fprintf(stderr, "%s: invalid option -- '%s'\n",
8236 if (!strcmp(popt->name, r + 1))
8240 if (popt->flags & HAS_ARG) {
8241 if (optind >= argc) {
8242 fprintf(stderr, "%s: option '%s' requires an argument\n",
8246 optarg = argv[optind++];
8251 switch(popt->index) {
8253 machine = find_machine(optarg);
8256 printf("Supported machines are:\n");
8257 for(m = first_machine; m != NULL; m = m->next) {
8258 printf("%-10s %s%s\n",
8260 m == first_machine ? " (default)" : "");
8262 exit(*optarg != '?');
8265 case QEMU_OPTION_cpu:
8266 /* hw initialization will check this */
8267 if (*optarg == '?') {
8268 /* XXX: implement xxx_cpu_list for targets that still miss it */
8269 #if defined(cpu_list)
8270 cpu_list(stdout, &fprintf);
8277 case QEMU_OPTION_initrd:
8278 initrd_filename = optarg;
8280 case QEMU_OPTION_hda:
8282 hda_index = drive_add(optarg, HD_ALIAS, 0);
8284 hda_index = drive_add(optarg, HD_ALIAS
8285 ",cyls=%d,heads=%d,secs=%d%s",
8286 0, cyls, heads, secs,
8287 translation == BIOS_ATA_TRANSLATION_LBA ?
8289 translation == BIOS_ATA_TRANSLATION_NONE ?
8290 ",trans=none" : "");
8292 case QEMU_OPTION_hdb:
8293 case QEMU_OPTION_hdc:
8294 case QEMU_OPTION_hdd:
8295 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
8297 case QEMU_OPTION_drive:
8298 drive_add(NULL, "%s", optarg);
8300 case QEMU_OPTION_mtdblock:
8301 drive_add(optarg, MTD_ALIAS);
8303 case QEMU_OPTION_sd:
8304 drive_add(optarg, SD_ALIAS);
8306 case QEMU_OPTION_pflash:
8307 drive_add(optarg, PFLASH_ALIAS);
8309 case QEMU_OPTION_snapshot:
8312 case QEMU_OPTION_hdachs:
8316 cyls = strtol(p, (char **)&p, 0);
8317 if (cyls < 1 || cyls > 16383)
8322 heads = strtol(p, (char **)&p, 0);
8323 if (heads < 1 || heads > 16)
8328 secs = strtol(p, (char **)&p, 0);
8329 if (secs < 1 || secs > 63)
8333 if (!strcmp(p, "none"))
8334 translation = BIOS_ATA_TRANSLATION_NONE;
8335 else if (!strcmp(p, "lba"))
8336 translation = BIOS_ATA_TRANSLATION_LBA;
8337 else if (!strcmp(p, "auto"))
8338 translation = BIOS_ATA_TRANSLATION_AUTO;
8341 } else if (*p != '\0') {
8343 fprintf(stderr, "qemu: invalid physical CHS format\n");
8346 if (hda_index != -1)
8347 snprintf(drives_opt[hda_index].opt,
8348 sizeof(drives_opt[hda_index].opt),
8349 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
8350 0, cyls, heads, secs,
8351 translation == BIOS_ATA_TRANSLATION_LBA ?
8353 translation == BIOS_ATA_TRANSLATION_NONE ?
8354 ",trans=none" : "");
8357 case QEMU_OPTION_nographic:
8358 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "stdio");
8359 pstrcpy(parallel_devices[0], sizeof(parallel_devices[0]), "null");
8360 pstrcpy(monitor_device, sizeof(monitor_device), "stdio");
8363 case QEMU_OPTION_portrait:
8366 case QEMU_OPTION_kernel:
8367 kernel_filename = optarg;
8369 case QEMU_OPTION_append:
8370 kernel_cmdline = optarg;
8372 case QEMU_OPTION_cdrom:
8373 drive_add(optarg, CDROM_ALIAS);
8375 case QEMU_OPTION_boot:
8376 boot_devices = optarg;
8377 /* We just do some generic consistency checks */
8379 /* Could easily be extended to 64 devices if needed */
8382 boot_devices_bitmap = 0;
8383 for (p = boot_devices; *p != '\0'; p++) {
8384 /* Allowed boot devices are:
8385 * a b : floppy disk drives
8386 * c ... f : IDE disk drives
8387 * g ... m : machine implementation dependant drives
8388 * n ... p : network devices
8389 * It's up to each machine implementation to check
8390 * if the given boot devices match the actual hardware
8391 * implementation and firmware features.
8393 if (*p < 'a' || *p > 'q') {
8394 fprintf(stderr, "Invalid boot device '%c'\n", *p);
8397 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
8399 "Boot device '%c' was given twice\n",*p);
8402 boot_devices_bitmap |= 1 << (*p - 'a');
8406 case QEMU_OPTION_fda:
8407 case QEMU_OPTION_fdb:
8408 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
8411 case QEMU_OPTION_no_fd_bootchk:
8415 case QEMU_OPTION_no_code_copy:
8416 code_copy_enabled = 0;
8418 case QEMU_OPTION_net:
8419 if (nb_net_clients >= MAX_NET_CLIENTS) {
8420 fprintf(stderr, "qemu: too many network clients\n");
8423 pstrcpy(net_clients[nb_net_clients],
8424 sizeof(net_clients[0]),
8429 case QEMU_OPTION_tftp:
8430 tftp_prefix = optarg;
8432 case QEMU_OPTION_bootp:
8433 bootp_filename = optarg;
8436 case QEMU_OPTION_smb:
8437 net_slirp_smb(optarg);
8440 case QEMU_OPTION_redir:
8441 net_slirp_redir(optarg);
8445 case QEMU_OPTION_audio_help:
8449 case QEMU_OPTION_soundhw:
8450 select_soundhw (optarg);
8457 ram_size = atoi(optarg) * 1024 * 1024;
8460 if (ram_size > PHYS_RAM_MAX_SIZE) {
8461 fprintf(stderr, "qemu: at most %d MB RAM can be simulated\n",
8462 PHYS_RAM_MAX_SIZE / (1024 * 1024));
8471 mask = cpu_str_to_log_mask(optarg);
8473 printf("Log items (comma separated):\n");
8474 for(item = cpu_log_items; item->mask != 0; item++) {
8475 printf("%-10s %s\n", item->name, item->help);
8482 #ifdef CONFIG_GDBSTUB
8487 gdbstub_port = optarg;
8493 case QEMU_OPTION_bios:
8500 keyboard_layout = optarg;
8502 case QEMU_OPTION_localtime:
8505 case QEMU_OPTION_cirrusvga:
8506 cirrus_vga_enabled = 1;
8509 case QEMU_OPTION_vmsvga:
8510 cirrus_vga_enabled = 0;
8513 case QEMU_OPTION_std_vga:
8514 cirrus_vga_enabled = 0;
8522 w = strtol(p, (char **)&p, 10);
8525 fprintf(stderr, "qemu: invalid resolution or depth\n");
8531 h = strtol(p, (char **)&p, 10);
8536 depth = strtol(p, (char **)&p, 10);
8537 if (depth != 8 && depth != 15 && depth != 16 &&
8538 depth != 24 && depth != 32)
8540 } else if (*p == '\0') {
8541 depth = graphic_depth;
8548 graphic_depth = depth;
8551 case QEMU_OPTION_echr:
8554 term_escape_char = strtol(optarg, &r, 0);
8556 printf("Bad argument to echr\n");
8559 case QEMU_OPTION_monitor:
8560 pstrcpy(monitor_device, sizeof(monitor_device), optarg);
8562 case QEMU_OPTION_serial:
8563 if (serial_device_index >= MAX_SERIAL_PORTS) {
8564 fprintf(stderr, "qemu: too many serial ports\n");
8567 pstrcpy(serial_devices[serial_device_index],
8568 sizeof(serial_devices[0]), optarg);
8569 serial_device_index++;
8571 case QEMU_OPTION_parallel:
8572 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8573 fprintf(stderr, "qemu: too many parallel ports\n");
8576 pstrcpy(parallel_devices[parallel_device_index],
8577 sizeof(parallel_devices[0]), optarg);
8578 parallel_device_index++;
8580 case QEMU_OPTION_loadvm:
8583 case QEMU_OPTION_full_screen:
8587 case QEMU_OPTION_no_frame:
8590 case QEMU_OPTION_alt_grab:
8593 case QEMU_OPTION_no_quit:
8597 case QEMU_OPTION_pidfile:
8601 case QEMU_OPTION_win2k_hack:
8602 win2k_install_hack = 1;
8606 case QEMU_OPTION_no_kqemu:
8609 case QEMU_OPTION_kernel_kqemu:
8613 case QEMU_OPTION_usb:
8616 case QEMU_OPTION_usbdevice:
8618 if (usb_devices_index >= MAX_USB_CMDLINE) {
8619 fprintf(stderr, "Too many USB devices\n");
8622 pstrcpy(usb_devices[usb_devices_index],
8623 sizeof(usb_devices[usb_devices_index]),
8625 usb_devices_index++;
8627 case QEMU_OPTION_smp:
8628 smp_cpus = atoi(optarg);
8629 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
8630 fprintf(stderr, "Invalid number of CPUs\n");
8634 case QEMU_OPTION_vnc:
8635 vnc_display = optarg;
8637 case QEMU_OPTION_no_acpi:
8640 case QEMU_OPTION_no_reboot:
8643 case QEMU_OPTION_show_cursor:
8646 case QEMU_OPTION_daemonize:
8649 case QEMU_OPTION_option_rom:
8650 if (nb_option_roms >= MAX_OPTION_ROMS) {
8651 fprintf(stderr, "Too many option ROMs\n");
8654 option_rom[nb_option_roms] = optarg;
8657 case QEMU_OPTION_semihosting:
8658 semihosting_enabled = 1;
8660 case QEMU_OPTION_name:
8664 case QEMU_OPTION_prom_env:
8665 if (nb_prom_envs >= MAX_PROM_ENVS) {
8666 fprintf(stderr, "Too many prom variables\n");
8669 prom_envs[nb_prom_envs] = optarg;
8674 case QEMU_OPTION_old_param:
8678 case QEMU_OPTION_clock:
8679 configure_alarms(optarg);
8681 case QEMU_OPTION_startdate:
8684 if (!strcmp(optarg, "now")) {
8685 rtc_start_date = -1;
8687 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
8695 } else if (sscanf(optarg, "%d-%d-%d",
8698 &tm.tm_mday) == 3) {
8707 rtc_start_date = mktimegm(&tm);
8708 if (rtc_start_date == -1) {
8710 fprintf(stderr, "Invalid date format. Valid format are:\n"
8711 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8722 if (daemonize && !nographic && vnc_display == NULL) {
8723 fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
8730 if (pipe(fds) == -1)
8741 len = read(fds[0], &status, 1);
8742 if (len == -1 && (errno == EINTR))
8747 else if (status == 1) {
8748 fprintf(stderr, "Could not acquire pidfile\n");
8766 signal(SIGTSTP, SIG_IGN);
8767 signal(SIGTTOU, SIG_IGN);
8768 signal(SIGTTIN, SIG_IGN);
8772 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
8775 write(fds[1], &status, 1);
8777 fprintf(stderr, "Could not acquire pid file\n");
8785 linux_boot = (kernel_filename != NULL);
8786 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
8788 /* XXX: this should not be: some embedded targets just have flash */
8789 if (!linux_boot && net_boot == 0 &&
8793 /* boot to floppy or the default cd if no hard disk defined yet */
8794 if (!boot_devices[0]) {
8795 boot_devices = "cad";
8797 setvbuf(stdout, NULL, _IOLBF, 0);
8807 /* init network clients */
8808 if (nb_net_clients == 0) {
8809 /* if no clients, we use a default config */
8810 pstrcpy(net_clients[0], sizeof(net_clients[0]),
8812 pstrcpy(net_clients[1], sizeof(net_clients[0]),
8817 for(i = 0;i < nb_net_clients; i++) {
8818 if (net_client_init(net_clients[i]) < 0)
8821 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8822 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
8824 if (vlan->nb_guest_devs == 0) {
8825 fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
8828 if (vlan->nb_host_devs == 0)
8830 "Warning: vlan %d is not connected to host network\n",
8835 /* XXX: this should be moved in the PC machine instantiation code */
8836 if (net_boot != 0) {
8838 for (i = 0; i < nb_nics && i < 4; i++) {
8839 const char *model = nd_table[i].model;
8841 if (net_boot & (1 << i)) {
8844 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
8845 if (get_image_size(buf) > 0) {
8846 if (nb_option_roms >= MAX_OPTION_ROMS) {
8847 fprintf(stderr, "Too many option ROMs\n");
8850 option_rom[nb_option_roms] = strdup(buf);
8857 fprintf(stderr, "No valid PXE rom found for network device\n");
8863 /* init the memory */
8864 phys_ram_size = ram_size + vga_ram_size + MAX_BIOS_SIZE;
8866 phys_ram_base = qemu_vmalloc(phys_ram_size);
8867 if (!phys_ram_base) {
8868 fprintf(stderr, "Could not allocate physical memory\n");
8874 /* we always create the cdrom drive, even if no disk is there */
8876 if (nb_drives_opt < MAX_DRIVES)
8877 drive_add(NULL, CDROM_ALIAS);
8879 /* we always create at least one floppy */
8881 if (nb_drives_opt < MAX_DRIVES)
8882 drive_add(NULL, FD_ALIAS, 0);
8884 /* we always create one sd slot, even if no card is in it */
8886 if (nb_drives_opt < MAX_DRIVES)
8887 drive_add(NULL, SD_ALIAS);
8889 /* open the virtual block devices */
8891 for(i = 0; i < nb_drives_opt; i++)
8892 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
8895 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
8896 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8901 memset(&display_state, 0, sizeof(display_state));
8903 /* nearly nothing to do */
8904 dumb_display_init(ds);
8905 } else if (vnc_display != NULL) {
8906 vnc_display_init(ds);
8907 if (vnc_display_open(ds, vnc_display) < 0)
8910 #if defined(CONFIG_SDL)
8911 sdl_display_init(ds, full_screen, no_frame);
8912 #elif defined(CONFIG_COCOA)
8913 cocoa_display_init(ds, full_screen);
8915 dumb_display_init(ds);
8919 /* Maintain compatibility with multiple stdio monitors */
8920 if (!strcmp(monitor_device,"stdio")) {
8921 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
8922 if (!strcmp(serial_devices[i],"mon:stdio")) {
8923 monitor_device[0] = '\0';
8925 } else if (!strcmp(serial_devices[i],"stdio")) {
8926 monitor_device[0] = '\0';
8927 pstrcpy(serial_devices[0], sizeof(serial_devices[0]), "mon:stdio");
8932 if (monitor_device[0] != '\0') {
8933 monitor_hd = qemu_chr_open(monitor_device);
8935 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
8938 monitor_init(monitor_hd, !nographic);
8941 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
8942 const char *devname = serial_devices[i];
8943 if (devname[0] != '\0' && strcmp(devname, "none")) {
8944 serial_hds[i] = qemu_chr_open(devname);
8945 if (!serial_hds[i]) {
8946 fprintf(stderr, "qemu: could not open serial device '%s'\n",
8950 if (strstart(devname, "vc", 0))
8951 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8955 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
8956 const char *devname = parallel_devices[i];
8957 if (devname[0] != '\0' && strcmp(devname, "none")) {
8958 parallel_hds[i] = qemu_chr_open(devname);
8959 if (!parallel_hds[i]) {
8960 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
8964 if (strstart(devname, "vc", 0))
8965 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
8969 machine->init(ram_size, vga_ram_size, boot_devices, ds,
8970 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
8972 /* init USB devices */
8974 for(i = 0; i < usb_devices_index; i++) {
8975 if (usb_device_add(usb_devices[i]) < 0) {
8976 fprintf(stderr, "Warning: could not add USB device %s\n",
8982 if (display_state.dpy_refresh) {
8983 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
8984 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
8987 #ifdef CONFIG_GDBSTUB
8989 /* XXX: use standard host:port notation and modify options
8991 if (gdbserver_start(gdbstub_port) < 0) {
8992 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
9003 /* XXX: simplify init */
9016 len = write(fds[1], &status, 1);
9017 if (len == -1 && (errno == EINTR))
9023 TFR(fd = open("/dev/null", O_RDWR));
9037 #if !defined(_WIN32)
9038 /* close network clients */
9039 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
9040 VLANClientState *vc;
9042 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
9043 if (vc->fd_read == tap_receive) {
9045 TAPState *s = vc->opaque;
9047 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
9049 launch_script(s->down_script, ifname, s->fd);