4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "hw/boards.h"
27 #include "hw/pcmcia.h"
29 #include "hw/audiodev.h"
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
146 #define DEFAULT_RAM_SIZE 144
148 #define DEFAULT_RAM_SIZE 128
151 #define GUI_REFRESH_INTERVAL 30
153 /* Max number of USB devices that can be specified on the commandline. */
154 #define MAX_USB_CMDLINE 8
156 /* XXX: use a two level table to limit memory usage */
157 #define MAX_IOPORTS 65536
159 const char *bios_dir = CONFIG_QEMU_SHAREDIR;
160 const char *bios_name = NULL;
161 void *ioport_opaque[MAX_IOPORTS];
162 IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
163 IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
164 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
165 to store the VM snapshots */
166 DriveInfo drives_table[MAX_DRIVES+1];
168 /* point to the block driver where the snapshots are managed */
169 BlockDriverState *bs_snapshots;
171 static DisplayState display_state;
174 const char* keyboard_layout = NULL;
175 int64_t ticks_per_sec;
177 int pit_min_timer_count = 0;
179 NICInfo nd_table[MAX_NICS];
181 static int rtc_utc = 1;
182 static int rtc_date_offset = -1; /* -1 means no change */
183 int cirrus_vga_enabled = 1;
184 int vmsvga_enabled = 0;
186 int graphic_width = 1024;
187 int graphic_height = 768;
188 int graphic_depth = 8;
190 int graphic_width = 800;
191 int graphic_height = 600;
192 int graphic_depth = 15;
197 CharDriverState *serial_hds[MAX_SERIAL_PORTS];
198 CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
200 int win2k_install_hack = 0;
203 static VLANState *first_vlan;
205 const char *vnc_display;
206 #if defined(TARGET_SPARC)
208 #elif defined(TARGET_I386)
213 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 - 1;
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(void)
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, "?")) {
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;
961 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)
1308 unsigned long current_rtc_freq = 0;
1310 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
1313 ioctl(rtc_fd, RTC_IRQP_READ, ¤t_rtc_freq);
1314 if (current_rtc_freq != RTC_FREQ &&
1315 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
1316 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1317 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1318 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1321 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1327 enable_sigio_timer(rtc_fd);
1329 t->priv = (void *)(long)rtc_fd;
1334 static void rtc_stop_timer(struct qemu_alarm_timer *t)
1336 int rtc_fd = (long)t->priv;
1341 static int dynticks_start_timer(struct qemu_alarm_timer *t)
1345 struct sigaction act;
1347 sigfillset(&act.sa_mask);
1349 act.sa_handler = host_alarm_handler;
1351 sigaction(SIGALRM, &act, NULL);
1353 ev.sigev_value.sival_int = 0;
1354 ev.sigev_notify = SIGEV_SIGNAL;
1355 ev.sigev_signo = SIGALRM;
1357 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1358 perror("timer_create");
1360 /* disable dynticks */
1361 fprintf(stderr, "Dynamic Ticks disabled\n");
1366 t->priv = (void *)host_timer;
1371 static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1373 timer_t host_timer = (timer_t)t->priv;
1375 timer_delete(host_timer);
1378 static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1380 timer_t host_timer = (timer_t)t->priv;
1381 struct itimerspec timeout;
1382 int64_t nearest_delta_us = INT64_MAX;
1385 if (!active_timers[QEMU_TIMER_REALTIME] &&
1386 !active_timers[QEMU_TIMER_VIRTUAL])
1389 nearest_delta_us = qemu_next_deadline();
1391 /* check whether a timer is already running */
1392 if (timer_gettime(host_timer, &timeout)) {
1394 fprintf(stderr, "Internal timer error: aborting\n");
1397 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1398 if (current_us && current_us <= nearest_delta_us)
1401 timeout.it_interval.tv_sec = 0;
1402 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1403 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1404 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1405 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1407 fprintf(stderr, "Internal timer error: aborting\n");
1412 #endif /* defined(__linux__) */
1414 static int unix_start_timer(struct qemu_alarm_timer *t)
1416 struct sigaction act;
1417 struct itimerval itv;
1421 sigfillset(&act.sa_mask);
1423 act.sa_handler = host_alarm_handler;
1425 sigaction(SIGALRM, &act, NULL);
1427 itv.it_interval.tv_sec = 0;
1428 /* for i386 kernel 2.6 to get 1 ms */
1429 itv.it_interval.tv_usec = 999;
1430 itv.it_value.tv_sec = 0;
1431 itv.it_value.tv_usec = 10 * 1000;
1433 err = setitimer(ITIMER_REAL, &itv, NULL);
1440 static void unix_stop_timer(struct qemu_alarm_timer *t)
1442 struct itimerval itv;
1444 memset(&itv, 0, sizeof(itv));
1445 setitimer(ITIMER_REAL, &itv, NULL);
1448 #endif /* !defined(_WIN32) */
1452 static int win32_start_timer(struct qemu_alarm_timer *t)
1455 struct qemu_alarm_win32 *data = t->priv;
1458 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1459 if (!data->host_alarm) {
1460 perror("Failed CreateEvent");
1464 memset(&tc, 0, sizeof(tc));
1465 timeGetDevCaps(&tc, sizeof(tc));
1467 if (data->period < tc.wPeriodMin)
1468 data->period = tc.wPeriodMin;
1470 timeBeginPeriod(data->period);
1472 flags = TIME_CALLBACK_FUNCTION;
1473 if (alarm_has_dynticks(t))
1474 flags |= TIME_ONESHOT;
1476 flags |= TIME_PERIODIC;
1478 data->timerId = timeSetEvent(1, // interval (ms)
1479 data->period, // resolution
1480 host_alarm_handler, // function
1481 (DWORD)t, // parameter
1484 if (!data->timerId) {
1485 perror("Failed to initialize win32 alarm timer");
1487 timeEndPeriod(data->period);
1488 CloseHandle(data->host_alarm);
1492 qemu_add_wait_object(data->host_alarm, NULL, NULL);
1497 static void win32_stop_timer(struct qemu_alarm_timer *t)
1499 struct qemu_alarm_win32 *data = t->priv;
1501 timeKillEvent(data->timerId);
1502 timeEndPeriod(data->period);
1504 CloseHandle(data->host_alarm);
1507 static void win32_rearm_timer(struct qemu_alarm_timer *t)
1509 struct qemu_alarm_win32 *data = t->priv;
1510 uint64_t nearest_delta_us;
1512 if (!active_timers[QEMU_TIMER_REALTIME] &&
1513 !active_timers[QEMU_TIMER_VIRTUAL])
1516 nearest_delta_us = qemu_next_deadline();
1517 nearest_delta_us /= 1000;
1519 timeKillEvent(data->timerId);
1521 data->timerId = timeSetEvent(1,
1525 TIME_ONESHOT | TIME_PERIODIC);
1527 if (!data->timerId) {
1528 perror("Failed to re-arm win32 alarm timer");
1530 timeEndPeriod(data->period);
1531 CloseHandle(data->host_alarm);
1538 static void init_timer_alarm(void)
1540 struct qemu_alarm_timer *t;
1543 for (i = 0; alarm_timers[i].name; i++) {
1544 t = &alarm_timers[i];
1552 fprintf(stderr, "Unable to find any suitable alarm timer.\n");
1553 fprintf(stderr, "Terminating\n");
1560 static void quit_timers(void)
1562 alarm_timer->stop(alarm_timer);
1566 /***********************************************************/
1567 /* host time/date access */
1568 void qemu_get_timedate(struct tm *tm, int offset)
1575 if (rtc_date_offset == -1) {
1579 ret = localtime(&ti);
1581 ti -= rtc_date_offset;
1585 memcpy(tm, ret, sizeof(struct tm));
1588 int qemu_timedate_diff(struct tm *tm)
1592 if (rtc_date_offset == -1)
1594 seconds = mktimegm(tm);
1596 seconds = mktime(tm);
1598 seconds = mktimegm(tm) + rtc_date_offset;
1600 return seconds - time(NULL);
1603 /***********************************************************/
1604 /* character device */
1606 static void qemu_chr_event(CharDriverState *s, int event)
1610 s->chr_event(s->handler_opaque, event);
1613 static void qemu_chr_reset_bh(void *opaque)
1615 CharDriverState *s = opaque;
1616 qemu_chr_event(s, CHR_EVENT_RESET);
1617 qemu_bh_delete(s->bh);
1621 void qemu_chr_reset(CharDriverState *s)
1623 if (s->bh == NULL) {
1624 s->bh = qemu_bh_new(qemu_chr_reset_bh, s);
1625 qemu_bh_schedule(s->bh);
1629 int qemu_chr_write(CharDriverState *s, const uint8_t *buf, int len)
1631 return s->chr_write(s, buf, len);
1634 int qemu_chr_ioctl(CharDriverState *s, int cmd, void *arg)
1638 return s->chr_ioctl(s, cmd, arg);
1641 int qemu_chr_can_read(CharDriverState *s)
1643 if (!s->chr_can_read)
1645 return s->chr_can_read(s->handler_opaque);
1648 void qemu_chr_read(CharDriverState *s, uint8_t *buf, int len)
1650 s->chr_read(s->handler_opaque, buf, len);
1653 void qemu_chr_accept_input(CharDriverState *s)
1655 if (s->chr_accept_input)
1656 s->chr_accept_input(s);
1659 void qemu_chr_printf(CharDriverState *s, const char *fmt, ...)
1664 vsnprintf(buf, sizeof(buf), fmt, ap);
1665 qemu_chr_write(s, (uint8_t *)buf, strlen(buf));
1669 void qemu_chr_send_event(CharDriverState *s, int event)
1671 if (s->chr_send_event)
1672 s->chr_send_event(s, event);
1675 void qemu_chr_add_handlers(CharDriverState *s,
1676 IOCanRWHandler *fd_can_read,
1677 IOReadHandler *fd_read,
1678 IOEventHandler *fd_event,
1681 s->chr_can_read = fd_can_read;
1682 s->chr_read = fd_read;
1683 s->chr_event = fd_event;
1684 s->handler_opaque = opaque;
1685 if (s->chr_update_read_handler)
1686 s->chr_update_read_handler(s);
1689 static int null_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1694 static CharDriverState *qemu_chr_open_null(void)
1696 CharDriverState *chr;
1698 chr = qemu_mallocz(sizeof(CharDriverState));
1701 chr->chr_write = null_chr_write;
1705 /* MUX driver for serial I/O splitting */
1706 static int term_timestamps;
1707 static int64_t term_timestamps_start;
1709 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1710 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1712 IOCanRWHandler *chr_can_read[MAX_MUX];
1713 IOReadHandler *chr_read[MAX_MUX];
1714 IOEventHandler *chr_event[MAX_MUX];
1715 void *ext_opaque[MAX_MUX];
1716 CharDriverState *drv;
1717 unsigned char buffer[MUX_BUFFER_SIZE];
1721 int term_got_escape;
1726 static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
1728 MuxDriver *d = chr->opaque;
1730 if (!term_timestamps) {
1731 ret = d->drv->chr_write(d->drv, buf, len);
1736 for(i = 0; i < len; i++) {
1737 ret += d->drv->chr_write(d->drv, buf+i, 1);
1738 if (buf[i] == '\n') {
1744 if (term_timestamps_start == -1)
1745 term_timestamps_start = ti;
1746 ti -= term_timestamps_start;
1747 secs = ti / 1000000000;
1748 snprintf(buf1, sizeof(buf1),
1749 "[%02d:%02d:%02d.%03d] ",
1753 (int)((ti / 1000000) % 1000));
1754 d->drv->chr_write(d->drv, (uint8_t *)buf1, strlen(buf1));
1761 static char *mux_help[] = {
1762 "% h print this help\n\r",
1763 "% x exit emulator\n\r",
1764 "% s save disk data back to file (if -snapshot)\n\r",
1765 "% t toggle console timestamps\n\r"
1766 "% b send break (magic sysrq)\n\r",
1767 "% c switch between console and monitor\n\r",
1772 static int term_escape_char = 0x01; /* ctrl-a is used for escape */
1773 static void mux_print_help(CharDriverState *chr)
1776 char ebuf[15] = "Escape-Char";
1777 char cbuf[50] = "\n\r";
1779 if (term_escape_char > 0 && term_escape_char < 26) {
1780 sprintf(cbuf,"\n\r");
1781 sprintf(ebuf,"C-%c", term_escape_char - 1 + 'a');
1783 sprintf(cbuf,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1786 chr->chr_write(chr, (uint8_t *)cbuf, strlen(cbuf));
1787 for (i = 0; mux_help[i] != NULL; i++) {
1788 for (j=0; mux_help[i][j] != '\0'; j++) {
1789 if (mux_help[i][j] == '%')
1790 chr->chr_write(chr, (uint8_t *)ebuf, strlen(ebuf));
1792 chr->chr_write(chr, (uint8_t *)&mux_help[i][j], 1);
1797 static int mux_proc_byte(CharDriverState *chr, MuxDriver *d, int ch)
1799 if (d->term_got_escape) {
1800 d->term_got_escape = 0;
1801 if (ch == term_escape_char)
1806 mux_print_help(chr);
1810 char *term = "QEMU: Terminated\n\r";
1811 chr->chr_write(chr,(uint8_t *)term,strlen(term));
1818 for (i = 0; i < nb_drives; i++) {
1819 bdrv_commit(drives_table[i].bdrv);
1824 qemu_chr_event(chr, CHR_EVENT_BREAK);
1827 /* Switch to the next registered device */
1829 if (chr->focus >= d->mux_cnt)
1833 term_timestamps = !term_timestamps;
1834 term_timestamps_start = -1;
1837 } else if (ch == term_escape_char) {
1838 d->term_got_escape = 1;
1846 static void mux_chr_accept_input(CharDriverState *chr)
1849 MuxDriver *d = chr->opaque;
1851 while (d->prod != d->cons &&
1852 d->chr_can_read[m] &&
1853 d->chr_can_read[m](d->ext_opaque[m])) {
1854 d->chr_read[m](d->ext_opaque[m],
1855 &d->buffer[d->cons++ & MUX_BUFFER_MASK], 1);
1859 static int mux_chr_can_read(void *opaque)
1861 CharDriverState *chr = opaque;
1862 MuxDriver *d = chr->opaque;
1864 if ((d->prod - d->cons) < MUX_BUFFER_SIZE)
1866 if (d->chr_can_read[chr->focus])
1867 return d->chr_can_read[chr->focus](d->ext_opaque[chr->focus]);
1871 static void mux_chr_read(void *opaque, const uint8_t *buf, int size)
1873 CharDriverState *chr = opaque;
1874 MuxDriver *d = chr->opaque;
1878 mux_chr_accept_input (opaque);
1880 for(i = 0; i < size; i++)
1881 if (mux_proc_byte(chr, d, buf[i])) {
1882 if (d->prod == d->cons &&
1883 d->chr_can_read[m] &&
1884 d->chr_can_read[m](d->ext_opaque[m]))
1885 d->chr_read[m](d->ext_opaque[m], &buf[i], 1);
1887 d->buffer[d->prod++ & MUX_BUFFER_MASK] = buf[i];
1891 static void mux_chr_event(void *opaque, int event)
1893 CharDriverState *chr = opaque;
1894 MuxDriver *d = chr->opaque;
1897 /* Send the event to all registered listeners */
1898 for (i = 0; i < d->mux_cnt; i++)
1899 if (d->chr_event[i])
1900 d->chr_event[i](d->ext_opaque[i], event);
1903 static void mux_chr_update_read_handler(CharDriverState *chr)
1905 MuxDriver *d = chr->opaque;
1907 if (d->mux_cnt >= MAX_MUX) {
1908 fprintf(stderr, "Cannot add I/O handlers, MUX array is full\n");
1911 d->ext_opaque[d->mux_cnt] = chr->handler_opaque;
1912 d->chr_can_read[d->mux_cnt] = chr->chr_can_read;
1913 d->chr_read[d->mux_cnt] = chr->chr_read;
1914 d->chr_event[d->mux_cnt] = chr->chr_event;
1915 /* Fix up the real driver with mux routines */
1916 if (d->mux_cnt == 0) {
1917 qemu_chr_add_handlers(d->drv, mux_chr_can_read, mux_chr_read,
1918 mux_chr_event, chr);
1920 chr->focus = d->mux_cnt;
1924 static CharDriverState *qemu_chr_open_mux(CharDriverState *drv)
1926 CharDriverState *chr;
1929 chr = qemu_mallocz(sizeof(CharDriverState));
1932 d = qemu_mallocz(sizeof(MuxDriver));
1941 chr->chr_write = mux_chr_write;
1942 chr->chr_update_read_handler = mux_chr_update_read_handler;
1943 chr->chr_accept_input = mux_chr_accept_input;
1950 static void socket_cleanup(void)
1955 static int socket_init(void)
1960 ret = WSAStartup(MAKEWORD(2,2), &Data);
1962 err = WSAGetLastError();
1963 fprintf(stderr, "WSAStartup: %d\n", err);
1966 atexit(socket_cleanup);
1970 static int send_all(int fd, const uint8_t *buf, int len1)
1976 ret = send(fd, buf, len, 0);
1979 errno = WSAGetLastError();
1980 if (errno != WSAEWOULDBLOCK) {
1983 } else if (ret == 0) {
1993 void socket_set_nonblock(int fd)
1995 unsigned long opt = 1;
1996 ioctlsocket(fd, FIONBIO, &opt);
2001 static int unix_write(int fd, const uint8_t *buf, int len1)
2007 ret = write(fd, buf, len);
2009 if (errno != EINTR && errno != EAGAIN)
2011 } else if (ret == 0) {
2021 static inline int send_all(int fd, const uint8_t *buf, int len1)
2023 return unix_write(fd, buf, len1);
2026 void socket_set_nonblock(int fd)
2028 fcntl(fd, F_SETFL, O_NONBLOCK);
2030 #endif /* !_WIN32 */
2039 #define STDIO_MAX_CLIENTS 1
2040 static int stdio_nb_clients = 0;
2042 static int fd_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2044 FDCharDriver *s = chr->opaque;
2045 return unix_write(s->fd_out, buf, len);
2048 static int fd_chr_read_poll(void *opaque)
2050 CharDriverState *chr = opaque;
2051 FDCharDriver *s = chr->opaque;
2053 s->max_size = qemu_chr_can_read(chr);
2057 static void fd_chr_read(void *opaque)
2059 CharDriverState *chr = opaque;
2060 FDCharDriver *s = chr->opaque;
2065 if (len > s->max_size)
2069 size = read(s->fd_in, buf, len);
2071 /* FD has been closed. Remove it from the active list. */
2072 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2076 qemu_chr_read(chr, buf, size);
2080 static void fd_chr_update_read_handler(CharDriverState *chr)
2082 FDCharDriver *s = chr->opaque;
2084 if (s->fd_in >= 0) {
2085 if (nographic && s->fd_in == 0) {
2087 qemu_set_fd_handler2(s->fd_in, fd_chr_read_poll,
2088 fd_chr_read, NULL, chr);
2093 static void fd_chr_close(struct CharDriverState *chr)
2095 FDCharDriver *s = chr->opaque;
2097 if (s->fd_in >= 0) {
2098 if (nographic && s->fd_in == 0) {
2100 qemu_set_fd_handler2(s->fd_in, NULL, NULL, NULL, NULL);
2107 /* open a character device to a unix fd */
2108 static CharDriverState *qemu_chr_open_fd(int fd_in, int fd_out)
2110 CharDriverState *chr;
2113 chr = qemu_mallocz(sizeof(CharDriverState));
2116 s = qemu_mallocz(sizeof(FDCharDriver));
2124 chr->chr_write = fd_chr_write;
2125 chr->chr_update_read_handler = fd_chr_update_read_handler;
2126 chr->chr_close = fd_chr_close;
2128 qemu_chr_reset(chr);
2133 static CharDriverState *qemu_chr_open_file_out(const char *file_out)
2137 TFR(fd_out = open(file_out, O_WRONLY | O_TRUNC | O_CREAT | O_BINARY, 0666));
2140 return qemu_chr_open_fd(-1, fd_out);
2143 static CharDriverState *qemu_chr_open_pipe(const char *filename)
2146 char filename_in[256], filename_out[256];
2148 snprintf(filename_in, 256, "%s.in", filename);
2149 snprintf(filename_out, 256, "%s.out", filename);
2150 TFR(fd_in = open(filename_in, O_RDWR | O_BINARY));
2151 TFR(fd_out = open(filename_out, O_RDWR | O_BINARY));
2152 if (fd_in < 0 || fd_out < 0) {
2157 TFR(fd_in = fd_out = open(filename, O_RDWR | O_BINARY));
2161 return qemu_chr_open_fd(fd_in, fd_out);
2165 /* for STDIO, we handle the case where several clients use it
2168 #define TERM_FIFO_MAX_SIZE 1
2170 static uint8_t term_fifo[TERM_FIFO_MAX_SIZE];
2171 static int term_fifo_size;
2173 static int stdio_read_poll(void *opaque)
2175 CharDriverState *chr = opaque;
2177 /* try to flush the queue if needed */
2178 if (term_fifo_size != 0 && qemu_chr_can_read(chr) > 0) {
2179 qemu_chr_read(chr, term_fifo, 1);
2182 /* see if we can absorb more chars */
2183 if (term_fifo_size == 0)
2189 static void stdio_read(void *opaque)
2193 CharDriverState *chr = opaque;
2195 size = read(0, buf, 1);
2197 /* stdin has been closed. Remove it from the active list. */
2198 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2202 if (qemu_chr_can_read(chr) > 0) {
2203 qemu_chr_read(chr, buf, 1);
2204 } else if (term_fifo_size == 0) {
2205 term_fifo[term_fifo_size++] = buf[0];
2210 /* init terminal so that we can grab keys */
2211 static struct termios oldtty;
2212 static int old_fd0_flags;
2213 static int term_atexit_done;
2215 static void term_exit(void)
2217 tcsetattr (0, TCSANOW, &oldtty);
2218 fcntl(0, F_SETFL, old_fd0_flags);
2221 static void term_init(void)
2225 tcgetattr (0, &tty);
2227 old_fd0_flags = fcntl(0, F_GETFL);
2229 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2230 |INLCR|IGNCR|ICRNL|IXON);
2231 tty.c_oflag |= OPOST;
2232 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
2233 /* if graphical mode, we allow Ctrl-C handling */
2235 tty.c_lflag &= ~ISIG;
2236 tty.c_cflag &= ~(CSIZE|PARENB);
2239 tty.c_cc[VTIME] = 0;
2241 tcsetattr (0, TCSANOW, &tty);
2243 if (!term_atexit_done++)
2246 fcntl(0, F_SETFL, O_NONBLOCK);
2249 static void qemu_chr_close_stdio(struct CharDriverState *chr)
2253 qemu_set_fd_handler2(0, NULL, NULL, NULL, NULL);
2257 static CharDriverState *qemu_chr_open_stdio(void)
2259 CharDriverState *chr;
2261 if (stdio_nb_clients >= STDIO_MAX_CLIENTS)
2263 chr = qemu_chr_open_fd(0, 1);
2264 chr->chr_close = qemu_chr_close_stdio;
2265 qemu_set_fd_handler2(0, stdio_read_poll, stdio_read, NULL, chr);
2272 #if defined(__linux__) || defined(__sun__)
2273 static CharDriverState *qemu_chr_open_pty(void)
2276 char slave_name[1024];
2277 int master_fd, slave_fd;
2279 #if defined(__linux__)
2280 /* Not satisfying */
2281 if (openpty(&master_fd, &slave_fd, slave_name, NULL, NULL) < 0) {
2286 /* Disabling local echo and line-buffered output */
2287 tcgetattr (master_fd, &tty);
2288 tty.c_lflag &= ~(ECHO|ICANON|ISIG);
2290 tty.c_cc[VTIME] = 0;
2291 tcsetattr (master_fd, TCSAFLUSH, &tty);
2293 fprintf(stderr, "char device redirected to %s\n", slave_name);
2294 return qemu_chr_open_fd(master_fd, master_fd);
2297 static void tty_serial_init(int fd, int speed,
2298 int parity, int data_bits, int stop_bits)
2304 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2305 speed, parity, data_bits, stop_bits);
2307 tcgetattr (fd, &tty);
2310 if (speed <= 50 * MARGIN)
2312 else if (speed <= 75 * MARGIN)
2314 else if (speed <= 300 * MARGIN)
2316 else if (speed <= 600 * MARGIN)
2318 else if (speed <= 1200 * MARGIN)
2320 else if (speed <= 2400 * MARGIN)
2322 else if (speed <= 4800 * MARGIN)
2324 else if (speed <= 9600 * MARGIN)
2326 else if (speed <= 19200 * MARGIN)
2328 else if (speed <= 38400 * MARGIN)
2330 else if (speed <= 57600 * MARGIN)
2332 else if (speed <= 115200 * MARGIN)
2337 cfsetispeed(&tty, spd);
2338 cfsetospeed(&tty, spd);
2340 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
2341 |INLCR|IGNCR|ICRNL|IXON);
2342 tty.c_oflag |= OPOST;
2343 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN|ISIG);
2344 tty.c_cflag &= ~(CSIZE|PARENB|PARODD|CRTSCTS|CSTOPB);
2365 tty.c_cflag |= PARENB;
2368 tty.c_cflag |= PARENB | PARODD;
2372 tty.c_cflag |= CSTOPB;
2374 tcsetattr (fd, TCSANOW, &tty);
2377 static int tty_serial_ioctl(CharDriverState *chr, int cmd, void *arg)
2379 FDCharDriver *s = chr->opaque;
2382 case CHR_IOCTL_SERIAL_SET_PARAMS:
2384 QEMUSerialSetParams *ssp = arg;
2385 tty_serial_init(s->fd_in, ssp->speed, ssp->parity,
2386 ssp->data_bits, ssp->stop_bits);
2389 case CHR_IOCTL_SERIAL_SET_BREAK:
2391 int enable = *(int *)arg;
2393 tcsendbreak(s->fd_in, 1);
2402 static CharDriverState *qemu_chr_open_tty(const char *filename)
2404 CharDriverState *chr;
2407 TFR(fd = open(filename, O_RDWR | O_NONBLOCK));
2408 fcntl(fd, F_SETFL, O_NONBLOCK);
2409 tty_serial_init(fd, 115200, 'N', 8, 1);
2410 chr = qemu_chr_open_fd(fd, fd);
2415 chr->chr_ioctl = tty_serial_ioctl;
2416 qemu_chr_reset(chr);
2419 #else /* ! __linux__ && ! __sun__ */
2420 static CharDriverState *qemu_chr_open_pty(void)
2424 #endif /* __linux__ || __sun__ */
2426 #if defined(__linux__)
2430 } ParallelCharDriver;
2432 static int pp_hw_mode(ParallelCharDriver *s, uint16_t mode)
2434 if (s->mode != mode) {
2436 if (ioctl(s->fd, PPSETMODE, &m) < 0)
2443 static int pp_ioctl(CharDriverState *chr, int cmd, void *arg)
2445 ParallelCharDriver *drv = chr->opaque;
2450 case CHR_IOCTL_PP_READ_DATA:
2451 if (ioctl(fd, PPRDATA, &b) < 0)
2453 *(uint8_t *)arg = b;
2455 case CHR_IOCTL_PP_WRITE_DATA:
2456 b = *(uint8_t *)arg;
2457 if (ioctl(fd, PPWDATA, &b) < 0)
2460 case CHR_IOCTL_PP_READ_CONTROL:
2461 if (ioctl(fd, PPRCONTROL, &b) < 0)
2463 /* Linux gives only the lowest bits, and no way to know data
2464 direction! For better compatibility set the fixed upper
2466 *(uint8_t *)arg = b | 0xc0;
2468 case CHR_IOCTL_PP_WRITE_CONTROL:
2469 b = *(uint8_t *)arg;
2470 if (ioctl(fd, PPWCONTROL, &b) < 0)
2473 case CHR_IOCTL_PP_READ_STATUS:
2474 if (ioctl(fd, PPRSTATUS, &b) < 0)
2476 *(uint8_t *)arg = b;
2478 case CHR_IOCTL_PP_EPP_READ_ADDR:
2479 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2480 struct ParallelIOArg *parg = arg;
2481 int n = read(fd, parg->buffer, parg->count);
2482 if (n != parg->count) {
2487 case CHR_IOCTL_PP_EPP_READ:
2488 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2489 struct ParallelIOArg *parg = arg;
2490 int n = read(fd, parg->buffer, parg->count);
2491 if (n != parg->count) {
2496 case CHR_IOCTL_PP_EPP_WRITE_ADDR:
2497 if (pp_hw_mode(drv, IEEE1284_MODE_EPP|IEEE1284_ADDR)) {
2498 struct ParallelIOArg *parg = arg;
2499 int n = write(fd, parg->buffer, parg->count);
2500 if (n != parg->count) {
2505 case CHR_IOCTL_PP_EPP_WRITE:
2506 if (pp_hw_mode(drv, IEEE1284_MODE_EPP)) {
2507 struct ParallelIOArg *parg = arg;
2508 int n = write(fd, parg->buffer, parg->count);
2509 if (n != parg->count) {
2520 static void pp_close(CharDriverState *chr)
2522 ParallelCharDriver *drv = chr->opaque;
2525 pp_hw_mode(drv, IEEE1284_MODE_COMPAT);
2526 ioctl(fd, PPRELEASE);
2531 static CharDriverState *qemu_chr_open_pp(const char *filename)
2533 CharDriverState *chr;
2534 ParallelCharDriver *drv;
2537 TFR(fd = open(filename, O_RDWR));
2541 if (ioctl(fd, PPCLAIM) < 0) {
2546 drv = qemu_mallocz(sizeof(ParallelCharDriver));
2552 drv->mode = IEEE1284_MODE_COMPAT;
2554 chr = qemu_mallocz(sizeof(CharDriverState));
2560 chr->chr_write = null_chr_write;
2561 chr->chr_ioctl = pp_ioctl;
2562 chr->chr_close = pp_close;
2565 qemu_chr_reset(chr);
2569 #endif /* __linux__ */
2575 HANDLE hcom, hrecv, hsend;
2576 OVERLAPPED orecv, osend;
2581 #define NSENDBUF 2048
2582 #define NRECVBUF 2048
2583 #define MAXCONNECT 1
2584 #define NTIMEOUT 5000
2586 static int win_chr_poll(void *opaque);
2587 static int win_chr_pipe_poll(void *opaque);
2589 static void win_chr_close(CharDriverState *chr)
2591 WinCharState *s = chr->opaque;
2594 CloseHandle(s->hsend);
2598 CloseHandle(s->hrecv);
2602 CloseHandle(s->hcom);
2606 qemu_del_polling_cb(win_chr_pipe_poll, chr);
2608 qemu_del_polling_cb(win_chr_poll, chr);
2611 static int win_chr_init(CharDriverState *chr, const char *filename)
2613 WinCharState *s = chr->opaque;
2615 COMMTIMEOUTS cto = { 0, 0, 0, 0, 0};
2620 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2622 fprintf(stderr, "Failed CreateEvent\n");
2625 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2627 fprintf(stderr, "Failed CreateEvent\n");
2631 s->hcom = CreateFile(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
2632 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, 0);
2633 if (s->hcom == INVALID_HANDLE_VALUE) {
2634 fprintf(stderr, "Failed CreateFile (%lu)\n", GetLastError());
2639 if (!SetupComm(s->hcom, NRECVBUF, NSENDBUF)) {
2640 fprintf(stderr, "Failed SetupComm\n");
2644 ZeroMemory(&comcfg, sizeof(COMMCONFIG));
2645 size = sizeof(COMMCONFIG);
2646 GetDefaultCommConfig(filename, &comcfg, &size);
2647 comcfg.dcb.DCBlength = sizeof(DCB);
2648 CommConfigDialog(filename, NULL, &comcfg);
2650 if (!SetCommState(s->hcom, &comcfg.dcb)) {
2651 fprintf(stderr, "Failed SetCommState\n");
2655 if (!SetCommMask(s->hcom, EV_ERR)) {
2656 fprintf(stderr, "Failed SetCommMask\n");
2660 cto.ReadIntervalTimeout = MAXDWORD;
2661 if (!SetCommTimeouts(s->hcom, &cto)) {
2662 fprintf(stderr, "Failed SetCommTimeouts\n");
2666 if (!ClearCommError(s->hcom, &err, &comstat)) {
2667 fprintf(stderr, "Failed ClearCommError\n");
2670 qemu_add_polling_cb(win_chr_poll, chr);
2678 static int win_chr_write(CharDriverState *chr, const uint8_t *buf, int len1)
2680 WinCharState *s = chr->opaque;
2681 DWORD len, ret, size, err;
2684 ZeroMemory(&s->osend, sizeof(s->osend));
2685 s->osend.hEvent = s->hsend;
2688 ret = WriteFile(s->hcom, buf, len, &size, &s->osend);
2690 ret = WriteFile(s->hcom, buf, len, &size, NULL);
2692 err = GetLastError();
2693 if (err == ERROR_IO_PENDING) {
2694 ret = GetOverlappedResult(s->hcom, &s->osend, &size, TRUE);
2712 static int win_chr_read_poll(CharDriverState *chr)
2714 WinCharState *s = chr->opaque;
2716 s->max_size = qemu_chr_can_read(chr);
2720 static void win_chr_readfile(CharDriverState *chr)
2722 WinCharState *s = chr->opaque;
2727 ZeroMemory(&s->orecv, sizeof(s->orecv));
2728 s->orecv.hEvent = s->hrecv;
2729 ret = ReadFile(s->hcom, buf, s->len, &size, &s->orecv);
2731 err = GetLastError();
2732 if (err == ERROR_IO_PENDING) {
2733 ret = GetOverlappedResult(s->hcom, &s->orecv, &size, TRUE);
2738 qemu_chr_read(chr, buf, size);
2742 static void win_chr_read(CharDriverState *chr)
2744 WinCharState *s = chr->opaque;
2746 if (s->len > s->max_size)
2747 s->len = s->max_size;
2751 win_chr_readfile(chr);
2754 static int win_chr_poll(void *opaque)
2756 CharDriverState *chr = opaque;
2757 WinCharState *s = chr->opaque;
2761 ClearCommError(s->hcom, &comerr, &status);
2762 if (status.cbInQue > 0) {
2763 s->len = status.cbInQue;
2764 win_chr_read_poll(chr);
2771 static CharDriverState *qemu_chr_open_win(const char *filename)
2773 CharDriverState *chr;
2776 chr = qemu_mallocz(sizeof(CharDriverState));
2779 s = qemu_mallocz(sizeof(WinCharState));
2785 chr->chr_write = win_chr_write;
2786 chr->chr_close = win_chr_close;
2788 if (win_chr_init(chr, filename) < 0) {
2793 qemu_chr_reset(chr);
2797 static int win_chr_pipe_poll(void *opaque)
2799 CharDriverState *chr = opaque;
2800 WinCharState *s = chr->opaque;
2803 PeekNamedPipe(s->hcom, NULL, 0, NULL, &size, NULL);
2806 win_chr_read_poll(chr);
2813 static int win_chr_pipe_init(CharDriverState *chr, const char *filename)
2815 WinCharState *s = chr->opaque;
2823 s->hsend = CreateEvent(NULL, TRUE, FALSE, NULL);
2825 fprintf(stderr, "Failed CreateEvent\n");
2828 s->hrecv = CreateEvent(NULL, TRUE, FALSE, NULL);
2830 fprintf(stderr, "Failed CreateEvent\n");
2834 snprintf(openname, sizeof(openname), "\\\\.\\pipe\\%s", filename);
2835 s->hcom = CreateNamedPipe(openname, PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
2836 PIPE_TYPE_BYTE | PIPE_READMODE_BYTE |
2838 MAXCONNECT, NSENDBUF, NRECVBUF, NTIMEOUT, NULL);
2839 if (s->hcom == INVALID_HANDLE_VALUE) {
2840 fprintf(stderr, "Failed CreateNamedPipe (%lu)\n", GetLastError());
2845 ZeroMemory(&ov, sizeof(ov));
2846 ov.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
2847 ret = ConnectNamedPipe(s->hcom, &ov);
2849 fprintf(stderr, "Failed ConnectNamedPipe\n");
2853 ret = GetOverlappedResult(s->hcom, &ov, &size, TRUE);
2855 fprintf(stderr, "Failed GetOverlappedResult\n");
2857 CloseHandle(ov.hEvent);
2864 CloseHandle(ov.hEvent);
2867 qemu_add_polling_cb(win_chr_pipe_poll, chr);
2876 static CharDriverState *qemu_chr_open_win_pipe(const char *filename)
2878 CharDriverState *chr;
2881 chr = qemu_mallocz(sizeof(CharDriverState));
2884 s = qemu_mallocz(sizeof(WinCharState));
2890 chr->chr_write = win_chr_write;
2891 chr->chr_close = win_chr_close;
2893 if (win_chr_pipe_init(chr, filename) < 0) {
2898 qemu_chr_reset(chr);
2902 static CharDriverState *qemu_chr_open_win_file(HANDLE fd_out)
2904 CharDriverState *chr;
2907 chr = qemu_mallocz(sizeof(CharDriverState));
2910 s = qemu_mallocz(sizeof(WinCharState));
2917 chr->chr_write = win_chr_write;
2918 qemu_chr_reset(chr);
2922 static CharDriverState *qemu_chr_open_win_con(const char *filename)
2924 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
2927 static CharDriverState *qemu_chr_open_win_file_out(const char *file_out)
2931 fd_out = CreateFile(file_out, GENERIC_WRITE, FILE_SHARE_READ, NULL,
2932 OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
2933 if (fd_out == INVALID_HANDLE_VALUE)
2936 return qemu_chr_open_win_file(fd_out);
2938 #endif /* !_WIN32 */
2940 /***********************************************************/
2941 /* UDP Net console */
2945 struct sockaddr_in daddr;
2952 static int udp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
2954 NetCharDriver *s = chr->opaque;
2956 return sendto(s->fd, buf, len, 0,
2957 (struct sockaddr *)&s->daddr, sizeof(struct sockaddr_in));
2960 static int udp_chr_read_poll(void *opaque)
2962 CharDriverState *chr = opaque;
2963 NetCharDriver *s = chr->opaque;
2965 s->max_size = qemu_chr_can_read(chr);
2967 /* If there were any stray characters in the queue process them
2970 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2971 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2973 s->max_size = qemu_chr_can_read(chr);
2978 static void udp_chr_read(void *opaque)
2980 CharDriverState *chr = opaque;
2981 NetCharDriver *s = chr->opaque;
2983 if (s->max_size == 0)
2985 s->bufcnt = recv(s->fd, s->buf, sizeof(s->buf), 0);
2986 s->bufptr = s->bufcnt;
2991 while (s->max_size > 0 && s->bufptr < s->bufcnt) {
2992 qemu_chr_read(chr, &s->buf[s->bufptr], 1);
2994 s->max_size = qemu_chr_can_read(chr);
2998 static void udp_chr_update_read_handler(CharDriverState *chr)
3000 NetCharDriver *s = chr->opaque;
3003 qemu_set_fd_handler2(s->fd, udp_chr_read_poll,
3004 udp_chr_read, NULL, chr);
3008 int parse_host_port(struct sockaddr_in *saddr, const char *str);
3010 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str);
3012 int parse_host_src_port(struct sockaddr_in *haddr,
3013 struct sockaddr_in *saddr,
3016 static CharDriverState *qemu_chr_open_udp(const char *def)
3018 CharDriverState *chr = NULL;
3019 NetCharDriver *s = NULL;
3021 struct sockaddr_in saddr;
3023 chr = qemu_mallocz(sizeof(CharDriverState));
3026 s = qemu_mallocz(sizeof(NetCharDriver));
3030 fd = socket(PF_INET, SOCK_DGRAM, 0);
3032 perror("socket(PF_INET, SOCK_DGRAM)");
3036 if (parse_host_src_port(&s->daddr, &saddr, def) < 0) {
3037 printf("Could not parse: %s\n", def);
3041 if (bind(fd, (struct sockaddr *)&saddr, sizeof(saddr)) < 0)
3051 chr->chr_write = udp_chr_write;
3052 chr->chr_update_read_handler = udp_chr_update_read_handler;
3065 /***********************************************************/
3066 /* TCP Net console */
3077 static void tcp_chr_accept(void *opaque);
3079 static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
3081 TCPCharDriver *s = chr->opaque;
3083 return send_all(s->fd, buf, len);
3085 /* XXX: indicate an error ? */
3090 static int tcp_chr_read_poll(void *opaque)
3092 CharDriverState *chr = opaque;
3093 TCPCharDriver *s = chr->opaque;
3096 s->max_size = qemu_chr_can_read(chr);
3101 #define IAC_BREAK 243
3102 static void tcp_chr_process_IAC_bytes(CharDriverState *chr,
3104 uint8_t *buf, int *size)
3106 /* Handle any telnet client's basic IAC options to satisfy char by
3107 * char mode with no echo. All IAC options will be removed from
3108 * the buf and the do_telnetopt variable will be used to track the
3109 * state of the width of the IAC information.
3111 * IAC commands come in sets of 3 bytes with the exception of the
3112 * "IAC BREAK" command and the double IAC.
3118 for (i = 0; i < *size; i++) {
3119 if (s->do_telnetopt > 1) {
3120 if ((unsigned char)buf[i] == IAC && s->do_telnetopt == 2) {
3121 /* Double IAC means send an IAC */
3125 s->do_telnetopt = 1;
3127 if ((unsigned char)buf[i] == IAC_BREAK && s->do_telnetopt == 2) {
3128 /* Handle IAC break commands by sending a serial break */
3129 qemu_chr_event(chr, CHR_EVENT_BREAK);
3134 if (s->do_telnetopt >= 4) {
3135 s->do_telnetopt = 1;
3138 if ((unsigned char)buf[i] == IAC) {
3139 s->do_telnetopt = 2;
3150 static void tcp_chr_read(void *opaque)
3152 CharDriverState *chr = opaque;
3153 TCPCharDriver *s = chr->opaque;
3157 if (!s->connected || s->max_size <= 0)
3160 if (len > s->max_size)
3162 size = recv(s->fd, buf, len, 0);
3164 /* connection closed */
3166 if (s->listen_fd >= 0) {
3167 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3169 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
3172 } else if (size > 0) {
3173 if (s->do_telnetopt)
3174 tcp_chr_process_IAC_bytes(chr, s, buf, &size);
3176 qemu_chr_read(chr, buf, size);
3180 static void tcp_chr_connect(void *opaque)
3182 CharDriverState *chr = opaque;
3183 TCPCharDriver *s = chr->opaque;
3186 qemu_set_fd_handler2(s->fd, tcp_chr_read_poll,
3187 tcp_chr_read, NULL, chr);
3188 qemu_chr_reset(chr);
3191 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3192 static void tcp_chr_telnet_init(int fd)
3195 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3196 IACSET(buf, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3197 send(fd, (char *)buf, 3, 0);
3198 IACSET(buf, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3199 send(fd, (char *)buf, 3, 0);
3200 IACSET(buf, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3201 send(fd, (char *)buf, 3, 0);
3202 IACSET(buf, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3203 send(fd, (char *)buf, 3, 0);
3206 static void socket_set_nodelay(int fd)
3209 setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
3212 static void tcp_chr_accept(void *opaque)
3214 CharDriverState *chr = opaque;
3215 TCPCharDriver *s = chr->opaque;
3216 struct sockaddr_in saddr;
3218 struct sockaddr_un uaddr;
3220 struct sockaddr *addr;
3227 len = sizeof(uaddr);
3228 addr = (struct sockaddr *)&uaddr;
3232 len = sizeof(saddr);
3233 addr = (struct sockaddr *)&saddr;
3235 fd = accept(s->listen_fd, addr, &len);
3236 if (fd < 0 && errno != EINTR) {
3238 } else if (fd >= 0) {
3239 if (s->do_telnetopt)
3240 tcp_chr_telnet_init(fd);
3244 socket_set_nonblock(fd);
3246 socket_set_nodelay(fd);
3248 qemu_set_fd_handler(s->listen_fd, NULL, NULL, NULL);
3249 tcp_chr_connect(chr);
3252 static void tcp_chr_close(CharDriverState *chr)
3254 TCPCharDriver *s = chr->opaque;
3257 if (s->listen_fd >= 0)
3258 closesocket(s->listen_fd);
3262 static CharDriverState *qemu_chr_open_tcp(const char *host_str,
3266 CharDriverState *chr = NULL;
3267 TCPCharDriver *s = NULL;
3268 int fd = -1, ret, err, val;
3270 int is_waitconnect = 1;
3273 struct sockaddr_in saddr;
3275 struct sockaddr_un uaddr;
3277 struct sockaddr *addr;
3282 addr = (struct sockaddr *)&uaddr;
3283 addrlen = sizeof(uaddr);
3284 if (parse_unix_path(&uaddr, host_str) < 0)
3289 addr = (struct sockaddr *)&saddr;
3290 addrlen = sizeof(saddr);
3291 if (parse_host_port(&saddr, host_str) < 0)
3296 while((ptr = strchr(ptr,','))) {
3298 if (!strncmp(ptr,"server",6)) {
3300 } else if (!strncmp(ptr,"nowait",6)) {
3302 } else if (!strncmp(ptr,"nodelay",6)) {
3305 printf("Unknown option: %s\n", ptr);
3312 chr = qemu_mallocz(sizeof(CharDriverState));
3315 s = qemu_mallocz(sizeof(TCPCharDriver));
3321 fd = socket(PF_UNIX, SOCK_STREAM, 0);
3324 fd = socket(PF_INET, SOCK_STREAM, 0);
3329 if (!is_waitconnect)
3330 socket_set_nonblock(fd);
3335 s->is_unix = is_unix;
3336 s->do_nodelay = do_nodelay && !is_unix;
3339 chr->chr_write = tcp_chr_write;
3340 chr->chr_close = tcp_chr_close;
3343 /* allow fast reuse */
3347 strncpy(path, uaddr.sun_path, 108);
3354 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
3357 ret = bind(fd, addr, addrlen);
3361 ret = listen(fd, 0);
3366 qemu_set_fd_handler(s->listen_fd, tcp_chr_accept, NULL, chr);
3368 s->do_telnetopt = 1;
3371 ret = connect(fd, addr, addrlen);
3373 err = socket_error();
3374 if (err == EINTR || err == EWOULDBLOCK) {
3375 } else if (err == EINPROGRESS) {
3378 } else if (err == WSAEALREADY) {
3390 socket_set_nodelay(fd);
3392 tcp_chr_connect(chr);
3394 qemu_set_fd_handler(s->fd, NULL, tcp_chr_connect, chr);
3397 if (is_listen && is_waitconnect) {
3398 printf("QEMU waiting for connection on: %s\n", host_str);
3399 tcp_chr_accept(chr);
3400 socket_set_nonblock(s->listen_fd);
3412 CharDriverState *qemu_chr_open(const char *filename)
3416 if (!strcmp(filename, "vc")) {
3417 return text_console_init(&display_state, 0);
3418 } else if (strstart(filename, "vc:", &p)) {
3419 return text_console_init(&display_state, p);
3420 } else if (!strcmp(filename, "null")) {
3421 return qemu_chr_open_null();
3423 if (strstart(filename, "tcp:", &p)) {
3424 return qemu_chr_open_tcp(p, 0, 0);
3426 if (strstart(filename, "telnet:", &p)) {
3427 return qemu_chr_open_tcp(p, 1, 0);
3429 if (strstart(filename, "udp:", &p)) {
3430 return qemu_chr_open_udp(p);
3432 if (strstart(filename, "mon:", &p)) {
3433 CharDriverState *drv = qemu_chr_open(p);
3435 drv = qemu_chr_open_mux(drv);
3436 monitor_init(drv, !nographic);
3439 printf("Unable to open driver: %s\n", p);
3443 if (strstart(filename, "unix:", &p)) {
3444 return qemu_chr_open_tcp(p, 0, 1);
3445 } else if (strstart(filename, "file:", &p)) {
3446 return qemu_chr_open_file_out(p);
3447 } else if (strstart(filename, "pipe:", &p)) {
3448 return qemu_chr_open_pipe(p);
3449 } else if (!strcmp(filename, "pty")) {
3450 return qemu_chr_open_pty();
3451 } else if (!strcmp(filename, "stdio")) {
3452 return qemu_chr_open_stdio();
3454 #if defined(__linux__)
3455 if (strstart(filename, "/dev/parport", NULL)) {
3456 return qemu_chr_open_pp(filename);
3459 #if defined(__linux__) || defined(__sun__)
3460 if (strstart(filename, "/dev/", NULL)) {
3461 return qemu_chr_open_tty(filename);
3465 if (strstart(filename, "COM", NULL)) {
3466 return qemu_chr_open_win(filename);
3468 if (strstart(filename, "pipe:", &p)) {
3469 return qemu_chr_open_win_pipe(p);
3471 if (strstart(filename, "con:", NULL)) {
3472 return qemu_chr_open_win_con(filename);
3474 if (strstart(filename, "file:", &p)) {
3475 return qemu_chr_open_win_file_out(p);
3478 #ifdef CONFIG_BRLAPI
3479 if (!strcmp(filename, "braille")) {
3480 return chr_baum_init();
3488 void qemu_chr_close(CharDriverState *chr)
3491 chr->chr_close(chr);
3495 /***********************************************************/
3496 /* network device redirectors */
3498 __attribute__ (( unused ))
3499 static void hex_dump(FILE *f, const uint8_t *buf, int size)
3503 for(i=0;i<size;i+=16) {
3507 fprintf(f, "%08x ", i);
3510 fprintf(f, " %02x", buf[i+j]);
3515 for(j=0;j<len;j++) {
3517 if (c < ' ' || c > '~')
3519 fprintf(f, "%c", c);
3525 static int parse_macaddr(uint8_t *macaddr, const char *p)
3532 offset = strtol(p, &last_char, 0);
3533 if (0 == errno && '\0' == *last_char &&
3534 offset >= 0 && offset <= 0xFFFFFF) {
3535 macaddr[3] = (offset & 0xFF0000) >> 16;
3536 macaddr[4] = (offset & 0xFF00) >> 8;
3537 macaddr[5] = offset & 0xFF;
3540 for(i = 0; i < 6; i++) {
3541 macaddr[i] = strtol(p, (char **)&p, 16);
3546 if (*p != ':' && *p != '-')
3557 static int get_str_sep(char *buf, int buf_size, const char **pp, int sep)
3562 p1 = strchr(p, sep);
3568 if (len > buf_size - 1)
3570 memcpy(buf, p, len);
3577 int parse_host_src_port(struct sockaddr_in *haddr,
3578 struct sockaddr_in *saddr,
3579 const char *input_str)
3581 char *str = strdup(input_str);
3582 char *host_str = str;
3587 * Chop off any extra arguments at the end of the string which
3588 * would start with a comma, then fill in the src port information
3589 * if it was provided else use the "any address" and "any port".
3591 if ((ptr = strchr(str,',')))
3594 if ((src_str = strchr(input_str,'@'))) {
3599 if (parse_host_port(haddr, host_str) < 0)
3602 if (!src_str || *src_str == '\0')
3605 if (parse_host_port(saddr, src_str) < 0)
3616 int parse_host_port(struct sockaddr_in *saddr, const char *str)
3624 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3626 saddr->sin_family = AF_INET;
3627 if (buf[0] == '\0') {
3628 saddr->sin_addr.s_addr = 0;
3630 if (isdigit(buf[0])) {
3631 if (!inet_aton(buf, &saddr->sin_addr))
3634 if ((he = gethostbyname(buf)) == NULL)
3636 saddr->sin_addr = *(struct in_addr *)he->h_addr;
3639 port = strtol(p, (char **)&r, 0);
3642 saddr->sin_port = htons(port);
3647 static int parse_unix_path(struct sockaddr_un *uaddr, const char *str)
3652 len = MIN(108, strlen(str));
3653 p = strchr(str, ',');
3655 len = MIN(len, p - str);
3657 memset(uaddr, 0, sizeof(*uaddr));
3659 uaddr->sun_family = AF_UNIX;
3660 memcpy(uaddr->sun_path, str, len);
3666 /* find or alloc a new VLAN */
3667 VLANState *qemu_find_vlan(int id)
3669 VLANState **pvlan, *vlan;
3670 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
3674 vlan = qemu_mallocz(sizeof(VLANState));
3679 pvlan = &first_vlan;
3680 while (*pvlan != NULL)
3681 pvlan = &(*pvlan)->next;
3686 VLANClientState *qemu_new_vlan_client(VLANState *vlan,
3687 IOReadHandler *fd_read,
3688 IOCanRWHandler *fd_can_read,
3691 VLANClientState *vc, **pvc;
3692 vc = qemu_mallocz(sizeof(VLANClientState));
3695 vc->fd_read = fd_read;
3696 vc->fd_can_read = fd_can_read;
3697 vc->opaque = opaque;
3701 pvc = &vlan->first_client;
3702 while (*pvc != NULL)
3703 pvc = &(*pvc)->next;
3708 int qemu_can_send_packet(VLANClientState *vc1)
3710 VLANState *vlan = vc1->vlan;
3711 VLANClientState *vc;
3713 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3715 if (vc->fd_can_read && vc->fd_can_read(vc->opaque))
3722 void qemu_send_packet(VLANClientState *vc1, const uint8_t *buf, int size)
3724 VLANState *vlan = vc1->vlan;
3725 VLANClientState *vc;
3728 printf("vlan %d send:\n", vlan->id);
3729 hex_dump(stdout, buf, size);
3731 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
3733 vc->fd_read(vc->opaque, buf, size);
3738 #if defined(CONFIG_SLIRP)
3740 /* slirp network adapter */
3742 static int slirp_inited;
3743 static VLANClientState *slirp_vc;
3745 int slirp_can_output(void)
3747 return !slirp_vc || qemu_can_send_packet(slirp_vc);
3750 void slirp_output(const uint8_t *pkt, int pkt_len)
3753 printf("slirp output:\n");
3754 hex_dump(stdout, pkt, pkt_len);
3758 qemu_send_packet(slirp_vc, pkt, pkt_len);
3761 static void slirp_receive(void *opaque, const uint8_t *buf, int size)
3764 printf("slirp input:\n");
3765 hex_dump(stdout, buf, size);
3767 slirp_input(buf, size);
3770 static int net_slirp_init(VLANState *vlan)
3772 if (!slirp_inited) {
3776 slirp_vc = qemu_new_vlan_client(vlan,
3777 slirp_receive, NULL, NULL);
3778 snprintf(slirp_vc->info_str, sizeof(slirp_vc->info_str), "user redirector");
3782 static void net_slirp_redir(const char *redir_str)
3787 struct in_addr guest_addr;
3788 int host_port, guest_port;
3790 if (!slirp_inited) {
3796 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3798 if (!strcmp(buf, "tcp")) {
3800 } else if (!strcmp(buf, "udp")) {
3806 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3808 host_port = strtol(buf, &r, 0);
3812 if (get_str_sep(buf, sizeof(buf), &p, ':') < 0)
3814 if (buf[0] == '\0') {
3815 pstrcpy(buf, sizeof(buf), "10.0.2.15");
3817 if (!inet_aton(buf, &guest_addr))
3820 guest_port = strtol(p, &r, 0);
3824 if (slirp_redir(is_udp, host_port, guest_addr, guest_port) < 0) {
3825 fprintf(stderr, "qemu: could not set up redirection\n");
3830 fprintf(stderr, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
3838 static void erase_dir(char *dir_name)
3842 char filename[1024];
3844 /* erase all the files in the directory */
3845 if ((d = opendir(dir_name)) != 0) {
3850 if (strcmp(de->d_name, ".") != 0 &&
3851 strcmp(de->d_name, "..") != 0) {
3852 snprintf(filename, sizeof(filename), "%s/%s",
3853 smb_dir, de->d_name);
3854 if (unlink(filename) != 0) /* is it a directory? */
3855 erase_dir(filename);
3863 /* automatic user mode samba server configuration */
3864 static void smb_exit(void)
3869 /* automatic user mode samba server configuration */
3870 static void net_slirp_smb(const char *exported_dir)
3872 char smb_conf[1024];
3873 char smb_cmdline[1024];
3876 if (!slirp_inited) {
3881 /* XXX: better tmp dir construction */
3882 snprintf(smb_dir, sizeof(smb_dir), "/tmp/qemu-smb.%d", getpid());
3883 if (mkdir(smb_dir, 0700) < 0) {
3884 fprintf(stderr, "qemu: could not create samba server dir '%s'\n", smb_dir);
3887 snprintf(smb_conf, sizeof(smb_conf), "%s/%s", smb_dir, "smb.conf");
3889 f = fopen(smb_conf, "w");
3891 fprintf(stderr, "qemu: could not create samba server configuration file '%s'\n", smb_conf);
3898 "socket address=127.0.0.1\n"
3899 "pid directory=%s\n"
3900 "lock directory=%s\n"
3901 "log file=%s/log.smbd\n"
3902 "smb passwd file=%s/smbpasswd\n"
3903 "security = share\n"
3918 snprintf(smb_cmdline, sizeof(smb_cmdline), "%s -s %s",
3919 SMBD_COMMAND, smb_conf);
3921 slirp_add_exec(0, smb_cmdline, 4, 139);
3924 #endif /* !defined(_WIN32) */
3925 void do_info_slirp(void)
3930 #endif /* CONFIG_SLIRP */
3932 #if !defined(_WIN32)
3934 typedef struct TAPState {
3935 VLANClientState *vc;
3937 char down_script[1024];
3940 static void tap_receive(void *opaque, const uint8_t *buf, int size)
3942 TAPState *s = opaque;
3945 ret = write(s->fd, buf, size);
3946 if (ret < 0 && (errno == EINTR || errno == EAGAIN)) {
3953 static void tap_send(void *opaque)
3955 TAPState *s = opaque;
3962 sbuf.maxlen = sizeof(buf);
3964 size = getmsg(s->fd, NULL, &sbuf, &f) >=0 ? sbuf.len : -1;
3966 size = read(s->fd, buf, sizeof(buf));
3969 qemu_send_packet(s->vc, buf, size);
3975 static TAPState *net_tap_fd_init(VLANState *vlan, int fd)
3979 s = qemu_mallocz(sizeof(TAPState));
3983 s->vc = qemu_new_vlan_client(vlan, tap_receive, NULL, s);
3984 qemu_set_fd_handler(s->fd, tap_send, NULL, s);
3985 snprintf(s->vc->info_str, sizeof(s->vc->info_str), "tap: fd=%d", fd);
3989 #if defined (_BSD) || defined (__FreeBSD_kernel__)
3990 static int tap_open(char *ifname, int ifname_size)
3996 TFR(fd = open("/dev/tap", O_RDWR));
3998 fprintf(stderr, "warning: could not open /dev/tap: no virtual network emulation\n");
4003 dev = devname(s.st_rdev, S_IFCHR);
4004 pstrcpy(ifname, ifname_size, dev);
4006 fcntl(fd, F_SETFL, O_NONBLOCK);
4009 #elif defined(__sun__)
4010 #define TUNNEWPPA (('T'<<16) | 0x0001)
4012 * Allocate TAP device, returns opened fd.
4013 * Stores dev name in the first arg(must be large enough).
4015 int tap_alloc(char *dev)
4017 int tap_fd, if_fd, ppa = -1;
4018 static int ip_fd = 0;
4021 static int arp_fd = 0;
4022 int ip_muxid, arp_muxid;
4023 struct strioctl strioc_if, strioc_ppa;
4024 int link_type = I_PLINK;;
4026 char actual_name[32] = "";
4028 memset(&ifr, 0x0, sizeof(ifr));
4032 while( *ptr && !isdigit((int)*ptr) ) ptr++;
4036 /* Check if IP device was opened */
4040 TFR(ip_fd = open("/dev/udp", O_RDWR, 0));
4042 syslog(LOG_ERR, "Can't open /dev/ip (actually /dev/udp)");
4046 TFR(tap_fd = open("/dev/tap", O_RDWR, 0));
4048 syslog(LOG_ERR, "Can't open /dev/tap");
4052 /* Assign a new PPA and get its unit number. */
4053 strioc_ppa.ic_cmd = TUNNEWPPA;
4054 strioc_ppa.ic_timout = 0;
4055 strioc_ppa.ic_len = sizeof(ppa);
4056 strioc_ppa.ic_dp = (char *)&ppa;
4057 if ((ppa = ioctl (tap_fd, I_STR, &strioc_ppa)) < 0)
4058 syslog (LOG_ERR, "Can't assign new interface");
4060 TFR(if_fd = open("/dev/tap", O_RDWR, 0));
4062 syslog(LOG_ERR, "Can't open /dev/tap (2)");
4065 if(ioctl(if_fd, I_PUSH, "ip") < 0){
4066 syslog(LOG_ERR, "Can't push IP module");
4070 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) < 0)
4071 syslog(LOG_ERR, "Can't get flags\n");
4073 snprintf (actual_name, 32, "tap%d", ppa);
4074 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4077 /* Assign ppa according to the unit number returned by tun device */
4079 if (ioctl (if_fd, SIOCSLIFNAME, &ifr) < 0)
4080 syslog (LOG_ERR, "Can't set PPA %d", ppa);
4081 if (ioctl(if_fd, SIOCGLIFFLAGS, &ifr) <0)
4082 syslog (LOG_ERR, "Can't get flags\n");
4083 /* Push arp module to if_fd */
4084 if (ioctl (if_fd, I_PUSH, "arp") < 0)
4085 syslog (LOG_ERR, "Can't push ARP module (2)");
4087 /* Push arp module to ip_fd */
4088 if (ioctl (ip_fd, I_POP, NULL) < 0)
4089 syslog (LOG_ERR, "I_POP failed\n");
4090 if (ioctl (ip_fd, I_PUSH, "arp") < 0)
4091 syslog (LOG_ERR, "Can't push ARP module (3)\n");
4093 TFR(arp_fd = open ("/dev/tap", O_RDWR, 0));
4095 syslog (LOG_ERR, "Can't open %s\n", "/dev/tap");
4097 /* Set ifname to arp */
4098 strioc_if.ic_cmd = SIOCSLIFNAME;
4099 strioc_if.ic_timout = 0;
4100 strioc_if.ic_len = sizeof(ifr);
4101 strioc_if.ic_dp = (char *)𝔦
4102 if (ioctl(arp_fd, I_STR, &strioc_if) < 0){
4103 syslog (LOG_ERR, "Can't set ifname to arp\n");
4106 if((ip_muxid = ioctl(ip_fd, I_LINK, if_fd)) < 0){
4107 syslog(LOG_ERR, "Can't link TAP device to IP");
4111 if ((arp_muxid = ioctl (ip_fd, link_type, arp_fd)) < 0)
4112 syslog (LOG_ERR, "Can't link TAP device to ARP");
4116 memset(&ifr, 0x0, sizeof(ifr));
4117 strncpy (ifr.lifr_name, actual_name, sizeof (ifr.lifr_name));
4118 ifr.lifr_ip_muxid = ip_muxid;
4119 ifr.lifr_arp_muxid = arp_muxid;
4121 if (ioctl (ip_fd, SIOCSLIFMUXID, &ifr) < 0)
4123 ioctl (ip_fd, I_PUNLINK , arp_muxid);
4124 ioctl (ip_fd, I_PUNLINK, ip_muxid);
4125 syslog (LOG_ERR, "Can't set multiplexor id");
4128 sprintf(dev, "tap%d", ppa);
4132 static int tap_open(char *ifname, int ifname_size)
4136 if( (fd = tap_alloc(dev)) < 0 ){
4137 fprintf(stderr, "Cannot allocate TAP device\n");
4140 pstrcpy(ifname, ifname_size, dev);
4141 fcntl(fd, F_SETFL, O_NONBLOCK);
4145 static int tap_open(char *ifname, int ifname_size)
4150 TFR(fd = open("/dev/net/tun", O_RDWR));
4152 fprintf(stderr, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4155 memset(&ifr, 0, sizeof(ifr));
4156 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
4157 if (ifname[0] != '\0')
4158 pstrcpy(ifr.ifr_name, IFNAMSIZ, ifname);
4160 pstrcpy(ifr.ifr_name, IFNAMSIZ, "tap%d");
4161 ret = ioctl(fd, TUNSETIFF, (void *) &ifr);
4163 fprintf(stderr, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4167 pstrcpy(ifname, ifname_size, ifr.ifr_name);
4168 fcntl(fd, F_SETFL, O_NONBLOCK);
4173 static int launch_script(const char *setup_script, const char *ifname, int fd)
4179 /* try to launch network script */
4183 int open_max = sysconf (_SC_OPEN_MAX), i;
4184 for (i = 0; i < open_max; i++)
4185 if (i != STDIN_FILENO &&
4186 i != STDOUT_FILENO &&
4187 i != STDERR_FILENO &&
4192 *parg++ = (char *)setup_script;
4193 *parg++ = (char *)ifname;
4195 execv(setup_script, args);
4198 while (waitpid(pid, &status, 0) != pid);
4199 if (!WIFEXITED(status) ||
4200 WEXITSTATUS(status) != 0) {
4201 fprintf(stderr, "%s: could not launch network script\n",
4209 static int net_tap_init(VLANState *vlan, const char *ifname1,
4210 const char *setup_script, const char *down_script)
4216 if (ifname1 != NULL)
4217 pstrcpy(ifname, sizeof(ifname), ifname1);
4220 TFR(fd = tap_open(ifname, sizeof(ifname)));
4224 if (!setup_script || !strcmp(setup_script, "no"))
4226 if (setup_script[0] != '\0') {
4227 if (launch_script(setup_script, ifname, fd))
4230 s = net_tap_fd_init(vlan, fd);
4233 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4234 "tap: ifname=%s setup_script=%s", ifname, setup_script);
4235 if (down_script && strcmp(down_script, "no"))
4236 snprintf(s->down_script, sizeof(s->down_script), "%s", down_script);
4240 #endif /* !_WIN32 */
4242 /* network connection */
4243 typedef struct NetSocketState {
4244 VLANClientState *vc;
4246 int state; /* 0 = getting length, 1 = getting data */
4250 struct sockaddr_in dgram_dst; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4253 typedef struct NetSocketListenState {
4256 } NetSocketListenState;
4258 /* XXX: we consider we can send the whole packet without blocking */
4259 static void net_socket_receive(void *opaque, const uint8_t *buf, int size)
4261 NetSocketState *s = opaque;
4265 send_all(s->fd, (const uint8_t *)&len, sizeof(len));
4266 send_all(s->fd, buf, size);
4269 static void net_socket_receive_dgram(void *opaque, const uint8_t *buf, int size)
4271 NetSocketState *s = opaque;
4272 sendto(s->fd, buf, size, 0,
4273 (struct sockaddr *)&s->dgram_dst, sizeof(s->dgram_dst));
4276 static void net_socket_send(void *opaque)
4278 NetSocketState *s = opaque;
4283 size = recv(s->fd, buf1, sizeof(buf1), 0);
4285 err = socket_error();
4286 if (err != EWOULDBLOCK)
4288 } else if (size == 0) {
4289 /* end of connection */
4291 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4297 /* reassemble a packet from the network */
4303 memcpy(s->buf + s->index, buf, l);
4307 if (s->index == 4) {
4309 s->packet_len = ntohl(*(uint32_t *)s->buf);
4315 l = s->packet_len - s->index;
4318 memcpy(s->buf + s->index, buf, l);
4322 if (s->index >= s->packet_len) {
4323 qemu_send_packet(s->vc, s->buf, s->packet_len);
4332 static void net_socket_send_dgram(void *opaque)
4334 NetSocketState *s = opaque;
4337 size = recv(s->fd, s->buf, sizeof(s->buf), 0);
4341 /* end of connection */
4342 qemu_set_fd_handler(s->fd, NULL, NULL, NULL);
4345 qemu_send_packet(s->vc, s->buf, size);
4348 static int net_socket_mcast_create(struct sockaddr_in *mcastaddr)
4353 if (!IN_MULTICAST(ntohl(mcastaddr->sin_addr.s_addr))) {
4354 fprintf(stderr, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4355 inet_ntoa(mcastaddr->sin_addr),
4356 (int)ntohl(mcastaddr->sin_addr.s_addr));
4360 fd = socket(PF_INET, SOCK_DGRAM, 0);
4362 perror("socket(PF_INET, SOCK_DGRAM)");
4367 ret=setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
4368 (const char *)&val, sizeof(val));
4370 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4374 ret = bind(fd, (struct sockaddr *)mcastaddr, sizeof(*mcastaddr));
4380 /* Add host to multicast group */
4381 imr.imr_multiaddr = mcastaddr->sin_addr;
4382 imr.imr_interface.s_addr = htonl(INADDR_ANY);
4384 ret = setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP,
4385 (const char *)&imr, sizeof(struct ip_mreq));
4387 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4391 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4393 ret=setsockopt(fd, IPPROTO_IP, IP_MULTICAST_LOOP,
4394 (const char *)&val, sizeof(val));
4396 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4400 socket_set_nonblock(fd);
4408 static NetSocketState *net_socket_fd_init_dgram(VLANState *vlan, int fd,
4411 struct sockaddr_in saddr;
4413 socklen_t saddr_len;
4416 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4417 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4418 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4422 if (getsockname(fd, (struct sockaddr *) &saddr, &saddr_len) == 0) {
4424 if (saddr.sin_addr.s_addr==0) {
4425 fprintf(stderr, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4429 /* clone dgram socket */
4430 newfd = net_socket_mcast_create(&saddr);
4432 /* error already reported by net_socket_mcast_create() */
4436 /* clone newfd to fd, close newfd */
4441 fprintf(stderr, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4442 fd, strerror(errno));
4447 s = qemu_mallocz(sizeof(NetSocketState));
4452 s->vc = qemu_new_vlan_client(vlan, net_socket_receive_dgram, NULL, s);
4453 qemu_set_fd_handler(s->fd, net_socket_send_dgram, NULL, s);
4455 /* mcast: save bound address as dst */
4456 if (is_connected) s->dgram_dst=saddr;
4458 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4459 "socket: fd=%d (%s mcast=%s:%d)",
4460 fd, is_connected? "cloned" : "",
4461 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4465 static void net_socket_connect(void *opaque)
4467 NetSocketState *s = opaque;
4468 qemu_set_fd_handler(s->fd, net_socket_send, NULL, s);
4471 static NetSocketState *net_socket_fd_init_stream(VLANState *vlan, int fd,
4475 s = qemu_mallocz(sizeof(NetSocketState));
4479 s->vc = qemu_new_vlan_client(vlan,
4480 net_socket_receive, NULL, s);
4481 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4482 "socket: fd=%d", fd);
4484 net_socket_connect(s);
4486 qemu_set_fd_handler(s->fd, NULL, net_socket_connect, s);
4491 static NetSocketState *net_socket_fd_init(VLANState *vlan, int fd,
4494 int so_type=-1, optlen=sizeof(so_type);
4496 if(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&so_type,
4497 (socklen_t *)&optlen)< 0) {
4498 fprintf(stderr, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd);
4503 return net_socket_fd_init_dgram(vlan, fd, is_connected);
4505 return net_socket_fd_init_stream(vlan, fd, is_connected);
4507 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4508 fprintf(stderr, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type, fd);
4509 return net_socket_fd_init_stream(vlan, fd, is_connected);
4514 static void net_socket_accept(void *opaque)
4516 NetSocketListenState *s = opaque;
4518 struct sockaddr_in saddr;
4523 len = sizeof(saddr);
4524 fd = accept(s->fd, (struct sockaddr *)&saddr, &len);
4525 if (fd < 0 && errno != EINTR) {
4527 } else if (fd >= 0) {
4531 s1 = net_socket_fd_init(s->vlan, fd, 1);
4535 snprintf(s1->vc->info_str, sizeof(s1->vc->info_str),
4536 "socket: connection from %s:%d",
4537 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4541 static int net_socket_listen_init(VLANState *vlan, const char *host_str)
4543 NetSocketListenState *s;
4545 struct sockaddr_in saddr;
4547 if (parse_host_port(&saddr, host_str) < 0)
4550 s = qemu_mallocz(sizeof(NetSocketListenState));
4554 fd = socket(PF_INET, SOCK_STREAM, 0);
4559 socket_set_nonblock(fd);
4561 /* allow fast reuse */
4563 setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(val));
4565 ret = bind(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4570 ret = listen(fd, 0);
4577 qemu_set_fd_handler(fd, net_socket_accept, NULL, s);
4581 static int net_socket_connect_init(VLANState *vlan, const char *host_str)
4584 int fd, connected, ret, err;
4585 struct sockaddr_in saddr;
4587 if (parse_host_port(&saddr, host_str) < 0)
4590 fd = socket(PF_INET, SOCK_STREAM, 0);
4595 socket_set_nonblock(fd);
4599 ret = connect(fd, (struct sockaddr *)&saddr, sizeof(saddr));
4601 err = socket_error();
4602 if (err == EINTR || err == EWOULDBLOCK) {
4603 } else if (err == EINPROGRESS) {
4606 } else if (err == WSAEALREADY) {
4619 s = net_socket_fd_init(vlan, fd, connected);
4622 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4623 "socket: connect to %s:%d",
4624 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4628 static int net_socket_mcast_init(VLANState *vlan, const char *host_str)
4632 struct sockaddr_in saddr;
4634 if (parse_host_port(&saddr, host_str) < 0)
4638 fd = net_socket_mcast_create(&saddr);
4642 s = net_socket_fd_init(vlan, fd, 0);
4646 s->dgram_dst = saddr;
4648 snprintf(s->vc->info_str, sizeof(s->vc->info_str),
4649 "socket: mcast=%s:%d",
4650 inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
4655 static const char *get_opt_name(char *buf, int buf_size, const char *p)
4660 while (*p != '\0' && *p != '=') {
4661 if (q && (q - buf) < buf_size - 1)
4671 static const char *get_opt_value(char *buf, int buf_size, const char *p)
4676 while (*p != '\0') {
4678 if (*(p + 1) != ',')
4682 if (q && (q - buf) < buf_size - 1)
4692 static int get_param_value(char *buf, int buf_size,
4693 const char *tag, const char *str)
4700 p = get_opt_name(option, sizeof(option), p);
4704 if (!strcmp(tag, option)) {
4705 (void)get_opt_value(buf, buf_size, p);
4708 p = get_opt_value(NULL, 0, p);
4717 static int check_params(char *buf, int buf_size,
4718 char **params, const char *str)
4725 p = get_opt_name(buf, buf_size, p);
4729 for(i = 0; params[i] != NULL; i++)
4730 if (!strcmp(params[i], buf))
4732 if (params[i] == NULL)
4734 p = get_opt_value(NULL, 0, p);
4743 static int net_client_init(const char *str)
4754 while (*p != '\0' && *p != ',') {
4755 if ((q - device) < sizeof(device) - 1)
4763 if (get_param_value(buf, sizeof(buf), "vlan", p)) {
4764 vlan_id = strtol(buf, NULL, 0);
4766 vlan = qemu_find_vlan(vlan_id);
4768 fprintf(stderr, "Could not create vlan %d\n", vlan_id);
4771 if (!strcmp(device, "nic")) {
4775 if (nb_nics >= MAX_NICS) {
4776 fprintf(stderr, "Too Many NICs\n");
4779 nd = &nd_table[nb_nics];
4780 macaddr = nd->macaddr;
4786 macaddr[5] = 0x56 + nb_nics;
4788 if (get_param_value(buf, sizeof(buf), "macaddr", p)) {
4789 if (parse_macaddr(macaddr, buf) < 0) {
4790 fprintf(stderr, "invalid syntax for ethernet address\n");
4794 if (get_param_value(buf, sizeof(buf), "model", p)) {
4795 nd->model = strdup(buf);
4799 vlan->nb_guest_devs++;
4802 if (!strcmp(device, "none")) {
4803 /* does nothing. It is needed to signal that no network cards
4808 if (!strcmp(device, "user")) {
4809 if (get_param_value(buf, sizeof(buf), "hostname", p)) {
4810 pstrcpy(slirp_hostname, sizeof(slirp_hostname), buf);
4812 vlan->nb_host_devs++;
4813 ret = net_slirp_init(vlan);
4817 if (!strcmp(device, "tap")) {
4819 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4820 fprintf(stderr, "tap: no interface name\n");
4823 vlan->nb_host_devs++;
4824 ret = tap_win32_init(vlan, ifname);
4827 if (!strcmp(device, "tap")) {
4829 char setup_script[1024], down_script[1024];
4831 vlan->nb_host_devs++;
4832 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4833 fd = strtol(buf, NULL, 0);
4834 fcntl(fd, F_SETFL, O_NONBLOCK);
4836 if (net_tap_fd_init(vlan, fd))
4839 if (get_param_value(ifname, sizeof(ifname), "ifname", p) <= 0) {
4842 if (get_param_value(setup_script, sizeof(setup_script), "script", p) == 0) {
4843 pstrcpy(setup_script, sizeof(setup_script), DEFAULT_NETWORK_SCRIPT);
4845 if (get_param_value(down_script, sizeof(down_script), "downscript", p) == 0) {
4846 pstrcpy(down_script, sizeof(down_script), DEFAULT_NETWORK_DOWN_SCRIPT);
4848 ret = net_tap_init(vlan, ifname, setup_script, down_script);
4852 if (!strcmp(device, "socket")) {
4853 if (get_param_value(buf, sizeof(buf), "fd", p) > 0) {
4855 fd = strtol(buf, NULL, 0);
4857 if (net_socket_fd_init(vlan, fd, 1))
4859 } else if (get_param_value(buf, sizeof(buf), "listen", p) > 0) {
4860 ret = net_socket_listen_init(vlan, buf);
4861 } else if (get_param_value(buf, sizeof(buf), "connect", p) > 0) {
4862 ret = net_socket_connect_init(vlan, buf);
4863 } else if (get_param_value(buf, sizeof(buf), "mcast", p) > 0) {
4864 ret = net_socket_mcast_init(vlan, buf);
4866 fprintf(stderr, "Unknown socket options: %s\n", p);
4869 vlan->nb_host_devs++;
4872 fprintf(stderr, "Unknown network device: %s\n", device);
4876 fprintf(stderr, "Could not initialize device '%s'\n", device);
4882 void do_info_network(void)
4885 VLANClientState *vc;
4887 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
4888 term_printf("VLAN %d devices:\n", vlan->id);
4889 for(vc = vlan->first_client; vc != NULL; vc = vc->next)
4890 term_printf(" %s\n", vc->info_str);
4894 #define HD_ALIAS "index=%d,media=disk"
4896 #define CDROM_ALIAS "index=1,media=cdrom"
4898 #define CDROM_ALIAS "index=2,media=cdrom"
4900 #define FD_ALIAS "index=%d,if=floppy"
4901 #define PFLASH_ALIAS "if=pflash"
4902 #define MTD_ALIAS "if=mtd"
4903 #define SD_ALIAS "index=0,if=sd"
4905 static int drive_add(const char *file, const char *fmt, ...)
4909 if (nb_drives_opt >= MAX_DRIVES) {
4910 fprintf(stderr, "qemu: too many drives\n");
4914 drives_opt[nb_drives_opt].file = file;
4916 vsnprintf(drives_opt[nb_drives_opt].opt,
4917 sizeof(drives_opt[0].opt), fmt, ap);
4920 return nb_drives_opt++;
4923 int drive_get_index(BlockInterfaceType type, int bus, int unit)
4927 /* seek interface, bus and unit */
4929 for (index = 0; index < nb_drives; index++)
4930 if (drives_table[index].type == type &&
4931 drives_table[index].bus == bus &&
4932 drives_table[index].unit == unit)
4938 int drive_get_max_bus(BlockInterfaceType type)
4944 for (index = 0; index < nb_drives; index++) {
4945 if(drives_table[index].type == type &&
4946 drives_table[index].bus > max_bus)
4947 max_bus = drives_table[index].bus;
4952 static void bdrv_format_print(void *opaque, const char *name)
4954 fprintf(stderr, " %s", name);
4957 static int drive_init(struct drive_opt *arg, int snapshot,
4958 QEMUMachine *machine)
4963 const char *mediastr = "";
4964 BlockInterfaceType type;
4965 enum { MEDIA_DISK, MEDIA_CDROM } media;
4966 int bus_id, unit_id;
4967 int cyls, heads, secs, translation;
4968 BlockDriverState *bdrv;
4969 BlockDriver *drv = NULL;
4974 char *str = arg->opt;
4975 char *params[] = { "bus", "unit", "if", "index", "cyls", "heads",
4976 "secs", "trans", "media", "snapshot", "file",
4977 "cache", "format", NULL };
4979 if (check_params(buf, sizeof(buf), params, str) < 0) {
4980 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
4986 cyls = heads = secs = 0;
4989 translation = BIOS_ATA_TRANSLATION_AUTO;
4993 if (!strcmp(machine->name, "realview") ||
4994 !strcmp(machine->name, "SS-5") ||
4995 !strcmp(machine->name, "SS-10") ||
4996 !strcmp(machine->name, "SS-600MP") ||
4997 !strcmp(machine->name, "versatilepb") ||
4998 !strcmp(machine->name, "versatileab")) {
5000 max_devs = MAX_SCSI_DEVS;
5001 strcpy(devname, "scsi");
5004 max_devs = MAX_IDE_DEVS;
5005 strcpy(devname, "ide");
5009 /* extract parameters */
5011 if (get_param_value(buf, sizeof(buf), "bus", str)) {
5012 bus_id = strtol(buf, NULL, 0);
5014 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
5019 if (get_param_value(buf, sizeof(buf), "unit", str)) {
5020 unit_id = strtol(buf, NULL, 0);
5022 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
5027 if (get_param_value(buf, sizeof(buf), "if", str)) {
5028 strncpy(devname, buf, sizeof(devname));
5029 if (!strcmp(buf, "ide")) {
5031 max_devs = MAX_IDE_DEVS;
5032 } else if (!strcmp(buf, "scsi")) {
5034 max_devs = MAX_SCSI_DEVS;
5035 } else if (!strcmp(buf, "floppy")) {
5038 } else if (!strcmp(buf, "pflash")) {
5041 } else if (!strcmp(buf, "mtd")) {
5044 } else if (!strcmp(buf, "sd")) {
5048 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
5053 if (get_param_value(buf, sizeof(buf), "index", str)) {
5054 index = strtol(buf, NULL, 0);
5056 fprintf(stderr, "qemu: '%s' invalid index\n", str);
5061 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
5062 cyls = strtol(buf, NULL, 0);
5065 if (get_param_value(buf, sizeof(buf), "heads", str)) {
5066 heads = strtol(buf, NULL, 0);
5069 if (get_param_value(buf, sizeof(buf), "secs", str)) {
5070 secs = strtol(buf, NULL, 0);
5073 if (cyls || heads || secs) {
5074 if (cyls < 1 || cyls > 16383) {
5075 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
5078 if (heads < 1 || heads > 16) {
5079 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
5082 if (secs < 1 || secs > 63) {
5083 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
5088 if (get_param_value(buf, sizeof(buf), "trans", str)) {
5091 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5095 if (!strcmp(buf, "none"))
5096 translation = BIOS_ATA_TRANSLATION_NONE;
5097 else if (!strcmp(buf, "lba"))
5098 translation = BIOS_ATA_TRANSLATION_LBA;
5099 else if (!strcmp(buf, "auto"))
5100 translation = BIOS_ATA_TRANSLATION_AUTO;
5102 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
5107 if (get_param_value(buf, sizeof(buf), "media", str)) {
5108 if (!strcmp(buf, "disk")) {
5110 } else if (!strcmp(buf, "cdrom")) {
5111 if (cyls || secs || heads) {
5113 "qemu: '%s' invalid physical CHS format\n", str);
5116 media = MEDIA_CDROM;
5118 fprintf(stderr, "qemu: '%s' invalid media\n", str);
5123 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
5124 if (!strcmp(buf, "on"))
5126 else if (!strcmp(buf, "off"))
5129 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
5134 if (get_param_value(buf, sizeof(buf), "cache", str)) {
5135 if (!strcmp(buf, "off"))
5137 else if (!strcmp(buf, "on"))
5140 fprintf(stderr, "qemu: invalid cache option\n");
5145 if (get_param_value(buf, sizeof(buf), "format", str)) {
5146 if (strcmp(buf, "?") == 0) {
5147 fprintf(stderr, "qemu: Supported formats:");
5148 bdrv_iterate_format(bdrv_format_print, NULL);
5149 fprintf(stderr, "\n");
5152 drv = bdrv_find_format(buf);
5154 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
5159 if (arg->file == NULL)
5160 get_param_value(file, sizeof(file), "file", str);
5162 pstrcpy(file, sizeof(file), arg->file);
5164 /* compute bus and unit according index */
5167 if (bus_id != 0 || unit_id != -1) {
5169 "qemu: '%s' index cannot be used with bus and unit\n", str);
5177 unit_id = index % max_devs;
5178 bus_id = index / max_devs;
5182 /* if user doesn't specify a unit_id,
5183 * try to find the first free
5186 if (unit_id == -1) {
5188 while (drive_get_index(type, bus_id, unit_id) != -1) {
5190 if (max_devs && unit_id >= max_devs) {
5191 unit_id -= max_devs;
5199 if (max_devs && unit_id >= max_devs) {
5200 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
5201 str, unit_id, max_devs - 1);
5206 * ignore multiple definitions
5209 if (drive_get_index(type, bus_id, unit_id) != -1)
5214 if (type == IF_IDE || type == IF_SCSI)
5215 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
5217 snprintf(buf, sizeof(buf), "%s%i%s%i",
5218 devname, bus_id, mediastr, unit_id);
5220 snprintf(buf, sizeof(buf), "%s%s%i",
5221 devname, mediastr, unit_id);
5222 bdrv = bdrv_new(buf);
5223 drives_table[nb_drives].bdrv = bdrv;
5224 drives_table[nb_drives].type = type;
5225 drives_table[nb_drives].bus = bus_id;
5226 drives_table[nb_drives].unit = unit_id;
5235 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
5236 bdrv_set_translation_hint(bdrv, translation);
5240 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
5245 /* FIXME: This isn't really a floppy, but it's a reasonable
5248 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
5258 bdrv_flags |= BDRV_O_SNAPSHOT;
5260 bdrv_flags |= BDRV_O_DIRECT;
5261 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
5262 fprintf(stderr, "qemu: could not open disk image %s\n",
5269 /***********************************************************/
5272 static USBPort *used_usb_ports;
5273 static USBPort *free_usb_ports;
5275 /* ??? Maybe change this to register a hub to keep track of the topology. */
5276 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
5277 usb_attachfn attach)
5279 port->opaque = opaque;
5280 port->index = index;
5281 port->attach = attach;
5282 port->next = free_usb_ports;
5283 free_usb_ports = port;
5286 static int usb_device_add(const char *devname)
5292 if (!free_usb_ports)
5295 if (strstart(devname, "host:", &p)) {
5296 dev = usb_host_device_open(p);
5297 } else if (!strcmp(devname, "mouse")) {
5298 dev = usb_mouse_init();
5299 } else if (!strcmp(devname, "tablet")) {
5300 dev = usb_tablet_init();
5301 } else if (!strcmp(devname, "keyboard")) {
5302 dev = usb_keyboard_init();
5303 } else if (strstart(devname, "disk:", &p)) {
5304 dev = usb_msd_init(p);
5305 } else if (!strcmp(devname, "wacom-tablet")) {
5306 dev = usb_wacom_init();
5307 } else if (strstart(devname, "serial:", &p)) {
5308 dev = usb_serial_init(p);
5309 #ifdef CONFIG_BRLAPI
5310 } else if (!strcmp(devname, "braille")) {
5311 dev = usb_baum_init();
5319 /* Find a USB port to add the device to. */
5320 port = free_usb_ports;
5324 /* Create a new hub and chain it on. */
5325 free_usb_ports = NULL;
5326 port->next = used_usb_ports;
5327 used_usb_ports = port;
5329 hub = usb_hub_init(VM_USB_HUB_SIZE);
5330 usb_attach(port, hub);
5331 port = free_usb_ports;
5334 free_usb_ports = port->next;
5335 port->next = used_usb_ports;
5336 used_usb_ports = port;
5337 usb_attach(port, dev);
5341 static int usb_device_del(const char *devname)
5349 if (!used_usb_ports)
5352 p = strchr(devname, '.');
5355 bus_num = strtoul(devname, NULL, 0);
5356 addr = strtoul(p + 1, NULL, 0);
5360 lastp = &used_usb_ports;
5361 port = used_usb_ports;
5362 while (port && port->dev->addr != addr) {
5363 lastp = &port->next;
5371 *lastp = port->next;
5372 usb_attach(port, NULL);
5373 dev->handle_destroy(dev);
5374 port->next = free_usb_ports;
5375 free_usb_ports = port;
5379 void do_usb_add(const char *devname)
5382 ret = usb_device_add(devname);
5384 term_printf("Could not add USB device '%s'\n", devname);
5387 void do_usb_del(const char *devname)
5390 ret = usb_device_del(devname);
5392 term_printf("Could not remove USB device '%s'\n", devname);
5399 const char *speed_str;
5402 term_printf("USB support not enabled\n");
5406 for (port = used_usb_ports; port; port = port->next) {
5410 switch(dev->speed) {
5414 case USB_SPEED_FULL:
5417 case USB_SPEED_HIGH:
5424 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5425 0, dev->addr, speed_str, dev->devname);
5429 /***********************************************************/
5430 /* PCMCIA/Cardbus */
5432 static struct pcmcia_socket_entry_s {
5433 struct pcmcia_socket_s *socket;
5434 struct pcmcia_socket_entry_s *next;
5435 } *pcmcia_sockets = 0;
5437 void pcmcia_socket_register(struct pcmcia_socket_s *socket)
5439 struct pcmcia_socket_entry_s *entry;
5441 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
5442 entry->socket = socket;
5443 entry->next = pcmcia_sockets;
5444 pcmcia_sockets = entry;
5447 void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
5449 struct pcmcia_socket_entry_s *entry, **ptr;
5451 ptr = &pcmcia_sockets;
5452 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
5453 if (entry->socket == socket) {
5459 void pcmcia_info(void)
5461 struct pcmcia_socket_entry_s *iter;
5462 if (!pcmcia_sockets)
5463 term_printf("No PCMCIA sockets\n");
5465 for (iter = pcmcia_sockets; iter; iter = iter->next)
5466 term_printf("%s: %s\n", iter->socket->slot_string,
5467 iter->socket->attached ? iter->socket->card_string :
5471 /***********************************************************/
5474 static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
5478 static void dumb_resize(DisplayState *ds, int w, int h)
5482 static void dumb_refresh(DisplayState *ds)
5484 #if defined(CONFIG_SDL)
5489 static void dumb_display_init(DisplayState *ds)
5494 ds->dpy_update = dumb_update;
5495 ds->dpy_resize = dumb_resize;
5496 ds->dpy_refresh = dumb_refresh;
5499 /***********************************************************/
5502 #define MAX_IO_HANDLERS 64
5504 typedef struct IOHandlerRecord {
5506 IOCanRWHandler *fd_read_poll;
5508 IOHandler *fd_write;
5511 /* temporary data */
5513 struct IOHandlerRecord *next;
5516 static IOHandlerRecord *first_io_handler;
5518 /* XXX: fd_read_poll should be suppressed, but an API change is
5519 necessary in the character devices to suppress fd_can_read(). */
5520 int qemu_set_fd_handler2(int fd,
5521 IOCanRWHandler *fd_read_poll,
5523 IOHandler *fd_write,
5526 IOHandlerRecord **pioh, *ioh;
5528 if (!fd_read && !fd_write) {
5529 pioh = &first_io_handler;
5534 if (ioh->fd == fd) {
5541 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
5545 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
5548 ioh->next = first_io_handler;
5549 first_io_handler = ioh;
5552 ioh->fd_read_poll = fd_read_poll;
5553 ioh->fd_read = fd_read;
5554 ioh->fd_write = fd_write;
5555 ioh->opaque = opaque;
5561 int qemu_set_fd_handler(int fd,
5563 IOHandler *fd_write,
5566 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
5569 /***********************************************************/
5570 /* Polling handling */
5572 typedef struct PollingEntry {
5575 struct PollingEntry *next;
5578 static PollingEntry *first_polling_entry;
5580 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
5582 PollingEntry **ppe, *pe;
5583 pe = qemu_mallocz(sizeof(PollingEntry));
5587 pe->opaque = opaque;
5588 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
5593 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
5595 PollingEntry **ppe, *pe;
5596 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
5598 if (pe->func == func && pe->opaque == opaque) {
5607 /***********************************************************/
5608 /* Wait objects support */
5609 typedef struct WaitObjects {
5611 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
5612 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
5613 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
5616 static WaitObjects wait_objects = {0};
5618 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5620 WaitObjects *w = &wait_objects;
5622 if (w->num >= MAXIMUM_WAIT_OBJECTS)
5624 w->events[w->num] = handle;
5625 w->func[w->num] = func;
5626 w->opaque[w->num] = opaque;
5631 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
5634 WaitObjects *w = &wait_objects;
5637 for (i = 0; i < w->num; i++) {
5638 if (w->events[i] == handle)
5641 w->events[i] = w->events[i + 1];
5642 w->func[i] = w->func[i + 1];
5643 w->opaque[i] = w->opaque[i + 1];
5651 /***********************************************************/
5652 /* savevm/loadvm support */
5654 #define IO_BUF_SIZE 32768
5658 BlockDriverState *bs;
5661 int64_t base_offset;
5662 int64_t buf_offset; /* start of buffer when writing, end of buffer
5665 int buf_size; /* 0 when writing */
5666 uint8_t buf[IO_BUF_SIZE];
5669 QEMUFile *qemu_fopen(const char *filename, const char *mode)
5673 f = qemu_mallocz(sizeof(QEMUFile));
5676 if (!strcmp(mode, "wb")) {
5678 } else if (!strcmp(mode, "rb")) {
5683 f->outfile = fopen(filename, mode);
5695 static QEMUFile *qemu_fopen_bdrv(BlockDriverState *bs, int64_t offset, int is_writable)
5699 f = qemu_mallocz(sizeof(QEMUFile));
5704 f->is_writable = is_writable;
5705 f->base_offset = offset;
5709 void qemu_fflush(QEMUFile *f)
5711 if (!f->is_writable)
5713 if (f->buf_index > 0) {
5715 fseek(f->outfile, f->buf_offset, SEEK_SET);
5716 fwrite(f->buf, 1, f->buf_index, f->outfile);
5718 bdrv_pwrite(f->bs, f->base_offset + f->buf_offset,
5719 f->buf, f->buf_index);
5721 f->buf_offset += f->buf_index;
5726 static void qemu_fill_buffer(QEMUFile *f)
5733 fseek(f->outfile, f->buf_offset, SEEK_SET);
5734 len = fread(f->buf, 1, IO_BUF_SIZE, f->outfile);
5738 len = bdrv_pread(f->bs, f->base_offset + f->buf_offset,
5739 f->buf, IO_BUF_SIZE);
5745 f->buf_offset += len;
5748 void qemu_fclose(QEMUFile *f)
5758 void qemu_put_buffer(QEMUFile *f, const uint8_t *buf, int size)
5762 l = IO_BUF_SIZE - f->buf_index;
5765 memcpy(f->buf + f->buf_index, buf, l);
5769 if (f->buf_index >= IO_BUF_SIZE)
5774 void qemu_put_byte(QEMUFile *f, int v)
5776 f->buf[f->buf_index++] = v;
5777 if (f->buf_index >= IO_BUF_SIZE)
5781 int qemu_get_buffer(QEMUFile *f, uint8_t *buf, int size1)
5787 l = f->buf_size - f->buf_index;
5789 qemu_fill_buffer(f);
5790 l = f->buf_size - f->buf_index;
5796 memcpy(buf, f->buf + f->buf_index, l);
5801 return size1 - size;
5804 int qemu_get_byte(QEMUFile *f)
5806 if (f->buf_index >= f->buf_size) {
5807 qemu_fill_buffer(f);
5808 if (f->buf_index >= f->buf_size)
5811 return f->buf[f->buf_index++];
5814 int64_t qemu_ftell(QEMUFile *f)
5816 return f->buf_offset - f->buf_size + f->buf_index;
5819 int64_t qemu_fseek(QEMUFile *f, int64_t pos, int whence)
5821 if (whence == SEEK_SET) {
5823 } else if (whence == SEEK_CUR) {
5824 pos += qemu_ftell(f);
5826 /* SEEK_END not supported */
5829 if (f->is_writable) {
5831 f->buf_offset = pos;
5833 f->buf_offset = pos;
5840 void qemu_put_be16(QEMUFile *f, unsigned int v)
5842 qemu_put_byte(f, v >> 8);
5843 qemu_put_byte(f, v);
5846 void qemu_put_be32(QEMUFile *f, unsigned int v)
5848 qemu_put_byte(f, v >> 24);
5849 qemu_put_byte(f, v >> 16);
5850 qemu_put_byte(f, v >> 8);
5851 qemu_put_byte(f, v);
5854 void qemu_put_be64(QEMUFile *f, uint64_t v)
5856 qemu_put_be32(f, v >> 32);
5857 qemu_put_be32(f, v);
5860 unsigned int qemu_get_be16(QEMUFile *f)
5863 v = qemu_get_byte(f) << 8;
5864 v |= qemu_get_byte(f);
5868 unsigned int qemu_get_be32(QEMUFile *f)
5871 v = qemu_get_byte(f) << 24;
5872 v |= qemu_get_byte(f) << 16;
5873 v |= qemu_get_byte(f) << 8;
5874 v |= qemu_get_byte(f);
5878 uint64_t qemu_get_be64(QEMUFile *f)
5881 v = (uint64_t)qemu_get_be32(f) << 32;
5882 v |= qemu_get_be32(f);
5886 typedef struct SaveStateEntry {
5890 SaveStateHandler *save_state;
5891 LoadStateHandler *load_state;
5893 struct SaveStateEntry *next;
5896 static SaveStateEntry *first_se;
5898 int register_savevm(const char *idstr,
5901 SaveStateHandler *save_state,
5902 LoadStateHandler *load_state,
5905 SaveStateEntry *se, **pse;
5907 se = qemu_malloc(sizeof(SaveStateEntry));
5910 pstrcpy(se->idstr, sizeof(se->idstr), idstr);
5911 se->instance_id = instance_id;
5912 se->version_id = version_id;
5913 se->save_state = save_state;
5914 se->load_state = load_state;
5915 se->opaque = opaque;
5918 /* add at the end of list */
5920 while (*pse != NULL)
5921 pse = &(*pse)->next;
5926 #define QEMU_VM_FILE_MAGIC 0x5145564d
5927 #define QEMU_VM_FILE_VERSION 0x00000002
5929 static int qemu_savevm_state(QEMUFile *f)
5933 int64_t cur_pos, len_pos, total_len_pos;
5935 qemu_put_be32(f, QEMU_VM_FILE_MAGIC);
5936 qemu_put_be32(f, QEMU_VM_FILE_VERSION);
5937 total_len_pos = qemu_ftell(f);
5938 qemu_put_be64(f, 0); /* total size */
5940 for(se = first_se; se != NULL; se = se->next) {
5942 len = strlen(se->idstr);
5943 qemu_put_byte(f, len);
5944 qemu_put_buffer(f, (uint8_t *)se->idstr, len);
5946 qemu_put_be32(f, se->instance_id);
5947 qemu_put_be32(f, se->version_id);
5949 /* record size: filled later */
5950 len_pos = qemu_ftell(f);
5951 qemu_put_be32(f, 0);
5952 se->save_state(f, se->opaque);
5954 /* fill record size */
5955 cur_pos = qemu_ftell(f);
5956 len = cur_pos - len_pos - 4;
5957 qemu_fseek(f, len_pos, SEEK_SET);
5958 qemu_put_be32(f, len);
5959 qemu_fseek(f, cur_pos, SEEK_SET);
5961 cur_pos = qemu_ftell(f);
5962 qemu_fseek(f, total_len_pos, SEEK_SET);
5963 qemu_put_be64(f, cur_pos - total_len_pos - 8);
5964 qemu_fseek(f, cur_pos, SEEK_SET);
5970 static SaveStateEntry *find_se(const char *idstr, int instance_id)
5974 for(se = first_se; se != NULL; se = se->next) {
5975 if (!strcmp(se->idstr, idstr) &&
5976 instance_id == se->instance_id)
5982 static int qemu_loadvm_state(QEMUFile *f)
5985 int len, ret, instance_id, record_len, version_id;
5986 int64_t total_len, end_pos, cur_pos;
5990 v = qemu_get_be32(f);
5991 if (v != QEMU_VM_FILE_MAGIC)
5993 v = qemu_get_be32(f);
5994 if (v != QEMU_VM_FILE_VERSION) {
5999 total_len = qemu_get_be64(f);
6000 end_pos = total_len + qemu_ftell(f);
6002 if (qemu_ftell(f) >= end_pos)
6004 len = qemu_get_byte(f);
6005 qemu_get_buffer(f, (uint8_t *)idstr, len);
6007 instance_id = qemu_get_be32(f);
6008 version_id = qemu_get_be32(f);
6009 record_len = qemu_get_be32(f);
6011 printf("idstr=%s instance=0x%x version=%d len=%d\n",
6012 idstr, instance_id, version_id, record_len);
6014 cur_pos = qemu_ftell(f);
6015 se = find_se(idstr, instance_id);
6017 fprintf(stderr, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6018 instance_id, idstr);
6020 ret = se->load_state(f, se->opaque, version_id);
6022 fprintf(stderr, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6023 instance_id, idstr);
6026 /* always seek to exact end of record */
6027 qemu_fseek(f, cur_pos + record_len, SEEK_SET);
6034 /* device can contain snapshots */
6035 static int bdrv_can_snapshot(BlockDriverState *bs)
6038 !bdrv_is_removable(bs) &&
6039 !bdrv_is_read_only(bs));
6042 /* device must be snapshots in order to have a reliable snapshot */
6043 static int bdrv_has_snapshot(BlockDriverState *bs)
6046 !bdrv_is_removable(bs) &&
6047 !bdrv_is_read_only(bs));
6050 static BlockDriverState *get_bs_snapshots(void)
6052 BlockDriverState *bs;
6056 return bs_snapshots;
6057 for(i = 0; i <= nb_drives; i++) {
6058 bs = drives_table[i].bdrv;
6059 if (bdrv_can_snapshot(bs))
6068 static int bdrv_snapshot_find(BlockDriverState *bs, QEMUSnapshotInfo *sn_info,
6071 QEMUSnapshotInfo *sn_tab, *sn;
6075 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6078 for(i = 0; i < nb_sns; i++) {
6080 if (!strcmp(sn->id_str, name) || !strcmp(sn->name, name)) {
6090 void do_savevm(const char *name)
6092 BlockDriverState *bs, *bs1;
6093 QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
6094 int must_delete, ret, i;
6095 BlockDriverInfo bdi1, *bdi = &bdi1;
6097 int saved_vm_running;
6104 bs = get_bs_snapshots();
6106 term_printf("No block device can accept snapshots\n");
6110 /* ??? Should this occur after vm_stop? */
6113 saved_vm_running = vm_running;
6118 ret = bdrv_snapshot_find(bs, old_sn, name);
6123 memset(sn, 0, sizeof(*sn));
6125 pstrcpy(sn->name, sizeof(sn->name), old_sn->name);
6126 pstrcpy(sn->id_str, sizeof(sn->id_str), old_sn->id_str);
6129 pstrcpy(sn->name, sizeof(sn->name), name);
6132 /* fill auxiliary fields */
6135 sn->date_sec = tb.time;
6136 sn->date_nsec = tb.millitm * 1000000;
6138 gettimeofday(&tv, NULL);
6139 sn->date_sec = tv.tv_sec;
6140 sn->date_nsec = tv.tv_usec * 1000;
6142 sn->vm_clock_nsec = qemu_get_clock(vm_clock);
6144 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6145 term_printf("Device %s does not support VM state snapshots\n",
6146 bdrv_get_device_name(bs));
6150 /* save the VM state */
6151 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 1);
6153 term_printf("Could not open VM state file\n");
6156 ret = qemu_savevm_state(f);
6157 sn->vm_state_size = qemu_ftell(f);
6160 term_printf("Error %d while writing VM\n", ret);
6164 /* create the snapshots */
6166 for(i = 0; i < nb_drives; i++) {
6167 bs1 = drives_table[i].bdrv;
6168 if (bdrv_has_snapshot(bs1)) {
6170 ret = bdrv_snapshot_delete(bs1, old_sn->id_str);
6172 term_printf("Error while deleting snapshot on '%s'\n",
6173 bdrv_get_device_name(bs1));
6176 ret = bdrv_snapshot_create(bs1, sn);
6178 term_printf("Error while creating snapshot on '%s'\n",
6179 bdrv_get_device_name(bs1));
6185 if (saved_vm_running)
6189 void do_loadvm(const char *name)
6191 BlockDriverState *bs, *bs1;
6192 BlockDriverInfo bdi1, *bdi = &bdi1;
6195 int saved_vm_running;
6197 bs = get_bs_snapshots();
6199 term_printf("No block device supports snapshots\n");
6203 /* Flush all IO requests so they don't interfere with the new state. */
6206 saved_vm_running = vm_running;
6209 for(i = 0; i <= nb_drives; i++) {
6210 bs1 = drives_table[i].bdrv;
6211 if (bdrv_has_snapshot(bs1)) {
6212 ret = bdrv_snapshot_goto(bs1, name);
6215 term_printf("Warning: ");
6218 term_printf("Snapshots not supported on device '%s'\n",
6219 bdrv_get_device_name(bs1));
6222 term_printf("Could not find snapshot '%s' on device '%s'\n",
6223 name, bdrv_get_device_name(bs1));
6226 term_printf("Error %d while activating snapshot on '%s'\n",
6227 ret, bdrv_get_device_name(bs1));
6230 /* fatal on snapshot block device */
6237 if (bdrv_get_info(bs, bdi) < 0 || bdi->vm_state_offset <= 0) {
6238 term_printf("Device %s does not support VM state snapshots\n",
6239 bdrv_get_device_name(bs));
6243 /* restore the VM state */
6244 f = qemu_fopen_bdrv(bs, bdi->vm_state_offset, 0);
6246 term_printf("Could not open VM state file\n");
6249 ret = qemu_loadvm_state(f);
6252 term_printf("Error %d while loading VM state\n", ret);
6255 if (saved_vm_running)
6259 void do_delvm(const char *name)
6261 BlockDriverState *bs, *bs1;
6264 bs = get_bs_snapshots();
6266 term_printf("No block device supports snapshots\n");
6270 for(i = 0; i <= nb_drives; i++) {
6271 bs1 = drives_table[i].bdrv;
6272 if (bdrv_has_snapshot(bs1)) {
6273 ret = bdrv_snapshot_delete(bs1, name);
6275 if (ret == -ENOTSUP)
6276 term_printf("Snapshots not supported on device '%s'\n",
6277 bdrv_get_device_name(bs1));
6279 term_printf("Error %d while deleting snapshot on '%s'\n",
6280 ret, bdrv_get_device_name(bs1));
6286 void do_info_snapshots(void)
6288 BlockDriverState *bs, *bs1;
6289 QEMUSnapshotInfo *sn_tab, *sn;
6293 bs = get_bs_snapshots();
6295 term_printf("No available block device supports snapshots\n");
6298 term_printf("Snapshot devices:");
6299 for(i = 0; i <= nb_drives; i++) {
6300 bs1 = drives_table[i].bdrv;
6301 if (bdrv_has_snapshot(bs1)) {
6303 term_printf(" %s", bdrv_get_device_name(bs1));
6308 nb_sns = bdrv_snapshot_list(bs, &sn_tab);
6310 term_printf("bdrv_snapshot_list: error %d\n", nb_sns);
6313 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs));
6314 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), NULL));
6315 for(i = 0; i < nb_sns; i++) {
6317 term_printf("%s\n", bdrv_snapshot_dump(buf, sizeof(buf), sn));
6322 /***********************************************************/
6323 /* ram save/restore */
6325 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
6329 v = qemu_get_byte(f);
6332 if (qemu_get_buffer(f, buf, len) != len)
6336 v = qemu_get_byte(f);
6337 memset(buf, v, len);
6345 static int ram_load_v1(QEMUFile *f, void *opaque)
6350 if (qemu_get_be32(f) != phys_ram_size)
6352 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
6353 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
6360 #define BDRV_HASH_BLOCK_SIZE 1024
6361 #define IOBUF_SIZE 4096
6362 #define RAM_CBLOCK_MAGIC 0xfabe
6364 typedef struct RamCompressState {
6367 uint8_t buf[IOBUF_SIZE];
6370 static int ram_compress_open(RamCompressState *s, QEMUFile *f)
6373 memset(s, 0, sizeof(*s));
6375 ret = deflateInit2(&s->zstream, 1,
6377 9, Z_DEFAULT_STRATEGY);
6380 s->zstream.avail_out = IOBUF_SIZE;
6381 s->zstream.next_out = s->buf;
6385 static void ram_put_cblock(RamCompressState *s, const uint8_t *buf, int len)
6387 qemu_put_be16(s->f, RAM_CBLOCK_MAGIC);
6388 qemu_put_be16(s->f, len);
6389 qemu_put_buffer(s->f, buf, len);
6392 static int ram_compress_buf(RamCompressState *s, const uint8_t *buf, int len)
6396 s->zstream.avail_in = len;
6397 s->zstream.next_in = (uint8_t *)buf;
6398 while (s->zstream.avail_in > 0) {
6399 ret = deflate(&s->zstream, Z_NO_FLUSH);
6402 if (s->zstream.avail_out == 0) {
6403 ram_put_cblock(s, s->buf, IOBUF_SIZE);
6404 s->zstream.avail_out = IOBUF_SIZE;
6405 s->zstream.next_out = s->buf;
6411 static void ram_compress_close(RamCompressState *s)
6415 /* compress last bytes */
6417 ret = deflate(&s->zstream, Z_FINISH);
6418 if (ret == Z_OK || ret == Z_STREAM_END) {
6419 len = IOBUF_SIZE - s->zstream.avail_out;
6421 ram_put_cblock(s, s->buf, len);
6423 s->zstream.avail_out = IOBUF_SIZE;
6424 s->zstream.next_out = s->buf;
6425 if (ret == Z_STREAM_END)
6432 deflateEnd(&s->zstream);
6435 typedef struct RamDecompressState {
6438 uint8_t buf[IOBUF_SIZE];
6439 } RamDecompressState;
6441 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
6444 memset(s, 0, sizeof(*s));
6446 ret = inflateInit(&s->zstream);
6452 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
6456 s->zstream.avail_out = len;
6457 s->zstream.next_out = buf;
6458 while (s->zstream.avail_out > 0) {
6459 if (s->zstream.avail_in == 0) {
6460 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
6462 clen = qemu_get_be16(s->f);
6463 if (clen > IOBUF_SIZE)
6465 qemu_get_buffer(s->f, s->buf, clen);
6466 s->zstream.avail_in = clen;
6467 s->zstream.next_in = s->buf;
6469 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
6470 if (ret != Z_OK && ret != Z_STREAM_END) {
6477 static void ram_decompress_close(RamDecompressState *s)
6479 inflateEnd(&s->zstream);
6482 static void ram_save(QEMUFile *f, void *opaque)
6485 RamCompressState s1, *s = &s1;
6488 qemu_put_be32(f, phys_ram_size);
6489 if (ram_compress_open(s, f) < 0)
6491 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6493 if (tight_savevm_enabled) {
6497 /* find if the memory block is available on a virtual
6500 for(j = 0; j < nb_drives; j++) {
6501 sector_num = bdrv_hash_find(drives_table[j].bdrv,
6503 BDRV_HASH_BLOCK_SIZE);
6504 if (sector_num >= 0)
6508 goto normal_compress;
6511 cpu_to_be64wu((uint64_t *)(buf + 2), sector_num);
6512 ram_compress_buf(s, buf, 10);
6518 ram_compress_buf(s, buf, 1);
6519 ram_compress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE);
6522 ram_compress_close(s);
6525 static int ram_load(QEMUFile *f, void *opaque, int version_id)
6527 RamDecompressState s1, *s = &s1;
6531 if (version_id == 1)
6532 return ram_load_v1(f, opaque);
6533 if (version_id != 2)
6535 if (qemu_get_be32(f) != phys_ram_size)
6537 if (ram_decompress_open(s, f) < 0)
6539 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
6540 if (ram_decompress_buf(s, buf, 1) < 0) {
6541 fprintf(stderr, "Error while reading ram block header\n");
6545 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
6546 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
6555 ram_decompress_buf(s, buf + 1, 9);
6557 sector_num = be64_to_cpupu((const uint64_t *)(buf + 2));
6558 if (bs_index >= nb_drives) {
6559 fprintf(stderr, "Invalid block device index %d\n", bs_index);
6562 if (bdrv_read(drives_table[bs_index].bdrv, sector_num,
6564 BDRV_HASH_BLOCK_SIZE / 512) < 0) {
6565 fprintf(stderr, "Error while reading sector %d:%" PRId64 "\n",
6566 bs_index, sector_num);
6573 printf("Error block header\n");
6577 ram_decompress_close(s);
6581 /***********************************************************/
6582 /* bottom halves (can be seen as timers which expire ASAP) */
6591 static QEMUBH *first_bh = NULL;
6593 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
6596 bh = qemu_mallocz(sizeof(QEMUBH));
6600 bh->opaque = opaque;
6604 int qemu_bh_poll(void)
6623 void qemu_bh_schedule(QEMUBH *bh)
6625 CPUState *env = cpu_single_env;
6629 bh->next = first_bh;
6632 /* stop the currently executing CPU to execute the BH ASAP */
6634 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
6638 void qemu_bh_cancel(QEMUBH *bh)
6641 if (bh->scheduled) {
6644 pbh = &(*pbh)->next;
6650 void qemu_bh_delete(QEMUBH *bh)
6656 /***********************************************************/
6657 /* machine registration */
6659 QEMUMachine *first_machine = NULL;
6661 int qemu_register_machine(QEMUMachine *m)
6664 pm = &first_machine;
6672 static QEMUMachine *find_machine(const char *name)
6676 for(m = first_machine; m != NULL; m = m->next) {
6677 if (!strcmp(m->name, name))
6683 /***********************************************************/
6684 /* main execution loop */
6686 static void gui_update(void *opaque)
6688 DisplayState *ds = opaque;
6689 ds->dpy_refresh(ds);
6690 qemu_mod_timer(ds->gui_timer,
6691 (ds->gui_timer_interval ?
6692 ds->gui_timer_interval :
6693 GUI_REFRESH_INTERVAL)
6694 + qemu_get_clock(rt_clock));
6697 struct vm_change_state_entry {
6698 VMChangeStateHandler *cb;
6700 LIST_ENTRY (vm_change_state_entry) entries;
6703 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
6705 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
6708 VMChangeStateEntry *e;
6710 e = qemu_mallocz(sizeof (*e));
6716 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
6720 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
6722 LIST_REMOVE (e, entries);
6726 static void vm_state_notify(int running)
6728 VMChangeStateEntry *e;
6730 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
6731 e->cb(e->opaque, running);
6735 /* XXX: support several handlers */
6736 static VMStopHandler *vm_stop_cb;
6737 static void *vm_stop_opaque;
6739 int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
6742 vm_stop_opaque = opaque;
6746 void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
6757 qemu_rearm_alarm_timer(alarm_timer);
6761 void vm_stop(int reason)
6764 cpu_disable_ticks();
6768 vm_stop_cb(vm_stop_opaque, reason);
6775 /* reset/shutdown handler */
6777 typedef struct QEMUResetEntry {
6778 QEMUResetHandler *func;
6780 struct QEMUResetEntry *next;
6783 static QEMUResetEntry *first_reset_entry;
6784 static int reset_requested;
6785 static int shutdown_requested;
6786 static int powerdown_requested;
6788 int qemu_shutdown_requested(void)
6790 int r = shutdown_requested;
6791 shutdown_requested = 0;
6795 int qemu_reset_requested(void)
6797 int r = reset_requested;
6798 reset_requested = 0;
6802 int qemu_powerdown_requested(void)
6804 int r = powerdown_requested;
6805 powerdown_requested = 0;
6809 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
6811 QEMUResetEntry **pre, *re;
6813 pre = &first_reset_entry;
6814 while (*pre != NULL)
6815 pre = &(*pre)->next;
6816 re = qemu_mallocz(sizeof(QEMUResetEntry));
6818 re->opaque = opaque;
6823 void qemu_system_reset(void)
6827 /* reset all devices */
6828 for(re = first_reset_entry; re != NULL; re = re->next) {
6829 re->func(re->opaque);
6833 void qemu_system_reset_request(void)
6836 shutdown_requested = 1;
6838 reset_requested = 1;
6841 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
6844 void qemu_system_shutdown_request(void)
6846 shutdown_requested = 1;
6848 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
6851 void qemu_system_powerdown_request(void)
6853 powerdown_requested = 1;
6855 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
6858 /* boot_set handler */
6859 QEMUBootSetHandler *qemu_boot_set_handler = NULL;
6861 void qemu_register_boot_set(QEMUBootSetHandler *func)
6863 qemu_boot_set_handler = func;
6866 void main_loop_wait(int timeout)
6868 IOHandlerRecord *ioh;
6869 fd_set rfds, wfds, xfds;
6878 /* XXX: need to suppress polling by better using win32 events */
6880 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
6881 ret |= pe->func(pe->opaque);
6886 WaitObjects *w = &wait_objects;
6888 ret = WaitForMultipleObjects(w->num, w->events, FALSE, timeout);
6889 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
6890 if (w->func[ret - WAIT_OBJECT_0])
6891 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
6893 /* Check for additional signaled events */
6894 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
6896 /* Check if event is signaled */
6897 ret2 = WaitForSingleObject(w->events[i], 0);
6898 if(ret2 == WAIT_OBJECT_0) {
6900 w->func[i](w->opaque[i]);
6901 } else if (ret2 == WAIT_TIMEOUT) {
6903 err = GetLastError();
6904 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
6907 } else if (ret == WAIT_TIMEOUT) {
6909 err = GetLastError();
6910 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
6914 /* poll any events */
6915 /* XXX: separate device handlers from system ones */
6920 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6924 (!ioh->fd_read_poll ||
6925 ioh->fd_read_poll(ioh->opaque) != 0)) {
6926 FD_SET(ioh->fd, &rfds);
6930 if (ioh->fd_write) {
6931 FD_SET(ioh->fd, &wfds);
6941 tv.tv_usec = timeout * 1000;
6943 #if defined(CONFIG_SLIRP)
6945 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
6948 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
6950 IOHandlerRecord **pioh;
6952 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6953 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
6954 ioh->fd_read(ioh->opaque);
6956 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
6957 ioh->fd_write(ioh->opaque);
6961 /* remove deleted IO handlers */
6962 pioh = &first_io_handler;
6972 #if defined(CONFIG_SLIRP)
6979 slirp_select_poll(&rfds, &wfds, &xfds);
6985 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
6986 qemu_get_clock(vm_clock));
6987 /* run dma transfers, if any */
6991 /* real time timers */
6992 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
6993 qemu_get_clock(rt_clock));
6995 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
6996 alarm_timer->flags &= ~(ALARM_FLAG_EXPIRED);
6997 qemu_rearm_alarm_timer(alarm_timer);
7000 /* Check bottom-halves last in case any of the earlier events triggered
7006 static int main_loop(void)
7009 #ifdef CONFIG_PROFILER
7014 cur_cpu = first_cpu;
7015 next_cpu = cur_cpu->next_cpu ?: first_cpu;
7022 #ifdef CONFIG_PROFILER
7023 ti = profile_getclock();
7025 ret = cpu_exec(env);
7026 #ifdef CONFIG_PROFILER
7027 qemu_time += profile_getclock() - ti;
7029 next_cpu = env->next_cpu ?: first_cpu;
7030 if (event_pending && likely(ret != EXCP_DEBUG)) {
7031 ret = EXCP_INTERRUPT;
7035 if (ret == EXCP_HLT) {
7036 /* Give the next CPU a chance to run. */
7040 if (ret != EXCP_HALTED)
7042 /* all CPUs are halted ? */
7048 if (shutdown_requested) {
7049 ret = EXCP_INTERRUPT;
7057 if (reset_requested) {
7058 reset_requested = 0;
7059 qemu_system_reset();
7060 ret = EXCP_INTERRUPT;
7062 if (powerdown_requested) {
7063 powerdown_requested = 0;
7064 qemu_system_powerdown();
7065 ret = EXCP_INTERRUPT;
7067 if (unlikely(ret == EXCP_DEBUG)) {
7068 vm_stop(EXCP_DEBUG);
7070 /* If all cpus are halted then wait until the next IRQ */
7071 /* XXX: use timeout computed from timers */
7072 if (ret == EXCP_HALTED)
7079 #ifdef CONFIG_PROFILER
7080 ti = profile_getclock();
7082 main_loop_wait(timeout);
7083 #ifdef CONFIG_PROFILER
7084 dev_time += profile_getclock() - ti;
7087 cpu_disable_ticks();
7091 static void help(int exitcode)
7093 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
7094 "usage: %s [options] [disk_image]\n"
7096 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7098 "Standard options:\n"
7099 "-M machine select emulated machine (-M ? for list)\n"
7100 "-cpu cpu select CPU (-cpu ? for list)\n"
7101 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7102 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7103 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7104 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7105 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7106 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7107 " [,cache=on|off][,format=f]\n"
7108 " use 'file' as a drive image\n"
7109 "-mtdblock file use 'file' as on-board Flash memory image\n"
7110 "-sd file use 'file' as SecureDigital card image\n"
7111 "-pflash file use 'file' as a parallel flash image\n"
7112 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7113 "-snapshot write to temporary files instead of disk image files\n"
7115 "-no-frame open SDL window without a frame and window decorations\n"
7116 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7117 "-no-quit disable SDL window close capability\n"
7120 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7122 "-m megs set virtual RAM size to megs MB [default=%d]\n"
7123 "-smp n set the number of CPUs to 'n' [default=1]\n"
7124 "-nographic disable graphical output and redirect serial I/Os to console\n"
7125 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7127 "-k language use keyboard layout (for example \"fr\" for French)\n"
7130 "-audio-help print list of audio drivers and their options\n"
7131 "-soundhw c1,... enable audio support\n"
7132 " and only specified sound cards (comma separated list)\n"
7133 " use -soundhw ? to get the list of supported cards\n"
7134 " use -soundhw all to enable all of them\n"
7136 "-localtime set the real time clock to local time [default=utc]\n"
7137 "-full-screen start in full screen\n"
7139 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7141 "-usb enable the USB driver (will be the default soon)\n"
7142 "-usbdevice name add the host or guest USB device 'name'\n"
7143 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7144 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7146 "-name string set the name of the guest\n"
7148 "Network options:\n"
7149 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7150 " create a new Network Interface Card and connect it to VLAN 'n'\n"
7152 "-net user[,vlan=n][,hostname=host]\n"
7153 " connect the user mode network stack to VLAN 'n' and send\n"
7154 " hostname 'host' to DHCP clients\n"
7157 "-net tap[,vlan=n],ifname=name\n"
7158 " connect the host TAP network interface to VLAN 'n'\n"
7160 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7161 " connect the host TAP network interface to VLAN 'n' and use the\n"
7162 " network scripts 'file' (default=%s)\n"
7163 " and 'dfile' (default=%s);\n"
7164 " use '[down]script=no' to disable script execution;\n"
7165 " use 'fd=h' to connect to an already opened TAP interface\n"
7167 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7168 " connect the vlan 'n' to another VLAN using a socket connection\n"
7169 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7170 " connect the vlan 'n' to multicast maddr and port\n"
7171 "-net none use it alone to have zero network devices; if no -net option\n"
7172 " is provided, the default is '-net nic -net user'\n"
7175 "-tftp dir allow tftp access to files in dir [-net user]\n"
7176 "-bootp file advertise file in BOOTP replies\n"
7178 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
7180 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7181 " redirect TCP or UDP connections from host to guest [-net user]\n"
7184 "Linux boot specific:\n"
7185 "-kernel bzImage use 'bzImage' as kernel image\n"
7186 "-append cmdline use 'cmdline' as kernel command line\n"
7187 "-initrd file use 'file' as initial ram disk\n"
7189 "Debug/Expert options:\n"
7190 "-monitor dev redirect the monitor to char device 'dev'\n"
7191 "-serial dev redirect the serial port to char device 'dev'\n"
7192 "-parallel dev redirect the parallel port to char device 'dev'\n"
7193 "-pidfile file Write PID to 'file'\n"
7194 "-S freeze CPU at startup (use 'c' to start execution)\n"
7195 "-s wait gdb connection to port\n"
7196 "-p port set gdb connection port [default=%s]\n"
7197 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
7198 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7199 " translation (t=none or lba) (usually qemu can guess them)\n"
7200 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7202 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7203 "-no-kqemu disable KQEMU kernel module usage\n"
7206 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7207 " (default is CL-GD5446 PCI VGA)\n"
7208 "-no-acpi disable ACPI\n"
7210 #ifdef CONFIG_CURSES
7211 "-curses use a curses/ncurses interface instead of SDL\n"
7213 "-no-reboot exit instead of rebooting\n"
7214 "-no-shutdown stop before shutdown\n"
7215 "-loadvm file start right away with a saved state (loadvm in monitor)\n"
7216 "-vnc display start a VNC server on display\n"
7218 "-daemonize daemonize QEMU after initializing\n"
7220 "-option-rom rom load a file, rom, into the option ROM space\n"
7222 "-prom-env variable=value set OpenBIOS nvram variables\n"
7224 "-clock force the use of the given methods for timer alarm.\n"
7225 " To see what timers are available use -clock ?\n"
7226 "-startdate select initial date of the clock\n"
7228 "During emulation, the following keys are useful:\n"
7229 "ctrl-alt-f toggle full screen\n"
7230 "ctrl-alt-n switch to virtual console 'n'\n"
7231 "ctrl-alt toggle mouse and keyboard grab\n"
7233 "When using -nographic, press 'ctrl-a h' to get some help.\n"
7238 DEFAULT_NETWORK_SCRIPT,
7239 DEFAULT_NETWORK_DOWN_SCRIPT,
7241 DEFAULT_GDBSTUB_PORT,
7246 #define HAS_ARG 0x0001
7261 QEMU_OPTION_mtdblock,
7265 QEMU_OPTION_snapshot,
7267 QEMU_OPTION_no_fd_bootchk,
7270 QEMU_OPTION_nographic,
7271 QEMU_OPTION_portrait,
7273 QEMU_OPTION_audio_help,
7274 QEMU_OPTION_soundhw,
7294 QEMU_OPTION_no_code_copy,
7296 QEMU_OPTION_localtime,
7297 QEMU_OPTION_cirrusvga,
7300 QEMU_OPTION_std_vga,
7302 QEMU_OPTION_monitor,
7304 QEMU_OPTION_parallel,
7306 QEMU_OPTION_full_screen,
7307 QEMU_OPTION_no_frame,
7308 QEMU_OPTION_alt_grab,
7309 QEMU_OPTION_no_quit,
7310 QEMU_OPTION_pidfile,
7311 QEMU_OPTION_no_kqemu,
7312 QEMU_OPTION_kernel_kqemu,
7313 QEMU_OPTION_win2k_hack,
7315 QEMU_OPTION_usbdevice,
7318 QEMU_OPTION_no_acpi,
7320 QEMU_OPTION_no_reboot,
7321 QEMU_OPTION_no_shutdown,
7322 QEMU_OPTION_show_cursor,
7323 QEMU_OPTION_daemonize,
7324 QEMU_OPTION_option_rom,
7325 QEMU_OPTION_semihosting,
7327 QEMU_OPTION_prom_env,
7328 QEMU_OPTION_old_param,
7330 QEMU_OPTION_startdate,
7333 typedef struct QEMUOption {
7339 const QEMUOption qemu_options[] = {
7340 { "h", 0, QEMU_OPTION_h },
7341 { "help", 0, QEMU_OPTION_h },
7343 { "M", HAS_ARG, QEMU_OPTION_M },
7344 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
7345 { "fda", HAS_ARG, QEMU_OPTION_fda },
7346 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
7347 { "hda", HAS_ARG, QEMU_OPTION_hda },
7348 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
7349 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
7350 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
7351 { "drive", HAS_ARG, QEMU_OPTION_drive },
7352 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
7353 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
7354 { "sd", HAS_ARG, QEMU_OPTION_sd },
7355 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
7356 { "boot", HAS_ARG, QEMU_OPTION_boot },
7357 { "snapshot", 0, QEMU_OPTION_snapshot },
7359 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
7361 { "m", HAS_ARG, QEMU_OPTION_m },
7362 { "nographic", 0, QEMU_OPTION_nographic },
7363 { "portrait", 0, QEMU_OPTION_portrait },
7364 { "k", HAS_ARG, QEMU_OPTION_k },
7366 { "audio-help", 0, QEMU_OPTION_audio_help },
7367 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
7370 { "net", HAS_ARG, QEMU_OPTION_net},
7372 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
7373 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
7375 { "smb", HAS_ARG, QEMU_OPTION_smb },
7377 { "redir", HAS_ARG, QEMU_OPTION_redir },
7380 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
7381 { "append", HAS_ARG, QEMU_OPTION_append },
7382 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
7384 { "S", 0, QEMU_OPTION_S },
7385 { "s", 0, QEMU_OPTION_s },
7386 { "p", HAS_ARG, QEMU_OPTION_p },
7387 { "d", HAS_ARG, QEMU_OPTION_d },
7388 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
7389 { "L", HAS_ARG, QEMU_OPTION_L },
7390 { "bios", HAS_ARG, QEMU_OPTION_bios },
7391 { "no-code-copy", 0, QEMU_OPTION_no_code_copy },
7393 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
7394 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
7396 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7397 { "g", 1, QEMU_OPTION_g },
7399 { "localtime", 0, QEMU_OPTION_localtime },
7400 { "std-vga", 0, QEMU_OPTION_std_vga },
7401 { "echr", HAS_ARG, QEMU_OPTION_echr },
7402 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
7403 { "serial", HAS_ARG, QEMU_OPTION_serial },
7404 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
7405 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
7406 { "full-screen", 0, QEMU_OPTION_full_screen },
7408 { "no-frame", 0, QEMU_OPTION_no_frame },
7409 { "alt-grab", 0, QEMU_OPTION_alt_grab },
7410 { "no-quit", 0, QEMU_OPTION_no_quit },
7412 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
7413 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
7414 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
7415 { "smp", HAS_ARG, QEMU_OPTION_smp },
7416 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
7417 #ifdef CONFIG_CURSES
7418 { "curses", 0, QEMU_OPTION_curses },
7421 /* temporary options */
7422 { "usb", 0, QEMU_OPTION_usb },
7423 { "cirrusvga", 0, QEMU_OPTION_cirrusvga },
7424 { "vmwarevga", 0, QEMU_OPTION_vmsvga },
7425 { "no-acpi", 0, QEMU_OPTION_no_acpi },
7426 { "no-reboot", 0, QEMU_OPTION_no_reboot },
7427 { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
7428 { "show-cursor", 0, QEMU_OPTION_show_cursor },
7429 { "daemonize", 0, QEMU_OPTION_daemonize },
7430 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
7431 #if defined(TARGET_ARM) || defined(TARGET_M68K)
7432 { "semihosting", 0, QEMU_OPTION_semihosting },
7434 { "name", HAS_ARG, QEMU_OPTION_name },
7435 #if defined(TARGET_SPARC)
7436 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
7438 #if defined(TARGET_ARM)
7439 { "old-param", 0, QEMU_OPTION_old_param },
7441 { "clock", HAS_ARG, QEMU_OPTION_clock },
7442 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
7446 /* password input */
7448 int qemu_key_check(BlockDriverState *bs, const char *name)
7453 if (!bdrv_is_encrypted(bs))
7456 term_printf("%s is encrypted.\n", name);
7457 for(i = 0; i < 3; i++) {
7458 monitor_readline("Password: ", 1, password, sizeof(password));
7459 if (bdrv_set_key(bs, password) == 0)
7461 term_printf("invalid password\n");
7466 static BlockDriverState *get_bdrv(int index)
7468 if (index > nb_drives)
7470 return drives_table[index].bdrv;
7473 static void read_passwords(void)
7475 BlockDriverState *bs;
7478 for(i = 0; i < 6; i++) {
7481 qemu_key_check(bs, bdrv_get_device_name(bs));
7486 struct soundhw soundhw[] = {
7487 #ifdef HAS_AUDIO_CHOICE
7488 #if defined(TARGET_I386) || defined(TARGET_MIPS)
7494 { .init_isa = pcspk_audio_init }
7499 "Creative Sound Blaster 16",
7502 { .init_isa = SB16_init }
7509 "Yamaha YMF262 (OPL3)",
7511 "Yamaha YM3812 (OPL2)",
7515 { .init_isa = Adlib_init }
7522 "Gravis Ultrasound GF1",
7525 { .init_isa = GUS_init }
7532 "Intel 82801AA AC97 Audio",
7535 { .init_pci = ac97_init }
7541 "ENSONIQ AudioPCI ES1370",
7544 { .init_pci = es1370_init }
7548 { NULL, NULL, 0, 0, { NULL } }
7551 static void select_soundhw (const char *optarg)
7555 if (*optarg == '?') {
7558 printf ("Valid sound card names (comma separated):\n");
7559 for (c = soundhw; c->name; ++c) {
7560 printf ("%-11s %s\n", c->name, c->descr);
7562 printf ("\n-soundhw all will enable all of the above\n");
7563 exit (*optarg != '?');
7571 if (!strcmp (optarg, "all")) {
7572 for (c = soundhw; c->name; ++c) {
7580 e = strchr (p, ',');
7581 l = !e ? strlen (p) : (size_t) (e - p);
7583 for (c = soundhw; c->name; ++c) {
7584 if (!strncmp (c->name, p, l)) {
7593 "Unknown sound card name (too big to show)\n");
7596 fprintf (stderr, "Unknown sound card name `%.*s'\n",
7601 p += l + (e != NULL);
7605 goto show_valid_cards;
7611 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
7613 exit(STATUS_CONTROL_C_EXIT);
7618 #define MAX_NET_CLIENTS 32
7620 int main(int argc, char **argv)
7622 #ifdef CONFIG_GDBSTUB
7624 const char *gdbstub_port;
7626 uint32_t boot_devices_bitmap = 0;
7628 int snapshot, linux_boot, net_boot;
7629 const char *initrd_filename;
7630 const char *kernel_filename, *kernel_cmdline;
7631 const char *boot_devices = "";
7632 DisplayState *ds = &display_state;
7633 int cyls, heads, secs, translation;
7634 const char *net_clients[MAX_NET_CLIENTS];
7638 const char *r, *optarg;
7639 CharDriverState *monitor_hd;
7640 const char *monitor_device;
7641 const char *serial_devices[MAX_SERIAL_PORTS];
7642 int serial_device_index;
7643 const char *parallel_devices[MAX_PARALLEL_PORTS];
7644 int parallel_device_index;
7645 const char *loadvm = NULL;
7646 QEMUMachine *machine;
7647 const char *cpu_model;
7648 const char *usb_devices[MAX_USB_CMDLINE];
7649 int usb_devices_index;
7651 const char *pid_file = NULL;
7654 LIST_INIT (&vm_change_state_head);
7657 struct sigaction act;
7658 sigfillset(&act.sa_mask);
7660 act.sa_handler = SIG_IGN;
7661 sigaction(SIGPIPE, &act, NULL);
7664 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
7665 /* Note: cpu_interrupt() is currently not SMP safe, so we force
7666 QEMU to run on a single CPU */
7671 h = GetCurrentProcess();
7672 if (GetProcessAffinityMask(h, &mask, &smask)) {
7673 for(i = 0; i < 32; i++) {
7674 if (mask & (1 << i))
7679 SetProcessAffinityMask(h, mask);
7685 register_machines();
7686 machine = first_machine;
7688 initrd_filename = NULL;
7690 vga_ram_size = VGA_RAM_SIZE;
7691 #ifdef CONFIG_GDBSTUB
7693 gdbstub_port = DEFAULT_GDBSTUB_PORT;
7698 kernel_filename = NULL;
7699 kernel_cmdline = "";
7700 cyls = heads = secs = 0;
7701 translation = BIOS_ATA_TRANSLATION_AUTO;
7702 monitor_device = "vc:800x600";
7704 serial_devices[0] = "vc:80Cx24C";
7705 for(i = 1; i < MAX_SERIAL_PORTS; i++)
7706 serial_devices[i] = NULL;
7707 serial_device_index = 0;
7709 parallel_devices[0] = "vc:640x480";
7710 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
7711 parallel_devices[i] = NULL;
7712 parallel_device_index = 0;
7714 usb_devices_index = 0;
7722 /* default mac address of the first network interface */
7730 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
7732 const QEMUOption *popt;
7735 /* Treat --foo the same as -foo. */
7738 popt = qemu_options;
7741 fprintf(stderr, "%s: invalid option -- '%s'\n",
7745 if (!strcmp(popt->name, r + 1))
7749 if (popt->flags & HAS_ARG) {
7750 if (optind >= argc) {
7751 fprintf(stderr, "%s: option '%s' requires an argument\n",
7755 optarg = argv[optind++];
7760 switch(popt->index) {
7762 machine = find_machine(optarg);
7765 printf("Supported machines are:\n");
7766 for(m = first_machine; m != NULL; m = m->next) {
7767 printf("%-10s %s%s\n",
7769 m == first_machine ? " (default)" : "");
7771 exit(*optarg != '?');
7774 case QEMU_OPTION_cpu:
7775 /* hw initialization will check this */
7776 if (*optarg == '?') {
7777 /* XXX: implement xxx_cpu_list for targets that still miss it */
7778 #if defined(cpu_list)
7779 cpu_list(stdout, &fprintf);
7786 case QEMU_OPTION_initrd:
7787 initrd_filename = optarg;
7789 case QEMU_OPTION_hda:
7791 hda_index = drive_add(optarg, HD_ALIAS, 0);
7793 hda_index = drive_add(optarg, HD_ALIAS
7794 ",cyls=%d,heads=%d,secs=%d%s",
7795 0, cyls, heads, secs,
7796 translation == BIOS_ATA_TRANSLATION_LBA ?
7798 translation == BIOS_ATA_TRANSLATION_NONE ?
7799 ",trans=none" : "");
7801 case QEMU_OPTION_hdb:
7802 case QEMU_OPTION_hdc:
7803 case QEMU_OPTION_hdd:
7804 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
7806 case QEMU_OPTION_drive:
7807 drive_add(NULL, "%s", optarg);
7809 case QEMU_OPTION_mtdblock:
7810 drive_add(optarg, MTD_ALIAS);
7812 case QEMU_OPTION_sd:
7813 drive_add(optarg, SD_ALIAS);
7815 case QEMU_OPTION_pflash:
7816 drive_add(optarg, PFLASH_ALIAS);
7818 case QEMU_OPTION_snapshot:
7821 case QEMU_OPTION_hdachs:
7825 cyls = strtol(p, (char **)&p, 0);
7826 if (cyls < 1 || cyls > 16383)
7831 heads = strtol(p, (char **)&p, 0);
7832 if (heads < 1 || heads > 16)
7837 secs = strtol(p, (char **)&p, 0);
7838 if (secs < 1 || secs > 63)
7842 if (!strcmp(p, "none"))
7843 translation = BIOS_ATA_TRANSLATION_NONE;
7844 else if (!strcmp(p, "lba"))
7845 translation = BIOS_ATA_TRANSLATION_LBA;
7846 else if (!strcmp(p, "auto"))
7847 translation = BIOS_ATA_TRANSLATION_AUTO;
7850 } else if (*p != '\0') {
7852 fprintf(stderr, "qemu: invalid physical CHS format\n");
7855 if (hda_index != -1)
7856 snprintf(drives_opt[hda_index].opt,
7857 sizeof(drives_opt[hda_index].opt),
7858 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
7859 0, cyls, heads, secs,
7860 translation == BIOS_ATA_TRANSLATION_LBA ?
7862 translation == BIOS_ATA_TRANSLATION_NONE ?
7863 ",trans=none" : "");
7866 case QEMU_OPTION_nographic:
7867 serial_devices[0] = "stdio";
7868 parallel_devices[0] = "null";
7869 monitor_device = "stdio";
7872 #ifdef CONFIG_CURSES
7873 case QEMU_OPTION_curses:
7877 case QEMU_OPTION_portrait:
7880 case QEMU_OPTION_kernel:
7881 kernel_filename = optarg;
7883 case QEMU_OPTION_append:
7884 kernel_cmdline = optarg;
7886 case QEMU_OPTION_cdrom:
7887 drive_add(optarg, CDROM_ALIAS);
7889 case QEMU_OPTION_boot:
7890 boot_devices = optarg;
7891 /* We just do some generic consistency checks */
7893 /* Could easily be extended to 64 devices if needed */
7896 boot_devices_bitmap = 0;
7897 for (p = boot_devices; *p != '\0'; p++) {
7898 /* Allowed boot devices are:
7899 * a b : floppy disk drives
7900 * c ... f : IDE disk drives
7901 * g ... m : machine implementation dependant drives
7902 * n ... p : network devices
7903 * It's up to each machine implementation to check
7904 * if the given boot devices match the actual hardware
7905 * implementation and firmware features.
7907 if (*p < 'a' || *p > 'q') {
7908 fprintf(stderr, "Invalid boot device '%c'\n", *p);
7911 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
7913 "Boot device '%c' was given twice\n",*p);
7916 boot_devices_bitmap |= 1 << (*p - 'a');
7920 case QEMU_OPTION_fda:
7921 case QEMU_OPTION_fdb:
7922 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
7925 case QEMU_OPTION_no_fd_bootchk:
7929 case QEMU_OPTION_no_code_copy:
7930 code_copy_enabled = 0;
7932 case QEMU_OPTION_net:
7933 if (nb_net_clients >= MAX_NET_CLIENTS) {
7934 fprintf(stderr, "qemu: too many network clients\n");
7937 net_clients[nb_net_clients] = optarg;
7941 case QEMU_OPTION_tftp:
7942 tftp_prefix = optarg;
7944 case QEMU_OPTION_bootp:
7945 bootp_filename = optarg;
7948 case QEMU_OPTION_smb:
7949 net_slirp_smb(optarg);
7952 case QEMU_OPTION_redir:
7953 net_slirp_redir(optarg);
7957 case QEMU_OPTION_audio_help:
7961 case QEMU_OPTION_soundhw:
7962 select_soundhw (optarg);
7968 case QEMU_OPTION_m: {
7972 value = strtoul(optarg, &ptr, 10);
7974 case 0: case 'M': case 'm':
7981 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
7985 /* On 32-bit hosts, QEMU is limited by virtual address space */
7986 if (value > (2047 << 20)
7988 && HOST_LONG_BITS == 32
7991 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
7994 if (value != (uint64_t)(ram_addr_t)value) {
7995 fprintf(stderr, "qemu: ram size too large\n");
8006 mask = cpu_str_to_log_mask(optarg);
8008 printf("Log items (comma separated):\n");
8009 for(item = cpu_log_items; item->mask != 0; item++) {
8010 printf("%-10s %s\n", item->name, item->help);
8017 #ifdef CONFIG_GDBSTUB
8022 gdbstub_port = optarg;
8028 case QEMU_OPTION_bios:
8035 keyboard_layout = optarg;
8037 case QEMU_OPTION_localtime:
8040 case QEMU_OPTION_cirrusvga:
8041 cirrus_vga_enabled = 1;
8044 case QEMU_OPTION_vmsvga:
8045 cirrus_vga_enabled = 0;
8048 case QEMU_OPTION_std_vga:
8049 cirrus_vga_enabled = 0;
8057 w = strtol(p, (char **)&p, 10);
8060 fprintf(stderr, "qemu: invalid resolution or depth\n");
8066 h = strtol(p, (char **)&p, 10);
8071 depth = strtol(p, (char **)&p, 10);
8072 if (depth != 8 && depth != 15 && depth != 16 &&
8073 depth != 24 && depth != 32)
8075 } else if (*p == '\0') {
8076 depth = graphic_depth;
8083 graphic_depth = depth;
8086 case QEMU_OPTION_echr:
8089 term_escape_char = strtol(optarg, &r, 0);
8091 printf("Bad argument to echr\n");
8094 case QEMU_OPTION_monitor:
8095 monitor_device = optarg;
8097 case QEMU_OPTION_serial:
8098 if (serial_device_index >= MAX_SERIAL_PORTS) {
8099 fprintf(stderr, "qemu: too many serial ports\n");
8102 serial_devices[serial_device_index] = optarg;
8103 serial_device_index++;
8105 case QEMU_OPTION_parallel:
8106 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
8107 fprintf(stderr, "qemu: too many parallel ports\n");
8110 parallel_devices[parallel_device_index] = optarg;
8111 parallel_device_index++;
8113 case QEMU_OPTION_loadvm:
8116 case QEMU_OPTION_full_screen:
8120 case QEMU_OPTION_no_frame:
8123 case QEMU_OPTION_alt_grab:
8126 case QEMU_OPTION_no_quit:
8130 case QEMU_OPTION_pidfile:
8134 case QEMU_OPTION_win2k_hack:
8135 win2k_install_hack = 1;
8139 case QEMU_OPTION_no_kqemu:
8142 case QEMU_OPTION_kernel_kqemu:
8146 case QEMU_OPTION_usb:
8149 case QEMU_OPTION_usbdevice:
8151 if (usb_devices_index >= MAX_USB_CMDLINE) {
8152 fprintf(stderr, "Too many USB devices\n");
8155 usb_devices[usb_devices_index] = optarg;
8156 usb_devices_index++;
8158 case QEMU_OPTION_smp:
8159 smp_cpus = atoi(optarg);
8160 if (smp_cpus < 1 || smp_cpus > MAX_CPUS) {
8161 fprintf(stderr, "Invalid number of CPUs\n");
8165 case QEMU_OPTION_vnc:
8166 vnc_display = optarg;
8168 case QEMU_OPTION_no_acpi:
8171 case QEMU_OPTION_no_reboot:
8174 case QEMU_OPTION_no_shutdown:
8177 case QEMU_OPTION_show_cursor:
8180 case QEMU_OPTION_daemonize:
8183 case QEMU_OPTION_option_rom:
8184 if (nb_option_roms >= MAX_OPTION_ROMS) {
8185 fprintf(stderr, "Too many option ROMs\n");
8188 option_rom[nb_option_roms] = optarg;
8191 case QEMU_OPTION_semihosting:
8192 semihosting_enabled = 1;
8194 case QEMU_OPTION_name:
8198 case QEMU_OPTION_prom_env:
8199 if (nb_prom_envs >= MAX_PROM_ENVS) {
8200 fprintf(stderr, "Too many prom variables\n");
8203 prom_envs[nb_prom_envs] = optarg;
8208 case QEMU_OPTION_old_param:
8212 case QEMU_OPTION_clock:
8213 configure_alarms(optarg);
8215 case QEMU_OPTION_startdate:
8218 time_t rtc_start_date;
8219 if (!strcmp(optarg, "now")) {
8220 rtc_date_offset = -1;
8222 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
8230 } else if (sscanf(optarg, "%d-%d-%d",
8233 &tm.tm_mday) == 3) {
8242 rtc_start_date = mktimegm(&tm);
8243 if (rtc_start_date == -1) {
8245 fprintf(stderr, "Invalid date format. Valid format are:\n"
8246 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8249 rtc_date_offset = time(NULL) - rtc_start_date;
8258 if (daemonize && !nographic && vnc_display == NULL) {
8259 fprintf(stderr, "Can only daemonize if using -nographic or -vnc\n");
8266 if (pipe(fds) == -1)
8277 len = read(fds[0], &status, 1);
8278 if (len == -1 && (errno == EINTR))
8283 else if (status == 1) {
8284 fprintf(stderr, "Could not acquire pidfile\n");
8302 signal(SIGTSTP, SIG_IGN);
8303 signal(SIGTTOU, SIG_IGN);
8304 signal(SIGTTIN, SIG_IGN);
8308 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
8311 write(fds[1], &status, 1);
8313 fprintf(stderr, "Could not acquire pid file\n");
8321 linux_boot = (kernel_filename != NULL);
8322 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
8324 /* XXX: this should not be: some embedded targets just have flash */
8325 if (!linux_boot && net_boot == 0 &&
8329 /* boot to floppy or the default cd if no hard disk defined yet */
8330 if (!boot_devices[0]) {
8331 boot_devices = "cad";
8333 setvbuf(stdout, NULL, _IOLBF, 0);
8343 /* init network clients */
8344 if (nb_net_clients == 0) {
8345 /* if no clients, we use a default config */
8346 net_clients[0] = "nic";
8347 net_clients[1] = "user";
8351 for(i = 0;i < nb_net_clients; i++) {
8352 if (net_client_init(net_clients[i]) < 0)
8355 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8356 if (vlan->nb_guest_devs == 0 && vlan->nb_host_devs == 0)
8358 if (vlan->nb_guest_devs == 0) {
8359 fprintf(stderr, "Invalid vlan (%d) with no nics\n", vlan->id);
8362 if (vlan->nb_host_devs == 0)
8364 "Warning: vlan %d is not connected to host network\n",
8369 /* XXX: this should be moved in the PC machine instantiation code */
8370 if (net_boot != 0) {
8372 for (i = 0; i < nb_nics && i < 4; i++) {
8373 const char *model = nd_table[i].model;
8375 if (net_boot & (1 << i)) {
8378 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
8379 if (get_image_size(buf) > 0) {
8380 if (nb_option_roms >= MAX_OPTION_ROMS) {
8381 fprintf(stderr, "Too many option ROMs\n");
8384 option_rom[nb_option_roms] = strdup(buf);
8391 fprintf(stderr, "No valid PXE rom found for network device\n");
8397 /* init the memory */
8398 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
8400 if (machine->ram_require & RAMSIZE_FIXED) {
8402 if (ram_size < phys_ram_size) {
8403 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
8404 machine->name, (unsigned long long) phys_ram_size);
8408 phys_ram_size = ram_size;
8410 ram_size = phys_ram_size;
8413 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
8415 phys_ram_size += ram_size;
8418 phys_ram_base = qemu_vmalloc(phys_ram_size);
8419 if (!phys_ram_base) {
8420 fprintf(stderr, "Could not allocate physical memory\n");
8426 /* we always create the cdrom drive, even if no disk is there */
8428 if (nb_drives_opt < MAX_DRIVES)
8429 drive_add(NULL, CDROM_ALIAS);
8431 /* we always create at least one floppy */
8433 if (nb_drives_opt < MAX_DRIVES)
8434 drive_add(NULL, FD_ALIAS, 0);
8436 /* we always create one sd slot, even if no card is in it */
8438 if (nb_drives_opt < MAX_DRIVES)
8439 drive_add(NULL, SD_ALIAS);
8441 /* open the virtual block devices */
8443 for(i = 0; i < nb_drives_opt; i++)
8444 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
8447 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
8448 register_savevm("ram", 0, 2, ram_save, ram_load, NULL);
8453 memset(&display_state, 0, sizeof(display_state));
8456 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
8459 /* nearly nothing to do */
8460 dumb_display_init(ds);
8461 } else if (vnc_display != NULL) {
8462 vnc_display_init(ds);
8463 if (vnc_display_open(ds, vnc_display) < 0)
8466 #if defined(CONFIG_CURSES)
8468 curses_display_init(ds, full_screen);
8472 #if defined(CONFIG_SDL)
8473 sdl_display_init(ds, full_screen, no_frame);
8474 #elif defined(CONFIG_COCOA)
8475 cocoa_display_init(ds, full_screen);
8477 dumb_display_init(ds);
8481 /* Maintain compatibility with multiple stdio monitors */
8482 if (!strcmp(monitor_device,"stdio")) {
8483 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
8484 const char *devname = serial_devices[i];
8485 if (devname && !strcmp(devname,"mon:stdio")) {
8486 monitor_device = NULL;
8488 } else if (devname && !strcmp(devname,"stdio")) {
8489 monitor_device = NULL;
8490 serial_devices[i] = "mon:stdio";
8495 if (monitor_device) {
8496 monitor_hd = qemu_chr_open(monitor_device);
8498 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
8501 monitor_init(monitor_hd, !nographic);
8504 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
8505 const char *devname = serial_devices[i];
8506 if (devname && strcmp(devname, "none")) {
8507 serial_hds[i] = qemu_chr_open(devname);
8508 if (!serial_hds[i]) {
8509 fprintf(stderr, "qemu: could not open serial device '%s'\n",
8513 if (strstart(devname, "vc", 0))
8514 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8518 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
8519 const char *devname = parallel_devices[i];
8520 if (devname && strcmp(devname, "none")) {
8521 parallel_hds[i] = qemu_chr_open(devname);
8522 if (!parallel_hds[i]) {
8523 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
8527 if (strstart(devname, "vc", 0))
8528 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
8532 machine->init(ram_size, vga_ram_size, boot_devices, ds,
8533 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
8535 /* init USB devices */
8537 for(i = 0; i < usb_devices_index; i++) {
8538 if (usb_device_add(usb_devices[i]) < 0) {
8539 fprintf(stderr, "Warning: could not add USB device %s\n",
8545 if (display_state.dpy_refresh) {
8546 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
8547 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
8550 #ifdef CONFIG_GDBSTUB
8552 /* XXX: use standard host:port notation and modify options
8554 if (gdbserver_start(gdbstub_port) < 0) {
8555 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
8566 /* XXX: simplify init */
8579 len = write(fds[1], &status, 1);
8580 if (len == -1 && (errno == EINTR))
8586 TFR(fd = open("/dev/null", O_RDWR));
8600 #if !defined(_WIN32)
8601 /* close network clients */
8602 for(vlan = first_vlan; vlan != NULL; vlan = vlan->next) {
8603 VLANClientState *vc;
8605 for(vc = vlan->first_client; vc != NULL; vc = vc->next) {
8606 if (vc->fd_read == tap_receive) {
8608 TAPState *s = vc->opaque;
8610 if (sscanf(vc->info_str, "tap: ifname=%63s ", ifname) == 1 &&
8612 launch_script(s->down_script, ifname, s->fd);