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;
242 /* Conversion factor from emulated instrctions to virtual clock ticks. */
243 static int icount_time_shift
;
244 /* Arbitrarily pick 1MIPS as the minimum alowable speed. */
245 #define MAX_ICOUNT_SHIFT 10
246 /* Compensate for varying guest execution speed. */
247 static int64_t qemu_icount_bias
;
248 QEMUTimer
*icount_rt_timer
;
249 QEMUTimer
*icount_vm_timer
;
251 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
253 /***********************************************************/
254 /* x86 ISA bus support */
256 target_phys_addr_t isa_mem_base
= 0;
259 static uint32_t default_ioport_readb(void *opaque
, uint32_t address
)
261 #ifdef DEBUG_UNUSED_IOPORT
262 fprintf(stderr
, "unused inb: port=0x%04x\n", address
);
267 static void default_ioport_writeb(void *opaque
, uint32_t address
, uint32_t data
)
269 #ifdef DEBUG_UNUSED_IOPORT
270 fprintf(stderr
, "unused outb: port=0x%04x data=0x%02x\n", address
, data
);
274 /* default is to make two byte accesses */
275 static uint32_t default_ioport_readw(void *opaque
, uint32_t address
)
278 data
= ioport_read_table
[0][address
](ioport_opaque
[address
], address
);
279 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
280 data
|= ioport_read_table
[0][address
](ioport_opaque
[address
], address
) << 8;
284 static void default_ioport_writew(void *opaque
, uint32_t address
, uint32_t data
)
286 ioport_write_table
[0][address
](ioport_opaque
[address
], address
, data
& 0xff);
287 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
288 ioport_write_table
[0][address
](ioport_opaque
[address
], address
, (data
>> 8) & 0xff);
291 static uint32_t default_ioport_readl(void *opaque
, uint32_t address
)
293 #ifdef DEBUG_UNUSED_IOPORT
294 fprintf(stderr
, "unused inl: port=0x%04x\n", address
);
299 static void default_ioport_writel(void *opaque
, uint32_t address
, uint32_t data
)
301 #ifdef DEBUG_UNUSED_IOPORT
302 fprintf(stderr
, "unused outl: port=0x%04x data=0x%02x\n", address
, data
);
306 static void init_ioports(void)
310 for(i
= 0; i
< MAX_IOPORTS
; i
++) {
311 ioport_read_table
[0][i
] = default_ioport_readb
;
312 ioport_write_table
[0][i
] = default_ioport_writeb
;
313 ioport_read_table
[1][i
] = default_ioport_readw
;
314 ioport_write_table
[1][i
] = default_ioport_writew
;
315 ioport_read_table
[2][i
] = default_ioport_readl
;
316 ioport_write_table
[2][i
] = default_ioport_writel
;
320 /* size is the word size in byte */
321 int register_ioport_read(int start
, int length
, int size
,
322 IOPortReadFunc
*func
, void *opaque
)
328 } else if (size
== 2) {
330 } else if (size
== 4) {
333 hw_error("register_ioport_read: invalid size");
336 for(i
= start
; i
< start
+ length
; i
+= size
) {
337 ioport_read_table
[bsize
][i
] = func
;
338 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
339 hw_error("register_ioport_read: invalid opaque");
340 ioport_opaque
[i
] = opaque
;
345 /* size is the word size in byte */
346 int register_ioport_write(int start
, int length
, int size
,
347 IOPortWriteFunc
*func
, void *opaque
)
353 } else if (size
== 2) {
355 } else if (size
== 4) {
358 hw_error("register_ioport_write: invalid size");
361 for(i
= start
; i
< start
+ length
; i
+= size
) {
362 ioport_write_table
[bsize
][i
] = func
;
363 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
364 hw_error("register_ioport_write: invalid opaque");
365 ioport_opaque
[i
] = opaque
;
370 void isa_unassign_ioport(int start
, int length
)
374 for(i
= start
; i
< start
+ length
; i
++) {
375 ioport_read_table
[0][i
] = default_ioport_readb
;
376 ioport_read_table
[1][i
] = default_ioport_readw
;
377 ioport_read_table
[2][i
] = default_ioport_readl
;
379 ioport_write_table
[0][i
] = default_ioport_writeb
;
380 ioport_write_table
[1][i
] = default_ioport_writew
;
381 ioport_write_table
[2][i
] = default_ioport_writel
;
385 /***********************************************************/
387 void cpu_outb(CPUState
*env
, int addr
, int val
)
390 if (loglevel
& CPU_LOG_IOPORT
)
391 fprintf(logfile
, "outb: %04x %02x\n", addr
, val
);
393 ioport_write_table
[0][addr
](ioport_opaque
[addr
], addr
, val
);
396 env
->last_io_time
= cpu_get_time_fast();
400 void cpu_outw(CPUState
*env
, int addr
, int val
)
403 if (loglevel
& CPU_LOG_IOPORT
)
404 fprintf(logfile
, "outw: %04x %04x\n", addr
, val
);
406 ioport_write_table
[1][addr
](ioport_opaque
[addr
], addr
, val
);
409 env
->last_io_time
= cpu_get_time_fast();
413 void cpu_outl(CPUState
*env
, int addr
, int val
)
416 if (loglevel
& CPU_LOG_IOPORT
)
417 fprintf(logfile
, "outl: %04x %08x\n", addr
, val
);
419 ioport_write_table
[2][addr
](ioport_opaque
[addr
], addr
, val
);
422 env
->last_io_time
= cpu_get_time_fast();
426 int cpu_inb(CPUState
*env
, int addr
)
429 val
= ioport_read_table
[0][addr
](ioport_opaque
[addr
], addr
);
431 if (loglevel
& CPU_LOG_IOPORT
)
432 fprintf(logfile
, "inb : %04x %02x\n", addr
, val
);
436 env
->last_io_time
= cpu_get_time_fast();
441 int cpu_inw(CPUState
*env
, int addr
)
444 val
= ioport_read_table
[1][addr
](ioport_opaque
[addr
], addr
);
446 if (loglevel
& CPU_LOG_IOPORT
)
447 fprintf(logfile
, "inw : %04x %04x\n", addr
, val
);
451 env
->last_io_time
= cpu_get_time_fast();
456 int cpu_inl(CPUState
*env
, int addr
)
459 val
= ioport_read_table
[2][addr
](ioport_opaque
[addr
], addr
);
461 if (loglevel
& CPU_LOG_IOPORT
)
462 fprintf(logfile
, "inl : %04x %08x\n", addr
, val
);
466 env
->last_io_time
= cpu_get_time_fast();
471 /***********************************************************/
472 void hw_error(const char *fmt
, ...)
478 fprintf(stderr
, "qemu: hardware error: ");
479 vfprintf(stderr
, fmt
, ap
);
480 fprintf(stderr
, "\n");
481 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
482 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
484 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
486 cpu_dump_state(env
, stderr
, fprintf
, 0);
493 /***********************************************************/
496 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
497 static void *qemu_put_kbd_event_opaque
;
498 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
499 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
501 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
503 qemu_put_kbd_event_opaque
= opaque
;
504 qemu_put_kbd_event
= func
;
507 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
508 void *opaque
, int absolute
,
511 QEMUPutMouseEntry
*s
, *cursor
;
513 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
517 s
->qemu_put_mouse_event
= func
;
518 s
->qemu_put_mouse_event_opaque
= opaque
;
519 s
->qemu_put_mouse_event_absolute
= absolute
;
520 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
523 if (!qemu_put_mouse_event_head
) {
524 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
528 cursor
= qemu_put_mouse_event_head
;
529 while (cursor
->next
!= NULL
)
530 cursor
= cursor
->next
;
533 qemu_put_mouse_event_current
= s
;
538 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
540 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
542 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
545 cursor
= qemu_put_mouse_event_head
;
546 while (cursor
!= NULL
&& cursor
!= entry
) {
548 cursor
= cursor
->next
;
551 if (cursor
== NULL
) // does not exist or list empty
553 else if (prev
== NULL
) { // entry is head
554 qemu_put_mouse_event_head
= cursor
->next
;
555 if (qemu_put_mouse_event_current
== entry
)
556 qemu_put_mouse_event_current
= cursor
->next
;
557 qemu_free(entry
->qemu_put_mouse_event_name
);
562 prev
->next
= entry
->next
;
564 if (qemu_put_mouse_event_current
== entry
)
565 qemu_put_mouse_event_current
= prev
;
567 qemu_free(entry
->qemu_put_mouse_event_name
);
571 void kbd_put_keycode(int keycode
)
573 if (qemu_put_kbd_event
) {
574 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
578 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
580 QEMUPutMouseEvent
*mouse_event
;
581 void *mouse_event_opaque
;
584 if (!qemu_put_mouse_event_current
) {
589 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
591 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
594 if (graphic_rotate
) {
595 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
598 width
= graphic_width
- 1;
599 mouse_event(mouse_event_opaque
,
600 width
- dy
, dx
, dz
, buttons_state
);
602 mouse_event(mouse_event_opaque
,
603 dx
, dy
, dz
, buttons_state
);
607 int kbd_mouse_is_absolute(void)
609 if (!qemu_put_mouse_event_current
)
612 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
615 void do_info_mice(void)
617 QEMUPutMouseEntry
*cursor
;
620 if (!qemu_put_mouse_event_head
) {
621 term_printf("No mouse devices connected\n");
625 term_printf("Mouse devices available:\n");
626 cursor
= qemu_put_mouse_event_head
;
627 while (cursor
!= NULL
) {
628 term_printf("%c Mouse #%d: %s\n",
629 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
630 index
, cursor
->qemu_put_mouse_event_name
);
632 cursor
= cursor
->next
;
636 void do_mouse_set(int index
)
638 QEMUPutMouseEntry
*cursor
;
641 if (!qemu_put_mouse_event_head
) {
642 term_printf("No mouse devices connected\n");
646 cursor
= qemu_put_mouse_event_head
;
647 while (cursor
!= NULL
&& index
!= i
) {
649 cursor
= cursor
->next
;
653 qemu_put_mouse_event_current
= cursor
;
655 term_printf("Mouse at given index not found\n");
658 /* compute with 96 bit intermediate result: (a*b)/c */
659 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
664 #ifdef WORDS_BIGENDIAN
674 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
675 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
678 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
682 /***********************************************************/
683 /* real time host monotonic timer */
685 #define QEMU_TIMER_BASE 1000000000LL
689 static int64_t clock_freq
;
691 static void init_get_clock(void)
695 ret
= QueryPerformanceFrequency(&freq
);
697 fprintf(stderr
, "Could not calibrate ticks\n");
700 clock_freq
= freq
.QuadPart
;
703 static int64_t get_clock(void)
706 QueryPerformanceCounter(&ti
);
707 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
712 static int use_rt_clock
;
714 static void init_get_clock(void)
717 #if defined(__linux__)
720 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
727 static int64_t get_clock(void)
729 #if defined(__linux__)
732 clock_gettime(CLOCK_MONOTONIC
, &ts
);
733 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
737 /* XXX: using gettimeofday leads to problems if the date
738 changes, so it should be avoided. */
740 gettimeofday(&tv
, NULL
);
741 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
746 /* Return the virtual CPU time, based on the instruction counter. */
747 static int64_t cpu_get_icount(void)
750 CPUState
*env
= cpu_single_env
;;
751 icount
= qemu_icount
;
754 fprintf(stderr
, "Bad clock read\n");
755 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
757 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
760 /***********************************************************/
761 /* guest cycle counter */
763 static int64_t cpu_ticks_prev
;
764 static int64_t cpu_ticks_offset
;
765 static int64_t cpu_clock_offset
;
766 static int cpu_ticks_enabled
;
768 /* return the host CPU cycle counter and handle stop/restart */
769 int64_t cpu_get_ticks(void)
772 return cpu_get_icount();
774 if (!cpu_ticks_enabled
) {
775 return cpu_ticks_offset
;
778 ticks
= cpu_get_real_ticks();
779 if (cpu_ticks_prev
> ticks
) {
780 /* Note: non increasing ticks may happen if the host uses
782 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
784 cpu_ticks_prev
= ticks
;
785 return ticks
+ cpu_ticks_offset
;
789 /* return the host CPU monotonic timer and handle stop/restart */
790 static int64_t cpu_get_clock(void)
793 if (!cpu_ticks_enabled
) {
794 return cpu_clock_offset
;
797 return ti
+ cpu_clock_offset
;
801 /* enable cpu_get_ticks() */
802 void cpu_enable_ticks(void)
804 if (!cpu_ticks_enabled
) {
805 cpu_ticks_offset
-= cpu_get_real_ticks();
806 cpu_clock_offset
-= get_clock();
807 cpu_ticks_enabled
= 1;
811 /* disable cpu_get_ticks() : the clock is stopped. You must not call
812 cpu_get_ticks() after that. */
813 void cpu_disable_ticks(void)
815 if (cpu_ticks_enabled
) {
816 cpu_ticks_offset
= cpu_get_ticks();
817 cpu_clock_offset
= cpu_get_clock();
818 cpu_ticks_enabled
= 0;
822 /***********************************************************/
825 #define QEMU_TIMER_REALTIME 0
826 #define QEMU_TIMER_VIRTUAL 1
830 /* XXX: add frequency */
838 struct QEMUTimer
*next
;
841 struct qemu_alarm_timer
{
845 int (*start
)(struct qemu_alarm_timer
*t
);
846 void (*stop
)(struct qemu_alarm_timer
*t
);
847 void (*rearm
)(struct qemu_alarm_timer
*t
);
851 #define ALARM_FLAG_DYNTICKS 0x1
852 #define ALARM_FLAG_EXPIRED 0x2
854 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
856 return t
->flags
& ALARM_FLAG_DYNTICKS
;
859 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
861 if (!alarm_has_dynticks(t
))
867 /* TODO: MIN_TIMER_REARM_US should be optimized */
868 #define MIN_TIMER_REARM_US 250
870 static struct qemu_alarm_timer
*alarm_timer
;
874 struct qemu_alarm_win32
{
878 } alarm_win32_data
= {0, NULL
, -1};
880 static int win32_start_timer(struct qemu_alarm_timer
*t
);
881 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
882 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
886 static int unix_start_timer(struct qemu_alarm_timer
*t
);
887 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
891 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
892 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
893 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
895 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
896 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
898 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
899 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
901 #endif /* __linux__ */
905 /* Correlation between real and virtual time is always going to be
906 farly approximate, so ignore small variation.
907 When the guest is idle real and virtual time will be aligned in
909 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
911 static void icount_adjust(void)
916 static int64_t last_delta
;
917 /* If the VM is not running, then do nothing. */
921 cur_time
= cpu_get_clock();
922 cur_icount
= qemu_get_clock(vm_clock
);
923 delta
= cur_icount
- cur_time
;
924 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
926 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
927 && icount_time_shift
> 0) {
928 /* The guest is getting too far ahead. Slow time down. */
932 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
933 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
934 /* The guest is getting too far behind. Speed time up. */
938 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
941 static void icount_adjust_rt(void * opaque
)
943 qemu_mod_timer(icount_rt_timer
,
944 qemu_get_clock(rt_clock
) + 1000);
948 static void icount_adjust_vm(void * opaque
)
950 qemu_mod_timer(icount_vm_timer
,
951 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
955 static void init_icount_adjust(void)
957 /* Have both realtime and virtual time triggers for speed adjustment.
958 The realtime trigger catches emulated time passing too slowly,
959 the virtual time trigger catches emulated time passing too fast.
960 Realtime triggers occur even when idle, so use them less frequently
962 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
963 qemu_mod_timer(icount_rt_timer
,
964 qemu_get_clock(rt_clock
) + 1000);
965 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
966 qemu_mod_timer(icount_vm_timer
,
967 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
970 static struct qemu_alarm_timer alarm_timers
[] = {
973 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
974 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
975 /* HPET - if available - is preferred */
976 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
977 /* ...otherwise try RTC */
978 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
980 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
982 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
983 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
984 {"win32", 0, win32_start_timer
,
985 win32_stop_timer
, NULL
, &alarm_win32_data
},
990 static void show_available_alarms(void)
994 printf("Available alarm timers, in order of precedence:\n");
995 for (i
= 0; alarm_timers
[i
].name
; i
++)
996 printf("%s\n", alarm_timers
[i
].name
);
999 static void configure_alarms(char const *opt
)
1003 int count
= (sizeof(alarm_timers
) / sizeof(*alarm_timers
)) - 1;
1006 struct qemu_alarm_timer tmp
;
1008 if (!strcmp(opt
, "?")) {
1009 show_available_alarms();
1015 /* Reorder the array */
1016 name
= strtok(arg
, ",");
1018 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
1019 if (!strcmp(alarm_timers
[i
].name
, name
))
1024 fprintf(stderr
, "Unknown clock %s\n", name
);
1033 tmp
= alarm_timers
[i
];
1034 alarm_timers
[i
] = alarm_timers
[cur
];
1035 alarm_timers
[cur
] = tmp
;
1039 name
= strtok(NULL
, ",");
1045 /* Disable remaining timers */
1046 for (i
= cur
; i
< count
; i
++)
1047 alarm_timers
[i
].name
= NULL
;
1049 show_available_alarms();
1054 QEMUClock
*rt_clock
;
1055 QEMUClock
*vm_clock
;
1057 static QEMUTimer
*active_timers
[2];
1059 static QEMUClock
*qemu_new_clock(int type
)
1062 clock
= qemu_mallocz(sizeof(QEMUClock
));
1069 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
1073 ts
= qemu_mallocz(sizeof(QEMUTimer
));
1076 ts
->opaque
= opaque
;
1080 void qemu_free_timer(QEMUTimer
*ts
)
1085 /* stop a timer, but do not dealloc it */
1086 void qemu_del_timer(QEMUTimer
*ts
)
1090 /* NOTE: this code must be signal safe because
1091 qemu_timer_expired() can be called from a signal. */
1092 pt
= &active_timers
[ts
->clock
->type
];
1105 /* modify the current timer so that it will be fired when current_time
1106 >= expire_time. The corresponding callback will be called. */
1107 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
1113 /* add the timer in the sorted list */
1114 /* NOTE: this code must be signal safe because
1115 qemu_timer_expired() can be called from a signal. */
1116 pt
= &active_timers
[ts
->clock
->type
];
1121 if (t
->expire_time
> expire_time
)
1125 ts
->expire_time
= expire_time
;
1129 /* Rearm if necessary */
1130 if (pt
== &active_timers
[ts
->clock
->type
]) {
1131 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
1132 qemu_rearm_alarm_timer(alarm_timer
);
1134 /* Interrupt execution to force deadline recalculation. */
1135 if (use_icount
&& cpu_single_env
) {
1136 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
1141 int qemu_timer_pending(QEMUTimer
*ts
)
1144 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1151 static inline int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1155 return (timer_head
->expire_time
<= current_time
);
1158 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1164 if (!ts
|| ts
->expire_time
> current_time
)
1166 /* remove timer from the list before calling the callback */
1167 *ptimer_head
= ts
->next
;
1170 /* run the callback (the timer list can be modified) */
1175 int64_t qemu_get_clock(QEMUClock
*clock
)
1177 switch(clock
->type
) {
1178 case QEMU_TIMER_REALTIME
:
1179 return get_clock() / 1000000;
1181 case QEMU_TIMER_VIRTUAL
:
1183 return cpu_get_icount();
1185 return cpu_get_clock();
1190 static void init_timers(void)
1193 ticks_per_sec
= QEMU_TIMER_BASE
;
1194 rt_clock
= qemu_new_clock(QEMU_TIMER_REALTIME
);
1195 vm_clock
= qemu_new_clock(QEMU_TIMER_VIRTUAL
);
1199 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1201 uint64_t expire_time
;
1203 if (qemu_timer_pending(ts
)) {
1204 expire_time
= ts
->expire_time
;
1208 qemu_put_be64(f
, expire_time
);
1211 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1213 uint64_t expire_time
;
1215 expire_time
= qemu_get_be64(f
);
1216 if (expire_time
!= -1) {
1217 qemu_mod_timer(ts
, expire_time
);
1223 static void timer_save(QEMUFile
*f
, void *opaque
)
1225 if (cpu_ticks_enabled
) {
1226 hw_error("cannot save state if virtual timers are running");
1228 qemu_put_be64(f
, cpu_ticks_offset
);
1229 qemu_put_be64(f
, ticks_per_sec
);
1230 qemu_put_be64(f
, cpu_clock_offset
);
1233 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1235 if (version_id
!= 1 && version_id
!= 2)
1237 if (cpu_ticks_enabled
) {
1240 cpu_ticks_offset
=qemu_get_be64(f
);
1241 ticks_per_sec
=qemu_get_be64(f
);
1242 if (version_id
== 2) {
1243 cpu_clock_offset
=qemu_get_be64(f
);
1249 void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1250 DWORD_PTR dwUser
, DWORD_PTR dw1
, DWORD_PTR dw2
)
1252 static void host_alarm_handler(int host_signum
)
1256 #define DISP_FREQ 1000
1258 static int64_t delta_min
= INT64_MAX
;
1259 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1261 ti
= qemu_get_clock(vm_clock
);
1262 if (last_clock
!= 0) {
1263 delta
= ti
- last_clock
;
1264 if (delta
< delta_min
)
1266 if (delta
> delta_max
)
1269 if (++count
== DISP_FREQ
) {
1270 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1271 muldiv64(delta_min
, 1000000, ticks_per_sec
),
1272 muldiv64(delta_max
, 1000000, ticks_per_sec
),
1273 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, ticks_per_sec
),
1274 (double)ticks_per_sec
/ ((double)delta_cum
/ DISP_FREQ
));
1276 delta_min
= INT64_MAX
;
1284 if (alarm_has_dynticks(alarm_timer
) ||
1286 qemu_timer_expired(active_timers
[QEMU_TIMER_VIRTUAL
],
1287 qemu_get_clock(vm_clock
))) ||
1288 qemu_timer_expired(active_timers
[QEMU_TIMER_REALTIME
],
1289 qemu_get_clock(rt_clock
))) {
1291 struct qemu_alarm_win32
*data
= ((struct qemu_alarm_timer
*)dwUser
)->priv
;
1292 SetEvent(data
->host_alarm
);
1294 CPUState
*env
= next_cpu
;
1296 alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1299 /* stop the currently executing cpu because a timer occured */
1300 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
1302 if (env
->kqemu_enabled
) {
1303 kqemu_cpu_interrupt(env
);
1311 static int64_t qemu_next_deadline(void)
1315 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1316 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1317 qemu_get_clock(vm_clock
);
1319 /* To avoid problems with overflow limit this to 2^32. */
1329 static uint64_t qemu_next_deadline_dyntick(void)
1337 delta
= (qemu_next_deadline() + 999) / 1000;
1339 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1340 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1341 qemu_get_clock(rt_clock
))*1000;
1342 if (rtdelta
< delta
)
1346 if (delta
< MIN_TIMER_REARM_US
)
1347 delta
= MIN_TIMER_REARM_US
;
1354 #if defined(__linux__)
1356 #define RTC_FREQ 1024
1358 static void enable_sigio_timer(int fd
)
1360 struct sigaction act
;
1363 sigfillset(&act
.sa_mask
);
1365 act
.sa_handler
= host_alarm_handler
;
1367 sigaction(SIGIO
, &act
, NULL
);
1368 fcntl(fd
, F_SETFL
, O_ASYNC
);
1369 fcntl(fd
, F_SETOWN
, getpid());
1372 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1374 struct hpet_info info
;
1377 fd
= open("/dev/hpet", O_RDONLY
);
1382 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1384 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1385 "error, but for better emulation accuracy type:\n"
1386 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1390 /* Check capabilities */
1391 r
= ioctl(fd
, HPET_INFO
, &info
);
1395 /* Enable periodic mode */
1396 r
= ioctl(fd
, HPET_EPI
, 0);
1397 if (info
.hi_flags
&& (r
< 0))
1400 /* Enable interrupt */
1401 r
= ioctl(fd
, HPET_IE_ON
, 0);
1405 enable_sigio_timer(fd
);
1406 t
->priv
= (void *)(long)fd
;
1414 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1416 int fd
= (long)t
->priv
;
1421 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1424 unsigned long current_rtc_freq
= 0;
1426 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1429 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1430 if (current_rtc_freq
!= RTC_FREQ
&&
1431 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1432 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1433 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1434 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1437 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1443 enable_sigio_timer(rtc_fd
);
1445 t
->priv
= (void *)(long)rtc_fd
;
1450 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1452 int rtc_fd
= (long)t
->priv
;
1457 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1461 struct sigaction act
;
1463 sigfillset(&act
.sa_mask
);
1465 act
.sa_handler
= host_alarm_handler
;
1467 sigaction(SIGALRM
, &act
, NULL
);
1469 ev
.sigev_value
.sival_int
= 0;
1470 ev
.sigev_notify
= SIGEV_SIGNAL
;
1471 ev
.sigev_signo
= SIGALRM
;
1473 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1474 perror("timer_create");
1476 /* disable dynticks */
1477 fprintf(stderr
, "Dynamic Ticks disabled\n");
1482 t
->priv
= (void *)host_timer
;
1487 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1489 timer_t host_timer
= (timer_t
)t
->priv
;
1491 timer_delete(host_timer
);
1494 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1496 timer_t host_timer
= (timer_t
)t
->priv
;
1497 struct itimerspec timeout
;
1498 int64_t nearest_delta_us
= INT64_MAX
;
1501 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1502 !active_timers
[QEMU_TIMER_VIRTUAL
])
1505 nearest_delta_us
= qemu_next_deadline_dyntick();
1507 /* check whether a timer is already running */
1508 if (timer_gettime(host_timer
, &timeout
)) {
1510 fprintf(stderr
, "Internal timer error: aborting\n");
1513 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1514 if (current_us
&& current_us
<= nearest_delta_us
)
1517 timeout
.it_interval
.tv_sec
= 0;
1518 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1519 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1520 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1521 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1523 fprintf(stderr
, "Internal timer error: aborting\n");
1528 #endif /* defined(__linux__) */
1530 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1532 struct sigaction act
;
1533 struct itimerval itv
;
1537 sigfillset(&act
.sa_mask
);
1539 act
.sa_handler
= host_alarm_handler
;
1541 sigaction(SIGALRM
, &act
, NULL
);
1543 itv
.it_interval
.tv_sec
= 0;
1544 /* for i386 kernel 2.6 to get 1 ms */
1545 itv
.it_interval
.tv_usec
= 999;
1546 itv
.it_value
.tv_sec
= 0;
1547 itv
.it_value
.tv_usec
= 10 * 1000;
1549 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1556 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1558 struct itimerval itv
;
1560 memset(&itv
, 0, sizeof(itv
));
1561 setitimer(ITIMER_REAL
, &itv
, NULL
);
1564 #endif /* !defined(_WIN32) */
1568 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1571 struct qemu_alarm_win32
*data
= t
->priv
;
1574 data
->host_alarm
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1575 if (!data
->host_alarm
) {
1576 perror("Failed CreateEvent");
1580 memset(&tc
, 0, sizeof(tc
));
1581 timeGetDevCaps(&tc
, sizeof(tc
));
1583 if (data
->period
< tc
.wPeriodMin
)
1584 data
->period
= tc
.wPeriodMin
;
1586 timeBeginPeriod(data
->period
);
1588 flags
= TIME_CALLBACK_FUNCTION
;
1589 if (alarm_has_dynticks(t
))
1590 flags
|= TIME_ONESHOT
;
1592 flags
|= TIME_PERIODIC
;
1594 data
->timerId
= timeSetEvent(1, // interval (ms)
1595 data
->period
, // resolution
1596 host_alarm_handler
, // function
1597 (DWORD
)t
, // parameter
1600 if (!data
->timerId
) {
1601 perror("Failed to initialize win32 alarm timer");
1603 timeEndPeriod(data
->period
);
1604 CloseHandle(data
->host_alarm
);
1608 qemu_add_wait_object(data
->host_alarm
, NULL
, NULL
);
1613 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1615 struct qemu_alarm_win32
*data
= t
->priv
;
1617 timeKillEvent(data
->timerId
);
1618 timeEndPeriod(data
->period
);
1620 CloseHandle(data
->host_alarm
);
1623 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1625 struct qemu_alarm_win32
*data
= t
->priv
;
1626 uint64_t nearest_delta_us
;
1628 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1629 !active_timers
[QEMU_TIMER_VIRTUAL
])
1632 nearest_delta_us
= qemu_next_deadline_dyntick();
1633 nearest_delta_us
/= 1000;
1635 timeKillEvent(data
->timerId
);
1637 data
->timerId
= timeSetEvent(1,
1641 TIME_ONESHOT
| TIME_PERIODIC
);
1643 if (!data
->timerId
) {
1644 perror("Failed to re-arm win32 alarm timer");
1646 timeEndPeriod(data
->period
);
1647 CloseHandle(data
->host_alarm
);
1654 static void init_timer_alarm(void)
1656 struct qemu_alarm_timer
*t
;
1659 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1660 t
= &alarm_timers
[i
];
1668 fprintf(stderr
, "Unable to find any suitable alarm timer.\n");
1669 fprintf(stderr
, "Terminating\n");
1676 static void quit_timers(void)
1678 alarm_timer
->stop(alarm_timer
);
1682 /***********************************************************/
1683 /* host time/date access */
1684 void qemu_get_timedate(struct tm
*tm
, int offset
)
1691 if (rtc_date_offset
== -1) {
1695 ret
= localtime(&ti
);
1697 ti
-= rtc_date_offset
;
1701 memcpy(tm
, ret
, sizeof(struct tm
));
1704 int qemu_timedate_diff(struct tm
*tm
)
1708 if (rtc_date_offset
== -1)
1710 seconds
= mktimegm(tm
);
1712 seconds
= mktime(tm
);
1714 seconds
= mktimegm(tm
) + rtc_date_offset
;
1716 return seconds
- time(NULL
);
1719 /***********************************************************/
1720 /* character device */
1722 static void qemu_chr_event(CharDriverState
*s
, int event
)
1726 s
->chr_event(s
->handler_opaque
, event
);
1729 static void qemu_chr_reset_bh(void *opaque
)
1731 CharDriverState
*s
= opaque
;
1732 qemu_chr_event(s
, CHR_EVENT_RESET
);
1733 qemu_bh_delete(s
->bh
);
1737 void qemu_chr_reset(CharDriverState
*s
)
1739 if (s
->bh
== NULL
) {
1740 s
->bh
= qemu_bh_new(qemu_chr_reset_bh
, s
);
1741 qemu_bh_schedule(s
->bh
);
1745 int qemu_chr_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
1747 return s
->chr_write(s
, buf
, len
);
1750 int qemu_chr_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
1754 return s
->chr_ioctl(s
, cmd
, arg
);
1757 int qemu_chr_can_read(CharDriverState
*s
)
1759 if (!s
->chr_can_read
)
1761 return s
->chr_can_read(s
->handler_opaque
);
1764 void qemu_chr_read(CharDriverState
*s
, uint8_t *buf
, int len
)
1766 s
->chr_read(s
->handler_opaque
, buf
, len
);
1769 void qemu_chr_accept_input(CharDriverState
*s
)
1771 if (s
->chr_accept_input
)
1772 s
->chr_accept_input(s
);
1775 void qemu_chr_printf(CharDriverState
*s
, const char *fmt
, ...)
1780 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
1781 qemu_chr_write(s
, (uint8_t *)buf
, strlen(buf
));
1785 void qemu_chr_send_event(CharDriverState
*s
, int event
)
1787 if (s
->chr_send_event
)
1788 s
->chr_send_event(s
, event
);
1791 void qemu_chr_add_handlers(CharDriverState
*s
,
1792 IOCanRWHandler
*fd_can_read
,
1793 IOReadHandler
*fd_read
,
1794 IOEventHandler
*fd_event
,
1797 s
->chr_can_read
= fd_can_read
;
1798 s
->chr_read
= fd_read
;
1799 s
->chr_event
= fd_event
;
1800 s
->handler_opaque
= opaque
;
1801 if (s
->chr_update_read_handler
)
1802 s
->chr_update_read_handler(s
);
1805 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1810 static CharDriverState
*qemu_chr_open_null(void)
1812 CharDriverState
*chr
;
1814 chr
= qemu_mallocz(sizeof(CharDriverState
));
1817 chr
->chr_write
= null_chr_write
;
1821 /* MUX driver for serial I/O splitting */
1822 static int term_timestamps
;
1823 static int64_t term_timestamps_start
;
1825 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1826 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1828 IOCanRWHandler
*chr_can_read
[MAX_MUX
];
1829 IOReadHandler
*chr_read
[MAX_MUX
];
1830 IOEventHandler
*chr_event
[MAX_MUX
];
1831 void *ext_opaque
[MAX_MUX
];
1832 CharDriverState
*drv
;
1833 unsigned char buffer
[MUX_BUFFER_SIZE
];
1837 int term_got_escape
;
1842 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1844 MuxDriver
*d
= chr
->opaque
;
1846 if (!term_timestamps
) {
1847 ret
= d
->drv
->chr_write(d
->drv
, buf
, len
);
1852 for(i
= 0; i
< len
; i
++) {
1853 ret
+= d
->drv
->chr_write(d
->drv
, buf
+i
, 1);
1854 if (buf
[i
] == '\n') {
1860 if (term_timestamps_start
== -1)
1861 term_timestamps_start
= ti
;
1862 ti
-= term_timestamps_start
;
1863 secs
= ti
/ 1000000000;
1864 snprintf(buf1
, sizeof(buf1
),
1865 "[%02d:%02d:%02d.%03d] ",
1869 (int)((ti
/ 1000000) % 1000));
1870 d
->drv
->chr_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
1877 static char *mux_help
[] = {
1878 "% h print this help\n\r",
1879 "% x exit emulator\n\r",
1880 "% s save disk data back to file (if -snapshot)\n\r",
1881 "% t toggle console timestamps\n\r"
1882 "% b send break (magic sysrq)\n\r",
1883 "% c switch between console and monitor\n\r",
1888 static int term_escape_char
= 0x01; /* ctrl-a is used for escape */
1889 static void mux_print_help(CharDriverState
*chr
)
1892 char ebuf
[15] = "Escape-Char";
1893 char cbuf
[50] = "\n\r";
1895 if (term_escape_char
> 0 && term_escape_char
< 26) {
1896 sprintf(cbuf
,"\n\r");
1897 sprintf(ebuf
,"C-%c", term_escape_char
- 1 + 'a');
1899 sprintf(cbuf
,"\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1902 chr
->chr_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
1903 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
1904 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
1905 if (mux_help
[i
][j
] == '%')
1906 chr
->chr_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
1908 chr
->chr_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
1913 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
1915 if (d
->term_got_escape
) {
1916 d
->term_got_escape
= 0;
1917 if (ch
== term_escape_char
)
1922 mux_print_help(chr
);
1926 char *term
= "QEMU: Terminated\n\r";
1927 chr
->chr_write(chr
,(uint8_t *)term
,strlen(term
));
1934 for (i
= 0; i
< nb_drives
; i
++) {
1935 bdrv_commit(drives_table
[i
].bdrv
);
1940 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
1943 /* Switch to the next registered device */
1945 if (chr
->focus
>= d
->mux_cnt
)
1949 term_timestamps
= !term_timestamps
;
1950 term_timestamps_start
= -1;
1953 } else if (ch
== term_escape_char
) {
1954 d
->term_got_escape
= 1;
1962 static void mux_chr_accept_input(CharDriverState
*chr
)
1965 MuxDriver
*d
= chr
->opaque
;
1967 while (d
->prod
!= d
->cons
&&
1968 d
->chr_can_read
[m
] &&
1969 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
1970 d
->chr_read
[m
](d
->ext_opaque
[m
],
1971 &d
->buffer
[d
->cons
++ & MUX_BUFFER_MASK
], 1);
1975 static int mux_chr_can_read(void *opaque
)
1977 CharDriverState
*chr
= opaque
;
1978 MuxDriver
*d
= chr
->opaque
;
1980 if ((d
->prod
- d
->cons
) < MUX_BUFFER_SIZE
)
1982 if (d
->chr_can_read
[chr
->focus
])
1983 return d
->chr_can_read
[chr
->focus
](d
->ext_opaque
[chr
->focus
]);
1987 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
1989 CharDriverState
*chr
= opaque
;
1990 MuxDriver
*d
= chr
->opaque
;
1994 mux_chr_accept_input (opaque
);
1996 for(i
= 0; i
< size
; i
++)
1997 if (mux_proc_byte(chr
, d
, buf
[i
])) {
1998 if (d
->prod
== d
->cons
&&
1999 d
->chr_can_read
[m
] &&
2000 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
2001 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
2003 d
->buffer
[d
->prod
++ & MUX_BUFFER_MASK
] = buf
[i
];
2007 static void mux_chr_event(void *opaque
, int event
)
2009 CharDriverState
*chr
= opaque
;
2010 MuxDriver
*d
= chr
->opaque
;
2013 /* Send the event to all registered listeners */
2014 for (i
= 0; i
< d
->mux_cnt
; i
++)
2015 if (d
->chr_event
[i
])
2016 d
->chr_event
[i
](d
->ext_opaque
[i
], event
);
2019 static void mux_chr_update_read_handler(CharDriverState
*chr
)
2021 MuxDriver
*d
= chr
->opaque
;
2023 if (d
->mux_cnt
>= MAX_MUX
) {
2024 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
2027 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
2028 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
2029 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
2030 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
2031 /* Fix up the real driver with mux routines */
2032 if (d
->mux_cnt
== 0) {
2033 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
2034 mux_chr_event
, chr
);
2036 chr
->focus
= d
->mux_cnt
;
2040 static CharDriverState
*qemu_chr_open_mux(CharDriverState
*drv
)
2042 CharDriverState
*chr
;
2045 chr
= qemu_mallocz(sizeof(CharDriverState
));
2048 d
= qemu_mallocz(sizeof(MuxDriver
));
2057 chr
->chr_write
= mux_chr_write
;
2058 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
2059 chr
->chr_accept_input
= mux_chr_accept_input
;
2066 static void socket_cleanup(void)
2071 static int socket_init(void)
2076 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
2078 err
= WSAGetLastError();
2079 fprintf(stderr
, "WSAStartup: %d\n", err
);
2082 atexit(socket_cleanup
);
2086 static int send_all(int fd
, const uint8_t *buf
, int len1
)
2092 ret
= send(fd
, buf
, len
, 0);
2095 errno
= WSAGetLastError();
2096 if (errno
!= WSAEWOULDBLOCK
) {
2099 } else if (ret
== 0) {
2109 void socket_set_nonblock(int fd
)
2111 unsigned long opt
= 1;
2112 ioctlsocket(fd
, FIONBIO
, &opt
);
2117 static int unix_write(int fd
, const uint8_t *buf
, int len1
)
2123 ret
= write(fd
, buf
, len
);
2125 if (errno
!= EINTR
&& errno
!= EAGAIN
)
2127 } else if (ret
== 0) {
2137 static inline int send_all(int fd
, const uint8_t *buf
, int len1
)
2139 return unix_write(fd
, buf
, len1
);
2142 void socket_set_nonblock(int fd
)
2144 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
2146 #endif /* !_WIN32 */
2155 #define STDIO_MAX_CLIENTS 1
2156 static int stdio_nb_clients
= 0;
2158 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2160 FDCharDriver
*s
= chr
->opaque
;
2161 return unix_write(s
->fd_out
, buf
, len
);
2164 static int fd_chr_read_poll(void *opaque
)
2166 CharDriverState
*chr
= opaque
;
2167 FDCharDriver
*s
= chr
->opaque
;
2169 s
->max_size
= qemu_chr_can_read(chr
);
2173 static void fd_chr_read(void *opaque
)
2175 CharDriverState
*chr
= opaque
;
2176 FDCharDriver
*s
= chr
->opaque
;
2181 if (len
> s
->max_size
)
2185 size
= read(s
->fd_in
, buf
, len
);
2187 /* FD has been closed. Remove it from the active list. */
2188 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2192 qemu_chr_read(chr
, buf
, size
);
2196 static void fd_chr_update_read_handler(CharDriverState
*chr
)
2198 FDCharDriver
*s
= chr
->opaque
;
2200 if (s
->fd_in
>= 0) {
2201 if (nographic
&& s
->fd_in
== 0) {
2203 qemu_set_fd_handler2(s
->fd_in
, fd_chr_read_poll
,
2204 fd_chr_read
, NULL
, chr
);
2209 static void fd_chr_close(struct CharDriverState
*chr
)
2211 FDCharDriver
*s
= chr
->opaque
;
2213 if (s
->fd_in
>= 0) {
2214 if (nographic
&& s
->fd_in
== 0) {
2216 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2223 /* open a character device to a unix fd */
2224 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
)
2226 CharDriverState
*chr
;
2229 chr
= qemu_mallocz(sizeof(CharDriverState
));
2232 s
= qemu_mallocz(sizeof(FDCharDriver
));
2240 chr
->chr_write
= fd_chr_write
;
2241 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
2242 chr
->chr_close
= fd_chr_close
;
2244 qemu_chr_reset(chr
);
2249 static CharDriverState
*qemu_chr_open_file_out(const char *file_out
)
2253 TFR(fd_out
= open(file_out
, O_WRONLY
| O_TRUNC
| O_CREAT
| O_BINARY
, 0666));
2256 return qemu_chr_open_fd(-1, fd_out
);
2259 static CharDriverState
*qemu_chr_open_pipe(const char *filename
)
2262 char filename_in
[256], filename_out
[256];
2264 snprintf(filename_in
, 256, "%s.in", filename
);
2265 snprintf(filename_out
, 256, "%s.out", filename
);
2266 TFR(fd_in
= open(filename_in
, O_RDWR
| O_BINARY
));
2267 TFR(fd_out
= open(filename_out
, O_RDWR
| O_BINARY
));
2268 if (fd_in
< 0 || fd_out
< 0) {
2273 TFR(fd_in
= fd_out
= open(filename
, O_RDWR
| O_BINARY
));
2277 return qemu_chr_open_fd(fd_in
, fd_out
);
2281 /* for STDIO, we handle the case where several clients use it
2284 #define TERM_FIFO_MAX_SIZE 1
2286 static uint8_t term_fifo
[TERM_FIFO_MAX_SIZE
];
2287 static int term_fifo_size
;
2289 static int stdio_read_poll(void *opaque
)
2291 CharDriverState
*chr
= opaque
;
2293 /* try to flush the queue if needed */
2294 if (term_fifo_size
!= 0 && qemu_chr_can_read(chr
) > 0) {
2295 qemu_chr_read(chr
, term_fifo
, 1);
2298 /* see if we can absorb more chars */
2299 if (term_fifo_size
== 0)
2305 static void stdio_read(void *opaque
)
2309 CharDriverState
*chr
= opaque
;
2311 size
= read(0, buf
, 1);
2313 /* stdin has been closed. Remove it from the active list. */
2314 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2318 if (qemu_chr_can_read(chr
) > 0) {
2319 qemu_chr_read(chr
, buf
, 1);
2320 } else if (term_fifo_size
== 0) {
2321 term_fifo
[term_fifo_size
++] = buf
[0];
2326 /* init terminal so that we can grab keys */
2327 static struct termios oldtty
;
2328 static int old_fd0_flags
;
2329 static int term_atexit_done
;
2331 static void term_exit(void)
2333 tcsetattr (0, TCSANOW
, &oldtty
);
2334 fcntl(0, F_SETFL
, old_fd0_flags
);
2337 static void term_init(void)
2341 tcgetattr (0, &tty
);
2343 old_fd0_flags
= fcntl(0, F_GETFL
);
2345 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2346 |INLCR
|IGNCR
|ICRNL
|IXON
);
2347 tty
.c_oflag
|= OPOST
;
2348 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
2349 /* if graphical mode, we allow Ctrl-C handling */
2351 tty
.c_lflag
&= ~ISIG
;
2352 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
2355 tty
.c_cc
[VTIME
] = 0;
2357 tcsetattr (0, TCSANOW
, &tty
);
2359 if (!term_atexit_done
++)
2362 fcntl(0, F_SETFL
, O_NONBLOCK
);
2365 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
2369 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2373 static CharDriverState
*qemu_chr_open_stdio(void)
2375 CharDriverState
*chr
;
2377 if (stdio_nb_clients
>= STDIO_MAX_CLIENTS
)
2379 chr
= qemu_chr_open_fd(0, 1);
2380 chr
->chr_close
= qemu_chr_close_stdio
;
2381 qemu_set_fd_handler2(0, stdio_read_poll
, stdio_read
, NULL
, chr
);
2389 /* Once Solaris has openpty(), this is going to be removed. */
2390 int openpty(int *amaster
, int *aslave
, char *name
,
2391 struct termios
*termp
, struct winsize
*winp
)
2394 int mfd
= -1, sfd
= -1;
2396 *amaster
= *aslave
= -1;
2398 mfd
= open("/dev/ptmx", O_RDWR
| O_NOCTTY
);
2402 if (grantpt(mfd
) == -1 || unlockpt(mfd
) == -1)
2405 if ((slave
= ptsname(mfd
)) == NULL
)
2408 if ((sfd
= open(slave
, O_RDONLY
| O_NOCTTY
)) == -1)
2411 if (ioctl(sfd
, I_PUSH
, "ptem") == -1 ||
2412 (termp
!= NULL
&& tcgetattr(sfd
, termp
) < 0))
2420 ioctl(sfd
, TIOCSWINSZ
, winp
);
2431 void cfmakeraw (struct termios
*termios_p
)
2433 termios_p
->c_iflag
&=
2434 ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2435 termios_p
->c_oflag
&= ~OPOST
;
2436 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2437 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2438 termios_p
->c_cflag
|= CS8
;
2440 termios_p
->c_cc
[VMIN
] = 0;
2441 termios_p
->c_cc
[VTIME
] = 0;
2445 #if defined(__linux__) || defined(__sun__)
2446 static CharDriverState
*qemu_chr_open_pty(void)
2449 int master_fd
, slave_fd
;
2451 if (openpty(&master_fd
, &slave_fd
, NULL
, NULL
, NULL
) < 0) {
2455 /* Set raw attributes on the pty. */
2457 tcsetattr(slave_fd
, TCSAFLUSH
, &tty
);
2459 fprintf(stderr
, "char device redirected to %s\n", ptsname(master_fd
));
2460 return qemu_chr_open_fd(master_fd
, master_fd
);
2463 static void tty_serial_init(int fd
, int speed
,
2464 int parity
, int data_bits
, int stop_bits
)
2470 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2471 speed
, parity
, data_bits
, stop_bits
);
2473 tcgetattr (fd
, &tty
);
2476 if (speed
<= 50 * MARGIN
)
2478 else if (speed
<= 75 * MARGIN
)
2480 else if (speed
<= 300 * MARGIN
)
2482 else if (speed
<= 600 * MARGIN
)
2484 else if (speed
<= 1200 * MARGIN
)
2486 else if (speed
<= 2400 * MARGIN
)
2488 else if (speed
<= 4800 * MARGIN
)
2490 else if (speed
<= 9600 * MARGIN
)
2492 else if (speed
<= 19200 * MARGIN
)
2494 else if (speed
<= 38400 * MARGIN
)
2496 else if (speed
<= 57600 * MARGIN
)
2498 else if (speed
<= 115200 * MARGIN
)
2503 cfsetispeed(&tty
, spd
);
2504 cfsetospeed(&tty
, spd
);
2506 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2507 |INLCR
|IGNCR
|ICRNL
|IXON
);
2508 tty
.c_oflag
|= OPOST
;
2509 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
2510 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
2531 tty
.c_cflag
|= PARENB
;
2534 tty
.c_cflag
|= PARENB
| PARODD
;
2538 tty
.c_cflag
|= CSTOPB
;
2540 tcsetattr (fd
, TCSANOW
, &tty
);
2543 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2545 FDCharDriver
*s
= chr
->opaque
;
2548 case CHR_IOCTL_SERIAL_SET_PARAMS
:
2550 QEMUSerialSetParams
*ssp
= arg
;
2551 tty_serial_init(s
->fd_in
, ssp
->speed
, ssp
->parity
,
2552 ssp
->data_bits
, ssp
->stop_bits
);
2555 case CHR_IOCTL_SERIAL_SET_BREAK
:
2557 int enable
= *(int *)arg
;
2559 tcsendbreak(s
->fd_in
, 1);
2568 static CharDriverState
*qemu_chr_open_tty(const char *filename
)
2570 CharDriverState
*chr
;
2573 TFR(fd
= open(filename
, O_RDWR
| O_NONBLOCK
));
2574 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
2575 tty_serial_init(fd
, 115200, 'N', 8, 1);
2576 chr
= qemu_chr_open_fd(fd
, fd
);
2581 chr
->chr_ioctl
= tty_serial_ioctl
;
2582 qemu_chr_reset(chr
);
2585 #else /* ! __linux__ && ! __sun__ */
2586 static CharDriverState
*qemu_chr_open_pty(void)
2590 #endif /* __linux__ || __sun__ */
2592 #if defined(__linux__)
2596 } ParallelCharDriver
;
2598 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
2600 if (s
->mode
!= mode
) {
2602 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
2609 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2611 ParallelCharDriver
*drv
= chr
->opaque
;
2616 case CHR_IOCTL_PP_READ_DATA
:
2617 if (ioctl(fd
, PPRDATA
, &b
) < 0)
2619 *(uint8_t *)arg
= b
;
2621 case CHR_IOCTL_PP_WRITE_DATA
:
2622 b
= *(uint8_t *)arg
;
2623 if (ioctl(fd
, PPWDATA
, &b
) < 0)
2626 case CHR_IOCTL_PP_READ_CONTROL
:
2627 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
2629 /* Linux gives only the lowest bits, and no way to know data
2630 direction! For better compatibility set the fixed upper
2632 *(uint8_t *)arg
= b
| 0xc0;
2634 case CHR_IOCTL_PP_WRITE_CONTROL
:
2635 b
= *(uint8_t *)arg
;
2636 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
2639 case CHR_IOCTL_PP_READ_STATUS
:
2640 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
2642 *(uint8_t *)arg
= b
;
2644 case CHR_IOCTL_PP_EPP_READ_ADDR
:
2645 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2646 struct ParallelIOArg
*parg
= arg
;
2647 int n
= read(fd
, parg
->buffer
, parg
->count
);
2648 if (n
!= parg
->count
) {
2653 case CHR_IOCTL_PP_EPP_READ
:
2654 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2655 struct ParallelIOArg
*parg
= arg
;
2656 int n
= read(fd
, parg
->buffer
, parg
->count
);
2657 if (n
!= parg
->count
) {
2662 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
2663 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2664 struct ParallelIOArg
*parg
= arg
;
2665 int n
= write(fd
, parg
->buffer
, parg
->count
);
2666 if (n
!= parg
->count
) {
2671 case CHR_IOCTL_PP_EPP_WRITE
:
2672 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2673 struct ParallelIOArg
*parg
= arg
;
2674 int n
= write(fd
, parg
->buffer
, parg
->count
);
2675 if (n
!= parg
->count
) {
2686 static void pp_close(CharDriverState
*chr
)
2688 ParallelCharDriver
*drv
= chr
->opaque
;
2691 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
2692 ioctl(fd
, PPRELEASE
);
2697 static CharDriverState
*qemu_chr_open_pp(const char *filename
)
2699 CharDriverState
*chr
;
2700 ParallelCharDriver
*drv
;
2703 TFR(fd
= open(filename
, O_RDWR
));
2707 if (ioctl(fd
, PPCLAIM
) < 0) {
2712 drv
= qemu_mallocz(sizeof(ParallelCharDriver
));
2718 drv
->mode
= IEEE1284_MODE_COMPAT
;
2720 chr
= qemu_mallocz(sizeof(CharDriverState
));
2726 chr
->chr_write
= null_chr_write
;
2727 chr
->chr_ioctl
= pp_ioctl
;
2728 chr
->chr_close
= pp_close
;
2731 qemu_chr_reset(chr
);
2735 #endif /* __linux__ */
2741 HANDLE hcom
, hrecv
, hsend
;
2742 OVERLAPPED orecv
, osend
;
2747 #define NSENDBUF 2048
2748 #define NRECVBUF 2048
2749 #define MAXCONNECT 1
2750 #define NTIMEOUT 5000
2752 static int win_chr_poll(void *opaque
);
2753 static int win_chr_pipe_poll(void *opaque
);
2755 static void win_chr_close(CharDriverState
*chr
)
2757 WinCharState
*s
= chr
->opaque
;
2760 CloseHandle(s
->hsend
);
2764 CloseHandle(s
->hrecv
);
2768 CloseHandle(s
->hcom
);
2772 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
2774 qemu_del_polling_cb(win_chr_poll
, chr
);
2777 static int win_chr_init(CharDriverState
*chr
, const char *filename
)
2779 WinCharState
*s
= chr
->opaque
;
2781 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
2786 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2788 fprintf(stderr
, "Failed CreateEvent\n");
2791 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2793 fprintf(stderr
, "Failed CreateEvent\n");
2797 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
2798 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
2799 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
2800 fprintf(stderr
, "Failed CreateFile (%lu)\n", GetLastError());
2805 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
2806 fprintf(stderr
, "Failed SetupComm\n");
2810 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
2811 size
= sizeof(COMMCONFIG
);
2812 GetDefaultCommConfig(filename
, &comcfg
, &size
);
2813 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
2814 CommConfigDialog(filename
, NULL
, &comcfg
);
2816 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
2817 fprintf(stderr
, "Failed SetCommState\n");
2821 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
2822 fprintf(stderr
, "Failed SetCommMask\n");
2826 cto
.ReadIntervalTimeout
= MAXDWORD
;
2827 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
2828 fprintf(stderr
, "Failed SetCommTimeouts\n");
2832 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
2833 fprintf(stderr
, "Failed ClearCommError\n");
2836 qemu_add_polling_cb(win_chr_poll
, chr
);
2844 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
2846 WinCharState
*s
= chr
->opaque
;
2847 DWORD len
, ret
, size
, err
;
2850 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
2851 s
->osend
.hEvent
= s
->hsend
;
2854 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
2856 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
2858 err
= GetLastError();
2859 if (err
== ERROR_IO_PENDING
) {
2860 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
2878 static int win_chr_read_poll(CharDriverState
*chr
)
2880 WinCharState
*s
= chr
->opaque
;
2882 s
->max_size
= qemu_chr_can_read(chr
);
2886 static void win_chr_readfile(CharDriverState
*chr
)
2888 WinCharState
*s
= chr
->opaque
;
2893 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
2894 s
->orecv
.hEvent
= s
->hrecv
;
2895 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
2897 err
= GetLastError();
2898 if (err
== ERROR_IO_PENDING
) {
2899 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
2904 qemu_chr_read(chr
, buf
, size
);
2908 static void win_chr_read(CharDriverState
*chr
)
2910 WinCharState
*s
= chr
->opaque
;
2912 if (s
->len
> s
->max_size
)
2913 s
->len
= s
->max_size
;
2917 win_chr_readfile(chr
);
2920 static int win_chr_poll(void *opaque
)
2922 CharDriverState
*chr
= opaque
;
2923 WinCharState
*s
= chr
->opaque
;
2927 ClearCommError(s
->hcom
, &comerr
, &status
);
2928 if (status
.cbInQue
> 0) {
2929 s
->len
= status
.cbInQue
;
2930 win_chr_read_poll(chr
);
2937 static CharDriverState
*qemu_chr_open_win(const char *filename
)
2939 CharDriverState
*chr
;
2942 chr
= qemu_mallocz(sizeof(CharDriverState
));
2945 s
= qemu_mallocz(sizeof(WinCharState
));
2951 chr
->chr_write
= win_chr_write
;
2952 chr
->chr_close
= win_chr_close
;
2954 if (win_chr_init(chr
, filename
) < 0) {
2959 qemu_chr_reset(chr
);
2963 static int win_chr_pipe_poll(void *opaque
)
2965 CharDriverState
*chr
= opaque
;
2966 WinCharState
*s
= chr
->opaque
;
2969 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
2972 win_chr_read_poll(chr
);
2979 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
)
2981 WinCharState
*s
= chr
->opaque
;
2989 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2991 fprintf(stderr
, "Failed CreateEvent\n");
2994 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2996 fprintf(stderr
, "Failed CreateEvent\n");
3000 snprintf(openname
, sizeof(openname
), "\\\\.\\pipe\\%s", filename
);
3001 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
3002 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
3004 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
3005 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3006 fprintf(stderr
, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3011 ZeroMemory(&ov
, sizeof(ov
));
3012 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3013 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
3015 fprintf(stderr
, "Failed ConnectNamedPipe\n");
3019 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
3021 fprintf(stderr
, "Failed GetOverlappedResult\n");
3023 CloseHandle(ov
.hEvent
);
3030 CloseHandle(ov
.hEvent
);
3033 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
3042 static CharDriverState
*qemu_chr_open_win_pipe(const char *filename
)
3044 CharDriverState
*chr
;
3047 chr
= qemu_mallocz(sizeof(CharDriverState
));
3050 s
= qemu_mallocz(sizeof(WinCharState
));
3056 chr
->chr_write
= win_chr_write
;
3057 chr
->chr_close
= win_chr_close
;
3059 if (win_chr_pipe_init(chr
, filename
) < 0) {
3064 qemu_chr_reset(chr
);
3068 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
)
3070 CharDriverState
*chr
;
3073 chr
= qemu_mallocz(sizeof(CharDriverState
));
3076 s
= qemu_mallocz(sizeof(WinCharState
));
3083 chr
->chr_write
= win_chr_write
;
3084 qemu_chr_reset(chr
);
3088 static CharDriverState
*qemu_chr_open_win_con(const char *filename
)
3090 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
));
3093 static CharDriverState
*qemu_chr_open_win_file_out(const char *file_out
)
3097 fd_out
= CreateFile(file_out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
3098 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3099 if (fd_out
== INVALID_HANDLE_VALUE
)
3102 return qemu_chr_open_win_file(fd_out
);
3104 #endif /* !_WIN32 */
3106 /***********************************************************/
3107 /* UDP Net console */
3111 struct sockaddr_in daddr
;
3118 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3120 NetCharDriver
*s
= chr
->opaque
;
3122 return sendto(s
->fd
, buf
, len
, 0,
3123 (struct sockaddr
*)&s
->daddr
, sizeof(struct sockaddr_in
));
3126 static int udp_chr_read_poll(void *opaque
)
3128 CharDriverState
*chr
= opaque
;
3129 NetCharDriver
*s
= chr
->opaque
;
3131 s
->max_size
= qemu_chr_can_read(chr
);
3133 /* If there were any stray characters in the queue process them
3136 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3137 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3139 s
->max_size
= qemu_chr_can_read(chr
);
3144 static void udp_chr_read(void *opaque
)
3146 CharDriverState
*chr
= opaque
;
3147 NetCharDriver
*s
= chr
->opaque
;
3149 if (s
->max_size
== 0)
3151 s
->bufcnt
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
3152 s
->bufptr
= s
->bufcnt
;
3157 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3158 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3160 s
->max_size
= qemu_chr_can_read(chr
);
3164 static void udp_chr_update_read_handler(CharDriverState
*chr
)
3166 NetCharDriver
*s
= chr
->opaque
;
3169 qemu_set_fd_handler2(s
->fd
, udp_chr_read_poll
,
3170 udp_chr_read
, NULL
, chr
);
3174 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
);
3176 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
);
3178 int parse_host_src_port(struct sockaddr_in
*haddr
,
3179 struct sockaddr_in
*saddr
,
3182 static CharDriverState
*qemu_chr_open_udp(const char *def
)
3184 CharDriverState
*chr
= NULL
;
3185 NetCharDriver
*s
= NULL
;
3187 struct sockaddr_in saddr
;
3189 chr
= qemu_mallocz(sizeof(CharDriverState
));
3192 s
= qemu_mallocz(sizeof(NetCharDriver
));
3196 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
3198 perror("socket(PF_INET, SOCK_DGRAM)");
3202 if (parse_host_src_port(&s
->daddr
, &saddr
, def
) < 0) {
3203 printf("Could not parse: %s\n", def
);
3207 if (bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
)) < 0)
3217 chr
->chr_write
= udp_chr_write
;
3218 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
3231 /***********************************************************/
3232 /* TCP Net console */
3243 static void tcp_chr_accept(void *opaque
);
3245 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3247 TCPCharDriver
*s
= chr
->opaque
;
3249 return send_all(s
->fd
, buf
, len
);
3251 /* XXX: indicate an error ? */
3256 static int tcp_chr_read_poll(void *opaque
)
3258 CharDriverState
*chr
= opaque
;
3259 TCPCharDriver
*s
= chr
->opaque
;
3262 s
->max_size
= qemu_chr_can_read(chr
);
3267 #define IAC_BREAK 243
3268 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
3270 uint8_t *buf
, int *size
)
3272 /* Handle any telnet client's basic IAC options to satisfy char by
3273 * char mode with no echo. All IAC options will be removed from
3274 * the buf and the do_telnetopt variable will be used to track the
3275 * state of the width of the IAC information.
3277 * IAC commands come in sets of 3 bytes with the exception of the
3278 * "IAC BREAK" command and the double IAC.
3284 for (i
= 0; i
< *size
; i
++) {
3285 if (s
->do_telnetopt
> 1) {
3286 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
3287 /* Double IAC means send an IAC */
3291 s
->do_telnetopt
= 1;
3293 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
3294 /* Handle IAC break commands by sending a serial break */
3295 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
3300 if (s
->do_telnetopt
>= 4) {
3301 s
->do_telnetopt
= 1;
3304 if ((unsigned char)buf
[i
] == IAC
) {
3305 s
->do_telnetopt
= 2;
3316 static void tcp_chr_read(void *opaque
)
3318 CharDriverState
*chr
= opaque
;
3319 TCPCharDriver
*s
= chr
->opaque
;
3323 if (!s
->connected
|| s
->max_size
<= 0)
3326 if (len
> s
->max_size
)
3328 size
= recv(s
->fd
, buf
, len
, 0);
3330 /* connection closed */
3332 if (s
->listen_fd
>= 0) {
3333 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3335 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
3338 } else if (size
> 0) {
3339 if (s
->do_telnetopt
)
3340 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
3342 qemu_chr_read(chr
, buf
, size
);
3346 static void tcp_chr_connect(void *opaque
)
3348 CharDriverState
*chr
= opaque
;
3349 TCPCharDriver
*s
= chr
->opaque
;
3352 qemu_set_fd_handler2(s
->fd
, tcp_chr_read_poll
,
3353 tcp_chr_read
, NULL
, chr
);
3354 qemu_chr_reset(chr
);
3357 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3358 static void tcp_chr_telnet_init(int fd
)
3361 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3362 IACSET(buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3363 send(fd
, (char *)buf
, 3, 0);
3364 IACSET(buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3365 send(fd
, (char *)buf
, 3, 0);
3366 IACSET(buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3367 send(fd
, (char *)buf
, 3, 0);
3368 IACSET(buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3369 send(fd
, (char *)buf
, 3, 0);
3372 static void socket_set_nodelay(int fd
)
3375 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
3378 static void tcp_chr_accept(void *opaque
)
3380 CharDriverState
*chr
= opaque
;
3381 TCPCharDriver
*s
= chr
->opaque
;
3382 struct sockaddr_in saddr
;
3384 struct sockaddr_un uaddr
;
3386 struct sockaddr
*addr
;
3393 len
= sizeof(uaddr
);
3394 addr
= (struct sockaddr
*)&uaddr
;
3398 len
= sizeof(saddr
);
3399 addr
= (struct sockaddr
*)&saddr
;
3401 fd
= accept(s
->listen_fd
, addr
, &len
);
3402 if (fd
< 0 && errno
!= EINTR
) {
3404 } else if (fd
>= 0) {
3405 if (s
->do_telnetopt
)
3406 tcp_chr_telnet_init(fd
);
3410 socket_set_nonblock(fd
);
3412 socket_set_nodelay(fd
);
3414 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
3415 tcp_chr_connect(chr
);
3418 static void tcp_chr_close(CharDriverState
*chr
)
3420 TCPCharDriver
*s
= chr
->opaque
;
3423 if (s
->listen_fd
>= 0)
3424 closesocket(s
->listen_fd
);
3428 static CharDriverState
*qemu_chr_open_tcp(const char *host_str
,
3432 CharDriverState
*chr
= NULL
;
3433 TCPCharDriver
*s
= NULL
;
3434 int fd
= -1, ret
, err
, val
;
3436 int is_waitconnect
= 1;
3439 struct sockaddr_in saddr
;
3441 struct sockaddr_un uaddr
;
3443 struct sockaddr
*addr
;
3448 addr
= (struct sockaddr
*)&uaddr
;
3449 addrlen
= sizeof(uaddr
);
3450 if (parse_unix_path(&uaddr
, host_str
) < 0)
3455 addr
= (struct sockaddr
*)&saddr
;
3456 addrlen
= sizeof(saddr
);
3457 if (parse_host_port(&saddr
, host_str
) < 0)
3462 while((ptr
= strchr(ptr
,','))) {
3464 if (!strncmp(ptr
,"server",6)) {
3466 } else if (!strncmp(ptr
,"nowait",6)) {
3468 } else if (!strncmp(ptr
,"nodelay",6)) {
3471 printf("Unknown option: %s\n", ptr
);
3478 chr
= qemu_mallocz(sizeof(CharDriverState
));
3481 s
= qemu_mallocz(sizeof(TCPCharDriver
));
3487 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
3490 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
3495 if (!is_waitconnect
)
3496 socket_set_nonblock(fd
);
3501 s
->is_unix
= is_unix
;
3502 s
->do_nodelay
= do_nodelay
&& !is_unix
;
3505 chr
->chr_write
= tcp_chr_write
;
3506 chr
->chr_close
= tcp_chr_close
;
3509 /* allow fast reuse */
3513 pstrcpy(path
, sizeof(path
), uaddr
.sun_path
);
3519 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
3522 ret
= bind(fd
, addr
, addrlen
);
3526 ret
= listen(fd
, 0);
3531 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3533 s
->do_telnetopt
= 1;
3536 ret
= connect(fd
, addr
, addrlen
);
3538 err
= socket_error();
3539 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
3540 } else if (err
== EINPROGRESS
) {
3543 } else if (err
== WSAEALREADY
) {
3555 socket_set_nodelay(fd
);
3557 tcp_chr_connect(chr
);
3559 qemu_set_fd_handler(s
->fd
, NULL
, tcp_chr_connect
, chr
);
3562 if (is_listen
&& is_waitconnect
) {
3563 printf("QEMU waiting for connection on: %s\n", host_str
);
3564 tcp_chr_accept(chr
);
3565 socket_set_nonblock(s
->listen_fd
);
3577 CharDriverState
*qemu_chr_open(const char *filename
)
3581 if (!strcmp(filename
, "vc")) {
3582 return text_console_init(&display_state
, 0);
3583 } else if (strstart(filename
, "vc:", &p
)) {
3584 return text_console_init(&display_state
, p
);
3585 } else if (!strcmp(filename
, "null")) {
3586 return qemu_chr_open_null();
3588 if (strstart(filename
, "tcp:", &p
)) {
3589 return qemu_chr_open_tcp(p
, 0, 0);
3591 if (strstart(filename
, "telnet:", &p
)) {
3592 return qemu_chr_open_tcp(p
, 1, 0);
3594 if (strstart(filename
, "udp:", &p
)) {
3595 return qemu_chr_open_udp(p
);
3597 if (strstart(filename
, "mon:", &p
)) {
3598 CharDriverState
*drv
= qemu_chr_open(p
);
3600 drv
= qemu_chr_open_mux(drv
);
3601 monitor_init(drv
, !nographic
);
3604 printf("Unable to open driver: %s\n", p
);
3608 if (strstart(filename
, "unix:", &p
)) {
3609 return qemu_chr_open_tcp(p
, 0, 1);
3610 } else if (strstart(filename
, "file:", &p
)) {
3611 return qemu_chr_open_file_out(p
);
3612 } else if (strstart(filename
, "pipe:", &p
)) {
3613 return qemu_chr_open_pipe(p
);
3614 } else if (!strcmp(filename
, "pty")) {
3615 return qemu_chr_open_pty();
3616 } else if (!strcmp(filename
, "stdio")) {
3617 return qemu_chr_open_stdio();
3619 #if defined(__linux__)
3620 if (strstart(filename
, "/dev/parport", NULL
)) {
3621 return qemu_chr_open_pp(filename
);
3624 #if defined(__linux__) || defined(__sun__)
3625 if (strstart(filename
, "/dev/", NULL
)) {
3626 return qemu_chr_open_tty(filename
);
3630 if (strstart(filename
, "COM", NULL
)) {
3631 return qemu_chr_open_win(filename
);
3633 if (strstart(filename
, "pipe:", &p
)) {
3634 return qemu_chr_open_win_pipe(p
);
3636 if (strstart(filename
, "con:", NULL
)) {
3637 return qemu_chr_open_win_con(filename
);
3639 if (strstart(filename
, "file:", &p
)) {
3640 return qemu_chr_open_win_file_out(p
);
3643 #ifdef CONFIG_BRLAPI
3644 if (!strcmp(filename
, "braille")) {
3645 return chr_baum_init();
3653 void qemu_chr_close(CharDriverState
*chr
)
3656 chr
->chr_close(chr
);
3660 /***********************************************************/
3661 /* network device redirectors */
3663 __attribute__ (( unused
))
3664 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
3668 for(i
=0;i
<size
;i
+=16) {
3672 fprintf(f
, "%08x ", i
);
3675 fprintf(f
, " %02x", buf
[i
+j
]);
3680 for(j
=0;j
<len
;j
++) {
3682 if (c
< ' ' || c
> '~')
3684 fprintf(f
, "%c", c
);
3690 static int parse_macaddr(uint8_t *macaddr
, const char *p
)
3697 offset
= strtol(p
, &last_char
, 0);
3698 if (0 == errno
&& '\0' == *last_char
&&
3699 offset
>= 0 && offset
<= 0xFFFFFF) {
3700 macaddr
[3] = (offset
& 0xFF0000) >> 16;
3701 macaddr
[4] = (offset
& 0xFF00) >> 8;
3702 macaddr
[5] = offset
& 0xFF;
3705 for(i
= 0; i
< 6; i
++) {
3706 macaddr
[i
] = strtol(p
, (char **)&p
, 16);
3711 if (*p
!= ':' && *p
!= '-')
3722 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
3727 p1
= strchr(p
, sep
);
3733 if (len
> buf_size
- 1)
3735 memcpy(buf
, p
, len
);
3742 int parse_host_src_port(struct sockaddr_in
*haddr
,
3743 struct sockaddr_in
*saddr
,
3744 const char *input_str
)
3746 char *str
= strdup(input_str
);
3747 char *host_str
= str
;
3752 * Chop off any extra arguments at the end of the string which
3753 * would start with a comma, then fill in the src port information
3754 * if it was provided else use the "any address" and "any port".
3756 if ((ptr
= strchr(str
,',')))
3759 if ((src_str
= strchr(input_str
,'@'))) {
3764 if (parse_host_port(haddr
, host_str
) < 0)
3767 if (!src_str
|| *src_str
== '\0')
3770 if (parse_host_port(saddr
, src_str
) < 0)
3781 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
3789 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3791 saddr
->sin_family
= AF_INET
;
3792 if (buf
[0] == '\0') {
3793 saddr
->sin_addr
.s_addr
= 0;
3795 if (isdigit(buf
[0])) {
3796 if (!inet_aton(buf
, &saddr
->sin_addr
))
3799 if ((he
= gethostbyname(buf
)) == NULL
)
3801 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
3804 port
= strtol(p
, (char **)&r
, 0);
3807 saddr
->sin_port
= htons(port
);
3812 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
)
3817 len
= MIN(108, strlen(str
));
3818 p
= strchr(str
, ',');
3820 len
= MIN(len
, p
- str
);
3822 memset(uaddr
, 0, sizeof(*uaddr
));
3824 uaddr
->sun_family
= AF_UNIX
;
3825 memcpy(uaddr
->sun_path
, str
, len
);
3831 /* find or alloc a new VLAN */
3832 VLANState
*qemu_find_vlan(int id
)
3834 VLANState
**pvlan
, *vlan
;
3835 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
3839 vlan
= qemu_mallocz(sizeof(VLANState
));
3844 pvlan
= &first_vlan
;
3845 while (*pvlan
!= NULL
)
3846 pvlan
= &(*pvlan
)->next
;
3851 VLANClientState
*qemu_new_vlan_client(VLANState
*vlan
,
3852 IOReadHandler
*fd_read
,
3853 IOCanRWHandler
*fd_can_read
,
3856 VLANClientState
*vc
, **pvc
;
3857 vc
= qemu_mallocz(sizeof(VLANClientState
));
3860 vc
->fd_read
= fd_read
;
3861 vc
->fd_can_read
= fd_can_read
;
3862 vc
->opaque
= opaque
;
3866 pvc
= &vlan
->first_client
;
3867 while (*pvc
!= NULL
)
3868 pvc
= &(*pvc
)->next
;
3873 int qemu_can_send_packet(VLANClientState
*vc1
)
3875 VLANState
*vlan
= vc1
->vlan
;
3876 VLANClientState
*vc
;
3878 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
3880 if (vc
->fd_can_read
&& vc
->fd_can_read(vc
->opaque
))
3887 void qemu_send_packet(VLANClientState
*vc1
, const uint8_t *buf
, int size
)
3889 VLANState
*vlan
= vc1
->vlan
;
3890 VLANClientState
*vc
;
3893 printf("vlan %d send:\n", vlan
->id
);
3894 hex_dump(stdout
, buf
, size
);
3896 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
3898 vc
->fd_read(vc
->opaque
, buf
, size
);
3903 #if defined(CONFIG_SLIRP)
3905 /* slirp network adapter */
3907 static int slirp_inited
;
3908 static VLANClientState
*slirp_vc
;
3910 int slirp_can_output(void)
3912 return !slirp_vc
|| qemu_can_send_packet(slirp_vc
);
3915 void slirp_output(const uint8_t *pkt
, int pkt_len
)
3918 printf("slirp output:\n");
3919 hex_dump(stdout
, pkt
, pkt_len
);
3923 qemu_send_packet(slirp_vc
, pkt
, pkt_len
);
3926 static void slirp_receive(void *opaque
, const uint8_t *buf
, int size
)
3929 printf("slirp input:\n");
3930 hex_dump(stdout
, buf
, size
);
3932 slirp_input(buf
, size
);
3935 static int net_slirp_init(VLANState
*vlan
)
3937 if (!slirp_inited
) {
3941 slirp_vc
= qemu_new_vlan_client(vlan
,
3942 slirp_receive
, NULL
, NULL
);
3943 snprintf(slirp_vc
->info_str
, sizeof(slirp_vc
->info_str
), "user redirector");
3947 static void net_slirp_redir(const char *redir_str
)
3952 struct in_addr guest_addr
;
3953 int host_port
, guest_port
;
3955 if (!slirp_inited
) {
3961 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3963 if (!strcmp(buf
, "tcp")) {
3965 } else if (!strcmp(buf
, "udp")) {
3971 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3973 host_port
= strtol(buf
, &r
, 0);
3977 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3979 if (buf
[0] == '\0') {
3980 pstrcpy(buf
, sizeof(buf
), "10.0.2.15");
3982 if (!inet_aton(buf
, &guest_addr
))
3985 guest_port
= strtol(p
, &r
, 0);
3989 if (slirp_redir(is_udp
, host_port
, guest_addr
, guest_port
) < 0) {
3990 fprintf(stderr
, "qemu: could not set up redirection\n");
3995 fprintf(stderr
, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4003 static void erase_dir(char *dir_name
)
4007 char filename
[1024];
4009 /* erase all the files in the directory */
4010 if ((d
= opendir(dir_name
)) != 0) {
4015 if (strcmp(de
->d_name
, ".") != 0 &&
4016 strcmp(de
->d_name
, "..") != 0) {
4017 snprintf(filename
, sizeof(filename
), "%s/%s",
4018 smb_dir
, de
->d_name
);
4019 if (unlink(filename
) != 0) /* is it a directory? */
4020 erase_dir(filename
);
4028 /* automatic user mode samba server configuration */
4029 static void smb_exit(void)
4034 /* automatic user mode samba server configuration */
4035 static void net_slirp_smb(const char *exported_dir
)
4037 char smb_conf
[1024];
4038 char smb_cmdline
[1024];
4041 if (!slirp_inited
) {
4046 /* XXX: better tmp dir construction */
4047 snprintf(smb_dir
, sizeof(smb_dir
), "/tmp/qemu-smb.%d", getpid());
4048 if (mkdir(smb_dir
, 0700) < 0) {
4049 fprintf(stderr
, "qemu: could not create samba server dir '%s'\n", smb_dir
);
4052 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", smb_dir
, "smb.conf");
4054 f
= fopen(smb_conf
, "w");
4056 fprintf(stderr
, "qemu: could not create samba server configuration file '%s'\n", smb_conf
);
4063 "socket address=127.0.0.1\n"
4064 "pid directory=%s\n"
4065 "lock directory=%s\n"
4066 "log file=%s/log.smbd\n"
4067 "smb passwd file=%s/smbpasswd\n"
4068 "security = share\n"
4083 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -s %s",
4084 SMBD_COMMAND
, smb_conf
);
4086 slirp_add_exec(0, smb_cmdline
, 4, 139);
4089 #endif /* !defined(_WIN32) */
4090 void do_info_slirp(void)
4095 #endif /* CONFIG_SLIRP */
4097 #if !defined(_WIN32)
4099 typedef struct TAPState
{
4100 VLANClientState
*vc
;
4102 char down_script
[1024];
4105 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
4107 TAPState
*s
= opaque
;
4110 ret
= write(s
->fd
, buf
, size
);
4111 if (ret
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
4118 static void tap_send(void *opaque
)
4120 TAPState
*s
= opaque
;
4127 sbuf
.maxlen
= sizeof(buf
);
4129 size
= getmsg(s
->fd
, NULL
, &sbuf
, &f
) >=0 ? sbuf
.len
: -1;
4131 size
= read(s
->fd
, buf
, sizeof(buf
));
4134 qemu_send_packet(s
->vc
, buf
, size
);
4140 static TAPState
*net_tap_fd_init(VLANState
*vlan
, int fd
)
4144 s
= qemu_mallocz(sizeof(TAPState
));
4148 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
4149 qemu_set_fd_handler(s
->fd
, tap_send
, NULL
, s
);
4150 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "tap: fd=%d", fd
);
4154 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4155 static int tap_open(char *ifname
, int ifname_size
)
4161 TFR(fd
= open("/dev/tap", O_RDWR
));
4163 fprintf(stderr
, "warning: could not open /dev/tap: no virtual network emulation\n");
4168 dev
= devname(s
.st_rdev
, S_IFCHR
);
4169 pstrcpy(ifname
, ifname_size
, dev
);
4171 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4174 #elif defined(__sun__)
4175 #define TUNNEWPPA (('T'<<16) | 0x0001)
4177 * Allocate TAP device, returns opened fd.
4178 * Stores dev name in the first arg(must be large enough).
4180 int tap_alloc(char *dev
)
4182 int tap_fd
, if_fd
, ppa
= -1;
4183 static int ip_fd
= 0;
4186 static int arp_fd
= 0;
4187 int ip_muxid
, arp_muxid
;
4188 struct strioctl strioc_if
, strioc_ppa
;
4189 int link_type
= I_PLINK
;;
4191 char actual_name
[32] = "";
4193 memset(&ifr
, 0x0, sizeof(ifr
));
4197 while( *ptr
&& !isdigit((int)*ptr
) ) ptr
++;
4201 /* Check if IP device was opened */
4205 TFR(ip_fd
= open("/dev/udp", O_RDWR
, 0));
4207 syslog(LOG_ERR
, "Can't open /dev/ip (actually /dev/udp)");
4211 TFR(tap_fd
= open("/dev/tap", O_RDWR
, 0));
4213 syslog(LOG_ERR
, "Can't open /dev/tap");
4217 /* Assign a new PPA and get its unit number. */
4218 strioc_ppa
.ic_cmd
= TUNNEWPPA
;
4219 strioc_ppa
.ic_timout
= 0;
4220 strioc_ppa
.ic_len
= sizeof(ppa
);
4221 strioc_ppa
.ic_dp
= (char *)&ppa
;
4222 if ((ppa
= ioctl (tap_fd
, I_STR
, &strioc_ppa
)) < 0)
4223 syslog (LOG_ERR
, "Can't assign new interface");
4225 TFR(if_fd
= open("/dev/tap", O_RDWR
, 0));
4227 syslog(LOG_ERR
, "Can't open /dev/tap (2)");
4230 if(ioctl(if_fd
, I_PUSH
, "ip") < 0){
4231 syslog(LOG_ERR
, "Can't push IP module");
4235 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) < 0)
4236 syslog(LOG_ERR
, "Can't get flags\n");
4238 snprintf (actual_name
, 32, "tap%d", ppa
);
4239 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4242 /* Assign ppa according to the unit number returned by tun device */
4244 if (ioctl (if_fd
, SIOCSLIFNAME
, &ifr
) < 0)
4245 syslog (LOG_ERR
, "Can't set PPA %d", ppa
);
4246 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) <0)
4247 syslog (LOG_ERR
, "Can't get flags\n");
4248 /* Push arp module to if_fd */
4249 if (ioctl (if_fd
, I_PUSH
, "arp") < 0)
4250 syslog (LOG_ERR
, "Can't push ARP module (2)");
4252 /* Push arp module to ip_fd */
4253 if (ioctl (ip_fd
, I_POP
, NULL
) < 0)
4254 syslog (LOG_ERR
, "I_POP failed\n");
4255 if (ioctl (ip_fd
, I_PUSH
, "arp") < 0)
4256 syslog (LOG_ERR
, "Can't push ARP module (3)\n");
4258 TFR(arp_fd
= open ("/dev/tap", O_RDWR
, 0));
4260 syslog (LOG_ERR
, "Can't open %s\n", "/dev/tap");
4262 /* Set ifname to arp */
4263 strioc_if
.ic_cmd
= SIOCSLIFNAME
;
4264 strioc_if
.ic_timout
= 0;
4265 strioc_if
.ic_len
= sizeof(ifr
);
4266 strioc_if
.ic_dp
= (char *)&ifr
;
4267 if (ioctl(arp_fd
, I_STR
, &strioc_if
) < 0){
4268 syslog (LOG_ERR
, "Can't set ifname to arp\n");
4271 if((ip_muxid
= ioctl(ip_fd
, I_LINK
, if_fd
)) < 0){
4272 syslog(LOG_ERR
, "Can't link TAP device to IP");
4276 if ((arp_muxid
= ioctl (ip_fd
, link_type
, arp_fd
)) < 0)
4277 syslog (LOG_ERR
, "Can't link TAP device to ARP");
4281 memset(&ifr
, 0x0, sizeof(ifr
));
4282 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4283 ifr
.lifr_ip_muxid
= ip_muxid
;
4284 ifr
.lifr_arp_muxid
= arp_muxid
;
4286 if (ioctl (ip_fd
, SIOCSLIFMUXID
, &ifr
) < 0)
4288 ioctl (ip_fd
, I_PUNLINK
, arp_muxid
);
4289 ioctl (ip_fd
, I_PUNLINK
, ip_muxid
);
4290 syslog (LOG_ERR
, "Can't set multiplexor id");
4293 sprintf(dev
, "tap%d", ppa
);
4297 static int tap_open(char *ifname
, int ifname_size
)
4301 if( (fd
= tap_alloc(dev
)) < 0 ){
4302 fprintf(stderr
, "Cannot allocate TAP device\n");
4305 pstrcpy(ifname
, ifname_size
, dev
);
4306 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4310 static int tap_open(char *ifname
, int ifname_size
)
4315 TFR(fd
= open("/dev/net/tun", O_RDWR
));
4317 fprintf(stderr
, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4320 memset(&ifr
, 0, sizeof(ifr
));
4321 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
4322 if (ifname
[0] != '\0')
4323 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, ifname
);
4325 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, "tap%d");
4326 ret
= ioctl(fd
, TUNSETIFF
, (void *) &ifr
);
4328 fprintf(stderr
, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4332 pstrcpy(ifname
, ifname_size
, ifr
.ifr_name
);
4333 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4338 static int launch_script(const char *setup_script
, const char *ifname
, int fd
)
4344 /* try to launch network script */
4348 int open_max
= sysconf (_SC_OPEN_MAX
), i
;
4349 for (i
= 0; i
< open_max
; i
++)
4350 if (i
!= STDIN_FILENO
&&
4351 i
!= STDOUT_FILENO
&&
4352 i
!= STDERR_FILENO
&&
4357 *parg
++ = (char *)setup_script
;
4358 *parg
++ = (char *)ifname
;
4360 execv(setup_script
, args
);
4363 while (waitpid(pid
, &status
, 0) != pid
);
4364 if (!WIFEXITED(status
) ||
4365 WEXITSTATUS(status
) != 0) {
4366 fprintf(stderr
, "%s: could not launch network script\n",
4374 static int net_tap_init(VLANState
*vlan
, const char *ifname1
,
4375 const char *setup_script
, const char *down_script
)
4381 if (ifname1
!= NULL
)
4382 pstrcpy(ifname
, sizeof(ifname
), ifname1
);
4385 TFR(fd
= tap_open(ifname
, sizeof(ifname
)));
4389 if (!setup_script
|| !strcmp(setup_script
, "no"))
4391 if (setup_script
[0] != '\0') {
4392 if (launch_script(setup_script
, ifname
, fd
))
4395 s
= net_tap_fd_init(vlan
, fd
);
4398 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4399 "tap: ifname=%s setup_script=%s", ifname
, setup_script
);
4400 if (down_script
&& strcmp(down_script
, "no"))
4401 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", down_script
);
4405 #endif /* !_WIN32 */
4407 /* network connection */
4408 typedef struct NetSocketState
{
4409 VLANClientState
*vc
;
4411 int state
; /* 0 = getting length, 1 = getting data */
4415 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4418 typedef struct NetSocketListenState
{
4421 } NetSocketListenState
;
4423 /* XXX: we consider we can send the whole packet without blocking */
4424 static void net_socket_receive(void *opaque
, const uint8_t *buf
, int size
)
4426 NetSocketState
*s
= opaque
;
4430 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
4431 send_all(s
->fd
, buf
, size
);
4434 static void net_socket_receive_dgram(void *opaque
, const uint8_t *buf
, int size
)
4436 NetSocketState
*s
= opaque
;
4437 sendto(s
->fd
, buf
, size
, 0,
4438 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
4441 static void net_socket_send(void *opaque
)
4443 NetSocketState
*s
= opaque
;
4448 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
4450 err
= socket_error();
4451 if (err
!= EWOULDBLOCK
)
4453 } else if (size
== 0) {
4454 /* end of connection */
4456 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4462 /* reassemble a packet from the network */
4468 memcpy(s
->buf
+ s
->index
, buf
, l
);
4472 if (s
->index
== 4) {
4474 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
4480 l
= s
->packet_len
- s
->index
;
4483 memcpy(s
->buf
+ s
->index
, buf
, l
);
4487 if (s
->index
>= s
->packet_len
) {
4488 qemu_send_packet(s
->vc
, s
->buf
, s
->packet_len
);
4497 static void net_socket_send_dgram(void *opaque
)
4499 NetSocketState
*s
= opaque
;
4502 size
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
4506 /* end of connection */
4507 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4510 qemu_send_packet(s
->vc
, s
->buf
, size
);
4513 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
)
4518 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
4519 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4520 inet_ntoa(mcastaddr
->sin_addr
),
4521 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
4525 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
4527 perror("socket(PF_INET, SOCK_DGRAM)");
4532 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
4533 (const char *)&val
, sizeof(val
));
4535 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4539 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
4545 /* Add host to multicast group */
4546 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
4547 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
4549 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
4550 (const char *)&imr
, sizeof(struct ip_mreq
));
4552 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4556 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4558 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
4559 (const char *)&val
, sizeof(val
));
4561 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4565 socket_set_nonblock(fd
);
4573 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
, int fd
,
4576 struct sockaddr_in saddr
;
4578 socklen_t saddr_len
;
4581 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4582 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4583 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4587 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
4589 if (saddr
.sin_addr
.s_addr
==0) {
4590 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4594 /* clone dgram socket */
4595 newfd
= net_socket_mcast_create(&saddr
);
4597 /* error already reported by net_socket_mcast_create() */
4601 /* clone newfd to fd, close newfd */
4606 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4607 fd
, strerror(errno
));
4612 s
= qemu_mallocz(sizeof(NetSocketState
));
4617 s
->vc
= qemu_new_vlan_client(vlan
, net_socket_receive_dgram
, NULL
, s
);
4618 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
4620 /* mcast: save bound address as dst */
4621 if (is_connected
) s
->dgram_dst
=saddr
;
4623 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4624 "socket: fd=%d (%s mcast=%s:%d)",
4625 fd
, is_connected
? "cloned" : "",
4626 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4630 static void net_socket_connect(void *opaque
)
4632 NetSocketState
*s
= opaque
;
4633 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
4636 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
, int fd
,
4640 s
= qemu_mallocz(sizeof(NetSocketState
));
4644 s
->vc
= qemu_new_vlan_client(vlan
,
4645 net_socket_receive
, NULL
, s
);
4646 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4647 "socket: fd=%d", fd
);
4649 net_socket_connect(s
);
4651 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
4656 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
, int fd
,
4659 int so_type
=-1, optlen
=sizeof(so_type
);
4661 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
4662 (socklen_t
*)&optlen
)< 0) {
4663 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
4668 return net_socket_fd_init_dgram(vlan
, fd
, is_connected
);
4670 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4672 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4673 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
4674 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4679 static void net_socket_accept(void *opaque
)
4681 NetSocketListenState
*s
= opaque
;
4683 struct sockaddr_in saddr
;
4688 len
= sizeof(saddr
);
4689 fd
= accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
4690 if (fd
< 0 && errno
!= EINTR
) {
4692 } else if (fd
>= 0) {
4696 s1
= net_socket_fd_init(s
->vlan
, fd
, 1);
4700 snprintf(s1
->vc
->info_str
, sizeof(s1
->vc
->info_str
),
4701 "socket: connection from %s:%d",
4702 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4706 static int net_socket_listen_init(VLANState
*vlan
, const char *host_str
)
4708 NetSocketListenState
*s
;
4710 struct sockaddr_in saddr
;
4712 if (parse_host_port(&saddr
, host_str
) < 0)
4715 s
= qemu_mallocz(sizeof(NetSocketListenState
));
4719 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
4724 socket_set_nonblock(fd
);
4726 /* allow fast reuse */
4728 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
4730 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
4735 ret
= listen(fd
, 0);
4742 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
4746 static int net_socket_connect_init(VLANState
*vlan
, const char *host_str
)
4749 int fd
, connected
, ret
, err
;
4750 struct sockaddr_in saddr
;
4752 if (parse_host_port(&saddr
, host_str
) < 0)
4755 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
4760 socket_set_nonblock(fd
);
4764 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
4766 err
= socket_error();
4767 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
4768 } else if (err
== EINPROGRESS
) {
4771 } else if (err
== WSAEALREADY
) {
4784 s
= net_socket_fd_init(vlan
, fd
, connected
);
4787 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4788 "socket: connect to %s:%d",
4789 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4793 static int net_socket_mcast_init(VLANState
*vlan
, const char *host_str
)
4797 struct sockaddr_in saddr
;
4799 if (parse_host_port(&saddr
, host_str
) < 0)
4803 fd
= net_socket_mcast_create(&saddr
);
4807 s
= net_socket_fd_init(vlan
, fd
, 0);
4811 s
->dgram_dst
= saddr
;
4813 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4814 "socket: mcast=%s:%d",
4815 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4820 static const char *get_opt_name(char *buf
, int buf_size
, const char *p
)
4825 while (*p
!= '\0' && *p
!= '=') {
4826 if (q
&& (q
- buf
) < buf_size
- 1)
4836 static const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
4841 while (*p
!= '\0') {
4843 if (*(p
+ 1) != ',')
4847 if (q
&& (q
- buf
) < buf_size
- 1)
4857 static int get_param_value(char *buf
, int buf_size
,
4858 const char *tag
, const char *str
)
4865 p
= get_opt_name(option
, sizeof(option
), p
);
4869 if (!strcmp(tag
, option
)) {
4870 (void)get_opt_value(buf
, buf_size
, p
);
4873 p
= get_opt_value(NULL
, 0, p
);
4882 static int check_params(char *buf
, int buf_size
,
4883 char **params
, const char *str
)
4890 p
= get_opt_name(buf
, buf_size
, p
);
4894 for(i
= 0; params
[i
] != NULL
; i
++)
4895 if (!strcmp(params
[i
], buf
))
4897 if (params
[i
] == NULL
)
4899 p
= get_opt_value(NULL
, 0, p
);
4908 static int net_client_init(const char *str
)
4919 while (*p
!= '\0' && *p
!= ',') {
4920 if ((q
- device
) < sizeof(device
) - 1)
4928 if (get_param_value(buf
, sizeof(buf
), "vlan", p
)) {
4929 vlan_id
= strtol(buf
, NULL
, 0);
4931 vlan
= qemu_find_vlan(vlan_id
);
4933 fprintf(stderr
, "Could not create vlan %d\n", vlan_id
);
4936 if (!strcmp(device
, "nic")) {
4940 if (nb_nics
>= MAX_NICS
) {
4941 fprintf(stderr
, "Too Many NICs\n");
4944 nd
= &nd_table
[nb_nics
];
4945 macaddr
= nd
->macaddr
;
4951 macaddr
[5] = 0x56 + nb_nics
;
4953 if (get_param_value(buf
, sizeof(buf
), "macaddr", p
)) {
4954 if (parse_macaddr(macaddr
, buf
) < 0) {
4955 fprintf(stderr
, "invalid syntax for ethernet address\n");
4959 if (get_param_value(buf
, sizeof(buf
), "model", p
)) {
4960 nd
->model
= strdup(buf
);
4964 vlan
->nb_guest_devs
++;
4967 if (!strcmp(device
, "none")) {
4968 /* does nothing. It is needed to signal that no network cards
4973 if (!strcmp(device
, "user")) {
4974 if (get_param_value(buf
, sizeof(buf
), "hostname", p
)) {
4975 pstrcpy(slirp_hostname
, sizeof(slirp_hostname
), buf
);
4977 vlan
->nb_host_devs
++;
4978 ret
= net_slirp_init(vlan
);
4982 if (!strcmp(device
, "tap")) {
4984 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
4985 fprintf(stderr
, "tap: no interface name\n");
4988 vlan
->nb_host_devs
++;
4989 ret
= tap_win32_init(vlan
, ifname
);
4992 if (!strcmp(device
, "tap")) {
4994 char setup_script
[1024], down_script
[1024];
4996 vlan
->nb_host_devs
++;
4997 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
4998 fd
= strtol(buf
, NULL
, 0);
4999 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
5001 if (net_tap_fd_init(vlan
, fd
))
5004 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5007 if (get_param_value(setup_script
, sizeof(setup_script
), "script", p
) == 0) {
5008 pstrcpy(setup_script
, sizeof(setup_script
), DEFAULT_NETWORK_SCRIPT
);
5010 if (get_param_value(down_script
, sizeof(down_script
), "downscript", p
) == 0) {
5011 pstrcpy(down_script
, sizeof(down_script
), DEFAULT_NETWORK_DOWN_SCRIPT
);
5013 ret
= net_tap_init(vlan
, ifname
, setup_script
, down_script
);
5017 if (!strcmp(device
, "socket")) {
5018 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5020 fd
= strtol(buf
, NULL
, 0);
5022 if (net_socket_fd_init(vlan
, fd
, 1))
5024 } else if (get_param_value(buf
, sizeof(buf
), "listen", p
) > 0) {
5025 ret
= net_socket_listen_init(vlan
, buf
);
5026 } else if (get_param_value(buf
, sizeof(buf
), "connect", p
) > 0) {
5027 ret
= net_socket_connect_init(vlan
, buf
);
5028 } else if (get_param_value(buf
, sizeof(buf
), "mcast", p
) > 0) {
5029 ret
= net_socket_mcast_init(vlan
, buf
);
5031 fprintf(stderr
, "Unknown socket options: %s\n", p
);
5034 vlan
->nb_host_devs
++;
5037 fprintf(stderr
, "Unknown network device: %s\n", device
);
5041 fprintf(stderr
, "Could not initialize device '%s'\n", device
);
5047 void do_info_network(void)
5050 VLANClientState
*vc
;
5052 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5053 term_printf("VLAN %d devices:\n", vlan
->id
);
5054 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
)
5055 term_printf(" %s\n", vc
->info_str
);
5059 #define HD_ALIAS "index=%d,media=disk"
5061 #define CDROM_ALIAS "index=1,media=cdrom"
5063 #define CDROM_ALIAS "index=2,media=cdrom"
5065 #define FD_ALIAS "index=%d,if=floppy"
5066 #define PFLASH_ALIAS "if=pflash"
5067 #define MTD_ALIAS "if=mtd"
5068 #define SD_ALIAS "index=0,if=sd"
5070 static int drive_add(const char *file
, const char *fmt
, ...)
5074 if (nb_drives_opt
>= MAX_DRIVES
) {
5075 fprintf(stderr
, "qemu: too many drives\n");
5079 drives_opt
[nb_drives_opt
].file
= file
;
5081 vsnprintf(drives_opt
[nb_drives_opt
].opt
,
5082 sizeof(drives_opt
[0].opt
), fmt
, ap
);
5085 return nb_drives_opt
++;
5088 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
5092 /* seek interface, bus and unit */
5094 for (index
= 0; index
< nb_drives
; index
++)
5095 if (drives_table
[index
].type
== type
&&
5096 drives_table
[index
].bus
== bus
&&
5097 drives_table
[index
].unit
== unit
)
5103 int drive_get_max_bus(BlockInterfaceType type
)
5109 for (index
= 0; index
< nb_drives
; index
++) {
5110 if(drives_table
[index
].type
== type
&&
5111 drives_table
[index
].bus
> max_bus
)
5112 max_bus
= drives_table
[index
].bus
;
5117 static void bdrv_format_print(void *opaque
, const char *name
)
5119 fprintf(stderr
, " %s", name
);
5122 static int drive_init(struct drive_opt
*arg
, int snapshot
,
5123 QEMUMachine
*machine
)
5128 const char *mediastr
= "";
5129 BlockInterfaceType type
;
5130 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
5131 int bus_id
, unit_id
;
5132 int cyls
, heads
, secs
, translation
;
5133 BlockDriverState
*bdrv
;
5134 BlockDriver
*drv
= NULL
;
5139 char *str
= arg
->opt
;
5140 char *params
[] = { "bus", "unit", "if", "index", "cyls", "heads",
5141 "secs", "trans", "media", "snapshot", "file",
5142 "cache", "format", NULL
};
5144 if (check_params(buf
, sizeof(buf
), params
, str
) < 0) {
5145 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
5151 cyls
= heads
= secs
= 0;
5154 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5158 if (!strcmp(machine
->name
, "realview") ||
5159 !strcmp(machine
->name
, "SS-5") ||
5160 !strcmp(machine
->name
, "SS-10") ||
5161 !strcmp(machine
->name
, "SS-600MP") ||
5162 !strcmp(machine
->name
, "versatilepb") ||
5163 !strcmp(machine
->name
, "versatileab")) {
5165 max_devs
= MAX_SCSI_DEVS
;
5166 strcpy(devname
, "scsi");
5169 max_devs
= MAX_IDE_DEVS
;
5170 strcpy(devname
, "ide");
5174 /* extract parameters */
5176 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
5177 bus_id
= strtol(buf
, NULL
, 0);
5179 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
5184 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
5185 unit_id
= strtol(buf
, NULL
, 0);
5187 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
5192 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
5193 pstrcpy(devname
, sizeof(devname
), buf
);
5194 if (!strcmp(buf
, "ide")) {
5196 max_devs
= MAX_IDE_DEVS
;
5197 } else if (!strcmp(buf
, "scsi")) {
5199 max_devs
= MAX_SCSI_DEVS
;
5200 } else if (!strcmp(buf
, "floppy")) {
5203 } else if (!strcmp(buf
, "pflash")) {
5206 } else if (!strcmp(buf
, "mtd")) {
5209 } else if (!strcmp(buf
, "sd")) {
5213 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
5218 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
5219 index
= strtol(buf
, NULL
, 0);
5221 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
5226 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
5227 cyls
= strtol(buf
, NULL
, 0);
5230 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
5231 heads
= strtol(buf
, NULL
, 0);
5234 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
5235 secs
= strtol(buf
, NULL
, 0);
5238 if (cyls
|| heads
|| secs
) {
5239 if (cyls
< 1 || cyls
> 16383) {
5240 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
5243 if (heads
< 1 || heads
> 16) {
5244 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
5247 if (secs
< 1 || secs
> 63) {
5248 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
5253 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
5256 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5260 if (!strcmp(buf
, "none"))
5261 translation
= BIOS_ATA_TRANSLATION_NONE
;
5262 else if (!strcmp(buf
, "lba"))
5263 translation
= BIOS_ATA_TRANSLATION_LBA
;
5264 else if (!strcmp(buf
, "auto"))
5265 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5267 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
5272 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
5273 if (!strcmp(buf
, "disk")) {
5275 } else if (!strcmp(buf
, "cdrom")) {
5276 if (cyls
|| secs
|| heads
) {
5278 "qemu: '%s' invalid physical CHS format\n", str
);
5281 media
= MEDIA_CDROM
;
5283 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
5288 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
5289 if (!strcmp(buf
, "on"))
5291 else if (!strcmp(buf
, "off"))
5294 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
5299 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
5300 if (!strcmp(buf
, "off"))
5302 else if (!strcmp(buf
, "on"))
5305 fprintf(stderr
, "qemu: invalid cache option\n");
5310 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
5311 if (strcmp(buf
, "?") == 0) {
5312 fprintf(stderr
, "qemu: Supported formats:");
5313 bdrv_iterate_format(bdrv_format_print
, NULL
);
5314 fprintf(stderr
, "\n");
5317 drv
= bdrv_find_format(buf
);
5319 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
5324 if (arg
->file
== NULL
)
5325 get_param_value(file
, sizeof(file
), "file", str
);
5327 pstrcpy(file
, sizeof(file
), arg
->file
);
5329 /* compute bus and unit according index */
5332 if (bus_id
!= 0 || unit_id
!= -1) {
5334 "qemu: '%s' index cannot be used with bus and unit\n", str
);
5342 unit_id
= index
% max_devs
;
5343 bus_id
= index
/ max_devs
;
5347 /* if user doesn't specify a unit_id,
5348 * try to find the first free
5351 if (unit_id
== -1) {
5353 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
5355 if (max_devs
&& unit_id
>= max_devs
) {
5356 unit_id
-= max_devs
;
5364 if (max_devs
&& unit_id
>= max_devs
) {
5365 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
5366 str
, unit_id
, max_devs
- 1);
5371 * ignore multiple definitions
5374 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
5379 if (type
== IF_IDE
|| type
== IF_SCSI
)
5380 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
5382 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
5383 devname
, bus_id
, mediastr
, unit_id
);
5385 snprintf(buf
, sizeof(buf
), "%s%s%i",
5386 devname
, mediastr
, unit_id
);
5387 bdrv
= bdrv_new(buf
);
5388 drives_table
[nb_drives
].bdrv
= bdrv
;
5389 drives_table
[nb_drives
].type
= type
;
5390 drives_table
[nb_drives
].bus
= bus_id
;
5391 drives_table
[nb_drives
].unit
= unit_id
;
5400 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
5401 bdrv_set_translation_hint(bdrv
, translation
);
5405 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
5410 /* FIXME: This isn't really a floppy, but it's a reasonable
5413 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
5423 bdrv_flags
|= BDRV_O_SNAPSHOT
;
5425 bdrv_flags
|= BDRV_O_DIRECT
;
5426 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0 || qemu_key_check(bdrv
, file
)) {
5427 fprintf(stderr
, "qemu: could not open disk image %s\n",
5434 /***********************************************************/
5437 static USBPort
*used_usb_ports
;
5438 static USBPort
*free_usb_ports
;
5440 /* ??? Maybe change this to register a hub to keep track of the topology. */
5441 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
5442 usb_attachfn attach
)
5444 port
->opaque
= opaque
;
5445 port
->index
= index
;
5446 port
->attach
= attach
;
5447 port
->next
= free_usb_ports
;
5448 free_usb_ports
= port
;
5451 static int usb_device_add(const char *devname
)
5457 if (!free_usb_ports
)
5460 if (strstart(devname
, "host:", &p
)) {
5461 dev
= usb_host_device_open(p
);
5462 } else if (!strcmp(devname
, "mouse")) {
5463 dev
= usb_mouse_init();
5464 } else if (!strcmp(devname
, "tablet")) {
5465 dev
= usb_tablet_init();
5466 } else if (!strcmp(devname
, "keyboard")) {
5467 dev
= usb_keyboard_init();
5468 } else if (strstart(devname
, "disk:", &p
)) {
5469 dev
= usb_msd_init(p
);
5470 } else if (!strcmp(devname
, "wacom-tablet")) {
5471 dev
= usb_wacom_init();
5472 } else if (strstart(devname
, "serial:", &p
)) {
5473 dev
= usb_serial_init(p
);
5474 #ifdef CONFIG_BRLAPI
5475 } else if (!strcmp(devname
, "braille")) {
5476 dev
= usb_baum_init();
5484 /* Find a USB port to add the device to. */
5485 port
= free_usb_ports
;
5489 /* Create a new hub and chain it on. */
5490 free_usb_ports
= NULL
;
5491 port
->next
= used_usb_ports
;
5492 used_usb_ports
= port
;
5494 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
5495 usb_attach(port
, hub
);
5496 port
= free_usb_ports
;
5499 free_usb_ports
= port
->next
;
5500 port
->next
= used_usb_ports
;
5501 used_usb_ports
= port
;
5502 usb_attach(port
, dev
);
5506 static int usb_device_del(const char *devname
)
5514 if (!used_usb_ports
)
5517 p
= strchr(devname
, '.');
5520 bus_num
= strtoul(devname
, NULL
, 0);
5521 addr
= strtoul(p
+ 1, NULL
, 0);
5525 lastp
= &used_usb_ports
;
5526 port
= used_usb_ports
;
5527 while (port
&& port
->dev
->addr
!= addr
) {
5528 lastp
= &port
->next
;
5536 *lastp
= port
->next
;
5537 usb_attach(port
, NULL
);
5538 dev
->handle_destroy(dev
);
5539 port
->next
= free_usb_ports
;
5540 free_usb_ports
= port
;
5544 void do_usb_add(const char *devname
)
5547 ret
= usb_device_add(devname
);
5549 term_printf("Could not add USB device '%s'\n", devname
);
5552 void do_usb_del(const char *devname
)
5555 ret
= usb_device_del(devname
);
5557 term_printf("Could not remove USB device '%s'\n", devname
);
5564 const char *speed_str
;
5567 term_printf("USB support not enabled\n");
5571 for (port
= used_usb_ports
; port
; port
= port
->next
) {
5575 switch(dev
->speed
) {
5579 case USB_SPEED_FULL
:
5582 case USB_SPEED_HIGH
:
5589 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5590 0, dev
->addr
, speed_str
, dev
->devname
);
5594 /***********************************************************/
5595 /* PCMCIA/Cardbus */
5597 static struct pcmcia_socket_entry_s
{
5598 struct pcmcia_socket_s
*socket
;
5599 struct pcmcia_socket_entry_s
*next
;
5600 } *pcmcia_sockets
= 0;
5602 void pcmcia_socket_register(struct pcmcia_socket_s
*socket
)
5604 struct pcmcia_socket_entry_s
*entry
;
5606 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
5607 entry
->socket
= socket
;
5608 entry
->next
= pcmcia_sockets
;
5609 pcmcia_sockets
= entry
;
5612 void pcmcia_socket_unregister(struct pcmcia_socket_s
*socket
)
5614 struct pcmcia_socket_entry_s
*entry
, **ptr
;
5616 ptr
= &pcmcia_sockets
;
5617 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
5618 if (entry
->socket
== socket
) {
5624 void pcmcia_info(void)
5626 struct pcmcia_socket_entry_s
*iter
;
5627 if (!pcmcia_sockets
)
5628 term_printf("No PCMCIA sockets\n");
5630 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
5631 term_printf("%s: %s\n", iter
->socket
->slot_string
,
5632 iter
->socket
->attached
? iter
->socket
->card_string
:
5636 /***********************************************************/
5639 static void dumb_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
5643 static void dumb_resize(DisplayState
*ds
, int w
, int h
)
5647 static void dumb_refresh(DisplayState
*ds
)
5649 #if defined(CONFIG_SDL)
5654 static void dumb_display_init(DisplayState
*ds
)
5659 ds
->dpy_update
= dumb_update
;
5660 ds
->dpy_resize
= dumb_resize
;
5661 ds
->dpy_refresh
= dumb_refresh
;
5664 /***********************************************************/
5667 #define MAX_IO_HANDLERS 64
5669 typedef struct IOHandlerRecord
{
5671 IOCanRWHandler
*fd_read_poll
;
5673 IOHandler
*fd_write
;
5676 /* temporary data */
5678 struct IOHandlerRecord
*next
;
5681 static IOHandlerRecord
*first_io_handler
;
5683 /* XXX: fd_read_poll should be suppressed, but an API change is
5684 necessary in the character devices to suppress fd_can_read(). */
5685 int qemu_set_fd_handler2(int fd
,
5686 IOCanRWHandler
*fd_read_poll
,
5688 IOHandler
*fd_write
,
5691 IOHandlerRecord
**pioh
, *ioh
;
5693 if (!fd_read
&& !fd_write
) {
5694 pioh
= &first_io_handler
;
5699 if (ioh
->fd
== fd
) {
5706 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
5710 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
5713 ioh
->next
= first_io_handler
;
5714 first_io_handler
= ioh
;
5717 ioh
->fd_read_poll
= fd_read_poll
;
5718 ioh
->fd_read
= fd_read
;
5719 ioh
->fd_write
= fd_write
;
5720 ioh
->opaque
= opaque
;
5726 int qemu_set_fd_handler(int fd
,
5728 IOHandler
*fd_write
,
5731 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
5734 /***********************************************************/
5735 /* Polling handling */
5737 typedef struct PollingEntry
{
5740 struct PollingEntry
*next
;
5743 static PollingEntry
*first_polling_entry
;
5745 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
5747 PollingEntry
**ppe
, *pe
;
5748 pe
= qemu_mallocz(sizeof(PollingEntry
));
5752 pe
->opaque
= opaque
;
5753 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
5758 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
5760 PollingEntry
**ppe
, *pe
;
5761 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
5763 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
5772 /***********************************************************/
5773 /* Wait objects support */
5774 typedef struct WaitObjects
{
5776 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
5777 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
5778 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
5781 static WaitObjects wait_objects
= {0};
5783 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
5785 WaitObjects
*w
= &wait_objects
;
5787 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
5789 w
->events
[w
->num
] = handle
;
5790 w
->func
[w
->num
] = func
;
5791 w
->opaque
[w
->num
] = opaque
;
5796 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
5799 WaitObjects
*w
= &wait_objects
;
5802 for (i
= 0; i
< w
->num
; i
++) {
5803 if (w
->events
[i
] == handle
)
5806 w
->events
[i
] = w
->events
[i
+ 1];
5807 w
->func
[i
] = w
->func
[i
+ 1];
5808 w
->opaque
[i
] = w
->opaque
[i
+ 1];
5816 /***********************************************************/
5817 /* savevm/loadvm support */
5819 #define IO_BUF_SIZE 32768
5823 BlockDriverState
*bs
;
5826 int64_t base_offset
;
5827 int64_t buf_offset
; /* start of buffer when writing, end of buffer
5830 int buf_size
; /* 0 when writing */
5831 uint8_t buf
[IO_BUF_SIZE
];
5834 QEMUFile
*qemu_fopen(const char *filename
, const char *mode
)
5838 f
= qemu_mallocz(sizeof(QEMUFile
));
5841 if (!strcmp(mode
, "wb")) {
5843 } else if (!strcmp(mode
, "rb")) {
5848 f
->outfile
= fopen(filename
, mode
);
5860 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int64_t offset
, int is_writable
)
5864 f
= qemu_mallocz(sizeof(QEMUFile
));
5869 f
->is_writable
= is_writable
;
5870 f
->base_offset
= offset
;
5874 void qemu_fflush(QEMUFile
*f
)
5876 if (!f
->is_writable
)
5878 if (f
->buf_index
> 0) {
5880 fseek(f
->outfile
, f
->buf_offset
, SEEK_SET
);
5881 fwrite(f
->buf
, 1, f
->buf_index
, f
->outfile
);
5883 bdrv_pwrite(f
->bs
, f
->base_offset
+ f
->buf_offset
,
5884 f
->buf
, f
->buf_index
);
5886 f
->buf_offset
+= f
->buf_index
;
5891 static void qemu_fill_buffer(QEMUFile
*f
)
5898 fseek(f
->outfile
, f
->buf_offset
, SEEK_SET
);
5899 len
= fread(f
->buf
, 1, IO_BUF_SIZE
, f
->outfile
);
5903 len
= bdrv_pread(f
->bs
, f
->base_offset
+ f
->buf_offset
,
5904 f
->buf
, IO_BUF_SIZE
);
5910 f
->buf_offset
+= len
;
5913 void qemu_fclose(QEMUFile
*f
)
5923 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, int size
)
5927 l
= IO_BUF_SIZE
- f
->buf_index
;
5930 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
5934 if (f
->buf_index
>= IO_BUF_SIZE
)
5939 void qemu_put_byte(QEMUFile
*f
, int v
)
5941 f
->buf
[f
->buf_index
++] = v
;
5942 if (f
->buf_index
>= IO_BUF_SIZE
)
5946 int qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, int size1
)
5952 l
= f
->buf_size
- f
->buf_index
;
5954 qemu_fill_buffer(f
);
5955 l
= f
->buf_size
- f
->buf_index
;
5961 memcpy(buf
, f
->buf
+ f
->buf_index
, l
);
5966 return size1
- size
;
5969 int qemu_get_byte(QEMUFile
*f
)
5971 if (f
->buf_index
>= f
->buf_size
) {
5972 qemu_fill_buffer(f
);
5973 if (f
->buf_index
>= f
->buf_size
)
5976 return f
->buf
[f
->buf_index
++];
5979 int64_t qemu_ftell(QEMUFile
*f
)
5981 return f
->buf_offset
- f
->buf_size
+ f
->buf_index
;
5984 int64_t qemu_fseek(QEMUFile
*f
, int64_t pos
, int whence
)
5986 if (whence
== SEEK_SET
) {
5988 } else if (whence
== SEEK_CUR
) {
5989 pos
+= qemu_ftell(f
);
5991 /* SEEK_END not supported */
5994 if (f
->is_writable
) {
5996 f
->buf_offset
= pos
;
5998 f
->buf_offset
= pos
;
6005 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
6007 qemu_put_byte(f
, v
>> 8);
6008 qemu_put_byte(f
, v
);
6011 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
6013 qemu_put_byte(f
, v
>> 24);
6014 qemu_put_byte(f
, v
>> 16);
6015 qemu_put_byte(f
, v
>> 8);
6016 qemu_put_byte(f
, v
);
6019 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
6021 qemu_put_be32(f
, v
>> 32);
6022 qemu_put_be32(f
, v
);
6025 unsigned int qemu_get_be16(QEMUFile
*f
)
6028 v
= qemu_get_byte(f
) << 8;
6029 v
|= qemu_get_byte(f
);
6033 unsigned int qemu_get_be32(QEMUFile
*f
)
6036 v
= qemu_get_byte(f
) << 24;
6037 v
|= qemu_get_byte(f
) << 16;
6038 v
|= qemu_get_byte(f
) << 8;
6039 v
|= qemu_get_byte(f
);
6043 uint64_t qemu_get_be64(QEMUFile
*f
)
6046 v
= (uint64_t)qemu_get_be32(f
) << 32;
6047 v
|= qemu_get_be32(f
);
6051 typedef struct SaveStateEntry
{
6055 SaveStateHandler
*save_state
;
6056 LoadStateHandler
*load_state
;
6058 struct SaveStateEntry
*next
;
6061 static SaveStateEntry
*first_se
;
6063 int register_savevm(const char *idstr
,
6066 SaveStateHandler
*save_state
,
6067 LoadStateHandler
*load_state
,
6070 SaveStateEntry
*se
, **pse
;
6072 se
= qemu_malloc(sizeof(SaveStateEntry
));
6075 pstrcpy(se
->idstr
, sizeof(se
->idstr
), idstr
);
6076 se
->instance_id
= instance_id
;
6077 se
->version_id
= version_id
;
6078 se
->save_state
= save_state
;
6079 se
->load_state
= load_state
;
6080 se
->opaque
= opaque
;
6083 /* add at the end of list */
6085 while (*pse
!= NULL
)
6086 pse
= &(*pse
)->next
;
6091 #define QEMU_VM_FILE_MAGIC 0x5145564d
6092 #define QEMU_VM_FILE_VERSION 0x00000002
6094 static int qemu_savevm_state(QEMUFile
*f
)
6098 int64_t cur_pos
, len_pos
, total_len_pos
;
6100 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
6101 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
6102 total_len_pos
= qemu_ftell(f
);
6103 qemu_put_be64(f
, 0); /* total size */
6105 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6106 if (se
->save_state
== NULL
)
6107 /* this one has a loader only, for backwards compatibility */
6111 len
= strlen(se
->idstr
);
6112 qemu_put_byte(f
, len
);
6113 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6115 qemu_put_be32(f
, se
->instance_id
);
6116 qemu_put_be32(f
, se
->version_id
);
6118 /* record size: filled later */
6119 len_pos
= qemu_ftell(f
);
6120 qemu_put_be32(f
, 0);
6121 se
->save_state(f
, se
->opaque
);
6123 /* fill record size */
6124 cur_pos
= qemu_ftell(f
);
6125 len
= cur_pos
- len_pos
- 4;
6126 qemu_fseek(f
, len_pos
, SEEK_SET
);
6127 qemu_put_be32(f
, len
);
6128 qemu_fseek(f
, cur_pos
, SEEK_SET
);
6130 cur_pos
= qemu_ftell(f
);
6131 qemu_fseek(f
, total_len_pos
, SEEK_SET
);
6132 qemu_put_be64(f
, cur_pos
- total_len_pos
- 8);
6133 qemu_fseek(f
, cur_pos
, SEEK_SET
);
6139 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
6143 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6144 if (!strcmp(se
->idstr
, idstr
) &&
6145 instance_id
== se
->instance_id
)
6151 static int qemu_loadvm_state(QEMUFile
*f
)
6154 int len
, ret
, instance_id
, record_len
, version_id
;
6155 int64_t total_len
, end_pos
, cur_pos
;
6159 v
= qemu_get_be32(f
);
6160 if (v
!= QEMU_VM_FILE_MAGIC
)
6162 v
= qemu_get_be32(f
);
6163 if (v
!= QEMU_VM_FILE_VERSION
) {
6168 total_len
= qemu_get_be64(f
);
6169 end_pos
= total_len
+ qemu_ftell(f
);
6171 if (qemu_ftell(f
) >= end_pos
)
6173 len
= qemu_get_byte(f
);
6174 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6176 instance_id
= qemu_get_be32(f
);
6177 version_id
= qemu_get_be32(f
);
6178 record_len
= qemu_get_be32(f
);
6180 printf("idstr=%s instance=0x%x version=%d len=%d\n",
6181 idstr
, instance_id
, version_id
, record_len
);
6183 cur_pos
= qemu_ftell(f
);
6184 se
= find_se(idstr
, instance_id
);
6186 fprintf(stderr
, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6187 instance_id
, idstr
);
6189 ret
= se
->load_state(f
, se
->opaque
, version_id
);
6191 fprintf(stderr
, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6192 instance_id
, idstr
);
6195 /* always seek to exact end of record */
6196 qemu_fseek(f
, cur_pos
+ record_len
, SEEK_SET
);
6203 /* device can contain snapshots */
6204 static int bdrv_can_snapshot(BlockDriverState
*bs
)
6207 !bdrv_is_removable(bs
) &&
6208 !bdrv_is_read_only(bs
));
6211 /* device must be snapshots in order to have a reliable snapshot */
6212 static int bdrv_has_snapshot(BlockDriverState
*bs
)
6215 !bdrv_is_removable(bs
) &&
6216 !bdrv_is_read_only(bs
));
6219 static BlockDriverState
*get_bs_snapshots(void)
6221 BlockDriverState
*bs
;
6225 return bs_snapshots
;
6226 for(i
= 0; i
<= nb_drives
; i
++) {
6227 bs
= drives_table
[i
].bdrv
;
6228 if (bdrv_can_snapshot(bs
))
6237 static int bdrv_snapshot_find(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
,
6240 QEMUSnapshotInfo
*sn_tab
, *sn
;
6244 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
6247 for(i
= 0; i
< nb_sns
; i
++) {
6249 if (!strcmp(sn
->id_str
, name
) || !strcmp(sn
->name
, name
)) {
6259 void do_savevm(const char *name
)
6261 BlockDriverState
*bs
, *bs1
;
6262 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
6263 int must_delete
, ret
, i
;
6264 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6266 int saved_vm_running
;
6273 bs
= get_bs_snapshots();
6275 term_printf("No block device can accept snapshots\n");
6279 /* ??? Should this occur after vm_stop? */
6282 saved_vm_running
= vm_running
;
6287 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
6292 memset(sn
, 0, sizeof(*sn
));
6294 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
6295 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
6298 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
6301 /* fill auxiliary fields */
6304 sn
->date_sec
= tb
.time
;
6305 sn
->date_nsec
= tb
.millitm
* 1000000;
6307 gettimeofday(&tv
, NULL
);
6308 sn
->date_sec
= tv
.tv_sec
;
6309 sn
->date_nsec
= tv
.tv_usec
* 1000;
6311 sn
->vm_clock_nsec
= qemu_get_clock(vm_clock
);
6313 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
6314 term_printf("Device %s does not support VM state snapshots\n",
6315 bdrv_get_device_name(bs
));
6319 /* save the VM state */
6320 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 1);
6322 term_printf("Could not open VM state file\n");
6325 ret
= qemu_savevm_state(f
);
6326 sn
->vm_state_size
= qemu_ftell(f
);
6329 term_printf("Error %d while writing VM\n", ret
);
6333 /* create the snapshots */
6335 for(i
= 0; i
< nb_drives
; i
++) {
6336 bs1
= drives_table
[i
].bdrv
;
6337 if (bdrv_has_snapshot(bs1
)) {
6339 ret
= bdrv_snapshot_delete(bs1
, old_sn
->id_str
);
6341 term_printf("Error while deleting snapshot on '%s'\n",
6342 bdrv_get_device_name(bs1
));
6345 ret
= bdrv_snapshot_create(bs1
, sn
);
6347 term_printf("Error while creating snapshot on '%s'\n",
6348 bdrv_get_device_name(bs1
));
6354 if (saved_vm_running
)
6358 void do_loadvm(const char *name
)
6360 BlockDriverState
*bs
, *bs1
;
6361 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6364 int saved_vm_running
;
6366 bs
= get_bs_snapshots();
6368 term_printf("No block device supports snapshots\n");
6372 /* Flush all IO requests so they don't interfere with the new state. */
6375 saved_vm_running
= vm_running
;
6378 for(i
= 0; i
<= nb_drives
; i
++) {
6379 bs1
= drives_table
[i
].bdrv
;
6380 if (bdrv_has_snapshot(bs1
)) {
6381 ret
= bdrv_snapshot_goto(bs1
, name
);
6384 term_printf("Warning: ");
6387 term_printf("Snapshots not supported on device '%s'\n",
6388 bdrv_get_device_name(bs1
));
6391 term_printf("Could not find snapshot '%s' on device '%s'\n",
6392 name
, bdrv_get_device_name(bs1
));
6395 term_printf("Error %d while activating snapshot on '%s'\n",
6396 ret
, bdrv_get_device_name(bs1
));
6399 /* fatal on snapshot block device */
6406 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
6407 term_printf("Device %s does not support VM state snapshots\n",
6408 bdrv_get_device_name(bs
));
6412 /* restore the VM state */
6413 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 0);
6415 term_printf("Could not open VM state file\n");
6418 ret
= qemu_loadvm_state(f
);
6421 term_printf("Error %d while loading VM state\n", ret
);
6424 if (saved_vm_running
)
6428 void do_delvm(const char *name
)
6430 BlockDriverState
*bs
, *bs1
;
6433 bs
= get_bs_snapshots();
6435 term_printf("No block device supports snapshots\n");
6439 for(i
= 0; i
<= nb_drives
; i
++) {
6440 bs1
= drives_table
[i
].bdrv
;
6441 if (bdrv_has_snapshot(bs1
)) {
6442 ret
= bdrv_snapshot_delete(bs1
, name
);
6444 if (ret
== -ENOTSUP
)
6445 term_printf("Snapshots not supported on device '%s'\n",
6446 bdrv_get_device_name(bs1
));
6448 term_printf("Error %d while deleting snapshot on '%s'\n",
6449 ret
, bdrv_get_device_name(bs1
));
6455 void do_info_snapshots(void)
6457 BlockDriverState
*bs
, *bs1
;
6458 QEMUSnapshotInfo
*sn_tab
, *sn
;
6462 bs
= get_bs_snapshots();
6464 term_printf("No available block device supports snapshots\n");
6467 term_printf("Snapshot devices:");
6468 for(i
= 0; i
<= nb_drives
; i
++) {
6469 bs1
= drives_table
[i
].bdrv
;
6470 if (bdrv_has_snapshot(bs1
)) {
6472 term_printf(" %s", bdrv_get_device_name(bs1
));
6477 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
6479 term_printf("bdrv_snapshot_list: error %d\n", nb_sns
);
6482 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs
));
6483 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
6484 for(i
= 0; i
< nb_sns
; i
++) {
6486 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
6491 /***********************************************************/
6492 /* ram save/restore */
6494 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
6498 v
= qemu_get_byte(f
);
6501 if (qemu_get_buffer(f
, buf
, len
) != len
)
6505 v
= qemu_get_byte(f
);
6506 memset(buf
, v
, len
);
6514 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
6519 if (qemu_get_be32(f
) != phys_ram_size
)
6521 for(i
= 0; i
< phys_ram_size
; i
+= TARGET_PAGE_SIZE
) {
6522 ret
= ram_get_page(f
, phys_ram_base
+ i
, TARGET_PAGE_SIZE
);
6529 #define BDRV_HASH_BLOCK_SIZE 1024
6530 #define IOBUF_SIZE 4096
6531 #define RAM_CBLOCK_MAGIC 0xfabe
6533 typedef struct RamCompressState
{
6536 uint8_t buf
[IOBUF_SIZE
];
6539 static int ram_compress_open(RamCompressState
*s
, QEMUFile
*f
)
6542 memset(s
, 0, sizeof(*s
));
6544 ret
= deflateInit2(&s
->zstream
, 1,
6546 9, Z_DEFAULT_STRATEGY
);
6549 s
->zstream
.avail_out
= IOBUF_SIZE
;
6550 s
->zstream
.next_out
= s
->buf
;
6554 static void ram_put_cblock(RamCompressState
*s
, const uint8_t *buf
, int len
)
6556 qemu_put_be16(s
->f
, RAM_CBLOCK_MAGIC
);
6557 qemu_put_be16(s
->f
, len
);
6558 qemu_put_buffer(s
->f
, buf
, len
);
6561 static int ram_compress_buf(RamCompressState
*s
, const uint8_t *buf
, int len
)
6565 s
->zstream
.avail_in
= len
;
6566 s
->zstream
.next_in
= (uint8_t *)buf
;
6567 while (s
->zstream
.avail_in
> 0) {
6568 ret
= deflate(&s
->zstream
, Z_NO_FLUSH
);
6571 if (s
->zstream
.avail_out
== 0) {
6572 ram_put_cblock(s
, s
->buf
, IOBUF_SIZE
);
6573 s
->zstream
.avail_out
= IOBUF_SIZE
;
6574 s
->zstream
.next_out
= s
->buf
;
6580 static void ram_compress_close(RamCompressState
*s
)
6584 /* compress last bytes */
6586 ret
= deflate(&s
->zstream
, Z_FINISH
);
6587 if (ret
== Z_OK
|| ret
== Z_STREAM_END
) {
6588 len
= IOBUF_SIZE
- s
->zstream
.avail_out
;
6590 ram_put_cblock(s
, s
->buf
, len
);
6592 s
->zstream
.avail_out
= IOBUF_SIZE
;
6593 s
->zstream
.next_out
= s
->buf
;
6594 if (ret
== Z_STREAM_END
)
6601 deflateEnd(&s
->zstream
);
6604 typedef struct RamDecompressState
{
6607 uint8_t buf
[IOBUF_SIZE
];
6608 } RamDecompressState
;
6610 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
6613 memset(s
, 0, sizeof(*s
));
6615 ret
= inflateInit(&s
->zstream
);
6621 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
6625 s
->zstream
.avail_out
= len
;
6626 s
->zstream
.next_out
= buf
;
6627 while (s
->zstream
.avail_out
> 0) {
6628 if (s
->zstream
.avail_in
== 0) {
6629 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
6631 clen
= qemu_get_be16(s
->f
);
6632 if (clen
> IOBUF_SIZE
)
6634 qemu_get_buffer(s
->f
, s
->buf
, clen
);
6635 s
->zstream
.avail_in
= clen
;
6636 s
->zstream
.next_in
= s
->buf
;
6638 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
6639 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
6646 static void ram_decompress_close(RamDecompressState
*s
)
6648 inflateEnd(&s
->zstream
);
6651 static void ram_save(QEMUFile
*f
, void *opaque
)
6654 RamCompressState s1
, *s
= &s1
;
6657 qemu_put_be32(f
, phys_ram_size
);
6658 if (ram_compress_open(s
, f
) < 0)
6660 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
6662 if (tight_savevm_enabled
) {
6666 /* find if the memory block is available on a virtual
6669 for(j
= 0; j
< nb_drives
; j
++) {
6670 sector_num
= bdrv_hash_find(drives_table
[j
].bdrv
,
6672 BDRV_HASH_BLOCK_SIZE
);
6673 if (sector_num
>= 0)
6677 goto normal_compress
;
6680 cpu_to_be64wu((uint64_t *)(buf
+ 2), sector_num
);
6681 ram_compress_buf(s
, buf
, 10);
6687 ram_compress_buf(s
, buf
, 1);
6688 ram_compress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
);
6691 ram_compress_close(s
);
6694 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
6696 RamDecompressState s1
, *s
= &s1
;
6700 if (version_id
== 1)
6701 return ram_load_v1(f
, opaque
);
6702 if (version_id
!= 2)
6704 if (qemu_get_be32(f
) != phys_ram_size
)
6706 if (ram_decompress_open(s
, f
) < 0)
6708 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
6709 if (ram_decompress_buf(s
, buf
, 1) < 0) {
6710 fprintf(stderr
, "Error while reading ram block header\n");
6714 if (ram_decompress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
) < 0) {
6715 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
6724 ram_decompress_buf(s
, buf
+ 1, 9);
6726 sector_num
= be64_to_cpupu((const uint64_t *)(buf
+ 2));
6727 if (bs_index
>= nb_drives
) {
6728 fprintf(stderr
, "Invalid block device index %d\n", bs_index
);
6731 if (bdrv_read(drives_table
[bs_index
].bdrv
, sector_num
,
6733 BDRV_HASH_BLOCK_SIZE
/ 512) < 0) {
6734 fprintf(stderr
, "Error while reading sector %d:%" PRId64
"\n",
6735 bs_index
, sector_num
);
6742 printf("Error block header\n");
6746 ram_decompress_close(s
);
6750 /***********************************************************/
6751 /* bottom halves (can be seen as timers which expire ASAP) */
6760 static QEMUBH
*first_bh
= NULL
;
6762 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
6765 bh
= qemu_mallocz(sizeof(QEMUBH
));
6769 bh
->opaque
= opaque
;
6773 int qemu_bh_poll(void)
6792 void qemu_bh_schedule(QEMUBH
*bh
)
6794 CPUState
*env
= cpu_single_env
;
6798 bh
->next
= first_bh
;
6801 /* stop the currently executing CPU to execute the BH ASAP */
6803 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
6807 void qemu_bh_cancel(QEMUBH
*bh
)
6810 if (bh
->scheduled
) {
6813 pbh
= &(*pbh
)->next
;
6819 void qemu_bh_delete(QEMUBH
*bh
)
6825 /***********************************************************/
6826 /* machine registration */
6828 QEMUMachine
*first_machine
= NULL
;
6830 int qemu_register_machine(QEMUMachine
*m
)
6833 pm
= &first_machine
;
6841 static QEMUMachine
*find_machine(const char *name
)
6845 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
6846 if (!strcmp(m
->name
, name
))
6852 /***********************************************************/
6853 /* main execution loop */
6855 static void gui_update(void *opaque
)
6857 DisplayState
*ds
= opaque
;
6858 ds
->dpy_refresh(ds
);
6859 qemu_mod_timer(ds
->gui_timer
,
6860 (ds
->gui_timer_interval
?
6861 ds
->gui_timer_interval
:
6862 GUI_REFRESH_INTERVAL
)
6863 + qemu_get_clock(rt_clock
));
6866 struct vm_change_state_entry
{
6867 VMChangeStateHandler
*cb
;
6869 LIST_ENTRY (vm_change_state_entry
) entries
;
6872 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
6874 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
6877 VMChangeStateEntry
*e
;
6879 e
= qemu_mallocz(sizeof (*e
));
6885 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
6889 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
6891 LIST_REMOVE (e
, entries
);
6895 static void vm_state_notify(int running
)
6897 VMChangeStateEntry
*e
;
6899 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
6900 e
->cb(e
->opaque
, running
);
6904 /* XXX: support several handlers */
6905 static VMStopHandler
*vm_stop_cb
;
6906 static void *vm_stop_opaque
;
6908 int qemu_add_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
6911 vm_stop_opaque
= opaque
;
6915 void qemu_del_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
6926 qemu_rearm_alarm_timer(alarm_timer
);
6930 void vm_stop(int reason
)
6933 cpu_disable_ticks();
6937 vm_stop_cb(vm_stop_opaque
, reason
);
6944 /* reset/shutdown handler */
6946 typedef struct QEMUResetEntry
{
6947 QEMUResetHandler
*func
;
6949 struct QEMUResetEntry
*next
;
6952 static QEMUResetEntry
*first_reset_entry
;
6953 static int reset_requested
;
6954 static int shutdown_requested
;
6955 static int powerdown_requested
;
6957 int qemu_shutdown_requested(void)
6959 int r
= shutdown_requested
;
6960 shutdown_requested
= 0;
6964 int qemu_reset_requested(void)
6966 int r
= reset_requested
;
6967 reset_requested
= 0;
6971 int qemu_powerdown_requested(void)
6973 int r
= powerdown_requested
;
6974 powerdown_requested
= 0;
6978 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
6980 QEMUResetEntry
**pre
, *re
;
6982 pre
= &first_reset_entry
;
6983 while (*pre
!= NULL
)
6984 pre
= &(*pre
)->next
;
6985 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
6987 re
->opaque
= opaque
;
6992 void qemu_system_reset(void)
6996 /* reset all devices */
6997 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
6998 re
->func(re
->opaque
);
7002 void qemu_system_reset_request(void)
7005 shutdown_requested
= 1;
7007 reset_requested
= 1;
7010 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7013 void qemu_system_shutdown_request(void)
7015 shutdown_requested
= 1;
7017 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7020 void qemu_system_powerdown_request(void)
7022 powerdown_requested
= 1;
7024 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7027 void main_loop_wait(int timeout
)
7029 IOHandlerRecord
*ioh
;
7030 fd_set rfds
, wfds
, xfds
;
7039 /* XXX: need to suppress polling by better using win32 events */
7041 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
7042 ret
|= pe
->func(pe
->opaque
);
7047 WaitObjects
*w
= &wait_objects
;
7049 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, timeout
);
7050 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
7051 if (w
->func
[ret
- WAIT_OBJECT_0
])
7052 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
7054 /* Check for additional signaled events */
7055 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
7057 /* Check if event is signaled */
7058 ret2
= WaitForSingleObject(w
->events
[i
], 0);
7059 if(ret2
== WAIT_OBJECT_0
) {
7061 w
->func
[i
](w
->opaque
[i
]);
7062 } else if (ret2
== WAIT_TIMEOUT
) {
7064 err
= GetLastError();
7065 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
7068 } else if (ret
== WAIT_TIMEOUT
) {
7070 err
= GetLastError();
7071 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
7075 /* poll any events */
7076 /* XXX: separate device handlers from system ones */
7081 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7085 (!ioh
->fd_read_poll
||
7086 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
7087 FD_SET(ioh
->fd
, &rfds
);
7091 if (ioh
->fd_write
) {
7092 FD_SET(ioh
->fd
, &wfds
);
7102 tv
.tv_usec
= timeout
* 1000;
7104 #if defined(CONFIG_SLIRP)
7106 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
7109 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
7111 IOHandlerRecord
**pioh
;
7113 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7114 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
7115 ioh
->fd_read(ioh
->opaque
);
7117 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
7118 ioh
->fd_write(ioh
->opaque
);
7122 /* remove deleted IO handlers */
7123 pioh
= &first_io_handler
;
7133 #if defined(CONFIG_SLIRP)
7140 slirp_select_poll(&rfds
, &wfds
, &xfds
);
7146 if (likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
7147 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
7148 qemu_get_clock(vm_clock
));
7149 /* run dma transfers, if any */
7153 /* real time timers */
7154 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
7155 qemu_get_clock(rt_clock
));
7157 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
7158 alarm_timer
->flags
&= ~(ALARM_FLAG_EXPIRED
);
7159 qemu_rearm_alarm_timer(alarm_timer
);
7162 /* Check bottom-halves last in case any of the earlier events triggered
7168 static int main_loop(void)
7171 #ifdef CONFIG_PROFILER
7176 cur_cpu
= first_cpu
;
7177 next_cpu
= cur_cpu
->next_cpu
?: first_cpu
;
7184 #ifdef CONFIG_PROFILER
7185 ti
= profile_getclock();
7190 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
7191 env
->icount_decr
.u16
.low
= 0;
7192 env
->icount_extra
= 0;
7193 count
= qemu_next_deadline();
7194 count
= (count
+ (1 << icount_time_shift
) - 1)
7195 >> icount_time_shift
;
7196 qemu_icount
+= count
;
7197 decr
= (count
> 0xffff) ? 0xffff : count
;
7199 env
->icount_decr
.u16
.low
= decr
;
7200 env
->icount_extra
= count
;
7202 ret
= cpu_exec(env
);
7203 #ifdef CONFIG_PROFILER
7204 qemu_time
+= profile_getclock() - ti
;
7207 /* Fold pending instructions back into the
7208 instruction counter, and clear the interrupt flag. */
7209 qemu_icount
-= (env
->icount_decr
.u16
.low
7210 + env
->icount_extra
);
7211 env
->icount_decr
.u32
= 0;
7212 env
->icount_extra
= 0;
7214 next_cpu
= env
->next_cpu
?: first_cpu
;
7215 if (event_pending
&& likely(ret
!= EXCP_DEBUG
)) {
7216 ret
= EXCP_INTERRUPT
;
7220 if (ret
== EXCP_HLT
) {
7221 /* Give the next CPU a chance to run. */
7225 if (ret
!= EXCP_HALTED
)
7227 /* all CPUs are halted ? */
7233 if (shutdown_requested
) {
7234 ret
= EXCP_INTERRUPT
;
7242 if (reset_requested
) {
7243 reset_requested
= 0;
7244 qemu_system_reset();
7245 ret
= EXCP_INTERRUPT
;
7247 if (powerdown_requested
) {
7248 powerdown_requested
= 0;
7249 qemu_system_powerdown();
7250 ret
= EXCP_INTERRUPT
;
7252 if (unlikely(ret
== EXCP_DEBUG
)) {
7253 vm_stop(EXCP_DEBUG
);
7255 /* If all cpus are halted then wait until the next IRQ */
7256 /* XXX: use timeout computed from timers */
7257 if (ret
== EXCP_HALTED
) {
7261 /* Advance virtual time to the next event. */
7262 if (use_icount
== 1) {
7263 /* When not using an adaptive execution frequency
7264 we tend to get badly out of sync with real time,
7265 so just delay for a resonable amount of time. */
7268 delta
= cpu_get_icount() - cpu_get_clock();
7271 /* If virtual time is ahead of real time then just
7273 timeout
= (delta
/ 1000000) + 1;
7275 /* Wait for either IO to occur or the next
7277 add
= qemu_next_deadline();
7278 /* We advance the timer before checking for IO.
7279 Limit the amount we advance so that early IO
7280 activity won't get the guest too far ahead. */
7284 add
= (add
+ (1 << icount_time_shift
) - 1)
7285 >> icount_time_shift
;
7287 timeout
= delta
/ 1000000;
7300 #ifdef CONFIG_PROFILER
7301 ti
= profile_getclock();
7303 main_loop_wait(timeout
);
7304 #ifdef CONFIG_PROFILER
7305 dev_time
+= profile_getclock() - ti
;
7308 cpu_disable_ticks();
7312 static void help(int exitcode
)
7314 printf("QEMU PC emulator version " QEMU_VERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n"
7315 "usage: %s [options] [disk_image]\n"
7317 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7319 "Standard options:\n"
7320 "-M machine select emulated machine (-M ? for list)\n"
7321 "-cpu cpu select CPU (-cpu ? for list)\n"
7322 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7323 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7324 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7325 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7326 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7327 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7328 " [,cache=on|off][,format=f]\n"
7329 " use 'file' as a drive image\n"
7330 "-mtdblock file use 'file' as on-board Flash memory image\n"
7331 "-sd file use 'file' as SecureDigital card image\n"
7332 "-pflash file use 'file' as a parallel flash image\n"
7333 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7334 "-snapshot write to temporary files instead of disk image files\n"
7336 "-no-frame open SDL window without a frame and window decorations\n"
7337 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7338 "-no-quit disable SDL window close capability\n"
7341 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7343 "-m megs set virtual RAM size to megs MB [default=%d]\n"
7344 "-smp n set the number of CPUs to 'n' [default=1]\n"
7345 "-nographic disable graphical output and redirect serial I/Os to console\n"
7346 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7348 "-k language use keyboard layout (for example \"fr\" for French)\n"
7351 "-audio-help print list of audio drivers and their options\n"
7352 "-soundhw c1,... enable audio support\n"
7353 " and only specified sound cards (comma separated list)\n"
7354 " use -soundhw ? to get the list of supported cards\n"
7355 " use -soundhw all to enable all of them\n"
7357 "-localtime set the real time clock to local time [default=utc]\n"
7358 "-full-screen start in full screen\n"
7360 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7362 "-usb enable the USB driver (will be the default soon)\n"
7363 "-usbdevice name add the host or guest USB device 'name'\n"
7364 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7365 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7367 "-name string set the name of the guest\n"
7369 "Network options:\n"
7370 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7371 " create a new Network Interface Card and connect it to VLAN 'n'\n"
7373 "-net user[,vlan=n][,hostname=host]\n"
7374 " connect the user mode network stack to VLAN 'n' and send\n"
7375 " hostname 'host' to DHCP clients\n"
7378 "-net tap[,vlan=n],ifname=name\n"
7379 " connect the host TAP network interface to VLAN 'n'\n"
7381 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7382 " connect the host TAP network interface to VLAN 'n' and use the\n"
7383 " network scripts 'file' (default=%s)\n"
7384 " and 'dfile' (default=%s);\n"
7385 " use '[down]script=no' to disable script execution;\n"
7386 " use 'fd=h' to connect to an already opened TAP interface\n"
7388 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7389 " connect the vlan 'n' to another VLAN using a socket connection\n"
7390 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7391 " connect the vlan 'n' to multicast maddr and port\n"
7392 "-net none use it alone to have zero network devices; if no -net option\n"
7393 " is provided, the default is '-net nic -net user'\n"
7396 "-tftp dir allow tftp access to files in dir [-net user]\n"
7397 "-bootp file advertise file in BOOTP replies\n"
7399 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
7401 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7402 " redirect TCP or UDP connections from host to guest [-net user]\n"
7405 "Linux boot specific:\n"
7406 "-kernel bzImage use 'bzImage' as kernel image\n"
7407 "-append cmdline use 'cmdline' as kernel command line\n"
7408 "-initrd file use 'file' as initial ram disk\n"
7410 "Debug/Expert options:\n"
7411 "-monitor dev redirect the monitor to char device 'dev'\n"
7412 "-serial dev redirect the serial port to char device 'dev'\n"
7413 "-parallel dev redirect the parallel port to char device 'dev'\n"
7414 "-pidfile file Write PID to 'file'\n"
7415 "-S freeze CPU at startup (use 'c' to start execution)\n"
7416 "-s wait gdb connection to port\n"
7417 "-p port set gdb connection port [default=%s]\n"
7418 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
7419 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7420 " translation (t=none or lba) (usually qemu can guess them)\n"
7421 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7423 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7424 "-no-kqemu disable KQEMU kernel module usage\n"
7427 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7428 " (default is CL-GD5446 PCI VGA)\n"
7429 "-no-acpi disable ACPI\n"
7431 #ifdef CONFIG_CURSES
7432 "-curses use a curses/ncurses interface instead of SDL\n"
7434 "-no-reboot exit instead of rebooting\n"
7435 "-no-shutdown stop before shutdown\n"
7436 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
7437 "-vnc display start a VNC server on display\n"
7439 "-daemonize daemonize QEMU after initializing\n"
7441 "-option-rom rom load a file, rom, into the option ROM space\n"
7443 "-prom-env variable=value set OpenBIOS nvram variables\n"
7445 "-clock force the use of the given methods for timer alarm.\n"
7446 " To see what timers are available use -clock ?\n"
7447 "-startdate select initial date of the clock\n"
7448 "-icount [N|auto]\n"
7449 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
7451 "During emulation, the following keys are useful:\n"
7452 "ctrl-alt-f toggle full screen\n"
7453 "ctrl-alt-n switch to virtual console 'n'\n"
7454 "ctrl-alt toggle mouse and keyboard grab\n"
7456 "When using -nographic, press 'ctrl-a h' to get some help.\n"
7461 DEFAULT_NETWORK_SCRIPT
,
7462 DEFAULT_NETWORK_DOWN_SCRIPT
,
7464 DEFAULT_GDBSTUB_PORT
,
7469 #define HAS_ARG 0x0001
7484 QEMU_OPTION_mtdblock
,
7488 QEMU_OPTION_snapshot
,
7490 QEMU_OPTION_no_fd_bootchk
,
7493 QEMU_OPTION_nographic
,
7494 QEMU_OPTION_portrait
,
7496 QEMU_OPTION_audio_help
,
7497 QEMU_OPTION_soundhw
,
7518 QEMU_OPTION_localtime
,
7519 QEMU_OPTION_cirrusvga
,
7522 QEMU_OPTION_std_vga
,
7524 QEMU_OPTION_monitor
,
7526 QEMU_OPTION_parallel
,
7528 QEMU_OPTION_full_screen
,
7529 QEMU_OPTION_no_frame
,
7530 QEMU_OPTION_alt_grab
,
7531 QEMU_OPTION_no_quit
,
7532 QEMU_OPTION_pidfile
,
7533 QEMU_OPTION_no_kqemu
,
7534 QEMU_OPTION_kernel_kqemu
,
7535 QEMU_OPTION_win2k_hack
,
7537 QEMU_OPTION_usbdevice
,
7540 QEMU_OPTION_no_acpi
,
7542 QEMU_OPTION_no_reboot
,
7543 QEMU_OPTION_no_shutdown
,
7544 QEMU_OPTION_show_cursor
,
7545 QEMU_OPTION_daemonize
,
7546 QEMU_OPTION_option_rom
,
7547 QEMU_OPTION_semihosting
,
7549 QEMU_OPTION_prom_env
,
7550 QEMU_OPTION_old_param
,
7552 QEMU_OPTION_startdate
,
7553 QEMU_OPTION_tb_size
,
7557 typedef struct QEMUOption
{
7563 const QEMUOption qemu_options
[] = {
7564 { "h", 0, QEMU_OPTION_h
},
7565 { "help", 0, QEMU_OPTION_h
},
7567 { "M", HAS_ARG
, QEMU_OPTION_M
},
7568 { "cpu", HAS_ARG
, QEMU_OPTION_cpu
},
7569 { "fda", HAS_ARG
, QEMU_OPTION_fda
},
7570 { "fdb", HAS_ARG
, QEMU_OPTION_fdb
},
7571 { "hda", HAS_ARG
, QEMU_OPTION_hda
},
7572 { "hdb", HAS_ARG
, QEMU_OPTION_hdb
},
7573 { "hdc", HAS_ARG
, QEMU_OPTION_hdc
},
7574 { "hdd", HAS_ARG
, QEMU_OPTION_hdd
},
7575 { "drive", HAS_ARG
, QEMU_OPTION_drive
},
7576 { "cdrom", HAS_ARG
, QEMU_OPTION_cdrom
},
7577 { "mtdblock", HAS_ARG
, QEMU_OPTION_mtdblock
},
7578 { "sd", HAS_ARG
, QEMU_OPTION_sd
},
7579 { "pflash", HAS_ARG
, QEMU_OPTION_pflash
},
7580 { "boot", HAS_ARG
, QEMU_OPTION_boot
},
7581 { "snapshot", 0, QEMU_OPTION_snapshot
},
7583 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk
},
7585 { "m", HAS_ARG
, QEMU_OPTION_m
},
7586 { "nographic", 0, QEMU_OPTION_nographic
},
7587 { "portrait", 0, QEMU_OPTION_portrait
},
7588 { "k", HAS_ARG
, QEMU_OPTION_k
},
7590 { "audio-help", 0, QEMU_OPTION_audio_help
},
7591 { "soundhw", HAS_ARG
, QEMU_OPTION_soundhw
},
7594 { "net", HAS_ARG
, QEMU_OPTION_net
},
7596 { "tftp", HAS_ARG
, QEMU_OPTION_tftp
},
7597 { "bootp", HAS_ARG
, QEMU_OPTION_bootp
},
7599 { "smb", HAS_ARG
, QEMU_OPTION_smb
},
7601 { "redir", HAS_ARG
, QEMU_OPTION_redir
},
7604 { "kernel", HAS_ARG
, QEMU_OPTION_kernel
},
7605 { "append", HAS_ARG
, QEMU_OPTION_append
},
7606 { "initrd", HAS_ARG
, QEMU_OPTION_initrd
},
7608 { "S", 0, QEMU_OPTION_S
},
7609 { "s", 0, QEMU_OPTION_s
},
7610 { "p", HAS_ARG
, QEMU_OPTION_p
},
7611 { "d", HAS_ARG
, QEMU_OPTION_d
},
7612 { "hdachs", HAS_ARG
, QEMU_OPTION_hdachs
},
7613 { "L", HAS_ARG
, QEMU_OPTION_L
},
7614 { "bios", HAS_ARG
, QEMU_OPTION_bios
},
7616 { "no-kqemu", 0, QEMU_OPTION_no_kqemu
},
7617 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu
},
7619 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7620 { "g", 1, QEMU_OPTION_g
},
7622 { "localtime", 0, QEMU_OPTION_localtime
},
7623 { "std-vga", 0, QEMU_OPTION_std_vga
},
7624 { "echr", HAS_ARG
, QEMU_OPTION_echr
},
7625 { "monitor", HAS_ARG
, QEMU_OPTION_monitor
},
7626 { "serial", HAS_ARG
, QEMU_OPTION_serial
},
7627 { "parallel", HAS_ARG
, QEMU_OPTION_parallel
},
7628 { "loadvm", HAS_ARG
, QEMU_OPTION_loadvm
},
7629 { "full-screen", 0, QEMU_OPTION_full_screen
},
7631 { "no-frame", 0, QEMU_OPTION_no_frame
},
7632 { "alt-grab", 0, QEMU_OPTION_alt_grab
},
7633 { "no-quit", 0, QEMU_OPTION_no_quit
},
7635 { "pidfile", HAS_ARG
, QEMU_OPTION_pidfile
},
7636 { "win2k-hack", 0, QEMU_OPTION_win2k_hack
},
7637 { "usbdevice", HAS_ARG
, QEMU_OPTION_usbdevice
},
7638 { "smp", HAS_ARG
, QEMU_OPTION_smp
},
7639 { "vnc", HAS_ARG
, QEMU_OPTION_vnc
},
7640 #ifdef CONFIG_CURSES
7641 { "curses", 0, QEMU_OPTION_curses
},
7644 /* temporary options */
7645 { "usb", 0, QEMU_OPTION_usb
},
7646 { "cirrusvga", 0, QEMU_OPTION_cirrusvga
},
7647 { "vmwarevga", 0, QEMU_OPTION_vmsvga
},
7648 { "no-acpi", 0, QEMU_OPTION_no_acpi
},
7649 { "no-reboot", 0, QEMU_OPTION_no_reboot
},
7650 { "no-shutdown", 0, QEMU_OPTION_no_shutdown
},
7651 { "show-cursor", 0, QEMU_OPTION_show_cursor
},
7652 { "daemonize", 0, QEMU_OPTION_daemonize
},
7653 { "option-rom", HAS_ARG
, QEMU_OPTION_option_rom
},
7654 #if defined(TARGET_ARM) || defined(TARGET_M68K)
7655 { "semihosting", 0, QEMU_OPTION_semihosting
},
7657 { "name", HAS_ARG
, QEMU_OPTION_name
},
7658 #if defined(TARGET_SPARC)
7659 { "prom-env", HAS_ARG
, QEMU_OPTION_prom_env
},
7661 #if defined(TARGET_ARM)
7662 { "old-param", 0, QEMU_OPTION_old_param
},
7664 { "clock", HAS_ARG
, QEMU_OPTION_clock
},
7665 { "startdate", HAS_ARG
, QEMU_OPTION_startdate
},
7666 { "tb-size", HAS_ARG
, QEMU_OPTION_tb_size
},
7667 { "icount", HAS_ARG
, QEMU_OPTION_icount
},
7671 /* password input */
7673 int qemu_key_check(BlockDriverState
*bs
, const char *name
)
7678 if (!bdrv_is_encrypted(bs
))
7681 term_printf("%s is encrypted.\n", name
);
7682 for(i
= 0; i
< 3; i
++) {
7683 monitor_readline("Password: ", 1, password
, sizeof(password
));
7684 if (bdrv_set_key(bs
, password
) == 0)
7686 term_printf("invalid password\n");
7691 static BlockDriverState
*get_bdrv(int index
)
7693 if (index
> nb_drives
)
7695 return drives_table
[index
].bdrv
;
7698 static void read_passwords(void)
7700 BlockDriverState
*bs
;
7703 for(i
= 0; i
< 6; i
++) {
7706 qemu_key_check(bs
, bdrv_get_device_name(bs
));
7711 struct soundhw soundhw
[] = {
7712 #ifdef HAS_AUDIO_CHOICE
7713 #if defined(TARGET_I386) || defined(TARGET_MIPS)
7719 { .init_isa
= pcspk_audio_init
}
7724 "Creative Sound Blaster 16",
7727 { .init_isa
= SB16_init
}
7730 #ifdef CONFIG_CS4231A
7736 { .init_isa
= cs4231a_init
}
7744 "Yamaha YMF262 (OPL3)",
7746 "Yamaha YM3812 (OPL2)",
7750 { .init_isa
= Adlib_init
}
7757 "Gravis Ultrasound GF1",
7760 { .init_isa
= GUS_init
}
7767 "Intel 82801AA AC97 Audio",
7770 { .init_pci
= ac97_init
}
7776 "ENSONIQ AudioPCI ES1370",
7779 { .init_pci
= es1370_init
}
7783 { NULL
, NULL
, 0, 0, { NULL
} }
7786 static void select_soundhw (const char *optarg
)
7790 if (*optarg
== '?') {
7793 printf ("Valid sound card names (comma separated):\n");
7794 for (c
= soundhw
; c
->name
; ++c
) {
7795 printf ("%-11s %s\n", c
->name
, c
->descr
);
7797 printf ("\n-soundhw all will enable all of the above\n");
7798 exit (*optarg
!= '?');
7806 if (!strcmp (optarg
, "all")) {
7807 for (c
= soundhw
; c
->name
; ++c
) {
7815 e
= strchr (p
, ',');
7816 l
= !e
? strlen (p
) : (size_t) (e
- p
);
7818 for (c
= soundhw
; c
->name
; ++c
) {
7819 if (!strncmp (c
->name
, p
, l
)) {
7828 "Unknown sound card name (too big to show)\n");
7831 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
7836 p
+= l
+ (e
!= NULL
);
7840 goto show_valid_cards
;
7846 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
7848 exit(STATUS_CONTROL_C_EXIT
);
7853 #define MAX_NET_CLIENTS 32
7855 int main(int argc
, char **argv
)
7857 #ifdef CONFIG_GDBSTUB
7859 const char *gdbstub_port
;
7861 uint32_t boot_devices_bitmap
= 0;
7863 int snapshot
, linux_boot
, net_boot
;
7864 const char *initrd_filename
;
7865 const char *kernel_filename
, *kernel_cmdline
;
7866 const char *boot_devices
= "";
7867 DisplayState
*ds
= &display_state
;
7868 int cyls
, heads
, secs
, translation
;
7869 const char *net_clients
[MAX_NET_CLIENTS
];
7873 const char *r
, *optarg
;
7874 CharDriverState
*monitor_hd
;
7875 const char *monitor_device
;
7876 const char *serial_devices
[MAX_SERIAL_PORTS
];
7877 int serial_device_index
;
7878 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
7879 int parallel_device_index
;
7880 const char *loadvm
= NULL
;
7881 QEMUMachine
*machine
;
7882 const char *cpu_model
;
7883 const char *usb_devices
[MAX_USB_CMDLINE
];
7884 int usb_devices_index
;
7887 const char *pid_file
= NULL
;
7890 LIST_INIT (&vm_change_state_head
);
7893 struct sigaction act
;
7894 sigfillset(&act
.sa_mask
);
7896 act
.sa_handler
= SIG_IGN
;
7897 sigaction(SIGPIPE
, &act
, NULL
);
7900 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
7901 /* Note: cpu_interrupt() is currently not SMP safe, so we force
7902 QEMU to run on a single CPU */
7907 h
= GetCurrentProcess();
7908 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
7909 for(i
= 0; i
< 32; i
++) {
7910 if (mask
& (1 << i
))
7915 SetProcessAffinityMask(h
, mask
);
7921 register_machines();
7922 machine
= first_machine
;
7924 initrd_filename
= NULL
;
7926 vga_ram_size
= VGA_RAM_SIZE
;
7927 #ifdef CONFIG_GDBSTUB
7929 gdbstub_port
= DEFAULT_GDBSTUB_PORT
;
7934 kernel_filename
= NULL
;
7935 kernel_cmdline
= "";
7936 cyls
= heads
= secs
= 0;
7937 translation
= BIOS_ATA_TRANSLATION_AUTO
;
7938 monitor_device
= "vc:800x600";
7940 serial_devices
[0] = "vc:80Cx24C";
7941 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
7942 serial_devices
[i
] = NULL
;
7943 serial_device_index
= 0;
7945 parallel_devices
[0] = "vc:640x480";
7946 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
7947 parallel_devices
[i
] = NULL
;
7948 parallel_device_index
= 0;
7950 usb_devices_index
= 0;
7967 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
7969 const QEMUOption
*popt
;
7972 /* Treat --foo the same as -foo. */
7975 popt
= qemu_options
;
7978 fprintf(stderr
, "%s: invalid option -- '%s'\n",
7982 if (!strcmp(popt
->name
, r
+ 1))
7986 if (popt
->flags
& HAS_ARG
) {
7987 if (optind
>= argc
) {
7988 fprintf(stderr
, "%s: option '%s' requires an argument\n",
7992 optarg
= argv
[optind
++];
7997 switch(popt
->index
) {
7999 machine
= find_machine(optarg
);
8002 printf("Supported machines are:\n");
8003 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
8004 printf("%-10s %s%s\n",
8006 m
== first_machine
? " (default)" : "");
8008 exit(*optarg
!= '?');
8011 case QEMU_OPTION_cpu
:
8012 /* hw initialization will check this */
8013 if (*optarg
== '?') {
8014 /* XXX: implement xxx_cpu_list for targets that still miss it */
8015 #if defined(cpu_list)
8016 cpu_list(stdout
, &fprintf
);
8023 case QEMU_OPTION_initrd
:
8024 initrd_filename
= optarg
;
8026 case QEMU_OPTION_hda
:
8028 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
8030 hda_index
= drive_add(optarg
, HD_ALIAS
8031 ",cyls=%d,heads=%d,secs=%d%s",
8032 0, cyls
, heads
, secs
,
8033 translation
== BIOS_ATA_TRANSLATION_LBA
?
8035 translation
== BIOS_ATA_TRANSLATION_NONE
?
8036 ",trans=none" : "");
8038 case QEMU_OPTION_hdb
:
8039 case QEMU_OPTION_hdc
:
8040 case QEMU_OPTION_hdd
:
8041 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
8043 case QEMU_OPTION_drive
:
8044 drive_add(NULL
, "%s", optarg
);
8046 case QEMU_OPTION_mtdblock
:
8047 drive_add(optarg
, MTD_ALIAS
);
8049 case QEMU_OPTION_sd
:
8050 drive_add(optarg
, SD_ALIAS
);
8052 case QEMU_OPTION_pflash
:
8053 drive_add(optarg
, PFLASH_ALIAS
);
8055 case QEMU_OPTION_snapshot
:
8058 case QEMU_OPTION_hdachs
:
8062 cyls
= strtol(p
, (char **)&p
, 0);
8063 if (cyls
< 1 || cyls
> 16383)
8068 heads
= strtol(p
, (char **)&p
, 0);
8069 if (heads
< 1 || heads
> 16)
8074 secs
= strtol(p
, (char **)&p
, 0);
8075 if (secs
< 1 || secs
> 63)
8079 if (!strcmp(p
, "none"))
8080 translation
= BIOS_ATA_TRANSLATION_NONE
;
8081 else if (!strcmp(p
, "lba"))
8082 translation
= BIOS_ATA_TRANSLATION_LBA
;
8083 else if (!strcmp(p
, "auto"))
8084 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8087 } else if (*p
!= '\0') {
8089 fprintf(stderr
, "qemu: invalid physical CHS format\n");
8092 if (hda_index
!= -1)
8093 snprintf(drives_opt
[hda_index
].opt
,
8094 sizeof(drives_opt
[hda_index
].opt
),
8095 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
8096 0, cyls
, heads
, secs
,
8097 translation
== BIOS_ATA_TRANSLATION_LBA
?
8099 translation
== BIOS_ATA_TRANSLATION_NONE
?
8100 ",trans=none" : "");
8103 case QEMU_OPTION_nographic
:
8104 serial_devices
[0] = "stdio";
8105 parallel_devices
[0] = "null";
8106 monitor_device
= "stdio";
8109 #ifdef CONFIG_CURSES
8110 case QEMU_OPTION_curses
:
8114 case QEMU_OPTION_portrait
:
8117 case QEMU_OPTION_kernel
:
8118 kernel_filename
= optarg
;
8120 case QEMU_OPTION_append
:
8121 kernel_cmdline
= optarg
;
8123 case QEMU_OPTION_cdrom
:
8124 drive_add(optarg
, CDROM_ALIAS
);
8126 case QEMU_OPTION_boot
:
8127 boot_devices
= optarg
;
8128 /* We just do some generic consistency checks */
8130 /* Could easily be extended to 64 devices if needed */
8133 boot_devices_bitmap
= 0;
8134 for (p
= boot_devices
; *p
!= '\0'; p
++) {
8135 /* Allowed boot devices are:
8136 * a b : floppy disk drives
8137 * c ... f : IDE disk drives
8138 * g ... m : machine implementation dependant drives
8139 * n ... p : network devices
8140 * It's up to each machine implementation to check
8141 * if the given boot devices match the actual hardware
8142 * implementation and firmware features.
8144 if (*p
< 'a' || *p
> 'q') {
8145 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
8148 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
8150 "Boot device '%c' was given twice\n",*p
);
8153 boot_devices_bitmap
|= 1 << (*p
- 'a');
8157 case QEMU_OPTION_fda
:
8158 case QEMU_OPTION_fdb
:
8159 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
8162 case QEMU_OPTION_no_fd_bootchk
:
8166 case QEMU_OPTION_net
:
8167 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
8168 fprintf(stderr
, "qemu: too many network clients\n");
8171 net_clients
[nb_net_clients
] = optarg
;
8175 case QEMU_OPTION_tftp
:
8176 tftp_prefix
= optarg
;
8178 case QEMU_OPTION_bootp
:
8179 bootp_filename
= optarg
;
8182 case QEMU_OPTION_smb
:
8183 net_slirp_smb(optarg
);
8186 case QEMU_OPTION_redir
:
8187 net_slirp_redir(optarg
);
8191 case QEMU_OPTION_audio_help
:
8195 case QEMU_OPTION_soundhw
:
8196 select_soundhw (optarg
);
8202 case QEMU_OPTION_m
: {
8206 value
= strtoul(optarg
, &ptr
, 10);
8208 case 0: case 'M': case 'm':
8215 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
8219 /* On 32-bit hosts, QEMU is limited by virtual address space */
8220 if (value
> (2047 << 20)
8222 && HOST_LONG_BITS
== 32
8225 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
8228 if (value
!= (uint64_t)(ram_addr_t
)value
) {
8229 fprintf(stderr
, "qemu: ram size too large\n");
8240 mask
= cpu_str_to_log_mask(optarg
);
8242 printf("Log items (comma separated):\n");
8243 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
8244 printf("%-10s %s\n", item
->name
, item
->help
);
8251 #ifdef CONFIG_GDBSTUB
8256 gdbstub_port
= optarg
;
8262 case QEMU_OPTION_bios
:
8269 keyboard_layout
= optarg
;
8271 case QEMU_OPTION_localtime
:
8274 case QEMU_OPTION_cirrusvga
:
8275 cirrus_vga_enabled
= 1;
8278 case QEMU_OPTION_vmsvga
:
8279 cirrus_vga_enabled
= 0;
8282 case QEMU_OPTION_std_vga
:
8283 cirrus_vga_enabled
= 0;
8291 w
= strtol(p
, (char **)&p
, 10);
8294 fprintf(stderr
, "qemu: invalid resolution or depth\n");
8300 h
= strtol(p
, (char **)&p
, 10);
8305 depth
= strtol(p
, (char **)&p
, 10);
8306 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
8307 depth
!= 24 && depth
!= 32)
8309 } else if (*p
== '\0') {
8310 depth
= graphic_depth
;
8317 graphic_depth
= depth
;
8320 case QEMU_OPTION_echr
:
8323 term_escape_char
= strtol(optarg
, &r
, 0);
8325 printf("Bad argument to echr\n");
8328 case QEMU_OPTION_monitor
:
8329 monitor_device
= optarg
;
8331 case QEMU_OPTION_serial
:
8332 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
8333 fprintf(stderr
, "qemu: too many serial ports\n");
8336 serial_devices
[serial_device_index
] = optarg
;
8337 serial_device_index
++;
8339 case QEMU_OPTION_parallel
:
8340 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
8341 fprintf(stderr
, "qemu: too many parallel ports\n");
8344 parallel_devices
[parallel_device_index
] = optarg
;
8345 parallel_device_index
++;
8347 case QEMU_OPTION_loadvm
:
8350 case QEMU_OPTION_full_screen
:
8354 case QEMU_OPTION_no_frame
:
8357 case QEMU_OPTION_alt_grab
:
8360 case QEMU_OPTION_no_quit
:
8364 case QEMU_OPTION_pidfile
:
8368 case QEMU_OPTION_win2k_hack
:
8369 win2k_install_hack
= 1;
8373 case QEMU_OPTION_no_kqemu
:
8376 case QEMU_OPTION_kernel_kqemu
:
8380 case QEMU_OPTION_usb
:
8383 case QEMU_OPTION_usbdevice
:
8385 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
8386 fprintf(stderr
, "Too many USB devices\n");
8389 usb_devices
[usb_devices_index
] = optarg
;
8390 usb_devices_index
++;
8392 case QEMU_OPTION_smp
:
8393 smp_cpus
= atoi(optarg
);
8394 if (smp_cpus
< 1 || smp_cpus
> MAX_CPUS
) {
8395 fprintf(stderr
, "Invalid number of CPUs\n");
8399 case QEMU_OPTION_vnc
:
8400 vnc_display
= optarg
;
8402 case QEMU_OPTION_no_acpi
:
8405 case QEMU_OPTION_no_reboot
:
8408 case QEMU_OPTION_no_shutdown
:
8411 case QEMU_OPTION_show_cursor
:
8414 case QEMU_OPTION_daemonize
:
8417 case QEMU_OPTION_option_rom
:
8418 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
8419 fprintf(stderr
, "Too many option ROMs\n");
8422 option_rom
[nb_option_roms
] = optarg
;
8425 case QEMU_OPTION_semihosting
:
8426 semihosting_enabled
= 1;
8428 case QEMU_OPTION_name
:
8432 case QEMU_OPTION_prom_env
:
8433 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
8434 fprintf(stderr
, "Too many prom variables\n");
8437 prom_envs
[nb_prom_envs
] = optarg
;
8442 case QEMU_OPTION_old_param
:
8446 case QEMU_OPTION_clock
:
8447 configure_alarms(optarg
);
8449 case QEMU_OPTION_startdate
:
8452 time_t rtc_start_date
;
8453 if (!strcmp(optarg
, "now")) {
8454 rtc_date_offset
= -1;
8456 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
8464 } else if (sscanf(optarg
, "%d-%d-%d",
8467 &tm
.tm_mday
) == 3) {
8476 rtc_start_date
= mktimegm(&tm
);
8477 if (rtc_start_date
== -1) {
8479 fprintf(stderr
, "Invalid date format. Valid format are:\n"
8480 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8483 rtc_date_offset
= time(NULL
) - rtc_start_date
;
8487 case QEMU_OPTION_tb_size
:
8488 tb_size
= strtol(optarg
, NULL
, 0);
8492 case QEMU_OPTION_icount
:
8494 if (strcmp(optarg
, "auto") == 0) {
8495 icount_time_shift
= -1;
8497 icount_time_shift
= strtol(optarg
, NULL
, 0);
8505 if (daemonize
&& !nographic
&& vnc_display
== NULL
) {
8506 fprintf(stderr
, "Can only daemonize if using -nographic or -vnc\n");
8513 if (pipe(fds
) == -1)
8524 len
= read(fds
[0], &status
, 1);
8525 if (len
== -1 && (errno
== EINTR
))
8530 else if (status
== 1) {
8531 fprintf(stderr
, "Could not acquire pidfile\n");
8549 signal(SIGTSTP
, SIG_IGN
);
8550 signal(SIGTTOU
, SIG_IGN
);
8551 signal(SIGTTIN
, SIG_IGN
);
8555 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
8558 write(fds
[1], &status
, 1);
8560 fprintf(stderr
, "Could not acquire pid file\n");
8568 linux_boot
= (kernel_filename
!= NULL
);
8569 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
8571 /* XXX: this should not be: some embedded targets just have flash */
8572 if (!linux_boot
&& net_boot
== 0 &&
8576 /* boot to floppy or the default cd if no hard disk defined yet */
8577 if (!boot_devices
[0]) {
8578 boot_devices
= "cad";
8580 setvbuf(stdout
, NULL
, _IOLBF
, 0);
8585 if (use_icount
&& icount_time_shift
< 0) {
8587 /* 125MIPS seems a reasonable initial guess at the guest speed.
8588 It will be corrected fairly quickly anyway. */
8589 icount_time_shift
= 3;
8590 init_icount_adjust();
8597 /* init network clients */
8598 if (nb_net_clients
== 0) {
8599 /* if no clients, we use a default config */
8600 net_clients
[0] = "nic";
8601 net_clients
[1] = "user";
8605 for(i
= 0;i
< nb_net_clients
; i
++) {
8606 if (net_client_init(net_clients
[i
]) < 0)
8609 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
8610 if (vlan
->nb_guest_devs
== 0 && vlan
->nb_host_devs
== 0)
8612 if (vlan
->nb_guest_devs
== 0) {
8613 fprintf(stderr
, "Invalid vlan (%d) with no nics\n", vlan
->id
);
8616 if (vlan
->nb_host_devs
== 0)
8618 "Warning: vlan %d is not connected to host network\n",
8623 /* XXX: this should be moved in the PC machine instantiation code */
8624 if (net_boot
!= 0) {
8626 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
8627 const char *model
= nd_table
[i
].model
;
8629 if (net_boot
& (1 << i
)) {
8632 snprintf(buf
, sizeof(buf
), "%s/pxe-%s.bin", bios_dir
, model
);
8633 if (get_image_size(buf
) > 0) {
8634 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
8635 fprintf(stderr
, "Too many option ROMs\n");
8638 option_rom
[nb_option_roms
] = strdup(buf
);
8645 fprintf(stderr
, "No valid PXE rom found for network device\n");
8651 /* init the memory */
8652 phys_ram_size
= machine
->ram_require
& ~RAMSIZE_FIXED
;
8654 if (machine
->ram_require
& RAMSIZE_FIXED
) {
8656 if (ram_size
< phys_ram_size
) {
8657 fprintf(stderr
, "Machine `%s' requires %llu bytes of memory\n",
8658 machine
->name
, (unsigned long long) phys_ram_size
);
8662 phys_ram_size
= ram_size
;
8664 ram_size
= phys_ram_size
;
8667 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
8669 phys_ram_size
+= ram_size
;
8672 phys_ram_base
= qemu_vmalloc(phys_ram_size
);
8673 if (!phys_ram_base
) {
8674 fprintf(stderr
, "Could not allocate physical memory\n");
8678 /* init the dynamic translator */
8679 cpu_exec_init_all(tb_size
* 1024 * 1024);
8683 /* we always create the cdrom drive, even if no disk is there */
8685 if (nb_drives_opt
< MAX_DRIVES
)
8686 drive_add(NULL
, CDROM_ALIAS
);
8688 /* we always create at least one floppy */
8690 if (nb_drives_opt
< MAX_DRIVES
)
8691 drive_add(NULL
, FD_ALIAS
, 0);
8693 /* we always create one sd slot, even if no card is in it */
8695 if (nb_drives_opt
< MAX_DRIVES
)
8696 drive_add(NULL
, SD_ALIAS
);
8698 /* open the virtual block devices */
8700 for(i
= 0; i
< nb_drives_opt
; i
++)
8701 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
8704 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
8705 register_savevm("ram", 0, 2, ram_save
, ram_load
, NULL
);
8710 memset(&display_state
, 0, sizeof(display_state
));
8713 fprintf(stderr
, "fatal: -nographic can't be used with -curses\n");
8716 /* nearly nothing to do */
8717 dumb_display_init(ds
);
8718 } else if (vnc_display
!= NULL
) {
8719 vnc_display_init(ds
);
8720 if (vnc_display_open(ds
, vnc_display
) < 0)
8723 #if defined(CONFIG_CURSES)
8725 curses_display_init(ds
, full_screen
);
8729 #if defined(CONFIG_SDL)
8730 sdl_display_init(ds
, full_screen
, no_frame
);
8731 #elif defined(CONFIG_COCOA)
8732 cocoa_display_init(ds
, full_screen
);
8734 dumb_display_init(ds
);
8738 /* Maintain compatibility with multiple stdio monitors */
8739 if (!strcmp(monitor_device
,"stdio")) {
8740 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
8741 const char *devname
= serial_devices
[i
];
8742 if (devname
&& !strcmp(devname
,"mon:stdio")) {
8743 monitor_device
= NULL
;
8745 } else if (devname
&& !strcmp(devname
,"stdio")) {
8746 monitor_device
= NULL
;
8747 serial_devices
[i
] = "mon:stdio";
8752 if (monitor_device
) {
8753 monitor_hd
= qemu_chr_open(monitor_device
);
8755 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
8758 monitor_init(monitor_hd
, !nographic
);
8761 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
8762 const char *devname
= serial_devices
[i
];
8763 if (devname
&& strcmp(devname
, "none")) {
8764 serial_hds
[i
] = qemu_chr_open(devname
);
8765 if (!serial_hds
[i
]) {
8766 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
8770 if (strstart(devname
, "vc", 0))
8771 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
8775 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
8776 const char *devname
= parallel_devices
[i
];
8777 if (devname
&& strcmp(devname
, "none")) {
8778 parallel_hds
[i
] = qemu_chr_open(devname
);
8779 if (!parallel_hds
[i
]) {
8780 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
8784 if (strstart(devname
, "vc", 0))
8785 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
8789 machine
->init(ram_size
, vga_ram_size
, boot_devices
, ds
,
8790 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
8792 /* init USB devices */
8794 for(i
= 0; i
< usb_devices_index
; i
++) {
8795 if (usb_device_add(usb_devices
[i
]) < 0) {
8796 fprintf(stderr
, "Warning: could not add USB device %s\n",
8802 if (display_state
.dpy_refresh
) {
8803 display_state
.gui_timer
= qemu_new_timer(rt_clock
, gui_update
, &display_state
);
8804 qemu_mod_timer(display_state
.gui_timer
, qemu_get_clock(rt_clock
));
8807 #ifdef CONFIG_GDBSTUB
8809 /* XXX: use standard host:port notation and modify options
8811 if (gdbserver_start(gdbstub_port
) < 0) {
8812 fprintf(stderr
, "qemu: could not open gdbstub device on port '%s'\n",
8823 /* XXX: simplify init */
8836 len
= write(fds
[1], &status
, 1);
8837 if (len
== -1 && (errno
== EINTR
))
8843 TFR(fd
= open("/dev/null", O_RDWR
));
8857 #if !defined(_WIN32)
8858 /* close network clients */
8859 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
8860 VLANClientState
*vc
;
8862 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
8863 if (vc
->fd_read
== tap_receive
) {
8865 TAPState
*s
= vc
->opaque
;
8867 if (sscanf(vc
->info_str
, "tap: ifname=%63s ", ifname
) == 1 &&
8869 launch_script(s
->down_script
, ifname
, s
->fd
);