4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "hw/boards.h"
27 #include "hw/pcmcia.h"
29 #include "hw/audiodev.h"
37 #include "qemu-timer.h"
38 #include "qemu-char.h"
40 #include "audio/audio.h"
51 #include <sys/times.h>
56 #include <sys/ioctl.h>
57 #include <sys/socket.h>
58 #include <netinet/in.h>
61 #include <sys/select.h>
62 #include <arpa/inet.h>
65 #if !defined(__APPLE__) && !defined(__OpenBSD__)
71 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72 #include <freebsd/stdlib.h>
76 #include <linux/if_tun.h>
79 #include <linux/rtc.h>
81 /* For the benefit of older linux systems which don't supply it,
82 we use a local copy of hpet.h. */
83 /* #include <linux/hpet.h> */
86 #include <linux/ppdev.h>
87 #include <linux/parport.h>
91 #include <sys/ethernet.h>
92 #include <sys/sockio.h>
93 #include <netinet/arp.h>
94 #include <netinet/in.h>
95 #include <netinet/in_systm.h>
96 #include <netinet/ip.h>
97 #include <netinet/ip_icmp.h> // must come after ip.h
98 #include <netinet/udp.h>
99 #include <netinet/tcp.h>
107 #include "qemu_socket.h"
109 #if defined(CONFIG_SLIRP)
110 #include "libslirp.h"
113 #if defined(__OpenBSD__)
117 #if defined(CONFIG_VDE)
118 #include <libvdeplug.h>
123 #include <sys/timeb.h>
124 #include <mmsystem.h>
125 #define getopt_long_only getopt_long
126 #define memalign(align, size) malloc(size)
133 #endif /* CONFIG_SDL */
137 #define main qemu_main
138 #endif /* CONFIG_COCOA */
142 #include "exec-all.h"
144 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
145 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
147 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
149 #define SMBD_COMMAND "/usr/sbin/smbd"
152 //#define DEBUG_UNUSED_IOPORT
153 //#define DEBUG_IOPORT
155 //#define DEBUG_SLIRP
158 #define DEFAULT_RAM_SIZE 144
160 #define DEFAULT_RAM_SIZE 128
163 /* Max number of USB devices that can be specified on the commandline. */
164 #define MAX_USB_CMDLINE 8
166 /* XXX: use a two level table to limit memory usage */
167 #define MAX_IOPORTS 65536
169 const char *bios_dir
= CONFIG_QEMU_SHAREDIR
;
170 const char *bios_name
= NULL
;
171 static void *ioport_opaque
[MAX_IOPORTS
];
172 static IOPortReadFunc
*ioport_read_table
[3][MAX_IOPORTS
];
173 static IOPortWriteFunc
*ioport_write_table
[3][MAX_IOPORTS
];
174 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
175 to store the VM snapshots */
176 DriveInfo drives_table
[MAX_DRIVES
+1];
178 /* point to the block driver where the snapshots are managed */
179 static BlockDriverState
*bs_snapshots
;
180 static int vga_ram_size
;
181 enum vga_retrace_method vga_retrace_method
= VGA_RETRACE_DUMB
;
182 static DisplayState display_state
;
185 const char* keyboard_layout
= NULL
;
186 int64_t ticks_per_sec
;
189 NICInfo nd_table
[MAX_NICS
];
191 static int rtc_utc
= 1;
192 static int rtc_date_offset
= -1; /* -1 means no change */
193 int cirrus_vga_enabled
= 1;
194 int vmsvga_enabled
= 0;
196 int graphic_width
= 1024;
197 int graphic_height
= 768;
198 int graphic_depth
= 8;
200 int graphic_width
= 800;
201 int graphic_height
= 600;
202 int graphic_depth
= 15;
204 static int full_screen
= 0;
205 static int no_frame
= 0;
207 CharDriverState
*serial_hds
[MAX_SERIAL_PORTS
];
208 CharDriverState
*parallel_hds
[MAX_PARALLEL_PORTS
];
210 int win2k_install_hack
= 0;
213 static VLANState
*first_vlan
;
215 const char *vnc_display
;
216 #if defined(TARGET_SPARC)
218 #elif defined(TARGET_I386)
223 int acpi_enabled
= 1;
228 int graphic_rotate
= 0;
230 const char *option_rom
[MAX_OPTION_ROMS
];
232 int semihosting_enabled
= 0;
236 const char *qemu_name
;
239 unsigned int nb_prom_envs
= 0;
240 const char *prom_envs
[MAX_PROM_ENVS
];
242 static int nb_drives_opt
;
243 static struct drive_opt
{
246 } drives_opt
[MAX_DRIVES
];
248 static CPUState
*cur_cpu
;
249 static CPUState
*next_cpu
;
250 static int event_pending
= 1;
251 /* Conversion factor from emulated instructions to virtual clock ticks. */
252 static int icount_time_shift
;
253 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
254 #define MAX_ICOUNT_SHIFT 10
255 /* Compensate for varying guest execution speed. */
256 static int64_t qemu_icount_bias
;
257 static QEMUTimer
*icount_rt_timer
;
258 static QEMUTimer
*icount_vm_timer
;
260 uint8_t qemu_uuid
[16];
262 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
264 /***********************************************************/
265 /* x86 ISA bus support */
267 target_phys_addr_t isa_mem_base
= 0;
270 static IOPortReadFunc default_ioport_readb
, default_ioport_readw
, default_ioport_readl
;
271 static IOPortWriteFunc default_ioport_writeb
, default_ioport_writew
, default_ioport_writel
;
273 static uint32_t ioport_read(int index
, uint32_t address
)
275 static IOPortReadFunc
*default_func
[3] = {
276 default_ioport_readb
,
277 default_ioport_readw
,
280 IOPortReadFunc
*func
= ioport_read_table
[index
][address
];
282 func
= default_func
[index
];
283 return func(ioport_opaque
[address
], address
);
286 static void ioport_write(int index
, uint32_t address
, uint32_t data
)
288 static IOPortWriteFunc
*default_func
[3] = {
289 default_ioport_writeb
,
290 default_ioport_writew
,
291 default_ioport_writel
293 IOPortWriteFunc
*func
= ioport_write_table
[index
][address
];
295 func
= default_func
[index
];
296 func(ioport_opaque
[address
], address
, data
);
299 static uint32_t default_ioport_readb(void *opaque
, uint32_t address
)
301 #ifdef DEBUG_UNUSED_IOPORT
302 fprintf(stderr
, "unused inb: port=0x%04x\n", address
);
307 static void default_ioport_writeb(void *opaque
, uint32_t address
, uint32_t data
)
309 #ifdef DEBUG_UNUSED_IOPORT
310 fprintf(stderr
, "unused outb: port=0x%04x data=0x%02x\n", address
, data
);
314 /* default is to make two byte accesses */
315 static uint32_t default_ioport_readw(void *opaque
, uint32_t address
)
318 data
= ioport_read(0, address
);
319 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
320 data
|= ioport_read(0, address
) << 8;
324 static void default_ioport_writew(void *opaque
, uint32_t address
, uint32_t data
)
326 ioport_write(0, address
, data
& 0xff);
327 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
328 ioport_write(0, address
, (data
>> 8) & 0xff);
331 static uint32_t default_ioport_readl(void *opaque
, uint32_t address
)
333 #ifdef DEBUG_UNUSED_IOPORT
334 fprintf(stderr
, "unused inl: port=0x%04x\n", address
);
339 static void default_ioport_writel(void *opaque
, uint32_t address
, uint32_t data
)
341 #ifdef DEBUG_UNUSED_IOPORT
342 fprintf(stderr
, "unused outl: port=0x%04x data=0x%02x\n", address
, data
);
346 /* size is the word size in byte */
347 int register_ioport_read(int start
, int length
, int size
,
348 IOPortReadFunc
*func
, void *opaque
)
354 } else if (size
== 2) {
356 } else if (size
== 4) {
359 hw_error("register_ioport_read: invalid size");
362 for(i
= start
; i
< start
+ length
; i
+= size
) {
363 ioport_read_table
[bsize
][i
] = func
;
364 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
365 hw_error("register_ioport_read: invalid opaque");
366 ioport_opaque
[i
] = opaque
;
371 /* size is the word size in byte */
372 int register_ioport_write(int start
, int length
, int size
,
373 IOPortWriteFunc
*func
, void *opaque
)
379 } else if (size
== 2) {
381 } else if (size
== 4) {
384 hw_error("register_ioport_write: invalid size");
387 for(i
= start
; i
< start
+ length
; i
+= size
) {
388 ioport_write_table
[bsize
][i
] = func
;
389 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
390 hw_error("register_ioport_write: invalid opaque");
391 ioport_opaque
[i
] = opaque
;
396 void isa_unassign_ioport(int start
, int length
)
400 for(i
= start
; i
< start
+ length
; i
++) {
401 ioport_read_table
[0][i
] = default_ioport_readb
;
402 ioport_read_table
[1][i
] = default_ioport_readw
;
403 ioport_read_table
[2][i
] = default_ioport_readl
;
405 ioport_write_table
[0][i
] = default_ioport_writeb
;
406 ioport_write_table
[1][i
] = default_ioport_writew
;
407 ioport_write_table
[2][i
] = default_ioport_writel
;
411 /***********************************************************/
413 void cpu_outb(CPUState
*env
, int addr
, int val
)
416 if (loglevel
& CPU_LOG_IOPORT
)
417 fprintf(logfile
, "outb: %04x %02x\n", addr
, val
);
419 ioport_write(0, addr
, val
);
422 env
->last_io_time
= cpu_get_time_fast();
426 void cpu_outw(CPUState
*env
, int addr
, int val
)
429 if (loglevel
& CPU_LOG_IOPORT
)
430 fprintf(logfile
, "outw: %04x %04x\n", addr
, val
);
432 ioport_write(1, addr
, val
);
435 env
->last_io_time
= cpu_get_time_fast();
439 void cpu_outl(CPUState
*env
, int addr
, int val
)
442 if (loglevel
& CPU_LOG_IOPORT
)
443 fprintf(logfile
, "outl: %04x %08x\n", addr
, val
);
445 ioport_write(2, addr
, val
);
448 env
->last_io_time
= cpu_get_time_fast();
452 int cpu_inb(CPUState
*env
, int addr
)
455 val
= ioport_read(0, addr
);
457 if (loglevel
& CPU_LOG_IOPORT
)
458 fprintf(logfile
, "inb : %04x %02x\n", addr
, val
);
462 env
->last_io_time
= cpu_get_time_fast();
467 int cpu_inw(CPUState
*env
, int addr
)
470 val
= ioport_read(1, addr
);
472 if (loglevel
& CPU_LOG_IOPORT
)
473 fprintf(logfile
, "inw : %04x %04x\n", addr
, val
);
477 env
->last_io_time
= cpu_get_time_fast();
482 int cpu_inl(CPUState
*env
, int addr
)
485 val
= ioport_read(2, addr
);
487 if (loglevel
& CPU_LOG_IOPORT
)
488 fprintf(logfile
, "inl : %04x %08x\n", addr
, val
);
492 env
->last_io_time
= cpu_get_time_fast();
497 /***********************************************************/
498 void hw_error(const char *fmt
, ...)
504 fprintf(stderr
, "qemu: hardware error: ");
505 vfprintf(stderr
, fmt
, ap
);
506 fprintf(stderr
, "\n");
507 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
508 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
510 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
512 cpu_dump_state(env
, stderr
, fprintf
, 0);
519 /***********************************************************/
522 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
523 static void *qemu_put_kbd_event_opaque
;
524 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
525 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
527 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
529 qemu_put_kbd_event_opaque
= opaque
;
530 qemu_put_kbd_event
= func
;
533 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
534 void *opaque
, int absolute
,
537 QEMUPutMouseEntry
*s
, *cursor
;
539 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
543 s
->qemu_put_mouse_event
= func
;
544 s
->qemu_put_mouse_event_opaque
= opaque
;
545 s
->qemu_put_mouse_event_absolute
= absolute
;
546 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
549 if (!qemu_put_mouse_event_head
) {
550 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
554 cursor
= qemu_put_mouse_event_head
;
555 while (cursor
->next
!= NULL
)
556 cursor
= cursor
->next
;
559 qemu_put_mouse_event_current
= s
;
564 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
566 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
568 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
571 cursor
= qemu_put_mouse_event_head
;
572 while (cursor
!= NULL
&& cursor
!= entry
) {
574 cursor
= cursor
->next
;
577 if (cursor
== NULL
) // does not exist or list empty
579 else if (prev
== NULL
) { // entry is head
580 qemu_put_mouse_event_head
= cursor
->next
;
581 if (qemu_put_mouse_event_current
== entry
)
582 qemu_put_mouse_event_current
= cursor
->next
;
583 qemu_free(entry
->qemu_put_mouse_event_name
);
588 prev
->next
= entry
->next
;
590 if (qemu_put_mouse_event_current
== entry
)
591 qemu_put_mouse_event_current
= prev
;
593 qemu_free(entry
->qemu_put_mouse_event_name
);
597 void kbd_put_keycode(int keycode
)
599 if (qemu_put_kbd_event
) {
600 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
604 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
606 QEMUPutMouseEvent
*mouse_event
;
607 void *mouse_event_opaque
;
610 if (!qemu_put_mouse_event_current
) {
615 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
617 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
620 if (graphic_rotate
) {
621 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
624 width
= graphic_width
- 1;
625 mouse_event(mouse_event_opaque
,
626 width
- dy
, dx
, dz
, buttons_state
);
628 mouse_event(mouse_event_opaque
,
629 dx
, dy
, dz
, buttons_state
);
633 int kbd_mouse_is_absolute(void)
635 if (!qemu_put_mouse_event_current
)
638 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
641 void do_info_mice(void)
643 QEMUPutMouseEntry
*cursor
;
646 if (!qemu_put_mouse_event_head
) {
647 term_printf("No mouse devices connected\n");
651 term_printf("Mouse devices available:\n");
652 cursor
= qemu_put_mouse_event_head
;
653 while (cursor
!= NULL
) {
654 term_printf("%c Mouse #%d: %s\n",
655 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
656 index
, cursor
->qemu_put_mouse_event_name
);
658 cursor
= cursor
->next
;
662 void do_mouse_set(int index
)
664 QEMUPutMouseEntry
*cursor
;
667 if (!qemu_put_mouse_event_head
) {
668 term_printf("No mouse devices connected\n");
672 cursor
= qemu_put_mouse_event_head
;
673 while (cursor
!= NULL
&& index
!= i
) {
675 cursor
= cursor
->next
;
679 qemu_put_mouse_event_current
= cursor
;
681 term_printf("Mouse at given index not found\n");
684 /* compute with 96 bit intermediate result: (a*b)/c */
685 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
690 #ifdef WORDS_BIGENDIAN
700 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
701 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
704 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
708 /***********************************************************/
709 /* real time host monotonic timer */
711 #define QEMU_TIMER_BASE 1000000000LL
715 static int64_t clock_freq
;
717 static void init_get_clock(void)
721 ret
= QueryPerformanceFrequency(&freq
);
723 fprintf(stderr
, "Could not calibrate ticks\n");
726 clock_freq
= freq
.QuadPart
;
729 static int64_t get_clock(void)
732 QueryPerformanceCounter(&ti
);
733 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
738 static int use_rt_clock
;
740 static void init_get_clock(void)
743 #if defined(__linux__)
746 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
753 static int64_t get_clock(void)
755 #if defined(__linux__)
758 clock_gettime(CLOCK_MONOTONIC
, &ts
);
759 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
763 /* XXX: using gettimeofday leads to problems if the date
764 changes, so it should be avoided. */
766 gettimeofday(&tv
, NULL
);
767 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
772 /* Return the virtual CPU time, based on the instruction counter. */
773 static int64_t cpu_get_icount(void)
776 CPUState
*env
= cpu_single_env
;;
777 icount
= qemu_icount
;
780 fprintf(stderr
, "Bad clock read\n");
781 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
783 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
786 /***********************************************************/
787 /* guest cycle counter */
789 static int64_t cpu_ticks_prev
;
790 static int64_t cpu_ticks_offset
;
791 static int64_t cpu_clock_offset
;
792 static int cpu_ticks_enabled
;
794 /* return the host CPU cycle counter and handle stop/restart */
795 int64_t cpu_get_ticks(void)
798 return cpu_get_icount();
800 if (!cpu_ticks_enabled
) {
801 return cpu_ticks_offset
;
804 ticks
= cpu_get_real_ticks();
805 if (cpu_ticks_prev
> ticks
) {
806 /* Note: non increasing ticks may happen if the host uses
808 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
810 cpu_ticks_prev
= ticks
;
811 return ticks
+ cpu_ticks_offset
;
815 /* return the host CPU monotonic timer and handle stop/restart */
816 static int64_t cpu_get_clock(void)
819 if (!cpu_ticks_enabled
) {
820 return cpu_clock_offset
;
823 return ti
+ cpu_clock_offset
;
827 /* enable cpu_get_ticks() */
828 void cpu_enable_ticks(void)
830 if (!cpu_ticks_enabled
) {
831 cpu_ticks_offset
-= cpu_get_real_ticks();
832 cpu_clock_offset
-= get_clock();
833 cpu_ticks_enabled
= 1;
837 /* disable cpu_get_ticks() : the clock is stopped. You must not call
838 cpu_get_ticks() after that. */
839 void cpu_disable_ticks(void)
841 if (cpu_ticks_enabled
) {
842 cpu_ticks_offset
= cpu_get_ticks();
843 cpu_clock_offset
= cpu_get_clock();
844 cpu_ticks_enabled
= 0;
848 /***********************************************************/
851 #define QEMU_TIMER_REALTIME 0
852 #define QEMU_TIMER_VIRTUAL 1
856 /* XXX: add frequency */
864 struct QEMUTimer
*next
;
867 struct qemu_alarm_timer
{
871 int (*start
)(struct qemu_alarm_timer
*t
);
872 void (*stop
)(struct qemu_alarm_timer
*t
);
873 void (*rearm
)(struct qemu_alarm_timer
*t
);
877 #define ALARM_FLAG_DYNTICKS 0x1
878 #define ALARM_FLAG_EXPIRED 0x2
880 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
882 return t
->flags
& ALARM_FLAG_DYNTICKS
;
885 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
887 if (!alarm_has_dynticks(t
))
893 /* TODO: MIN_TIMER_REARM_US should be optimized */
894 #define MIN_TIMER_REARM_US 250
896 static struct qemu_alarm_timer
*alarm_timer
;
900 struct qemu_alarm_win32
{
904 } alarm_win32_data
= {0, NULL
, -1};
906 static int win32_start_timer(struct qemu_alarm_timer
*t
);
907 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
908 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
912 static int unix_start_timer(struct qemu_alarm_timer
*t
);
913 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
917 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
918 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
919 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
921 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
922 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
924 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
925 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
927 #endif /* __linux__ */
931 /* Correlation between real and virtual time is always going to be
932 fairly approximate, so ignore small variation.
933 When the guest is idle real and virtual time will be aligned in
935 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
937 static void icount_adjust(void)
942 static int64_t last_delta
;
943 /* If the VM is not running, then do nothing. */
947 cur_time
= cpu_get_clock();
948 cur_icount
= qemu_get_clock(vm_clock
);
949 delta
= cur_icount
- cur_time
;
950 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
952 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
953 && icount_time_shift
> 0) {
954 /* The guest is getting too far ahead. Slow time down. */
958 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
959 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
960 /* The guest is getting too far behind. Speed time up. */
964 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
967 static void icount_adjust_rt(void * opaque
)
969 qemu_mod_timer(icount_rt_timer
,
970 qemu_get_clock(rt_clock
) + 1000);
974 static void icount_adjust_vm(void * opaque
)
976 qemu_mod_timer(icount_vm_timer
,
977 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
981 static void init_icount_adjust(void)
983 /* Have both realtime and virtual time triggers for speed adjustment.
984 The realtime trigger catches emulated time passing too slowly,
985 the virtual time trigger catches emulated time passing too fast.
986 Realtime triggers occur even when idle, so use them less frequently
988 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
989 qemu_mod_timer(icount_rt_timer
,
990 qemu_get_clock(rt_clock
) + 1000);
991 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
992 qemu_mod_timer(icount_vm_timer
,
993 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
996 static struct qemu_alarm_timer alarm_timers
[] = {
999 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
1000 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
1001 /* HPET - if available - is preferred */
1002 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
1003 /* ...otherwise try RTC */
1004 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
1006 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
1008 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
1009 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
1010 {"win32", 0, win32_start_timer
,
1011 win32_stop_timer
, NULL
, &alarm_win32_data
},
1016 static void show_available_alarms(void)
1020 printf("Available alarm timers, in order of precedence:\n");
1021 for (i
= 0; alarm_timers
[i
].name
; i
++)
1022 printf("%s\n", alarm_timers
[i
].name
);
1025 static void configure_alarms(char const *opt
)
1029 int count
= (sizeof(alarm_timers
) / sizeof(*alarm_timers
)) - 1;
1032 struct qemu_alarm_timer tmp
;
1034 if (!strcmp(opt
, "?")) {
1035 show_available_alarms();
1041 /* Reorder the array */
1042 name
= strtok(arg
, ",");
1044 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
1045 if (!strcmp(alarm_timers
[i
].name
, name
))
1050 fprintf(stderr
, "Unknown clock %s\n", name
);
1059 tmp
= alarm_timers
[i
];
1060 alarm_timers
[i
] = alarm_timers
[cur
];
1061 alarm_timers
[cur
] = tmp
;
1065 name
= strtok(NULL
, ",");
1071 /* Disable remaining timers */
1072 for (i
= cur
; i
< count
; i
++)
1073 alarm_timers
[i
].name
= NULL
;
1075 show_available_alarms();
1080 QEMUClock
*rt_clock
;
1081 QEMUClock
*vm_clock
;
1083 static QEMUTimer
*active_timers
[2];
1085 static QEMUClock
*qemu_new_clock(int type
)
1088 clock
= qemu_mallocz(sizeof(QEMUClock
));
1095 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
1099 ts
= qemu_mallocz(sizeof(QEMUTimer
));
1102 ts
->opaque
= opaque
;
1106 void qemu_free_timer(QEMUTimer
*ts
)
1111 /* stop a timer, but do not dealloc it */
1112 void qemu_del_timer(QEMUTimer
*ts
)
1116 /* NOTE: this code must be signal safe because
1117 qemu_timer_expired() can be called from a signal. */
1118 pt
= &active_timers
[ts
->clock
->type
];
1131 /* modify the current timer so that it will be fired when current_time
1132 >= expire_time. The corresponding callback will be called. */
1133 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
1139 /* add the timer in the sorted list */
1140 /* NOTE: this code must be signal safe because
1141 qemu_timer_expired() can be called from a signal. */
1142 pt
= &active_timers
[ts
->clock
->type
];
1147 if (t
->expire_time
> expire_time
)
1151 ts
->expire_time
= expire_time
;
1155 /* Rearm if necessary */
1156 if (pt
== &active_timers
[ts
->clock
->type
]) {
1157 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
1158 qemu_rearm_alarm_timer(alarm_timer
);
1160 /* Interrupt execution to force deadline recalculation. */
1161 if (use_icount
&& cpu_single_env
) {
1162 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
1167 int qemu_timer_pending(QEMUTimer
*ts
)
1170 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1177 static inline int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1181 return (timer_head
->expire_time
<= current_time
);
1184 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1190 if (!ts
|| ts
->expire_time
> current_time
)
1192 /* remove timer from the list before calling the callback */
1193 *ptimer_head
= ts
->next
;
1196 /* run the callback (the timer list can be modified) */
1201 int64_t qemu_get_clock(QEMUClock
*clock
)
1203 switch(clock
->type
) {
1204 case QEMU_TIMER_REALTIME
:
1205 return get_clock() / 1000000;
1207 case QEMU_TIMER_VIRTUAL
:
1209 return cpu_get_icount();
1211 return cpu_get_clock();
1216 static void init_timers(void)
1219 ticks_per_sec
= QEMU_TIMER_BASE
;
1220 rt_clock
= qemu_new_clock(QEMU_TIMER_REALTIME
);
1221 vm_clock
= qemu_new_clock(QEMU_TIMER_VIRTUAL
);
1225 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1227 uint64_t expire_time
;
1229 if (qemu_timer_pending(ts
)) {
1230 expire_time
= ts
->expire_time
;
1234 qemu_put_be64(f
, expire_time
);
1237 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1239 uint64_t expire_time
;
1241 expire_time
= qemu_get_be64(f
);
1242 if (expire_time
!= -1) {
1243 qemu_mod_timer(ts
, expire_time
);
1249 static void timer_save(QEMUFile
*f
, void *opaque
)
1251 if (cpu_ticks_enabled
) {
1252 hw_error("cannot save state if virtual timers are running");
1254 qemu_put_be64(f
, cpu_ticks_offset
);
1255 qemu_put_be64(f
, ticks_per_sec
);
1256 qemu_put_be64(f
, cpu_clock_offset
);
1259 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1261 if (version_id
!= 1 && version_id
!= 2)
1263 if (cpu_ticks_enabled
) {
1266 cpu_ticks_offset
=qemu_get_be64(f
);
1267 ticks_per_sec
=qemu_get_be64(f
);
1268 if (version_id
== 2) {
1269 cpu_clock_offset
=qemu_get_be64(f
);
1275 void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1276 DWORD_PTR dwUser
, DWORD_PTR dw1
, DWORD_PTR dw2
)
1278 static void host_alarm_handler(int host_signum
)
1282 #define DISP_FREQ 1000
1284 static int64_t delta_min
= INT64_MAX
;
1285 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1287 ti
= qemu_get_clock(vm_clock
);
1288 if (last_clock
!= 0) {
1289 delta
= ti
- last_clock
;
1290 if (delta
< delta_min
)
1292 if (delta
> delta_max
)
1295 if (++count
== DISP_FREQ
) {
1296 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1297 muldiv64(delta_min
, 1000000, ticks_per_sec
),
1298 muldiv64(delta_max
, 1000000, ticks_per_sec
),
1299 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, ticks_per_sec
),
1300 (double)ticks_per_sec
/ ((double)delta_cum
/ DISP_FREQ
));
1302 delta_min
= INT64_MAX
;
1310 if (alarm_has_dynticks(alarm_timer
) ||
1312 qemu_timer_expired(active_timers
[QEMU_TIMER_VIRTUAL
],
1313 qemu_get_clock(vm_clock
))) ||
1314 qemu_timer_expired(active_timers
[QEMU_TIMER_REALTIME
],
1315 qemu_get_clock(rt_clock
))) {
1317 struct qemu_alarm_win32
*data
= ((struct qemu_alarm_timer
*)dwUser
)->priv
;
1318 SetEvent(data
->host_alarm
);
1320 CPUState
*env
= next_cpu
;
1322 alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1325 /* stop the currently executing cpu because a timer occured */
1326 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
1328 if (env
->kqemu_enabled
) {
1329 kqemu_cpu_interrupt(env
);
1337 static int64_t qemu_next_deadline(void)
1341 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1342 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1343 qemu_get_clock(vm_clock
);
1345 /* To avoid problems with overflow limit this to 2^32. */
1355 #if defined(__linux__) || defined(_WIN32)
1356 static uint64_t qemu_next_deadline_dyntick(void)
1364 delta
= (qemu_next_deadline() + 999) / 1000;
1366 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1367 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1368 qemu_get_clock(rt_clock
))*1000;
1369 if (rtdelta
< delta
)
1373 if (delta
< MIN_TIMER_REARM_US
)
1374 delta
= MIN_TIMER_REARM_US
;
1382 #if defined(__linux__)
1384 #define RTC_FREQ 1024
1386 static void enable_sigio_timer(int fd
)
1388 struct sigaction act
;
1391 sigfillset(&act
.sa_mask
);
1393 act
.sa_handler
= host_alarm_handler
;
1395 sigaction(SIGIO
, &act
, NULL
);
1396 fcntl(fd
, F_SETFL
, O_ASYNC
);
1397 fcntl(fd
, F_SETOWN
, getpid());
1400 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1402 struct hpet_info info
;
1405 fd
= open("/dev/hpet", O_RDONLY
);
1410 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1412 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1413 "error, but for better emulation accuracy type:\n"
1414 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1418 /* Check capabilities */
1419 r
= ioctl(fd
, HPET_INFO
, &info
);
1423 /* Enable periodic mode */
1424 r
= ioctl(fd
, HPET_EPI
, 0);
1425 if (info
.hi_flags
&& (r
< 0))
1428 /* Enable interrupt */
1429 r
= ioctl(fd
, HPET_IE_ON
, 0);
1433 enable_sigio_timer(fd
);
1434 t
->priv
= (void *)(long)fd
;
1442 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1444 int fd
= (long)t
->priv
;
1449 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1452 unsigned long current_rtc_freq
= 0;
1454 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1457 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1458 if (current_rtc_freq
!= RTC_FREQ
&&
1459 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1460 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1461 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1462 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1465 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1471 enable_sigio_timer(rtc_fd
);
1473 t
->priv
= (void *)(long)rtc_fd
;
1478 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1480 int rtc_fd
= (long)t
->priv
;
1485 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1489 struct sigaction act
;
1491 sigfillset(&act
.sa_mask
);
1493 act
.sa_handler
= host_alarm_handler
;
1495 sigaction(SIGALRM
, &act
, NULL
);
1497 ev
.sigev_value
.sival_int
= 0;
1498 ev
.sigev_notify
= SIGEV_SIGNAL
;
1499 ev
.sigev_signo
= SIGALRM
;
1501 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1502 perror("timer_create");
1504 /* disable dynticks */
1505 fprintf(stderr
, "Dynamic Ticks disabled\n");
1510 t
->priv
= (void *)host_timer
;
1515 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1517 timer_t host_timer
= (timer_t
)t
->priv
;
1519 timer_delete(host_timer
);
1522 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1524 timer_t host_timer
= (timer_t
)t
->priv
;
1525 struct itimerspec timeout
;
1526 int64_t nearest_delta_us
= INT64_MAX
;
1529 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1530 !active_timers
[QEMU_TIMER_VIRTUAL
])
1533 nearest_delta_us
= qemu_next_deadline_dyntick();
1535 /* check whether a timer is already running */
1536 if (timer_gettime(host_timer
, &timeout
)) {
1538 fprintf(stderr
, "Internal timer error: aborting\n");
1541 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1542 if (current_us
&& current_us
<= nearest_delta_us
)
1545 timeout
.it_interval
.tv_sec
= 0;
1546 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1547 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1548 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1549 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1551 fprintf(stderr
, "Internal timer error: aborting\n");
1556 #endif /* defined(__linux__) */
1558 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1560 struct sigaction act
;
1561 struct itimerval itv
;
1565 sigfillset(&act
.sa_mask
);
1567 act
.sa_handler
= host_alarm_handler
;
1569 sigaction(SIGALRM
, &act
, NULL
);
1571 itv
.it_interval
.tv_sec
= 0;
1572 /* for i386 kernel 2.6 to get 1 ms */
1573 itv
.it_interval
.tv_usec
= 999;
1574 itv
.it_value
.tv_sec
= 0;
1575 itv
.it_value
.tv_usec
= 10 * 1000;
1577 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1584 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1586 struct itimerval itv
;
1588 memset(&itv
, 0, sizeof(itv
));
1589 setitimer(ITIMER_REAL
, &itv
, NULL
);
1592 #endif /* !defined(_WIN32) */
1596 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1599 struct qemu_alarm_win32
*data
= t
->priv
;
1602 data
->host_alarm
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1603 if (!data
->host_alarm
) {
1604 perror("Failed CreateEvent");
1608 memset(&tc
, 0, sizeof(tc
));
1609 timeGetDevCaps(&tc
, sizeof(tc
));
1611 if (data
->period
< tc
.wPeriodMin
)
1612 data
->period
= tc
.wPeriodMin
;
1614 timeBeginPeriod(data
->period
);
1616 flags
= TIME_CALLBACK_FUNCTION
;
1617 if (alarm_has_dynticks(t
))
1618 flags
|= TIME_ONESHOT
;
1620 flags
|= TIME_PERIODIC
;
1622 data
->timerId
= timeSetEvent(1, // interval (ms)
1623 data
->period
, // resolution
1624 host_alarm_handler
, // function
1625 (DWORD
)t
, // parameter
1628 if (!data
->timerId
) {
1629 perror("Failed to initialize win32 alarm timer");
1631 timeEndPeriod(data
->period
);
1632 CloseHandle(data
->host_alarm
);
1636 qemu_add_wait_object(data
->host_alarm
, NULL
, NULL
);
1641 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1643 struct qemu_alarm_win32
*data
= t
->priv
;
1645 timeKillEvent(data
->timerId
);
1646 timeEndPeriod(data
->period
);
1648 CloseHandle(data
->host_alarm
);
1651 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1653 struct qemu_alarm_win32
*data
= t
->priv
;
1654 uint64_t nearest_delta_us
;
1656 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1657 !active_timers
[QEMU_TIMER_VIRTUAL
])
1660 nearest_delta_us
= qemu_next_deadline_dyntick();
1661 nearest_delta_us
/= 1000;
1663 timeKillEvent(data
->timerId
);
1665 data
->timerId
= timeSetEvent(1,
1669 TIME_ONESHOT
| TIME_PERIODIC
);
1671 if (!data
->timerId
) {
1672 perror("Failed to re-arm win32 alarm timer");
1674 timeEndPeriod(data
->period
);
1675 CloseHandle(data
->host_alarm
);
1682 static void init_timer_alarm(void)
1684 struct qemu_alarm_timer
*t
= NULL
;
1687 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1688 t
= &alarm_timers
[i
];
1696 fprintf(stderr
, "Unable to find any suitable alarm timer.\n");
1697 fprintf(stderr
, "Terminating\n");
1704 static void quit_timers(void)
1706 alarm_timer
->stop(alarm_timer
);
1710 /***********************************************************/
1711 /* host time/date access */
1712 void qemu_get_timedate(struct tm
*tm
, int offset
)
1719 if (rtc_date_offset
== -1) {
1723 ret
= localtime(&ti
);
1725 ti
-= rtc_date_offset
;
1729 memcpy(tm
, ret
, sizeof(struct tm
));
1732 int qemu_timedate_diff(struct tm
*tm
)
1736 if (rtc_date_offset
== -1)
1738 seconds
= mktimegm(tm
);
1740 seconds
= mktime(tm
);
1742 seconds
= mktimegm(tm
) + rtc_date_offset
;
1744 return seconds
- time(NULL
);
1747 /***********************************************************/
1748 /* character device */
1750 static void qemu_chr_event(CharDriverState
*s
, int event
)
1754 s
->chr_event(s
->handler_opaque
, event
);
1757 static void qemu_chr_reset_bh(void *opaque
)
1759 CharDriverState
*s
= opaque
;
1760 qemu_chr_event(s
, CHR_EVENT_RESET
);
1761 qemu_bh_delete(s
->bh
);
1765 void qemu_chr_reset(CharDriverState
*s
)
1767 if (s
->bh
== NULL
) {
1768 s
->bh
= qemu_bh_new(qemu_chr_reset_bh
, s
);
1769 qemu_bh_schedule(s
->bh
);
1773 int qemu_chr_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
1775 return s
->chr_write(s
, buf
, len
);
1778 int qemu_chr_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
1782 return s
->chr_ioctl(s
, cmd
, arg
);
1785 int qemu_chr_can_read(CharDriverState
*s
)
1787 if (!s
->chr_can_read
)
1789 return s
->chr_can_read(s
->handler_opaque
);
1792 void qemu_chr_read(CharDriverState
*s
, uint8_t *buf
, int len
)
1794 s
->chr_read(s
->handler_opaque
, buf
, len
);
1797 void qemu_chr_accept_input(CharDriverState
*s
)
1799 if (s
->chr_accept_input
)
1800 s
->chr_accept_input(s
);
1803 void qemu_chr_printf(CharDriverState
*s
, const char *fmt
, ...)
1808 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
1809 qemu_chr_write(s
, (uint8_t *)buf
, strlen(buf
));
1813 void qemu_chr_send_event(CharDriverState
*s
, int event
)
1815 if (s
->chr_send_event
)
1816 s
->chr_send_event(s
, event
);
1819 void qemu_chr_add_handlers(CharDriverState
*s
,
1820 IOCanRWHandler
*fd_can_read
,
1821 IOReadHandler
*fd_read
,
1822 IOEventHandler
*fd_event
,
1825 s
->chr_can_read
= fd_can_read
;
1826 s
->chr_read
= fd_read
;
1827 s
->chr_event
= fd_event
;
1828 s
->handler_opaque
= opaque
;
1829 if (s
->chr_update_read_handler
)
1830 s
->chr_update_read_handler(s
);
1833 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1838 static CharDriverState
*qemu_chr_open_null(void)
1840 CharDriverState
*chr
;
1842 chr
= qemu_mallocz(sizeof(CharDriverState
));
1845 chr
->chr_write
= null_chr_write
;
1849 /* MUX driver for serial I/O splitting */
1850 static int term_timestamps
;
1851 static int64_t term_timestamps_start
;
1853 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1854 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1856 IOCanRWHandler
*chr_can_read
[MAX_MUX
];
1857 IOReadHandler
*chr_read
[MAX_MUX
];
1858 IOEventHandler
*chr_event
[MAX_MUX
];
1859 void *ext_opaque
[MAX_MUX
];
1860 CharDriverState
*drv
;
1861 unsigned char buffer
[MUX_BUFFER_SIZE
];
1865 int term_got_escape
;
1870 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1872 MuxDriver
*d
= chr
->opaque
;
1874 if (!term_timestamps
) {
1875 ret
= d
->drv
->chr_write(d
->drv
, buf
, len
);
1880 for(i
= 0; i
< len
; i
++) {
1881 ret
+= d
->drv
->chr_write(d
->drv
, buf
+i
, 1);
1882 if (buf
[i
] == '\n') {
1888 if (term_timestamps_start
== -1)
1889 term_timestamps_start
= ti
;
1890 ti
-= term_timestamps_start
;
1891 secs
= ti
/ 1000000000;
1892 snprintf(buf1
, sizeof(buf1
),
1893 "[%02d:%02d:%02d.%03d] ",
1897 (int)((ti
/ 1000000) % 1000));
1898 d
->drv
->chr_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
1905 static const char * const mux_help
[] = {
1906 "% h print this help\n\r",
1907 "% x exit emulator\n\r",
1908 "% s save disk data back to file (if -snapshot)\n\r",
1909 "% t toggle console timestamps\n\r"
1910 "% b send break (magic sysrq)\n\r",
1911 "% c switch between console and monitor\n\r",
1916 static int term_escape_char
= 0x01; /* ctrl-a is used for escape */
1917 static void mux_print_help(CharDriverState
*chr
)
1920 char ebuf
[15] = "Escape-Char";
1921 char cbuf
[50] = "\n\r";
1923 if (term_escape_char
> 0 && term_escape_char
< 26) {
1924 snprintf(cbuf
, sizeof(cbuf
), "\n\r");
1925 snprintf(ebuf
, sizeof(ebuf
), "C-%c", term_escape_char
- 1 + 'a');
1927 snprintf(cbuf
, sizeof(cbuf
),
1928 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1931 chr
->chr_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
1932 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
1933 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
1934 if (mux_help
[i
][j
] == '%')
1935 chr
->chr_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
1937 chr
->chr_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
1942 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
1944 if (d
->term_got_escape
) {
1945 d
->term_got_escape
= 0;
1946 if (ch
== term_escape_char
)
1951 mux_print_help(chr
);
1955 const char *term
= "QEMU: Terminated\n\r";
1956 chr
->chr_write(chr
,(uint8_t *)term
,strlen(term
));
1963 for (i
= 0; i
< nb_drives
; i
++) {
1964 bdrv_commit(drives_table
[i
].bdrv
);
1969 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
1972 /* Switch to the next registered device */
1974 if (chr
->focus
>= d
->mux_cnt
)
1978 term_timestamps
= !term_timestamps
;
1979 term_timestamps_start
= -1;
1982 } else if (ch
== term_escape_char
) {
1983 d
->term_got_escape
= 1;
1991 static void mux_chr_accept_input(CharDriverState
*chr
)
1994 MuxDriver
*d
= chr
->opaque
;
1996 while (d
->prod
!= d
->cons
&&
1997 d
->chr_can_read
[m
] &&
1998 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
1999 d
->chr_read
[m
](d
->ext_opaque
[m
],
2000 &d
->buffer
[d
->cons
++ & MUX_BUFFER_MASK
], 1);
2004 static int mux_chr_can_read(void *opaque
)
2006 CharDriverState
*chr
= opaque
;
2007 MuxDriver
*d
= chr
->opaque
;
2009 if ((d
->prod
- d
->cons
) < MUX_BUFFER_SIZE
)
2011 if (d
->chr_can_read
[chr
->focus
])
2012 return d
->chr_can_read
[chr
->focus
](d
->ext_opaque
[chr
->focus
]);
2016 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
2018 CharDriverState
*chr
= opaque
;
2019 MuxDriver
*d
= chr
->opaque
;
2023 mux_chr_accept_input (opaque
);
2025 for(i
= 0; i
< size
; i
++)
2026 if (mux_proc_byte(chr
, d
, buf
[i
])) {
2027 if (d
->prod
== d
->cons
&&
2028 d
->chr_can_read
[m
] &&
2029 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
2030 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
2032 d
->buffer
[d
->prod
++ & MUX_BUFFER_MASK
] = buf
[i
];
2036 static void mux_chr_event(void *opaque
, int event
)
2038 CharDriverState
*chr
= opaque
;
2039 MuxDriver
*d
= chr
->opaque
;
2042 /* Send the event to all registered listeners */
2043 for (i
= 0; i
< d
->mux_cnt
; i
++)
2044 if (d
->chr_event
[i
])
2045 d
->chr_event
[i
](d
->ext_opaque
[i
], event
);
2048 static void mux_chr_update_read_handler(CharDriverState
*chr
)
2050 MuxDriver
*d
= chr
->opaque
;
2052 if (d
->mux_cnt
>= MAX_MUX
) {
2053 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
2056 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
2057 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
2058 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
2059 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
2060 /* Fix up the real driver with mux routines */
2061 if (d
->mux_cnt
== 0) {
2062 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
2063 mux_chr_event
, chr
);
2065 chr
->focus
= d
->mux_cnt
;
2069 static CharDriverState
*qemu_chr_open_mux(CharDriverState
*drv
)
2071 CharDriverState
*chr
;
2074 chr
= qemu_mallocz(sizeof(CharDriverState
));
2077 d
= qemu_mallocz(sizeof(MuxDriver
));
2086 chr
->chr_write
= mux_chr_write
;
2087 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
2088 chr
->chr_accept_input
= mux_chr_accept_input
;
2095 static void socket_cleanup(void)
2100 static int socket_init(void)
2105 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
2107 err
= WSAGetLastError();
2108 fprintf(stderr
, "WSAStartup: %d\n", err
);
2111 atexit(socket_cleanup
);
2115 static int send_all(int fd
, const uint8_t *buf
, int len1
)
2121 ret
= send(fd
, buf
, len
, 0);
2124 errno
= WSAGetLastError();
2125 if (errno
!= WSAEWOULDBLOCK
) {
2128 } else if (ret
== 0) {
2140 static int unix_write(int fd
, const uint8_t *buf
, int len1
)
2146 ret
= write(fd
, buf
, len
);
2148 if (errno
!= EINTR
&& errno
!= EAGAIN
)
2150 } else if (ret
== 0) {
2160 static inline int send_all(int fd
, const uint8_t *buf
, int len1
)
2162 return unix_write(fd
, buf
, len1
);
2164 #endif /* !_WIN32 */
2173 #define STDIO_MAX_CLIENTS 1
2174 static int stdio_nb_clients
= 0;
2176 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2178 FDCharDriver
*s
= chr
->opaque
;
2179 return unix_write(s
->fd_out
, buf
, len
);
2182 static int fd_chr_read_poll(void *opaque
)
2184 CharDriverState
*chr
= opaque
;
2185 FDCharDriver
*s
= chr
->opaque
;
2187 s
->max_size
= qemu_chr_can_read(chr
);
2191 static void fd_chr_read(void *opaque
)
2193 CharDriverState
*chr
= opaque
;
2194 FDCharDriver
*s
= chr
->opaque
;
2199 if (len
> s
->max_size
)
2203 size
= read(s
->fd_in
, buf
, len
);
2205 /* FD has been closed. Remove it from the active list. */
2206 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2210 qemu_chr_read(chr
, buf
, size
);
2214 static void fd_chr_update_read_handler(CharDriverState
*chr
)
2216 FDCharDriver
*s
= chr
->opaque
;
2218 if (s
->fd_in
>= 0) {
2219 if (nographic
&& s
->fd_in
== 0) {
2221 qemu_set_fd_handler2(s
->fd_in
, fd_chr_read_poll
,
2222 fd_chr_read
, NULL
, chr
);
2227 static void fd_chr_close(struct CharDriverState
*chr
)
2229 FDCharDriver
*s
= chr
->opaque
;
2231 if (s
->fd_in
>= 0) {
2232 if (nographic
&& s
->fd_in
== 0) {
2234 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2241 /* open a character device to a unix fd */
2242 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
)
2244 CharDriverState
*chr
;
2247 chr
= qemu_mallocz(sizeof(CharDriverState
));
2250 s
= qemu_mallocz(sizeof(FDCharDriver
));
2258 chr
->chr_write
= fd_chr_write
;
2259 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
2260 chr
->chr_close
= fd_chr_close
;
2262 qemu_chr_reset(chr
);
2267 static CharDriverState
*qemu_chr_open_file_out(const char *file_out
)
2271 TFR(fd_out
= open(file_out
, O_WRONLY
| O_TRUNC
| O_CREAT
| O_BINARY
, 0666));
2274 return qemu_chr_open_fd(-1, fd_out
);
2277 static CharDriverState
*qemu_chr_open_pipe(const char *filename
)
2280 char filename_in
[256], filename_out
[256];
2282 snprintf(filename_in
, 256, "%s.in", filename
);
2283 snprintf(filename_out
, 256, "%s.out", filename
);
2284 TFR(fd_in
= open(filename_in
, O_RDWR
| O_BINARY
));
2285 TFR(fd_out
= open(filename_out
, O_RDWR
| O_BINARY
));
2286 if (fd_in
< 0 || fd_out
< 0) {
2291 TFR(fd_in
= fd_out
= open(filename
, O_RDWR
| O_BINARY
));
2295 return qemu_chr_open_fd(fd_in
, fd_out
);
2299 /* for STDIO, we handle the case where several clients use it
2302 #define TERM_FIFO_MAX_SIZE 1
2304 static uint8_t term_fifo
[TERM_FIFO_MAX_SIZE
];
2305 static int term_fifo_size
;
2307 static int stdio_read_poll(void *opaque
)
2309 CharDriverState
*chr
= opaque
;
2311 /* try to flush the queue if needed */
2312 if (term_fifo_size
!= 0 && qemu_chr_can_read(chr
) > 0) {
2313 qemu_chr_read(chr
, term_fifo
, 1);
2316 /* see if we can absorb more chars */
2317 if (term_fifo_size
== 0)
2323 static void stdio_read(void *opaque
)
2327 CharDriverState
*chr
= opaque
;
2329 size
= read(0, buf
, 1);
2331 /* stdin has been closed. Remove it from the active list. */
2332 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2336 if (qemu_chr_can_read(chr
) > 0) {
2337 qemu_chr_read(chr
, buf
, 1);
2338 } else if (term_fifo_size
== 0) {
2339 term_fifo
[term_fifo_size
++] = buf
[0];
2344 /* init terminal so that we can grab keys */
2345 static struct termios oldtty
;
2346 static int old_fd0_flags
;
2347 static int term_atexit_done
;
2349 static void term_exit(void)
2351 tcsetattr (0, TCSANOW
, &oldtty
);
2352 fcntl(0, F_SETFL
, old_fd0_flags
);
2355 static void term_init(void)
2359 tcgetattr (0, &tty
);
2361 old_fd0_flags
= fcntl(0, F_GETFL
);
2363 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2364 |INLCR
|IGNCR
|ICRNL
|IXON
);
2365 tty
.c_oflag
|= OPOST
;
2366 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
2367 /* if graphical mode, we allow Ctrl-C handling */
2369 tty
.c_lflag
&= ~ISIG
;
2370 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
2373 tty
.c_cc
[VTIME
] = 0;
2375 tcsetattr (0, TCSANOW
, &tty
);
2377 if (!term_atexit_done
++)
2380 fcntl(0, F_SETFL
, O_NONBLOCK
);
2383 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
2387 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2391 static CharDriverState
*qemu_chr_open_stdio(void)
2393 CharDriverState
*chr
;
2395 if (stdio_nb_clients
>= STDIO_MAX_CLIENTS
)
2397 chr
= qemu_chr_open_fd(0, 1);
2398 chr
->chr_close
= qemu_chr_close_stdio
;
2399 qemu_set_fd_handler2(0, stdio_read_poll
, stdio_read
, NULL
, chr
);
2407 /* Once Solaris has openpty(), this is going to be removed. */
2408 int openpty(int *amaster
, int *aslave
, char *name
,
2409 struct termios
*termp
, struct winsize
*winp
)
2412 int mfd
= -1, sfd
= -1;
2414 *amaster
= *aslave
= -1;
2416 mfd
= open("/dev/ptmx", O_RDWR
| O_NOCTTY
);
2420 if (grantpt(mfd
) == -1 || unlockpt(mfd
) == -1)
2423 if ((slave
= ptsname(mfd
)) == NULL
)
2426 if ((sfd
= open(slave
, O_RDONLY
| O_NOCTTY
)) == -1)
2429 if (ioctl(sfd
, I_PUSH
, "ptem") == -1 ||
2430 (termp
!= NULL
&& tcgetattr(sfd
, termp
) < 0))
2438 ioctl(sfd
, TIOCSWINSZ
, winp
);
2449 void cfmakeraw (struct termios
*termios_p
)
2451 termios_p
->c_iflag
&=
2452 ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2453 termios_p
->c_oflag
&= ~OPOST
;
2454 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2455 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2456 termios_p
->c_cflag
|= CS8
;
2458 termios_p
->c_cc
[VMIN
] = 0;
2459 termios_p
->c_cc
[VTIME
] = 0;
2463 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2464 || defined(__NetBSD__) || defined(__OpenBSD__)
2474 static void pty_chr_update_read_handler(CharDriverState
*chr
);
2475 static void pty_chr_state(CharDriverState
*chr
, int connected
);
2477 static int pty_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2479 PtyCharDriver
*s
= chr
->opaque
;
2481 if (!s
->connected
) {
2482 /* guest sends data, check for (re-)connect */
2483 pty_chr_update_read_handler(chr
);
2486 return unix_write(s
->fd
, buf
, len
);
2489 static int pty_chr_read_poll(void *opaque
)
2491 CharDriverState
*chr
= opaque
;
2492 PtyCharDriver
*s
= chr
->opaque
;
2494 s
->read_bytes
= qemu_chr_can_read(chr
);
2495 return s
->read_bytes
;
2498 static void pty_chr_read(void *opaque
)
2500 CharDriverState
*chr
= opaque
;
2501 PtyCharDriver
*s
= chr
->opaque
;
2506 if (len
> s
->read_bytes
)
2507 len
= s
->read_bytes
;
2510 size
= read(s
->fd
, buf
, len
);
2511 if ((size
== -1 && errno
== EIO
) ||
2513 pty_chr_state(chr
, 0);
2517 pty_chr_state(chr
, 1);
2518 qemu_chr_read(chr
, buf
, size
);
2522 static void pty_chr_update_read_handler(CharDriverState
*chr
)
2524 PtyCharDriver
*s
= chr
->opaque
;
2526 qemu_set_fd_handler2(s
->fd
, pty_chr_read_poll
,
2527 pty_chr_read
, NULL
, chr
);
2530 * Short timeout here: just need wait long enougth that qemu makes
2531 * it through the poll loop once. When reconnected we want a
2532 * short timeout so we notice it almost instantly. Otherwise
2533 * read() gives us -EIO instantly, making pty_chr_state() reset the
2534 * timeout to the normal (much longer) poll interval before the
2537 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 10);
2540 static void pty_chr_state(CharDriverState
*chr
, int connected
)
2542 PtyCharDriver
*s
= chr
->opaque
;
2545 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2548 /* (re-)connect poll interval for idle guests: once per second.
2549 * We check more frequently in case the guests sends data to
2550 * the virtual device linked to our pty. */
2551 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 1000);
2554 qemu_chr_reset(chr
);
2559 static void pty_chr_timer(void *opaque
)
2561 struct CharDriverState
*chr
= opaque
;
2562 PtyCharDriver
*s
= chr
->opaque
;
2567 /* If we arrive here without polling being cleared due
2568 * read returning -EIO, then we are (re-)connected */
2569 pty_chr_state(chr
, 1);
2574 pty_chr_update_read_handler(chr
);
2577 static void pty_chr_close(struct CharDriverState
*chr
)
2579 PtyCharDriver
*s
= chr
->opaque
;
2581 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2586 static CharDriverState
*qemu_chr_open_pty(void)
2588 CharDriverState
*chr
;
2592 #if defined(__OpenBSD__)
2593 char pty_name
[PATH_MAX
];
2594 #define q_ptsname(x) pty_name
2596 char *pty_name
= NULL
;
2597 #define q_ptsname(x) ptsname(x)
2600 chr
= qemu_mallocz(sizeof(CharDriverState
));
2603 s
= qemu_mallocz(sizeof(PtyCharDriver
));
2609 if (openpty(&s
->fd
, &slave_fd
, pty_name
, NULL
, NULL
) < 0) {
2613 /* Set raw attributes on the pty. */
2615 tcsetattr(slave_fd
, TCSAFLUSH
, &tty
);
2618 fprintf(stderr
, "char device redirected to %s\n", q_ptsname(s
->fd
));
2621 chr
->chr_write
= pty_chr_write
;
2622 chr
->chr_update_read_handler
= pty_chr_update_read_handler
;
2623 chr
->chr_close
= pty_chr_close
;
2625 s
->timer
= qemu_new_timer(rt_clock
, pty_chr_timer
, chr
);
2630 static void tty_serial_init(int fd
, int speed
,
2631 int parity
, int data_bits
, int stop_bits
)
2637 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2638 speed
, parity
, data_bits
, stop_bits
);
2640 tcgetattr (fd
, &tty
);
2643 if (speed
<= 50 * MARGIN
)
2645 else if (speed
<= 75 * MARGIN
)
2647 else if (speed
<= 300 * MARGIN
)
2649 else if (speed
<= 600 * MARGIN
)
2651 else if (speed
<= 1200 * MARGIN
)
2653 else if (speed
<= 2400 * MARGIN
)
2655 else if (speed
<= 4800 * MARGIN
)
2657 else if (speed
<= 9600 * MARGIN
)
2659 else if (speed
<= 19200 * MARGIN
)
2661 else if (speed
<= 38400 * MARGIN
)
2663 else if (speed
<= 57600 * MARGIN
)
2665 else if (speed
<= 115200 * MARGIN
)
2670 cfsetispeed(&tty
, spd
);
2671 cfsetospeed(&tty
, spd
);
2673 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2674 |INLCR
|IGNCR
|ICRNL
|IXON
);
2675 tty
.c_oflag
|= OPOST
;
2676 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
2677 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
2698 tty
.c_cflag
|= PARENB
;
2701 tty
.c_cflag
|= PARENB
| PARODD
;
2705 tty
.c_cflag
|= CSTOPB
;
2707 tcsetattr (fd
, TCSANOW
, &tty
);
2710 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2712 FDCharDriver
*s
= chr
->opaque
;
2715 case CHR_IOCTL_SERIAL_SET_PARAMS
:
2717 QEMUSerialSetParams
*ssp
= arg
;
2718 tty_serial_init(s
->fd_in
, ssp
->speed
, ssp
->parity
,
2719 ssp
->data_bits
, ssp
->stop_bits
);
2722 case CHR_IOCTL_SERIAL_SET_BREAK
:
2724 int enable
= *(int *)arg
;
2726 tcsendbreak(s
->fd_in
, 1);
2729 case CHR_IOCTL_SERIAL_GET_TIOCM
:
2732 int *targ
= (int *)arg
;
2733 ioctl(s
->fd_in
, TIOCMGET
, &sarg
);
2735 if (sarg
| TIOCM_CTS
)
2736 *targ
|= CHR_TIOCM_CTS
;
2737 if (sarg
| TIOCM_CAR
)
2738 *targ
|= CHR_TIOCM_CAR
;
2739 if (sarg
| TIOCM_DSR
)
2740 *targ
|= CHR_TIOCM_DSR
;
2741 if (sarg
| TIOCM_RI
)
2742 *targ
|= CHR_TIOCM_RI
;
2743 if (sarg
| TIOCM_DTR
)
2744 *targ
|= CHR_TIOCM_DTR
;
2745 if (sarg
| TIOCM_RTS
)
2746 *targ
|= CHR_TIOCM_RTS
;
2749 case CHR_IOCTL_SERIAL_SET_TIOCM
:
2751 int sarg
= *(int *)arg
;
2753 if (sarg
| CHR_TIOCM_DTR
)
2755 if (sarg
| CHR_TIOCM_RTS
)
2757 ioctl(s
->fd_in
, TIOCMSET
, &targ
);
2766 static CharDriverState
*qemu_chr_open_tty(const char *filename
)
2768 CharDriverState
*chr
;
2771 TFR(fd
= open(filename
, O_RDWR
| O_NONBLOCK
));
2772 tty_serial_init(fd
, 115200, 'N', 8, 1);
2773 chr
= qemu_chr_open_fd(fd
, fd
);
2778 chr
->chr_ioctl
= tty_serial_ioctl
;
2779 qemu_chr_reset(chr
);
2782 #else /* ! __linux__ && ! __sun__ */
2783 static CharDriverState
*qemu_chr_open_pty(void)
2787 #endif /* __linux__ || __sun__ */
2789 #if defined(__linux__)
2793 } ParallelCharDriver
;
2795 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
2797 if (s
->mode
!= mode
) {
2799 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
2806 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2808 ParallelCharDriver
*drv
= chr
->opaque
;
2813 case CHR_IOCTL_PP_READ_DATA
:
2814 if (ioctl(fd
, PPRDATA
, &b
) < 0)
2816 *(uint8_t *)arg
= b
;
2818 case CHR_IOCTL_PP_WRITE_DATA
:
2819 b
= *(uint8_t *)arg
;
2820 if (ioctl(fd
, PPWDATA
, &b
) < 0)
2823 case CHR_IOCTL_PP_READ_CONTROL
:
2824 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
2826 /* Linux gives only the lowest bits, and no way to know data
2827 direction! For better compatibility set the fixed upper
2829 *(uint8_t *)arg
= b
| 0xc0;
2831 case CHR_IOCTL_PP_WRITE_CONTROL
:
2832 b
= *(uint8_t *)arg
;
2833 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
2836 case CHR_IOCTL_PP_READ_STATUS
:
2837 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
2839 *(uint8_t *)arg
= b
;
2841 case CHR_IOCTL_PP_DATA_DIR
:
2842 if (ioctl(fd
, PPDATADIR
, (int *)arg
) < 0)
2845 case CHR_IOCTL_PP_EPP_READ_ADDR
:
2846 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2847 struct ParallelIOArg
*parg
= arg
;
2848 int n
= read(fd
, parg
->buffer
, parg
->count
);
2849 if (n
!= parg
->count
) {
2854 case CHR_IOCTL_PP_EPP_READ
:
2855 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2856 struct ParallelIOArg
*parg
= arg
;
2857 int n
= read(fd
, parg
->buffer
, parg
->count
);
2858 if (n
!= parg
->count
) {
2863 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
2864 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2865 struct ParallelIOArg
*parg
= arg
;
2866 int n
= write(fd
, parg
->buffer
, parg
->count
);
2867 if (n
!= parg
->count
) {
2872 case CHR_IOCTL_PP_EPP_WRITE
:
2873 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2874 struct ParallelIOArg
*parg
= arg
;
2875 int n
= write(fd
, parg
->buffer
, parg
->count
);
2876 if (n
!= parg
->count
) {
2887 static void pp_close(CharDriverState
*chr
)
2889 ParallelCharDriver
*drv
= chr
->opaque
;
2892 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
2893 ioctl(fd
, PPRELEASE
);
2898 static CharDriverState
*qemu_chr_open_pp(const char *filename
)
2900 CharDriverState
*chr
;
2901 ParallelCharDriver
*drv
;
2904 TFR(fd
= open(filename
, O_RDWR
));
2908 if (ioctl(fd
, PPCLAIM
) < 0) {
2913 drv
= qemu_mallocz(sizeof(ParallelCharDriver
));
2919 drv
->mode
= IEEE1284_MODE_COMPAT
;
2921 chr
= qemu_mallocz(sizeof(CharDriverState
));
2927 chr
->chr_write
= null_chr_write
;
2928 chr
->chr_ioctl
= pp_ioctl
;
2929 chr
->chr_close
= pp_close
;
2932 qemu_chr_reset(chr
);
2936 #endif /* __linux__ */
2942 HANDLE hcom
, hrecv
, hsend
;
2943 OVERLAPPED orecv
, osend
;
2948 #define NSENDBUF 2048
2949 #define NRECVBUF 2048
2950 #define MAXCONNECT 1
2951 #define NTIMEOUT 5000
2953 static int win_chr_poll(void *opaque
);
2954 static int win_chr_pipe_poll(void *opaque
);
2956 static void win_chr_close(CharDriverState
*chr
)
2958 WinCharState
*s
= chr
->opaque
;
2961 CloseHandle(s
->hsend
);
2965 CloseHandle(s
->hrecv
);
2969 CloseHandle(s
->hcom
);
2973 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
2975 qemu_del_polling_cb(win_chr_poll
, chr
);
2978 static int win_chr_init(CharDriverState
*chr
, const char *filename
)
2980 WinCharState
*s
= chr
->opaque
;
2982 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
2987 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2989 fprintf(stderr
, "Failed CreateEvent\n");
2992 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2994 fprintf(stderr
, "Failed CreateEvent\n");
2998 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
2999 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
3000 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3001 fprintf(stderr
, "Failed CreateFile (%lu)\n", GetLastError());
3006 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
3007 fprintf(stderr
, "Failed SetupComm\n");
3011 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
3012 size
= sizeof(COMMCONFIG
);
3013 GetDefaultCommConfig(filename
, &comcfg
, &size
);
3014 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
3015 CommConfigDialog(filename
, NULL
, &comcfg
);
3017 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
3018 fprintf(stderr
, "Failed SetCommState\n");
3022 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
3023 fprintf(stderr
, "Failed SetCommMask\n");
3027 cto
.ReadIntervalTimeout
= MAXDWORD
;
3028 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
3029 fprintf(stderr
, "Failed SetCommTimeouts\n");
3033 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
3034 fprintf(stderr
, "Failed ClearCommError\n");
3037 qemu_add_polling_cb(win_chr_poll
, chr
);
3045 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
3047 WinCharState
*s
= chr
->opaque
;
3048 DWORD len
, ret
, size
, err
;
3051 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
3052 s
->osend
.hEvent
= s
->hsend
;
3055 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
3057 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
3059 err
= GetLastError();
3060 if (err
== ERROR_IO_PENDING
) {
3061 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
3079 static int win_chr_read_poll(CharDriverState
*chr
)
3081 WinCharState
*s
= chr
->opaque
;
3083 s
->max_size
= qemu_chr_can_read(chr
);
3087 static void win_chr_readfile(CharDriverState
*chr
)
3089 WinCharState
*s
= chr
->opaque
;
3094 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
3095 s
->orecv
.hEvent
= s
->hrecv
;
3096 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
3098 err
= GetLastError();
3099 if (err
== ERROR_IO_PENDING
) {
3100 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
3105 qemu_chr_read(chr
, buf
, size
);
3109 static void win_chr_read(CharDriverState
*chr
)
3111 WinCharState
*s
= chr
->opaque
;
3113 if (s
->len
> s
->max_size
)
3114 s
->len
= s
->max_size
;
3118 win_chr_readfile(chr
);
3121 static int win_chr_poll(void *opaque
)
3123 CharDriverState
*chr
= opaque
;
3124 WinCharState
*s
= chr
->opaque
;
3128 ClearCommError(s
->hcom
, &comerr
, &status
);
3129 if (status
.cbInQue
> 0) {
3130 s
->len
= status
.cbInQue
;
3131 win_chr_read_poll(chr
);
3138 static CharDriverState
*qemu_chr_open_win(const char *filename
)
3140 CharDriverState
*chr
;
3143 chr
= qemu_mallocz(sizeof(CharDriverState
));
3146 s
= qemu_mallocz(sizeof(WinCharState
));
3152 chr
->chr_write
= win_chr_write
;
3153 chr
->chr_close
= win_chr_close
;
3155 if (win_chr_init(chr
, filename
) < 0) {
3160 qemu_chr_reset(chr
);
3164 static int win_chr_pipe_poll(void *opaque
)
3166 CharDriverState
*chr
= opaque
;
3167 WinCharState
*s
= chr
->opaque
;
3170 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
3173 win_chr_read_poll(chr
);
3180 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
)
3182 WinCharState
*s
= chr
->opaque
;
3190 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3192 fprintf(stderr
, "Failed CreateEvent\n");
3195 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3197 fprintf(stderr
, "Failed CreateEvent\n");
3201 snprintf(openname
, sizeof(openname
), "\\\\.\\pipe\\%s", filename
);
3202 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
3203 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
3205 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
3206 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3207 fprintf(stderr
, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3212 ZeroMemory(&ov
, sizeof(ov
));
3213 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3214 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
3216 fprintf(stderr
, "Failed ConnectNamedPipe\n");
3220 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
3222 fprintf(stderr
, "Failed GetOverlappedResult\n");
3224 CloseHandle(ov
.hEvent
);
3231 CloseHandle(ov
.hEvent
);
3234 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
3243 static CharDriverState
*qemu_chr_open_win_pipe(const char *filename
)
3245 CharDriverState
*chr
;
3248 chr
= qemu_mallocz(sizeof(CharDriverState
));
3251 s
= qemu_mallocz(sizeof(WinCharState
));
3257 chr
->chr_write
= win_chr_write
;
3258 chr
->chr_close
= win_chr_close
;
3260 if (win_chr_pipe_init(chr
, filename
) < 0) {
3265 qemu_chr_reset(chr
);
3269 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
)
3271 CharDriverState
*chr
;
3274 chr
= qemu_mallocz(sizeof(CharDriverState
));
3277 s
= qemu_mallocz(sizeof(WinCharState
));
3284 chr
->chr_write
= win_chr_write
;
3285 qemu_chr_reset(chr
);
3289 static CharDriverState
*qemu_chr_open_win_con(const char *filename
)
3291 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
));
3294 static CharDriverState
*qemu_chr_open_win_file_out(const char *file_out
)
3298 fd_out
= CreateFile(file_out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
3299 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3300 if (fd_out
== INVALID_HANDLE_VALUE
)
3303 return qemu_chr_open_win_file(fd_out
);
3305 #endif /* !_WIN32 */
3307 /***********************************************************/
3308 /* UDP Net console */
3312 struct sockaddr_in daddr
;
3319 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3321 NetCharDriver
*s
= chr
->opaque
;
3323 return sendto(s
->fd
, buf
, len
, 0,
3324 (struct sockaddr
*)&s
->daddr
, sizeof(struct sockaddr_in
));
3327 static int udp_chr_read_poll(void *opaque
)
3329 CharDriverState
*chr
= opaque
;
3330 NetCharDriver
*s
= chr
->opaque
;
3332 s
->max_size
= qemu_chr_can_read(chr
);
3334 /* If there were any stray characters in the queue process them
3337 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3338 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3340 s
->max_size
= qemu_chr_can_read(chr
);
3345 static void udp_chr_read(void *opaque
)
3347 CharDriverState
*chr
= opaque
;
3348 NetCharDriver
*s
= chr
->opaque
;
3350 if (s
->max_size
== 0)
3352 s
->bufcnt
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
3353 s
->bufptr
= s
->bufcnt
;
3358 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3359 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3361 s
->max_size
= qemu_chr_can_read(chr
);
3365 static void udp_chr_update_read_handler(CharDriverState
*chr
)
3367 NetCharDriver
*s
= chr
->opaque
;
3370 qemu_set_fd_handler2(s
->fd
, udp_chr_read_poll
,
3371 udp_chr_read
, NULL
, chr
);
3375 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
);
3377 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
);
3379 int parse_host_src_port(struct sockaddr_in
*haddr
,
3380 struct sockaddr_in
*saddr
,
3383 static CharDriverState
*qemu_chr_open_udp(const char *def
)
3385 CharDriverState
*chr
= NULL
;
3386 NetCharDriver
*s
= NULL
;
3388 struct sockaddr_in saddr
;
3390 chr
= qemu_mallocz(sizeof(CharDriverState
));
3393 s
= qemu_mallocz(sizeof(NetCharDriver
));
3397 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
3399 perror("socket(PF_INET, SOCK_DGRAM)");
3403 if (parse_host_src_port(&s
->daddr
, &saddr
, def
) < 0) {
3404 printf("Could not parse: %s\n", def
);
3408 if (bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
)) < 0)
3418 chr
->chr_write
= udp_chr_write
;
3419 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
3432 /***********************************************************/
3433 /* TCP Net console */
3444 static void tcp_chr_accept(void *opaque
);
3446 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3448 TCPCharDriver
*s
= chr
->opaque
;
3450 return send_all(s
->fd
, buf
, len
);
3452 /* XXX: indicate an error ? */
3457 static int tcp_chr_read_poll(void *opaque
)
3459 CharDriverState
*chr
= opaque
;
3460 TCPCharDriver
*s
= chr
->opaque
;
3463 s
->max_size
= qemu_chr_can_read(chr
);
3468 #define IAC_BREAK 243
3469 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
3471 uint8_t *buf
, int *size
)
3473 /* Handle any telnet client's basic IAC options to satisfy char by
3474 * char mode with no echo. All IAC options will be removed from
3475 * the buf and the do_telnetopt variable will be used to track the
3476 * state of the width of the IAC information.
3478 * IAC commands come in sets of 3 bytes with the exception of the
3479 * "IAC BREAK" command and the double IAC.
3485 for (i
= 0; i
< *size
; i
++) {
3486 if (s
->do_telnetopt
> 1) {
3487 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
3488 /* Double IAC means send an IAC */
3492 s
->do_telnetopt
= 1;
3494 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
3495 /* Handle IAC break commands by sending a serial break */
3496 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
3501 if (s
->do_telnetopt
>= 4) {
3502 s
->do_telnetopt
= 1;
3505 if ((unsigned char)buf
[i
] == IAC
) {
3506 s
->do_telnetopt
= 2;
3517 static void tcp_chr_read(void *opaque
)
3519 CharDriverState
*chr
= opaque
;
3520 TCPCharDriver
*s
= chr
->opaque
;
3524 if (!s
->connected
|| s
->max_size
<= 0)
3527 if (len
> s
->max_size
)
3529 size
= recv(s
->fd
, buf
, len
, 0);
3531 /* connection closed */
3533 if (s
->listen_fd
>= 0) {
3534 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3536 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
3539 } else if (size
> 0) {
3540 if (s
->do_telnetopt
)
3541 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
3543 qemu_chr_read(chr
, buf
, size
);
3547 static void tcp_chr_connect(void *opaque
)
3549 CharDriverState
*chr
= opaque
;
3550 TCPCharDriver
*s
= chr
->opaque
;
3553 qemu_set_fd_handler2(s
->fd
, tcp_chr_read_poll
,
3554 tcp_chr_read
, NULL
, chr
);
3555 qemu_chr_reset(chr
);
3558 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3559 static void tcp_chr_telnet_init(int fd
)
3562 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3563 IACSET(buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3564 send(fd
, (char *)buf
, 3, 0);
3565 IACSET(buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3566 send(fd
, (char *)buf
, 3, 0);
3567 IACSET(buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3568 send(fd
, (char *)buf
, 3, 0);
3569 IACSET(buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3570 send(fd
, (char *)buf
, 3, 0);
3573 static void socket_set_nodelay(int fd
)
3576 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
3579 static void tcp_chr_accept(void *opaque
)
3581 CharDriverState
*chr
= opaque
;
3582 TCPCharDriver
*s
= chr
->opaque
;
3583 struct sockaddr_in saddr
;
3585 struct sockaddr_un uaddr
;
3587 struct sockaddr
*addr
;
3594 len
= sizeof(uaddr
);
3595 addr
= (struct sockaddr
*)&uaddr
;
3599 len
= sizeof(saddr
);
3600 addr
= (struct sockaddr
*)&saddr
;
3602 fd
= accept(s
->listen_fd
, addr
, &len
);
3603 if (fd
< 0 && errno
!= EINTR
) {
3605 } else if (fd
>= 0) {
3606 if (s
->do_telnetopt
)
3607 tcp_chr_telnet_init(fd
);
3611 socket_set_nonblock(fd
);
3613 socket_set_nodelay(fd
);
3615 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
3616 tcp_chr_connect(chr
);
3619 static void tcp_chr_close(CharDriverState
*chr
)
3621 TCPCharDriver
*s
= chr
->opaque
;
3624 if (s
->listen_fd
>= 0)
3625 closesocket(s
->listen_fd
);
3629 static CharDriverState
*qemu_chr_open_tcp(const char *host_str
,
3633 CharDriverState
*chr
= NULL
;
3634 TCPCharDriver
*s
= NULL
;
3635 int fd
= -1, ret
, err
, val
;
3637 int is_waitconnect
= 1;
3640 struct sockaddr_in saddr
;
3642 struct sockaddr_un uaddr
;
3644 struct sockaddr
*addr
;
3649 addr
= (struct sockaddr
*)&uaddr
;
3650 addrlen
= sizeof(uaddr
);
3651 if (parse_unix_path(&uaddr
, host_str
) < 0)
3656 addr
= (struct sockaddr
*)&saddr
;
3657 addrlen
= sizeof(saddr
);
3658 if (parse_host_port(&saddr
, host_str
) < 0)
3663 while((ptr
= strchr(ptr
,','))) {
3665 if (!strncmp(ptr
,"server",6)) {
3667 } else if (!strncmp(ptr
,"nowait",6)) {
3669 } else if (!strncmp(ptr
,"nodelay",6)) {
3672 printf("Unknown option: %s\n", ptr
);
3679 chr
= qemu_mallocz(sizeof(CharDriverState
));
3682 s
= qemu_mallocz(sizeof(TCPCharDriver
));
3688 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
3691 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
3696 if (!is_waitconnect
)
3697 socket_set_nonblock(fd
);
3702 s
->is_unix
= is_unix
;
3703 s
->do_nodelay
= do_nodelay
&& !is_unix
;
3706 chr
->chr_write
= tcp_chr_write
;
3707 chr
->chr_close
= tcp_chr_close
;
3710 /* allow fast reuse */
3714 pstrcpy(path
, sizeof(path
), uaddr
.sun_path
);
3720 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
3723 ret
= bind(fd
, addr
, addrlen
);
3727 ret
= listen(fd
, 0);
3732 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3734 s
->do_telnetopt
= 1;
3737 ret
= connect(fd
, addr
, addrlen
);
3739 err
= socket_error();
3740 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
3741 } else if (err
== EINPROGRESS
) {
3744 } else if (err
== WSAEALREADY
) {
3756 socket_set_nodelay(fd
);
3758 tcp_chr_connect(chr
);
3760 qemu_set_fd_handler(s
->fd
, NULL
, tcp_chr_connect
, chr
);
3763 if (is_listen
&& is_waitconnect
) {
3764 printf("QEMU waiting for connection on: %s\n", host_str
);
3765 tcp_chr_accept(chr
);
3766 socket_set_nonblock(s
->listen_fd
);
3778 CharDriverState
*qemu_chr_open(const char *filename
)
3782 if (!strcmp(filename
, "vc")) {
3783 return text_console_init(&display_state
, 0);
3784 } else if (strstart(filename
, "vc:", &p
)) {
3785 return text_console_init(&display_state
, p
);
3786 } else if (!strcmp(filename
, "null")) {
3787 return qemu_chr_open_null();
3789 if (strstart(filename
, "tcp:", &p
)) {
3790 return qemu_chr_open_tcp(p
, 0, 0);
3792 if (strstart(filename
, "telnet:", &p
)) {
3793 return qemu_chr_open_tcp(p
, 1, 0);
3795 if (strstart(filename
, "udp:", &p
)) {
3796 return qemu_chr_open_udp(p
);
3798 if (strstart(filename
, "mon:", &p
)) {
3799 CharDriverState
*drv
= qemu_chr_open(p
);
3801 drv
= qemu_chr_open_mux(drv
);
3802 monitor_init(drv
, !nographic
);
3805 printf("Unable to open driver: %s\n", p
);
3809 if (strstart(filename
, "unix:", &p
)) {
3810 return qemu_chr_open_tcp(p
, 0, 1);
3811 } else if (strstart(filename
, "file:", &p
)) {
3812 return qemu_chr_open_file_out(p
);
3813 } else if (strstart(filename
, "pipe:", &p
)) {
3814 return qemu_chr_open_pipe(p
);
3815 } else if (!strcmp(filename
, "pty")) {
3816 return qemu_chr_open_pty();
3817 } else if (!strcmp(filename
, "stdio")) {
3818 return qemu_chr_open_stdio();
3820 #if defined(__linux__)
3821 if (strstart(filename
, "/dev/parport", NULL
)) {
3822 return qemu_chr_open_pp(filename
);
3825 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3826 || defined(__NetBSD__) || defined(__OpenBSD__)
3827 if (strstart(filename
, "/dev/", NULL
)) {
3828 return qemu_chr_open_tty(filename
);
3832 if (strstart(filename
, "COM", NULL
)) {
3833 return qemu_chr_open_win(filename
);
3835 if (strstart(filename
, "pipe:", &p
)) {
3836 return qemu_chr_open_win_pipe(p
);
3838 if (strstart(filename
, "con:", NULL
)) {
3839 return qemu_chr_open_win_con(filename
);
3841 if (strstart(filename
, "file:", &p
)) {
3842 return qemu_chr_open_win_file_out(p
);
3845 #ifdef CONFIG_BRLAPI
3846 if (!strcmp(filename
, "braille")) {
3847 return chr_baum_init();
3855 void qemu_chr_close(CharDriverState
*chr
)
3858 chr
->chr_close(chr
);
3862 /***********************************************************/
3863 /* network device redirectors */
3865 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
3866 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
3870 for(i
=0;i
<size
;i
+=16) {
3874 fprintf(f
, "%08x ", i
);
3877 fprintf(f
, " %02x", buf
[i
+j
]);
3882 for(j
=0;j
<len
;j
++) {
3884 if (c
< ' ' || c
> '~')
3886 fprintf(f
, "%c", c
);
3893 static int parse_macaddr(uint8_t *macaddr
, const char *p
)
3900 offset
= strtol(p
, &last_char
, 0);
3901 if (0 == errno
&& '\0' == *last_char
&&
3902 offset
>= 0 && offset
<= 0xFFFFFF) {
3903 macaddr
[3] = (offset
& 0xFF0000) >> 16;
3904 macaddr
[4] = (offset
& 0xFF00) >> 8;
3905 macaddr
[5] = offset
& 0xFF;
3908 for(i
= 0; i
< 6; i
++) {
3909 macaddr
[i
] = strtol(p
, (char **)&p
, 16);
3914 if (*p
!= ':' && *p
!= '-')
3925 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
3930 p1
= strchr(p
, sep
);
3936 if (len
> buf_size
- 1)
3938 memcpy(buf
, p
, len
);
3945 int parse_host_src_port(struct sockaddr_in
*haddr
,
3946 struct sockaddr_in
*saddr
,
3947 const char *input_str
)
3949 char *str
= strdup(input_str
);
3950 char *host_str
= str
;
3952 const char *src_str2
;
3956 * Chop off any extra arguments at the end of the string which
3957 * would start with a comma, then fill in the src port information
3958 * if it was provided else use the "any address" and "any port".
3960 if ((ptr
= strchr(str
,',')))
3963 if ((src_str
= strchr(input_str
,'@'))) {
3968 if (parse_host_port(haddr
, host_str
) < 0)
3972 if (!src_str
|| *src_str
== '\0')
3975 if (parse_host_port(saddr
, src_str2
) < 0)
3986 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
3994 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3996 saddr
->sin_family
= AF_INET
;
3997 if (buf
[0] == '\0') {
3998 saddr
->sin_addr
.s_addr
= 0;
4000 if (isdigit(buf
[0])) {
4001 if (!inet_aton(buf
, &saddr
->sin_addr
))
4004 if ((he
= gethostbyname(buf
)) == NULL
)
4006 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
4009 port
= strtol(p
, (char **)&r
, 0);
4012 saddr
->sin_port
= htons(port
);
4017 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
)
4022 len
= MIN(108, strlen(str
));
4023 p
= strchr(str
, ',');
4025 len
= MIN(len
, p
- str
);
4027 memset(uaddr
, 0, sizeof(*uaddr
));
4029 uaddr
->sun_family
= AF_UNIX
;
4030 memcpy(uaddr
->sun_path
, str
, len
);
4036 /* find or alloc a new VLAN */
4037 VLANState
*qemu_find_vlan(int id
)
4039 VLANState
**pvlan
, *vlan
;
4040 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
4044 vlan
= qemu_mallocz(sizeof(VLANState
));
4049 pvlan
= &first_vlan
;
4050 while (*pvlan
!= NULL
)
4051 pvlan
= &(*pvlan
)->next
;
4056 VLANClientState
*qemu_new_vlan_client(VLANState
*vlan
,
4057 IOReadHandler
*fd_read
,
4058 IOCanRWHandler
*fd_can_read
,
4061 VLANClientState
*vc
, **pvc
;
4062 vc
= qemu_mallocz(sizeof(VLANClientState
));
4065 vc
->fd_read
= fd_read
;
4066 vc
->fd_can_read
= fd_can_read
;
4067 vc
->opaque
= opaque
;
4071 pvc
= &vlan
->first_client
;
4072 while (*pvc
!= NULL
)
4073 pvc
= &(*pvc
)->next
;
4078 void qemu_del_vlan_client(VLANClientState
*vc
)
4080 VLANClientState
**pvc
= &vc
->vlan
->first_client
;
4082 while (*pvc
!= NULL
)
4088 pvc
= &(*pvc
)->next
;
4091 int qemu_can_send_packet(VLANClientState
*vc1
)
4093 VLANState
*vlan
= vc1
->vlan
;
4094 VLANClientState
*vc
;
4096 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4098 if (vc
->fd_can_read
&& vc
->fd_can_read(vc
->opaque
))
4105 void qemu_send_packet(VLANClientState
*vc1
, const uint8_t *buf
, int size
)
4107 VLANState
*vlan
= vc1
->vlan
;
4108 VLANClientState
*vc
;
4111 printf("vlan %d send:\n", vlan
->id
);
4112 hex_dump(stdout
, buf
, size
);
4114 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4116 vc
->fd_read(vc
->opaque
, buf
, size
);
4121 #if defined(CONFIG_SLIRP)
4123 /* slirp network adapter */
4125 static int slirp_inited
;
4126 static VLANClientState
*slirp_vc
;
4128 int slirp_can_output(void)
4130 return !slirp_vc
|| qemu_can_send_packet(slirp_vc
);
4133 void slirp_output(const uint8_t *pkt
, int pkt_len
)
4136 printf("slirp output:\n");
4137 hex_dump(stdout
, pkt
, pkt_len
);
4141 qemu_send_packet(slirp_vc
, pkt
, pkt_len
);
4144 static void slirp_receive(void *opaque
, const uint8_t *buf
, int size
)
4147 printf("slirp input:\n");
4148 hex_dump(stdout
, buf
, size
);
4150 slirp_input(buf
, size
);
4153 static int net_slirp_init(VLANState
*vlan
)
4155 if (!slirp_inited
) {
4159 slirp_vc
= qemu_new_vlan_client(vlan
,
4160 slirp_receive
, NULL
, NULL
);
4161 snprintf(slirp_vc
->info_str
, sizeof(slirp_vc
->info_str
), "user redirector");
4165 static void net_slirp_redir(const char *redir_str
)
4170 struct in_addr guest_addr
;
4171 int host_port
, guest_port
;
4173 if (!slirp_inited
) {
4179 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4181 if (!strcmp(buf
, "tcp")) {
4183 } else if (!strcmp(buf
, "udp")) {
4189 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4191 host_port
= strtol(buf
, &r
, 0);
4195 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4197 if (buf
[0] == '\0') {
4198 pstrcpy(buf
, sizeof(buf
), "10.0.2.15");
4200 if (!inet_aton(buf
, &guest_addr
))
4203 guest_port
= strtol(p
, &r
, 0);
4207 if (slirp_redir(is_udp
, host_port
, guest_addr
, guest_port
) < 0) {
4208 fprintf(stderr
, "qemu: could not set up redirection\n");
4213 fprintf(stderr
, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4219 static char smb_dir
[1024];
4221 static void erase_dir(char *dir_name
)
4225 char filename
[1024];
4227 /* erase all the files in the directory */
4228 if ((d
= opendir(dir_name
)) != 0) {
4233 if (strcmp(de
->d_name
, ".") != 0 &&
4234 strcmp(de
->d_name
, "..") != 0) {
4235 snprintf(filename
, sizeof(filename
), "%s/%s",
4236 smb_dir
, de
->d_name
);
4237 if (unlink(filename
) != 0) /* is it a directory? */
4238 erase_dir(filename
);
4246 /* automatic user mode samba server configuration */
4247 static void smb_exit(void)
4252 /* automatic user mode samba server configuration */
4253 static void net_slirp_smb(const char *exported_dir
)
4255 char smb_conf
[1024];
4256 char smb_cmdline
[1024];
4259 if (!slirp_inited
) {
4264 /* XXX: better tmp dir construction */
4265 snprintf(smb_dir
, sizeof(smb_dir
), "/tmp/qemu-smb.%d", getpid());
4266 if (mkdir(smb_dir
, 0700) < 0) {
4267 fprintf(stderr
, "qemu: could not create samba server dir '%s'\n", smb_dir
);
4270 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", smb_dir
, "smb.conf");
4272 f
= fopen(smb_conf
, "w");
4274 fprintf(stderr
, "qemu: could not create samba server configuration file '%s'\n", smb_conf
);
4281 "socket address=127.0.0.1\n"
4282 "pid directory=%s\n"
4283 "lock directory=%s\n"
4284 "log file=%s/log.smbd\n"
4285 "smb passwd file=%s/smbpasswd\n"
4286 "security = share\n"
4301 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -s %s",
4302 SMBD_COMMAND
, smb_conf
);
4304 slirp_add_exec(0, smb_cmdline
, 4, 139);
4307 #endif /* !defined(_WIN32) */
4308 void do_info_slirp(void)
4313 #endif /* CONFIG_SLIRP */
4315 #if !defined(_WIN32)
4317 typedef struct TAPState
{
4318 VLANClientState
*vc
;
4320 char down_script
[1024];
4323 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
4325 TAPState
*s
= opaque
;
4328 ret
= write(s
->fd
, buf
, size
);
4329 if (ret
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
4336 static void tap_send(void *opaque
)
4338 TAPState
*s
= opaque
;
4345 sbuf
.maxlen
= sizeof(buf
);
4347 size
= getmsg(s
->fd
, NULL
, &sbuf
, &f
) >=0 ? sbuf
.len
: -1;
4349 size
= read(s
->fd
, buf
, sizeof(buf
));
4352 qemu_send_packet(s
->vc
, buf
, size
);
4358 static TAPState
*net_tap_fd_init(VLANState
*vlan
, int fd
)
4362 s
= qemu_mallocz(sizeof(TAPState
));
4366 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
4367 qemu_set_fd_handler(s
->fd
, tap_send
, NULL
, s
);
4368 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "tap: fd=%d", fd
);
4372 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4373 static int tap_open(char *ifname
, int ifname_size
)
4379 TFR(fd
= open("/dev/tap", O_RDWR
));
4381 fprintf(stderr
, "warning: could not open /dev/tap: no virtual network emulation\n");
4386 dev
= devname(s
.st_rdev
, S_IFCHR
);
4387 pstrcpy(ifname
, ifname_size
, dev
);
4389 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4392 #elif defined(__sun__)
4393 #define TUNNEWPPA (('T'<<16) | 0x0001)
4395 * Allocate TAP device, returns opened fd.
4396 * Stores dev name in the first arg(must be large enough).
4398 int tap_alloc(char *dev
, size_t dev_size
)
4400 int tap_fd
, if_fd
, ppa
= -1;
4401 static int ip_fd
= 0;
4404 static int arp_fd
= 0;
4405 int ip_muxid
, arp_muxid
;
4406 struct strioctl strioc_if
, strioc_ppa
;
4407 int link_type
= I_PLINK
;;
4409 char actual_name
[32] = "";
4411 memset(&ifr
, 0x0, sizeof(ifr
));
4415 while( *ptr
&& !isdigit((int)*ptr
) ) ptr
++;
4419 /* Check if IP device was opened */
4423 TFR(ip_fd
= open("/dev/udp", O_RDWR
, 0));
4425 syslog(LOG_ERR
, "Can't open /dev/ip (actually /dev/udp)");
4429 TFR(tap_fd
= open("/dev/tap", O_RDWR
, 0));
4431 syslog(LOG_ERR
, "Can't open /dev/tap");
4435 /* Assign a new PPA and get its unit number. */
4436 strioc_ppa
.ic_cmd
= TUNNEWPPA
;
4437 strioc_ppa
.ic_timout
= 0;
4438 strioc_ppa
.ic_len
= sizeof(ppa
);
4439 strioc_ppa
.ic_dp
= (char *)&ppa
;
4440 if ((ppa
= ioctl (tap_fd
, I_STR
, &strioc_ppa
)) < 0)
4441 syslog (LOG_ERR
, "Can't assign new interface");
4443 TFR(if_fd
= open("/dev/tap", O_RDWR
, 0));
4445 syslog(LOG_ERR
, "Can't open /dev/tap (2)");
4448 if(ioctl(if_fd
, I_PUSH
, "ip") < 0){
4449 syslog(LOG_ERR
, "Can't push IP module");
4453 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) < 0)
4454 syslog(LOG_ERR
, "Can't get flags\n");
4456 snprintf (actual_name
, 32, "tap%d", ppa
);
4457 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4460 /* Assign ppa according to the unit number returned by tun device */
4462 if (ioctl (if_fd
, SIOCSLIFNAME
, &ifr
) < 0)
4463 syslog (LOG_ERR
, "Can't set PPA %d", ppa
);
4464 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) <0)
4465 syslog (LOG_ERR
, "Can't get flags\n");
4466 /* Push arp module to if_fd */
4467 if (ioctl (if_fd
, I_PUSH
, "arp") < 0)
4468 syslog (LOG_ERR
, "Can't push ARP module (2)");
4470 /* Push arp module to ip_fd */
4471 if (ioctl (ip_fd
, I_POP
, NULL
) < 0)
4472 syslog (LOG_ERR
, "I_POP failed\n");
4473 if (ioctl (ip_fd
, I_PUSH
, "arp") < 0)
4474 syslog (LOG_ERR
, "Can't push ARP module (3)\n");
4476 TFR(arp_fd
= open ("/dev/tap", O_RDWR
, 0));
4478 syslog (LOG_ERR
, "Can't open %s\n", "/dev/tap");
4480 /* Set ifname to arp */
4481 strioc_if
.ic_cmd
= SIOCSLIFNAME
;
4482 strioc_if
.ic_timout
= 0;
4483 strioc_if
.ic_len
= sizeof(ifr
);
4484 strioc_if
.ic_dp
= (char *)&ifr
;
4485 if (ioctl(arp_fd
, I_STR
, &strioc_if
) < 0){
4486 syslog (LOG_ERR
, "Can't set ifname to arp\n");
4489 if((ip_muxid
= ioctl(ip_fd
, I_LINK
, if_fd
)) < 0){
4490 syslog(LOG_ERR
, "Can't link TAP device to IP");
4494 if ((arp_muxid
= ioctl (ip_fd
, link_type
, arp_fd
)) < 0)
4495 syslog (LOG_ERR
, "Can't link TAP device to ARP");
4499 memset(&ifr
, 0x0, sizeof(ifr
));
4500 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4501 ifr
.lifr_ip_muxid
= ip_muxid
;
4502 ifr
.lifr_arp_muxid
= arp_muxid
;
4504 if (ioctl (ip_fd
, SIOCSLIFMUXID
, &ifr
) < 0)
4506 ioctl (ip_fd
, I_PUNLINK
, arp_muxid
);
4507 ioctl (ip_fd
, I_PUNLINK
, ip_muxid
);
4508 syslog (LOG_ERR
, "Can't set multiplexor id");
4511 snprintf(dev
, dev_size
, "tap%d", ppa
);
4515 static int tap_open(char *ifname
, int ifname_size
)
4519 if( (fd
= tap_alloc(dev
, sizeof(dev
))) < 0 ){
4520 fprintf(stderr
, "Cannot allocate TAP device\n");
4523 pstrcpy(ifname
, ifname_size
, dev
);
4524 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4528 static int tap_open(char *ifname
, int ifname_size
)
4533 TFR(fd
= open("/dev/net/tun", O_RDWR
));
4535 fprintf(stderr
, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4538 memset(&ifr
, 0, sizeof(ifr
));
4539 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
4540 if (ifname
[0] != '\0')
4541 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, ifname
);
4543 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, "tap%d");
4544 ret
= ioctl(fd
, TUNSETIFF
, (void *) &ifr
);
4546 fprintf(stderr
, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4550 pstrcpy(ifname
, ifname_size
, ifr
.ifr_name
);
4551 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4556 static int launch_script(const char *setup_script
, const char *ifname
, int fd
)
4562 /* try to launch network script */
4566 int open_max
= sysconf (_SC_OPEN_MAX
), i
;
4567 for (i
= 0; i
< open_max
; i
++)
4568 if (i
!= STDIN_FILENO
&&
4569 i
!= STDOUT_FILENO
&&
4570 i
!= STDERR_FILENO
&&
4575 *parg
++ = (char *)setup_script
;
4576 *parg
++ = (char *)ifname
;
4578 execv(setup_script
, args
);
4581 while (waitpid(pid
, &status
, 0) != pid
);
4582 if (!WIFEXITED(status
) ||
4583 WEXITSTATUS(status
) != 0) {
4584 fprintf(stderr
, "%s: could not launch network script\n",
4592 static int net_tap_init(VLANState
*vlan
, const char *ifname1
,
4593 const char *setup_script
, const char *down_script
)
4599 if (ifname1
!= NULL
)
4600 pstrcpy(ifname
, sizeof(ifname
), ifname1
);
4603 TFR(fd
= tap_open(ifname
, sizeof(ifname
)));
4607 if (!setup_script
|| !strcmp(setup_script
, "no"))
4609 if (setup_script
[0] != '\0') {
4610 if (launch_script(setup_script
, ifname
, fd
))
4613 s
= net_tap_fd_init(vlan
, fd
);
4616 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4617 "tap: ifname=%s setup_script=%s", ifname
, setup_script
);
4618 if (down_script
&& strcmp(down_script
, "no"))
4619 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", down_script
);
4623 #endif /* !_WIN32 */
4625 #if defined(CONFIG_VDE)
4626 typedef struct VDEState
{
4627 VLANClientState
*vc
;
4631 static void vde_to_qemu(void *opaque
)
4633 VDEState
*s
= opaque
;
4637 size
= vde_recv(s
->vde
, buf
, sizeof(buf
), 0);
4639 qemu_send_packet(s
->vc
, buf
, size
);
4643 static void vde_from_qemu(void *opaque
, const uint8_t *buf
, int size
)
4645 VDEState
*s
= opaque
;
4648 ret
= vde_send(s
->vde
, buf
, size
, 0);
4649 if (ret
< 0 && errno
== EINTR
) {
4656 static int net_vde_init(VLANState
*vlan
, const char *sock
, int port
,
4657 const char *group
, int mode
)
4660 char *init_group
= strlen(group
) ? (char *)group
: NULL
;
4661 char *init_sock
= strlen(sock
) ? (char *)sock
: NULL
;
4663 struct vde_open_args args
= {
4665 .group
= init_group
,
4669 s
= qemu_mallocz(sizeof(VDEState
));
4672 s
->vde
= vde_open(init_sock
, "QEMU", &args
);
4677 s
->vc
= qemu_new_vlan_client(vlan
, vde_from_qemu
, NULL
, s
);
4678 qemu_set_fd_handler(vde_datafd(s
->vde
), vde_to_qemu
, NULL
, s
);
4679 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "vde: sock=%s fd=%d",
4680 sock
, vde_datafd(s
->vde
));
4685 /* network connection */
4686 typedef struct NetSocketState
{
4687 VLANClientState
*vc
;
4689 int state
; /* 0 = getting length, 1 = getting data */
4693 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4696 typedef struct NetSocketListenState
{
4699 } NetSocketListenState
;
4701 /* XXX: we consider we can send the whole packet without blocking */
4702 static void net_socket_receive(void *opaque
, const uint8_t *buf
, int size
)
4704 NetSocketState
*s
= opaque
;
4708 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
4709 send_all(s
->fd
, buf
, size
);
4712 static void net_socket_receive_dgram(void *opaque
, const uint8_t *buf
, int size
)
4714 NetSocketState
*s
= opaque
;
4715 sendto(s
->fd
, buf
, size
, 0,
4716 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
4719 static void net_socket_send(void *opaque
)
4721 NetSocketState
*s
= opaque
;
4726 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
4728 err
= socket_error();
4729 if (err
!= EWOULDBLOCK
)
4731 } else if (size
== 0) {
4732 /* end of connection */
4734 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4740 /* reassemble a packet from the network */
4746 memcpy(s
->buf
+ s
->index
, buf
, l
);
4750 if (s
->index
== 4) {
4752 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
4758 l
= s
->packet_len
- s
->index
;
4761 memcpy(s
->buf
+ s
->index
, buf
, l
);
4765 if (s
->index
>= s
->packet_len
) {
4766 qemu_send_packet(s
->vc
, s
->buf
, s
->packet_len
);
4775 static void net_socket_send_dgram(void *opaque
)
4777 NetSocketState
*s
= opaque
;
4780 size
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
4784 /* end of connection */
4785 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4788 qemu_send_packet(s
->vc
, s
->buf
, size
);
4791 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
)
4796 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
4797 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4798 inet_ntoa(mcastaddr
->sin_addr
),
4799 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
4803 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
4805 perror("socket(PF_INET, SOCK_DGRAM)");
4810 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
4811 (const char *)&val
, sizeof(val
));
4813 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4817 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
4823 /* Add host to multicast group */
4824 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
4825 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
4827 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
4828 (const char *)&imr
, sizeof(struct ip_mreq
));
4830 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4834 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4836 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
4837 (const char *)&val
, sizeof(val
));
4839 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4843 socket_set_nonblock(fd
);
4851 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
, int fd
,
4854 struct sockaddr_in saddr
;
4856 socklen_t saddr_len
;
4859 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4860 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4861 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4865 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
4867 if (saddr
.sin_addr
.s_addr
==0) {
4868 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4872 /* clone dgram socket */
4873 newfd
= net_socket_mcast_create(&saddr
);
4875 /* error already reported by net_socket_mcast_create() */
4879 /* clone newfd to fd, close newfd */
4884 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4885 fd
, strerror(errno
));
4890 s
= qemu_mallocz(sizeof(NetSocketState
));
4895 s
->vc
= qemu_new_vlan_client(vlan
, net_socket_receive_dgram
, NULL
, s
);
4896 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
4898 /* mcast: save bound address as dst */
4899 if (is_connected
) s
->dgram_dst
=saddr
;
4901 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4902 "socket: fd=%d (%s mcast=%s:%d)",
4903 fd
, is_connected
? "cloned" : "",
4904 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4908 static void net_socket_connect(void *opaque
)
4910 NetSocketState
*s
= opaque
;
4911 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
4914 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
, int fd
,
4918 s
= qemu_mallocz(sizeof(NetSocketState
));
4922 s
->vc
= qemu_new_vlan_client(vlan
,
4923 net_socket_receive
, NULL
, s
);
4924 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4925 "socket: fd=%d", fd
);
4927 net_socket_connect(s
);
4929 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
4934 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
, int fd
,
4937 int so_type
=-1, optlen
=sizeof(so_type
);
4939 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
4940 (socklen_t
*)&optlen
)< 0) {
4941 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
4946 return net_socket_fd_init_dgram(vlan
, fd
, is_connected
);
4948 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4950 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4951 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
4952 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4957 static void net_socket_accept(void *opaque
)
4959 NetSocketListenState
*s
= opaque
;
4961 struct sockaddr_in saddr
;
4966 len
= sizeof(saddr
);
4967 fd
= accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
4968 if (fd
< 0 && errno
!= EINTR
) {
4970 } else if (fd
>= 0) {
4974 s1
= net_socket_fd_init(s
->vlan
, fd
, 1);
4978 snprintf(s1
->vc
->info_str
, sizeof(s1
->vc
->info_str
),
4979 "socket: connection from %s:%d",
4980 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4984 static int net_socket_listen_init(VLANState
*vlan
, const char *host_str
)
4986 NetSocketListenState
*s
;
4988 struct sockaddr_in saddr
;
4990 if (parse_host_port(&saddr
, host_str
) < 0)
4993 s
= qemu_mallocz(sizeof(NetSocketListenState
));
4997 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5002 socket_set_nonblock(fd
);
5004 /* allow fast reuse */
5006 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
5008 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5013 ret
= listen(fd
, 0);
5020 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
5024 static int net_socket_connect_init(VLANState
*vlan
, const char *host_str
)
5027 int fd
, connected
, ret
, err
;
5028 struct sockaddr_in saddr
;
5030 if (parse_host_port(&saddr
, host_str
) < 0)
5033 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5038 socket_set_nonblock(fd
);
5042 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5044 err
= socket_error();
5045 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
5046 } else if (err
== EINPROGRESS
) {
5049 } else if (err
== WSAEALREADY
) {
5062 s
= net_socket_fd_init(vlan
, fd
, connected
);
5065 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5066 "socket: connect to %s:%d",
5067 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5071 static int net_socket_mcast_init(VLANState
*vlan
, const char *host_str
)
5075 struct sockaddr_in saddr
;
5077 if (parse_host_port(&saddr
, host_str
) < 0)
5081 fd
= net_socket_mcast_create(&saddr
);
5085 s
= net_socket_fd_init(vlan
, fd
, 0);
5089 s
->dgram_dst
= saddr
;
5091 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5092 "socket: mcast=%s:%d",
5093 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5098 static const char *get_opt_name(char *buf
, int buf_size
, const char *p
)
5103 while (*p
!= '\0' && *p
!= '=') {
5104 if (q
&& (q
- buf
) < buf_size
- 1)
5114 static const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
5119 while (*p
!= '\0') {
5121 if (*(p
+ 1) != ',')
5125 if (q
&& (q
- buf
) < buf_size
- 1)
5135 static int get_param_value(char *buf
, int buf_size
,
5136 const char *tag
, const char *str
)
5143 p
= get_opt_name(option
, sizeof(option
), p
);
5147 if (!strcmp(tag
, option
)) {
5148 (void)get_opt_value(buf
, buf_size
, p
);
5151 p
= get_opt_value(NULL
, 0, p
);
5160 static int check_params(char *buf
, int buf_size
,
5161 const char * const *params
, const char *str
)
5168 p
= get_opt_name(buf
, buf_size
, p
);
5172 for(i
= 0; params
[i
] != NULL
; i
++)
5173 if (!strcmp(params
[i
], buf
))
5175 if (params
[i
] == NULL
)
5177 p
= get_opt_value(NULL
, 0, p
);
5185 static int net_client_init(const char *device
, const char *p
)
5192 if (get_param_value(buf
, sizeof(buf
), "vlan", p
)) {
5193 vlan_id
= strtol(buf
, NULL
, 0);
5195 vlan
= qemu_find_vlan(vlan_id
);
5197 fprintf(stderr
, "Could not create vlan %d\n", vlan_id
);
5200 if (!strcmp(device
, "nic")) {
5204 if (nb_nics
>= MAX_NICS
) {
5205 fprintf(stderr
, "Too Many NICs\n");
5208 nd
= &nd_table
[nb_nics
];
5209 macaddr
= nd
->macaddr
;
5215 macaddr
[5] = 0x56 + nb_nics
;
5217 if (get_param_value(buf
, sizeof(buf
), "macaddr", p
)) {
5218 if (parse_macaddr(macaddr
, buf
) < 0) {
5219 fprintf(stderr
, "invalid syntax for ethernet address\n");
5223 if (get_param_value(buf
, sizeof(buf
), "model", p
)) {
5224 nd
->model
= strdup(buf
);
5228 vlan
->nb_guest_devs
++;
5231 if (!strcmp(device
, "none")) {
5232 /* does nothing. It is needed to signal that no network cards
5237 if (!strcmp(device
, "user")) {
5238 if (get_param_value(buf
, sizeof(buf
), "hostname", p
)) {
5239 pstrcpy(slirp_hostname
, sizeof(slirp_hostname
), buf
);
5241 vlan
->nb_host_devs
++;
5242 ret
= net_slirp_init(vlan
);
5246 if (!strcmp(device
, "tap")) {
5248 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5249 fprintf(stderr
, "tap: no interface name\n");
5252 vlan
->nb_host_devs
++;
5253 ret
= tap_win32_init(vlan
, ifname
);
5256 if (!strcmp(device
, "tap")) {
5258 char setup_script
[1024], down_script
[1024];
5260 vlan
->nb_host_devs
++;
5261 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5262 fd
= strtol(buf
, NULL
, 0);
5263 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
5265 if (net_tap_fd_init(vlan
, fd
))
5268 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5271 if (get_param_value(setup_script
, sizeof(setup_script
), "script", p
) == 0) {
5272 pstrcpy(setup_script
, sizeof(setup_script
), DEFAULT_NETWORK_SCRIPT
);
5274 if (get_param_value(down_script
, sizeof(down_script
), "downscript", p
) == 0) {
5275 pstrcpy(down_script
, sizeof(down_script
), DEFAULT_NETWORK_DOWN_SCRIPT
);
5277 ret
= net_tap_init(vlan
, ifname
, setup_script
, down_script
);
5281 if (!strcmp(device
, "socket")) {
5282 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5284 fd
= strtol(buf
, NULL
, 0);
5286 if (net_socket_fd_init(vlan
, fd
, 1))
5288 } else if (get_param_value(buf
, sizeof(buf
), "listen", p
) > 0) {
5289 ret
= net_socket_listen_init(vlan
, buf
);
5290 } else if (get_param_value(buf
, sizeof(buf
), "connect", p
) > 0) {
5291 ret
= net_socket_connect_init(vlan
, buf
);
5292 } else if (get_param_value(buf
, sizeof(buf
), "mcast", p
) > 0) {
5293 ret
= net_socket_mcast_init(vlan
, buf
);
5295 fprintf(stderr
, "Unknown socket options: %s\n", p
);
5298 vlan
->nb_host_devs
++;
5301 if (!strcmp(device
, "vde")) {
5302 char vde_sock
[1024], vde_group
[512];
5303 int vde_port
, vde_mode
;
5304 vlan
->nb_host_devs
++;
5305 if (get_param_value(vde_sock
, sizeof(vde_sock
), "sock", p
) <= 0) {
5308 if (get_param_value(buf
, sizeof(buf
), "port", p
) > 0) {
5309 vde_port
= strtol(buf
, NULL
, 10);
5313 if (get_param_value(vde_group
, sizeof(vde_group
), "group", p
) <= 0) {
5314 vde_group
[0] = '\0';
5316 if (get_param_value(buf
, sizeof(buf
), "mode", p
) > 0) {
5317 vde_mode
= strtol(buf
, NULL
, 8);
5321 ret
= net_vde_init(vlan
, vde_sock
, vde_port
, vde_group
, vde_mode
);
5325 fprintf(stderr
, "Unknown network device: %s\n", device
);
5329 fprintf(stderr
, "Could not initialize device '%s'\n", device
);
5335 static int net_client_parse(const char *str
)
5343 while (*p
!= '\0' && *p
!= ',') {
5344 if ((q
- device
) < sizeof(device
) - 1)
5352 return net_client_init(device
, p
);
5355 void do_info_network(void)
5358 VLANClientState
*vc
;
5360 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5361 term_printf("VLAN %d devices:\n", vlan
->id
);
5362 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
)
5363 term_printf(" %s\n", vc
->info_str
);
5367 /***********************************************************/
5368 /* Bluetooth support */
5371 static struct HCIInfo
*hci_table
[MAX_NICS
];
5372 static struct bt_vlan_s
{
5373 struct bt_scatternet_s net
;
5375 struct bt_vlan_s
*next
;
5378 /* find or alloc a new bluetooth "VLAN" */
5379 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
5381 struct bt_vlan_s
**pvlan
, *vlan
;
5382 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5386 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
5388 pvlan
= &first_bt_vlan
;
5389 while (*pvlan
!= NULL
)
5390 pvlan
= &(*pvlan
)->next
;
5395 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
5399 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
5404 static struct HCIInfo null_hci
= {
5405 .cmd_send
= null_hci_send
,
5406 .sco_send
= null_hci_send
,
5407 .acl_send
= null_hci_send
,
5408 .bdaddr_set
= null_hci_addr_set
,
5411 struct HCIInfo
*qemu_next_hci(void)
5413 if (cur_hci
== nb_hcis
)
5416 return hci_table
[cur_hci
++];
5419 /***********************************************************/
5420 /* QEMU Block devices */
5422 #define HD_ALIAS "index=%d,media=disk"
5424 #define CDROM_ALIAS "index=1,media=cdrom"
5426 #define CDROM_ALIAS "index=2,media=cdrom"
5428 #define FD_ALIAS "index=%d,if=floppy"
5429 #define PFLASH_ALIAS "if=pflash"
5430 #define MTD_ALIAS "if=mtd"
5431 #define SD_ALIAS "index=0,if=sd"
5433 static int drive_add(const char *file
, const char *fmt
, ...)
5437 if (nb_drives_opt
>= MAX_DRIVES
) {
5438 fprintf(stderr
, "qemu: too many drives\n");
5442 drives_opt
[nb_drives_opt
].file
= file
;
5444 vsnprintf(drives_opt
[nb_drives_opt
].opt
,
5445 sizeof(drives_opt
[0].opt
), fmt
, ap
);
5448 return nb_drives_opt
++;
5451 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
5455 /* seek interface, bus and unit */
5457 for (index
= 0; index
< nb_drives
; index
++)
5458 if (drives_table
[index
].type
== type
&&
5459 drives_table
[index
].bus
== bus
&&
5460 drives_table
[index
].unit
== unit
)
5466 int drive_get_max_bus(BlockInterfaceType type
)
5472 for (index
= 0; index
< nb_drives
; index
++) {
5473 if(drives_table
[index
].type
== type
&&
5474 drives_table
[index
].bus
> max_bus
)
5475 max_bus
= drives_table
[index
].bus
;
5480 static void bdrv_format_print(void *opaque
, const char *name
)
5482 fprintf(stderr
, " %s", name
);
5485 static int drive_init(struct drive_opt
*arg
, int snapshot
,
5486 QEMUMachine
*machine
)
5491 const char *mediastr
= "";
5492 BlockInterfaceType type
;
5493 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
5494 int bus_id
, unit_id
;
5495 int cyls
, heads
, secs
, translation
;
5496 BlockDriverState
*bdrv
;
5497 BlockDriver
*drv
= NULL
;
5502 char *str
= arg
->opt
;
5503 static const char * const params
[] = { "bus", "unit", "if", "index",
5504 "cyls", "heads", "secs", "trans",
5505 "media", "snapshot", "file",
5506 "cache", "format", NULL
};
5508 if (check_params(buf
, sizeof(buf
), params
, str
) < 0) {
5509 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
5515 cyls
= heads
= secs
= 0;
5518 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5522 if (machine
->use_scsi
) {
5524 max_devs
= MAX_SCSI_DEVS
;
5525 pstrcpy(devname
, sizeof(devname
), "scsi");
5528 max_devs
= MAX_IDE_DEVS
;
5529 pstrcpy(devname
, sizeof(devname
), "ide");
5533 /* extract parameters */
5535 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
5536 bus_id
= strtol(buf
, NULL
, 0);
5538 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
5543 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
5544 unit_id
= strtol(buf
, NULL
, 0);
5546 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
5551 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
5552 pstrcpy(devname
, sizeof(devname
), buf
);
5553 if (!strcmp(buf
, "ide")) {
5555 max_devs
= MAX_IDE_DEVS
;
5556 } else if (!strcmp(buf
, "scsi")) {
5558 max_devs
= MAX_SCSI_DEVS
;
5559 } else if (!strcmp(buf
, "floppy")) {
5562 } else if (!strcmp(buf
, "pflash")) {
5565 } else if (!strcmp(buf
, "mtd")) {
5568 } else if (!strcmp(buf
, "sd")) {
5572 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
5577 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
5578 index
= strtol(buf
, NULL
, 0);
5580 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
5585 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
5586 cyls
= strtol(buf
, NULL
, 0);
5589 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
5590 heads
= strtol(buf
, NULL
, 0);
5593 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
5594 secs
= strtol(buf
, NULL
, 0);
5597 if (cyls
|| heads
|| secs
) {
5598 if (cyls
< 1 || cyls
> 16383) {
5599 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
5602 if (heads
< 1 || heads
> 16) {
5603 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
5606 if (secs
< 1 || secs
> 63) {
5607 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
5612 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
5615 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5619 if (!strcmp(buf
, "none"))
5620 translation
= BIOS_ATA_TRANSLATION_NONE
;
5621 else if (!strcmp(buf
, "lba"))
5622 translation
= BIOS_ATA_TRANSLATION_LBA
;
5623 else if (!strcmp(buf
, "auto"))
5624 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5626 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
5631 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
5632 if (!strcmp(buf
, "disk")) {
5634 } else if (!strcmp(buf
, "cdrom")) {
5635 if (cyls
|| secs
|| heads
) {
5637 "qemu: '%s' invalid physical CHS format\n", str
);
5640 media
= MEDIA_CDROM
;
5642 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
5647 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
5648 if (!strcmp(buf
, "on"))
5650 else if (!strcmp(buf
, "off"))
5653 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
5658 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
5659 if (!strcmp(buf
, "off"))
5661 else if (!strcmp(buf
, "on"))
5664 fprintf(stderr
, "qemu: invalid cache option\n");
5669 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
5670 if (strcmp(buf
, "?") == 0) {
5671 fprintf(stderr
, "qemu: Supported formats:");
5672 bdrv_iterate_format(bdrv_format_print
, NULL
);
5673 fprintf(stderr
, "\n");
5676 drv
= bdrv_find_format(buf
);
5678 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
5683 if (arg
->file
== NULL
)
5684 get_param_value(file
, sizeof(file
), "file", str
);
5686 pstrcpy(file
, sizeof(file
), arg
->file
);
5688 /* compute bus and unit according index */
5691 if (bus_id
!= 0 || unit_id
!= -1) {
5693 "qemu: '%s' index cannot be used with bus and unit\n", str
);
5701 unit_id
= index
% max_devs
;
5702 bus_id
= index
/ max_devs
;
5706 /* if user doesn't specify a unit_id,
5707 * try to find the first free
5710 if (unit_id
== -1) {
5712 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
5714 if (max_devs
&& unit_id
>= max_devs
) {
5715 unit_id
-= max_devs
;
5723 if (max_devs
&& unit_id
>= max_devs
) {
5724 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
5725 str
, unit_id
, max_devs
- 1);
5730 * ignore multiple definitions
5733 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
5738 if (type
== IF_IDE
|| type
== IF_SCSI
)
5739 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
5741 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
5742 devname
, bus_id
, mediastr
, unit_id
);
5744 snprintf(buf
, sizeof(buf
), "%s%s%i",
5745 devname
, mediastr
, unit_id
);
5746 bdrv
= bdrv_new(buf
);
5747 drives_table
[nb_drives
].bdrv
= bdrv
;
5748 drives_table
[nb_drives
].type
= type
;
5749 drives_table
[nb_drives
].bus
= bus_id
;
5750 drives_table
[nb_drives
].unit
= unit_id
;
5759 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
5760 bdrv_set_translation_hint(bdrv
, translation
);
5764 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
5769 /* FIXME: This isn't really a floppy, but it's a reasonable
5772 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
5782 bdrv_flags
|= BDRV_O_SNAPSHOT
;
5784 bdrv_flags
|= BDRV_O_DIRECT
;
5785 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0 || qemu_key_check(bdrv
, file
)) {
5786 fprintf(stderr
, "qemu: could not open disk image %s\n",
5793 /***********************************************************/
5796 static USBPort
*used_usb_ports
;
5797 static USBPort
*free_usb_ports
;
5799 /* ??? Maybe change this to register a hub to keep track of the topology. */
5800 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
5801 usb_attachfn attach
)
5803 port
->opaque
= opaque
;
5804 port
->index
= index
;
5805 port
->attach
= attach
;
5806 port
->next
= free_usb_ports
;
5807 free_usb_ports
= port
;
5810 int usb_device_add_dev(USBDevice
*dev
)
5814 /* Find a USB port to add the device to. */
5815 port
= free_usb_ports
;
5819 /* Create a new hub and chain it on. */
5820 free_usb_ports
= NULL
;
5821 port
->next
= used_usb_ports
;
5822 used_usb_ports
= port
;
5824 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
5825 usb_attach(port
, hub
);
5826 port
= free_usb_ports
;
5829 free_usb_ports
= port
->next
;
5830 port
->next
= used_usb_ports
;
5831 used_usb_ports
= port
;
5832 usb_attach(port
, dev
);
5836 static int usb_device_add(const char *devname
)
5841 if (!free_usb_ports
)
5844 if (strstart(devname
, "host:", &p
)) {
5845 dev
= usb_host_device_open(p
);
5846 } else if (!strcmp(devname
, "mouse")) {
5847 dev
= usb_mouse_init();
5848 } else if (!strcmp(devname
, "tablet")) {
5849 dev
= usb_tablet_init();
5850 } else if (!strcmp(devname
, "keyboard")) {
5851 dev
= usb_keyboard_init();
5852 } else if (strstart(devname
, "disk:", &p
)) {
5853 dev
= usb_msd_init(p
);
5854 } else if (!strcmp(devname
, "wacom-tablet")) {
5855 dev
= usb_wacom_init();
5856 } else if (strstart(devname
, "serial:", &p
)) {
5857 dev
= usb_serial_init(p
);
5858 #ifdef CONFIG_BRLAPI
5859 } else if (!strcmp(devname
, "braille")) {
5860 dev
= usb_baum_init();
5862 } else if (strstart(devname
, "net:", &p
)) {
5865 if (net_client_init("nic", p
) < 0)
5867 nd_table
[nic
].model
= "usb";
5868 dev
= usb_net_init(&nd_table
[nic
]);
5875 return usb_device_add_dev(dev
);
5878 int usb_device_del_addr(int bus_num
, int addr
)
5884 if (!used_usb_ports
)
5890 lastp
= &used_usb_ports
;
5891 port
= used_usb_ports
;
5892 while (port
&& port
->dev
->addr
!= addr
) {
5893 lastp
= &port
->next
;
5901 *lastp
= port
->next
;
5902 usb_attach(port
, NULL
);
5903 dev
->handle_destroy(dev
);
5904 port
->next
= free_usb_ports
;
5905 free_usb_ports
= port
;
5909 static int usb_device_del(const char *devname
)
5914 if (strstart(devname
, "host:", &p
))
5915 return usb_host_device_close(p
);
5917 if (!used_usb_ports
)
5920 p
= strchr(devname
, '.');
5923 bus_num
= strtoul(devname
, NULL
, 0);
5924 addr
= strtoul(p
+ 1, NULL
, 0);
5926 return usb_device_del_addr(bus_num
, addr
);
5929 void do_usb_add(const char *devname
)
5931 usb_device_add(devname
);
5934 void do_usb_del(const char *devname
)
5936 usb_device_del(devname
);
5943 const char *speed_str
;
5946 term_printf("USB support not enabled\n");
5950 for (port
= used_usb_ports
; port
; port
= port
->next
) {
5954 switch(dev
->speed
) {
5958 case USB_SPEED_FULL
:
5961 case USB_SPEED_HIGH
:
5968 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5969 0, dev
->addr
, speed_str
, dev
->devname
);
5973 /***********************************************************/
5974 /* PCMCIA/Cardbus */
5976 static struct pcmcia_socket_entry_s
{
5977 struct pcmcia_socket_s
*socket
;
5978 struct pcmcia_socket_entry_s
*next
;
5979 } *pcmcia_sockets
= 0;
5981 void pcmcia_socket_register(struct pcmcia_socket_s
*socket
)
5983 struct pcmcia_socket_entry_s
*entry
;
5985 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
5986 entry
->socket
= socket
;
5987 entry
->next
= pcmcia_sockets
;
5988 pcmcia_sockets
= entry
;
5991 void pcmcia_socket_unregister(struct pcmcia_socket_s
*socket
)
5993 struct pcmcia_socket_entry_s
*entry
, **ptr
;
5995 ptr
= &pcmcia_sockets
;
5996 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
5997 if (entry
->socket
== socket
) {
6003 void pcmcia_info(void)
6005 struct pcmcia_socket_entry_s
*iter
;
6006 if (!pcmcia_sockets
)
6007 term_printf("No PCMCIA sockets\n");
6009 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
6010 term_printf("%s: %s\n", iter
->socket
->slot_string
,
6011 iter
->socket
->attached
? iter
->socket
->card_string
:
6015 /***********************************************************/
6018 static void dumb_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
6022 static void dumb_resize(DisplayState
*ds
, int w
, int h
)
6026 static void dumb_refresh(DisplayState
*ds
)
6028 #if defined(CONFIG_SDL)
6033 static void dumb_display_init(DisplayState
*ds
)
6038 ds
->dpy_update
= dumb_update
;
6039 ds
->dpy_resize
= dumb_resize
;
6040 ds
->dpy_refresh
= dumb_refresh
;
6041 ds
->gui_timer_interval
= 500;
6045 /***********************************************************/
6048 #define MAX_IO_HANDLERS 64
6050 typedef struct IOHandlerRecord
{
6052 IOCanRWHandler
*fd_read_poll
;
6054 IOHandler
*fd_write
;
6057 /* temporary data */
6059 struct IOHandlerRecord
*next
;
6062 static IOHandlerRecord
*first_io_handler
;
6064 /* XXX: fd_read_poll should be suppressed, but an API change is
6065 necessary in the character devices to suppress fd_can_read(). */
6066 int qemu_set_fd_handler2(int fd
,
6067 IOCanRWHandler
*fd_read_poll
,
6069 IOHandler
*fd_write
,
6072 IOHandlerRecord
**pioh
, *ioh
;
6074 if (!fd_read
&& !fd_write
) {
6075 pioh
= &first_io_handler
;
6080 if (ioh
->fd
== fd
) {
6087 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
6091 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
6094 ioh
->next
= first_io_handler
;
6095 first_io_handler
= ioh
;
6098 ioh
->fd_read_poll
= fd_read_poll
;
6099 ioh
->fd_read
= fd_read
;
6100 ioh
->fd_write
= fd_write
;
6101 ioh
->opaque
= opaque
;
6107 int qemu_set_fd_handler(int fd
,
6109 IOHandler
*fd_write
,
6112 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
6115 /***********************************************************/
6116 /* Polling handling */
6118 typedef struct PollingEntry
{
6121 struct PollingEntry
*next
;
6124 static PollingEntry
*first_polling_entry
;
6126 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
6128 PollingEntry
**ppe
, *pe
;
6129 pe
= qemu_mallocz(sizeof(PollingEntry
));
6133 pe
->opaque
= opaque
;
6134 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
6139 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
6141 PollingEntry
**ppe
, *pe
;
6142 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
6144 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
6153 /***********************************************************/
6154 /* Wait objects support */
6155 typedef struct WaitObjects
{
6157 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
6158 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
6159 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
6162 static WaitObjects wait_objects
= {0};
6164 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6166 WaitObjects
*w
= &wait_objects
;
6168 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
6170 w
->events
[w
->num
] = handle
;
6171 w
->func
[w
->num
] = func
;
6172 w
->opaque
[w
->num
] = opaque
;
6177 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6180 WaitObjects
*w
= &wait_objects
;
6183 for (i
= 0; i
< w
->num
; i
++) {
6184 if (w
->events
[i
] == handle
)
6187 w
->events
[i
] = w
->events
[i
+ 1];
6188 w
->func
[i
] = w
->func
[i
+ 1];
6189 w
->opaque
[i
] = w
->opaque
[i
+ 1];
6197 /***********************************************************/
6198 /* savevm/loadvm support */
6200 #define IO_BUF_SIZE 32768
6203 QEMUFilePutBufferFunc
*put_buffer
;
6204 QEMUFileGetBufferFunc
*get_buffer
;
6205 QEMUFileCloseFunc
*close
;
6206 QEMUFileRateLimit
*rate_limit
;
6209 int64_t buf_offset
; /* start of buffer when writing, end of buffer
6212 int buf_size
; /* 0 when writing */
6213 uint8_t buf
[IO_BUF_SIZE
];
6216 typedef struct QEMUFileFD
6222 static void fd_put_notify(void *opaque
)
6224 QEMUFileFD
*s
= opaque
;
6226 /* Remove writable callback and do a put notify */
6227 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
6228 qemu_file_put_notify(s
->file
);
6231 static void fd_put_buffer(void *opaque
, const uint8_t *buf
,
6232 int64_t pos
, int size
)
6234 QEMUFileFD
*s
= opaque
;
6238 len
= write(s
->fd
, buf
, size
);
6239 } while (len
== -1 && errno
== EINTR
);
6244 /* When the fd becomes writable again, register a callback to do
6247 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, fd_put_notify
, s
);
6250 static int fd_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6252 QEMUFileFD
*s
= opaque
;
6256 len
= read(s
->fd
, buf
, size
);
6257 } while (len
== -1 && errno
== EINTR
);
6265 static int fd_close(void *opaque
)
6267 QEMUFileFD
*s
= opaque
;
6272 QEMUFile
*qemu_fopen_fd(int fd
)
6274 QEMUFileFD
*s
= qemu_mallocz(sizeof(QEMUFileFD
));
6280 s
->file
= qemu_fopen_ops(s
, fd_put_buffer
, fd_get_buffer
, fd_close
, NULL
);
6284 typedef struct QEMUFileStdio
6289 static void file_put_buffer(void *opaque
, const uint8_t *buf
,
6290 int64_t pos
, int size
)
6292 QEMUFileStdio
*s
= opaque
;
6293 fseek(s
->outfile
, pos
, SEEK_SET
);
6294 fwrite(buf
, 1, size
, s
->outfile
);
6297 static int file_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6299 QEMUFileStdio
*s
= opaque
;
6300 fseek(s
->outfile
, pos
, SEEK_SET
);
6301 return fread(buf
, 1, size
, s
->outfile
);
6304 static int file_close(void *opaque
)
6306 QEMUFileStdio
*s
= opaque
;
6312 QEMUFile
*qemu_fopen(const char *filename
, const char *mode
)
6316 s
= qemu_mallocz(sizeof(QEMUFileStdio
));
6320 s
->outfile
= fopen(filename
, mode
);
6324 if (!strcmp(mode
, "wb"))
6325 return qemu_fopen_ops(s
, file_put_buffer
, NULL
, file_close
, NULL
);
6326 else if (!strcmp(mode
, "rb"))
6327 return qemu_fopen_ops(s
, NULL
, file_get_buffer
, file_close
, NULL
);
6336 typedef struct QEMUFileBdrv
6338 BlockDriverState
*bs
;
6339 int64_t base_offset
;
6342 static void bdrv_put_buffer(void *opaque
, const uint8_t *buf
,
6343 int64_t pos
, int size
)
6345 QEMUFileBdrv
*s
= opaque
;
6346 bdrv_pwrite(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6349 static int bdrv_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6351 QEMUFileBdrv
*s
= opaque
;
6352 return bdrv_pread(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6355 static int bdrv_fclose(void *opaque
)
6357 QEMUFileBdrv
*s
= opaque
;
6362 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int64_t offset
, int is_writable
)
6366 s
= qemu_mallocz(sizeof(QEMUFileBdrv
));
6371 s
->base_offset
= offset
;
6374 return qemu_fopen_ops(s
, bdrv_put_buffer
, NULL
, bdrv_fclose
, NULL
);
6376 return qemu_fopen_ops(s
, NULL
, bdrv_get_buffer
, bdrv_fclose
, NULL
);
6379 QEMUFile
*qemu_fopen_ops(void *opaque
, QEMUFilePutBufferFunc
*put_buffer
,
6380 QEMUFileGetBufferFunc
*get_buffer
,
6381 QEMUFileCloseFunc
*close
,
6382 QEMUFileRateLimit
*rate_limit
)
6386 f
= qemu_mallocz(sizeof(QEMUFile
));
6391 f
->put_buffer
= put_buffer
;
6392 f
->get_buffer
= get_buffer
;
6394 f
->rate_limit
= rate_limit
;
6399 void qemu_fflush(QEMUFile
*f
)
6404 if (f
->buf_index
> 0) {
6405 f
->put_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, f
->buf_index
);
6406 f
->buf_offset
+= f
->buf_index
;
6411 static void qemu_fill_buffer(QEMUFile
*f
)
6418 len
= f
->get_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, IO_BUF_SIZE
);
6424 f
->buf_offset
+= len
;
6427 int qemu_fclose(QEMUFile
*f
)
6432 ret
= f
->close(f
->opaque
);
6437 void qemu_file_put_notify(QEMUFile
*f
)
6439 f
->put_buffer(f
->opaque
, NULL
, 0, 0);
6442 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, int size
)
6446 l
= IO_BUF_SIZE
- f
->buf_index
;
6449 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
6453 if (f
->buf_index
>= IO_BUF_SIZE
)
6458 void qemu_put_byte(QEMUFile
*f
, int v
)
6460 f
->buf
[f
->buf_index
++] = v
;
6461 if (f
->buf_index
>= IO_BUF_SIZE
)
6465 int qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, int size1
)
6471 l
= f
->buf_size
- f
->buf_index
;
6473 qemu_fill_buffer(f
);
6474 l
= f
->buf_size
- f
->buf_index
;
6480 memcpy(buf
, f
->buf
+ f
->buf_index
, l
);
6485 return size1
- size
;
6488 int qemu_get_byte(QEMUFile
*f
)
6490 if (f
->buf_index
>= f
->buf_size
) {
6491 qemu_fill_buffer(f
);
6492 if (f
->buf_index
>= f
->buf_size
)
6495 return f
->buf
[f
->buf_index
++];
6498 int64_t qemu_ftell(QEMUFile
*f
)
6500 return f
->buf_offset
- f
->buf_size
+ f
->buf_index
;
6503 int64_t qemu_fseek(QEMUFile
*f
, int64_t pos
, int whence
)
6505 if (whence
== SEEK_SET
) {
6507 } else if (whence
== SEEK_CUR
) {
6508 pos
+= qemu_ftell(f
);
6510 /* SEEK_END not supported */
6513 if (f
->put_buffer
) {
6515 f
->buf_offset
= pos
;
6517 f
->buf_offset
= pos
;
6524 int qemu_file_rate_limit(QEMUFile
*f
)
6527 return f
->rate_limit(f
->opaque
);
6532 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
6534 qemu_put_byte(f
, v
>> 8);
6535 qemu_put_byte(f
, v
);
6538 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
6540 qemu_put_byte(f
, v
>> 24);
6541 qemu_put_byte(f
, v
>> 16);
6542 qemu_put_byte(f
, v
>> 8);
6543 qemu_put_byte(f
, v
);
6546 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
6548 qemu_put_be32(f
, v
>> 32);
6549 qemu_put_be32(f
, v
);
6552 unsigned int qemu_get_be16(QEMUFile
*f
)
6555 v
= qemu_get_byte(f
) << 8;
6556 v
|= qemu_get_byte(f
);
6560 unsigned int qemu_get_be32(QEMUFile
*f
)
6563 v
= qemu_get_byte(f
) << 24;
6564 v
|= qemu_get_byte(f
) << 16;
6565 v
|= qemu_get_byte(f
) << 8;
6566 v
|= qemu_get_byte(f
);
6570 uint64_t qemu_get_be64(QEMUFile
*f
)
6573 v
= (uint64_t)qemu_get_be32(f
) << 32;
6574 v
|= qemu_get_be32(f
);
6578 typedef struct SaveStateEntry
{
6583 SaveLiveStateHandler
*save_live_state
;
6584 SaveStateHandler
*save_state
;
6585 LoadStateHandler
*load_state
;
6587 struct SaveStateEntry
*next
;
6590 static SaveStateEntry
*first_se
;
6592 /* TODO: Individual devices generally have very little idea about the rest
6593 of the system, so instance_id should be removed/replaced.
6594 Meanwhile pass -1 as instance_id if you do not already have a clearly
6595 distinguishing id for all instances of your device class. */
6596 int register_savevm_live(const char *idstr
,
6599 SaveLiveStateHandler
*save_live_state
,
6600 SaveStateHandler
*save_state
,
6601 LoadStateHandler
*load_state
,
6604 SaveStateEntry
*se
, **pse
;
6605 static int global_section_id
;
6607 se
= qemu_malloc(sizeof(SaveStateEntry
));
6610 pstrcpy(se
->idstr
, sizeof(se
->idstr
), idstr
);
6611 se
->instance_id
= (instance_id
== -1) ? 0 : instance_id
;
6612 se
->version_id
= version_id
;
6613 se
->section_id
= global_section_id
++;
6614 se
->save_live_state
= save_live_state
;
6615 se
->save_state
= save_state
;
6616 se
->load_state
= load_state
;
6617 se
->opaque
= opaque
;
6620 /* add at the end of list */
6622 while (*pse
!= NULL
) {
6623 if (instance_id
== -1
6624 && strcmp(se
->idstr
, (*pse
)->idstr
) == 0
6625 && se
->instance_id
<= (*pse
)->instance_id
)
6626 se
->instance_id
= (*pse
)->instance_id
+ 1;
6627 pse
= &(*pse
)->next
;
6633 int register_savevm(const char *idstr
,
6636 SaveStateHandler
*save_state
,
6637 LoadStateHandler
*load_state
,
6640 return register_savevm_live(idstr
, instance_id
, version_id
,
6641 NULL
, save_state
, load_state
, opaque
);
6644 #define QEMU_VM_FILE_MAGIC 0x5145564d
6645 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
6646 #define QEMU_VM_FILE_VERSION 0x00000003
6648 #define QEMU_VM_EOF 0x00
6649 #define QEMU_VM_SECTION_START 0x01
6650 #define QEMU_VM_SECTION_PART 0x02
6651 #define QEMU_VM_SECTION_END 0x03
6652 #define QEMU_VM_SECTION_FULL 0x04
6654 int qemu_savevm_state_begin(QEMUFile
*f
)
6658 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
6659 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
6661 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
6664 if (se
->save_live_state
== NULL
)
6668 qemu_put_byte(f
, QEMU_VM_SECTION_START
);
6669 qemu_put_be32(f
, se
->section_id
);
6672 len
= strlen(se
->idstr
);
6673 qemu_put_byte(f
, len
);
6674 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6676 qemu_put_be32(f
, se
->instance_id
);
6677 qemu_put_be32(f
, se
->version_id
);
6679 se
->save_live_state(f
, QEMU_VM_SECTION_START
, se
->opaque
);
6685 int qemu_savevm_state_iterate(QEMUFile
*f
)
6690 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
6691 if (se
->save_live_state
== NULL
)
6695 qemu_put_byte(f
, QEMU_VM_SECTION_PART
);
6696 qemu_put_be32(f
, se
->section_id
);
6698 ret
&= !!se
->save_live_state(f
, QEMU_VM_SECTION_PART
, se
->opaque
);
6707 int qemu_savevm_state_complete(QEMUFile
*f
)
6711 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
6712 if (se
->save_live_state
== NULL
)
6716 qemu_put_byte(f
, QEMU_VM_SECTION_END
);
6717 qemu_put_be32(f
, se
->section_id
);
6719 se
->save_live_state(f
, QEMU_VM_SECTION_END
, se
->opaque
);
6722 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6725 if (se
->save_state
== NULL
)
6729 qemu_put_byte(f
, QEMU_VM_SECTION_FULL
);
6730 qemu_put_be32(f
, se
->section_id
);
6733 len
= strlen(se
->idstr
);
6734 qemu_put_byte(f
, len
);
6735 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6737 qemu_put_be32(f
, se
->instance_id
);
6738 qemu_put_be32(f
, se
->version_id
);
6740 se
->save_state(f
, se
->opaque
);
6743 qemu_put_byte(f
, QEMU_VM_EOF
);
6748 int qemu_savevm_state(QEMUFile
*f
)
6750 int saved_vm_running
;
6753 saved_vm_running
= vm_running
;
6756 ret
= qemu_savevm_state_begin(f
);
6761 ret
= qemu_savevm_state_iterate(f
);
6766 ret
= qemu_savevm_state_complete(f
);
6769 if (saved_vm_running
)
6774 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
6778 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6779 if (!strcmp(se
->idstr
, idstr
) &&
6780 instance_id
== se
->instance_id
)
6786 typedef struct LoadStateEntry
{
6790 struct LoadStateEntry
*next
;
6793 static int qemu_loadvm_state_v2(QEMUFile
*f
)
6796 int len
, ret
, instance_id
, record_len
, version_id
;
6797 int64_t total_len
, end_pos
, cur_pos
;
6800 total_len
= qemu_get_be64(f
);
6801 end_pos
= total_len
+ qemu_ftell(f
);
6803 if (qemu_ftell(f
) >= end_pos
)
6805 len
= qemu_get_byte(f
);
6806 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6808 instance_id
= qemu_get_be32(f
);
6809 version_id
= qemu_get_be32(f
);
6810 record_len
= qemu_get_be32(f
);
6811 cur_pos
= qemu_ftell(f
);
6812 se
= find_se(idstr
, instance_id
);
6814 fprintf(stderr
, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6815 instance_id
, idstr
);
6817 ret
= se
->load_state(f
, se
->opaque
, version_id
);
6819 fprintf(stderr
, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6820 instance_id
, idstr
);
6823 /* always seek to exact end of record */
6824 qemu_fseek(f
, cur_pos
+ record_len
, SEEK_SET
);
6829 int qemu_loadvm_state(QEMUFile
*f
)
6831 LoadStateEntry
*first_le
= NULL
;
6832 uint8_t section_type
;
6836 v
= qemu_get_be32(f
);
6837 if (v
!= QEMU_VM_FILE_MAGIC
)
6840 v
= qemu_get_be32(f
);
6841 if (v
== QEMU_VM_FILE_VERSION_COMPAT
)
6842 return qemu_loadvm_state_v2(f
);
6843 if (v
!= QEMU_VM_FILE_VERSION
)
6846 while ((section_type
= qemu_get_byte(f
)) != QEMU_VM_EOF
) {
6847 uint32_t instance_id
, version_id
, section_id
;
6853 switch (section_type
) {
6854 case QEMU_VM_SECTION_START
:
6855 case QEMU_VM_SECTION_FULL
:
6856 /* Read section start */
6857 section_id
= qemu_get_be32(f
);
6858 len
= qemu_get_byte(f
);
6859 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6861 instance_id
= qemu_get_be32(f
);
6862 version_id
= qemu_get_be32(f
);
6864 /* Find savevm section */
6865 se
= find_se(idstr
, instance_id
);
6867 fprintf(stderr
, "Unknown savevm section or instance '%s' %d\n", idstr
, instance_id
);
6872 /* Validate version */
6873 if (version_id
> se
->version_id
) {
6874 fprintf(stderr
, "savevm: unsupported version %d for '%s' v%d\n",
6875 version_id
, idstr
, se
->version_id
);
6881 le
= qemu_mallocz(sizeof(*le
));
6888 le
->section_id
= section_id
;
6889 le
->version_id
= version_id
;
6890 le
->next
= first_le
;
6893 le
->se
->load_state(f
, le
->se
->opaque
, le
->version_id
);
6895 case QEMU_VM_SECTION_PART
:
6896 case QEMU_VM_SECTION_END
:
6897 section_id
= qemu_get_be32(f
);
6899 for (le
= first_le
; le
&& le
->section_id
!= section_id
; le
= le
->next
);
6901 fprintf(stderr
, "Unknown savevm section %d\n", section_id
);
6906 le
->se
->load_state(f
, le
->se
->opaque
, le
->version_id
);
6909 fprintf(stderr
, "Unknown savevm section type %d\n", section_type
);
6919 LoadStateEntry
*le
= first_le
;
6920 first_le
= first_le
->next
;
6927 /* device can contain snapshots */
6928 static int bdrv_can_snapshot(BlockDriverState
*bs
)
6931 !bdrv_is_removable(bs
) &&
6932 !bdrv_is_read_only(bs
));
6935 /* device must be snapshots in order to have a reliable snapshot */
6936 static int bdrv_has_snapshot(BlockDriverState
*bs
)
6939 !bdrv_is_removable(bs
) &&
6940 !bdrv_is_read_only(bs
));
6943 static BlockDriverState
*get_bs_snapshots(void)
6945 BlockDriverState
*bs
;
6949 return bs_snapshots
;
6950 for(i
= 0; i
<= nb_drives
; i
++) {
6951 bs
= drives_table
[i
].bdrv
;
6952 if (bdrv_can_snapshot(bs
))
6961 static int bdrv_snapshot_find(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
,
6964 QEMUSnapshotInfo
*sn_tab
, *sn
;
6968 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
6971 for(i
= 0; i
< nb_sns
; i
++) {
6973 if (!strcmp(sn
->id_str
, name
) || !strcmp(sn
->name
, name
)) {
6983 void do_savevm(const char *name
)
6985 BlockDriverState
*bs
, *bs1
;
6986 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
6987 int must_delete
, ret
, i
;
6988 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6990 int saved_vm_running
;
6997 bs
= get_bs_snapshots();
6999 term_printf("No block device can accept snapshots\n");
7003 /* ??? Should this occur after vm_stop? */
7006 saved_vm_running
= vm_running
;
7011 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
7016 memset(sn
, 0, sizeof(*sn
));
7018 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
7019 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
7022 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
7025 /* fill auxiliary fields */
7028 sn
->date_sec
= tb
.time
;
7029 sn
->date_nsec
= tb
.millitm
* 1000000;
7031 gettimeofday(&tv
, NULL
);
7032 sn
->date_sec
= tv
.tv_sec
;
7033 sn
->date_nsec
= tv
.tv_usec
* 1000;
7035 sn
->vm_clock_nsec
= qemu_get_clock(vm_clock
);
7037 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
7038 term_printf("Device %s does not support VM state snapshots\n",
7039 bdrv_get_device_name(bs
));
7043 /* save the VM state */
7044 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 1);
7046 term_printf("Could not open VM state file\n");
7049 ret
= qemu_savevm_state(f
);
7050 sn
->vm_state_size
= qemu_ftell(f
);
7053 term_printf("Error %d while writing VM\n", ret
);
7057 /* create the snapshots */
7059 for(i
= 0; i
< nb_drives
; i
++) {
7060 bs1
= drives_table
[i
].bdrv
;
7061 if (bdrv_has_snapshot(bs1
)) {
7063 ret
= bdrv_snapshot_delete(bs1
, old_sn
->id_str
);
7065 term_printf("Error while deleting snapshot on '%s'\n",
7066 bdrv_get_device_name(bs1
));
7069 ret
= bdrv_snapshot_create(bs1
, sn
);
7071 term_printf("Error while creating snapshot on '%s'\n",
7072 bdrv_get_device_name(bs1
));
7078 if (saved_vm_running
)
7082 void do_loadvm(const char *name
)
7084 BlockDriverState
*bs
, *bs1
;
7085 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
7088 int saved_vm_running
;
7090 bs
= get_bs_snapshots();
7092 term_printf("No block device supports snapshots\n");
7096 /* Flush all IO requests so they don't interfere with the new state. */
7099 saved_vm_running
= vm_running
;
7102 for(i
= 0; i
<= nb_drives
; i
++) {
7103 bs1
= drives_table
[i
].bdrv
;
7104 if (bdrv_has_snapshot(bs1
)) {
7105 ret
= bdrv_snapshot_goto(bs1
, name
);
7108 term_printf("Warning: ");
7111 term_printf("Snapshots not supported on device '%s'\n",
7112 bdrv_get_device_name(bs1
));
7115 term_printf("Could not find snapshot '%s' on device '%s'\n",
7116 name
, bdrv_get_device_name(bs1
));
7119 term_printf("Error %d while activating snapshot on '%s'\n",
7120 ret
, bdrv_get_device_name(bs1
));
7123 /* fatal on snapshot block device */
7130 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
7131 term_printf("Device %s does not support VM state snapshots\n",
7132 bdrv_get_device_name(bs
));
7136 /* restore the VM state */
7137 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 0);
7139 term_printf("Could not open VM state file\n");
7142 ret
= qemu_loadvm_state(f
);
7145 term_printf("Error %d while loading VM state\n", ret
);
7148 if (saved_vm_running
)
7152 void do_delvm(const char *name
)
7154 BlockDriverState
*bs
, *bs1
;
7157 bs
= get_bs_snapshots();
7159 term_printf("No block device supports snapshots\n");
7163 for(i
= 0; i
<= nb_drives
; i
++) {
7164 bs1
= drives_table
[i
].bdrv
;
7165 if (bdrv_has_snapshot(bs1
)) {
7166 ret
= bdrv_snapshot_delete(bs1
, name
);
7168 if (ret
== -ENOTSUP
)
7169 term_printf("Snapshots not supported on device '%s'\n",
7170 bdrv_get_device_name(bs1
));
7172 term_printf("Error %d while deleting snapshot on '%s'\n",
7173 ret
, bdrv_get_device_name(bs1
));
7179 void do_info_snapshots(void)
7181 BlockDriverState
*bs
, *bs1
;
7182 QEMUSnapshotInfo
*sn_tab
, *sn
;
7186 bs
= get_bs_snapshots();
7188 term_printf("No available block device supports snapshots\n");
7191 term_printf("Snapshot devices:");
7192 for(i
= 0; i
<= nb_drives
; i
++) {
7193 bs1
= drives_table
[i
].bdrv
;
7194 if (bdrv_has_snapshot(bs1
)) {
7196 term_printf(" %s", bdrv_get_device_name(bs1
));
7201 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
7203 term_printf("bdrv_snapshot_list: error %d\n", nb_sns
);
7206 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs
));
7207 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
7208 for(i
= 0; i
< nb_sns
; i
++) {
7210 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
7215 /***********************************************************/
7216 /* ram save/restore */
7218 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
7222 v
= qemu_get_byte(f
);
7225 if (qemu_get_buffer(f
, buf
, len
) != len
)
7229 v
= qemu_get_byte(f
);
7230 memset(buf
, v
, len
);
7238 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
7243 if (qemu_get_be32(f
) != phys_ram_size
)
7245 for(i
= 0; i
< phys_ram_size
; i
+= TARGET_PAGE_SIZE
) {
7246 ret
= ram_get_page(f
, phys_ram_base
+ i
, TARGET_PAGE_SIZE
);
7253 #define BDRV_HASH_BLOCK_SIZE 1024
7254 #define IOBUF_SIZE 4096
7255 #define RAM_CBLOCK_MAGIC 0xfabe
7257 typedef struct RamDecompressState
{
7260 uint8_t buf
[IOBUF_SIZE
];
7261 } RamDecompressState
;
7263 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
7266 memset(s
, 0, sizeof(*s
));
7268 ret
= inflateInit(&s
->zstream
);
7274 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
7278 s
->zstream
.avail_out
= len
;
7279 s
->zstream
.next_out
= buf
;
7280 while (s
->zstream
.avail_out
> 0) {
7281 if (s
->zstream
.avail_in
== 0) {
7282 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
7284 clen
= qemu_get_be16(s
->f
);
7285 if (clen
> IOBUF_SIZE
)
7287 qemu_get_buffer(s
->f
, s
->buf
, clen
);
7288 s
->zstream
.avail_in
= clen
;
7289 s
->zstream
.next_in
= s
->buf
;
7291 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
7292 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
7299 static void ram_decompress_close(RamDecompressState
*s
)
7301 inflateEnd(&s
->zstream
);
7304 #define RAM_SAVE_FLAG_FULL 0x01
7305 #define RAM_SAVE_FLAG_COMPRESS 0x02
7306 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
7307 #define RAM_SAVE_FLAG_PAGE 0x08
7308 #define RAM_SAVE_FLAG_EOS 0x10
7310 static int is_dup_page(uint8_t *page
, uint8_t ch
)
7312 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
7313 uint32_t *array
= (uint32_t *)page
;
7316 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
7317 if (array
[i
] != val
)
7324 static int ram_save_block(QEMUFile
*f
)
7326 static ram_addr_t current_addr
= 0;
7327 ram_addr_t saved_addr
= current_addr
;
7328 ram_addr_t addr
= 0;
7331 while (addr
< phys_ram_size
) {
7332 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
7335 cpu_physical_memory_reset_dirty(current_addr
,
7336 current_addr
+ TARGET_PAGE_SIZE
,
7337 MIGRATION_DIRTY_FLAG
);
7339 ch
= *(phys_ram_base
+ current_addr
);
7341 if (is_dup_page(phys_ram_base
+ current_addr
, ch
)) {
7342 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_COMPRESS
);
7343 qemu_put_byte(f
, ch
);
7345 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_PAGE
);
7346 qemu_put_buffer(f
, phys_ram_base
+ current_addr
, TARGET_PAGE_SIZE
);
7352 addr
+= TARGET_PAGE_SIZE
;
7353 current_addr
= (saved_addr
+ addr
) % phys_ram_size
;
7359 static ram_addr_t ram_save_threshold
= 10;
7361 static ram_addr_t
ram_save_remaining(void)
7364 ram_addr_t count
= 0;
7366 for (addr
= 0; addr
< phys_ram_size
; addr
+= TARGET_PAGE_SIZE
) {
7367 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
7374 static int ram_save_live(QEMUFile
*f
, int stage
, void *opaque
)
7379 /* Make sure all dirty bits are set */
7380 for (addr
= 0; addr
< phys_ram_size
; addr
+= TARGET_PAGE_SIZE
) {
7381 if (!cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
7382 cpu_physical_memory_set_dirty(addr
);
7385 /* Enable dirty memory tracking */
7386 cpu_physical_memory_set_dirty_tracking(1);
7388 qemu_put_be64(f
, phys_ram_size
| RAM_SAVE_FLAG_MEM_SIZE
);
7391 while (!qemu_file_rate_limit(f
)) {
7394 ret
= ram_save_block(f
);
7395 if (ret
== 0) /* no more blocks */
7399 /* try transferring iterative blocks of memory */
7402 cpu_physical_memory_set_dirty_tracking(0);
7404 /* flush all remaining blocks regardless of rate limiting */
7405 while (ram_save_block(f
) != 0);
7408 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
7410 return (stage
== 2) && (ram_save_remaining() < ram_save_threshold
);
7413 static int ram_load_dead(QEMUFile
*f
, void *opaque
)
7415 RamDecompressState s1
, *s
= &s1
;
7419 if (ram_decompress_open(s
, f
) < 0)
7421 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
7422 if (ram_decompress_buf(s
, buf
, 1) < 0) {
7423 fprintf(stderr
, "Error while reading ram block header\n");
7427 if (ram_decompress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
) < 0) {
7428 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
7433 printf("Error block header\n");
7437 ram_decompress_close(s
);
7442 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
7447 if (version_id
== 1)
7448 return ram_load_v1(f
, opaque
);
7450 if (version_id
== 2) {
7451 if (qemu_get_be32(f
) != phys_ram_size
)
7453 return ram_load_dead(f
, opaque
);
7456 if (version_id
!= 3)
7460 addr
= qemu_get_be64(f
);
7462 flags
= addr
& ~TARGET_PAGE_MASK
;
7463 addr
&= TARGET_PAGE_MASK
;
7465 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
7466 if (addr
!= phys_ram_size
)
7470 if (flags
& RAM_SAVE_FLAG_FULL
) {
7471 if (ram_load_dead(f
, opaque
) < 0)
7475 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
7476 uint8_t ch
= qemu_get_byte(f
);
7477 memset(phys_ram_base
+ addr
, ch
, TARGET_PAGE_SIZE
);
7478 } else if (flags
& RAM_SAVE_FLAG_PAGE
)
7479 qemu_get_buffer(f
, phys_ram_base
+ addr
, TARGET_PAGE_SIZE
);
7480 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
7485 /***********************************************************/
7486 /* bottom halves (can be seen as timers which expire ASAP) */
7495 static QEMUBH
*first_bh
= NULL
;
7497 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
7500 bh
= qemu_mallocz(sizeof(QEMUBH
));
7504 bh
->opaque
= opaque
;
7508 int qemu_bh_poll(void)
7527 void qemu_bh_schedule(QEMUBH
*bh
)
7529 CPUState
*env
= cpu_single_env
;
7533 bh
->next
= first_bh
;
7536 /* stop the currently executing CPU to execute the BH ASAP */
7538 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
7542 void qemu_bh_cancel(QEMUBH
*bh
)
7545 if (bh
->scheduled
) {
7548 pbh
= &(*pbh
)->next
;
7554 void qemu_bh_delete(QEMUBH
*bh
)
7560 /***********************************************************/
7561 /* machine registration */
7563 static QEMUMachine
*first_machine
= NULL
;
7565 int qemu_register_machine(QEMUMachine
*m
)
7568 pm
= &first_machine
;
7576 static QEMUMachine
*find_machine(const char *name
)
7580 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
7581 if (!strcmp(m
->name
, name
))
7587 /***********************************************************/
7588 /* main execution loop */
7590 static void gui_update(void *opaque
)
7592 DisplayState
*ds
= opaque
;
7593 ds
->dpy_refresh(ds
);
7594 qemu_mod_timer(ds
->gui_timer
,
7595 (ds
->gui_timer_interval
?
7596 ds
->gui_timer_interval
:
7597 GUI_REFRESH_INTERVAL
)
7598 + qemu_get_clock(rt_clock
));
7601 struct vm_change_state_entry
{
7602 VMChangeStateHandler
*cb
;
7604 LIST_ENTRY (vm_change_state_entry
) entries
;
7607 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
7609 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
7612 VMChangeStateEntry
*e
;
7614 e
= qemu_mallocz(sizeof (*e
));
7620 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
7624 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
7626 LIST_REMOVE (e
, entries
);
7630 static void vm_state_notify(int running
)
7632 VMChangeStateEntry
*e
;
7634 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
7635 e
->cb(e
->opaque
, running
);
7639 /* XXX: support several handlers */
7640 static VMStopHandler
*vm_stop_cb
;
7641 static void *vm_stop_opaque
;
7643 int qemu_add_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
7646 vm_stop_opaque
= opaque
;
7650 void qemu_del_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
7661 qemu_rearm_alarm_timer(alarm_timer
);
7665 void vm_stop(int reason
)
7668 cpu_disable_ticks();
7672 vm_stop_cb(vm_stop_opaque
, reason
);
7679 /* reset/shutdown handler */
7681 typedef struct QEMUResetEntry
{
7682 QEMUResetHandler
*func
;
7684 struct QEMUResetEntry
*next
;
7687 static QEMUResetEntry
*first_reset_entry
;
7688 static int reset_requested
;
7689 static int shutdown_requested
;
7690 static int powerdown_requested
;
7692 int qemu_shutdown_requested(void)
7694 int r
= shutdown_requested
;
7695 shutdown_requested
= 0;
7699 int qemu_reset_requested(void)
7701 int r
= reset_requested
;
7702 reset_requested
= 0;
7706 int qemu_powerdown_requested(void)
7708 int r
= powerdown_requested
;
7709 powerdown_requested
= 0;
7713 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
7715 QEMUResetEntry
**pre
, *re
;
7717 pre
= &first_reset_entry
;
7718 while (*pre
!= NULL
)
7719 pre
= &(*pre
)->next
;
7720 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
7722 re
->opaque
= opaque
;
7727 void qemu_system_reset(void)
7731 /* reset all devices */
7732 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
7733 re
->func(re
->opaque
);
7737 void qemu_system_reset_request(void)
7740 shutdown_requested
= 1;
7742 reset_requested
= 1;
7745 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7748 void qemu_system_shutdown_request(void)
7750 shutdown_requested
= 1;
7752 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7755 void qemu_system_powerdown_request(void)
7757 powerdown_requested
= 1;
7759 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7762 void main_loop_wait(int timeout
)
7764 IOHandlerRecord
*ioh
;
7765 fd_set rfds
, wfds
, xfds
;
7774 /* XXX: need to suppress polling by better using win32 events */
7776 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
7777 ret
|= pe
->func(pe
->opaque
);
7782 WaitObjects
*w
= &wait_objects
;
7784 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, timeout
);
7785 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
7786 if (w
->func
[ret
- WAIT_OBJECT_0
])
7787 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
7789 /* Check for additional signaled events */
7790 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
7792 /* Check if event is signaled */
7793 ret2
= WaitForSingleObject(w
->events
[i
], 0);
7794 if(ret2
== WAIT_OBJECT_0
) {
7796 w
->func
[i
](w
->opaque
[i
]);
7797 } else if (ret2
== WAIT_TIMEOUT
) {
7799 err
= GetLastError();
7800 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
7803 } else if (ret
== WAIT_TIMEOUT
) {
7805 err
= GetLastError();
7806 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
7810 /* poll any events */
7811 /* XXX: separate device handlers from system ones */
7816 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7820 (!ioh
->fd_read_poll
||
7821 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
7822 FD_SET(ioh
->fd
, &rfds
);
7826 if (ioh
->fd_write
) {
7827 FD_SET(ioh
->fd
, &wfds
);
7837 tv
.tv_usec
= timeout
* 1000;
7839 #if defined(CONFIG_SLIRP)
7841 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
7844 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
7846 IOHandlerRecord
**pioh
;
7848 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7849 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
7850 ioh
->fd_read(ioh
->opaque
);
7852 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
7853 ioh
->fd_write(ioh
->opaque
);
7857 /* remove deleted IO handlers */
7858 pioh
= &first_io_handler
;
7868 #if defined(CONFIG_SLIRP)
7875 slirp_select_poll(&rfds
, &wfds
, &xfds
);
7880 if (likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
7881 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
7882 qemu_get_clock(vm_clock
));
7883 /* run dma transfers, if any */
7887 /* real time timers */
7888 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
7889 qemu_get_clock(rt_clock
));
7891 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
7892 alarm_timer
->flags
&= ~(ALARM_FLAG_EXPIRED
);
7893 qemu_rearm_alarm_timer(alarm_timer
);
7896 /* Check bottom-halves last in case any of the earlier events triggered
7902 static int main_loop(void)
7905 #ifdef CONFIG_PROFILER
7910 cur_cpu
= first_cpu
;
7911 next_cpu
= cur_cpu
->next_cpu
?: first_cpu
;
7918 #ifdef CONFIG_PROFILER
7919 ti
= profile_getclock();
7924 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
7925 env
->icount_decr
.u16
.low
= 0;
7926 env
->icount_extra
= 0;
7927 count
= qemu_next_deadline();
7928 count
= (count
+ (1 << icount_time_shift
) - 1)
7929 >> icount_time_shift
;
7930 qemu_icount
+= count
;
7931 decr
= (count
> 0xffff) ? 0xffff : count
;
7933 env
->icount_decr
.u16
.low
= decr
;
7934 env
->icount_extra
= count
;
7936 ret
= cpu_exec(env
);
7937 #ifdef CONFIG_PROFILER
7938 qemu_time
+= profile_getclock() - ti
;
7941 /* Fold pending instructions back into the
7942 instruction counter, and clear the interrupt flag. */
7943 qemu_icount
-= (env
->icount_decr
.u16
.low
7944 + env
->icount_extra
);
7945 env
->icount_decr
.u32
= 0;
7946 env
->icount_extra
= 0;
7948 next_cpu
= env
->next_cpu
?: first_cpu
;
7949 if (event_pending
&& likely(ret
!= EXCP_DEBUG
)) {
7950 ret
= EXCP_INTERRUPT
;
7954 if (ret
== EXCP_HLT
) {
7955 /* Give the next CPU a chance to run. */
7959 if (ret
!= EXCP_HALTED
)
7961 /* all CPUs are halted ? */
7967 if (shutdown_requested
) {
7968 ret
= EXCP_INTERRUPT
;
7976 if (reset_requested
) {
7977 reset_requested
= 0;
7978 qemu_system_reset();
7979 ret
= EXCP_INTERRUPT
;
7981 if (powerdown_requested
) {
7982 powerdown_requested
= 0;
7983 qemu_system_powerdown();
7984 ret
= EXCP_INTERRUPT
;
7986 if (unlikely(ret
== EXCP_DEBUG
)) {
7987 vm_stop(EXCP_DEBUG
);
7989 /* If all cpus are halted then wait until the next IRQ */
7990 /* XXX: use timeout computed from timers */
7991 if (ret
== EXCP_HALTED
) {
7995 /* Advance virtual time to the next event. */
7996 if (use_icount
== 1) {
7997 /* When not using an adaptive execution frequency
7998 we tend to get badly out of sync with real time,
7999 so just delay for a reasonable amount of time. */
8002 delta
= cpu_get_icount() - cpu_get_clock();
8005 /* If virtual time is ahead of real time then just
8007 timeout
= (delta
/ 1000000) + 1;
8009 /* Wait for either IO to occur or the next
8011 add
= qemu_next_deadline();
8012 /* We advance the timer before checking for IO.
8013 Limit the amount we advance so that early IO
8014 activity won't get the guest too far ahead. */
8018 add
= (add
+ (1 << icount_time_shift
) - 1)
8019 >> icount_time_shift
;
8021 timeout
= delta
/ 1000000;
8032 if (shutdown_requested
) {
8033 ret
= EXCP_INTERRUPT
;
8038 #ifdef CONFIG_PROFILER
8039 ti
= profile_getclock();
8041 main_loop_wait(timeout
);
8042 #ifdef CONFIG_PROFILER
8043 dev_time
+= profile_getclock() - ti
;
8046 cpu_disable_ticks();
8050 static void help(int exitcode
)
8052 printf("QEMU PC emulator version " QEMU_VERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n"
8053 "usage: %s [options] [disk_image]\n"
8055 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
8057 "Standard options:\n"
8058 "-M machine select emulated machine (-M ? for list)\n"
8059 "-cpu cpu select CPU (-cpu ? for list)\n"
8060 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
8061 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
8062 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
8063 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
8064 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
8065 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
8066 " [,cache=on|off][,format=f]\n"
8067 " use 'file' as a drive image\n"
8068 "-mtdblock file use 'file' as on-board Flash memory image\n"
8069 "-sd file use 'file' as SecureDigital card image\n"
8070 "-pflash file use 'file' as a parallel flash image\n"
8071 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
8072 "-snapshot write to temporary files instead of disk image files\n"
8074 "-no-frame open SDL window without a frame and window decorations\n"
8075 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
8076 "-no-quit disable SDL window close capability\n"
8079 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
8081 "-m megs set virtual RAM size to megs MB [default=%d]\n"
8082 "-smp n set the number of CPUs to 'n' [default=1]\n"
8083 "-nographic disable graphical output and redirect serial I/Os to console\n"
8084 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
8086 "-k language use keyboard layout (for example \"fr\" for French)\n"
8089 "-audio-help print list of audio drivers and their options\n"
8090 "-soundhw c1,... enable audio support\n"
8091 " and only specified sound cards (comma separated list)\n"
8092 " use -soundhw ? to get the list of supported cards\n"
8093 " use -soundhw all to enable all of them\n"
8095 "-vga [std|cirrus|vmware]\n"
8096 " select video card type\n"
8097 "-localtime set the real time clock to local time [default=utc]\n"
8098 "-full-screen start in full screen\n"
8100 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
8102 "-usb enable the USB driver (will be the default soon)\n"
8103 "-usbdevice name add the host or guest USB device 'name'\n"
8104 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8105 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
8107 "-name string set the name of the guest\n"
8108 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
8110 "Network options:\n"
8111 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
8112 " create a new Network Interface Card and connect it to VLAN 'n'\n"
8114 "-net user[,vlan=n][,hostname=host]\n"
8115 " connect the user mode network stack to VLAN 'n' and send\n"
8116 " hostname 'host' to DHCP clients\n"
8119 "-net tap[,vlan=n],ifname=name\n"
8120 " connect the host TAP network interface to VLAN 'n'\n"
8122 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
8123 " connect the host TAP network interface to VLAN 'n' and use the\n"
8124 " network scripts 'file' (default=%s)\n"
8125 " and 'dfile' (default=%s);\n"
8126 " use '[down]script=no' to disable script execution;\n"
8127 " use 'fd=h' to connect to an already opened TAP interface\n"
8129 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
8130 " connect the vlan 'n' to another VLAN using a socket connection\n"
8131 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
8132 " connect the vlan 'n' to multicast maddr and port\n"
8134 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
8135 " connect the vlan 'n' to port 'n' of a vde switch running\n"
8136 " on host and listening for incoming connections on 'socketpath'.\n"
8137 " Use group 'groupname' and mode 'octalmode' to change default\n"
8138 " ownership and permissions for communication port.\n"
8140 "-net none use it alone to have zero network devices; if no -net option\n"
8141 " is provided, the default is '-net nic -net user'\n"
8144 "-tftp dir allow tftp access to files in dir [-net user]\n"
8145 "-bootp file advertise file in BOOTP replies\n"
8147 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
8149 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
8150 " redirect TCP or UDP connections from host to guest [-net user]\n"
8153 "Linux boot specific:\n"
8154 "-kernel bzImage use 'bzImage' as kernel image\n"
8155 "-append cmdline use 'cmdline' as kernel command line\n"
8156 "-initrd file use 'file' as initial ram disk\n"
8158 "Debug/Expert options:\n"
8159 "-monitor dev redirect the monitor to char device 'dev'\n"
8160 "-serial dev redirect the serial port to char device 'dev'\n"
8161 "-parallel dev redirect the parallel port to char device 'dev'\n"
8162 "-pidfile file Write PID to 'file'\n"
8163 "-S freeze CPU at startup (use 'c' to start execution)\n"
8164 "-s wait gdb connection to port\n"
8165 "-p port set gdb connection port [default=%s]\n"
8166 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
8167 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
8168 " translation (t=none or lba) (usually qemu can guess them)\n"
8169 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
8171 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
8172 "-no-kqemu disable KQEMU kernel module usage\n"
8175 "-no-acpi disable ACPI\n"
8177 #ifdef CONFIG_CURSES
8178 "-curses use a curses/ncurses interface instead of SDL\n"
8180 "-no-reboot exit instead of rebooting\n"
8181 "-no-shutdown stop before shutdown\n"
8182 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
8183 "-vnc display start a VNC server on display\n"
8185 "-daemonize daemonize QEMU after initializing\n"
8187 "-option-rom rom load a file, rom, into the option ROM space\n"
8189 "-prom-env variable=value set OpenBIOS nvram variables\n"
8191 "-clock force the use of the given methods for timer alarm.\n"
8192 " To see what timers are available use -clock ?\n"
8193 "-startdate select initial date of the clock\n"
8194 "-icount [N|auto]\n"
8195 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
8197 "During emulation, the following keys are useful:\n"
8198 "ctrl-alt-f toggle full screen\n"
8199 "ctrl-alt-n switch to virtual console 'n'\n"
8200 "ctrl-alt toggle mouse and keyboard grab\n"
8202 "When using -nographic, press 'ctrl-a h' to get some help.\n"
8207 DEFAULT_NETWORK_SCRIPT
,
8208 DEFAULT_NETWORK_DOWN_SCRIPT
,
8210 DEFAULT_GDBSTUB_PORT
,
8215 #define HAS_ARG 0x0001
8230 QEMU_OPTION_mtdblock
,
8234 QEMU_OPTION_snapshot
,
8236 QEMU_OPTION_no_fd_bootchk
,
8239 QEMU_OPTION_nographic
,
8240 QEMU_OPTION_portrait
,
8242 QEMU_OPTION_audio_help
,
8243 QEMU_OPTION_soundhw
,
8264 QEMU_OPTION_localtime
,
8268 QEMU_OPTION_monitor
,
8270 QEMU_OPTION_parallel
,
8272 QEMU_OPTION_full_screen
,
8273 QEMU_OPTION_no_frame
,
8274 QEMU_OPTION_alt_grab
,
8275 QEMU_OPTION_no_quit
,
8276 QEMU_OPTION_pidfile
,
8277 QEMU_OPTION_no_kqemu
,
8278 QEMU_OPTION_kernel_kqemu
,
8279 QEMU_OPTION_win2k_hack
,
8281 QEMU_OPTION_usbdevice
,
8284 QEMU_OPTION_no_acpi
,
8286 QEMU_OPTION_no_reboot
,
8287 QEMU_OPTION_no_shutdown
,
8288 QEMU_OPTION_show_cursor
,
8289 QEMU_OPTION_daemonize
,
8290 QEMU_OPTION_option_rom
,
8291 QEMU_OPTION_semihosting
,
8293 QEMU_OPTION_prom_env
,
8294 QEMU_OPTION_old_param
,
8296 QEMU_OPTION_startdate
,
8297 QEMU_OPTION_tb_size
,
8302 typedef struct QEMUOption
{
8308 static const QEMUOption qemu_options
[] = {
8309 { "h", 0, QEMU_OPTION_h
},
8310 { "help", 0, QEMU_OPTION_h
},
8312 { "M", HAS_ARG
, QEMU_OPTION_M
},
8313 { "cpu", HAS_ARG
, QEMU_OPTION_cpu
},
8314 { "fda", HAS_ARG
, QEMU_OPTION_fda
},
8315 { "fdb", HAS_ARG
, QEMU_OPTION_fdb
},
8316 { "hda", HAS_ARG
, QEMU_OPTION_hda
},
8317 { "hdb", HAS_ARG
, QEMU_OPTION_hdb
},
8318 { "hdc", HAS_ARG
, QEMU_OPTION_hdc
},
8319 { "hdd", HAS_ARG
, QEMU_OPTION_hdd
},
8320 { "drive", HAS_ARG
, QEMU_OPTION_drive
},
8321 { "cdrom", HAS_ARG
, QEMU_OPTION_cdrom
},
8322 { "mtdblock", HAS_ARG
, QEMU_OPTION_mtdblock
},
8323 { "sd", HAS_ARG
, QEMU_OPTION_sd
},
8324 { "pflash", HAS_ARG
, QEMU_OPTION_pflash
},
8325 { "boot", HAS_ARG
, QEMU_OPTION_boot
},
8326 { "snapshot", 0, QEMU_OPTION_snapshot
},
8328 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk
},
8330 { "m", HAS_ARG
, QEMU_OPTION_m
},
8331 { "nographic", 0, QEMU_OPTION_nographic
},
8332 { "portrait", 0, QEMU_OPTION_portrait
},
8333 { "k", HAS_ARG
, QEMU_OPTION_k
},
8335 { "audio-help", 0, QEMU_OPTION_audio_help
},
8336 { "soundhw", HAS_ARG
, QEMU_OPTION_soundhw
},
8339 { "net", HAS_ARG
, QEMU_OPTION_net
},
8341 { "tftp", HAS_ARG
, QEMU_OPTION_tftp
},
8342 { "bootp", HAS_ARG
, QEMU_OPTION_bootp
},
8344 { "smb", HAS_ARG
, QEMU_OPTION_smb
},
8346 { "redir", HAS_ARG
, QEMU_OPTION_redir
},
8349 { "kernel", HAS_ARG
, QEMU_OPTION_kernel
},
8350 { "append", HAS_ARG
, QEMU_OPTION_append
},
8351 { "initrd", HAS_ARG
, QEMU_OPTION_initrd
},
8353 { "S", 0, QEMU_OPTION_S
},
8354 { "s", 0, QEMU_OPTION_s
},
8355 { "p", HAS_ARG
, QEMU_OPTION_p
},
8356 { "d", HAS_ARG
, QEMU_OPTION_d
},
8357 { "hdachs", HAS_ARG
, QEMU_OPTION_hdachs
},
8358 { "L", HAS_ARG
, QEMU_OPTION_L
},
8359 { "bios", HAS_ARG
, QEMU_OPTION_bios
},
8361 { "no-kqemu", 0, QEMU_OPTION_no_kqemu
},
8362 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu
},
8364 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8365 { "g", 1, QEMU_OPTION_g
},
8367 { "localtime", 0, QEMU_OPTION_localtime
},
8368 { "vga", HAS_ARG
, QEMU_OPTION_vga
},
8369 { "echr", HAS_ARG
, QEMU_OPTION_echr
},
8370 { "monitor", HAS_ARG
, QEMU_OPTION_monitor
},
8371 { "serial", HAS_ARG
, QEMU_OPTION_serial
},
8372 { "parallel", HAS_ARG
, QEMU_OPTION_parallel
},
8373 { "loadvm", HAS_ARG
, QEMU_OPTION_loadvm
},
8374 { "full-screen", 0, QEMU_OPTION_full_screen
},
8376 { "no-frame", 0, QEMU_OPTION_no_frame
},
8377 { "alt-grab", 0, QEMU_OPTION_alt_grab
},
8378 { "no-quit", 0, QEMU_OPTION_no_quit
},
8380 { "pidfile", HAS_ARG
, QEMU_OPTION_pidfile
},
8381 { "win2k-hack", 0, QEMU_OPTION_win2k_hack
},
8382 { "usbdevice", HAS_ARG
, QEMU_OPTION_usbdevice
},
8383 { "smp", HAS_ARG
, QEMU_OPTION_smp
},
8384 { "vnc", HAS_ARG
, QEMU_OPTION_vnc
},
8385 #ifdef CONFIG_CURSES
8386 { "curses", 0, QEMU_OPTION_curses
},
8388 { "uuid", HAS_ARG
, QEMU_OPTION_uuid
},
8390 /* temporary options */
8391 { "usb", 0, QEMU_OPTION_usb
},
8392 { "no-acpi", 0, QEMU_OPTION_no_acpi
},
8393 { "no-reboot", 0, QEMU_OPTION_no_reboot
},
8394 { "no-shutdown", 0, QEMU_OPTION_no_shutdown
},
8395 { "show-cursor", 0, QEMU_OPTION_show_cursor
},
8396 { "daemonize", 0, QEMU_OPTION_daemonize
},
8397 { "option-rom", HAS_ARG
, QEMU_OPTION_option_rom
},
8398 #if defined(TARGET_ARM) || defined(TARGET_M68K)
8399 { "semihosting", 0, QEMU_OPTION_semihosting
},
8401 { "name", HAS_ARG
, QEMU_OPTION_name
},
8402 #if defined(TARGET_SPARC)
8403 { "prom-env", HAS_ARG
, QEMU_OPTION_prom_env
},
8405 #if defined(TARGET_ARM)
8406 { "old-param", 0, QEMU_OPTION_old_param
},
8408 { "clock", HAS_ARG
, QEMU_OPTION_clock
},
8409 { "startdate", HAS_ARG
, QEMU_OPTION_startdate
},
8410 { "tb-size", HAS_ARG
, QEMU_OPTION_tb_size
},
8411 { "icount", HAS_ARG
, QEMU_OPTION_icount
},
8415 /* password input */
8417 int qemu_key_check(BlockDriverState
*bs
, const char *name
)
8422 if (!bdrv_is_encrypted(bs
))
8425 term_printf("%s is encrypted.\n", name
);
8426 for(i
= 0; i
< 3; i
++) {
8427 monitor_readline("Password: ", 1, password
, sizeof(password
));
8428 if (bdrv_set_key(bs
, password
) == 0)
8430 term_printf("invalid password\n");
8435 static BlockDriverState
*get_bdrv(int index
)
8437 if (index
> nb_drives
)
8439 return drives_table
[index
].bdrv
;
8442 static void read_passwords(void)
8444 BlockDriverState
*bs
;
8447 for(i
= 0; i
< 6; i
++) {
8450 qemu_key_check(bs
, bdrv_get_device_name(bs
));
8455 struct soundhw soundhw
[] = {
8456 #ifdef HAS_AUDIO_CHOICE
8457 #if defined(TARGET_I386) || defined(TARGET_MIPS)
8463 { .init_isa
= pcspk_audio_init
}
8468 "Creative Sound Blaster 16",
8471 { .init_isa
= SB16_init
}
8474 #ifdef CONFIG_CS4231A
8480 { .init_isa
= cs4231a_init
}
8488 "Yamaha YMF262 (OPL3)",
8490 "Yamaha YM3812 (OPL2)",
8494 { .init_isa
= Adlib_init
}
8501 "Gravis Ultrasound GF1",
8504 { .init_isa
= GUS_init
}
8511 "Intel 82801AA AC97 Audio",
8514 { .init_pci
= ac97_init
}
8520 "ENSONIQ AudioPCI ES1370",
8523 { .init_pci
= es1370_init
}
8527 { NULL
, NULL
, 0, 0, { NULL
} }
8530 static void select_soundhw (const char *optarg
)
8534 if (*optarg
== '?') {
8537 printf ("Valid sound card names (comma separated):\n");
8538 for (c
= soundhw
; c
->name
; ++c
) {
8539 printf ("%-11s %s\n", c
->name
, c
->descr
);
8541 printf ("\n-soundhw all will enable all of the above\n");
8542 exit (*optarg
!= '?');
8550 if (!strcmp (optarg
, "all")) {
8551 for (c
= soundhw
; c
->name
; ++c
) {
8559 e
= strchr (p
, ',');
8560 l
= !e
? strlen (p
) : (size_t) (e
- p
);
8562 for (c
= soundhw
; c
->name
; ++c
) {
8563 if (!strncmp (c
->name
, p
, l
)) {
8572 "Unknown sound card name (too big to show)\n");
8575 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
8580 p
+= l
+ (e
!= NULL
);
8584 goto show_valid_cards
;
8589 static void select_vgahw (const char *p
)
8593 if (strstart(p
, "std", &opts
)) {
8594 cirrus_vga_enabled
= 0;
8596 } else if (strstart(p
, "cirrus", &opts
)) {
8597 cirrus_vga_enabled
= 1;
8599 } else if (strstart(p
, "vmware", &opts
)) {
8600 cirrus_vga_enabled
= 0;
8604 fprintf(stderr
, "Unknown vga type: %s\n", p
);
8608 const char *nextopt
;
8610 if (strstart(opts
, ",retrace=", &nextopt
)) {
8612 if (strstart(opts
, "dumb", &nextopt
))
8613 vga_retrace_method
= VGA_RETRACE_DUMB
;
8614 else if (strstart(opts
, "precise", &nextopt
))
8615 vga_retrace_method
= VGA_RETRACE_PRECISE
;
8616 else goto invalid_vga
;
8617 } else goto invalid_vga
;
8623 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
8625 exit(STATUS_CONTROL_C_EXIT
);
8630 static int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
8634 if(strlen(str
) != 36)
8637 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
8638 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
8639 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
8647 #define MAX_NET_CLIENTS 32
8651 static void termsig_handler(int signal
)
8653 qemu_system_shutdown_request();
8656 static void termsig_setup(void)
8658 struct sigaction act
;
8660 memset(&act
, 0, sizeof(act
));
8661 act
.sa_handler
= termsig_handler
;
8662 sigaction(SIGINT
, &act
, NULL
);
8663 sigaction(SIGHUP
, &act
, NULL
);
8664 sigaction(SIGTERM
, &act
, NULL
);
8669 int main(int argc
, char **argv
)
8671 #ifdef CONFIG_GDBSTUB
8673 const char *gdbstub_port
;
8675 uint32_t boot_devices_bitmap
= 0;
8677 int snapshot
, linux_boot
, net_boot
;
8678 const char *initrd_filename
;
8679 const char *kernel_filename
, *kernel_cmdline
;
8680 const char *boot_devices
= "";
8681 DisplayState
*ds
= &display_state
;
8682 int cyls
, heads
, secs
, translation
;
8683 const char *net_clients
[MAX_NET_CLIENTS
];
8687 const char *r
, *optarg
;
8688 CharDriverState
*monitor_hd
;
8689 const char *monitor_device
;
8690 const char *serial_devices
[MAX_SERIAL_PORTS
];
8691 int serial_device_index
;
8692 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
8693 int parallel_device_index
;
8694 const char *loadvm
= NULL
;
8695 QEMUMachine
*machine
;
8696 const char *cpu_model
;
8697 const char *usb_devices
[MAX_USB_CMDLINE
];
8698 int usb_devices_index
;
8701 const char *pid_file
= NULL
;
8705 LIST_INIT (&vm_change_state_head
);
8708 struct sigaction act
;
8709 sigfillset(&act
.sa_mask
);
8711 act
.sa_handler
= SIG_IGN
;
8712 sigaction(SIGPIPE
, &act
, NULL
);
8715 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
8716 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8717 QEMU to run on a single CPU */
8722 h
= GetCurrentProcess();
8723 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
8724 for(i
= 0; i
< 32; i
++) {
8725 if (mask
& (1 << i
))
8730 SetProcessAffinityMask(h
, mask
);
8736 register_machines();
8737 machine
= first_machine
;
8739 initrd_filename
= NULL
;
8741 vga_ram_size
= VGA_RAM_SIZE
;
8742 #ifdef CONFIG_GDBSTUB
8744 gdbstub_port
= DEFAULT_GDBSTUB_PORT
;
8749 kernel_filename
= NULL
;
8750 kernel_cmdline
= "";
8751 cyls
= heads
= secs
= 0;
8752 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8753 monitor_device
= "vc";
8755 serial_devices
[0] = "vc:80Cx24C";
8756 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
8757 serial_devices
[i
] = NULL
;
8758 serial_device_index
= 0;
8760 parallel_devices
[0] = "vc:640x480";
8761 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
8762 parallel_devices
[i
] = NULL
;
8763 parallel_device_index
= 0;
8765 usb_devices_index
= 0;
8783 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
8785 const QEMUOption
*popt
;
8788 /* Treat --foo the same as -foo. */
8791 popt
= qemu_options
;
8794 fprintf(stderr
, "%s: invalid option -- '%s'\n",
8798 if (!strcmp(popt
->name
, r
+ 1))
8802 if (popt
->flags
& HAS_ARG
) {
8803 if (optind
>= argc
) {
8804 fprintf(stderr
, "%s: option '%s' requires an argument\n",
8808 optarg
= argv
[optind
++];
8813 switch(popt
->index
) {
8815 machine
= find_machine(optarg
);
8818 printf("Supported machines are:\n");
8819 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
8820 printf("%-10s %s%s\n",
8822 m
== first_machine
? " (default)" : "");
8824 exit(*optarg
!= '?');
8827 case QEMU_OPTION_cpu
:
8828 /* hw initialization will check this */
8829 if (*optarg
== '?') {
8830 /* XXX: implement xxx_cpu_list for targets that still miss it */
8831 #if defined(cpu_list)
8832 cpu_list(stdout
, &fprintf
);
8839 case QEMU_OPTION_initrd
:
8840 initrd_filename
= optarg
;
8842 case QEMU_OPTION_hda
:
8844 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
8846 hda_index
= drive_add(optarg
, HD_ALIAS
8847 ",cyls=%d,heads=%d,secs=%d%s",
8848 0, cyls
, heads
, secs
,
8849 translation
== BIOS_ATA_TRANSLATION_LBA
?
8851 translation
== BIOS_ATA_TRANSLATION_NONE
?
8852 ",trans=none" : "");
8854 case QEMU_OPTION_hdb
:
8855 case QEMU_OPTION_hdc
:
8856 case QEMU_OPTION_hdd
:
8857 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
8859 case QEMU_OPTION_drive
:
8860 drive_add(NULL
, "%s", optarg
);
8862 case QEMU_OPTION_mtdblock
:
8863 drive_add(optarg
, MTD_ALIAS
);
8865 case QEMU_OPTION_sd
:
8866 drive_add(optarg
, SD_ALIAS
);
8868 case QEMU_OPTION_pflash
:
8869 drive_add(optarg
, PFLASH_ALIAS
);
8871 case QEMU_OPTION_snapshot
:
8874 case QEMU_OPTION_hdachs
:
8878 cyls
= strtol(p
, (char **)&p
, 0);
8879 if (cyls
< 1 || cyls
> 16383)
8884 heads
= strtol(p
, (char **)&p
, 0);
8885 if (heads
< 1 || heads
> 16)
8890 secs
= strtol(p
, (char **)&p
, 0);
8891 if (secs
< 1 || secs
> 63)
8895 if (!strcmp(p
, "none"))
8896 translation
= BIOS_ATA_TRANSLATION_NONE
;
8897 else if (!strcmp(p
, "lba"))
8898 translation
= BIOS_ATA_TRANSLATION_LBA
;
8899 else if (!strcmp(p
, "auto"))
8900 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8903 } else if (*p
!= '\0') {
8905 fprintf(stderr
, "qemu: invalid physical CHS format\n");
8908 if (hda_index
!= -1)
8909 snprintf(drives_opt
[hda_index
].opt
,
8910 sizeof(drives_opt
[hda_index
].opt
),
8911 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
8912 0, cyls
, heads
, secs
,
8913 translation
== BIOS_ATA_TRANSLATION_LBA
?
8915 translation
== BIOS_ATA_TRANSLATION_NONE
?
8916 ",trans=none" : "");
8919 case QEMU_OPTION_nographic
:
8922 #ifdef CONFIG_CURSES
8923 case QEMU_OPTION_curses
:
8927 case QEMU_OPTION_portrait
:
8930 case QEMU_OPTION_kernel
:
8931 kernel_filename
= optarg
;
8933 case QEMU_OPTION_append
:
8934 kernel_cmdline
= optarg
;
8936 case QEMU_OPTION_cdrom
:
8937 drive_add(optarg
, CDROM_ALIAS
);
8939 case QEMU_OPTION_boot
:
8940 boot_devices
= optarg
;
8941 /* We just do some generic consistency checks */
8943 /* Could easily be extended to 64 devices if needed */
8946 boot_devices_bitmap
= 0;
8947 for (p
= boot_devices
; *p
!= '\0'; p
++) {
8948 /* Allowed boot devices are:
8949 * a b : floppy disk drives
8950 * c ... f : IDE disk drives
8951 * g ... m : machine implementation dependant drives
8952 * n ... p : network devices
8953 * It's up to each machine implementation to check
8954 * if the given boot devices match the actual hardware
8955 * implementation and firmware features.
8957 if (*p
< 'a' || *p
> 'q') {
8958 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
8961 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
8963 "Boot device '%c' was given twice\n",*p
);
8966 boot_devices_bitmap
|= 1 << (*p
- 'a');
8970 case QEMU_OPTION_fda
:
8971 case QEMU_OPTION_fdb
:
8972 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
8975 case QEMU_OPTION_no_fd_bootchk
:
8979 case QEMU_OPTION_net
:
8980 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
8981 fprintf(stderr
, "qemu: too many network clients\n");
8984 net_clients
[nb_net_clients
] = optarg
;
8988 case QEMU_OPTION_tftp
:
8989 tftp_prefix
= optarg
;
8991 case QEMU_OPTION_bootp
:
8992 bootp_filename
= optarg
;
8995 case QEMU_OPTION_smb
:
8996 net_slirp_smb(optarg
);
8999 case QEMU_OPTION_redir
:
9000 net_slirp_redir(optarg
);
9004 case QEMU_OPTION_audio_help
:
9008 case QEMU_OPTION_soundhw
:
9009 select_soundhw (optarg
);
9015 case QEMU_OPTION_m
: {
9019 value
= strtoul(optarg
, &ptr
, 10);
9021 case 0: case 'M': case 'm':
9028 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
9032 /* On 32-bit hosts, QEMU is limited by virtual address space */
9033 if (value
> (2047 << 20)
9035 && HOST_LONG_BITS
== 32
9038 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
9041 if (value
!= (uint64_t)(ram_addr_t
)value
) {
9042 fprintf(stderr
, "qemu: ram size too large\n");
9051 const CPULogItem
*item
;
9053 mask
= cpu_str_to_log_mask(optarg
);
9055 printf("Log items (comma separated):\n");
9056 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
9057 printf("%-10s %s\n", item
->name
, item
->help
);
9064 #ifdef CONFIG_GDBSTUB
9069 gdbstub_port
= optarg
;
9075 case QEMU_OPTION_bios
:
9082 keyboard_layout
= optarg
;
9084 case QEMU_OPTION_localtime
:
9087 case QEMU_OPTION_vga
:
9088 select_vgahw (optarg
);
9095 w
= strtol(p
, (char **)&p
, 10);
9098 fprintf(stderr
, "qemu: invalid resolution or depth\n");
9104 h
= strtol(p
, (char **)&p
, 10);
9109 depth
= strtol(p
, (char **)&p
, 10);
9110 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
9111 depth
!= 24 && depth
!= 32)
9113 } else if (*p
== '\0') {
9114 depth
= graphic_depth
;
9121 graphic_depth
= depth
;
9124 case QEMU_OPTION_echr
:
9127 term_escape_char
= strtol(optarg
, &r
, 0);
9129 printf("Bad argument to echr\n");
9132 case QEMU_OPTION_monitor
:
9133 monitor_device
= optarg
;
9135 case QEMU_OPTION_serial
:
9136 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
9137 fprintf(stderr
, "qemu: too many serial ports\n");
9140 serial_devices
[serial_device_index
] = optarg
;
9141 serial_device_index
++;
9143 case QEMU_OPTION_parallel
:
9144 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
9145 fprintf(stderr
, "qemu: too many parallel ports\n");
9148 parallel_devices
[parallel_device_index
] = optarg
;
9149 parallel_device_index
++;
9151 case QEMU_OPTION_loadvm
:
9154 case QEMU_OPTION_full_screen
:
9158 case QEMU_OPTION_no_frame
:
9161 case QEMU_OPTION_alt_grab
:
9164 case QEMU_OPTION_no_quit
:
9168 case QEMU_OPTION_pidfile
:
9172 case QEMU_OPTION_win2k_hack
:
9173 win2k_install_hack
= 1;
9177 case QEMU_OPTION_no_kqemu
:
9180 case QEMU_OPTION_kernel_kqemu
:
9184 case QEMU_OPTION_usb
:
9187 case QEMU_OPTION_usbdevice
:
9189 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
9190 fprintf(stderr
, "Too many USB devices\n");
9193 usb_devices
[usb_devices_index
] = optarg
;
9194 usb_devices_index
++;
9196 case QEMU_OPTION_smp
:
9197 smp_cpus
= atoi(optarg
);
9198 if (smp_cpus
< 1 || smp_cpus
> MAX_CPUS
) {
9199 fprintf(stderr
, "Invalid number of CPUs\n");
9203 case QEMU_OPTION_vnc
:
9204 vnc_display
= optarg
;
9206 case QEMU_OPTION_no_acpi
:
9209 case QEMU_OPTION_no_reboot
:
9212 case QEMU_OPTION_no_shutdown
:
9215 case QEMU_OPTION_show_cursor
:
9218 case QEMU_OPTION_uuid
:
9219 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
9220 fprintf(stderr
, "Fail to parse UUID string."
9221 " Wrong format.\n");
9225 case QEMU_OPTION_daemonize
:
9228 case QEMU_OPTION_option_rom
:
9229 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9230 fprintf(stderr
, "Too many option ROMs\n");
9233 option_rom
[nb_option_roms
] = optarg
;
9236 case QEMU_OPTION_semihosting
:
9237 semihosting_enabled
= 1;
9239 case QEMU_OPTION_name
:
9243 case QEMU_OPTION_prom_env
:
9244 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
9245 fprintf(stderr
, "Too many prom variables\n");
9248 prom_envs
[nb_prom_envs
] = optarg
;
9253 case QEMU_OPTION_old_param
:
9257 case QEMU_OPTION_clock
:
9258 configure_alarms(optarg
);
9260 case QEMU_OPTION_startdate
:
9263 time_t rtc_start_date
;
9264 if (!strcmp(optarg
, "now")) {
9265 rtc_date_offset
= -1;
9267 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
9275 } else if (sscanf(optarg
, "%d-%d-%d",
9278 &tm
.tm_mday
) == 3) {
9287 rtc_start_date
= mktimegm(&tm
);
9288 if (rtc_start_date
== -1) {
9290 fprintf(stderr
, "Invalid date format. Valid format are:\n"
9291 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9294 rtc_date_offset
= time(NULL
) - rtc_start_date
;
9298 case QEMU_OPTION_tb_size
:
9299 tb_size
= strtol(optarg
, NULL
, 0);
9303 case QEMU_OPTION_icount
:
9305 if (strcmp(optarg
, "auto") == 0) {
9306 icount_time_shift
= -1;
9308 icount_time_shift
= strtol(optarg
, NULL
, 0);
9316 if (serial_device_index
== 0)
9317 serial_devices
[0] = "stdio";
9318 if (parallel_device_index
== 0)
9319 parallel_devices
[0] = "null";
9320 if (strncmp(monitor_device
, "vc", 2) == 0)
9321 monitor_device
= "stdio";
9328 if (pipe(fds
) == -1)
9339 len
= read(fds
[0], &status
, 1);
9340 if (len
== -1 && (errno
== EINTR
))
9345 else if (status
== 1) {
9346 fprintf(stderr
, "Could not acquire pidfile\n");
9363 signal(SIGTSTP
, SIG_IGN
);
9364 signal(SIGTTOU
, SIG_IGN
);
9365 signal(SIGTTIN
, SIG_IGN
);
9369 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
9372 write(fds
[1], &status
, 1);
9374 fprintf(stderr
, "Could not acquire pid file\n");
9382 linux_boot
= (kernel_filename
!= NULL
);
9383 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
9385 if (!linux_boot
&& net_boot
== 0 &&
9386 !machine
->nodisk_ok
&& nb_drives_opt
== 0)
9389 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
9390 fprintf(stderr
, "-append only allowed with -kernel option\n");
9394 if (!linux_boot
&& initrd_filename
!= NULL
) {
9395 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
9399 /* boot to floppy or the default cd if no hard disk defined yet */
9400 if (!boot_devices
[0]) {
9401 boot_devices
= "cad";
9403 setvbuf(stdout
, NULL
, _IOLBF
, 0);
9407 if (use_icount
&& icount_time_shift
< 0) {
9409 /* 125MIPS seems a reasonable initial guess at the guest speed.
9410 It will be corrected fairly quickly anyway. */
9411 icount_time_shift
= 3;
9412 init_icount_adjust();
9419 /* init network clients */
9420 if (nb_net_clients
== 0) {
9421 /* if no clients, we use a default config */
9422 net_clients
[nb_net_clients
++] = "nic";
9424 net_clients
[nb_net_clients
++] = "user";
9428 for(i
= 0;i
< nb_net_clients
; i
++) {
9429 if (net_client_parse(net_clients
[i
]) < 0)
9432 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
9433 if (vlan
->nb_guest_devs
== 0 && vlan
->nb_host_devs
== 0)
9435 if (vlan
->nb_guest_devs
== 0)
9436 fprintf(stderr
, "Warning: vlan %d with no nics\n", vlan
->id
);
9437 if (vlan
->nb_host_devs
== 0)
9439 "Warning: vlan %d is not connected to host network\n",
9444 /* XXX: this should be moved in the PC machine instantiation code */
9445 if (net_boot
!= 0) {
9447 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
9448 const char *model
= nd_table
[i
].model
;
9450 if (net_boot
& (1 << i
)) {
9453 snprintf(buf
, sizeof(buf
), "%s/pxe-%s.bin", bios_dir
, model
);
9454 if (get_image_size(buf
) > 0) {
9455 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9456 fprintf(stderr
, "Too many option ROMs\n");
9459 option_rom
[nb_option_roms
] = strdup(buf
);
9466 fprintf(stderr
, "No valid PXE rom found for network device\n");
9472 /* init the memory */
9473 phys_ram_size
= machine
->ram_require
& ~RAMSIZE_FIXED
;
9475 if (machine
->ram_require
& RAMSIZE_FIXED
) {
9477 if (ram_size
< phys_ram_size
) {
9478 fprintf(stderr
, "Machine `%s' requires %llu bytes of memory\n",
9479 machine
->name
, (unsigned long long) phys_ram_size
);
9483 phys_ram_size
= ram_size
;
9485 ram_size
= phys_ram_size
;
9488 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
9490 phys_ram_size
+= ram_size
;
9493 phys_ram_base
= qemu_vmalloc(phys_ram_size
);
9494 if (!phys_ram_base
) {
9495 fprintf(stderr
, "Could not allocate physical memory\n");
9499 /* init the dynamic translator */
9500 cpu_exec_init_all(tb_size
* 1024 * 1024);
9504 /* we always create the cdrom drive, even if no disk is there */
9506 if (nb_drives_opt
< MAX_DRIVES
)
9507 drive_add(NULL
, CDROM_ALIAS
);
9509 /* we always create at least one floppy */
9511 if (nb_drives_opt
< MAX_DRIVES
)
9512 drive_add(NULL
, FD_ALIAS
, 0);
9514 /* we always create one sd slot, even if no card is in it */
9516 if (nb_drives_opt
< MAX_DRIVES
)
9517 drive_add(NULL
, SD_ALIAS
);
9519 /* open the virtual block devices */
9521 for(i
= 0; i
< nb_drives_opt
; i
++)
9522 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
9525 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
9526 register_savevm_live("ram", 0, 3, ram_save_live
, NULL
, ram_load
, NULL
);
9529 memset(&display_state
, 0, sizeof(display_state
));
9532 fprintf(stderr
, "fatal: -nographic can't be used with -curses\n");
9535 /* nearly nothing to do */
9536 dumb_display_init(ds
);
9537 } else if (vnc_display
!= NULL
) {
9538 vnc_display_init(ds
);
9539 if (vnc_display_open(ds
, vnc_display
) < 0)
9542 #if defined(CONFIG_CURSES)
9544 curses_display_init(ds
, full_screen
);
9548 #if defined(CONFIG_SDL)
9549 sdl_display_init(ds
, full_screen
, no_frame
);
9550 #elif defined(CONFIG_COCOA)
9551 cocoa_display_init(ds
, full_screen
);
9553 dumb_display_init(ds
);
9558 /* must be after terminal init, SDL library changes signal handlers */
9562 /* Maintain compatibility with multiple stdio monitors */
9563 if (!strcmp(monitor_device
,"stdio")) {
9564 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
9565 const char *devname
= serial_devices
[i
];
9566 if (devname
&& !strcmp(devname
,"mon:stdio")) {
9567 monitor_device
= NULL
;
9569 } else if (devname
&& !strcmp(devname
,"stdio")) {
9570 monitor_device
= NULL
;
9571 serial_devices
[i
] = "mon:stdio";
9576 if (monitor_device
) {
9577 monitor_hd
= qemu_chr_open(monitor_device
);
9579 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
9582 monitor_init(monitor_hd
, !nographic
);
9585 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
9586 const char *devname
= serial_devices
[i
];
9587 if (devname
&& strcmp(devname
, "none")) {
9588 serial_hds
[i
] = qemu_chr_open(devname
);
9589 if (!serial_hds
[i
]) {
9590 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
9594 if (strstart(devname
, "vc", 0))
9595 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
9599 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
9600 const char *devname
= parallel_devices
[i
];
9601 if (devname
&& strcmp(devname
, "none")) {
9602 parallel_hds
[i
] = qemu_chr_open(devname
);
9603 if (!parallel_hds
[i
]) {
9604 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
9608 if (strstart(devname
, "vc", 0))
9609 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
9613 machine
->init(ram_size
, vga_ram_size
, boot_devices
, ds
,
9614 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
9616 /* init USB devices */
9618 for(i
= 0; i
< usb_devices_index
; i
++) {
9619 if (usb_device_add(usb_devices
[i
]) < 0) {
9620 fprintf(stderr
, "Warning: could not add USB device %s\n",
9626 if (display_state
.dpy_refresh
) {
9627 display_state
.gui_timer
= qemu_new_timer(rt_clock
, gui_update
, &display_state
);
9628 qemu_mod_timer(display_state
.gui_timer
, qemu_get_clock(rt_clock
));
9631 #ifdef CONFIG_GDBSTUB
9633 /* XXX: use standard host:port notation and modify options
9635 if (gdbserver_start(gdbstub_port
) < 0) {
9636 fprintf(stderr
, "qemu: could not open gdbstub device on port '%s'\n",
9647 /* XXX: simplify init */
9660 len
= write(fds
[1], &status
, 1);
9661 if (len
== -1 && (errno
== EINTR
))
9668 TFR(fd
= open("/dev/null", O_RDWR
));
9682 #if !defined(_WIN32)
9683 /* close network clients */
9684 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
9685 VLANClientState
*vc
;
9687 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
9688 if (vc
->fd_read
== tap_receive
) {
9690 TAPState
*s
= vc
->opaque
;
9692 if (sscanf(vc
->info_str
, "tap: ifname=%63s ", ifname
) == 1 &&
9694 launch_script(s
->down_script
, ifname
, s
->fd
);
9696 #if defined(CONFIG_VDE)
9697 if (vc
->fd_read
== vde_from_qemu
) {
9698 VDEState
*s
= vc
->opaque
;