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 instructions to virtual clock ticks. */
243 static int icount_time_shift
;
244 /* Arbitrarily pick 1MIPS as the minimum allowable 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 fairly 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 void qemu_del_vlan_client(VLANClientState
*vc
)
3875 VLANClientState
**pvc
= &vc
->vlan
->first_client
;
3877 while (*pvc
!= NULL
)
3883 pvc
= &(*pvc
)->next
;
3886 int qemu_can_send_packet(VLANClientState
*vc1
)
3888 VLANState
*vlan
= vc1
->vlan
;
3889 VLANClientState
*vc
;
3891 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
3893 if (vc
->fd_can_read
&& vc
->fd_can_read(vc
->opaque
))
3900 void qemu_send_packet(VLANClientState
*vc1
, const uint8_t *buf
, int size
)
3902 VLANState
*vlan
= vc1
->vlan
;
3903 VLANClientState
*vc
;
3906 printf("vlan %d send:\n", vlan
->id
);
3907 hex_dump(stdout
, buf
, size
);
3909 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
3911 vc
->fd_read(vc
->opaque
, buf
, size
);
3916 #if defined(CONFIG_SLIRP)
3918 /* slirp network adapter */
3920 static int slirp_inited
;
3921 static VLANClientState
*slirp_vc
;
3923 int slirp_can_output(void)
3925 return !slirp_vc
|| qemu_can_send_packet(slirp_vc
);
3928 void slirp_output(const uint8_t *pkt
, int pkt_len
)
3931 printf("slirp output:\n");
3932 hex_dump(stdout
, pkt
, pkt_len
);
3936 qemu_send_packet(slirp_vc
, pkt
, pkt_len
);
3939 static void slirp_receive(void *opaque
, const uint8_t *buf
, int size
)
3942 printf("slirp input:\n");
3943 hex_dump(stdout
, buf
, size
);
3945 slirp_input(buf
, size
);
3948 static int net_slirp_init(VLANState
*vlan
)
3950 if (!slirp_inited
) {
3954 slirp_vc
= qemu_new_vlan_client(vlan
,
3955 slirp_receive
, NULL
, NULL
);
3956 snprintf(slirp_vc
->info_str
, sizeof(slirp_vc
->info_str
), "user redirector");
3960 static void net_slirp_redir(const char *redir_str
)
3965 struct in_addr guest_addr
;
3966 int host_port
, guest_port
;
3968 if (!slirp_inited
) {
3974 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3976 if (!strcmp(buf
, "tcp")) {
3978 } else if (!strcmp(buf
, "udp")) {
3984 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3986 host_port
= strtol(buf
, &r
, 0);
3990 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3992 if (buf
[0] == '\0') {
3993 pstrcpy(buf
, sizeof(buf
), "10.0.2.15");
3995 if (!inet_aton(buf
, &guest_addr
))
3998 guest_port
= strtol(p
, &r
, 0);
4002 if (slirp_redir(is_udp
, host_port
, guest_addr
, guest_port
) < 0) {
4003 fprintf(stderr
, "qemu: could not set up redirection\n");
4008 fprintf(stderr
, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4016 static void erase_dir(char *dir_name
)
4020 char filename
[1024];
4022 /* erase all the files in the directory */
4023 if ((d
= opendir(dir_name
)) != 0) {
4028 if (strcmp(de
->d_name
, ".") != 0 &&
4029 strcmp(de
->d_name
, "..") != 0) {
4030 snprintf(filename
, sizeof(filename
), "%s/%s",
4031 smb_dir
, de
->d_name
);
4032 if (unlink(filename
) != 0) /* is it a directory? */
4033 erase_dir(filename
);
4041 /* automatic user mode samba server configuration */
4042 static void smb_exit(void)
4047 /* automatic user mode samba server configuration */
4048 static void net_slirp_smb(const char *exported_dir
)
4050 char smb_conf
[1024];
4051 char smb_cmdline
[1024];
4054 if (!slirp_inited
) {
4059 /* XXX: better tmp dir construction */
4060 snprintf(smb_dir
, sizeof(smb_dir
), "/tmp/qemu-smb.%d", getpid());
4061 if (mkdir(smb_dir
, 0700) < 0) {
4062 fprintf(stderr
, "qemu: could not create samba server dir '%s'\n", smb_dir
);
4065 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", smb_dir
, "smb.conf");
4067 f
= fopen(smb_conf
, "w");
4069 fprintf(stderr
, "qemu: could not create samba server configuration file '%s'\n", smb_conf
);
4076 "socket address=127.0.0.1\n"
4077 "pid directory=%s\n"
4078 "lock directory=%s\n"
4079 "log file=%s/log.smbd\n"
4080 "smb passwd file=%s/smbpasswd\n"
4081 "security = share\n"
4096 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -s %s",
4097 SMBD_COMMAND
, smb_conf
);
4099 slirp_add_exec(0, smb_cmdline
, 4, 139);
4102 #endif /* !defined(_WIN32) */
4103 void do_info_slirp(void)
4108 #endif /* CONFIG_SLIRP */
4110 #if !defined(_WIN32)
4112 typedef struct TAPState
{
4113 VLANClientState
*vc
;
4115 char down_script
[1024];
4118 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
4120 TAPState
*s
= opaque
;
4123 ret
= write(s
->fd
, buf
, size
);
4124 if (ret
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
4131 static void tap_send(void *opaque
)
4133 TAPState
*s
= opaque
;
4140 sbuf
.maxlen
= sizeof(buf
);
4142 size
= getmsg(s
->fd
, NULL
, &sbuf
, &f
) >=0 ? sbuf
.len
: -1;
4144 size
= read(s
->fd
, buf
, sizeof(buf
));
4147 qemu_send_packet(s
->vc
, buf
, size
);
4153 static TAPState
*net_tap_fd_init(VLANState
*vlan
, int fd
)
4157 s
= qemu_mallocz(sizeof(TAPState
));
4161 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
4162 qemu_set_fd_handler(s
->fd
, tap_send
, NULL
, s
);
4163 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "tap: fd=%d", fd
);
4167 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4168 static int tap_open(char *ifname
, int ifname_size
)
4174 TFR(fd
= open("/dev/tap", O_RDWR
));
4176 fprintf(stderr
, "warning: could not open /dev/tap: no virtual network emulation\n");
4181 dev
= devname(s
.st_rdev
, S_IFCHR
);
4182 pstrcpy(ifname
, ifname_size
, dev
);
4184 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4187 #elif defined(__sun__)
4188 #define TUNNEWPPA (('T'<<16) | 0x0001)
4190 * Allocate TAP device, returns opened fd.
4191 * Stores dev name in the first arg(must be large enough).
4193 int tap_alloc(char *dev
)
4195 int tap_fd
, if_fd
, ppa
= -1;
4196 static int ip_fd
= 0;
4199 static int arp_fd
= 0;
4200 int ip_muxid
, arp_muxid
;
4201 struct strioctl strioc_if
, strioc_ppa
;
4202 int link_type
= I_PLINK
;;
4204 char actual_name
[32] = "";
4206 memset(&ifr
, 0x0, sizeof(ifr
));
4210 while( *ptr
&& !isdigit((int)*ptr
) ) ptr
++;
4214 /* Check if IP device was opened */
4218 TFR(ip_fd
= open("/dev/udp", O_RDWR
, 0));
4220 syslog(LOG_ERR
, "Can't open /dev/ip (actually /dev/udp)");
4224 TFR(tap_fd
= open("/dev/tap", O_RDWR
, 0));
4226 syslog(LOG_ERR
, "Can't open /dev/tap");
4230 /* Assign a new PPA and get its unit number. */
4231 strioc_ppa
.ic_cmd
= TUNNEWPPA
;
4232 strioc_ppa
.ic_timout
= 0;
4233 strioc_ppa
.ic_len
= sizeof(ppa
);
4234 strioc_ppa
.ic_dp
= (char *)&ppa
;
4235 if ((ppa
= ioctl (tap_fd
, I_STR
, &strioc_ppa
)) < 0)
4236 syslog (LOG_ERR
, "Can't assign new interface");
4238 TFR(if_fd
= open("/dev/tap", O_RDWR
, 0));
4240 syslog(LOG_ERR
, "Can't open /dev/tap (2)");
4243 if(ioctl(if_fd
, I_PUSH
, "ip") < 0){
4244 syslog(LOG_ERR
, "Can't push IP module");
4248 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) < 0)
4249 syslog(LOG_ERR
, "Can't get flags\n");
4251 snprintf (actual_name
, 32, "tap%d", ppa
);
4252 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4255 /* Assign ppa according to the unit number returned by tun device */
4257 if (ioctl (if_fd
, SIOCSLIFNAME
, &ifr
) < 0)
4258 syslog (LOG_ERR
, "Can't set PPA %d", ppa
);
4259 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) <0)
4260 syslog (LOG_ERR
, "Can't get flags\n");
4261 /* Push arp module to if_fd */
4262 if (ioctl (if_fd
, I_PUSH
, "arp") < 0)
4263 syslog (LOG_ERR
, "Can't push ARP module (2)");
4265 /* Push arp module to ip_fd */
4266 if (ioctl (ip_fd
, I_POP
, NULL
) < 0)
4267 syslog (LOG_ERR
, "I_POP failed\n");
4268 if (ioctl (ip_fd
, I_PUSH
, "arp") < 0)
4269 syslog (LOG_ERR
, "Can't push ARP module (3)\n");
4271 TFR(arp_fd
= open ("/dev/tap", O_RDWR
, 0));
4273 syslog (LOG_ERR
, "Can't open %s\n", "/dev/tap");
4275 /* Set ifname to arp */
4276 strioc_if
.ic_cmd
= SIOCSLIFNAME
;
4277 strioc_if
.ic_timout
= 0;
4278 strioc_if
.ic_len
= sizeof(ifr
);
4279 strioc_if
.ic_dp
= (char *)&ifr
;
4280 if (ioctl(arp_fd
, I_STR
, &strioc_if
) < 0){
4281 syslog (LOG_ERR
, "Can't set ifname to arp\n");
4284 if((ip_muxid
= ioctl(ip_fd
, I_LINK
, if_fd
)) < 0){
4285 syslog(LOG_ERR
, "Can't link TAP device to IP");
4289 if ((arp_muxid
= ioctl (ip_fd
, link_type
, arp_fd
)) < 0)
4290 syslog (LOG_ERR
, "Can't link TAP device to ARP");
4294 memset(&ifr
, 0x0, sizeof(ifr
));
4295 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4296 ifr
.lifr_ip_muxid
= ip_muxid
;
4297 ifr
.lifr_arp_muxid
= arp_muxid
;
4299 if (ioctl (ip_fd
, SIOCSLIFMUXID
, &ifr
) < 0)
4301 ioctl (ip_fd
, I_PUNLINK
, arp_muxid
);
4302 ioctl (ip_fd
, I_PUNLINK
, ip_muxid
);
4303 syslog (LOG_ERR
, "Can't set multiplexor id");
4306 sprintf(dev
, "tap%d", ppa
);
4310 static int tap_open(char *ifname
, int ifname_size
)
4314 if( (fd
= tap_alloc(dev
)) < 0 ){
4315 fprintf(stderr
, "Cannot allocate TAP device\n");
4318 pstrcpy(ifname
, ifname_size
, dev
);
4319 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4323 static int tap_open(char *ifname
, int ifname_size
)
4328 TFR(fd
= open("/dev/net/tun", O_RDWR
));
4330 fprintf(stderr
, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4333 memset(&ifr
, 0, sizeof(ifr
));
4334 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
4335 if (ifname
[0] != '\0')
4336 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, ifname
);
4338 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, "tap%d");
4339 ret
= ioctl(fd
, TUNSETIFF
, (void *) &ifr
);
4341 fprintf(stderr
, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4345 pstrcpy(ifname
, ifname_size
, ifr
.ifr_name
);
4346 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4351 static int launch_script(const char *setup_script
, const char *ifname
, int fd
)
4357 /* try to launch network script */
4361 int open_max
= sysconf (_SC_OPEN_MAX
), i
;
4362 for (i
= 0; i
< open_max
; i
++)
4363 if (i
!= STDIN_FILENO
&&
4364 i
!= STDOUT_FILENO
&&
4365 i
!= STDERR_FILENO
&&
4370 *parg
++ = (char *)setup_script
;
4371 *parg
++ = (char *)ifname
;
4373 execv(setup_script
, args
);
4376 while (waitpid(pid
, &status
, 0) != pid
);
4377 if (!WIFEXITED(status
) ||
4378 WEXITSTATUS(status
) != 0) {
4379 fprintf(stderr
, "%s: could not launch network script\n",
4387 static int net_tap_init(VLANState
*vlan
, const char *ifname1
,
4388 const char *setup_script
, const char *down_script
)
4394 if (ifname1
!= NULL
)
4395 pstrcpy(ifname
, sizeof(ifname
), ifname1
);
4398 TFR(fd
= tap_open(ifname
, sizeof(ifname
)));
4402 if (!setup_script
|| !strcmp(setup_script
, "no"))
4404 if (setup_script
[0] != '\0') {
4405 if (launch_script(setup_script
, ifname
, fd
))
4408 s
= net_tap_fd_init(vlan
, fd
);
4411 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4412 "tap: ifname=%s setup_script=%s", ifname
, setup_script
);
4413 if (down_script
&& strcmp(down_script
, "no"))
4414 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", down_script
);
4418 #endif /* !_WIN32 */
4420 /* network connection */
4421 typedef struct NetSocketState
{
4422 VLANClientState
*vc
;
4424 int state
; /* 0 = getting length, 1 = getting data */
4428 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4431 typedef struct NetSocketListenState
{
4434 } NetSocketListenState
;
4436 /* XXX: we consider we can send the whole packet without blocking */
4437 static void net_socket_receive(void *opaque
, const uint8_t *buf
, int size
)
4439 NetSocketState
*s
= opaque
;
4443 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
4444 send_all(s
->fd
, buf
, size
);
4447 static void net_socket_receive_dgram(void *opaque
, const uint8_t *buf
, int size
)
4449 NetSocketState
*s
= opaque
;
4450 sendto(s
->fd
, buf
, size
, 0,
4451 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
4454 static void net_socket_send(void *opaque
)
4456 NetSocketState
*s
= opaque
;
4461 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
4463 err
= socket_error();
4464 if (err
!= EWOULDBLOCK
)
4466 } else if (size
== 0) {
4467 /* end of connection */
4469 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4475 /* reassemble a packet from the network */
4481 memcpy(s
->buf
+ s
->index
, buf
, l
);
4485 if (s
->index
== 4) {
4487 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
4493 l
= s
->packet_len
- s
->index
;
4496 memcpy(s
->buf
+ s
->index
, buf
, l
);
4500 if (s
->index
>= s
->packet_len
) {
4501 qemu_send_packet(s
->vc
, s
->buf
, s
->packet_len
);
4510 static void net_socket_send_dgram(void *opaque
)
4512 NetSocketState
*s
= opaque
;
4515 size
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
4519 /* end of connection */
4520 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4523 qemu_send_packet(s
->vc
, s
->buf
, size
);
4526 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
)
4531 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
4532 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4533 inet_ntoa(mcastaddr
->sin_addr
),
4534 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
4538 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
4540 perror("socket(PF_INET, SOCK_DGRAM)");
4545 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
4546 (const char *)&val
, sizeof(val
));
4548 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4552 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
4558 /* Add host to multicast group */
4559 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
4560 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
4562 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
4563 (const char *)&imr
, sizeof(struct ip_mreq
));
4565 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4569 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4571 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
4572 (const char *)&val
, sizeof(val
));
4574 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4578 socket_set_nonblock(fd
);
4586 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
, int fd
,
4589 struct sockaddr_in saddr
;
4591 socklen_t saddr_len
;
4594 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4595 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4596 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4600 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
4602 if (saddr
.sin_addr
.s_addr
==0) {
4603 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4607 /* clone dgram socket */
4608 newfd
= net_socket_mcast_create(&saddr
);
4610 /* error already reported by net_socket_mcast_create() */
4614 /* clone newfd to fd, close newfd */
4619 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4620 fd
, strerror(errno
));
4625 s
= qemu_mallocz(sizeof(NetSocketState
));
4630 s
->vc
= qemu_new_vlan_client(vlan
, net_socket_receive_dgram
, NULL
, s
);
4631 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
4633 /* mcast: save bound address as dst */
4634 if (is_connected
) s
->dgram_dst
=saddr
;
4636 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4637 "socket: fd=%d (%s mcast=%s:%d)",
4638 fd
, is_connected
? "cloned" : "",
4639 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4643 static void net_socket_connect(void *opaque
)
4645 NetSocketState
*s
= opaque
;
4646 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
4649 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
, int fd
,
4653 s
= qemu_mallocz(sizeof(NetSocketState
));
4657 s
->vc
= qemu_new_vlan_client(vlan
,
4658 net_socket_receive
, NULL
, s
);
4659 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4660 "socket: fd=%d", fd
);
4662 net_socket_connect(s
);
4664 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
4669 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
, int fd
,
4672 int so_type
=-1, optlen
=sizeof(so_type
);
4674 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
4675 (socklen_t
*)&optlen
)< 0) {
4676 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
4681 return net_socket_fd_init_dgram(vlan
, fd
, is_connected
);
4683 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4685 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4686 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
4687 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4692 static void net_socket_accept(void *opaque
)
4694 NetSocketListenState
*s
= opaque
;
4696 struct sockaddr_in saddr
;
4701 len
= sizeof(saddr
);
4702 fd
= accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
4703 if (fd
< 0 && errno
!= EINTR
) {
4705 } else if (fd
>= 0) {
4709 s1
= net_socket_fd_init(s
->vlan
, fd
, 1);
4713 snprintf(s1
->vc
->info_str
, sizeof(s1
->vc
->info_str
),
4714 "socket: connection from %s:%d",
4715 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4719 static int net_socket_listen_init(VLANState
*vlan
, const char *host_str
)
4721 NetSocketListenState
*s
;
4723 struct sockaddr_in saddr
;
4725 if (parse_host_port(&saddr
, host_str
) < 0)
4728 s
= qemu_mallocz(sizeof(NetSocketListenState
));
4732 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
4737 socket_set_nonblock(fd
);
4739 /* allow fast reuse */
4741 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
4743 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
4748 ret
= listen(fd
, 0);
4755 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
4759 static int net_socket_connect_init(VLANState
*vlan
, const char *host_str
)
4762 int fd
, connected
, ret
, err
;
4763 struct sockaddr_in saddr
;
4765 if (parse_host_port(&saddr
, host_str
) < 0)
4768 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
4773 socket_set_nonblock(fd
);
4777 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
4779 err
= socket_error();
4780 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
4781 } else if (err
== EINPROGRESS
) {
4784 } else if (err
== WSAEALREADY
) {
4797 s
= net_socket_fd_init(vlan
, fd
, connected
);
4800 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4801 "socket: connect to %s:%d",
4802 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4806 static int net_socket_mcast_init(VLANState
*vlan
, const char *host_str
)
4810 struct sockaddr_in saddr
;
4812 if (parse_host_port(&saddr
, host_str
) < 0)
4816 fd
= net_socket_mcast_create(&saddr
);
4820 s
= net_socket_fd_init(vlan
, fd
, 0);
4824 s
->dgram_dst
= saddr
;
4826 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4827 "socket: mcast=%s:%d",
4828 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4833 static const char *get_opt_name(char *buf
, int buf_size
, const char *p
)
4838 while (*p
!= '\0' && *p
!= '=') {
4839 if (q
&& (q
- buf
) < buf_size
- 1)
4849 static const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
4854 while (*p
!= '\0') {
4856 if (*(p
+ 1) != ',')
4860 if (q
&& (q
- buf
) < buf_size
- 1)
4870 static int get_param_value(char *buf
, int buf_size
,
4871 const char *tag
, const char *str
)
4878 p
= get_opt_name(option
, sizeof(option
), p
);
4882 if (!strcmp(tag
, option
)) {
4883 (void)get_opt_value(buf
, buf_size
, p
);
4886 p
= get_opt_value(NULL
, 0, p
);
4895 static int check_params(char *buf
, int buf_size
,
4896 char **params
, const char *str
)
4903 p
= get_opt_name(buf
, buf_size
, p
);
4907 for(i
= 0; params
[i
] != NULL
; i
++)
4908 if (!strcmp(params
[i
], buf
))
4910 if (params
[i
] == NULL
)
4912 p
= get_opt_value(NULL
, 0, p
);
4921 static int net_client_init(const char *str
)
4932 while (*p
!= '\0' && *p
!= ',') {
4933 if ((q
- device
) < sizeof(device
) - 1)
4941 if (get_param_value(buf
, sizeof(buf
), "vlan", p
)) {
4942 vlan_id
= strtol(buf
, NULL
, 0);
4944 vlan
= qemu_find_vlan(vlan_id
);
4946 fprintf(stderr
, "Could not create vlan %d\n", vlan_id
);
4949 if (!strcmp(device
, "nic")) {
4953 if (nb_nics
>= MAX_NICS
) {
4954 fprintf(stderr
, "Too Many NICs\n");
4957 nd
= &nd_table
[nb_nics
];
4958 macaddr
= nd
->macaddr
;
4964 macaddr
[5] = 0x56 + nb_nics
;
4966 if (get_param_value(buf
, sizeof(buf
), "macaddr", p
)) {
4967 if (parse_macaddr(macaddr
, buf
) < 0) {
4968 fprintf(stderr
, "invalid syntax for ethernet address\n");
4972 if (get_param_value(buf
, sizeof(buf
), "model", p
)) {
4973 nd
->model
= strdup(buf
);
4977 vlan
->nb_guest_devs
++;
4980 if (!strcmp(device
, "none")) {
4981 /* does nothing. It is needed to signal that no network cards
4986 if (!strcmp(device
, "user")) {
4987 if (get_param_value(buf
, sizeof(buf
), "hostname", p
)) {
4988 pstrcpy(slirp_hostname
, sizeof(slirp_hostname
), buf
);
4990 vlan
->nb_host_devs
++;
4991 ret
= net_slirp_init(vlan
);
4995 if (!strcmp(device
, "tap")) {
4997 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
4998 fprintf(stderr
, "tap: no interface name\n");
5001 vlan
->nb_host_devs
++;
5002 ret
= tap_win32_init(vlan
, ifname
);
5005 if (!strcmp(device
, "tap")) {
5007 char setup_script
[1024], down_script
[1024];
5009 vlan
->nb_host_devs
++;
5010 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5011 fd
= strtol(buf
, NULL
, 0);
5012 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
5014 if (net_tap_fd_init(vlan
, fd
))
5017 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5020 if (get_param_value(setup_script
, sizeof(setup_script
), "script", p
) == 0) {
5021 pstrcpy(setup_script
, sizeof(setup_script
), DEFAULT_NETWORK_SCRIPT
);
5023 if (get_param_value(down_script
, sizeof(down_script
), "downscript", p
) == 0) {
5024 pstrcpy(down_script
, sizeof(down_script
), DEFAULT_NETWORK_DOWN_SCRIPT
);
5026 ret
= net_tap_init(vlan
, ifname
, setup_script
, down_script
);
5030 if (!strcmp(device
, "socket")) {
5031 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5033 fd
= strtol(buf
, NULL
, 0);
5035 if (net_socket_fd_init(vlan
, fd
, 1))
5037 } else if (get_param_value(buf
, sizeof(buf
), "listen", p
) > 0) {
5038 ret
= net_socket_listen_init(vlan
, buf
);
5039 } else if (get_param_value(buf
, sizeof(buf
), "connect", p
) > 0) {
5040 ret
= net_socket_connect_init(vlan
, buf
);
5041 } else if (get_param_value(buf
, sizeof(buf
), "mcast", p
) > 0) {
5042 ret
= net_socket_mcast_init(vlan
, buf
);
5044 fprintf(stderr
, "Unknown socket options: %s\n", p
);
5047 vlan
->nb_host_devs
++;
5050 fprintf(stderr
, "Unknown network device: %s\n", device
);
5054 fprintf(stderr
, "Could not initialize device '%s'\n", device
);
5060 void do_info_network(void)
5063 VLANClientState
*vc
;
5065 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5066 term_printf("VLAN %d devices:\n", vlan
->id
);
5067 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
)
5068 term_printf(" %s\n", vc
->info_str
);
5072 #define HD_ALIAS "index=%d,media=disk"
5074 #define CDROM_ALIAS "index=1,media=cdrom"
5076 #define CDROM_ALIAS "index=2,media=cdrom"
5078 #define FD_ALIAS "index=%d,if=floppy"
5079 #define PFLASH_ALIAS "if=pflash"
5080 #define MTD_ALIAS "if=mtd"
5081 #define SD_ALIAS "index=0,if=sd"
5083 static int drive_add(const char *file
, const char *fmt
, ...)
5087 if (nb_drives_opt
>= MAX_DRIVES
) {
5088 fprintf(stderr
, "qemu: too many drives\n");
5092 drives_opt
[nb_drives_opt
].file
= file
;
5094 vsnprintf(drives_opt
[nb_drives_opt
].opt
,
5095 sizeof(drives_opt
[0].opt
), fmt
, ap
);
5098 return nb_drives_opt
++;
5101 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
5105 /* seek interface, bus and unit */
5107 for (index
= 0; index
< nb_drives
; index
++)
5108 if (drives_table
[index
].type
== type
&&
5109 drives_table
[index
].bus
== bus
&&
5110 drives_table
[index
].unit
== unit
)
5116 int drive_get_max_bus(BlockInterfaceType type
)
5122 for (index
= 0; index
< nb_drives
; index
++) {
5123 if(drives_table
[index
].type
== type
&&
5124 drives_table
[index
].bus
> max_bus
)
5125 max_bus
= drives_table
[index
].bus
;
5130 static void bdrv_format_print(void *opaque
, const char *name
)
5132 fprintf(stderr
, " %s", name
);
5135 static int drive_init(struct drive_opt
*arg
, int snapshot
,
5136 QEMUMachine
*machine
)
5141 const char *mediastr
= "";
5142 BlockInterfaceType type
;
5143 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
5144 int bus_id
, unit_id
;
5145 int cyls
, heads
, secs
, translation
;
5146 BlockDriverState
*bdrv
;
5147 BlockDriver
*drv
= NULL
;
5152 char *str
= arg
->opt
;
5153 char *params
[] = { "bus", "unit", "if", "index", "cyls", "heads",
5154 "secs", "trans", "media", "snapshot", "file",
5155 "cache", "format", NULL
};
5157 if (check_params(buf
, sizeof(buf
), params
, str
) < 0) {
5158 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
5164 cyls
= heads
= secs
= 0;
5167 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5171 if (!strcmp(machine
->name
, "realview") ||
5172 !strcmp(machine
->name
, "SS-5") ||
5173 !strcmp(machine
->name
, "SS-10") ||
5174 !strcmp(machine
->name
, "SS-600MP") ||
5175 !strcmp(machine
->name
, "versatilepb") ||
5176 !strcmp(machine
->name
, "versatileab")) {
5178 max_devs
= MAX_SCSI_DEVS
;
5179 strcpy(devname
, "scsi");
5182 max_devs
= MAX_IDE_DEVS
;
5183 strcpy(devname
, "ide");
5187 /* extract parameters */
5189 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
5190 bus_id
= strtol(buf
, NULL
, 0);
5192 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
5197 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
5198 unit_id
= strtol(buf
, NULL
, 0);
5200 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
5205 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
5206 pstrcpy(devname
, sizeof(devname
), buf
);
5207 if (!strcmp(buf
, "ide")) {
5209 max_devs
= MAX_IDE_DEVS
;
5210 } else if (!strcmp(buf
, "scsi")) {
5212 max_devs
= MAX_SCSI_DEVS
;
5213 } else if (!strcmp(buf
, "floppy")) {
5216 } else if (!strcmp(buf
, "pflash")) {
5219 } else if (!strcmp(buf
, "mtd")) {
5222 } else if (!strcmp(buf
, "sd")) {
5226 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
5231 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
5232 index
= strtol(buf
, NULL
, 0);
5234 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
5239 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
5240 cyls
= strtol(buf
, NULL
, 0);
5243 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
5244 heads
= strtol(buf
, NULL
, 0);
5247 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
5248 secs
= strtol(buf
, NULL
, 0);
5251 if (cyls
|| heads
|| secs
) {
5252 if (cyls
< 1 || cyls
> 16383) {
5253 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
5256 if (heads
< 1 || heads
> 16) {
5257 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
5260 if (secs
< 1 || secs
> 63) {
5261 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
5266 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
5269 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5273 if (!strcmp(buf
, "none"))
5274 translation
= BIOS_ATA_TRANSLATION_NONE
;
5275 else if (!strcmp(buf
, "lba"))
5276 translation
= BIOS_ATA_TRANSLATION_LBA
;
5277 else if (!strcmp(buf
, "auto"))
5278 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5280 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
5285 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
5286 if (!strcmp(buf
, "disk")) {
5288 } else if (!strcmp(buf
, "cdrom")) {
5289 if (cyls
|| secs
|| heads
) {
5291 "qemu: '%s' invalid physical CHS format\n", str
);
5294 media
= MEDIA_CDROM
;
5296 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
5301 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
5302 if (!strcmp(buf
, "on"))
5304 else if (!strcmp(buf
, "off"))
5307 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
5312 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
5313 if (!strcmp(buf
, "off"))
5315 else if (!strcmp(buf
, "on"))
5318 fprintf(stderr
, "qemu: invalid cache option\n");
5323 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
5324 if (strcmp(buf
, "?") == 0) {
5325 fprintf(stderr
, "qemu: Supported formats:");
5326 bdrv_iterate_format(bdrv_format_print
, NULL
);
5327 fprintf(stderr
, "\n");
5330 drv
= bdrv_find_format(buf
);
5332 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
5337 if (arg
->file
== NULL
)
5338 get_param_value(file
, sizeof(file
), "file", str
);
5340 pstrcpy(file
, sizeof(file
), arg
->file
);
5342 /* compute bus and unit according index */
5345 if (bus_id
!= 0 || unit_id
!= -1) {
5347 "qemu: '%s' index cannot be used with bus and unit\n", str
);
5355 unit_id
= index
% max_devs
;
5356 bus_id
= index
/ max_devs
;
5360 /* if user doesn't specify a unit_id,
5361 * try to find the first free
5364 if (unit_id
== -1) {
5366 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
5368 if (max_devs
&& unit_id
>= max_devs
) {
5369 unit_id
-= max_devs
;
5377 if (max_devs
&& unit_id
>= max_devs
) {
5378 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
5379 str
, unit_id
, max_devs
- 1);
5384 * ignore multiple definitions
5387 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
5392 if (type
== IF_IDE
|| type
== IF_SCSI
)
5393 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
5395 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
5396 devname
, bus_id
, mediastr
, unit_id
);
5398 snprintf(buf
, sizeof(buf
), "%s%s%i",
5399 devname
, mediastr
, unit_id
);
5400 bdrv
= bdrv_new(buf
);
5401 drives_table
[nb_drives
].bdrv
= bdrv
;
5402 drives_table
[nb_drives
].type
= type
;
5403 drives_table
[nb_drives
].bus
= bus_id
;
5404 drives_table
[nb_drives
].unit
= unit_id
;
5413 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
5414 bdrv_set_translation_hint(bdrv
, translation
);
5418 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
5423 /* FIXME: This isn't really a floppy, but it's a reasonable
5426 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
5436 bdrv_flags
|= BDRV_O_SNAPSHOT
;
5438 bdrv_flags
|= BDRV_O_DIRECT
;
5439 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0 || qemu_key_check(bdrv
, file
)) {
5440 fprintf(stderr
, "qemu: could not open disk image %s\n",
5447 /***********************************************************/
5450 static USBPort
*used_usb_ports
;
5451 static USBPort
*free_usb_ports
;
5453 /* ??? Maybe change this to register a hub to keep track of the topology. */
5454 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
5455 usb_attachfn attach
)
5457 port
->opaque
= opaque
;
5458 port
->index
= index
;
5459 port
->attach
= attach
;
5460 port
->next
= free_usb_ports
;
5461 free_usb_ports
= port
;
5464 static int usb_device_add(const char *devname
)
5470 if (!free_usb_ports
)
5473 if (strstart(devname
, "host:", &p
)) {
5474 dev
= usb_host_device_open(p
);
5475 } else if (!strcmp(devname
, "mouse")) {
5476 dev
= usb_mouse_init();
5477 } else if (!strcmp(devname
, "tablet")) {
5478 dev
= usb_tablet_init();
5479 } else if (!strcmp(devname
, "keyboard")) {
5480 dev
= usb_keyboard_init();
5481 } else if (strstart(devname
, "disk:", &p
)) {
5482 dev
= usb_msd_init(p
);
5483 } else if (!strcmp(devname
, "wacom-tablet")) {
5484 dev
= usb_wacom_init();
5485 } else if (strstart(devname
, "serial:", &p
)) {
5486 dev
= usb_serial_init(p
);
5487 #ifdef CONFIG_BRLAPI
5488 } else if (!strcmp(devname
, "braille")) {
5489 dev
= usb_baum_init();
5491 } else if (strstart(devname
, "net:", &p
)) {
5492 int nicidx
= strtoul(p
, NULL
, 0);
5494 if (nicidx
>= nb_nics
|| strcmp(nd_table
[nicidx
].model
, "usb"))
5496 dev
= usb_net_init(&nd_table
[nicidx
]);
5503 /* Find a USB port to add the device to. */
5504 port
= free_usb_ports
;
5508 /* Create a new hub and chain it on. */
5509 free_usb_ports
= NULL
;
5510 port
->next
= used_usb_ports
;
5511 used_usb_ports
= port
;
5513 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
5514 usb_attach(port
, hub
);
5515 port
= free_usb_ports
;
5518 free_usb_ports
= port
->next
;
5519 port
->next
= used_usb_ports
;
5520 used_usb_ports
= port
;
5521 usb_attach(port
, dev
);
5525 static int usb_device_del(const char *devname
)
5533 if (!used_usb_ports
)
5536 p
= strchr(devname
, '.');
5539 bus_num
= strtoul(devname
, NULL
, 0);
5540 addr
= strtoul(p
+ 1, NULL
, 0);
5544 lastp
= &used_usb_ports
;
5545 port
= used_usb_ports
;
5546 while (port
&& port
->dev
->addr
!= addr
) {
5547 lastp
= &port
->next
;
5555 *lastp
= port
->next
;
5556 usb_attach(port
, NULL
);
5557 dev
->handle_destroy(dev
);
5558 port
->next
= free_usb_ports
;
5559 free_usb_ports
= port
;
5563 void do_usb_add(const char *devname
)
5566 ret
= usb_device_add(devname
);
5568 term_printf("Could not add USB device '%s'\n", devname
);
5571 void do_usb_del(const char *devname
)
5574 ret
= usb_device_del(devname
);
5576 term_printf("Could not remove USB device '%s'\n", devname
);
5583 const char *speed_str
;
5586 term_printf("USB support not enabled\n");
5590 for (port
= used_usb_ports
; port
; port
= port
->next
) {
5594 switch(dev
->speed
) {
5598 case USB_SPEED_FULL
:
5601 case USB_SPEED_HIGH
:
5608 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5609 0, dev
->addr
, speed_str
, dev
->devname
);
5613 /***********************************************************/
5614 /* PCMCIA/Cardbus */
5616 static struct pcmcia_socket_entry_s
{
5617 struct pcmcia_socket_s
*socket
;
5618 struct pcmcia_socket_entry_s
*next
;
5619 } *pcmcia_sockets
= 0;
5621 void pcmcia_socket_register(struct pcmcia_socket_s
*socket
)
5623 struct pcmcia_socket_entry_s
*entry
;
5625 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
5626 entry
->socket
= socket
;
5627 entry
->next
= pcmcia_sockets
;
5628 pcmcia_sockets
= entry
;
5631 void pcmcia_socket_unregister(struct pcmcia_socket_s
*socket
)
5633 struct pcmcia_socket_entry_s
*entry
, **ptr
;
5635 ptr
= &pcmcia_sockets
;
5636 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
5637 if (entry
->socket
== socket
) {
5643 void pcmcia_info(void)
5645 struct pcmcia_socket_entry_s
*iter
;
5646 if (!pcmcia_sockets
)
5647 term_printf("No PCMCIA sockets\n");
5649 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
5650 term_printf("%s: %s\n", iter
->socket
->slot_string
,
5651 iter
->socket
->attached
? iter
->socket
->card_string
:
5655 /***********************************************************/
5658 static void dumb_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
5662 static void dumb_resize(DisplayState
*ds
, int w
, int h
)
5666 static void dumb_refresh(DisplayState
*ds
)
5668 #if defined(CONFIG_SDL)
5673 static void dumb_display_init(DisplayState
*ds
)
5678 ds
->dpy_update
= dumb_update
;
5679 ds
->dpy_resize
= dumb_resize
;
5680 ds
->dpy_refresh
= dumb_refresh
;
5683 /***********************************************************/
5686 #define MAX_IO_HANDLERS 64
5688 typedef struct IOHandlerRecord
{
5690 IOCanRWHandler
*fd_read_poll
;
5692 IOHandler
*fd_write
;
5695 /* temporary data */
5697 struct IOHandlerRecord
*next
;
5700 static IOHandlerRecord
*first_io_handler
;
5702 /* XXX: fd_read_poll should be suppressed, but an API change is
5703 necessary in the character devices to suppress fd_can_read(). */
5704 int qemu_set_fd_handler2(int fd
,
5705 IOCanRWHandler
*fd_read_poll
,
5707 IOHandler
*fd_write
,
5710 IOHandlerRecord
**pioh
, *ioh
;
5712 if (!fd_read
&& !fd_write
) {
5713 pioh
= &first_io_handler
;
5718 if (ioh
->fd
== fd
) {
5725 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
5729 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
5732 ioh
->next
= first_io_handler
;
5733 first_io_handler
= ioh
;
5736 ioh
->fd_read_poll
= fd_read_poll
;
5737 ioh
->fd_read
= fd_read
;
5738 ioh
->fd_write
= fd_write
;
5739 ioh
->opaque
= opaque
;
5745 int qemu_set_fd_handler(int fd
,
5747 IOHandler
*fd_write
,
5750 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
5753 /***********************************************************/
5754 /* Polling handling */
5756 typedef struct PollingEntry
{
5759 struct PollingEntry
*next
;
5762 static PollingEntry
*first_polling_entry
;
5764 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
5766 PollingEntry
**ppe
, *pe
;
5767 pe
= qemu_mallocz(sizeof(PollingEntry
));
5771 pe
->opaque
= opaque
;
5772 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
5777 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
5779 PollingEntry
**ppe
, *pe
;
5780 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
5782 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
5791 /***********************************************************/
5792 /* Wait objects support */
5793 typedef struct WaitObjects
{
5795 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
5796 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
5797 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
5800 static WaitObjects wait_objects
= {0};
5802 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
5804 WaitObjects
*w
= &wait_objects
;
5806 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
5808 w
->events
[w
->num
] = handle
;
5809 w
->func
[w
->num
] = func
;
5810 w
->opaque
[w
->num
] = opaque
;
5815 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
5818 WaitObjects
*w
= &wait_objects
;
5821 for (i
= 0; i
< w
->num
; i
++) {
5822 if (w
->events
[i
] == handle
)
5825 w
->events
[i
] = w
->events
[i
+ 1];
5826 w
->func
[i
] = w
->func
[i
+ 1];
5827 w
->opaque
[i
] = w
->opaque
[i
+ 1];
5835 /***********************************************************/
5836 /* savevm/loadvm support */
5838 #define IO_BUF_SIZE 32768
5842 BlockDriverState
*bs
;
5845 int64_t base_offset
;
5846 int64_t buf_offset
; /* start of buffer when writing, end of buffer
5849 int buf_size
; /* 0 when writing */
5850 uint8_t buf
[IO_BUF_SIZE
];
5853 QEMUFile
*qemu_fopen(const char *filename
, const char *mode
)
5857 f
= qemu_mallocz(sizeof(QEMUFile
));
5860 if (!strcmp(mode
, "wb")) {
5862 } else if (!strcmp(mode
, "rb")) {
5867 f
->outfile
= fopen(filename
, mode
);
5879 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int64_t offset
, int is_writable
)
5883 f
= qemu_mallocz(sizeof(QEMUFile
));
5888 f
->is_writable
= is_writable
;
5889 f
->base_offset
= offset
;
5893 void qemu_fflush(QEMUFile
*f
)
5895 if (!f
->is_writable
)
5897 if (f
->buf_index
> 0) {
5899 fseek(f
->outfile
, f
->buf_offset
, SEEK_SET
);
5900 fwrite(f
->buf
, 1, f
->buf_index
, f
->outfile
);
5902 bdrv_pwrite(f
->bs
, f
->base_offset
+ f
->buf_offset
,
5903 f
->buf
, f
->buf_index
);
5905 f
->buf_offset
+= f
->buf_index
;
5910 static void qemu_fill_buffer(QEMUFile
*f
)
5917 fseek(f
->outfile
, f
->buf_offset
, SEEK_SET
);
5918 len
= fread(f
->buf
, 1, IO_BUF_SIZE
, f
->outfile
);
5922 len
= bdrv_pread(f
->bs
, f
->base_offset
+ f
->buf_offset
,
5923 f
->buf
, IO_BUF_SIZE
);
5929 f
->buf_offset
+= len
;
5932 void qemu_fclose(QEMUFile
*f
)
5942 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, int size
)
5946 l
= IO_BUF_SIZE
- f
->buf_index
;
5949 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
5953 if (f
->buf_index
>= IO_BUF_SIZE
)
5958 void qemu_put_byte(QEMUFile
*f
, int v
)
5960 f
->buf
[f
->buf_index
++] = v
;
5961 if (f
->buf_index
>= IO_BUF_SIZE
)
5965 int qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, int size1
)
5971 l
= f
->buf_size
- f
->buf_index
;
5973 qemu_fill_buffer(f
);
5974 l
= f
->buf_size
- f
->buf_index
;
5980 memcpy(buf
, f
->buf
+ f
->buf_index
, l
);
5985 return size1
- size
;
5988 int qemu_get_byte(QEMUFile
*f
)
5990 if (f
->buf_index
>= f
->buf_size
) {
5991 qemu_fill_buffer(f
);
5992 if (f
->buf_index
>= f
->buf_size
)
5995 return f
->buf
[f
->buf_index
++];
5998 int64_t qemu_ftell(QEMUFile
*f
)
6000 return f
->buf_offset
- f
->buf_size
+ f
->buf_index
;
6003 int64_t qemu_fseek(QEMUFile
*f
, int64_t pos
, int whence
)
6005 if (whence
== SEEK_SET
) {
6007 } else if (whence
== SEEK_CUR
) {
6008 pos
+= qemu_ftell(f
);
6010 /* SEEK_END not supported */
6013 if (f
->is_writable
) {
6015 f
->buf_offset
= pos
;
6017 f
->buf_offset
= pos
;
6024 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
6026 qemu_put_byte(f
, v
>> 8);
6027 qemu_put_byte(f
, v
);
6030 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
6032 qemu_put_byte(f
, v
>> 24);
6033 qemu_put_byte(f
, v
>> 16);
6034 qemu_put_byte(f
, v
>> 8);
6035 qemu_put_byte(f
, v
);
6038 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
6040 qemu_put_be32(f
, v
>> 32);
6041 qemu_put_be32(f
, v
);
6044 unsigned int qemu_get_be16(QEMUFile
*f
)
6047 v
= qemu_get_byte(f
) << 8;
6048 v
|= qemu_get_byte(f
);
6052 unsigned int qemu_get_be32(QEMUFile
*f
)
6055 v
= qemu_get_byte(f
) << 24;
6056 v
|= qemu_get_byte(f
) << 16;
6057 v
|= qemu_get_byte(f
) << 8;
6058 v
|= qemu_get_byte(f
);
6062 uint64_t qemu_get_be64(QEMUFile
*f
)
6065 v
= (uint64_t)qemu_get_be32(f
) << 32;
6066 v
|= qemu_get_be32(f
);
6070 typedef struct SaveStateEntry
{
6074 SaveStateHandler
*save_state
;
6075 LoadStateHandler
*load_state
;
6077 struct SaveStateEntry
*next
;
6080 static SaveStateEntry
*first_se
;
6082 /* TODO: Individual devices generally have very little idea about the rest
6083 of the system, so instance_id should be removed/replaced. */
6084 int register_savevm(const char *idstr
,
6087 SaveStateHandler
*save_state
,
6088 LoadStateHandler
*load_state
,
6091 SaveStateEntry
*se
, **pse
;
6093 se
= qemu_malloc(sizeof(SaveStateEntry
));
6096 pstrcpy(se
->idstr
, sizeof(se
->idstr
), idstr
);
6097 se
->instance_id
= (instance_id
== -1) ? 0 : instance_id
;
6098 se
->version_id
= version_id
;
6099 se
->save_state
= save_state
;
6100 se
->load_state
= load_state
;
6101 se
->opaque
= opaque
;
6104 /* add at the end of list */
6106 while (*pse
!= NULL
) {
6107 if (instance_id
== -1
6108 && strcmp(se
->idstr
, (*pse
)->idstr
) == 0
6109 && se
->instance_id
<= (*pse
)->instance_id
)
6110 se
->instance_id
= (*pse
)->instance_id
+ 1;
6111 pse
= &(*pse
)->next
;
6117 #define QEMU_VM_FILE_MAGIC 0x5145564d
6118 #define QEMU_VM_FILE_VERSION 0x00000002
6120 static int qemu_savevm_state(QEMUFile
*f
)
6124 int64_t cur_pos
, len_pos
, total_len_pos
;
6126 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
6127 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
6128 total_len_pos
= qemu_ftell(f
);
6129 qemu_put_be64(f
, 0); /* total size */
6131 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6132 if (se
->save_state
== NULL
)
6133 /* this one has a loader only, for backwards compatibility */
6137 len
= strlen(se
->idstr
);
6138 qemu_put_byte(f
, len
);
6139 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6141 qemu_put_be32(f
, se
->instance_id
);
6142 qemu_put_be32(f
, se
->version_id
);
6144 /* record size: filled later */
6145 len_pos
= qemu_ftell(f
);
6146 qemu_put_be32(f
, 0);
6147 se
->save_state(f
, se
->opaque
);
6149 /* fill record size */
6150 cur_pos
= qemu_ftell(f
);
6151 len
= cur_pos
- len_pos
- 4;
6152 qemu_fseek(f
, len_pos
, SEEK_SET
);
6153 qemu_put_be32(f
, len
);
6154 qemu_fseek(f
, cur_pos
, SEEK_SET
);
6156 cur_pos
= qemu_ftell(f
);
6157 qemu_fseek(f
, total_len_pos
, SEEK_SET
);
6158 qemu_put_be64(f
, cur_pos
- total_len_pos
- 8);
6159 qemu_fseek(f
, cur_pos
, SEEK_SET
);
6165 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
6169 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6170 if (!strcmp(se
->idstr
, idstr
) &&
6171 instance_id
== se
->instance_id
)
6177 static int qemu_loadvm_state(QEMUFile
*f
)
6180 int len
, ret
, instance_id
, record_len
, version_id
;
6181 int64_t total_len
, end_pos
, cur_pos
;
6185 v
= qemu_get_be32(f
);
6186 if (v
!= QEMU_VM_FILE_MAGIC
)
6188 v
= qemu_get_be32(f
);
6189 if (v
!= QEMU_VM_FILE_VERSION
) {
6194 total_len
= qemu_get_be64(f
);
6195 end_pos
= total_len
+ qemu_ftell(f
);
6197 if (qemu_ftell(f
) >= end_pos
)
6199 len
= qemu_get_byte(f
);
6200 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6202 instance_id
= qemu_get_be32(f
);
6203 version_id
= qemu_get_be32(f
);
6204 record_len
= qemu_get_be32(f
);
6206 printf("idstr=%s instance=0x%x version=%d len=%d\n",
6207 idstr
, instance_id
, version_id
, record_len
);
6209 cur_pos
= qemu_ftell(f
);
6210 se
= find_se(idstr
, instance_id
);
6212 fprintf(stderr
, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6213 instance_id
, idstr
);
6215 ret
= se
->load_state(f
, se
->opaque
, version_id
);
6217 fprintf(stderr
, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6218 instance_id
, idstr
);
6221 /* always seek to exact end of record */
6222 qemu_fseek(f
, cur_pos
+ record_len
, SEEK_SET
);
6229 /* device can contain snapshots */
6230 static int bdrv_can_snapshot(BlockDriverState
*bs
)
6233 !bdrv_is_removable(bs
) &&
6234 !bdrv_is_read_only(bs
));
6237 /* device must be snapshots in order to have a reliable snapshot */
6238 static int bdrv_has_snapshot(BlockDriverState
*bs
)
6241 !bdrv_is_removable(bs
) &&
6242 !bdrv_is_read_only(bs
));
6245 static BlockDriverState
*get_bs_snapshots(void)
6247 BlockDriverState
*bs
;
6251 return bs_snapshots
;
6252 for(i
= 0; i
<= nb_drives
; i
++) {
6253 bs
= drives_table
[i
].bdrv
;
6254 if (bdrv_can_snapshot(bs
))
6263 static int bdrv_snapshot_find(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
,
6266 QEMUSnapshotInfo
*sn_tab
, *sn
;
6270 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
6273 for(i
= 0; i
< nb_sns
; i
++) {
6275 if (!strcmp(sn
->id_str
, name
) || !strcmp(sn
->name
, name
)) {
6285 void do_savevm(const char *name
)
6287 BlockDriverState
*bs
, *bs1
;
6288 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
6289 int must_delete
, ret
, i
;
6290 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6292 int saved_vm_running
;
6299 bs
= get_bs_snapshots();
6301 term_printf("No block device can accept snapshots\n");
6305 /* ??? Should this occur after vm_stop? */
6308 saved_vm_running
= vm_running
;
6313 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
6318 memset(sn
, 0, sizeof(*sn
));
6320 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
6321 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
6324 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
6327 /* fill auxiliary fields */
6330 sn
->date_sec
= tb
.time
;
6331 sn
->date_nsec
= tb
.millitm
* 1000000;
6333 gettimeofday(&tv
, NULL
);
6334 sn
->date_sec
= tv
.tv_sec
;
6335 sn
->date_nsec
= tv
.tv_usec
* 1000;
6337 sn
->vm_clock_nsec
= qemu_get_clock(vm_clock
);
6339 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
6340 term_printf("Device %s does not support VM state snapshots\n",
6341 bdrv_get_device_name(bs
));
6345 /* save the VM state */
6346 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 1);
6348 term_printf("Could not open VM state file\n");
6351 ret
= qemu_savevm_state(f
);
6352 sn
->vm_state_size
= qemu_ftell(f
);
6355 term_printf("Error %d while writing VM\n", ret
);
6359 /* create the snapshots */
6361 for(i
= 0; i
< nb_drives
; i
++) {
6362 bs1
= drives_table
[i
].bdrv
;
6363 if (bdrv_has_snapshot(bs1
)) {
6365 ret
= bdrv_snapshot_delete(bs1
, old_sn
->id_str
);
6367 term_printf("Error while deleting snapshot on '%s'\n",
6368 bdrv_get_device_name(bs1
));
6371 ret
= bdrv_snapshot_create(bs1
, sn
);
6373 term_printf("Error while creating snapshot on '%s'\n",
6374 bdrv_get_device_name(bs1
));
6380 if (saved_vm_running
)
6384 void do_loadvm(const char *name
)
6386 BlockDriverState
*bs
, *bs1
;
6387 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6390 int saved_vm_running
;
6392 bs
= get_bs_snapshots();
6394 term_printf("No block device supports snapshots\n");
6398 /* Flush all IO requests so they don't interfere with the new state. */
6401 saved_vm_running
= vm_running
;
6404 for(i
= 0; i
<= nb_drives
; i
++) {
6405 bs1
= drives_table
[i
].bdrv
;
6406 if (bdrv_has_snapshot(bs1
)) {
6407 ret
= bdrv_snapshot_goto(bs1
, name
);
6410 term_printf("Warning: ");
6413 term_printf("Snapshots not supported on device '%s'\n",
6414 bdrv_get_device_name(bs1
));
6417 term_printf("Could not find snapshot '%s' on device '%s'\n",
6418 name
, bdrv_get_device_name(bs1
));
6421 term_printf("Error %d while activating snapshot on '%s'\n",
6422 ret
, bdrv_get_device_name(bs1
));
6425 /* fatal on snapshot block device */
6432 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
6433 term_printf("Device %s does not support VM state snapshots\n",
6434 bdrv_get_device_name(bs
));
6438 /* restore the VM state */
6439 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 0);
6441 term_printf("Could not open VM state file\n");
6444 ret
= qemu_loadvm_state(f
);
6447 term_printf("Error %d while loading VM state\n", ret
);
6450 if (saved_vm_running
)
6454 void do_delvm(const char *name
)
6456 BlockDriverState
*bs
, *bs1
;
6459 bs
= get_bs_snapshots();
6461 term_printf("No block device supports snapshots\n");
6465 for(i
= 0; i
<= nb_drives
; i
++) {
6466 bs1
= drives_table
[i
].bdrv
;
6467 if (bdrv_has_snapshot(bs1
)) {
6468 ret
= bdrv_snapshot_delete(bs1
, name
);
6470 if (ret
== -ENOTSUP
)
6471 term_printf("Snapshots not supported on device '%s'\n",
6472 bdrv_get_device_name(bs1
));
6474 term_printf("Error %d while deleting snapshot on '%s'\n",
6475 ret
, bdrv_get_device_name(bs1
));
6481 void do_info_snapshots(void)
6483 BlockDriverState
*bs
, *bs1
;
6484 QEMUSnapshotInfo
*sn_tab
, *sn
;
6488 bs
= get_bs_snapshots();
6490 term_printf("No available block device supports snapshots\n");
6493 term_printf("Snapshot devices:");
6494 for(i
= 0; i
<= nb_drives
; i
++) {
6495 bs1
= drives_table
[i
].bdrv
;
6496 if (bdrv_has_snapshot(bs1
)) {
6498 term_printf(" %s", bdrv_get_device_name(bs1
));
6503 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
6505 term_printf("bdrv_snapshot_list: error %d\n", nb_sns
);
6508 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs
));
6509 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
6510 for(i
= 0; i
< nb_sns
; i
++) {
6512 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
6517 /***********************************************************/
6518 /* ram save/restore */
6520 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
6524 v
= qemu_get_byte(f
);
6527 if (qemu_get_buffer(f
, buf
, len
) != len
)
6531 v
= qemu_get_byte(f
);
6532 memset(buf
, v
, len
);
6540 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
6545 if (qemu_get_be32(f
) != phys_ram_size
)
6547 for(i
= 0; i
< phys_ram_size
; i
+= TARGET_PAGE_SIZE
) {
6548 ret
= ram_get_page(f
, phys_ram_base
+ i
, TARGET_PAGE_SIZE
);
6555 #define BDRV_HASH_BLOCK_SIZE 1024
6556 #define IOBUF_SIZE 4096
6557 #define RAM_CBLOCK_MAGIC 0xfabe
6559 typedef struct RamCompressState
{
6562 uint8_t buf
[IOBUF_SIZE
];
6565 static int ram_compress_open(RamCompressState
*s
, QEMUFile
*f
)
6568 memset(s
, 0, sizeof(*s
));
6570 ret
= deflateInit2(&s
->zstream
, 1,
6572 9, Z_DEFAULT_STRATEGY
);
6575 s
->zstream
.avail_out
= IOBUF_SIZE
;
6576 s
->zstream
.next_out
= s
->buf
;
6580 static void ram_put_cblock(RamCompressState
*s
, const uint8_t *buf
, int len
)
6582 qemu_put_be16(s
->f
, RAM_CBLOCK_MAGIC
);
6583 qemu_put_be16(s
->f
, len
);
6584 qemu_put_buffer(s
->f
, buf
, len
);
6587 static int ram_compress_buf(RamCompressState
*s
, const uint8_t *buf
, int len
)
6591 s
->zstream
.avail_in
= len
;
6592 s
->zstream
.next_in
= (uint8_t *)buf
;
6593 while (s
->zstream
.avail_in
> 0) {
6594 ret
= deflate(&s
->zstream
, Z_NO_FLUSH
);
6597 if (s
->zstream
.avail_out
== 0) {
6598 ram_put_cblock(s
, s
->buf
, IOBUF_SIZE
);
6599 s
->zstream
.avail_out
= IOBUF_SIZE
;
6600 s
->zstream
.next_out
= s
->buf
;
6606 static void ram_compress_close(RamCompressState
*s
)
6610 /* compress last bytes */
6612 ret
= deflate(&s
->zstream
, Z_FINISH
);
6613 if (ret
== Z_OK
|| ret
== Z_STREAM_END
) {
6614 len
= IOBUF_SIZE
- s
->zstream
.avail_out
;
6616 ram_put_cblock(s
, s
->buf
, len
);
6618 s
->zstream
.avail_out
= IOBUF_SIZE
;
6619 s
->zstream
.next_out
= s
->buf
;
6620 if (ret
== Z_STREAM_END
)
6627 deflateEnd(&s
->zstream
);
6630 typedef struct RamDecompressState
{
6633 uint8_t buf
[IOBUF_SIZE
];
6634 } RamDecompressState
;
6636 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
6639 memset(s
, 0, sizeof(*s
));
6641 ret
= inflateInit(&s
->zstream
);
6647 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
6651 s
->zstream
.avail_out
= len
;
6652 s
->zstream
.next_out
= buf
;
6653 while (s
->zstream
.avail_out
> 0) {
6654 if (s
->zstream
.avail_in
== 0) {
6655 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
6657 clen
= qemu_get_be16(s
->f
);
6658 if (clen
> IOBUF_SIZE
)
6660 qemu_get_buffer(s
->f
, s
->buf
, clen
);
6661 s
->zstream
.avail_in
= clen
;
6662 s
->zstream
.next_in
= s
->buf
;
6664 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
6665 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
6672 static void ram_decompress_close(RamDecompressState
*s
)
6674 inflateEnd(&s
->zstream
);
6677 static void ram_save(QEMUFile
*f
, void *opaque
)
6680 RamCompressState s1
, *s
= &s1
;
6683 qemu_put_be32(f
, phys_ram_size
);
6684 if (ram_compress_open(s
, f
) < 0)
6686 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
6688 if (tight_savevm_enabled
) {
6692 /* find if the memory block is available on a virtual
6695 for(j
= 0; j
< nb_drives
; j
++) {
6696 sector_num
= bdrv_hash_find(drives_table
[j
].bdrv
,
6698 BDRV_HASH_BLOCK_SIZE
);
6699 if (sector_num
>= 0)
6703 goto normal_compress
;
6706 cpu_to_be64wu((uint64_t *)(buf
+ 2), sector_num
);
6707 ram_compress_buf(s
, buf
, 10);
6713 ram_compress_buf(s
, buf
, 1);
6714 ram_compress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
);
6717 ram_compress_close(s
);
6720 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
6722 RamDecompressState s1
, *s
= &s1
;
6726 if (version_id
== 1)
6727 return ram_load_v1(f
, opaque
);
6728 if (version_id
!= 2)
6730 if (qemu_get_be32(f
) != phys_ram_size
)
6732 if (ram_decompress_open(s
, f
) < 0)
6734 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
6735 if (ram_decompress_buf(s
, buf
, 1) < 0) {
6736 fprintf(stderr
, "Error while reading ram block header\n");
6740 if (ram_decompress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
) < 0) {
6741 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
6750 ram_decompress_buf(s
, buf
+ 1, 9);
6752 sector_num
= be64_to_cpupu((const uint64_t *)(buf
+ 2));
6753 if (bs_index
>= nb_drives
) {
6754 fprintf(stderr
, "Invalid block device index %d\n", bs_index
);
6757 if (bdrv_read(drives_table
[bs_index
].bdrv
, sector_num
,
6759 BDRV_HASH_BLOCK_SIZE
/ 512) < 0) {
6760 fprintf(stderr
, "Error while reading sector %d:%" PRId64
"\n",
6761 bs_index
, sector_num
);
6768 printf("Error block header\n");
6772 ram_decompress_close(s
);
6776 /***********************************************************/
6777 /* bottom halves (can be seen as timers which expire ASAP) */
6786 static QEMUBH
*first_bh
= NULL
;
6788 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
6791 bh
= qemu_mallocz(sizeof(QEMUBH
));
6795 bh
->opaque
= opaque
;
6799 int qemu_bh_poll(void)
6818 void qemu_bh_schedule(QEMUBH
*bh
)
6820 CPUState
*env
= cpu_single_env
;
6824 bh
->next
= first_bh
;
6827 /* stop the currently executing CPU to execute the BH ASAP */
6829 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
6833 void qemu_bh_cancel(QEMUBH
*bh
)
6836 if (bh
->scheduled
) {
6839 pbh
= &(*pbh
)->next
;
6845 void qemu_bh_delete(QEMUBH
*bh
)
6851 /***********************************************************/
6852 /* machine registration */
6854 QEMUMachine
*first_machine
= NULL
;
6856 int qemu_register_machine(QEMUMachine
*m
)
6859 pm
= &first_machine
;
6867 static QEMUMachine
*find_machine(const char *name
)
6871 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
6872 if (!strcmp(m
->name
, name
))
6878 /***********************************************************/
6879 /* main execution loop */
6881 static void gui_update(void *opaque
)
6883 DisplayState
*ds
= opaque
;
6884 ds
->dpy_refresh(ds
);
6885 qemu_mod_timer(ds
->gui_timer
,
6886 (ds
->gui_timer_interval
?
6887 ds
->gui_timer_interval
:
6888 GUI_REFRESH_INTERVAL
)
6889 + qemu_get_clock(rt_clock
));
6892 struct vm_change_state_entry
{
6893 VMChangeStateHandler
*cb
;
6895 LIST_ENTRY (vm_change_state_entry
) entries
;
6898 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
6900 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
6903 VMChangeStateEntry
*e
;
6905 e
= qemu_mallocz(sizeof (*e
));
6911 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
6915 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
6917 LIST_REMOVE (e
, entries
);
6921 static void vm_state_notify(int running
)
6923 VMChangeStateEntry
*e
;
6925 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
6926 e
->cb(e
->opaque
, running
);
6930 /* XXX: support several handlers */
6931 static VMStopHandler
*vm_stop_cb
;
6932 static void *vm_stop_opaque
;
6934 int qemu_add_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
6937 vm_stop_opaque
= opaque
;
6941 void qemu_del_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
6952 qemu_rearm_alarm_timer(alarm_timer
);
6956 void vm_stop(int reason
)
6959 cpu_disable_ticks();
6963 vm_stop_cb(vm_stop_opaque
, reason
);
6970 /* reset/shutdown handler */
6972 typedef struct QEMUResetEntry
{
6973 QEMUResetHandler
*func
;
6975 struct QEMUResetEntry
*next
;
6978 static QEMUResetEntry
*first_reset_entry
;
6979 static int reset_requested
;
6980 static int shutdown_requested
;
6981 static int powerdown_requested
;
6983 int qemu_shutdown_requested(void)
6985 int r
= shutdown_requested
;
6986 shutdown_requested
= 0;
6990 int qemu_reset_requested(void)
6992 int r
= reset_requested
;
6993 reset_requested
= 0;
6997 int qemu_powerdown_requested(void)
6999 int r
= powerdown_requested
;
7000 powerdown_requested
= 0;
7004 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
7006 QEMUResetEntry
**pre
, *re
;
7008 pre
= &first_reset_entry
;
7009 while (*pre
!= NULL
)
7010 pre
= &(*pre
)->next
;
7011 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
7013 re
->opaque
= opaque
;
7018 void qemu_system_reset(void)
7022 /* reset all devices */
7023 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
7024 re
->func(re
->opaque
);
7028 void qemu_system_reset_request(void)
7031 shutdown_requested
= 1;
7033 reset_requested
= 1;
7036 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7039 void qemu_system_shutdown_request(void)
7041 shutdown_requested
= 1;
7043 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7046 void qemu_system_powerdown_request(void)
7048 powerdown_requested
= 1;
7050 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7053 void main_loop_wait(int timeout
)
7055 IOHandlerRecord
*ioh
;
7056 fd_set rfds
, wfds
, xfds
;
7065 /* XXX: need to suppress polling by better using win32 events */
7067 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
7068 ret
|= pe
->func(pe
->opaque
);
7073 WaitObjects
*w
= &wait_objects
;
7075 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, timeout
);
7076 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
7077 if (w
->func
[ret
- WAIT_OBJECT_0
])
7078 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
7080 /* Check for additional signaled events */
7081 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
7083 /* Check if event is signaled */
7084 ret2
= WaitForSingleObject(w
->events
[i
], 0);
7085 if(ret2
== WAIT_OBJECT_0
) {
7087 w
->func
[i
](w
->opaque
[i
]);
7088 } else if (ret2
== WAIT_TIMEOUT
) {
7090 err
= GetLastError();
7091 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
7094 } else if (ret
== WAIT_TIMEOUT
) {
7096 err
= GetLastError();
7097 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
7101 /* poll any events */
7102 /* XXX: separate device handlers from system ones */
7107 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7111 (!ioh
->fd_read_poll
||
7112 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
7113 FD_SET(ioh
->fd
, &rfds
);
7117 if (ioh
->fd_write
) {
7118 FD_SET(ioh
->fd
, &wfds
);
7128 tv
.tv_usec
= timeout
* 1000;
7130 #if defined(CONFIG_SLIRP)
7132 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
7135 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
7137 IOHandlerRecord
**pioh
;
7139 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7140 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
7141 ioh
->fd_read(ioh
->opaque
);
7143 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
7144 ioh
->fd_write(ioh
->opaque
);
7148 /* remove deleted IO handlers */
7149 pioh
= &first_io_handler
;
7159 #if defined(CONFIG_SLIRP)
7166 slirp_select_poll(&rfds
, &wfds
, &xfds
);
7172 if (likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
7173 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
7174 qemu_get_clock(vm_clock
));
7175 /* run dma transfers, if any */
7179 /* real time timers */
7180 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
7181 qemu_get_clock(rt_clock
));
7183 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
7184 alarm_timer
->flags
&= ~(ALARM_FLAG_EXPIRED
);
7185 qemu_rearm_alarm_timer(alarm_timer
);
7188 /* Check bottom-halves last in case any of the earlier events triggered
7194 static int main_loop(void)
7197 #ifdef CONFIG_PROFILER
7202 cur_cpu
= first_cpu
;
7203 next_cpu
= cur_cpu
->next_cpu
?: first_cpu
;
7210 #ifdef CONFIG_PROFILER
7211 ti
= profile_getclock();
7216 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
7217 env
->icount_decr
.u16
.low
= 0;
7218 env
->icount_extra
= 0;
7219 count
= qemu_next_deadline();
7220 count
= (count
+ (1 << icount_time_shift
) - 1)
7221 >> icount_time_shift
;
7222 qemu_icount
+= count
;
7223 decr
= (count
> 0xffff) ? 0xffff : count
;
7225 env
->icount_decr
.u16
.low
= decr
;
7226 env
->icount_extra
= count
;
7228 ret
= cpu_exec(env
);
7229 #ifdef CONFIG_PROFILER
7230 qemu_time
+= profile_getclock() - ti
;
7233 /* Fold pending instructions back into the
7234 instruction counter, and clear the interrupt flag. */
7235 qemu_icount
-= (env
->icount_decr
.u16
.low
7236 + env
->icount_extra
);
7237 env
->icount_decr
.u32
= 0;
7238 env
->icount_extra
= 0;
7240 next_cpu
= env
->next_cpu
?: first_cpu
;
7241 if (event_pending
&& likely(ret
!= EXCP_DEBUG
)) {
7242 ret
= EXCP_INTERRUPT
;
7246 if (ret
== EXCP_HLT
) {
7247 /* Give the next CPU a chance to run. */
7251 if (ret
!= EXCP_HALTED
)
7253 /* all CPUs are halted ? */
7259 if (shutdown_requested
) {
7260 ret
= EXCP_INTERRUPT
;
7268 if (reset_requested
) {
7269 reset_requested
= 0;
7270 qemu_system_reset();
7271 ret
= EXCP_INTERRUPT
;
7273 if (powerdown_requested
) {
7274 powerdown_requested
= 0;
7275 qemu_system_powerdown();
7276 ret
= EXCP_INTERRUPT
;
7278 if (unlikely(ret
== EXCP_DEBUG
)) {
7279 vm_stop(EXCP_DEBUG
);
7281 /* If all cpus are halted then wait until the next IRQ */
7282 /* XXX: use timeout computed from timers */
7283 if (ret
== EXCP_HALTED
) {
7287 /* Advance virtual time to the next event. */
7288 if (use_icount
== 1) {
7289 /* When not using an adaptive execution frequency
7290 we tend to get badly out of sync with real time,
7291 so just delay for a reasonable amount of time. */
7294 delta
= cpu_get_icount() - cpu_get_clock();
7297 /* If virtual time is ahead of real time then just
7299 timeout
= (delta
/ 1000000) + 1;
7301 /* Wait for either IO to occur or the next
7303 add
= qemu_next_deadline();
7304 /* We advance the timer before checking for IO.
7305 Limit the amount we advance so that early IO
7306 activity won't get the guest too far ahead. */
7310 add
= (add
+ (1 << icount_time_shift
) - 1)
7311 >> icount_time_shift
;
7313 timeout
= delta
/ 1000000;
7326 #ifdef CONFIG_PROFILER
7327 ti
= profile_getclock();
7329 main_loop_wait(timeout
);
7330 #ifdef CONFIG_PROFILER
7331 dev_time
+= profile_getclock() - ti
;
7334 cpu_disable_ticks();
7338 static void help(int exitcode
)
7340 printf("QEMU PC emulator version " QEMU_VERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n"
7341 "usage: %s [options] [disk_image]\n"
7343 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7345 "Standard options:\n"
7346 "-M machine select emulated machine (-M ? for list)\n"
7347 "-cpu cpu select CPU (-cpu ? for list)\n"
7348 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7349 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7350 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7351 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7352 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7353 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7354 " [,cache=on|off][,format=f]\n"
7355 " use 'file' as a drive image\n"
7356 "-mtdblock file use 'file' as on-board Flash memory image\n"
7357 "-sd file use 'file' as SecureDigital card image\n"
7358 "-pflash file use 'file' as a parallel flash image\n"
7359 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7360 "-snapshot write to temporary files instead of disk image files\n"
7362 "-no-frame open SDL window without a frame and window decorations\n"
7363 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7364 "-no-quit disable SDL window close capability\n"
7367 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7369 "-m megs set virtual RAM size to megs MB [default=%d]\n"
7370 "-smp n set the number of CPUs to 'n' [default=1]\n"
7371 "-nographic disable graphical output and redirect serial I/Os to console\n"
7372 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7374 "-k language use keyboard layout (for example \"fr\" for French)\n"
7377 "-audio-help print list of audio drivers and their options\n"
7378 "-soundhw c1,... enable audio support\n"
7379 " and only specified sound cards (comma separated list)\n"
7380 " use -soundhw ? to get the list of supported cards\n"
7381 " use -soundhw all to enable all of them\n"
7383 "-localtime set the real time clock to local time [default=utc]\n"
7384 "-full-screen start in full screen\n"
7386 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7388 "-usb enable the USB driver (will be the default soon)\n"
7389 "-usbdevice name add the host or guest USB device 'name'\n"
7390 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7391 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7393 "-name string set the name of the guest\n"
7395 "Network options:\n"
7396 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7397 " create a new Network Interface Card and connect it to VLAN 'n'\n"
7399 "-net user[,vlan=n][,hostname=host]\n"
7400 " connect the user mode network stack to VLAN 'n' and send\n"
7401 " hostname 'host' to DHCP clients\n"
7404 "-net tap[,vlan=n],ifname=name\n"
7405 " connect the host TAP network interface to VLAN 'n'\n"
7407 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7408 " connect the host TAP network interface to VLAN 'n' and use the\n"
7409 " network scripts 'file' (default=%s)\n"
7410 " and 'dfile' (default=%s);\n"
7411 " use '[down]script=no' to disable script execution;\n"
7412 " use 'fd=h' to connect to an already opened TAP interface\n"
7414 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7415 " connect the vlan 'n' to another VLAN using a socket connection\n"
7416 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7417 " connect the vlan 'n' to multicast maddr and port\n"
7418 "-net none use it alone to have zero network devices; if no -net option\n"
7419 " is provided, the default is '-net nic -net user'\n"
7422 "-tftp dir allow tftp access to files in dir [-net user]\n"
7423 "-bootp file advertise file in BOOTP replies\n"
7425 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
7427 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7428 " redirect TCP or UDP connections from host to guest [-net user]\n"
7431 "Linux boot specific:\n"
7432 "-kernel bzImage use 'bzImage' as kernel image\n"
7433 "-append cmdline use 'cmdline' as kernel command line\n"
7434 "-initrd file use 'file' as initial ram disk\n"
7436 "Debug/Expert options:\n"
7437 "-monitor dev redirect the monitor to char device 'dev'\n"
7438 "-serial dev redirect the serial port to char device 'dev'\n"
7439 "-parallel dev redirect the parallel port to char device 'dev'\n"
7440 "-pidfile file Write PID to 'file'\n"
7441 "-S freeze CPU at startup (use 'c' to start execution)\n"
7442 "-s wait gdb connection to port\n"
7443 "-p port set gdb connection port [default=%s]\n"
7444 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
7445 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7446 " translation (t=none or lba) (usually qemu can guess them)\n"
7447 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7449 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7450 "-no-kqemu disable KQEMU kernel module usage\n"
7453 "-std-vga simulate a standard VGA card with VESA Bochs Extensions\n"
7454 " (default is CL-GD5446 PCI VGA)\n"
7455 "-no-acpi disable ACPI\n"
7457 #ifdef CONFIG_CURSES
7458 "-curses use a curses/ncurses interface instead of SDL\n"
7460 "-no-reboot exit instead of rebooting\n"
7461 "-no-shutdown stop before shutdown\n"
7462 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
7463 "-vnc display start a VNC server on display\n"
7465 "-daemonize daemonize QEMU after initializing\n"
7467 "-option-rom rom load a file, rom, into the option ROM space\n"
7469 "-prom-env variable=value set OpenBIOS nvram variables\n"
7471 "-clock force the use of the given methods for timer alarm.\n"
7472 " To see what timers are available use -clock ?\n"
7473 "-startdate select initial date of the clock\n"
7474 "-icount [N|auto]\n"
7475 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
7477 "During emulation, the following keys are useful:\n"
7478 "ctrl-alt-f toggle full screen\n"
7479 "ctrl-alt-n switch to virtual console 'n'\n"
7480 "ctrl-alt toggle mouse and keyboard grab\n"
7482 "When using -nographic, press 'ctrl-a h' to get some help.\n"
7487 DEFAULT_NETWORK_SCRIPT
,
7488 DEFAULT_NETWORK_DOWN_SCRIPT
,
7490 DEFAULT_GDBSTUB_PORT
,
7495 #define HAS_ARG 0x0001
7510 QEMU_OPTION_mtdblock
,
7514 QEMU_OPTION_snapshot
,
7516 QEMU_OPTION_no_fd_bootchk
,
7519 QEMU_OPTION_nographic
,
7520 QEMU_OPTION_portrait
,
7522 QEMU_OPTION_audio_help
,
7523 QEMU_OPTION_soundhw
,
7544 QEMU_OPTION_localtime
,
7545 QEMU_OPTION_cirrusvga
,
7548 QEMU_OPTION_std_vga
,
7550 QEMU_OPTION_monitor
,
7552 QEMU_OPTION_parallel
,
7554 QEMU_OPTION_full_screen
,
7555 QEMU_OPTION_no_frame
,
7556 QEMU_OPTION_alt_grab
,
7557 QEMU_OPTION_no_quit
,
7558 QEMU_OPTION_pidfile
,
7559 QEMU_OPTION_no_kqemu
,
7560 QEMU_OPTION_kernel_kqemu
,
7561 QEMU_OPTION_win2k_hack
,
7563 QEMU_OPTION_usbdevice
,
7566 QEMU_OPTION_no_acpi
,
7568 QEMU_OPTION_no_reboot
,
7569 QEMU_OPTION_no_shutdown
,
7570 QEMU_OPTION_show_cursor
,
7571 QEMU_OPTION_daemonize
,
7572 QEMU_OPTION_option_rom
,
7573 QEMU_OPTION_semihosting
,
7575 QEMU_OPTION_prom_env
,
7576 QEMU_OPTION_old_param
,
7578 QEMU_OPTION_startdate
,
7579 QEMU_OPTION_tb_size
,
7583 typedef struct QEMUOption
{
7589 const QEMUOption qemu_options
[] = {
7590 { "h", 0, QEMU_OPTION_h
},
7591 { "help", 0, QEMU_OPTION_h
},
7593 { "M", HAS_ARG
, QEMU_OPTION_M
},
7594 { "cpu", HAS_ARG
, QEMU_OPTION_cpu
},
7595 { "fda", HAS_ARG
, QEMU_OPTION_fda
},
7596 { "fdb", HAS_ARG
, QEMU_OPTION_fdb
},
7597 { "hda", HAS_ARG
, QEMU_OPTION_hda
},
7598 { "hdb", HAS_ARG
, QEMU_OPTION_hdb
},
7599 { "hdc", HAS_ARG
, QEMU_OPTION_hdc
},
7600 { "hdd", HAS_ARG
, QEMU_OPTION_hdd
},
7601 { "drive", HAS_ARG
, QEMU_OPTION_drive
},
7602 { "cdrom", HAS_ARG
, QEMU_OPTION_cdrom
},
7603 { "mtdblock", HAS_ARG
, QEMU_OPTION_mtdblock
},
7604 { "sd", HAS_ARG
, QEMU_OPTION_sd
},
7605 { "pflash", HAS_ARG
, QEMU_OPTION_pflash
},
7606 { "boot", HAS_ARG
, QEMU_OPTION_boot
},
7607 { "snapshot", 0, QEMU_OPTION_snapshot
},
7609 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk
},
7611 { "m", HAS_ARG
, QEMU_OPTION_m
},
7612 { "nographic", 0, QEMU_OPTION_nographic
},
7613 { "portrait", 0, QEMU_OPTION_portrait
},
7614 { "k", HAS_ARG
, QEMU_OPTION_k
},
7616 { "audio-help", 0, QEMU_OPTION_audio_help
},
7617 { "soundhw", HAS_ARG
, QEMU_OPTION_soundhw
},
7620 { "net", HAS_ARG
, QEMU_OPTION_net
},
7622 { "tftp", HAS_ARG
, QEMU_OPTION_tftp
},
7623 { "bootp", HAS_ARG
, QEMU_OPTION_bootp
},
7625 { "smb", HAS_ARG
, QEMU_OPTION_smb
},
7627 { "redir", HAS_ARG
, QEMU_OPTION_redir
},
7630 { "kernel", HAS_ARG
, QEMU_OPTION_kernel
},
7631 { "append", HAS_ARG
, QEMU_OPTION_append
},
7632 { "initrd", HAS_ARG
, QEMU_OPTION_initrd
},
7634 { "S", 0, QEMU_OPTION_S
},
7635 { "s", 0, QEMU_OPTION_s
},
7636 { "p", HAS_ARG
, QEMU_OPTION_p
},
7637 { "d", HAS_ARG
, QEMU_OPTION_d
},
7638 { "hdachs", HAS_ARG
, QEMU_OPTION_hdachs
},
7639 { "L", HAS_ARG
, QEMU_OPTION_L
},
7640 { "bios", HAS_ARG
, QEMU_OPTION_bios
},
7642 { "no-kqemu", 0, QEMU_OPTION_no_kqemu
},
7643 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu
},
7645 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7646 { "g", 1, QEMU_OPTION_g
},
7648 { "localtime", 0, QEMU_OPTION_localtime
},
7649 { "std-vga", 0, QEMU_OPTION_std_vga
},
7650 { "echr", HAS_ARG
, QEMU_OPTION_echr
},
7651 { "monitor", HAS_ARG
, QEMU_OPTION_monitor
},
7652 { "serial", HAS_ARG
, QEMU_OPTION_serial
},
7653 { "parallel", HAS_ARG
, QEMU_OPTION_parallel
},
7654 { "loadvm", HAS_ARG
, QEMU_OPTION_loadvm
},
7655 { "full-screen", 0, QEMU_OPTION_full_screen
},
7657 { "no-frame", 0, QEMU_OPTION_no_frame
},
7658 { "alt-grab", 0, QEMU_OPTION_alt_grab
},
7659 { "no-quit", 0, QEMU_OPTION_no_quit
},
7661 { "pidfile", HAS_ARG
, QEMU_OPTION_pidfile
},
7662 { "win2k-hack", 0, QEMU_OPTION_win2k_hack
},
7663 { "usbdevice", HAS_ARG
, QEMU_OPTION_usbdevice
},
7664 { "smp", HAS_ARG
, QEMU_OPTION_smp
},
7665 { "vnc", HAS_ARG
, QEMU_OPTION_vnc
},
7666 #ifdef CONFIG_CURSES
7667 { "curses", 0, QEMU_OPTION_curses
},
7670 /* temporary options */
7671 { "usb", 0, QEMU_OPTION_usb
},
7672 { "cirrusvga", 0, QEMU_OPTION_cirrusvga
},
7673 { "vmwarevga", 0, QEMU_OPTION_vmsvga
},
7674 { "no-acpi", 0, QEMU_OPTION_no_acpi
},
7675 { "no-reboot", 0, QEMU_OPTION_no_reboot
},
7676 { "no-shutdown", 0, QEMU_OPTION_no_shutdown
},
7677 { "show-cursor", 0, QEMU_OPTION_show_cursor
},
7678 { "daemonize", 0, QEMU_OPTION_daemonize
},
7679 { "option-rom", HAS_ARG
, QEMU_OPTION_option_rom
},
7680 #if defined(TARGET_ARM) || defined(TARGET_M68K)
7681 { "semihosting", 0, QEMU_OPTION_semihosting
},
7683 { "name", HAS_ARG
, QEMU_OPTION_name
},
7684 #if defined(TARGET_SPARC)
7685 { "prom-env", HAS_ARG
, QEMU_OPTION_prom_env
},
7687 #if defined(TARGET_ARM)
7688 { "old-param", 0, QEMU_OPTION_old_param
},
7690 { "clock", HAS_ARG
, QEMU_OPTION_clock
},
7691 { "startdate", HAS_ARG
, QEMU_OPTION_startdate
},
7692 { "tb-size", HAS_ARG
, QEMU_OPTION_tb_size
},
7693 { "icount", HAS_ARG
, QEMU_OPTION_icount
},
7697 /* password input */
7699 int qemu_key_check(BlockDriverState
*bs
, const char *name
)
7704 if (!bdrv_is_encrypted(bs
))
7707 term_printf("%s is encrypted.\n", name
);
7708 for(i
= 0; i
< 3; i
++) {
7709 monitor_readline("Password: ", 1, password
, sizeof(password
));
7710 if (bdrv_set_key(bs
, password
) == 0)
7712 term_printf("invalid password\n");
7717 static BlockDriverState
*get_bdrv(int index
)
7719 if (index
> nb_drives
)
7721 return drives_table
[index
].bdrv
;
7724 static void read_passwords(void)
7726 BlockDriverState
*bs
;
7729 for(i
= 0; i
< 6; i
++) {
7732 qemu_key_check(bs
, bdrv_get_device_name(bs
));
7737 struct soundhw soundhw
[] = {
7738 #ifdef HAS_AUDIO_CHOICE
7739 #if defined(TARGET_I386) || defined(TARGET_MIPS)
7745 { .init_isa
= pcspk_audio_init
}
7750 "Creative Sound Blaster 16",
7753 { .init_isa
= SB16_init
}
7756 #ifdef CONFIG_CS4231A
7762 { .init_isa
= cs4231a_init
}
7770 "Yamaha YMF262 (OPL3)",
7772 "Yamaha YM3812 (OPL2)",
7776 { .init_isa
= Adlib_init
}
7783 "Gravis Ultrasound GF1",
7786 { .init_isa
= GUS_init
}
7793 "Intel 82801AA AC97 Audio",
7796 { .init_pci
= ac97_init
}
7802 "ENSONIQ AudioPCI ES1370",
7805 { .init_pci
= es1370_init
}
7809 { NULL
, NULL
, 0, 0, { NULL
} }
7812 static void select_soundhw (const char *optarg
)
7816 if (*optarg
== '?') {
7819 printf ("Valid sound card names (comma separated):\n");
7820 for (c
= soundhw
; c
->name
; ++c
) {
7821 printf ("%-11s %s\n", c
->name
, c
->descr
);
7823 printf ("\n-soundhw all will enable all of the above\n");
7824 exit (*optarg
!= '?');
7832 if (!strcmp (optarg
, "all")) {
7833 for (c
= soundhw
; c
->name
; ++c
) {
7841 e
= strchr (p
, ',');
7842 l
= !e
? strlen (p
) : (size_t) (e
- p
);
7844 for (c
= soundhw
; c
->name
; ++c
) {
7845 if (!strncmp (c
->name
, p
, l
)) {
7854 "Unknown sound card name (too big to show)\n");
7857 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
7862 p
+= l
+ (e
!= NULL
);
7866 goto show_valid_cards
;
7872 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
7874 exit(STATUS_CONTROL_C_EXIT
);
7879 #define MAX_NET_CLIENTS 32
7881 int main(int argc
, char **argv
)
7883 #ifdef CONFIG_GDBSTUB
7885 const char *gdbstub_port
;
7887 uint32_t boot_devices_bitmap
= 0;
7889 int snapshot
, linux_boot
, net_boot
;
7890 const char *initrd_filename
;
7891 const char *kernel_filename
, *kernel_cmdline
;
7892 const char *boot_devices
= "";
7893 DisplayState
*ds
= &display_state
;
7894 int cyls
, heads
, secs
, translation
;
7895 const char *net_clients
[MAX_NET_CLIENTS
];
7899 const char *r
, *optarg
;
7900 CharDriverState
*monitor_hd
;
7901 const char *monitor_device
;
7902 const char *serial_devices
[MAX_SERIAL_PORTS
];
7903 int serial_device_index
;
7904 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
7905 int parallel_device_index
;
7906 const char *loadvm
= NULL
;
7907 QEMUMachine
*machine
;
7908 const char *cpu_model
;
7909 const char *usb_devices
[MAX_USB_CMDLINE
];
7910 int usb_devices_index
;
7913 const char *pid_file
= NULL
;
7916 LIST_INIT (&vm_change_state_head
);
7919 struct sigaction act
;
7920 sigfillset(&act
.sa_mask
);
7922 act
.sa_handler
= SIG_IGN
;
7923 sigaction(SIGPIPE
, &act
, NULL
);
7926 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
7927 /* Note: cpu_interrupt() is currently not SMP safe, so we force
7928 QEMU to run on a single CPU */
7933 h
= GetCurrentProcess();
7934 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
7935 for(i
= 0; i
< 32; i
++) {
7936 if (mask
& (1 << i
))
7941 SetProcessAffinityMask(h
, mask
);
7947 register_machines();
7948 machine
= first_machine
;
7950 initrd_filename
= NULL
;
7952 vga_ram_size
= VGA_RAM_SIZE
;
7953 #ifdef CONFIG_GDBSTUB
7955 gdbstub_port
= DEFAULT_GDBSTUB_PORT
;
7960 kernel_filename
= NULL
;
7961 kernel_cmdline
= "";
7962 cyls
= heads
= secs
= 0;
7963 translation
= BIOS_ATA_TRANSLATION_AUTO
;
7964 monitor_device
= "vc";
7966 serial_devices
[0] = "vc:80Cx24C";
7967 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
7968 serial_devices
[i
] = NULL
;
7969 serial_device_index
= 0;
7971 parallel_devices
[0] = "vc:640x480";
7972 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
7973 parallel_devices
[i
] = NULL
;
7974 parallel_device_index
= 0;
7976 usb_devices_index
= 0;
7993 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
7995 const QEMUOption
*popt
;
7998 /* Treat --foo the same as -foo. */
8001 popt
= qemu_options
;
8004 fprintf(stderr
, "%s: invalid option -- '%s'\n",
8008 if (!strcmp(popt
->name
, r
+ 1))
8012 if (popt
->flags
& HAS_ARG
) {
8013 if (optind
>= argc
) {
8014 fprintf(stderr
, "%s: option '%s' requires an argument\n",
8018 optarg
= argv
[optind
++];
8023 switch(popt
->index
) {
8025 machine
= find_machine(optarg
);
8028 printf("Supported machines are:\n");
8029 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
8030 printf("%-10s %s%s\n",
8032 m
== first_machine
? " (default)" : "");
8034 exit(*optarg
!= '?');
8037 case QEMU_OPTION_cpu
:
8038 /* hw initialization will check this */
8039 if (*optarg
== '?') {
8040 /* XXX: implement xxx_cpu_list for targets that still miss it */
8041 #if defined(cpu_list)
8042 cpu_list(stdout
, &fprintf
);
8049 case QEMU_OPTION_initrd
:
8050 initrd_filename
= optarg
;
8052 case QEMU_OPTION_hda
:
8054 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
8056 hda_index
= drive_add(optarg
, HD_ALIAS
8057 ",cyls=%d,heads=%d,secs=%d%s",
8058 0, cyls
, heads
, secs
,
8059 translation
== BIOS_ATA_TRANSLATION_LBA
?
8061 translation
== BIOS_ATA_TRANSLATION_NONE
?
8062 ",trans=none" : "");
8064 case QEMU_OPTION_hdb
:
8065 case QEMU_OPTION_hdc
:
8066 case QEMU_OPTION_hdd
:
8067 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
8069 case QEMU_OPTION_drive
:
8070 drive_add(NULL
, "%s", optarg
);
8072 case QEMU_OPTION_mtdblock
:
8073 drive_add(optarg
, MTD_ALIAS
);
8075 case QEMU_OPTION_sd
:
8076 drive_add(optarg
, SD_ALIAS
);
8078 case QEMU_OPTION_pflash
:
8079 drive_add(optarg
, PFLASH_ALIAS
);
8081 case QEMU_OPTION_snapshot
:
8084 case QEMU_OPTION_hdachs
:
8088 cyls
= strtol(p
, (char **)&p
, 0);
8089 if (cyls
< 1 || cyls
> 16383)
8094 heads
= strtol(p
, (char **)&p
, 0);
8095 if (heads
< 1 || heads
> 16)
8100 secs
= strtol(p
, (char **)&p
, 0);
8101 if (secs
< 1 || secs
> 63)
8105 if (!strcmp(p
, "none"))
8106 translation
= BIOS_ATA_TRANSLATION_NONE
;
8107 else if (!strcmp(p
, "lba"))
8108 translation
= BIOS_ATA_TRANSLATION_LBA
;
8109 else if (!strcmp(p
, "auto"))
8110 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8113 } else if (*p
!= '\0') {
8115 fprintf(stderr
, "qemu: invalid physical CHS format\n");
8118 if (hda_index
!= -1)
8119 snprintf(drives_opt
[hda_index
].opt
,
8120 sizeof(drives_opt
[hda_index
].opt
),
8121 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
8122 0, cyls
, heads
, secs
,
8123 translation
== BIOS_ATA_TRANSLATION_LBA
?
8125 translation
== BIOS_ATA_TRANSLATION_NONE
?
8126 ",trans=none" : "");
8129 case QEMU_OPTION_nographic
:
8130 serial_devices
[0] = "stdio";
8131 parallel_devices
[0] = "null";
8132 monitor_device
= "stdio";
8135 #ifdef CONFIG_CURSES
8136 case QEMU_OPTION_curses
:
8140 case QEMU_OPTION_portrait
:
8143 case QEMU_OPTION_kernel
:
8144 kernel_filename
= optarg
;
8146 case QEMU_OPTION_append
:
8147 kernel_cmdline
= optarg
;
8149 case QEMU_OPTION_cdrom
:
8150 drive_add(optarg
, CDROM_ALIAS
);
8152 case QEMU_OPTION_boot
:
8153 boot_devices
= optarg
;
8154 /* We just do some generic consistency checks */
8156 /* Could easily be extended to 64 devices if needed */
8159 boot_devices_bitmap
= 0;
8160 for (p
= boot_devices
; *p
!= '\0'; p
++) {
8161 /* Allowed boot devices are:
8162 * a b : floppy disk drives
8163 * c ... f : IDE disk drives
8164 * g ... m : machine implementation dependant drives
8165 * n ... p : network devices
8166 * It's up to each machine implementation to check
8167 * if the given boot devices match the actual hardware
8168 * implementation and firmware features.
8170 if (*p
< 'a' || *p
> 'q') {
8171 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
8174 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
8176 "Boot device '%c' was given twice\n",*p
);
8179 boot_devices_bitmap
|= 1 << (*p
- 'a');
8183 case QEMU_OPTION_fda
:
8184 case QEMU_OPTION_fdb
:
8185 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
8188 case QEMU_OPTION_no_fd_bootchk
:
8192 case QEMU_OPTION_net
:
8193 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
8194 fprintf(stderr
, "qemu: too many network clients\n");
8197 net_clients
[nb_net_clients
] = optarg
;
8201 case QEMU_OPTION_tftp
:
8202 tftp_prefix
= optarg
;
8204 case QEMU_OPTION_bootp
:
8205 bootp_filename
= optarg
;
8208 case QEMU_OPTION_smb
:
8209 net_slirp_smb(optarg
);
8212 case QEMU_OPTION_redir
:
8213 net_slirp_redir(optarg
);
8217 case QEMU_OPTION_audio_help
:
8221 case QEMU_OPTION_soundhw
:
8222 select_soundhw (optarg
);
8228 case QEMU_OPTION_m
: {
8232 value
= strtoul(optarg
, &ptr
, 10);
8234 case 0: case 'M': case 'm':
8241 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
8245 /* On 32-bit hosts, QEMU is limited by virtual address space */
8246 if (value
> (2047 << 20)
8248 && HOST_LONG_BITS
== 32
8251 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
8254 if (value
!= (uint64_t)(ram_addr_t
)value
) {
8255 fprintf(stderr
, "qemu: ram size too large\n");
8266 mask
= cpu_str_to_log_mask(optarg
);
8268 printf("Log items (comma separated):\n");
8269 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
8270 printf("%-10s %s\n", item
->name
, item
->help
);
8277 #ifdef CONFIG_GDBSTUB
8282 gdbstub_port
= optarg
;
8288 case QEMU_OPTION_bios
:
8295 keyboard_layout
= optarg
;
8297 case QEMU_OPTION_localtime
:
8300 case QEMU_OPTION_cirrusvga
:
8301 cirrus_vga_enabled
= 1;
8304 case QEMU_OPTION_vmsvga
:
8305 cirrus_vga_enabled
= 0;
8308 case QEMU_OPTION_std_vga
:
8309 cirrus_vga_enabled
= 0;
8317 w
= strtol(p
, (char **)&p
, 10);
8320 fprintf(stderr
, "qemu: invalid resolution or depth\n");
8326 h
= strtol(p
, (char **)&p
, 10);
8331 depth
= strtol(p
, (char **)&p
, 10);
8332 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
8333 depth
!= 24 && depth
!= 32)
8335 } else if (*p
== '\0') {
8336 depth
= graphic_depth
;
8343 graphic_depth
= depth
;
8346 case QEMU_OPTION_echr
:
8349 term_escape_char
= strtol(optarg
, &r
, 0);
8351 printf("Bad argument to echr\n");
8354 case QEMU_OPTION_monitor
:
8355 monitor_device
= optarg
;
8357 case QEMU_OPTION_serial
:
8358 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
8359 fprintf(stderr
, "qemu: too many serial ports\n");
8362 serial_devices
[serial_device_index
] = optarg
;
8363 serial_device_index
++;
8365 case QEMU_OPTION_parallel
:
8366 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
8367 fprintf(stderr
, "qemu: too many parallel ports\n");
8370 parallel_devices
[parallel_device_index
] = optarg
;
8371 parallel_device_index
++;
8373 case QEMU_OPTION_loadvm
:
8376 case QEMU_OPTION_full_screen
:
8380 case QEMU_OPTION_no_frame
:
8383 case QEMU_OPTION_alt_grab
:
8386 case QEMU_OPTION_no_quit
:
8390 case QEMU_OPTION_pidfile
:
8394 case QEMU_OPTION_win2k_hack
:
8395 win2k_install_hack
= 1;
8399 case QEMU_OPTION_no_kqemu
:
8402 case QEMU_OPTION_kernel_kqemu
:
8406 case QEMU_OPTION_usb
:
8409 case QEMU_OPTION_usbdevice
:
8411 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
8412 fprintf(stderr
, "Too many USB devices\n");
8415 usb_devices
[usb_devices_index
] = optarg
;
8416 usb_devices_index
++;
8418 case QEMU_OPTION_smp
:
8419 smp_cpus
= atoi(optarg
);
8420 if (smp_cpus
< 1 || smp_cpus
> MAX_CPUS
) {
8421 fprintf(stderr
, "Invalid number of CPUs\n");
8425 case QEMU_OPTION_vnc
:
8426 vnc_display
= optarg
;
8428 case QEMU_OPTION_no_acpi
:
8431 case QEMU_OPTION_no_reboot
:
8434 case QEMU_OPTION_no_shutdown
:
8437 case QEMU_OPTION_show_cursor
:
8440 case QEMU_OPTION_daemonize
:
8443 case QEMU_OPTION_option_rom
:
8444 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
8445 fprintf(stderr
, "Too many option ROMs\n");
8448 option_rom
[nb_option_roms
] = optarg
;
8451 case QEMU_OPTION_semihosting
:
8452 semihosting_enabled
= 1;
8454 case QEMU_OPTION_name
:
8458 case QEMU_OPTION_prom_env
:
8459 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
8460 fprintf(stderr
, "Too many prom variables\n");
8463 prom_envs
[nb_prom_envs
] = optarg
;
8468 case QEMU_OPTION_old_param
:
8472 case QEMU_OPTION_clock
:
8473 configure_alarms(optarg
);
8475 case QEMU_OPTION_startdate
:
8478 time_t rtc_start_date
;
8479 if (!strcmp(optarg
, "now")) {
8480 rtc_date_offset
= -1;
8482 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
8490 } else if (sscanf(optarg
, "%d-%d-%d",
8493 &tm
.tm_mday
) == 3) {
8502 rtc_start_date
= mktimegm(&tm
);
8503 if (rtc_start_date
== -1) {
8505 fprintf(stderr
, "Invalid date format. Valid format are:\n"
8506 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
8509 rtc_date_offset
= time(NULL
) - rtc_start_date
;
8513 case QEMU_OPTION_tb_size
:
8514 tb_size
= strtol(optarg
, NULL
, 0);
8518 case QEMU_OPTION_icount
:
8520 if (strcmp(optarg
, "auto") == 0) {
8521 icount_time_shift
= -1;
8523 icount_time_shift
= strtol(optarg
, NULL
, 0);
8531 if (daemonize
&& !nographic
&& vnc_display
== NULL
) {
8532 fprintf(stderr
, "Can only daemonize if using -nographic or -vnc\n");
8539 if (pipe(fds
) == -1)
8550 len
= read(fds
[0], &status
, 1);
8551 if (len
== -1 && (errno
== EINTR
))
8556 else if (status
== 1) {
8557 fprintf(stderr
, "Could not acquire pidfile\n");
8575 signal(SIGTSTP
, SIG_IGN
);
8576 signal(SIGTTOU
, SIG_IGN
);
8577 signal(SIGTTIN
, SIG_IGN
);
8581 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
8584 write(fds
[1], &status
, 1);
8586 fprintf(stderr
, "Could not acquire pid file\n");
8594 linux_boot
= (kernel_filename
!= NULL
);
8595 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
8597 /* XXX: this should not be: some embedded targets just have flash */
8598 if (!linux_boot
&& net_boot
== 0 &&
8602 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
8603 fprintf(stderr
, "-append only allowed with -kernel option\n");
8607 if (!linux_boot
&& initrd_filename
!= NULL
) {
8608 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
8612 /* boot to floppy or the default cd if no hard disk defined yet */
8613 if (!boot_devices
[0]) {
8614 boot_devices
= "cad";
8616 setvbuf(stdout
, NULL
, _IOLBF
, 0);
8621 if (use_icount
&& icount_time_shift
< 0) {
8623 /* 125MIPS seems a reasonable initial guess at the guest speed.
8624 It will be corrected fairly quickly anyway. */
8625 icount_time_shift
= 3;
8626 init_icount_adjust();
8633 /* init network clients */
8634 if (nb_net_clients
== 0) {
8635 /* if no clients, we use a default config */
8636 net_clients
[0] = "nic";
8637 net_clients
[1] = "user";
8641 for(i
= 0;i
< nb_net_clients
; i
++) {
8642 if (net_client_init(net_clients
[i
]) < 0)
8645 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
8646 if (vlan
->nb_guest_devs
== 0 && vlan
->nb_host_devs
== 0)
8648 if (vlan
->nb_guest_devs
== 0) {
8649 fprintf(stderr
, "Invalid vlan (%d) with no nics\n", vlan
->id
);
8652 if (vlan
->nb_host_devs
== 0)
8654 "Warning: vlan %d is not connected to host network\n",
8659 /* XXX: this should be moved in the PC machine instantiation code */
8660 if (net_boot
!= 0) {
8662 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
8663 const char *model
= nd_table
[i
].model
;
8665 if (net_boot
& (1 << i
)) {
8668 snprintf(buf
, sizeof(buf
), "%s/pxe-%s.bin", bios_dir
, model
);
8669 if (get_image_size(buf
) > 0) {
8670 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
8671 fprintf(stderr
, "Too many option ROMs\n");
8674 option_rom
[nb_option_roms
] = strdup(buf
);
8681 fprintf(stderr
, "No valid PXE rom found for network device\n");
8687 /* init the memory */
8688 phys_ram_size
= machine
->ram_require
& ~RAMSIZE_FIXED
;
8690 if (machine
->ram_require
& RAMSIZE_FIXED
) {
8692 if (ram_size
< phys_ram_size
) {
8693 fprintf(stderr
, "Machine `%s' requires %llu bytes of memory\n",
8694 machine
->name
, (unsigned long long) phys_ram_size
);
8698 phys_ram_size
= ram_size
;
8700 ram_size
= phys_ram_size
;
8703 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
8705 phys_ram_size
+= ram_size
;
8708 phys_ram_base
= qemu_vmalloc(phys_ram_size
);
8709 if (!phys_ram_base
) {
8710 fprintf(stderr
, "Could not allocate physical memory\n");
8714 /* init the dynamic translator */
8715 cpu_exec_init_all(tb_size
* 1024 * 1024);
8719 /* we always create the cdrom drive, even if no disk is there */
8721 if (nb_drives_opt
< MAX_DRIVES
)
8722 drive_add(NULL
, CDROM_ALIAS
);
8724 /* we always create at least one floppy */
8726 if (nb_drives_opt
< MAX_DRIVES
)
8727 drive_add(NULL
, FD_ALIAS
, 0);
8729 /* we always create one sd slot, even if no card is in it */
8731 if (nb_drives_opt
< MAX_DRIVES
)
8732 drive_add(NULL
, SD_ALIAS
);
8734 /* open the virtual block devices */
8736 for(i
= 0; i
< nb_drives_opt
; i
++)
8737 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
8740 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
8741 register_savevm("ram", 0, 2, ram_save
, ram_load
, NULL
);
8746 memset(&display_state
, 0, sizeof(display_state
));
8749 fprintf(stderr
, "fatal: -nographic can't be used with -curses\n");
8752 /* nearly nothing to do */
8753 dumb_display_init(ds
);
8754 } else if (vnc_display
!= NULL
) {
8755 vnc_display_init(ds
);
8756 if (vnc_display_open(ds
, vnc_display
) < 0)
8759 #if defined(CONFIG_CURSES)
8761 curses_display_init(ds
, full_screen
);
8765 #if defined(CONFIG_SDL)
8766 sdl_display_init(ds
, full_screen
, no_frame
);
8767 #elif defined(CONFIG_COCOA)
8768 cocoa_display_init(ds
, full_screen
);
8770 dumb_display_init(ds
);
8774 /* Maintain compatibility with multiple stdio monitors */
8775 if (!strcmp(monitor_device
,"stdio")) {
8776 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
8777 const char *devname
= serial_devices
[i
];
8778 if (devname
&& !strcmp(devname
,"mon:stdio")) {
8779 monitor_device
= NULL
;
8781 } else if (devname
&& !strcmp(devname
,"stdio")) {
8782 monitor_device
= NULL
;
8783 serial_devices
[i
] = "mon:stdio";
8788 if (monitor_device
) {
8789 monitor_hd
= qemu_chr_open(monitor_device
);
8791 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
8794 monitor_init(monitor_hd
, !nographic
);
8797 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
8798 const char *devname
= serial_devices
[i
];
8799 if (devname
&& strcmp(devname
, "none")) {
8800 serial_hds
[i
] = qemu_chr_open(devname
);
8801 if (!serial_hds
[i
]) {
8802 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
8806 if (strstart(devname
, "vc", 0))
8807 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
8811 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
8812 const char *devname
= parallel_devices
[i
];
8813 if (devname
&& strcmp(devname
, "none")) {
8814 parallel_hds
[i
] = qemu_chr_open(devname
);
8815 if (!parallel_hds
[i
]) {
8816 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
8820 if (strstart(devname
, "vc", 0))
8821 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
8825 machine
->init(ram_size
, vga_ram_size
, boot_devices
, ds
,
8826 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
8828 /* init USB devices */
8830 for(i
= 0; i
< usb_devices_index
; i
++) {
8831 if (usb_device_add(usb_devices
[i
]) < 0) {
8832 fprintf(stderr
, "Warning: could not add USB device %s\n",
8838 if (display_state
.dpy_refresh
) {
8839 display_state
.gui_timer
= qemu_new_timer(rt_clock
, gui_update
, &display_state
);
8840 qemu_mod_timer(display_state
.gui_timer
, qemu_get_clock(rt_clock
));
8843 #ifdef CONFIG_GDBSTUB
8845 /* XXX: use standard host:port notation and modify options
8847 if (gdbserver_start(gdbstub_port
) < 0) {
8848 fprintf(stderr
, "qemu: could not open gdbstub device on port '%s'\n",
8859 /* XXX: simplify init */
8872 len
= write(fds
[1], &status
, 1);
8873 if (len
== -1 && (errno
== EINTR
))
8879 TFR(fd
= open("/dev/null", O_RDWR
));
8893 #if !defined(_WIN32)
8894 /* close network clients */
8895 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
8896 VLANClientState
*vc
;
8898 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
8899 if (vc
->fd_read
== tap_receive
) {
8901 TAPState
*s
= vc
->opaque
;
8903 if (sscanf(vc
->info_str
, "tap: ifname=%63s ", ifname
) == 1 &&
8905 launch_script(s
->down_script
, ifname
, s
->fd
);