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"
41 #include "migration.h"
52 #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 int acpi_enabled
= 1;
221 int graphic_rotate
= 0;
223 const char *option_rom
[MAX_OPTION_ROMS
];
225 int semihosting_enabled
= 0;
229 const char *qemu_name
;
232 unsigned int nb_prom_envs
= 0;
233 const char *prom_envs
[MAX_PROM_ENVS
];
235 static int nb_drives_opt
;
236 static struct drive_opt
{
239 } drives_opt
[MAX_DRIVES
];
241 static CPUState
*cur_cpu
;
242 static CPUState
*next_cpu
;
243 static int event_pending
= 1;
244 /* Conversion factor from emulated instructions to virtual clock ticks. */
245 static int icount_time_shift
;
246 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
247 #define MAX_ICOUNT_SHIFT 10
248 /* Compensate for varying guest execution speed. */
249 static int64_t qemu_icount_bias
;
250 static QEMUTimer
*icount_rt_timer
;
251 static QEMUTimer
*icount_vm_timer
;
253 uint8_t qemu_uuid
[16];
255 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
257 /***********************************************************/
258 /* x86 ISA bus support */
260 target_phys_addr_t isa_mem_base
= 0;
263 static IOPortReadFunc default_ioport_readb
, default_ioport_readw
, default_ioport_readl
;
264 static IOPortWriteFunc default_ioport_writeb
, default_ioport_writew
, default_ioport_writel
;
266 static uint32_t ioport_read(int index
, uint32_t address
)
268 static IOPortReadFunc
*default_func
[3] = {
269 default_ioport_readb
,
270 default_ioport_readw
,
273 IOPortReadFunc
*func
= ioport_read_table
[index
][address
];
275 func
= default_func
[index
];
276 return func(ioport_opaque
[address
], address
);
279 static void ioport_write(int index
, uint32_t address
, uint32_t data
)
281 static IOPortWriteFunc
*default_func
[3] = {
282 default_ioport_writeb
,
283 default_ioport_writew
,
284 default_ioport_writel
286 IOPortWriteFunc
*func
= ioport_write_table
[index
][address
];
288 func
= default_func
[index
];
289 func(ioport_opaque
[address
], address
, data
);
292 static uint32_t default_ioport_readb(void *opaque
, uint32_t address
)
294 #ifdef DEBUG_UNUSED_IOPORT
295 fprintf(stderr
, "unused inb: port=0x%04x\n", address
);
300 static void default_ioport_writeb(void *opaque
, uint32_t address
, uint32_t data
)
302 #ifdef DEBUG_UNUSED_IOPORT
303 fprintf(stderr
, "unused outb: port=0x%04x data=0x%02x\n", address
, data
);
307 /* default is to make two byte accesses */
308 static uint32_t default_ioport_readw(void *opaque
, uint32_t address
)
311 data
= ioport_read(0, address
);
312 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
313 data
|= ioport_read(0, address
) << 8;
317 static void default_ioport_writew(void *opaque
, uint32_t address
, uint32_t data
)
319 ioport_write(0, address
, data
& 0xff);
320 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
321 ioport_write(0, address
, (data
>> 8) & 0xff);
324 static uint32_t default_ioport_readl(void *opaque
, uint32_t address
)
326 #ifdef DEBUG_UNUSED_IOPORT
327 fprintf(stderr
, "unused inl: port=0x%04x\n", address
);
332 static void default_ioport_writel(void *opaque
, uint32_t address
, uint32_t data
)
334 #ifdef DEBUG_UNUSED_IOPORT
335 fprintf(stderr
, "unused outl: port=0x%04x data=0x%02x\n", address
, data
);
339 /* size is the word size in byte */
340 int register_ioport_read(int start
, int length
, int size
,
341 IOPortReadFunc
*func
, void *opaque
)
347 } else if (size
== 2) {
349 } else if (size
== 4) {
352 hw_error("register_ioport_read: invalid size");
355 for(i
= start
; i
< start
+ length
; i
+= size
) {
356 ioport_read_table
[bsize
][i
] = func
;
357 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
358 hw_error("register_ioport_read: invalid opaque");
359 ioport_opaque
[i
] = opaque
;
364 /* size is the word size in byte */
365 int register_ioport_write(int start
, int length
, int size
,
366 IOPortWriteFunc
*func
, void *opaque
)
372 } else if (size
== 2) {
374 } else if (size
== 4) {
377 hw_error("register_ioport_write: invalid size");
380 for(i
= start
; i
< start
+ length
; i
+= size
) {
381 ioport_write_table
[bsize
][i
] = func
;
382 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
383 hw_error("register_ioport_write: invalid opaque");
384 ioport_opaque
[i
] = opaque
;
389 void isa_unassign_ioport(int start
, int length
)
393 for(i
= start
; i
< start
+ length
; i
++) {
394 ioport_read_table
[0][i
] = default_ioport_readb
;
395 ioport_read_table
[1][i
] = default_ioport_readw
;
396 ioport_read_table
[2][i
] = default_ioport_readl
;
398 ioport_write_table
[0][i
] = default_ioport_writeb
;
399 ioport_write_table
[1][i
] = default_ioport_writew
;
400 ioport_write_table
[2][i
] = default_ioport_writel
;
404 /***********************************************************/
406 void cpu_outb(CPUState
*env
, int addr
, int val
)
409 if (loglevel
& CPU_LOG_IOPORT
)
410 fprintf(logfile
, "outb: %04x %02x\n", addr
, val
);
412 ioport_write(0, addr
, val
);
415 env
->last_io_time
= cpu_get_time_fast();
419 void cpu_outw(CPUState
*env
, int addr
, int val
)
422 if (loglevel
& CPU_LOG_IOPORT
)
423 fprintf(logfile
, "outw: %04x %04x\n", addr
, val
);
425 ioport_write(1, addr
, val
);
428 env
->last_io_time
= cpu_get_time_fast();
432 void cpu_outl(CPUState
*env
, int addr
, int val
)
435 if (loglevel
& CPU_LOG_IOPORT
)
436 fprintf(logfile
, "outl: %04x %08x\n", addr
, val
);
438 ioport_write(2, addr
, val
);
441 env
->last_io_time
= cpu_get_time_fast();
445 int cpu_inb(CPUState
*env
, int addr
)
448 val
= ioport_read(0, addr
);
450 if (loglevel
& CPU_LOG_IOPORT
)
451 fprintf(logfile
, "inb : %04x %02x\n", addr
, val
);
455 env
->last_io_time
= cpu_get_time_fast();
460 int cpu_inw(CPUState
*env
, int addr
)
463 val
= ioport_read(1, addr
);
465 if (loglevel
& CPU_LOG_IOPORT
)
466 fprintf(logfile
, "inw : %04x %04x\n", addr
, val
);
470 env
->last_io_time
= cpu_get_time_fast();
475 int cpu_inl(CPUState
*env
, int addr
)
478 val
= ioport_read(2, addr
);
480 if (loglevel
& CPU_LOG_IOPORT
)
481 fprintf(logfile
, "inl : %04x %08x\n", addr
, val
);
485 env
->last_io_time
= cpu_get_time_fast();
490 /***********************************************************/
491 void hw_error(const char *fmt
, ...)
497 fprintf(stderr
, "qemu: hardware error: ");
498 vfprintf(stderr
, fmt
, ap
);
499 fprintf(stderr
, "\n");
500 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
501 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
503 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
505 cpu_dump_state(env
, stderr
, fprintf
, 0);
512 /***********************************************************/
515 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
516 static void *qemu_put_kbd_event_opaque
;
517 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
518 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
520 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
522 qemu_put_kbd_event_opaque
= opaque
;
523 qemu_put_kbd_event
= func
;
526 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
527 void *opaque
, int absolute
,
530 QEMUPutMouseEntry
*s
, *cursor
;
532 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
536 s
->qemu_put_mouse_event
= func
;
537 s
->qemu_put_mouse_event_opaque
= opaque
;
538 s
->qemu_put_mouse_event_absolute
= absolute
;
539 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
542 if (!qemu_put_mouse_event_head
) {
543 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
547 cursor
= qemu_put_mouse_event_head
;
548 while (cursor
->next
!= NULL
)
549 cursor
= cursor
->next
;
552 qemu_put_mouse_event_current
= s
;
557 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
559 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
561 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
564 cursor
= qemu_put_mouse_event_head
;
565 while (cursor
!= NULL
&& cursor
!= entry
) {
567 cursor
= cursor
->next
;
570 if (cursor
== NULL
) // does not exist or list empty
572 else if (prev
== NULL
) { // entry is head
573 qemu_put_mouse_event_head
= cursor
->next
;
574 if (qemu_put_mouse_event_current
== entry
)
575 qemu_put_mouse_event_current
= cursor
->next
;
576 qemu_free(entry
->qemu_put_mouse_event_name
);
581 prev
->next
= entry
->next
;
583 if (qemu_put_mouse_event_current
== entry
)
584 qemu_put_mouse_event_current
= prev
;
586 qemu_free(entry
->qemu_put_mouse_event_name
);
590 void kbd_put_keycode(int keycode
)
592 if (qemu_put_kbd_event
) {
593 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
597 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
599 QEMUPutMouseEvent
*mouse_event
;
600 void *mouse_event_opaque
;
603 if (!qemu_put_mouse_event_current
) {
608 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
610 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
613 if (graphic_rotate
) {
614 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
617 width
= graphic_width
- 1;
618 mouse_event(mouse_event_opaque
,
619 width
- dy
, dx
, dz
, buttons_state
);
621 mouse_event(mouse_event_opaque
,
622 dx
, dy
, dz
, buttons_state
);
626 int kbd_mouse_is_absolute(void)
628 if (!qemu_put_mouse_event_current
)
631 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
634 void do_info_mice(void)
636 QEMUPutMouseEntry
*cursor
;
639 if (!qemu_put_mouse_event_head
) {
640 term_printf("No mouse devices connected\n");
644 term_printf("Mouse devices available:\n");
645 cursor
= qemu_put_mouse_event_head
;
646 while (cursor
!= NULL
) {
647 term_printf("%c Mouse #%d: %s\n",
648 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
649 index
, cursor
->qemu_put_mouse_event_name
);
651 cursor
= cursor
->next
;
655 void do_mouse_set(int index
)
657 QEMUPutMouseEntry
*cursor
;
660 if (!qemu_put_mouse_event_head
) {
661 term_printf("No mouse devices connected\n");
665 cursor
= qemu_put_mouse_event_head
;
666 while (cursor
!= NULL
&& index
!= i
) {
668 cursor
= cursor
->next
;
672 qemu_put_mouse_event_current
= cursor
;
674 term_printf("Mouse at given index not found\n");
677 /* compute with 96 bit intermediate result: (a*b)/c */
678 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
683 #ifdef WORDS_BIGENDIAN
693 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
694 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
697 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
701 /***********************************************************/
702 /* real time host monotonic timer */
704 #define QEMU_TIMER_BASE 1000000000LL
708 static int64_t clock_freq
;
710 static void init_get_clock(void)
714 ret
= QueryPerformanceFrequency(&freq
);
716 fprintf(stderr
, "Could not calibrate ticks\n");
719 clock_freq
= freq
.QuadPart
;
722 static int64_t get_clock(void)
725 QueryPerformanceCounter(&ti
);
726 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
731 static int use_rt_clock
;
733 static void init_get_clock(void)
736 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
739 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
746 static int64_t get_clock(void)
748 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
751 clock_gettime(CLOCK_MONOTONIC
, &ts
);
752 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
756 /* XXX: using gettimeofday leads to problems if the date
757 changes, so it should be avoided. */
759 gettimeofday(&tv
, NULL
);
760 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
765 /* Return the virtual CPU time, based on the instruction counter. */
766 static int64_t cpu_get_icount(void)
769 CPUState
*env
= cpu_single_env
;;
770 icount
= qemu_icount
;
773 fprintf(stderr
, "Bad clock read\n");
774 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
776 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
779 /***********************************************************/
780 /* guest cycle counter */
782 static int64_t cpu_ticks_prev
;
783 static int64_t cpu_ticks_offset
;
784 static int64_t cpu_clock_offset
;
785 static int cpu_ticks_enabled
;
787 /* return the host CPU cycle counter and handle stop/restart */
788 int64_t cpu_get_ticks(void)
791 return cpu_get_icount();
793 if (!cpu_ticks_enabled
) {
794 return cpu_ticks_offset
;
797 ticks
= cpu_get_real_ticks();
798 if (cpu_ticks_prev
> ticks
) {
799 /* Note: non increasing ticks may happen if the host uses
801 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
803 cpu_ticks_prev
= ticks
;
804 return ticks
+ cpu_ticks_offset
;
808 /* return the host CPU monotonic timer and handle stop/restart */
809 static int64_t cpu_get_clock(void)
812 if (!cpu_ticks_enabled
) {
813 return cpu_clock_offset
;
816 return ti
+ cpu_clock_offset
;
820 /* enable cpu_get_ticks() */
821 void cpu_enable_ticks(void)
823 if (!cpu_ticks_enabled
) {
824 cpu_ticks_offset
-= cpu_get_real_ticks();
825 cpu_clock_offset
-= get_clock();
826 cpu_ticks_enabled
= 1;
830 /* disable cpu_get_ticks() : the clock is stopped. You must not call
831 cpu_get_ticks() after that. */
832 void cpu_disable_ticks(void)
834 if (cpu_ticks_enabled
) {
835 cpu_ticks_offset
= cpu_get_ticks();
836 cpu_clock_offset
= cpu_get_clock();
837 cpu_ticks_enabled
= 0;
841 /***********************************************************/
844 #define QEMU_TIMER_REALTIME 0
845 #define QEMU_TIMER_VIRTUAL 1
849 /* XXX: add frequency */
857 struct QEMUTimer
*next
;
860 struct qemu_alarm_timer
{
864 int (*start
)(struct qemu_alarm_timer
*t
);
865 void (*stop
)(struct qemu_alarm_timer
*t
);
866 void (*rearm
)(struct qemu_alarm_timer
*t
);
870 #define ALARM_FLAG_DYNTICKS 0x1
871 #define ALARM_FLAG_EXPIRED 0x2
873 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
875 return t
->flags
& ALARM_FLAG_DYNTICKS
;
878 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
880 if (!alarm_has_dynticks(t
))
886 /* TODO: MIN_TIMER_REARM_US should be optimized */
887 #define MIN_TIMER_REARM_US 250
889 static struct qemu_alarm_timer
*alarm_timer
;
893 struct qemu_alarm_win32
{
897 } alarm_win32_data
= {0, NULL
, -1};
899 static int win32_start_timer(struct qemu_alarm_timer
*t
);
900 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
901 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
905 static int unix_start_timer(struct qemu_alarm_timer
*t
);
906 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
910 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
911 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
912 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
914 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
915 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
917 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
918 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
920 #endif /* __linux__ */
924 /* Correlation between real and virtual time is always going to be
925 fairly approximate, so ignore small variation.
926 When the guest is idle real and virtual time will be aligned in
928 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
930 static void icount_adjust(void)
935 static int64_t last_delta
;
936 /* If the VM is not running, then do nothing. */
940 cur_time
= cpu_get_clock();
941 cur_icount
= qemu_get_clock(vm_clock
);
942 delta
= cur_icount
- cur_time
;
943 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
945 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
946 && icount_time_shift
> 0) {
947 /* The guest is getting too far ahead. Slow time down. */
951 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
952 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
953 /* The guest is getting too far behind. Speed time up. */
957 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
960 static void icount_adjust_rt(void * opaque
)
962 qemu_mod_timer(icount_rt_timer
,
963 qemu_get_clock(rt_clock
) + 1000);
967 static void icount_adjust_vm(void * opaque
)
969 qemu_mod_timer(icount_vm_timer
,
970 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
974 static void init_icount_adjust(void)
976 /* Have both realtime and virtual time triggers for speed adjustment.
977 The realtime trigger catches emulated time passing too slowly,
978 the virtual time trigger catches emulated time passing too fast.
979 Realtime triggers occur even when idle, so use them less frequently
981 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
982 qemu_mod_timer(icount_rt_timer
,
983 qemu_get_clock(rt_clock
) + 1000);
984 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
985 qemu_mod_timer(icount_vm_timer
,
986 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
989 static struct qemu_alarm_timer alarm_timers
[] = {
992 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
993 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
994 /* HPET - if available - is preferred */
995 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
996 /* ...otherwise try RTC */
997 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
999 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
1001 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
1002 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
1003 {"win32", 0, win32_start_timer
,
1004 win32_stop_timer
, NULL
, &alarm_win32_data
},
1009 static void show_available_alarms(void)
1013 printf("Available alarm timers, in order of precedence:\n");
1014 for (i
= 0; alarm_timers
[i
].name
; i
++)
1015 printf("%s\n", alarm_timers
[i
].name
);
1018 static void configure_alarms(char const *opt
)
1022 int count
= (sizeof(alarm_timers
) / sizeof(*alarm_timers
)) - 1;
1025 struct qemu_alarm_timer tmp
;
1027 if (!strcmp(opt
, "?")) {
1028 show_available_alarms();
1034 /* Reorder the array */
1035 name
= strtok(arg
, ",");
1037 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
1038 if (!strcmp(alarm_timers
[i
].name
, name
))
1043 fprintf(stderr
, "Unknown clock %s\n", name
);
1052 tmp
= alarm_timers
[i
];
1053 alarm_timers
[i
] = alarm_timers
[cur
];
1054 alarm_timers
[cur
] = tmp
;
1058 name
= strtok(NULL
, ",");
1064 /* Disable remaining timers */
1065 for (i
= cur
; i
< count
; i
++)
1066 alarm_timers
[i
].name
= NULL
;
1068 show_available_alarms();
1073 QEMUClock
*rt_clock
;
1074 QEMUClock
*vm_clock
;
1076 static QEMUTimer
*active_timers
[2];
1078 static QEMUClock
*qemu_new_clock(int type
)
1081 clock
= qemu_mallocz(sizeof(QEMUClock
));
1088 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
1092 ts
= qemu_mallocz(sizeof(QEMUTimer
));
1095 ts
->opaque
= opaque
;
1099 void qemu_free_timer(QEMUTimer
*ts
)
1104 /* stop a timer, but do not dealloc it */
1105 void qemu_del_timer(QEMUTimer
*ts
)
1109 /* NOTE: this code must be signal safe because
1110 qemu_timer_expired() can be called from a signal. */
1111 pt
= &active_timers
[ts
->clock
->type
];
1124 /* modify the current timer so that it will be fired when current_time
1125 >= expire_time. The corresponding callback will be called. */
1126 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
1132 /* add the timer in the sorted list */
1133 /* NOTE: this code must be signal safe because
1134 qemu_timer_expired() can be called from a signal. */
1135 pt
= &active_timers
[ts
->clock
->type
];
1140 if (t
->expire_time
> expire_time
)
1144 ts
->expire_time
= expire_time
;
1148 /* Rearm if necessary */
1149 if (pt
== &active_timers
[ts
->clock
->type
]) {
1150 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
1151 qemu_rearm_alarm_timer(alarm_timer
);
1153 /* Interrupt execution to force deadline recalculation. */
1154 if (use_icount
&& cpu_single_env
) {
1155 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
1160 int qemu_timer_pending(QEMUTimer
*ts
)
1163 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1170 static inline int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1174 return (timer_head
->expire_time
<= current_time
);
1177 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1183 if (!ts
|| ts
->expire_time
> current_time
)
1185 /* remove timer from the list before calling the callback */
1186 *ptimer_head
= ts
->next
;
1189 /* run the callback (the timer list can be modified) */
1194 int64_t qemu_get_clock(QEMUClock
*clock
)
1196 switch(clock
->type
) {
1197 case QEMU_TIMER_REALTIME
:
1198 return get_clock() / 1000000;
1200 case QEMU_TIMER_VIRTUAL
:
1202 return cpu_get_icount();
1204 return cpu_get_clock();
1209 static void init_timers(void)
1212 ticks_per_sec
= QEMU_TIMER_BASE
;
1213 rt_clock
= qemu_new_clock(QEMU_TIMER_REALTIME
);
1214 vm_clock
= qemu_new_clock(QEMU_TIMER_VIRTUAL
);
1218 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1220 uint64_t expire_time
;
1222 if (qemu_timer_pending(ts
)) {
1223 expire_time
= ts
->expire_time
;
1227 qemu_put_be64(f
, expire_time
);
1230 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1232 uint64_t expire_time
;
1234 expire_time
= qemu_get_be64(f
);
1235 if (expire_time
!= -1) {
1236 qemu_mod_timer(ts
, expire_time
);
1242 static void timer_save(QEMUFile
*f
, void *opaque
)
1244 if (cpu_ticks_enabled
) {
1245 hw_error("cannot save state if virtual timers are running");
1247 qemu_put_be64(f
, cpu_ticks_offset
);
1248 qemu_put_be64(f
, ticks_per_sec
);
1249 qemu_put_be64(f
, cpu_clock_offset
);
1252 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1254 if (version_id
!= 1 && version_id
!= 2)
1256 if (cpu_ticks_enabled
) {
1259 cpu_ticks_offset
=qemu_get_be64(f
);
1260 ticks_per_sec
=qemu_get_be64(f
);
1261 if (version_id
== 2) {
1262 cpu_clock_offset
=qemu_get_be64(f
);
1268 void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1269 DWORD_PTR dwUser
, DWORD_PTR dw1
, DWORD_PTR dw2
)
1271 static void host_alarm_handler(int host_signum
)
1275 #define DISP_FREQ 1000
1277 static int64_t delta_min
= INT64_MAX
;
1278 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1280 ti
= qemu_get_clock(vm_clock
);
1281 if (last_clock
!= 0) {
1282 delta
= ti
- last_clock
;
1283 if (delta
< delta_min
)
1285 if (delta
> delta_max
)
1288 if (++count
== DISP_FREQ
) {
1289 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1290 muldiv64(delta_min
, 1000000, ticks_per_sec
),
1291 muldiv64(delta_max
, 1000000, ticks_per_sec
),
1292 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, ticks_per_sec
),
1293 (double)ticks_per_sec
/ ((double)delta_cum
/ DISP_FREQ
));
1295 delta_min
= INT64_MAX
;
1303 if (alarm_has_dynticks(alarm_timer
) ||
1305 qemu_timer_expired(active_timers
[QEMU_TIMER_VIRTUAL
],
1306 qemu_get_clock(vm_clock
))) ||
1307 qemu_timer_expired(active_timers
[QEMU_TIMER_REALTIME
],
1308 qemu_get_clock(rt_clock
))) {
1310 struct qemu_alarm_win32
*data
= ((struct qemu_alarm_timer
*)dwUser
)->priv
;
1311 SetEvent(data
->host_alarm
);
1313 CPUState
*env
= next_cpu
;
1315 alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1318 /* stop the currently executing cpu because a timer occured */
1319 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
1321 if (env
->kqemu_enabled
) {
1322 kqemu_cpu_interrupt(env
);
1330 static int64_t qemu_next_deadline(void)
1334 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1335 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1336 qemu_get_clock(vm_clock
);
1338 /* To avoid problems with overflow limit this to 2^32. */
1348 #if defined(__linux__) || defined(_WIN32)
1349 static uint64_t qemu_next_deadline_dyntick(void)
1357 delta
= (qemu_next_deadline() + 999) / 1000;
1359 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1360 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1361 qemu_get_clock(rt_clock
))*1000;
1362 if (rtdelta
< delta
)
1366 if (delta
< MIN_TIMER_REARM_US
)
1367 delta
= MIN_TIMER_REARM_US
;
1375 #if defined(__linux__)
1377 #define RTC_FREQ 1024
1379 static void enable_sigio_timer(int fd
)
1381 struct sigaction act
;
1384 sigfillset(&act
.sa_mask
);
1386 act
.sa_handler
= host_alarm_handler
;
1388 sigaction(SIGIO
, &act
, NULL
);
1389 fcntl(fd
, F_SETFL
, O_ASYNC
);
1390 fcntl(fd
, F_SETOWN
, getpid());
1393 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1395 struct hpet_info info
;
1398 fd
= open("/dev/hpet", O_RDONLY
);
1403 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1405 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1406 "error, but for better emulation accuracy type:\n"
1407 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1411 /* Check capabilities */
1412 r
= ioctl(fd
, HPET_INFO
, &info
);
1416 /* Enable periodic mode */
1417 r
= ioctl(fd
, HPET_EPI
, 0);
1418 if (info
.hi_flags
&& (r
< 0))
1421 /* Enable interrupt */
1422 r
= ioctl(fd
, HPET_IE_ON
, 0);
1426 enable_sigio_timer(fd
);
1427 t
->priv
= (void *)(long)fd
;
1435 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1437 int fd
= (long)t
->priv
;
1442 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1445 unsigned long current_rtc_freq
= 0;
1447 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1450 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1451 if (current_rtc_freq
!= RTC_FREQ
&&
1452 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1453 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1454 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1455 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1458 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1464 enable_sigio_timer(rtc_fd
);
1466 t
->priv
= (void *)(long)rtc_fd
;
1471 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1473 int rtc_fd
= (long)t
->priv
;
1478 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1482 struct sigaction act
;
1484 sigfillset(&act
.sa_mask
);
1486 act
.sa_handler
= host_alarm_handler
;
1488 sigaction(SIGALRM
, &act
, NULL
);
1490 ev
.sigev_value
.sival_int
= 0;
1491 ev
.sigev_notify
= SIGEV_SIGNAL
;
1492 ev
.sigev_signo
= SIGALRM
;
1494 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1495 perror("timer_create");
1497 /* disable dynticks */
1498 fprintf(stderr
, "Dynamic Ticks disabled\n");
1503 t
->priv
= (void *)host_timer
;
1508 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1510 timer_t host_timer
= (timer_t
)t
->priv
;
1512 timer_delete(host_timer
);
1515 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1517 timer_t host_timer
= (timer_t
)t
->priv
;
1518 struct itimerspec timeout
;
1519 int64_t nearest_delta_us
= INT64_MAX
;
1522 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1523 !active_timers
[QEMU_TIMER_VIRTUAL
])
1526 nearest_delta_us
= qemu_next_deadline_dyntick();
1528 /* check whether a timer is already running */
1529 if (timer_gettime(host_timer
, &timeout
)) {
1531 fprintf(stderr
, "Internal timer error: aborting\n");
1534 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1535 if (current_us
&& current_us
<= nearest_delta_us
)
1538 timeout
.it_interval
.tv_sec
= 0;
1539 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1540 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1541 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1542 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1544 fprintf(stderr
, "Internal timer error: aborting\n");
1549 #endif /* defined(__linux__) */
1551 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1553 struct sigaction act
;
1554 struct itimerval itv
;
1558 sigfillset(&act
.sa_mask
);
1560 act
.sa_handler
= host_alarm_handler
;
1562 sigaction(SIGALRM
, &act
, NULL
);
1564 itv
.it_interval
.tv_sec
= 0;
1565 /* for i386 kernel 2.6 to get 1 ms */
1566 itv
.it_interval
.tv_usec
= 999;
1567 itv
.it_value
.tv_sec
= 0;
1568 itv
.it_value
.tv_usec
= 10 * 1000;
1570 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1577 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1579 struct itimerval itv
;
1581 memset(&itv
, 0, sizeof(itv
));
1582 setitimer(ITIMER_REAL
, &itv
, NULL
);
1585 #endif /* !defined(_WIN32) */
1589 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1592 struct qemu_alarm_win32
*data
= t
->priv
;
1595 data
->host_alarm
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1596 if (!data
->host_alarm
) {
1597 perror("Failed CreateEvent");
1601 memset(&tc
, 0, sizeof(tc
));
1602 timeGetDevCaps(&tc
, sizeof(tc
));
1604 if (data
->period
< tc
.wPeriodMin
)
1605 data
->period
= tc
.wPeriodMin
;
1607 timeBeginPeriod(data
->period
);
1609 flags
= TIME_CALLBACK_FUNCTION
;
1610 if (alarm_has_dynticks(t
))
1611 flags
|= TIME_ONESHOT
;
1613 flags
|= TIME_PERIODIC
;
1615 data
->timerId
= timeSetEvent(1, // interval (ms)
1616 data
->period
, // resolution
1617 host_alarm_handler
, // function
1618 (DWORD
)t
, // parameter
1621 if (!data
->timerId
) {
1622 perror("Failed to initialize win32 alarm timer");
1624 timeEndPeriod(data
->period
);
1625 CloseHandle(data
->host_alarm
);
1629 qemu_add_wait_object(data
->host_alarm
, NULL
, NULL
);
1634 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1636 struct qemu_alarm_win32
*data
= t
->priv
;
1638 timeKillEvent(data
->timerId
);
1639 timeEndPeriod(data
->period
);
1641 CloseHandle(data
->host_alarm
);
1644 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1646 struct qemu_alarm_win32
*data
= t
->priv
;
1647 uint64_t nearest_delta_us
;
1649 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1650 !active_timers
[QEMU_TIMER_VIRTUAL
])
1653 nearest_delta_us
= qemu_next_deadline_dyntick();
1654 nearest_delta_us
/= 1000;
1656 timeKillEvent(data
->timerId
);
1658 data
->timerId
= timeSetEvent(1,
1662 TIME_ONESHOT
| TIME_PERIODIC
);
1664 if (!data
->timerId
) {
1665 perror("Failed to re-arm win32 alarm timer");
1667 timeEndPeriod(data
->period
);
1668 CloseHandle(data
->host_alarm
);
1675 static void init_timer_alarm(void)
1677 struct qemu_alarm_timer
*t
= NULL
;
1680 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1681 t
= &alarm_timers
[i
];
1689 fprintf(stderr
, "Unable to find any suitable alarm timer.\n");
1690 fprintf(stderr
, "Terminating\n");
1697 static void quit_timers(void)
1699 alarm_timer
->stop(alarm_timer
);
1703 /***********************************************************/
1704 /* host time/date access */
1705 void qemu_get_timedate(struct tm
*tm
, int offset
)
1712 if (rtc_date_offset
== -1) {
1716 ret
= localtime(&ti
);
1718 ti
-= rtc_date_offset
;
1722 memcpy(tm
, ret
, sizeof(struct tm
));
1725 int qemu_timedate_diff(struct tm
*tm
)
1729 if (rtc_date_offset
== -1)
1731 seconds
= mktimegm(tm
);
1733 seconds
= mktime(tm
);
1735 seconds
= mktimegm(tm
) + rtc_date_offset
;
1737 return seconds
- time(NULL
);
1740 /***********************************************************/
1741 /* character device */
1743 static void qemu_chr_event(CharDriverState
*s
, int event
)
1747 s
->chr_event(s
->handler_opaque
, event
);
1750 static void qemu_chr_reset_bh(void *opaque
)
1752 CharDriverState
*s
= opaque
;
1753 qemu_chr_event(s
, CHR_EVENT_RESET
);
1754 qemu_bh_delete(s
->bh
);
1758 void qemu_chr_reset(CharDriverState
*s
)
1760 if (s
->bh
== NULL
) {
1761 s
->bh
= qemu_bh_new(qemu_chr_reset_bh
, s
);
1762 qemu_bh_schedule(s
->bh
);
1766 int qemu_chr_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
1768 return s
->chr_write(s
, buf
, len
);
1771 int qemu_chr_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
1775 return s
->chr_ioctl(s
, cmd
, arg
);
1778 int qemu_chr_can_read(CharDriverState
*s
)
1780 if (!s
->chr_can_read
)
1782 return s
->chr_can_read(s
->handler_opaque
);
1785 void qemu_chr_read(CharDriverState
*s
, uint8_t *buf
, int len
)
1787 s
->chr_read(s
->handler_opaque
, buf
, len
);
1790 void qemu_chr_accept_input(CharDriverState
*s
)
1792 if (s
->chr_accept_input
)
1793 s
->chr_accept_input(s
);
1796 void qemu_chr_printf(CharDriverState
*s
, const char *fmt
, ...)
1801 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
1802 qemu_chr_write(s
, (uint8_t *)buf
, strlen(buf
));
1806 void qemu_chr_send_event(CharDriverState
*s
, int event
)
1808 if (s
->chr_send_event
)
1809 s
->chr_send_event(s
, event
);
1812 void qemu_chr_add_handlers(CharDriverState
*s
,
1813 IOCanRWHandler
*fd_can_read
,
1814 IOReadHandler
*fd_read
,
1815 IOEventHandler
*fd_event
,
1818 s
->chr_can_read
= fd_can_read
;
1819 s
->chr_read
= fd_read
;
1820 s
->chr_event
= fd_event
;
1821 s
->handler_opaque
= opaque
;
1822 if (s
->chr_update_read_handler
)
1823 s
->chr_update_read_handler(s
);
1826 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1831 static CharDriverState
*qemu_chr_open_null(void)
1833 CharDriverState
*chr
;
1835 chr
= qemu_mallocz(sizeof(CharDriverState
));
1838 chr
->chr_write
= null_chr_write
;
1842 /* MUX driver for serial I/O splitting */
1843 static int term_timestamps
;
1844 static int64_t term_timestamps_start
;
1846 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1847 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1849 IOCanRWHandler
*chr_can_read
[MAX_MUX
];
1850 IOReadHandler
*chr_read
[MAX_MUX
];
1851 IOEventHandler
*chr_event
[MAX_MUX
];
1852 void *ext_opaque
[MAX_MUX
];
1853 CharDriverState
*drv
;
1854 unsigned char buffer
[MUX_BUFFER_SIZE
];
1858 int term_got_escape
;
1863 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1865 MuxDriver
*d
= chr
->opaque
;
1867 if (!term_timestamps
) {
1868 ret
= d
->drv
->chr_write(d
->drv
, buf
, len
);
1873 for(i
= 0; i
< len
; i
++) {
1874 ret
+= d
->drv
->chr_write(d
->drv
, buf
+i
, 1);
1875 if (buf
[i
] == '\n') {
1881 if (term_timestamps_start
== -1)
1882 term_timestamps_start
= ti
;
1883 ti
-= term_timestamps_start
;
1884 secs
= ti
/ 1000000000;
1885 snprintf(buf1
, sizeof(buf1
),
1886 "[%02d:%02d:%02d.%03d] ",
1890 (int)((ti
/ 1000000) % 1000));
1891 d
->drv
->chr_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
1898 static const char * const mux_help
[] = {
1899 "% h print this help\n\r",
1900 "% x exit emulator\n\r",
1901 "% s save disk data back to file (if -snapshot)\n\r",
1902 "% t toggle console timestamps\n\r"
1903 "% b send break (magic sysrq)\n\r",
1904 "% c switch between console and monitor\n\r",
1909 static int term_escape_char
= 0x01; /* ctrl-a is used for escape */
1910 static void mux_print_help(CharDriverState
*chr
)
1913 char ebuf
[15] = "Escape-Char";
1914 char cbuf
[50] = "\n\r";
1916 if (term_escape_char
> 0 && term_escape_char
< 26) {
1917 snprintf(cbuf
, sizeof(cbuf
), "\n\r");
1918 snprintf(ebuf
, sizeof(ebuf
), "C-%c", term_escape_char
- 1 + 'a');
1920 snprintf(cbuf
, sizeof(cbuf
),
1921 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1924 chr
->chr_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
1925 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
1926 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
1927 if (mux_help
[i
][j
] == '%')
1928 chr
->chr_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
1930 chr
->chr_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
1935 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
1937 if (d
->term_got_escape
) {
1938 d
->term_got_escape
= 0;
1939 if (ch
== term_escape_char
)
1944 mux_print_help(chr
);
1948 const char *term
= "QEMU: Terminated\n\r";
1949 chr
->chr_write(chr
,(uint8_t *)term
,strlen(term
));
1956 for (i
= 0; i
< nb_drives
; i
++) {
1957 bdrv_commit(drives_table
[i
].bdrv
);
1962 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
1965 /* Switch to the next registered device */
1967 if (chr
->focus
>= d
->mux_cnt
)
1971 term_timestamps
= !term_timestamps
;
1972 term_timestamps_start
= -1;
1975 } else if (ch
== term_escape_char
) {
1976 d
->term_got_escape
= 1;
1984 static void mux_chr_accept_input(CharDriverState
*chr
)
1987 MuxDriver
*d
= chr
->opaque
;
1989 while (d
->prod
!= d
->cons
&&
1990 d
->chr_can_read
[m
] &&
1991 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
1992 d
->chr_read
[m
](d
->ext_opaque
[m
],
1993 &d
->buffer
[d
->cons
++ & MUX_BUFFER_MASK
], 1);
1997 static int mux_chr_can_read(void *opaque
)
1999 CharDriverState
*chr
= opaque
;
2000 MuxDriver
*d
= chr
->opaque
;
2002 if ((d
->prod
- d
->cons
) < MUX_BUFFER_SIZE
)
2004 if (d
->chr_can_read
[chr
->focus
])
2005 return d
->chr_can_read
[chr
->focus
](d
->ext_opaque
[chr
->focus
]);
2009 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
2011 CharDriverState
*chr
= opaque
;
2012 MuxDriver
*d
= chr
->opaque
;
2016 mux_chr_accept_input (opaque
);
2018 for(i
= 0; i
< size
; i
++)
2019 if (mux_proc_byte(chr
, d
, buf
[i
])) {
2020 if (d
->prod
== d
->cons
&&
2021 d
->chr_can_read
[m
] &&
2022 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
2023 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
2025 d
->buffer
[d
->prod
++ & MUX_BUFFER_MASK
] = buf
[i
];
2029 static void mux_chr_event(void *opaque
, int event
)
2031 CharDriverState
*chr
= opaque
;
2032 MuxDriver
*d
= chr
->opaque
;
2035 /* Send the event to all registered listeners */
2036 for (i
= 0; i
< d
->mux_cnt
; i
++)
2037 if (d
->chr_event
[i
])
2038 d
->chr_event
[i
](d
->ext_opaque
[i
], event
);
2041 static void mux_chr_update_read_handler(CharDriverState
*chr
)
2043 MuxDriver
*d
= chr
->opaque
;
2045 if (d
->mux_cnt
>= MAX_MUX
) {
2046 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
2049 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
2050 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
2051 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
2052 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
2053 /* Fix up the real driver with mux routines */
2054 if (d
->mux_cnt
== 0) {
2055 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
2056 mux_chr_event
, chr
);
2058 chr
->focus
= d
->mux_cnt
;
2062 static CharDriverState
*qemu_chr_open_mux(CharDriverState
*drv
)
2064 CharDriverState
*chr
;
2067 chr
= qemu_mallocz(sizeof(CharDriverState
));
2070 d
= qemu_mallocz(sizeof(MuxDriver
));
2079 chr
->chr_write
= mux_chr_write
;
2080 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
2081 chr
->chr_accept_input
= mux_chr_accept_input
;
2088 static void socket_cleanup(void)
2093 static int socket_init(void)
2098 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
2100 err
= WSAGetLastError();
2101 fprintf(stderr
, "WSAStartup: %d\n", err
);
2104 atexit(socket_cleanup
);
2108 static int send_all(int fd
, const uint8_t *buf
, int len1
)
2114 ret
= send(fd
, buf
, len
, 0);
2117 errno
= WSAGetLastError();
2118 if (errno
!= WSAEWOULDBLOCK
) {
2121 } else if (ret
== 0) {
2133 static int unix_write(int fd
, const uint8_t *buf
, int len1
)
2139 ret
= write(fd
, buf
, len
);
2141 if (errno
!= EINTR
&& errno
!= EAGAIN
)
2143 } else if (ret
== 0) {
2153 static inline int send_all(int fd
, const uint8_t *buf
, int len1
)
2155 return unix_write(fd
, buf
, len1
);
2157 #endif /* !_WIN32 */
2166 #define STDIO_MAX_CLIENTS 1
2167 static int stdio_nb_clients
= 0;
2169 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2171 FDCharDriver
*s
= chr
->opaque
;
2172 return unix_write(s
->fd_out
, buf
, len
);
2175 static int fd_chr_read_poll(void *opaque
)
2177 CharDriverState
*chr
= opaque
;
2178 FDCharDriver
*s
= chr
->opaque
;
2180 s
->max_size
= qemu_chr_can_read(chr
);
2184 static void fd_chr_read(void *opaque
)
2186 CharDriverState
*chr
= opaque
;
2187 FDCharDriver
*s
= chr
->opaque
;
2192 if (len
> s
->max_size
)
2196 size
= read(s
->fd_in
, buf
, len
);
2198 /* FD has been closed. Remove it from the active list. */
2199 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2203 qemu_chr_read(chr
, buf
, size
);
2207 static void fd_chr_update_read_handler(CharDriverState
*chr
)
2209 FDCharDriver
*s
= chr
->opaque
;
2211 if (s
->fd_in
>= 0) {
2212 if (nographic
&& s
->fd_in
== 0) {
2214 qemu_set_fd_handler2(s
->fd_in
, fd_chr_read_poll
,
2215 fd_chr_read
, NULL
, chr
);
2220 static void fd_chr_close(struct CharDriverState
*chr
)
2222 FDCharDriver
*s
= chr
->opaque
;
2224 if (s
->fd_in
>= 0) {
2225 if (nographic
&& s
->fd_in
== 0) {
2227 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2234 /* open a character device to a unix fd */
2235 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
)
2237 CharDriverState
*chr
;
2240 chr
= qemu_mallocz(sizeof(CharDriverState
));
2243 s
= qemu_mallocz(sizeof(FDCharDriver
));
2251 chr
->chr_write
= fd_chr_write
;
2252 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
2253 chr
->chr_close
= fd_chr_close
;
2255 qemu_chr_reset(chr
);
2260 static CharDriverState
*qemu_chr_open_file_out(const char *file_out
)
2264 TFR(fd_out
= open(file_out
, O_WRONLY
| O_TRUNC
| O_CREAT
| O_BINARY
, 0666));
2267 return qemu_chr_open_fd(-1, fd_out
);
2270 static CharDriverState
*qemu_chr_open_pipe(const char *filename
)
2273 char filename_in
[256], filename_out
[256];
2275 snprintf(filename_in
, 256, "%s.in", filename
);
2276 snprintf(filename_out
, 256, "%s.out", filename
);
2277 TFR(fd_in
= open(filename_in
, O_RDWR
| O_BINARY
));
2278 TFR(fd_out
= open(filename_out
, O_RDWR
| O_BINARY
));
2279 if (fd_in
< 0 || fd_out
< 0) {
2284 TFR(fd_in
= fd_out
= open(filename
, O_RDWR
| O_BINARY
));
2288 return qemu_chr_open_fd(fd_in
, fd_out
);
2292 /* for STDIO, we handle the case where several clients use it
2295 #define TERM_FIFO_MAX_SIZE 1
2297 static uint8_t term_fifo
[TERM_FIFO_MAX_SIZE
];
2298 static int term_fifo_size
;
2300 static int stdio_read_poll(void *opaque
)
2302 CharDriverState
*chr
= opaque
;
2304 /* try to flush the queue if needed */
2305 if (term_fifo_size
!= 0 && qemu_chr_can_read(chr
) > 0) {
2306 qemu_chr_read(chr
, term_fifo
, 1);
2309 /* see if we can absorb more chars */
2310 if (term_fifo_size
== 0)
2316 static void stdio_read(void *opaque
)
2320 CharDriverState
*chr
= opaque
;
2322 size
= read(0, buf
, 1);
2324 /* stdin has been closed. Remove it from the active list. */
2325 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2329 if (qemu_chr_can_read(chr
) > 0) {
2330 qemu_chr_read(chr
, buf
, 1);
2331 } else if (term_fifo_size
== 0) {
2332 term_fifo
[term_fifo_size
++] = buf
[0];
2337 /* init terminal so that we can grab keys */
2338 static struct termios oldtty
;
2339 static int old_fd0_flags
;
2340 static int term_atexit_done
;
2342 static void term_exit(void)
2344 tcsetattr (0, TCSANOW
, &oldtty
);
2345 fcntl(0, F_SETFL
, old_fd0_flags
);
2348 static void term_init(void)
2352 tcgetattr (0, &tty
);
2354 old_fd0_flags
= fcntl(0, F_GETFL
);
2356 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2357 |INLCR
|IGNCR
|ICRNL
|IXON
);
2358 tty
.c_oflag
|= OPOST
;
2359 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
2360 /* if graphical mode, we allow Ctrl-C handling */
2362 tty
.c_lflag
&= ~ISIG
;
2363 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
2366 tty
.c_cc
[VTIME
] = 0;
2368 tcsetattr (0, TCSANOW
, &tty
);
2370 if (!term_atexit_done
++)
2373 fcntl(0, F_SETFL
, O_NONBLOCK
);
2376 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
2380 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2384 static CharDriverState
*qemu_chr_open_stdio(void)
2386 CharDriverState
*chr
;
2388 if (stdio_nb_clients
>= STDIO_MAX_CLIENTS
)
2390 chr
= qemu_chr_open_fd(0, 1);
2391 chr
->chr_close
= qemu_chr_close_stdio
;
2392 qemu_set_fd_handler2(0, stdio_read_poll
, stdio_read
, NULL
, chr
);
2400 /* Once Solaris has openpty(), this is going to be removed. */
2401 int openpty(int *amaster
, int *aslave
, char *name
,
2402 struct termios
*termp
, struct winsize
*winp
)
2405 int mfd
= -1, sfd
= -1;
2407 *amaster
= *aslave
= -1;
2409 mfd
= open("/dev/ptmx", O_RDWR
| O_NOCTTY
);
2413 if (grantpt(mfd
) == -1 || unlockpt(mfd
) == -1)
2416 if ((slave
= ptsname(mfd
)) == NULL
)
2419 if ((sfd
= open(slave
, O_RDONLY
| O_NOCTTY
)) == -1)
2422 if (ioctl(sfd
, I_PUSH
, "ptem") == -1 ||
2423 (termp
!= NULL
&& tcgetattr(sfd
, termp
) < 0))
2431 ioctl(sfd
, TIOCSWINSZ
, winp
);
2442 void cfmakeraw (struct termios
*termios_p
)
2444 termios_p
->c_iflag
&=
2445 ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2446 termios_p
->c_oflag
&= ~OPOST
;
2447 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2448 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2449 termios_p
->c_cflag
|= CS8
;
2451 termios_p
->c_cc
[VMIN
] = 0;
2452 termios_p
->c_cc
[VTIME
] = 0;
2456 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2457 || defined(__NetBSD__) || defined(__OpenBSD__)
2467 static void pty_chr_update_read_handler(CharDriverState
*chr
);
2468 static void pty_chr_state(CharDriverState
*chr
, int connected
);
2470 static int pty_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2472 PtyCharDriver
*s
= chr
->opaque
;
2474 if (!s
->connected
) {
2475 /* guest sends data, check for (re-)connect */
2476 pty_chr_update_read_handler(chr
);
2479 return unix_write(s
->fd
, buf
, len
);
2482 static int pty_chr_read_poll(void *opaque
)
2484 CharDriverState
*chr
= opaque
;
2485 PtyCharDriver
*s
= chr
->opaque
;
2487 s
->read_bytes
= qemu_chr_can_read(chr
);
2488 return s
->read_bytes
;
2491 static void pty_chr_read(void *opaque
)
2493 CharDriverState
*chr
= opaque
;
2494 PtyCharDriver
*s
= chr
->opaque
;
2499 if (len
> s
->read_bytes
)
2500 len
= s
->read_bytes
;
2503 size
= read(s
->fd
, buf
, len
);
2504 if ((size
== -1 && errno
== EIO
) ||
2506 pty_chr_state(chr
, 0);
2510 pty_chr_state(chr
, 1);
2511 qemu_chr_read(chr
, buf
, size
);
2515 static void pty_chr_update_read_handler(CharDriverState
*chr
)
2517 PtyCharDriver
*s
= chr
->opaque
;
2519 qemu_set_fd_handler2(s
->fd
, pty_chr_read_poll
,
2520 pty_chr_read
, NULL
, chr
);
2523 * Short timeout here: just need wait long enougth that qemu makes
2524 * it through the poll loop once. When reconnected we want a
2525 * short timeout so we notice it almost instantly. Otherwise
2526 * read() gives us -EIO instantly, making pty_chr_state() reset the
2527 * timeout to the normal (much longer) poll interval before the
2530 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 10);
2533 static void pty_chr_state(CharDriverState
*chr
, int connected
)
2535 PtyCharDriver
*s
= chr
->opaque
;
2538 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2541 /* (re-)connect poll interval for idle guests: once per second.
2542 * We check more frequently in case the guests sends data to
2543 * the virtual device linked to our pty. */
2544 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 1000);
2547 qemu_chr_reset(chr
);
2552 static void pty_chr_timer(void *opaque
)
2554 struct CharDriverState
*chr
= opaque
;
2555 PtyCharDriver
*s
= chr
->opaque
;
2560 /* If we arrive here without polling being cleared due
2561 * read returning -EIO, then we are (re-)connected */
2562 pty_chr_state(chr
, 1);
2567 pty_chr_update_read_handler(chr
);
2570 static void pty_chr_close(struct CharDriverState
*chr
)
2572 PtyCharDriver
*s
= chr
->opaque
;
2574 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2579 static CharDriverState
*qemu_chr_open_pty(void)
2581 CharDriverState
*chr
;
2585 #if defined(__OpenBSD__)
2586 char pty_name
[PATH_MAX
];
2587 #define q_ptsname(x) pty_name
2589 char *pty_name
= NULL
;
2590 #define q_ptsname(x) ptsname(x)
2593 chr
= qemu_mallocz(sizeof(CharDriverState
));
2596 s
= qemu_mallocz(sizeof(PtyCharDriver
));
2602 if (openpty(&s
->fd
, &slave_fd
, pty_name
, NULL
, NULL
) < 0) {
2606 /* Set raw attributes on the pty. */
2608 tcsetattr(slave_fd
, TCSAFLUSH
, &tty
);
2611 len
= strlen(q_ptsname(s
->fd
)) + 5;
2612 chr
->filename
= qemu_malloc(len
);
2613 snprintf(chr
->filename
, len
, "pty:%s", q_ptsname(s
->fd
));
2614 fprintf(stderr
, "char device redirected to %s\n", q_ptsname(s
->fd
));
2617 chr
->chr_write
= pty_chr_write
;
2618 chr
->chr_update_read_handler
= pty_chr_update_read_handler
;
2619 chr
->chr_close
= pty_chr_close
;
2621 s
->timer
= qemu_new_timer(rt_clock
, pty_chr_timer
, chr
);
2626 static void tty_serial_init(int fd
, int speed
,
2627 int parity
, int data_bits
, int stop_bits
)
2633 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2634 speed
, parity
, data_bits
, stop_bits
);
2636 tcgetattr (fd
, &tty
);
2639 if (speed
<= 50 * MARGIN
)
2641 else if (speed
<= 75 * MARGIN
)
2643 else if (speed
<= 300 * MARGIN
)
2645 else if (speed
<= 600 * MARGIN
)
2647 else if (speed
<= 1200 * MARGIN
)
2649 else if (speed
<= 2400 * MARGIN
)
2651 else if (speed
<= 4800 * MARGIN
)
2653 else if (speed
<= 9600 * MARGIN
)
2655 else if (speed
<= 19200 * MARGIN
)
2657 else if (speed
<= 38400 * MARGIN
)
2659 else if (speed
<= 57600 * MARGIN
)
2661 else if (speed
<= 115200 * MARGIN
)
2666 cfsetispeed(&tty
, spd
);
2667 cfsetospeed(&tty
, spd
);
2669 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2670 |INLCR
|IGNCR
|ICRNL
|IXON
);
2671 tty
.c_oflag
|= OPOST
;
2672 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
2673 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
2694 tty
.c_cflag
|= PARENB
;
2697 tty
.c_cflag
|= PARENB
| PARODD
;
2701 tty
.c_cflag
|= CSTOPB
;
2703 tcsetattr (fd
, TCSANOW
, &tty
);
2706 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2708 FDCharDriver
*s
= chr
->opaque
;
2711 case CHR_IOCTL_SERIAL_SET_PARAMS
:
2713 QEMUSerialSetParams
*ssp
= arg
;
2714 tty_serial_init(s
->fd_in
, ssp
->speed
, ssp
->parity
,
2715 ssp
->data_bits
, ssp
->stop_bits
);
2718 case CHR_IOCTL_SERIAL_SET_BREAK
:
2720 int enable
= *(int *)arg
;
2722 tcsendbreak(s
->fd_in
, 1);
2725 case CHR_IOCTL_SERIAL_GET_TIOCM
:
2728 int *targ
= (int *)arg
;
2729 ioctl(s
->fd_in
, TIOCMGET
, &sarg
);
2731 if (sarg
| TIOCM_CTS
)
2732 *targ
|= CHR_TIOCM_CTS
;
2733 if (sarg
| TIOCM_CAR
)
2734 *targ
|= CHR_TIOCM_CAR
;
2735 if (sarg
| TIOCM_DSR
)
2736 *targ
|= CHR_TIOCM_DSR
;
2737 if (sarg
| TIOCM_RI
)
2738 *targ
|= CHR_TIOCM_RI
;
2739 if (sarg
| TIOCM_DTR
)
2740 *targ
|= CHR_TIOCM_DTR
;
2741 if (sarg
| TIOCM_RTS
)
2742 *targ
|= CHR_TIOCM_RTS
;
2745 case CHR_IOCTL_SERIAL_SET_TIOCM
:
2747 int sarg
= *(int *)arg
;
2749 if (sarg
| CHR_TIOCM_DTR
)
2751 if (sarg
| CHR_TIOCM_RTS
)
2753 ioctl(s
->fd_in
, TIOCMSET
, &targ
);
2762 static CharDriverState
*qemu_chr_open_tty(const char *filename
)
2764 CharDriverState
*chr
;
2767 TFR(fd
= open(filename
, O_RDWR
| O_NONBLOCK
));
2768 tty_serial_init(fd
, 115200, 'N', 8, 1);
2769 chr
= qemu_chr_open_fd(fd
, fd
);
2774 chr
->chr_ioctl
= tty_serial_ioctl
;
2775 qemu_chr_reset(chr
);
2778 #else /* ! __linux__ && ! __sun__ */
2779 static CharDriverState
*qemu_chr_open_pty(void)
2783 #endif /* __linux__ || __sun__ */
2785 #if defined(__linux__)
2789 } ParallelCharDriver
;
2791 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
2793 if (s
->mode
!= mode
) {
2795 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
2802 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2804 ParallelCharDriver
*drv
= chr
->opaque
;
2809 case CHR_IOCTL_PP_READ_DATA
:
2810 if (ioctl(fd
, PPRDATA
, &b
) < 0)
2812 *(uint8_t *)arg
= b
;
2814 case CHR_IOCTL_PP_WRITE_DATA
:
2815 b
= *(uint8_t *)arg
;
2816 if (ioctl(fd
, PPWDATA
, &b
) < 0)
2819 case CHR_IOCTL_PP_READ_CONTROL
:
2820 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
2822 /* Linux gives only the lowest bits, and no way to know data
2823 direction! For better compatibility set the fixed upper
2825 *(uint8_t *)arg
= b
| 0xc0;
2827 case CHR_IOCTL_PP_WRITE_CONTROL
:
2828 b
= *(uint8_t *)arg
;
2829 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
2832 case CHR_IOCTL_PP_READ_STATUS
:
2833 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
2835 *(uint8_t *)arg
= b
;
2837 case CHR_IOCTL_PP_DATA_DIR
:
2838 if (ioctl(fd
, PPDATADIR
, (int *)arg
) < 0)
2841 case CHR_IOCTL_PP_EPP_READ_ADDR
:
2842 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2843 struct ParallelIOArg
*parg
= arg
;
2844 int n
= read(fd
, parg
->buffer
, parg
->count
);
2845 if (n
!= parg
->count
) {
2850 case CHR_IOCTL_PP_EPP_READ
:
2851 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2852 struct ParallelIOArg
*parg
= arg
;
2853 int n
= read(fd
, parg
->buffer
, parg
->count
);
2854 if (n
!= parg
->count
) {
2859 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
2860 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2861 struct ParallelIOArg
*parg
= arg
;
2862 int n
= write(fd
, parg
->buffer
, parg
->count
);
2863 if (n
!= parg
->count
) {
2868 case CHR_IOCTL_PP_EPP_WRITE
:
2869 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2870 struct ParallelIOArg
*parg
= arg
;
2871 int n
= write(fd
, parg
->buffer
, parg
->count
);
2872 if (n
!= parg
->count
) {
2883 static void pp_close(CharDriverState
*chr
)
2885 ParallelCharDriver
*drv
= chr
->opaque
;
2888 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
2889 ioctl(fd
, PPRELEASE
);
2894 static CharDriverState
*qemu_chr_open_pp(const char *filename
)
2896 CharDriverState
*chr
;
2897 ParallelCharDriver
*drv
;
2900 TFR(fd
= open(filename
, O_RDWR
));
2904 if (ioctl(fd
, PPCLAIM
) < 0) {
2909 drv
= qemu_mallocz(sizeof(ParallelCharDriver
));
2915 drv
->mode
= IEEE1284_MODE_COMPAT
;
2917 chr
= qemu_mallocz(sizeof(CharDriverState
));
2923 chr
->chr_write
= null_chr_write
;
2924 chr
->chr_ioctl
= pp_ioctl
;
2925 chr
->chr_close
= pp_close
;
2928 qemu_chr_reset(chr
);
2932 #endif /* __linux__ */
2938 HANDLE hcom
, hrecv
, hsend
;
2939 OVERLAPPED orecv
, osend
;
2944 #define NSENDBUF 2048
2945 #define NRECVBUF 2048
2946 #define MAXCONNECT 1
2947 #define NTIMEOUT 5000
2949 static int win_chr_poll(void *opaque
);
2950 static int win_chr_pipe_poll(void *opaque
);
2952 static void win_chr_close(CharDriverState
*chr
)
2954 WinCharState
*s
= chr
->opaque
;
2957 CloseHandle(s
->hsend
);
2961 CloseHandle(s
->hrecv
);
2965 CloseHandle(s
->hcom
);
2969 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
2971 qemu_del_polling_cb(win_chr_poll
, chr
);
2974 static int win_chr_init(CharDriverState
*chr
, const char *filename
)
2976 WinCharState
*s
= chr
->opaque
;
2978 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
2983 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2985 fprintf(stderr
, "Failed CreateEvent\n");
2988 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2990 fprintf(stderr
, "Failed CreateEvent\n");
2994 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
2995 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
2996 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
2997 fprintf(stderr
, "Failed CreateFile (%lu)\n", GetLastError());
3002 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
3003 fprintf(stderr
, "Failed SetupComm\n");
3007 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
3008 size
= sizeof(COMMCONFIG
);
3009 GetDefaultCommConfig(filename
, &comcfg
, &size
);
3010 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
3011 CommConfigDialog(filename
, NULL
, &comcfg
);
3013 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
3014 fprintf(stderr
, "Failed SetCommState\n");
3018 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
3019 fprintf(stderr
, "Failed SetCommMask\n");
3023 cto
.ReadIntervalTimeout
= MAXDWORD
;
3024 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
3025 fprintf(stderr
, "Failed SetCommTimeouts\n");
3029 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
3030 fprintf(stderr
, "Failed ClearCommError\n");
3033 qemu_add_polling_cb(win_chr_poll
, chr
);
3041 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
3043 WinCharState
*s
= chr
->opaque
;
3044 DWORD len
, ret
, size
, err
;
3047 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
3048 s
->osend
.hEvent
= s
->hsend
;
3051 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
3053 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
3055 err
= GetLastError();
3056 if (err
== ERROR_IO_PENDING
) {
3057 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
3075 static int win_chr_read_poll(CharDriverState
*chr
)
3077 WinCharState
*s
= chr
->opaque
;
3079 s
->max_size
= qemu_chr_can_read(chr
);
3083 static void win_chr_readfile(CharDriverState
*chr
)
3085 WinCharState
*s
= chr
->opaque
;
3090 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
3091 s
->orecv
.hEvent
= s
->hrecv
;
3092 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
3094 err
= GetLastError();
3095 if (err
== ERROR_IO_PENDING
) {
3096 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
3101 qemu_chr_read(chr
, buf
, size
);
3105 static void win_chr_read(CharDriverState
*chr
)
3107 WinCharState
*s
= chr
->opaque
;
3109 if (s
->len
> s
->max_size
)
3110 s
->len
= s
->max_size
;
3114 win_chr_readfile(chr
);
3117 static int win_chr_poll(void *opaque
)
3119 CharDriverState
*chr
= opaque
;
3120 WinCharState
*s
= chr
->opaque
;
3124 ClearCommError(s
->hcom
, &comerr
, &status
);
3125 if (status
.cbInQue
> 0) {
3126 s
->len
= status
.cbInQue
;
3127 win_chr_read_poll(chr
);
3134 static CharDriverState
*qemu_chr_open_win(const char *filename
)
3136 CharDriverState
*chr
;
3139 chr
= qemu_mallocz(sizeof(CharDriverState
));
3142 s
= qemu_mallocz(sizeof(WinCharState
));
3148 chr
->chr_write
= win_chr_write
;
3149 chr
->chr_close
= win_chr_close
;
3151 if (win_chr_init(chr
, filename
) < 0) {
3156 qemu_chr_reset(chr
);
3160 static int win_chr_pipe_poll(void *opaque
)
3162 CharDriverState
*chr
= opaque
;
3163 WinCharState
*s
= chr
->opaque
;
3166 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
3169 win_chr_read_poll(chr
);
3176 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
)
3178 WinCharState
*s
= chr
->opaque
;
3186 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3188 fprintf(stderr
, "Failed CreateEvent\n");
3191 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3193 fprintf(stderr
, "Failed CreateEvent\n");
3197 snprintf(openname
, sizeof(openname
), "\\\\.\\pipe\\%s", filename
);
3198 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
3199 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
3201 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
3202 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3203 fprintf(stderr
, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3208 ZeroMemory(&ov
, sizeof(ov
));
3209 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3210 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
3212 fprintf(stderr
, "Failed ConnectNamedPipe\n");
3216 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
3218 fprintf(stderr
, "Failed GetOverlappedResult\n");
3220 CloseHandle(ov
.hEvent
);
3227 CloseHandle(ov
.hEvent
);
3230 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
3239 static CharDriverState
*qemu_chr_open_win_pipe(const char *filename
)
3241 CharDriverState
*chr
;
3244 chr
= qemu_mallocz(sizeof(CharDriverState
));
3247 s
= qemu_mallocz(sizeof(WinCharState
));
3253 chr
->chr_write
= win_chr_write
;
3254 chr
->chr_close
= win_chr_close
;
3256 if (win_chr_pipe_init(chr
, filename
) < 0) {
3261 qemu_chr_reset(chr
);
3265 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
)
3267 CharDriverState
*chr
;
3270 chr
= qemu_mallocz(sizeof(CharDriverState
));
3273 s
= qemu_mallocz(sizeof(WinCharState
));
3280 chr
->chr_write
= win_chr_write
;
3281 qemu_chr_reset(chr
);
3285 static CharDriverState
*qemu_chr_open_win_con(const char *filename
)
3287 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
));
3290 static CharDriverState
*qemu_chr_open_win_file_out(const char *file_out
)
3294 fd_out
= CreateFile(file_out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
3295 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3296 if (fd_out
== INVALID_HANDLE_VALUE
)
3299 return qemu_chr_open_win_file(fd_out
);
3301 #endif /* !_WIN32 */
3303 /***********************************************************/
3304 /* UDP Net console */
3308 struct sockaddr_in daddr
;
3315 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3317 NetCharDriver
*s
= chr
->opaque
;
3319 return sendto(s
->fd
, buf
, len
, 0,
3320 (struct sockaddr
*)&s
->daddr
, sizeof(struct sockaddr_in
));
3323 static int udp_chr_read_poll(void *opaque
)
3325 CharDriverState
*chr
= opaque
;
3326 NetCharDriver
*s
= chr
->opaque
;
3328 s
->max_size
= qemu_chr_can_read(chr
);
3330 /* If there were any stray characters in the queue process them
3333 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3334 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3336 s
->max_size
= qemu_chr_can_read(chr
);
3341 static void udp_chr_read(void *opaque
)
3343 CharDriverState
*chr
= opaque
;
3344 NetCharDriver
*s
= chr
->opaque
;
3346 if (s
->max_size
== 0)
3348 s
->bufcnt
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
3349 s
->bufptr
= s
->bufcnt
;
3354 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3355 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3357 s
->max_size
= qemu_chr_can_read(chr
);
3361 static void udp_chr_update_read_handler(CharDriverState
*chr
)
3363 NetCharDriver
*s
= chr
->opaque
;
3366 qemu_set_fd_handler2(s
->fd
, udp_chr_read_poll
,
3367 udp_chr_read
, NULL
, chr
);
3372 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
);
3374 int parse_host_src_port(struct sockaddr_in
*haddr
,
3375 struct sockaddr_in
*saddr
,
3378 static CharDriverState
*qemu_chr_open_udp(const char *def
)
3380 CharDriverState
*chr
= NULL
;
3381 NetCharDriver
*s
= NULL
;
3383 struct sockaddr_in saddr
;
3385 chr
= qemu_mallocz(sizeof(CharDriverState
));
3388 s
= qemu_mallocz(sizeof(NetCharDriver
));
3392 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
3394 perror("socket(PF_INET, SOCK_DGRAM)");
3398 if (parse_host_src_port(&s
->daddr
, &saddr
, def
) < 0) {
3399 printf("Could not parse: %s\n", def
);
3403 if (bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
)) < 0)
3413 chr
->chr_write
= udp_chr_write
;
3414 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
3427 /***********************************************************/
3428 /* TCP Net console */
3439 static void tcp_chr_accept(void *opaque
);
3441 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3443 TCPCharDriver
*s
= chr
->opaque
;
3445 return send_all(s
->fd
, buf
, len
);
3447 /* XXX: indicate an error ? */
3452 static int tcp_chr_read_poll(void *opaque
)
3454 CharDriverState
*chr
= opaque
;
3455 TCPCharDriver
*s
= chr
->opaque
;
3458 s
->max_size
= qemu_chr_can_read(chr
);
3463 #define IAC_BREAK 243
3464 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
3466 uint8_t *buf
, int *size
)
3468 /* Handle any telnet client's basic IAC options to satisfy char by
3469 * char mode with no echo. All IAC options will be removed from
3470 * the buf and the do_telnetopt variable will be used to track the
3471 * state of the width of the IAC information.
3473 * IAC commands come in sets of 3 bytes with the exception of the
3474 * "IAC BREAK" command and the double IAC.
3480 for (i
= 0; i
< *size
; i
++) {
3481 if (s
->do_telnetopt
> 1) {
3482 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
3483 /* Double IAC means send an IAC */
3487 s
->do_telnetopt
= 1;
3489 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
3490 /* Handle IAC break commands by sending a serial break */
3491 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
3496 if (s
->do_telnetopt
>= 4) {
3497 s
->do_telnetopt
= 1;
3500 if ((unsigned char)buf
[i
] == IAC
) {
3501 s
->do_telnetopt
= 2;
3512 static void tcp_chr_read(void *opaque
)
3514 CharDriverState
*chr
= opaque
;
3515 TCPCharDriver
*s
= chr
->opaque
;
3519 if (!s
->connected
|| s
->max_size
<= 0)
3522 if (len
> s
->max_size
)
3524 size
= recv(s
->fd
, buf
, len
, 0);
3526 /* connection closed */
3528 if (s
->listen_fd
>= 0) {
3529 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3531 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
3534 } else if (size
> 0) {
3535 if (s
->do_telnetopt
)
3536 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
3538 qemu_chr_read(chr
, buf
, size
);
3542 static void tcp_chr_connect(void *opaque
)
3544 CharDriverState
*chr
= opaque
;
3545 TCPCharDriver
*s
= chr
->opaque
;
3548 qemu_set_fd_handler2(s
->fd
, tcp_chr_read_poll
,
3549 tcp_chr_read
, NULL
, chr
);
3550 qemu_chr_reset(chr
);
3553 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3554 static void tcp_chr_telnet_init(int fd
)
3557 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3558 IACSET(buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3559 send(fd
, (char *)buf
, 3, 0);
3560 IACSET(buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3561 send(fd
, (char *)buf
, 3, 0);
3562 IACSET(buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3563 send(fd
, (char *)buf
, 3, 0);
3564 IACSET(buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3565 send(fd
, (char *)buf
, 3, 0);
3568 static void socket_set_nodelay(int fd
)
3571 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
3574 static void tcp_chr_accept(void *opaque
)
3576 CharDriverState
*chr
= opaque
;
3577 TCPCharDriver
*s
= chr
->opaque
;
3578 struct sockaddr_in saddr
;
3580 struct sockaddr_un uaddr
;
3582 struct sockaddr
*addr
;
3589 len
= sizeof(uaddr
);
3590 addr
= (struct sockaddr
*)&uaddr
;
3594 len
= sizeof(saddr
);
3595 addr
= (struct sockaddr
*)&saddr
;
3597 fd
= accept(s
->listen_fd
, addr
, &len
);
3598 if (fd
< 0 && errno
!= EINTR
) {
3600 } else if (fd
>= 0) {
3601 if (s
->do_telnetopt
)
3602 tcp_chr_telnet_init(fd
);
3606 socket_set_nonblock(fd
);
3608 socket_set_nodelay(fd
);
3610 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
3611 tcp_chr_connect(chr
);
3614 static void tcp_chr_close(CharDriverState
*chr
)
3616 TCPCharDriver
*s
= chr
->opaque
;
3619 if (s
->listen_fd
>= 0)
3620 closesocket(s
->listen_fd
);
3624 static CharDriverState
*qemu_chr_open_tcp(const char *host_str
,
3628 CharDriverState
*chr
= NULL
;
3629 TCPCharDriver
*s
= NULL
;
3630 int fd
= -1, ret
, err
, val
;
3632 int is_waitconnect
= 1;
3635 struct sockaddr_in saddr
;
3637 struct sockaddr_un uaddr
;
3639 struct sockaddr
*addr
;
3644 addr
= (struct sockaddr
*)&uaddr
;
3645 addrlen
= sizeof(uaddr
);
3646 if (parse_unix_path(&uaddr
, host_str
) < 0)
3651 addr
= (struct sockaddr
*)&saddr
;
3652 addrlen
= sizeof(saddr
);
3653 if (parse_host_port(&saddr
, host_str
) < 0)
3658 while((ptr
= strchr(ptr
,','))) {
3660 if (!strncmp(ptr
,"server",6)) {
3662 } else if (!strncmp(ptr
,"nowait",6)) {
3664 } else if (!strncmp(ptr
,"nodelay",6)) {
3667 printf("Unknown option: %s\n", ptr
);
3674 chr
= qemu_mallocz(sizeof(CharDriverState
));
3677 s
= qemu_mallocz(sizeof(TCPCharDriver
));
3683 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
3686 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
3691 if (!is_waitconnect
)
3692 socket_set_nonblock(fd
);
3697 s
->is_unix
= is_unix
;
3698 s
->do_nodelay
= do_nodelay
&& !is_unix
;
3701 chr
->chr_write
= tcp_chr_write
;
3702 chr
->chr_close
= tcp_chr_close
;
3705 /* allow fast reuse */
3709 pstrcpy(path
, sizeof(path
), uaddr
.sun_path
);
3715 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
3718 ret
= bind(fd
, addr
, addrlen
);
3722 ret
= listen(fd
, 0);
3727 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3729 s
->do_telnetopt
= 1;
3732 ret
= connect(fd
, addr
, addrlen
);
3734 err
= socket_error();
3735 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
3736 } else if (err
== EINPROGRESS
) {
3739 } else if (err
== WSAEALREADY
) {
3751 socket_set_nodelay(fd
);
3753 tcp_chr_connect(chr
);
3755 qemu_set_fd_handler(s
->fd
, NULL
, tcp_chr_connect
, chr
);
3758 if (is_listen
&& is_waitconnect
) {
3759 printf("QEMU waiting for connection on: %s\n", host_str
);
3760 tcp_chr_accept(chr
);
3761 socket_set_nonblock(s
->listen_fd
);
3773 static TAILQ_HEAD(CharDriverStateHead
, CharDriverState
) chardevs
3774 = TAILQ_HEAD_INITIALIZER(chardevs
);
3776 CharDriverState
*qemu_chr_open(const char *label
, const char *filename
)
3779 CharDriverState
*chr
;
3781 if (!strcmp(filename
, "vc")) {
3782 chr
= text_console_init(&display_state
, 0);
3784 if (strstart(filename
, "vc:", &p
)) {
3785 chr
= text_console_init(&display_state
, p
);
3787 if (!strcmp(filename
, "null")) {
3788 chr
= qemu_chr_open_null();
3790 if (strstart(filename
, "tcp:", &p
)) {
3791 chr
= qemu_chr_open_tcp(p
, 0, 0);
3793 if (strstart(filename
, "telnet:", &p
)) {
3794 chr
= qemu_chr_open_tcp(p
, 1, 0);
3796 if (strstart(filename
, "udp:", &p
)) {
3797 chr
= qemu_chr_open_udp(p
);
3799 if (strstart(filename
, "mon:", &p
)) {
3800 chr
= qemu_chr_open(label
, p
);
3802 chr
= qemu_chr_open_mux(chr
);
3803 monitor_init(chr
, !nographic
);
3805 printf("Unable to open driver: %s\n", p
);
3809 if (strstart(filename
, "unix:", &p
)) {
3810 chr
= qemu_chr_open_tcp(p
, 0, 1);
3811 } else if (strstart(filename
, "file:", &p
)) {
3812 chr
= qemu_chr_open_file_out(p
);
3813 } else if (strstart(filename
, "pipe:", &p
)) {
3814 chr
= qemu_chr_open_pipe(p
);
3815 } else if (!strcmp(filename
, "pty")) {
3816 chr
= qemu_chr_open_pty();
3817 } else if (!strcmp(filename
, "stdio")) {
3818 chr
= qemu_chr_open_stdio();
3820 #if defined(__linux__)
3821 if (strstart(filename
, "/dev/parport", NULL
)) {
3822 chr
= 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 chr
= qemu_chr_open_tty(filename
);
3832 if (strstart(filename
, "COM", NULL
)) {
3833 chr
= qemu_chr_open_win(filename
);
3835 if (strstart(filename
, "pipe:", &p
)) {
3836 chr
= qemu_chr_open_win_pipe(p
);
3838 if (strstart(filename
, "con:", NULL
)) {
3839 chr
= qemu_chr_open_win_con(filename
);
3841 if (strstart(filename
, "file:", &p
)) {
3842 chr
= qemu_chr_open_win_file_out(p
);
3845 #ifdef CONFIG_BRLAPI
3846 if (!strcmp(filename
, "braille")) {
3847 chr
= chr_baum_init();
3856 chr
->filename
= qemu_strdup(filename
);
3857 chr
->label
= qemu_strdup(label
);
3858 TAILQ_INSERT_TAIL(&chardevs
, chr
, next
);
3863 void qemu_chr_close(CharDriverState
*chr
)
3865 TAILQ_REMOVE(&chardevs
, chr
, next
);
3867 chr
->chr_close(chr
);
3868 qemu_free(chr
->filename
);
3869 qemu_free(chr
->label
);
3873 void qemu_chr_info(void)
3875 CharDriverState
*chr
;
3877 TAILQ_FOREACH(chr
, &chardevs
, next
) {
3878 term_printf("%s: filename=%s\n", chr
->label
, chr
->filename
);
3882 /***********************************************************/
3883 /* network device redirectors */
3885 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
3886 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
3890 for(i
=0;i
<size
;i
+=16) {
3894 fprintf(f
, "%08x ", i
);
3897 fprintf(f
, " %02x", buf
[i
+j
]);
3902 for(j
=0;j
<len
;j
++) {
3904 if (c
< ' ' || c
> '~')
3906 fprintf(f
, "%c", c
);
3913 static int parse_macaddr(uint8_t *macaddr
, const char *p
)
3920 offset
= strtol(p
, &last_char
, 0);
3921 if (0 == errno
&& '\0' == *last_char
&&
3922 offset
>= 0 && offset
<= 0xFFFFFF) {
3923 macaddr
[3] = (offset
& 0xFF0000) >> 16;
3924 macaddr
[4] = (offset
& 0xFF00) >> 8;
3925 macaddr
[5] = offset
& 0xFF;
3928 for(i
= 0; i
< 6; i
++) {
3929 macaddr
[i
] = strtol(p
, (char **)&p
, 16);
3934 if (*p
!= ':' && *p
!= '-')
3945 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
3950 p1
= strchr(p
, sep
);
3956 if (len
> buf_size
- 1)
3958 memcpy(buf
, p
, len
);
3965 int parse_host_src_port(struct sockaddr_in
*haddr
,
3966 struct sockaddr_in
*saddr
,
3967 const char *input_str
)
3969 char *str
= strdup(input_str
);
3970 char *host_str
= str
;
3972 const char *src_str2
;
3976 * Chop off any extra arguments at the end of the string which
3977 * would start with a comma, then fill in the src port information
3978 * if it was provided else use the "any address" and "any port".
3980 if ((ptr
= strchr(str
,',')))
3983 if ((src_str
= strchr(input_str
,'@'))) {
3988 if (parse_host_port(haddr
, host_str
) < 0)
3992 if (!src_str
|| *src_str
== '\0')
3995 if (parse_host_port(saddr
, src_str2
) < 0)
4006 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
4014 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4016 saddr
->sin_family
= AF_INET
;
4017 if (buf
[0] == '\0') {
4018 saddr
->sin_addr
.s_addr
= 0;
4020 if (isdigit(buf
[0])) {
4021 if (!inet_aton(buf
, &saddr
->sin_addr
))
4024 if ((he
= gethostbyname(buf
)) == NULL
)
4026 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
4029 port
= strtol(p
, (char **)&r
, 0);
4032 saddr
->sin_port
= htons(port
);
4037 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
)
4042 len
= MIN(108, strlen(str
));
4043 p
= strchr(str
, ',');
4045 len
= MIN(len
, p
- str
);
4047 memset(uaddr
, 0, sizeof(*uaddr
));
4049 uaddr
->sun_family
= AF_UNIX
;
4050 memcpy(uaddr
->sun_path
, str
, len
);
4056 /* find or alloc a new VLAN */
4057 VLANState
*qemu_find_vlan(int id
)
4059 VLANState
**pvlan
, *vlan
;
4060 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
4064 vlan
= qemu_mallocz(sizeof(VLANState
));
4069 pvlan
= &first_vlan
;
4070 while (*pvlan
!= NULL
)
4071 pvlan
= &(*pvlan
)->next
;
4076 VLANClientState
*qemu_new_vlan_client(VLANState
*vlan
,
4077 IOReadHandler
*fd_read
,
4078 IOCanRWHandler
*fd_can_read
,
4081 VLANClientState
*vc
, **pvc
;
4082 vc
= qemu_mallocz(sizeof(VLANClientState
));
4085 vc
->fd_read
= fd_read
;
4086 vc
->fd_can_read
= fd_can_read
;
4087 vc
->opaque
= opaque
;
4091 pvc
= &vlan
->first_client
;
4092 while (*pvc
!= NULL
)
4093 pvc
= &(*pvc
)->next
;
4098 void qemu_del_vlan_client(VLANClientState
*vc
)
4100 VLANClientState
**pvc
= &vc
->vlan
->first_client
;
4102 while (*pvc
!= NULL
)
4108 pvc
= &(*pvc
)->next
;
4111 int qemu_can_send_packet(VLANClientState
*vc1
)
4113 VLANState
*vlan
= vc1
->vlan
;
4114 VLANClientState
*vc
;
4116 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4118 if (vc
->fd_can_read
&& vc
->fd_can_read(vc
->opaque
))
4125 void qemu_send_packet(VLANClientState
*vc1
, const uint8_t *buf
, int size
)
4127 VLANState
*vlan
= vc1
->vlan
;
4128 VLANClientState
*vc
;
4131 printf("vlan %d send:\n", vlan
->id
);
4132 hex_dump(stdout
, buf
, size
);
4134 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4136 vc
->fd_read(vc
->opaque
, buf
, size
);
4141 #if defined(CONFIG_SLIRP)
4143 /* slirp network adapter */
4145 static int slirp_inited
;
4146 static VLANClientState
*slirp_vc
;
4148 int slirp_can_output(void)
4150 return !slirp_vc
|| qemu_can_send_packet(slirp_vc
);
4153 void slirp_output(const uint8_t *pkt
, int pkt_len
)
4156 printf("slirp output:\n");
4157 hex_dump(stdout
, pkt
, pkt_len
);
4161 qemu_send_packet(slirp_vc
, pkt
, pkt_len
);
4164 static void slirp_receive(void *opaque
, const uint8_t *buf
, int size
)
4167 printf("slirp input:\n");
4168 hex_dump(stdout
, buf
, size
);
4170 slirp_input(buf
, size
);
4173 static int net_slirp_init(VLANState
*vlan
)
4175 if (!slirp_inited
) {
4179 slirp_vc
= qemu_new_vlan_client(vlan
,
4180 slirp_receive
, NULL
, NULL
);
4181 snprintf(slirp_vc
->info_str
, sizeof(slirp_vc
->info_str
), "user redirector");
4185 static void net_slirp_redir(const char *redir_str
)
4190 struct in_addr guest_addr
;
4191 int host_port
, guest_port
;
4193 if (!slirp_inited
) {
4199 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4201 if (!strcmp(buf
, "tcp")) {
4203 } else if (!strcmp(buf
, "udp")) {
4209 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4211 host_port
= strtol(buf
, &r
, 0);
4215 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4217 if (buf
[0] == '\0') {
4218 pstrcpy(buf
, sizeof(buf
), "10.0.2.15");
4220 if (!inet_aton(buf
, &guest_addr
))
4223 guest_port
= strtol(p
, &r
, 0);
4227 if (slirp_redir(is_udp
, host_port
, guest_addr
, guest_port
) < 0) {
4228 fprintf(stderr
, "qemu: could not set up redirection\n");
4233 fprintf(stderr
, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4239 static char smb_dir
[1024];
4241 static void erase_dir(char *dir_name
)
4245 char filename
[1024];
4247 /* erase all the files in the directory */
4248 if ((d
= opendir(dir_name
)) != 0) {
4253 if (strcmp(de
->d_name
, ".") != 0 &&
4254 strcmp(de
->d_name
, "..") != 0) {
4255 snprintf(filename
, sizeof(filename
), "%s/%s",
4256 smb_dir
, de
->d_name
);
4257 if (unlink(filename
) != 0) /* is it a directory? */
4258 erase_dir(filename
);
4266 /* automatic user mode samba server configuration */
4267 static void smb_exit(void)
4272 /* automatic user mode samba server configuration */
4273 static void net_slirp_smb(const char *exported_dir
)
4275 char smb_conf
[1024];
4276 char smb_cmdline
[1024];
4279 if (!slirp_inited
) {
4284 /* XXX: better tmp dir construction */
4285 snprintf(smb_dir
, sizeof(smb_dir
), "/tmp/qemu-smb.%d", getpid());
4286 if (mkdir(smb_dir
, 0700) < 0) {
4287 fprintf(stderr
, "qemu: could not create samba server dir '%s'\n", smb_dir
);
4290 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", smb_dir
, "smb.conf");
4292 f
= fopen(smb_conf
, "w");
4294 fprintf(stderr
, "qemu: could not create samba server configuration file '%s'\n", smb_conf
);
4301 "socket address=127.0.0.1\n"
4302 "pid directory=%s\n"
4303 "lock directory=%s\n"
4304 "log file=%s/log.smbd\n"
4305 "smb passwd file=%s/smbpasswd\n"
4306 "security = share\n"
4321 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -s %s",
4322 SMBD_COMMAND
, smb_conf
);
4324 slirp_add_exec(0, smb_cmdline
, 4, 139);
4327 #endif /* !defined(_WIN32) */
4328 void do_info_slirp(void)
4333 #endif /* CONFIG_SLIRP */
4335 #if !defined(_WIN32)
4337 typedef struct TAPState
{
4338 VLANClientState
*vc
;
4340 char down_script
[1024];
4343 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
4345 TAPState
*s
= opaque
;
4348 ret
= write(s
->fd
, buf
, size
);
4349 if (ret
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
4356 static void tap_send(void *opaque
)
4358 TAPState
*s
= opaque
;
4365 sbuf
.maxlen
= sizeof(buf
);
4367 size
= getmsg(s
->fd
, NULL
, &sbuf
, &f
) >=0 ? sbuf
.len
: -1;
4369 size
= read(s
->fd
, buf
, sizeof(buf
));
4372 qemu_send_packet(s
->vc
, buf
, size
);
4378 static TAPState
*net_tap_fd_init(VLANState
*vlan
, int fd
)
4382 s
= qemu_mallocz(sizeof(TAPState
));
4386 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
4387 qemu_set_fd_handler(s
->fd
, tap_send
, NULL
, s
);
4388 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "tap: fd=%d", fd
);
4392 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4393 static int tap_open(char *ifname
, int ifname_size
)
4399 TFR(fd
= open("/dev/tap", O_RDWR
));
4401 fprintf(stderr
, "warning: could not open /dev/tap: no virtual network emulation\n");
4406 dev
= devname(s
.st_rdev
, S_IFCHR
);
4407 pstrcpy(ifname
, ifname_size
, dev
);
4409 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4412 #elif defined(__sun__)
4413 #define TUNNEWPPA (('T'<<16) | 0x0001)
4415 * Allocate TAP device, returns opened fd.
4416 * Stores dev name in the first arg(must be large enough).
4418 int tap_alloc(char *dev
, size_t dev_size
)
4420 int tap_fd
, if_fd
, ppa
= -1;
4421 static int ip_fd
= 0;
4424 static int arp_fd
= 0;
4425 int ip_muxid
, arp_muxid
;
4426 struct strioctl strioc_if
, strioc_ppa
;
4427 int link_type
= I_PLINK
;;
4429 char actual_name
[32] = "";
4431 memset(&ifr
, 0x0, sizeof(ifr
));
4435 while( *ptr
&& !isdigit((int)*ptr
) ) ptr
++;
4439 /* Check if IP device was opened */
4443 TFR(ip_fd
= open("/dev/udp", O_RDWR
, 0));
4445 syslog(LOG_ERR
, "Can't open /dev/ip (actually /dev/udp)");
4449 TFR(tap_fd
= open("/dev/tap", O_RDWR
, 0));
4451 syslog(LOG_ERR
, "Can't open /dev/tap");
4455 /* Assign a new PPA and get its unit number. */
4456 strioc_ppa
.ic_cmd
= TUNNEWPPA
;
4457 strioc_ppa
.ic_timout
= 0;
4458 strioc_ppa
.ic_len
= sizeof(ppa
);
4459 strioc_ppa
.ic_dp
= (char *)&ppa
;
4460 if ((ppa
= ioctl (tap_fd
, I_STR
, &strioc_ppa
)) < 0)
4461 syslog (LOG_ERR
, "Can't assign new interface");
4463 TFR(if_fd
= open("/dev/tap", O_RDWR
, 0));
4465 syslog(LOG_ERR
, "Can't open /dev/tap (2)");
4468 if(ioctl(if_fd
, I_PUSH
, "ip") < 0){
4469 syslog(LOG_ERR
, "Can't push IP module");
4473 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) < 0)
4474 syslog(LOG_ERR
, "Can't get flags\n");
4476 snprintf (actual_name
, 32, "tap%d", ppa
);
4477 pstrcpy(ifr
.lifr_name
, sizeof(ifr
.lifr_name
), actual_name
);
4480 /* Assign ppa according to the unit number returned by tun device */
4482 if (ioctl (if_fd
, SIOCSLIFNAME
, &ifr
) < 0)
4483 syslog (LOG_ERR
, "Can't set PPA %d", ppa
);
4484 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) <0)
4485 syslog (LOG_ERR
, "Can't get flags\n");
4486 /* Push arp module to if_fd */
4487 if (ioctl (if_fd
, I_PUSH
, "arp") < 0)
4488 syslog (LOG_ERR
, "Can't push ARP module (2)");
4490 /* Push arp module to ip_fd */
4491 if (ioctl (ip_fd
, I_POP
, NULL
) < 0)
4492 syslog (LOG_ERR
, "I_POP failed\n");
4493 if (ioctl (ip_fd
, I_PUSH
, "arp") < 0)
4494 syslog (LOG_ERR
, "Can't push ARP module (3)\n");
4496 TFR(arp_fd
= open ("/dev/tap", O_RDWR
, 0));
4498 syslog (LOG_ERR
, "Can't open %s\n", "/dev/tap");
4500 /* Set ifname to arp */
4501 strioc_if
.ic_cmd
= SIOCSLIFNAME
;
4502 strioc_if
.ic_timout
= 0;
4503 strioc_if
.ic_len
= sizeof(ifr
);
4504 strioc_if
.ic_dp
= (char *)&ifr
;
4505 if (ioctl(arp_fd
, I_STR
, &strioc_if
) < 0){
4506 syslog (LOG_ERR
, "Can't set ifname to arp\n");
4509 if((ip_muxid
= ioctl(ip_fd
, I_LINK
, if_fd
)) < 0){
4510 syslog(LOG_ERR
, "Can't link TAP device to IP");
4514 if ((arp_muxid
= ioctl (ip_fd
, link_type
, arp_fd
)) < 0)
4515 syslog (LOG_ERR
, "Can't link TAP device to ARP");
4519 memset(&ifr
, 0x0, sizeof(ifr
));
4520 pstrcpy(ifr
.lifr_name
, sizeof(ifr
.lifr_name
), actual_name
);
4521 ifr
.lifr_ip_muxid
= ip_muxid
;
4522 ifr
.lifr_arp_muxid
= arp_muxid
;
4524 if (ioctl (ip_fd
, SIOCSLIFMUXID
, &ifr
) < 0)
4526 ioctl (ip_fd
, I_PUNLINK
, arp_muxid
);
4527 ioctl (ip_fd
, I_PUNLINK
, ip_muxid
);
4528 syslog (LOG_ERR
, "Can't set multiplexor id");
4531 snprintf(dev
, dev_size
, "tap%d", ppa
);
4535 static int tap_open(char *ifname
, int ifname_size
)
4539 if( (fd
= tap_alloc(dev
, sizeof(dev
))) < 0 ){
4540 fprintf(stderr
, "Cannot allocate TAP device\n");
4543 pstrcpy(ifname
, ifname_size
, dev
);
4544 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4548 static int tap_open(char *ifname
, int ifname_size
)
4553 TFR(fd
= open("/dev/net/tun", O_RDWR
));
4555 fprintf(stderr
, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4558 memset(&ifr
, 0, sizeof(ifr
));
4559 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
4560 if (ifname
[0] != '\0')
4561 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, ifname
);
4563 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, "tap%d");
4564 ret
= ioctl(fd
, TUNSETIFF
, (void *) &ifr
);
4566 fprintf(stderr
, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4570 pstrcpy(ifname
, ifname_size
, ifr
.ifr_name
);
4571 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4576 static int launch_script(const char *setup_script
, const char *ifname
, int fd
)
4582 /* try to launch network script */
4586 int open_max
= sysconf (_SC_OPEN_MAX
), i
;
4587 for (i
= 0; i
< open_max
; i
++)
4588 if (i
!= STDIN_FILENO
&&
4589 i
!= STDOUT_FILENO
&&
4590 i
!= STDERR_FILENO
&&
4595 *parg
++ = (char *)setup_script
;
4596 *parg
++ = (char *)ifname
;
4598 execv(setup_script
, args
);
4601 while (waitpid(pid
, &status
, 0) != pid
);
4602 if (!WIFEXITED(status
) ||
4603 WEXITSTATUS(status
) != 0) {
4604 fprintf(stderr
, "%s: could not launch network script\n",
4612 static int net_tap_init(VLANState
*vlan
, const char *ifname1
,
4613 const char *setup_script
, const char *down_script
)
4619 if (ifname1
!= NULL
)
4620 pstrcpy(ifname
, sizeof(ifname
), ifname1
);
4623 TFR(fd
= tap_open(ifname
, sizeof(ifname
)));
4627 if (!setup_script
|| !strcmp(setup_script
, "no"))
4629 if (setup_script
[0] != '\0') {
4630 if (launch_script(setup_script
, ifname
, fd
))
4633 s
= net_tap_fd_init(vlan
, fd
);
4636 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4637 "tap: ifname=%s setup_script=%s", ifname
, setup_script
);
4638 if (down_script
&& strcmp(down_script
, "no"))
4639 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", down_script
);
4643 #endif /* !_WIN32 */
4645 #if defined(CONFIG_VDE)
4646 typedef struct VDEState
{
4647 VLANClientState
*vc
;
4651 static void vde_to_qemu(void *opaque
)
4653 VDEState
*s
= opaque
;
4657 size
= vde_recv(s
->vde
, buf
, sizeof(buf
), 0);
4659 qemu_send_packet(s
->vc
, buf
, size
);
4663 static void vde_from_qemu(void *opaque
, const uint8_t *buf
, int size
)
4665 VDEState
*s
= opaque
;
4668 ret
= vde_send(s
->vde
, buf
, size
, 0);
4669 if (ret
< 0 && errno
== EINTR
) {
4676 static int net_vde_init(VLANState
*vlan
, const char *sock
, int port
,
4677 const char *group
, int mode
)
4680 char *init_group
= strlen(group
) ? (char *)group
: NULL
;
4681 char *init_sock
= strlen(sock
) ? (char *)sock
: NULL
;
4683 struct vde_open_args args
= {
4685 .group
= init_group
,
4689 s
= qemu_mallocz(sizeof(VDEState
));
4692 s
->vde
= vde_open(init_sock
, "QEMU", &args
);
4697 s
->vc
= qemu_new_vlan_client(vlan
, vde_from_qemu
, NULL
, s
);
4698 qemu_set_fd_handler(vde_datafd(s
->vde
), vde_to_qemu
, NULL
, s
);
4699 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "vde: sock=%s fd=%d",
4700 sock
, vde_datafd(s
->vde
));
4705 /* network connection */
4706 typedef struct NetSocketState
{
4707 VLANClientState
*vc
;
4709 int state
; /* 0 = getting length, 1 = getting data */
4713 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4716 typedef struct NetSocketListenState
{
4719 } NetSocketListenState
;
4721 /* XXX: we consider we can send the whole packet without blocking */
4722 static void net_socket_receive(void *opaque
, const uint8_t *buf
, int size
)
4724 NetSocketState
*s
= opaque
;
4728 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
4729 send_all(s
->fd
, buf
, size
);
4732 static void net_socket_receive_dgram(void *opaque
, const uint8_t *buf
, int size
)
4734 NetSocketState
*s
= opaque
;
4735 sendto(s
->fd
, buf
, size
, 0,
4736 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
4739 static void net_socket_send(void *opaque
)
4741 NetSocketState
*s
= opaque
;
4746 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
4748 err
= socket_error();
4749 if (err
!= EWOULDBLOCK
)
4751 } else if (size
== 0) {
4752 /* end of connection */
4754 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4760 /* reassemble a packet from the network */
4766 memcpy(s
->buf
+ s
->index
, buf
, l
);
4770 if (s
->index
== 4) {
4772 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
4778 l
= s
->packet_len
- s
->index
;
4781 memcpy(s
->buf
+ s
->index
, buf
, l
);
4785 if (s
->index
>= s
->packet_len
) {
4786 qemu_send_packet(s
->vc
, s
->buf
, s
->packet_len
);
4795 static void net_socket_send_dgram(void *opaque
)
4797 NetSocketState
*s
= opaque
;
4800 size
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
4804 /* end of connection */
4805 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4808 qemu_send_packet(s
->vc
, s
->buf
, size
);
4811 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
)
4816 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
4817 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4818 inet_ntoa(mcastaddr
->sin_addr
),
4819 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
4823 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
4825 perror("socket(PF_INET, SOCK_DGRAM)");
4830 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
4831 (const char *)&val
, sizeof(val
));
4833 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4837 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
4843 /* Add host to multicast group */
4844 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
4845 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
4847 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
4848 (const char *)&imr
, sizeof(struct ip_mreq
));
4850 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4854 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4856 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
4857 (const char *)&val
, sizeof(val
));
4859 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4863 socket_set_nonblock(fd
);
4871 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
, int fd
,
4874 struct sockaddr_in saddr
;
4876 socklen_t saddr_len
;
4879 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4880 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4881 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4885 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
4887 if (saddr
.sin_addr
.s_addr
==0) {
4888 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4892 /* clone dgram socket */
4893 newfd
= net_socket_mcast_create(&saddr
);
4895 /* error already reported by net_socket_mcast_create() */
4899 /* clone newfd to fd, close newfd */
4904 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4905 fd
, strerror(errno
));
4910 s
= qemu_mallocz(sizeof(NetSocketState
));
4915 s
->vc
= qemu_new_vlan_client(vlan
, net_socket_receive_dgram
, NULL
, s
);
4916 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
4918 /* mcast: save bound address as dst */
4919 if (is_connected
) s
->dgram_dst
=saddr
;
4921 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4922 "socket: fd=%d (%s mcast=%s:%d)",
4923 fd
, is_connected
? "cloned" : "",
4924 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4928 static void net_socket_connect(void *opaque
)
4930 NetSocketState
*s
= opaque
;
4931 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
4934 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
, int fd
,
4938 s
= qemu_mallocz(sizeof(NetSocketState
));
4942 s
->vc
= qemu_new_vlan_client(vlan
,
4943 net_socket_receive
, NULL
, s
);
4944 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4945 "socket: fd=%d", fd
);
4947 net_socket_connect(s
);
4949 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
4954 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
, int fd
,
4957 int so_type
=-1, optlen
=sizeof(so_type
);
4959 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
4960 (socklen_t
*)&optlen
)< 0) {
4961 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
4966 return net_socket_fd_init_dgram(vlan
, fd
, is_connected
);
4968 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4970 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4971 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
4972 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4977 static void net_socket_accept(void *opaque
)
4979 NetSocketListenState
*s
= opaque
;
4981 struct sockaddr_in saddr
;
4986 len
= sizeof(saddr
);
4987 fd
= accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
4988 if (fd
< 0 && errno
!= EINTR
) {
4990 } else if (fd
>= 0) {
4994 s1
= net_socket_fd_init(s
->vlan
, fd
, 1);
4998 snprintf(s1
->vc
->info_str
, sizeof(s1
->vc
->info_str
),
4999 "socket: connection from %s:%d",
5000 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5004 static int net_socket_listen_init(VLANState
*vlan
, const char *host_str
)
5006 NetSocketListenState
*s
;
5008 struct sockaddr_in saddr
;
5010 if (parse_host_port(&saddr
, host_str
) < 0)
5013 s
= qemu_mallocz(sizeof(NetSocketListenState
));
5017 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5022 socket_set_nonblock(fd
);
5024 /* allow fast reuse */
5026 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
5028 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5033 ret
= listen(fd
, 0);
5040 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
5044 static int net_socket_connect_init(VLANState
*vlan
, const char *host_str
)
5047 int fd
, connected
, ret
, err
;
5048 struct sockaddr_in saddr
;
5050 if (parse_host_port(&saddr
, host_str
) < 0)
5053 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5058 socket_set_nonblock(fd
);
5062 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5064 err
= socket_error();
5065 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
5066 } else if (err
== EINPROGRESS
) {
5069 } else if (err
== WSAEALREADY
) {
5082 s
= net_socket_fd_init(vlan
, fd
, connected
);
5085 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5086 "socket: connect to %s:%d",
5087 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5091 static int net_socket_mcast_init(VLANState
*vlan
, const char *host_str
)
5095 struct sockaddr_in saddr
;
5097 if (parse_host_port(&saddr
, host_str
) < 0)
5101 fd
= net_socket_mcast_create(&saddr
);
5105 s
= net_socket_fd_init(vlan
, fd
, 0);
5109 s
->dgram_dst
= saddr
;
5111 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5112 "socket: mcast=%s:%d",
5113 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5118 static const char *get_opt_name(char *buf
, int buf_size
, const char *p
)
5123 while (*p
!= '\0' && *p
!= '=') {
5124 if (q
&& (q
- buf
) < buf_size
- 1)
5134 static const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
5139 while (*p
!= '\0') {
5141 if (*(p
+ 1) != ',')
5145 if (q
&& (q
- buf
) < buf_size
- 1)
5155 static int get_param_value(char *buf
, int buf_size
,
5156 const char *tag
, const char *str
)
5163 p
= get_opt_name(option
, sizeof(option
), p
);
5167 if (!strcmp(tag
, option
)) {
5168 (void)get_opt_value(buf
, buf_size
, p
);
5171 p
= get_opt_value(NULL
, 0, p
);
5180 static int check_params(char *buf
, int buf_size
,
5181 const char * const *params
, const char *str
)
5188 p
= get_opt_name(buf
, buf_size
, p
);
5192 for(i
= 0; params
[i
] != NULL
; i
++)
5193 if (!strcmp(params
[i
], buf
))
5195 if (params
[i
] == NULL
)
5197 p
= get_opt_value(NULL
, 0, p
);
5205 static int net_client_init(const char *device
, const char *p
)
5212 if (get_param_value(buf
, sizeof(buf
), "vlan", p
)) {
5213 vlan_id
= strtol(buf
, NULL
, 0);
5215 vlan
= qemu_find_vlan(vlan_id
);
5217 fprintf(stderr
, "Could not create vlan %d\n", vlan_id
);
5220 if (!strcmp(device
, "nic")) {
5224 if (nb_nics
>= MAX_NICS
) {
5225 fprintf(stderr
, "Too Many NICs\n");
5228 nd
= &nd_table
[nb_nics
];
5229 macaddr
= nd
->macaddr
;
5235 macaddr
[5] = 0x56 + nb_nics
;
5237 if (get_param_value(buf
, sizeof(buf
), "macaddr", p
)) {
5238 if (parse_macaddr(macaddr
, buf
) < 0) {
5239 fprintf(stderr
, "invalid syntax for ethernet address\n");
5243 if (get_param_value(buf
, sizeof(buf
), "model", p
)) {
5244 nd
->model
= strdup(buf
);
5248 vlan
->nb_guest_devs
++;
5251 if (!strcmp(device
, "none")) {
5252 /* does nothing. It is needed to signal that no network cards
5257 if (!strcmp(device
, "user")) {
5258 if (get_param_value(buf
, sizeof(buf
), "hostname", p
)) {
5259 pstrcpy(slirp_hostname
, sizeof(slirp_hostname
), buf
);
5261 vlan
->nb_host_devs
++;
5262 ret
= net_slirp_init(vlan
);
5266 if (!strcmp(device
, "tap")) {
5268 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5269 fprintf(stderr
, "tap: no interface name\n");
5272 vlan
->nb_host_devs
++;
5273 ret
= tap_win32_init(vlan
, ifname
);
5276 if (!strcmp(device
, "tap")) {
5278 char setup_script
[1024], down_script
[1024];
5280 vlan
->nb_host_devs
++;
5281 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5282 fd
= strtol(buf
, NULL
, 0);
5283 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
5285 if (net_tap_fd_init(vlan
, fd
))
5288 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5291 if (get_param_value(setup_script
, sizeof(setup_script
), "script", p
) == 0) {
5292 pstrcpy(setup_script
, sizeof(setup_script
), DEFAULT_NETWORK_SCRIPT
);
5294 if (get_param_value(down_script
, sizeof(down_script
), "downscript", p
) == 0) {
5295 pstrcpy(down_script
, sizeof(down_script
), DEFAULT_NETWORK_DOWN_SCRIPT
);
5297 ret
= net_tap_init(vlan
, ifname
, setup_script
, down_script
);
5301 if (!strcmp(device
, "socket")) {
5302 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5304 fd
= strtol(buf
, NULL
, 0);
5306 if (net_socket_fd_init(vlan
, fd
, 1))
5308 } else if (get_param_value(buf
, sizeof(buf
), "listen", p
) > 0) {
5309 ret
= net_socket_listen_init(vlan
, buf
);
5310 } else if (get_param_value(buf
, sizeof(buf
), "connect", p
) > 0) {
5311 ret
= net_socket_connect_init(vlan
, buf
);
5312 } else if (get_param_value(buf
, sizeof(buf
), "mcast", p
) > 0) {
5313 ret
= net_socket_mcast_init(vlan
, buf
);
5315 fprintf(stderr
, "Unknown socket options: %s\n", p
);
5318 vlan
->nb_host_devs
++;
5321 if (!strcmp(device
, "vde")) {
5322 char vde_sock
[1024], vde_group
[512];
5323 int vde_port
, vde_mode
;
5324 vlan
->nb_host_devs
++;
5325 if (get_param_value(vde_sock
, sizeof(vde_sock
), "sock", p
) <= 0) {
5328 if (get_param_value(buf
, sizeof(buf
), "port", p
) > 0) {
5329 vde_port
= strtol(buf
, NULL
, 10);
5333 if (get_param_value(vde_group
, sizeof(vde_group
), "group", p
) <= 0) {
5334 vde_group
[0] = '\0';
5336 if (get_param_value(buf
, sizeof(buf
), "mode", p
) > 0) {
5337 vde_mode
= strtol(buf
, NULL
, 8);
5341 ret
= net_vde_init(vlan
, vde_sock
, vde_port
, vde_group
, vde_mode
);
5345 fprintf(stderr
, "Unknown network device: %s\n", device
);
5349 fprintf(stderr
, "Could not initialize device '%s'\n", device
);
5355 static int net_client_parse(const char *str
)
5363 while (*p
!= '\0' && *p
!= ',') {
5364 if ((q
- device
) < sizeof(device
) - 1)
5372 return net_client_init(device
, p
);
5375 void do_info_network(void)
5378 VLANClientState
*vc
;
5380 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5381 term_printf("VLAN %d devices:\n", vlan
->id
);
5382 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
)
5383 term_printf(" %s\n", vc
->info_str
);
5387 /***********************************************************/
5388 /* Bluetooth support */
5391 static struct HCIInfo
*hci_table
[MAX_NICS
];
5393 static struct bt_vlan_s
{
5394 struct bt_scatternet_s net
;
5396 struct bt_vlan_s
*next
;
5399 /* find or alloc a new bluetooth "VLAN" */
5400 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
5402 struct bt_vlan_s
**pvlan
, *vlan
;
5403 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5407 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
5409 pvlan
= &first_bt_vlan
;
5410 while (*pvlan
!= NULL
)
5411 pvlan
= &(*pvlan
)->next
;
5417 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
5421 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
5426 static struct HCIInfo null_hci
= {
5427 .cmd_send
= null_hci_send
,
5428 .sco_send
= null_hci_send
,
5429 .acl_send
= null_hci_send
,
5430 .bdaddr_set
= null_hci_addr_set
,
5433 struct HCIInfo
*qemu_next_hci(void)
5435 if (cur_hci
== nb_hcis
)
5438 return hci_table
[cur_hci
++];
5441 /***********************************************************/
5442 /* QEMU Block devices */
5444 #define HD_ALIAS "index=%d,media=disk"
5446 #define CDROM_ALIAS "index=1,media=cdrom"
5448 #define CDROM_ALIAS "index=2,media=cdrom"
5450 #define FD_ALIAS "index=%d,if=floppy"
5451 #define PFLASH_ALIAS "if=pflash"
5452 #define MTD_ALIAS "if=mtd"
5453 #define SD_ALIAS "index=0,if=sd"
5455 static int drive_add(const char *file
, const char *fmt
, ...)
5459 if (nb_drives_opt
>= MAX_DRIVES
) {
5460 fprintf(stderr
, "qemu: too many drives\n");
5464 drives_opt
[nb_drives_opt
].file
= file
;
5466 vsnprintf(drives_opt
[nb_drives_opt
].opt
,
5467 sizeof(drives_opt
[0].opt
), fmt
, ap
);
5470 return nb_drives_opt
++;
5473 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
5477 /* seek interface, bus and unit */
5479 for (index
= 0; index
< nb_drives
; index
++)
5480 if (drives_table
[index
].type
== type
&&
5481 drives_table
[index
].bus
== bus
&&
5482 drives_table
[index
].unit
== unit
)
5488 int drive_get_max_bus(BlockInterfaceType type
)
5494 for (index
= 0; index
< nb_drives
; index
++) {
5495 if(drives_table
[index
].type
== type
&&
5496 drives_table
[index
].bus
> max_bus
)
5497 max_bus
= drives_table
[index
].bus
;
5502 static void bdrv_format_print(void *opaque
, const char *name
)
5504 fprintf(stderr
, " %s", name
);
5507 static int drive_init(struct drive_opt
*arg
, int snapshot
,
5508 QEMUMachine
*machine
)
5513 const char *mediastr
= "";
5514 BlockInterfaceType type
;
5515 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
5516 int bus_id
, unit_id
;
5517 int cyls
, heads
, secs
, translation
;
5518 BlockDriverState
*bdrv
;
5519 BlockDriver
*drv
= NULL
;
5524 char *str
= arg
->opt
;
5525 static const char * const params
[] = { "bus", "unit", "if", "index",
5526 "cyls", "heads", "secs", "trans",
5527 "media", "snapshot", "file",
5528 "cache", "format", NULL
};
5530 if (check_params(buf
, sizeof(buf
), params
, str
) < 0) {
5531 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
5537 cyls
= heads
= secs
= 0;
5540 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5544 if (machine
->use_scsi
) {
5546 max_devs
= MAX_SCSI_DEVS
;
5547 pstrcpy(devname
, sizeof(devname
), "scsi");
5550 max_devs
= MAX_IDE_DEVS
;
5551 pstrcpy(devname
, sizeof(devname
), "ide");
5555 /* extract parameters */
5557 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
5558 bus_id
= strtol(buf
, NULL
, 0);
5560 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
5565 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
5566 unit_id
= strtol(buf
, NULL
, 0);
5568 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
5573 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
5574 pstrcpy(devname
, sizeof(devname
), buf
);
5575 if (!strcmp(buf
, "ide")) {
5577 max_devs
= MAX_IDE_DEVS
;
5578 } else if (!strcmp(buf
, "scsi")) {
5580 max_devs
= MAX_SCSI_DEVS
;
5581 } else if (!strcmp(buf
, "floppy")) {
5584 } else if (!strcmp(buf
, "pflash")) {
5587 } else if (!strcmp(buf
, "mtd")) {
5590 } else if (!strcmp(buf
, "sd")) {
5594 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
5599 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
5600 index
= strtol(buf
, NULL
, 0);
5602 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
5607 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
5608 cyls
= strtol(buf
, NULL
, 0);
5611 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
5612 heads
= strtol(buf
, NULL
, 0);
5615 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
5616 secs
= strtol(buf
, NULL
, 0);
5619 if (cyls
|| heads
|| secs
) {
5620 if (cyls
< 1 || cyls
> 16383) {
5621 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
5624 if (heads
< 1 || heads
> 16) {
5625 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
5628 if (secs
< 1 || secs
> 63) {
5629 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
5634 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
5637 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5641 if (!strcmp(buf
, "none"))
5642 translation
= BIOS_ATA_TRANSLATION_NONE
;
5643 else if (!strcmp(buf
, "lba"))
5644 translation
= BIOS_ATA_TRANSLATION_LBA
;
5645 else if (!strcmp(buf
, "auto"))
5646 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5648 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
5653 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
5654 if (!strcmp(buf
, "disk")) {
5656 } else if (!strcmp(buf
, "cdrom")) {
5657 if (cyls
|| secs
|| heads
) {
5659 "qemu: '%s' invalid physical CHS format\n", str
);
5662 media
= MEDIA_CDROM
;
5664 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
5669 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
5670 if (!strcmp(buf
, "on"))
5672 else if (!strcmp(buf
, "off"))
5675 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
5680 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
5681 if (!strcmp(buf
, "off") || !strcmp(buf
, "none"))
5683 else if (!strcmp(buf
, "writethrough"))
5685 else if (!strcmp(buf
, "writeback"))
5688 fprintf(stderr
, "qemu: invalid cache option\n");
5693 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
5694 if (strcmp(buf
, "?") == 0) {
5695 fprintf(stderr
, "qemu: Supported formats:");
5696 bdrv_iterate_format(bdrv_format_print
, NULL
);
5697 fprintf(stderr
, "\n");
5700 drv
= bdrv_find_format(buf
);
5702 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
5707 if (arg
->file
== NULL
)
5708 get_param_value(file
, sizeof(file
), "file", str
);
5710 pstrcpy(file
, sizeof(file
), arg
->file
);
5712 /* compute bus and unit according index */
5715 if (bus_id
!= 0 || unit_id
!= -1) {
5717 "qemu: '%s' index cannot be used with bus and unit\n", str
);
5725 unit_id
= index
% max_devs
;
5726 bus_id
= index
/ max_devs
;
5730 /* if user doesn't specify a unit_id,
5731 * try to find the first free
5734 if (unit_id
== -1) {
5736 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
5738 if (max_devs
&& unit_id
>= max_devs
) {
5739 unit_id
-= max_devs
;
5747 if (max_devs
&& unit_id
>= max_devs
) {
5748 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
5749 str
, unit_id
, max_devs
- 1);
5754 * ignore multiple definitions
5757 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
5762 if (type
== IF_IDE
|| type
== IF_SCSI
)
5763 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
5765 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
5766 devname
, bus_id
, mediastr
, unit_id
);
5768 snprintf(buf
, sizeof(buf
), "%s%s%i",
5769 devname
, mediastr
, unit_id
);
5770 bdrv
= bdrv_new(buf
);
5771 drives_table
[nb_drives
].bdrv
= bdrv
;
5772 drives_table
[nb_drives
].type
= type
;
5773 drives_table
[nb_drives
].bus
= bus_id
;
5774 drives_table
[nb_drives
].unit
= unit_id
;
5783 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
5784 bdrv_set_translation_hint(bdrv
, translation
);
5788 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
5793 /* FIXME: This isn't really a floppy, but it's a reasonable
5796 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
5806 bdrv_flags
|= BDRV_O_SNAPSHOT
;
5807 cache
= 2; /* always use write-back with snapshot */
5809 if (cache
== 0) /* no caching */
5810 bdrv_flags
|= BDRV_O_NOCACHE
;
5811 else if (cache
== 2) /* write-back */
5812 bdrv_flags
|= BDRV_O_CACHE_WB
;
5813 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0 || qemu_key_check(bdrv
, file
)) {
5814 fprintf(stderr
, "qemu: could not open disk image %s\n",
5821 /***********************************************************/
5824 static USBPort
*used_usb_ports
;
5825 static USBPort
*free_usb_ports
;
5827 /* ??? Maybe change this to register a hub to keep track of the topology. */
5828 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
5829 usb_attachfn attach
)
5831 port
->opaque
= opaque
;
5832 port
->index
= index
;
5833 port
->attach
= attach
;
5834 port
->next
= free_usb_ports
;
5835 free_usb_ports
= port
;
5838 int usb_device_add_dev(USBDevice
*dev
)
5842 /* Find a USB port to add the device to. */
5843 port
= free_usb_ports
;
5847 /* Create a new hub and chain it on. */
5848 free_usb_ports
= NULL
;
5849 port
->next
= used_usb_ports
;
5850 used_usb_ports
= port
;
5852 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
5853 usb_attach(port
, hub
);
5854 port
= free_usb_ports
;
5857 free_usb_ports
= port
->next
;
5858 port
->next
= used_usb_ports
;
5859 used_usb_ports
= port
;
5860 usb_attach(port
, dev
);
5864 static int usb_device_add(const char *devname
)
5869 if (!free_usb_ports
)
5872 if (strstart(devname
, "host:", &p
)) {
5873 dev
= usb_host_device_open(p
);
5874 } else if (!strcmp(devname
, "mouse")) {
5875 dev
= usb_mouse_init();
5876 } else if (!strcmp(devname
, "tablet")) {
5877 dev
= usb_tablet_init();
5878 } else if (!strcmp(devname
, "keyboard")) {
5879 dev
= usb_keyboard_init();
5880 } else if (strstart(devname
, "disk:", &p
)) {
5881 dev
= usb_msd_init(p
);
5882 } else if (!strcmp(devname
, "wacom-tablet")) {
5883 dev
= usb_wacom_init();
5884 } else if (strstart(devname
, "serial:", &p
)) {
5885 dev
= usb_serial_init(p
);
5886 #ifdef CONFIG_BRLAPI
5887 } else if (!strcmp(devname
, "braille")) {
5888 dev
= usb_baum_init();
5890 } else if (strstart(devname
, "net:", &p
)) {
5893 if (net_client_init("nic", p
) < 0)
5895 nd_table
[nic
].model
= "usb";
5896 dev
= usb_net_init(&nd_table
[nic
]);
5903 return usb_device_add_dev(dev
);
5906 int usb_device_del_addr(int bus_num
, int addr
)
5912 if (!used_usb_ports
)
5918 lastp
= &used_usb_ports
;
5919 port
= used_usb_ports
;
5920 while (port
&& port
->dev
->addr
!= addr
) {
5921 lastp
= &port
->next
;
5929 *lastp
= port
->next
;
5930 usb_attach(port
, NULL
);
5931 dev
->handle_destroy(dev
);
5932 port
->next
= free_usb_ports
;
5933 free_usb_ports
= port
;
5937 static int usb_device_del(const char *devname
)
5942 if (strstart(devname
, "host:", &p
))
5943 return usb_host_device_close(p
);
5945 if (!used_usb_ports
)
5948 p
= strchr(devname
, '.');
5951 bus_num
= strtoul(devname
, NULL
, 0);
5952 addr
= strtoul(p
+ 1, NULL
, 0);
5954 return usb_device_del_addr(bus_num
, addr
);
5957 void do_usb_add(const char *devname
)
5959 usb_device_add(devname
);
5962 void do_usb_del(const char *devname
)
5964 usb_device_del(devname
);
5971 const char *speed_str
;
5974 term_printf("USB support not enabled\n");
5978 for (port
= used_usb_ports
; port
; port
= port
->next
) {
5982 switch(dev
->speed
) {
5986 case USB_SPEED_FULL
:
5989 case USB_SPEED_HIGH
:
5996 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5997 0, dev
->addr
, speed_str
, dev
->devname
);
6001 /***********************************************************/
6002 /* PCMCIA/Cardbus */
6004 static struct pcmcia_socket_entry_s
{
6005 struct pcmcia_socket_s
*socket
;
6006 struct pcmcia_socket_entry_s
*next
;
6007 } *pcmcia_sockets
= 0;
6009 void pcmcia_socket_register(struct pcmcia_socket_s
*socket
)
6011 struct pcmcia_socket_entry_s
*entry
;
6013 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
6014 entry
->socket
= socket
;
6015 entry
->next
= pcmcia_sockets
;
6016 pcmcia_sockets
= entry
;
6019 void pcmcia_socket_unregister(struct pcmcia_socket_s
*socket
)
6021 struct pcmcia_socket_entry_s
*entry
, **ptr
;
6023 ptr
= &pcmcia_sockets
;
6024 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
6025 if (entry
->socket
== socket
) {
6031 void pcmcia_info(void)
6033 struct pcmcia_socket_entry_s
*iter
;
6034 if (!pcmcia_sockets
)
6035 term_printf("No PCMCIA sockets\n");
6037 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
6038 term_printf("%s: %s\n", iter
->socket
->slot_string
,
6039 iter
->socket
->attached
? iter
->socket
->card_string
:
6043 /***********************************************************/
6046 static void dumb_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
6050 static void dumb_resize(DisplayState
*ds
, int w
, int h
)
6054 static void dumb_refresh(DisplayState
*ds
)
6056 #if defined(CONFIG_SDL)
6061 static void dumb_display_init(DisplayState
*ds
)
6066 ds
->dpy_update
= dumb_update
;
6067 ds
->dpy_resize
= dumb_resize
;
6068 ds
->dpy_refresh
= dumb_refresh
;
6069 ds
->gui_timer_interval
= 500;
6073 /***********************************************************/
6076 #define MAX_IO_HANDLERS 64
6078 typedef struct IOHandlerRecord
{
6080 IOCanRWHandler
*fd_read_poll
;
6082 IOHandler
*fd_write
;
6085 /* temporary data */
6087 struct IOHandlerRecord
*next
;
6090 static IOHandlerRecord
*first_io_handler
;
6092 /* XXX: fd_read_poll should be suppressed, but an API change is
6093 necessary in the character devices to suppress fd_can_read(). */
6094 int qemu_set_fd_handler2(int fd
,
6095 IOCanRWHandler
*fd_read_poll
,
6097 IOHandler
*fd_write
,
6100 IOHandlerRecord
**pioh
, *ioh
;
6102 if (!fd_read
&& !fd_write
) {
6103 pioh
= &first_io_handler
;
6108 if (ioh
->fd
== fd
) {
6115 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
6119 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
6122 ioh
->next
= first_io_handler
;
6123 first_io_handler
= ioh
;
6126 ioh
->fd_read_poll
= fd_read_poll
;
6127 ioh
->fd_read
= fd_read
;
6128 ioh
->fd_write
= fd_write
;
6129 ioh
->opaque
= opaque
;
6135 int qemu_set_fd_handler(int fd
,
6137 IOHandler
*fd_write
,
6140 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
6143 /***********************************************************/
6144 /* Polling handling */
6146 typedef struct PollingEntry
{
6149 struct PollingEntry
*next
;
6152 static PollingEntry
*first_polling_entry
;
6154 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
6156 PollingEntry
**ppe
, *pe
;
6157 pe
= qemu_mallocz(sizeof(PollingEntry
));
6161 pe
->opaque
= opaque
;
6162 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
6167 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
6169 PollingEntry
**ppe
, *pe
;
6170 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
6172 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
6181 /***********************************************************/
6182 /* Wait objects support */
6183 typedef struct WaitObjects
{
6185 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
6186 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
6187 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
6190 static WaitObjects wait_objects
= {0};
6192 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6194 WaitObjects
*w
= &wait_objects
;
6196 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
6198 w
->events
[w
->num
] = handle
;
6199 w
->func
[w
->num
] = func
;
6200 w
->opaque
[w
->num
] = opaque
;
6205 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6208 WaitObjects
*w
= &wait_objects
;
6211 for (i
= 0; i
< w
->num
; i
++) {
6212 if (w
->events
[i
] == handle
)
6215 w
->events
[i
] = w
->events
[i
+ 1];
6216 w
->func
[i
] = w
->func
[i
+ 1];
6217 w
->opaque
[i
] = w
->opaque
[i
+ 1];
6225 #define SELF_ANNOUNCE_ROUNDS 5
6226 #define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
6227 //#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
6228 #define EXPERIMENTAL_MAGIC 0xf1f23f4f
6230 static int announce_self_create(uint8_t *buf
,
6233 uint32_t magic
= EXPERIMENTAL_MAGIC
;
6234 uint16_t proto
= htons(ETH_P_EXPERIMENTAL
);
6236 /* FIXME: should we send a different packet (arp/rarp/ping)? */
6238 memset(buf
, 0xff, 6); /* h_dst */
6239 memcpy(buf
+ 6, mac_addr
, 6); /* h_src */
6240 memcpy(buf
+ 12, &proto
, 2); /* h_proto */
6241 memcpy(buf
+ 14, &magic
, 4); /* magic */
6243 return 18; /* len */
6246 void qemu_announce_self(void)
6250 VLANClientState
*vc
;
6253 for (i
= 0; i
< nb_nics
; i
++) {
6254 len
= announce_self_create(buf
, nd_table
[i
].macaddr
);
6255 vlan
= nd_table
[i
].vlan
;
6256 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
6257 for (j
=0; j
< SELF_ANNOUNCE_ROUNDS
; j
++)
6258 vc
->fd_read(vc
->opaque
, buf
, len
);
6263 /***********************************************************/
6264 /* savevm/loadvm support */
6266 #define IO_BUF_SIZE 32768
6269 QEMUFilePutBufferFunc
*put_buffer
;
6270 QEMUFileGetBufferFunc
*get_buffer
;
6271 QEMUFileCloseFunc
*close
;
6272 QEMUFileRateLimit
*rate_limit
;
6276 int64_t buf_offset
; /* start of buffer when writing, end of buffer
6279 int buf_size
; /* 0 when writing */
6280 uint8_t buf
[IO_BUF_SIZE
];
6285 typedef struct QEMUFileSocket
6291 static int socket_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6293 QEMUFileSocket
*s
= opaque
;
6297 len
= recv(s
->fd
, buf
, size
, 0);
6298 } while (len
== -1 && socket_error() == EINTR
);
6301 len
= -socket_error();
6306 static int socket_close(void *opaque
)
6308 QEMUFileSocket
*s
= opaque
;
6313 QEMUFile
*qemu_fopen_socket(int fd
)
6315 QEMUFileSocket
*s
= qemu_mallocz(sizeof(QEMUFileSocket
));
6321 s
->file
= qemu_fopen_ops(s
, NULL
, socket_get_buffer
, socket_close
, NULL
);
6325 typedef struct QEMUFileStdio
6330 static int file_put_buffer(void *opaque
, const uint8_t *buf
,
6331 int64_t pos
, int size
)
6333 QEMUFileStdio
*s
= opaque
;
6334 fseek(s
->outfile
, pos
, SEEK_SET
);
6335 fwrite(buf
, 1, size
, s
->outfile
);
6339 static int file_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6341 QEMUFileStdio
*s
= opaque
;
6342 fseek(s
->outfile
, pos
, SEEK_SET
);
6343 return fread(buf
, 1, size
, s
->outfile
);
6346 static int file_close(void *opaque
)
6348 QEMUFileStdio
*s
= opaque
;
6354 QEMUFile
*qemu_fopen(const char *filename
, const char *mode
)
6358 s
= qemu_mallocz(sizeof(QEMUFileStdio
));
6362 s
->outfile
= fopen(filename
, mode
);
6366 if (!strcmp(mode
, "wb"))
6367 return qemu_fopen_ops(s
, file_put_buffer
, NULL
, file_close
, NULL
);
6368 else if (!strcmp(mode
, "rb"))
6369 return qemu_fopen_ops(s
, NULL
, file_get_buffer
, file_close
, NULL
);
6378 typedef struct QEMUFileBdrv
6380 BlockDriverState
*bs
;
6381 int64_t base_offset
;
6384 static int bdrv_put_buffer(void *opaque
, const uint8_t *buf
,
6385 int64_t pos
, int size
)
6387 QEMUFileBdrv
*s
= opaque
;
6388 bdrv_pwrite(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6392 static int bdrv_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6394 QEMUFileBdrv
*s
= opaque
;
6395 return bdrv_pread(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6398 static int bdrv_fclose(void *opaque
)
6400 QEMUFileBdrv
*s
= opaque
;
6405 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int64_t offset
, int is_writable
)
6409 s
= qemu_mallocz(sizeof(QEMUFileBdrv
));
6414 s
->base_offset
= offset
;
6417 return qemu_fopen_ops(s
, bdrv_put_buffer
, NULL
, bdrv_fclose
, NULL
);
6419 return qemu_fopen_ops(s
, NULL
, bdrv_get_buffer
, bdrv_fclose
, NULL
);
6422 QEMUFile
*qemu_fopen_ops(void *opaque
, QEMUFilePutBufferFunc
*put_buffer
,
6423 QEMUFileGetBufferFunc
*get_buffer
,
6424 QEMUFileCloseFunc
*close
,
6425 QEMUFileRateLimit
*rate_limit
)
6429 f
= qemu_mallocz(sizeof(QEMUFile
));
6434 f
->put_buffer
= put_buffer
;
6435 f
->get_buffer
= get_buffer
;
6437 f
->rate_limit
= rate_limit
;
6443 int qemu_file_has_error(QEMUFile
*f
)
6445 return f
->has_error
;
6448 void qemu_fflush(QEMUFile
*f
)
6453 if (f
->is_write
&& f
->buf_index
> 0) {
6456 len
= f
->put_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, f
->buf_index
);
6458 f
->buf_offset
+= f
->buf_index
;
6465 static void qemu_fill_buffer(QEMUFile
*f
)
6475 len
= f
->get_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, IO_BUF_SIZE
);
6479 f
->buf_offset
+= len
;
6480 } else if (len
!= -EAGAIN
)
6484 int qemu_fclose(QEMUFile
*f
)
6489 ret
= f
->close(f
->opaque
);
6494 void qemu_file_put_notify(QEMUFile
*f
)
6496 f
->put_buffer(f
->opaque
, NULL
, 0, 0);
6499 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, int size
)
6503 if (!f
->has_error
&& f
->is_write
== 0 && f
->buf_index
> 0) {
6505 "Attempted to write to buffer while read buffer is not empty\n");
6509 while (!f
->has_error
&& size
> 0) {
6510 l
= IO_BUF_SIZE
- f
->buf_index
;
6513 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
6518 if (f
->buf_index
>= IO_BUF_SIZE
)
6523 void qemu_put_byte(QEMUFile
*f
, int v
)
6525 if (!f
->has_error
&& f
->is_write
== 0 && f
->buf_index
> 0) {
6527 "Attempted to write to buffer while read buffer is not empty\n");
6531 f
->buf
[f
->buf_index
++] = v
;
6533 if (f
->buf_index
>= IO_BUF_SIZE
)
6537 int qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, int size1
)
6546 l
= f
->buf_size
- f
->buf_index
;
6548 qemu_fill_buffer(f
);
6549 l
= f
->buf_size
- f
->buf_index
;
6555 memcpy(buf
, f
->buf
+ f
->buf_index
, l
);
6560 return size1
- size
;
6563 int qemu_get_byte(QEMUFile
*f
)
6568 if (f
->buf_index
>= f
->buf_size
) {
6569 qemu_fill_buffer(f
);
6570 if (f
->buf_index
>= f
->buf_size
)
6573 return f
->buf
[f
->buf_index
++];
6576 int64_t qemu_ftell(QEMUFile
*f
)
6578 return f
->buf_offset
- f
->buf_size
+ f
->buf_index
;
6581 int64_t qemu_fseek(QEMUFile
*f
, int64_t pos
, int whence
)
6583 if (whence
== SEEK_SET
) {
6585 } else if (whence
== SEEK_CUR
) {
6586 pos
+= qemu_ftell(f
);
6588 /* SEEK_END not supported */
6591 if (f
->put_buffer
) {
6593 f
->buf_offset
= pos
;
6595 f
->buf_offset
= pos
;
6602 int qemu_file_rate_limit(QEMUFile
*f
)
6605 return f
->rate_limit(f
->opaque
);
6610 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
6612 qemu_put_byte(f
, v
>> 8);
6613 qemu_put_byte(f
, v
);
6616 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
6618 qemu_put_byte(f
, v
>> 24);
6619 qemu_put_byte(f
, v
>> 16);
6620 qemu_put_byte(f
, v
>> 8);
6621 qemu_put_byte(f
, v
);
6624 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
6626 qemu_put_be32(f
, v
>> 32);
6627 qemu_put_be32(f
, v
);
6630 unsigned int qemu_get_be16(QEMUFile
*f
)
6633 v
= qemu_get_byte(f
) << 8;
6634 v
|= qemu_get_byte(f
);
6638 unsigned int qemu_get_be32(QEMUFile
*f
)
6641 v
= qemu_get_byte(f
) << 24;
6642 v
|= qemu_get_byte(f
) << 16;
6643 v
|= qemu_get_byte(f
) << 8;
6644 v
|= qemu_get_byte(f
);
6648 uint64_t qemu_get_be64(QEMUFile
*f
)
6651 v
= (uint64_t)qemu_get_be32(f
) << 32;
6652 v
|= qemu_get_be32(f
);
6656 typedef struct SaveStateEntry
{
6661 SaveLiveStateHandler
*save_live_state
;
6662 SaveStateHandler
*save_state
;
6663 LoadStateHandler
*load_state
;
6665 struct SaveStateEntry
*next
;
6668 static SaveStateEntry
*first_se
;
6670 /* TODO: Individual devices generally have very little idea about the rest
6671 of the system, so instance_id should be removed/replaced.
6672 Meanwhile pass -1 as instance_id if you do not already have a clearly
6673 distinguishing id for all instances of your device class. */
6674 int register_savevm_live(const char *idstr
,
6677 SaveLiveStateHandler
*save_live_state
,
6678 SaveStateHandler
*save_state
,
6679 LoadStateHandler
*load_state
,
6682 SaveStateEntry
*se
, **pse
;
6683 static int global_section_id
;
6685 se
= qemu_malloc(sizeof(SaveStateEntry
));
6688 pstrcpy(se
->idstr
, sizeof(se
->idstr
), idstr
);
6689 se
->instance_id
= (instance_id
== -1) ? 0 : instance_id
;
6690 se
->version_id
= version_id
;
6691 se
->section_id
= global_section_id
++;
6692 se
->save_live_state
= save_live_state
;
6693 se
->save_state
= save_state
;
6694 se
->load_state
= load_state
;
6695 se
->opaque
= opaque
;
6698 /* add at the end of list */
6700 while (*pse
!= NULL
) {
6701 if (instance_id
== -1
6702 && strcmp(se
->idstr
, (*pse
)->idstr
) == 0
6703 && se
->instance_id
<= (*pse
)->instance_id
)
6704 se
->instance_id
= (*pse
)->instance_id
+ 1;
6705 pse
= &(*pse
)->next
;
6711 int register_savevm(const char *idstr
,
6714 SaveStateHandler
*save_state
,
6715 LoadStateHandler
*load_state
,
6718 return register_savevm_live(idstr
, instance_id
, version_id
,
6719 NULL
, save_state
, load_state
, opaque
);
6722 #define QEMU_VM_FILE_MAGIC 0x5145564d
6723 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
6724 #define QEMU_VM_FILE_VERSION 0x00000003
6726 #define QEMU_VM_EOF 0x00
6727 #define QEMU_VM_SECTION_START 0x01
6728 #define QEMU_VM_SECTION_PART 0x02
6729 #define QEMU_VM_SECTION_END 0x03
6730 #define QEMU_VM_SECTION_FULL 0x04
6732 int qemu_savevm_state_begin(QEMUFile
*f
)
6736 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
6737 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
6739 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
6742 if (se
->save_live_state
== NULL
)
6746 qemu_put_byte(f
, QEMU_VM_SECTION_START
);
6747 qemu_put_be32(f
, se
->section_id
);
6750 len
= strlen(se
->idstr
);
6751 qemu_put_byte(f
, len
);
6752 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6754 qemu_put_be32(f
, se
->instance_id
);
6755 qemu_put_be32(f
, se
->version_id
);
6757 se
->save_live_state(f
, QEMU_VM_SECTION_START
, se
->opaque
);
6760 if (qemu_file_has_error(f
))
6766 int qemu_savevm_state_iterate(QEMUFile
*f
)
6771 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
6772 if (se
->save_live_state
== NULL
)
6776 qemu_put_byte(f
, QEMU_VM_SECTION_PART
);
6777 qemu_put_be32(f
, se
->section_id
);
6779 ret
&= !!se
->save_live_state(f
, QEMU_VM_SECTION_PART
, se
->opaque
);
6785 if (qemu_file_has_error(f
))
6791 int qemu_savevm_state_complete(QEMUFile
*f
)
6795 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
6796 if (se
->save_live_state
== NULL
)
6800 qemu_put_byte(f
, QEMU_VM_SECTION_END
);
6801 qemu_put_be32(f
, se
->section_id
);
6803 se
->save_live_state(f
, QEMU_VM_SECTION_END
, se
->opaque
);
6806 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6809 if (se
->save_state
== NULL
)
6813 qemu_put_byte(f
, QEMU_VM_SECTION_FULL
);
6814 qemu_put_be32(f
, se
->section_id
);
6817 len
= strlen(se
->idstr
);
6818 qemu_put_byte(f
, len
);
6819 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6821 qemu_put_be32(f
, se
->instance_id
);
6822 qemu_put_be32(f
, se
->version_id
);
6824 se
->save_state(f
, se
->opaque
);
6827 qemu_put_byte(f
, QEMU_VM_EOF
);
6829 if (qemu_file_has_error(f
))
6835 int qemu_savevm_state(QEMUFile
*f
)
6837 int saved_vm_running
;
6840 saved_vm_running
= vm_running
;
6845 ret
= qemu_savevm_state_begin(f
);
6850 ret
= qemu_savevm_state_iterate(f
);
6855 ret
= qemu_savevm_state_complete(f
);
6858 if (qemu_file_has_error(f
))
6861 if (!ret
&& saved_vm_running
)
6867 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
6871 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6872 if (!strcmp(se
->idstr
, idstr
) &&
6873 instance_id
== se
->instance_id
)
6879 typedef struct LoadStateEntry
{
6883 struct LoadStateEntry
*next
;
6886 static int qemu_loadvm_state_v2(QEMUFile
*f
)
6889 int len
, ret
, instance_id
, record_len
, version_id
;
6890 int64_t total_len
, end_pos
, cur_pos
;
6893 total_len
= qemu_get_be64(f
);
6894 end_pos
= total_len
+ qemu_ftell(f
);
6896 if (qemu_ftell(f
) >= end_pos
)
6898 len
= qemu_get_byte(f
);
6899 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6901 instance_id
= qemu_get_be32(f
);
6902 version_id
= qemu_get_be32(f
);
6903 record_len
= qemu_get_be32(f
);
6904 cur_pos
= qemu_ftell(f
);
6905 se
= find_se(idstr
, instance_id
);
6907 fprintf(stderr
, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6908 instance_id
, idstr
);
6910 ret
= se
->load_state(f
, se
->opaque
, version_id
);
6912 fprintf(stderr
, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6913 instance_id
, idstr
);
6916 /* always seek to exact end of record */
6917 qemu_fseek(f
, cur_pos
+ record_len
, SEEK_SET
);
6920 if (qemu_file_has_error(f
))
6926 int qemu_loadvm_state(QEMUFile
*f
)
6928 LoadStateEntry
*first_le
= NULL
;
6929 uint8_t section_type
;
6933 v
= qemu_get_be32(f
);
6934 if (v
!= QEMU_VM_FILE_MAGIC
)
6937 v
= qemu_get_be32(f
);
6938 if (v
== QEMU_VM_FILE_VERSION_COMPAT
)
6939 return qemu_loadvm_state_v2(f
);
6940 if (v
!= QEMU_VM_FILE_VERSION
)
6943 while ((section_type
= qemu_get_byte(f
)) != QEMU_VM_EOF
) {
6944 uint32_t instance_id
, version_id
, section_id
;
6950 switch (section_type
) {
6951 case QEMU_VM_SECTION_START
:
6952 case QEMU_VM_SECTION_FULL
:
6953 /* Read section start */
6954 section_id
= qemu_get_be32(f
);
6955 len
= qemu_get_byte(f
);
6956 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6958 instance_id
= qemu_get_be32(f
);
6959 version_id
= qemu_get_be32(f
);
6961 /* Find savevm section */
6962 se
= find_se(idstr
, instance_id
);
6964 fprintf(stderr
, "Unknown savevm section or instance '%s' %d\n", idstr
, instance_id
);
6969 /* Validate version */
6970 if (version_id
> se
->version_id
) {
6971 fprintf(stderr
, "savevm: unsupported version %d for '%s' v%d\n",
6972 version_id
, idstr
, se
->version_id
);
6978 le
= qemu_mallocz(sizeof(*le
));
6985 le
->section_id
= section_id
;
6986 le
->version_id
= version_id
;
6987 le
->next
= first_le
;
6990 le
->se
->load_state(f
, le
->se
->opaque
, le
->version_id
);
6992 case QEMU_VM_SECTION_PART
:
6993 case QEMU_VM_SECTION_END
:
6994 section_id
= qemu_get_be32(f
);
6996 for (le
= first_le
; le
&& le
->section_id
!= section_id
; le
= le
->next
);
6998 fprintf(stderr
, "Unknown savevm section %d\n", section_id
);
7003 le
->se
->load_state(f
, le
->se
->opaque
, le
->version_id
);
7006 fprintf(stderr
, "Unknown savevm section type %d\n", section_type
);
7016 LoadStateEntry
*le
= first_le
;
7017 first_le
= first_le
->next
;
7021 if (qemu_file_has_error(f
))
7027 /* device can contain snapshots */
7028 static int bdrv_can_snapshot(BlockDriverState
*bs
)
7031 !bdrv_is_removable(bs
) &&
7032 !bdrv_is_read_only(bs
));
7035 /* device must be snapshots in order to have a reliable snapshot */
7036 static int bdrv_has_snapshot(BlockDriverState
*bs
)
7039 !bdrv_is_removable(bs
) &&
7040 !bdrv_is_read_only(bs
));
7043 static BlockDriverState
*get_bs_snapshots(void)
7045 BlockDriverState
*bs
;
7049 return bs_snapshots
;
7050 for(i
= 0; i
<= nb_drives
; i
++) {
7051 bs
= drives_table
[i
].bdrv
;
7052 if (bdrv_can_snapshot(bs
))
7061 static int bdrv_snapshot_find(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
,
7064 QEMUSnapshotInfo
*sn_tab
, *sn
;
7068 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
7071 for(i
= 0; i
< nb_sns
; i
++) {
7073 if (!strcmp(sn
->id_str
, name
) || !strcmp(sn
->name
, name
)) {
7083 void do_savevm(const char *name
)
7085 BlockDriverState
*bs
, *bs1
;
7086 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
7087 int must_delete
, ret
, i
;
7088 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
7090 int saved_vm_running
;
7097 bs
= get_bs_snapshots();
7099 term_printf("No block device can accept snapshots\n");
7103 /* ??? Should this occur after vm_stop? */
7106 saved_vm_running
= vm_running
;
7111 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
7116 memset(sn
, 0, sizeof(*sn
));
7118 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
7119 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
7122 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
7125 /* fill auxiliary fields */
7128 sn
->date_sec
= tb
.time
;
7129 sn
->date_nsec
= tb
.millitm
* 1000000;
7131 gettimeofday(&tv
, NULL
);
7132 sn
->date_sec
= tv
.tv_sec
;
7133 sn
->date_nsec
= tv
.tv_usec
* 1000;
7135 sn
->vm_clock_nsec
= qemu_get_clock(vm_clock
);
7137 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
7138 term_printf("Device %s does not support VM state snapshots\n",
7139 bdrv_get_device_name(bs
));
7143 /* save the VM state */
7144 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 1);
7146 term_printf("Could not open VM state file\n");
7149 ret
= qemu_savevm_state(f
);
7150 sn
->vm_state_size
= qemu_ftell(f
);
7153 term_printf("Error %d while writing VM\n", ret
);
7157 /* create the snapshots */
7159 for(i
= 0; i
< nb_drives
; i
++) {
7160 bs1
= drives_table
[i
].bdrv
;
7161 if (bdrv_has_snapshot(bs1
)) {
7163 ret
= bdrv_snapshot_delete(bs1
, old_sn
->id_str
);
7165 term_printf("Error while deleting snapshot on '%s'\n",
7166 bdrv_get_device_name(bs1
));
7169 ret
= bdrv_snapshot_create(bs1
, sn
);
7171 term_printf("Error while creating snapshot on '%s'\n",
7172 bdrv_get_device_name(bs1
));
7178 if (saved_vm_running
)
7182 void do_loadvm(const char *name
)
7184 BlockDriverState
*bs
, *bs1
;
7185 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
7188 int saved_vm_running
;
7190 bs
= get_bs_snapshots();
7192 term_printf("No block device supports snapshots\n");
7196 /* Flush all IO requests so they don't interfere with the new state. */
7199 saved_vm_running
= vm_running
;
7202 for(i
= 0; i
<= nb_drives
; i
++) {
7203 bs1
= drives_table
[i
].bdrv
;
7204 if (bdrv_has_snapshot(bs1
)) {
7205 ret
= bdrv_snapshot_goto(bs1
, name
);
7208 term_printf("Warning: ");
7211 term_printf("Snapshots not supported on device '%s'\n",
7212 bdrv_get_device_name(bs1
));
7215 term_printf("Could not find snapshot '%s' on device '%s'\n",
7216 name
, bdrv_get_device_name(bs1
));
7219 term_printf("Error %d while activating snapshot on '%s'\n",
7220 ret
, bdrv_get_device_name(bs1
));
7223 /* fatal on snapshot block device */
7230 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
7231 term_printf("Device %s does not support VM state snapshots\n",
7232 bdrv_get_device_name(bs
));
7236 /* restore the VM state */
7237 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 0);
7239 term_printf("Could not open VM state file\n");
7242 ret
= qemu_loadvm_state(f
);
7245 term_printf("Error %d while loading VM state\n", ret
);
7248 if (saved_vm_running
)
7252 void do_delvm(const char *name
)
7254 BlockDriverState
*bs
, *bs1
;
7257 bs
= get_bs_snapshots();
7259 term_printf("No block device supports snapshots\n");
7263 for(i
= 0; i
<= nb_drives
; i
++) {
7264 bs1
= drives_table
[i
].bdrv
;
7265 if (bdrv_has_snapshot(bs1
)) {
7266 ret
= bdrv_snapshot_delete(bs1
, name
);
7268 if (ret
== -ENOTSUP
)
7269 term_printf("Snapshots not supported on device '%s'\n",
7270 bdrv_get_device_name(bs1
));
7272 term_printf("Error %d while deleting snapshot on '%s'\n",
7273 ret
, bdrv_get_device_name(bs1
));
7279 void do_info_snapshots(void)
7281 BlockDriverState
*bs
, *bs1
;
7282 QEMUSnapshotInfo
*sn_tab
, *sn
;
7286 bs
= get_bs_snapshots();
7288 term_printf("No available block device supports snapshots\n");
7291 term_printf("Snapshot devices:");
7292 for(i
= 0; i
<= nb_drives
; i
++) {
7293 bs1
= drives_table
[i
].bdrv
;
7294 if (bdrv_has_snapshot(bs1
)) {
7296 term_printf(" %s", bdrv_get_device_name(bs1
));
7301 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
7303 term_printf("bdrv_snapshot_list: error %d\n", nb_sns
);
7306 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs
));
7307 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
7308 for(i
= 0; i
< nb_sns
; i
++) {
7310 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
7315 /***********************************************************/
7316 /* ram save/restore */
7318 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
7322 v
= qemu_get_byte(f
);
7325 if (qemu_get_buffer(f
, buf
, len
) != len
)
7329 v
= qemu_get_byte(f
);
7330 memset(buf
, v
, len
);
7336 if (qemu_file_has_error(f
))
7342 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
7347 if (qemu_get_be32(f
) != phys_ram_size
)
7349 for(i
= 0; i
< phys_ram_size
; i
+= TARGET_PAGE_SIZE
) {
7350 ret
= ram_get_page(f
, phys_ram_base
+ i
, TARGET_PAGE_SIZE
);
7357 #define BDRV_HASH_BLOCK_SIZE 1024
7358 #define IOBUF_SIZE 4096
7359 #define RAM_CBLOCK_MAGIC 0xfabe
7361 typedef struct RamDecompressState
{
7364 uint8_t buf
[IOBUF_SIZE
];
7365 } RamDecompressState
;
7367 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
7370 memset(s
, 0, sizeof(*s
));
7372 ret
= inflateInit(&s
->zstream
);
7378 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
7382 s
->zstream
.avail_out
= len
;
7383 s
->zstream
.next_out
= buf
;
7384 while (s
->zstream
.avail_out
> 0) {
7385 if (s
->zstream
.avail_in
== 0) {
7386 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
7388 clen
= qemu_get_be16(s
->f
);
7389 if (clen
> IOBUF_SIZE
)
7391 qemu_get_buffer(s
->f
, s
->buf
, clen
);
7392 s
->zstream
.avail_in
= clen
;
7393 s
->zstream
.next_in
= s
->buf
;
7395 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
7396 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
7403 static void ram_decompress_close(RamDecompressState
*s
)
7405 inflateEnd(&s
->zstream
);
7408 #define RAM_SAVE_FLAG_FULL 0x01
7409 #define RAM_SAVE_FLAG_COMPRESS 0x02
7410 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
7411 #define RAM_SAVE_FLAG_PAGE 0x08
7412 #define RAM_SAVE_FLAG_EOS 0x10
7414 static int is_dup_page(uint8_t *page
, uint8_t ch
)
7416 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
7417 uint32_t *array
= (uint32_t *)page
;
7420 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
7421 if (array
[i
] != val
)
7428 static int ram_save_block(QEMUFile
*f
)
7430 static ram_addr_t current_addr
= 0;
7431 ram_addr_t saved_addr
= current_addr
;
7432 ram_addr_t addr
= 0;
7435 while (addr
< phys_ram_size
) {
7436 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
7439 cpu_physical_memory_reset_dirty(current_addr
,
7440 current_addr
+ TARGET_PAGE_SIZE
,
7441 MIGRATION_DIRTY_FLAG
);
7443 ch
= *(phys_ram_base
+ current_addr
);
7445 if (is_dup_page(phys_ram_base
+ current_addr
, ch
)) {
7446 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_COMPRESS
);
7447 qemu_put_byte(f
, ch
);
7449 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_PAGE
);
7450 qemu_put_buffer(f
, phys_ram_base
+ current_addr
, TARGET_PAGE_SIZE
);
7456 addr
+= TARGET_PAGE_SIZE
;
7457 current_addr
= (saved_addr
+ addr
) % phys_ram_size
;
7463 static ram_addr_t ram_save_threshold
= 10;
7465 static ram_addr_t
ram_save_remaining(void)
7468 ram_addr_t count
= 0;
7470 for (addr
= 0; addr
< phys_ram_size
; addr
+= TARGET_PAGE_SIZE
) {
7471 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
7478 static int ram_save_live(QEMUFile
*f
, int stage
, void *opaque
)
7483 /* Make sure all dirty bits are set */
7484 for (addr
= 0; addr
< phys_ram_size
; addr
+= TARGET_PAGE_SIZE
) {
7485 if (!cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
7486 cpu_physical_memory_set_dirty(addr
);
7489 /* Enable dirty memory tracking */
7490 cpu_physical_memory_set_dirty_tracking(1);
7492 qemu_put_be64(f
, phys_ram_size
| RAM_SAVE_FLAG_MEM_SIZE
);
7495 while (!qemu_file_rate_limit(f
)) {
7498 ret
= ram_save_block(f
);
7499 if (ret
== 0) /* no more blocks */
7503 /* try transferring iterative blocks of memory */
7506 cpu_physical_memory_set_dirty_tracking(0);
7508 /* flush all remaining blocks regardless of rate limiting */
7509 while (ram_save_block(f
) != 0);
7512 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
7514 return (stage
== 2) && (ram_save_remaining() < ram_save_threshold
);
7517 static int ram_load_dead(QEMUFile
*f
, void *opaque
)
7519 RamDecompressState s1
, *s
= &s1
;
7523 if (ram_decompress_open(s
, f
) < 0)
7525 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
7526 if (ram_decompress_buf(s
, buf
, 1) < 0) {
7527 fprintf(stderr
, "Error while reading ram block header\n");
7531 if (ram_decompress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
) < 0) {
7532 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
7537 printf("Error block header\n");
7541 ram_decompress_close(s
);
7546 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
7551 if (version_id
== 1)
7552 return ram_load_v1(f
, opaque
);
7554 if (version_id
== 2) {
7555 if (qemu_get_be32(f
) != phys_ram_size
)
7557 return ram_load_dead(f
, opaque
);
7560 if (version_id
!= 3)
7564 addr
= qemu_get_be64(f
);
7566 flags
= addr
& ~TARGET_PAGE_MASK
;
7567 addr
&= TARGET_PAGE_MASK
;
7569 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
7570 if (addr
!= phys_ram_size
)
7574 if (flags
& RAM_SAVE_FLAG_FULL
) {
7575 if (ram_load_dead(f
, opaque
) < 0)
7579 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
7580 uint8_t ch
= qemu_get_byte(f
);
7581 memset(phys_ram_base
+ addr
, ch
, TARGET_PAGE_SIZE
);
7582 } else if (flags
& RAM_SAVE_FLAG_PAGE
)
7583 qemu_get_buffer(f
, phys_ram_base
+ addr
, TARGET_PAGE_SIZE
);
7584 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
7589 void qemu_service_io(void)
7591 CPUState
*env
= cpu_single_env
;
7593 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
7595 if (env
->kqemu_enabled
) {
7596 kqemu_cpu_interrupt(env
);
7602 /***********************************************************/
7603 /* bottom halves (can be seen as timers which expire ASAP) */
7614 static QEMUBH
*first_bh
= NULL
;
7616 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
7619 bh
= qemu_mallocz(sizeof(QEMUBH
));
7623 bh
->opaque
= opaque
;
7624 bh
->next
= first_bh
;
7629 int qemu_bh_poll(void)
7635 for (bh
= first_bh
; bh
; bh
= bh
->next
) {
7636 if (!bh
->deleted
&& bh
->scheduled
) {
7645 /* remove deleted bhs */
7659 void qemu_bh_schedule_idle(QEMUBH
*bh
)
7667 void qemu_bh_schedule(QEMUBH
*bh
)
7669 CPUState
*env
= cpu_single_env
;
7674 /* stop the currently executing CPU to execute the BH ASAP */
7676 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
7680 void qemu_bh_cancel(QEMUBH
*bh
)
7685 void qemu_bh_delete(QEMUBH
*bh
)
7691 /***********************************************************/
7692 /* machine registration */
7694 static QEMUMachine
*first_machine
= NULL
;
7696 int qemu_register_machine(QEMUMachine
*m
)
7699 pm
= &first_machine
;
7707 static QEMUMachine
*find_machine(const char *name
)
7711 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
7712 if (!strcmp(m
->name
, name
))
7718 /***********************************************************/
7719 /* main execution loop */
7721 static void gui_update(void *opaque
)
7723 DisplayState
*ds
= opaque
;
7724 ds
->dpy_refresh(ds
);
7725 qemu_mod_timer(ds
->gui_timer
,
7726 (ds
->gui_timer_interval
?
7727 ds
->gui_timer_interval
:
7728 GUI_REFRESH_INTERVAL
)
7729 + qemu_get_clock(rt_clock
));
7732 struct vm_change_state_entry
{
7733 VMChangeStateHandler
*cb
;
7735 LIST_ENTRY (vm_change_state_entry
) entries
;
7738 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
7740 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
7743 VMChangeStateEntry
*e
;
7745 e
= qemu_mallocz(sizeof (*e
));
7751 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
7755 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
7757 LIST_REMOVE (e
, entries
);
7761 static void vm_state_notify(int running
)
7763 VMChangeStateEntry
*e
;
7765 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
7766 e
->cb(e
->opaque
, running
);
7770 /* XXX: support several handlers */
7771 static VMStopHandler
*vm_stop_cb
;
7772 static void *vm_stop_opaque
;
7774 int qemu_add_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
7777 vm_stop_opaque
= opaque
;
7781 void qemu_del_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
7792 qemu_rearm_alarm_timer(alarm_timer
);
7796 void vm_stop(int reason
)
7799 cpu_disable_ticks();
7803 vm_stop_cb(vm_stop_opaque
, reason
);
7810 /* reset/shutdown handler */
7812 typedef struct QEMUResetEntry
{
7813 QEMUResetHandler
*func
;
7815 struct QEMUResetEntry
*next
;
7818 static QEMUResetEntry
*first_reset_entry
;
7819 static int reset_requested
;
7820 static int shutdown_requested
;
7821 static int powerdown_requested
;
7823 int qemu_shutdown_requested(void)
7825 int r
= shutdown_requested
;
7826 shutdown_requested
= 0;
7830 int qemu_reset_requested(void)
7832 int r
= reset_requested
;
7833 reset_requested
= 0;
7837 int qemu_powerdown_requested(void)
7839 int r
= powerdown_requested
;
7840 powerdown_requested
= 0;
7844 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
7846 QEMUResetEntry
**pre
, *re
;
7848 pre
= &first_reset_entry
;
7849 while (*pre
!= NULL
)
7850 pre
= &(*pre
)->next
;
7851 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
7853 re
->opaque
= opaque
;
7858 void qemu_system_reset(void)
7862 /* reset all devices */
7863 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
7864 re
->func(re
->opaque
);
7868 void qemu_system_reset_request(void)
7871 shutdown_requested
= 1;
7873 reset_requested
= 1;
7876 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7879 void qemu_system_shutdown_request(void)
7881 shutdown_requested
= 1;
7883 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7886 void qemu_system_powerdown_request(void)
7888 powerdown_requested
= 1;
7890 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7893 void main_loop_wait(int timeout
)
7895 IOHandlerRecord
*ioh
;
7896 fd_set rfds
, wfds
, xfds
;
7905 /* XXX: need to suppress polling by better using win32 events */
7907 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
7908 ret
|= pe
->func(pe
->opaque
);
7913 WaitObjects
*w
= &wait_objects
;
7915 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, timeout
);
7916 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
7917 if (w
->func
[ret
- WAIT_OBJECT_0
])
7918 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
7920 /* Check for additional signaled events */
7921 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
7923 /* Check if event is signaled */
7924 ret2
= WaitForSingleObject(w
->events
[i
], 0);
7925 if(ret2
== WAIT_OBJECT_0
) {
7927 w
->func
[i
](w
->opaque
[i
]);
7928 } else if (ret2
== WAIT_TIMEOUT
) {
7930 err
= GetLastError();
7931 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
7934 } else if (ret
== WAIT_TIMEOUT
) {
7936 err
= GetLastError();
7937 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
7941 /* poll any events */
7942 /* XXX: separate device handlers from system ones */
7947 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7951 (!ioh
->fd_read_poll
||
7952 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
7953 FD_SET(ioh
->fd
, &rfds
);
7957 if (ioh
->fd_write
) {
7958 FD_SET(ioh
->fd
, &wfds
);
7968 tv
.tv_usec
= timeout
* 1000;
7970 #if defined(CONFIG_SLIRP)
7972 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
7975 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
7977 IOHandlerRecord
**pioh
;
7979 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7980 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
7981 ioh
->fd_read(ioh
->opaque
);
7983 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
7984 ioh
->fd_write(ioh
->opaque
);
7988 /* remove deleted IO handlers */
7989 pioh
= &first_io_handler
;
7999 #if defined(CONFIG_SLIRP)
8006 slirp_select_poll(&rfds
, &wfds
, &xfds
);
8011 if (likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
8012 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
8013 qemu_get_clock(vm_clock
));
8016 /* real time timers */
8017 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
8018 qemu_get_clock(rt_clock
));
8020 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
8021 alarm_timer
->flags
&= ~(ALARM_FLAG_EXPIRED
);
8022 qemu_rearm_alarm_timer(alarm_timer
);
8025 /* Check bottom-halves last in case any of the earlier events triggered
8031 static int main_loop(void)
8034 #ifdef CONFIG_PROFILER
8039 cur_cpu
= first_cpu
;
8040 next_cpu
= cur_cpu
->next_cpu
?: first_cpu
;
8047 #ifdef CONFIG_PROFILER
8048 ti
= profile_getclock();
8053 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
8054 env
->icount_decr
.u16
.low
= 0;
8055 env
->icount_extra
= 0;
8056 count
= qemu_next_deadline();
8057 count
= (count
+ (1 << icount_time_shift
) - 1)
8058 >> icount_time_shift
;
8059 qemu_icount
+= count
;
8060 decr
= (count
> 0xffff) ? 0xffff : count
;
8062 env
->icount_decr
.u16
.low
= decr
;
8063 env
->icount_extra
= count
;
8065 ret
= cpu_exec(env
);
8066 #ifdef CONFIG_PROFILER
8067 qemu_time
+= profile_getclock() - ti
;
8070 /* Fold pending instructions back into the
8071 instruction counter, and clear the interrupt flag. */
8072 qemu_icount
-= (env
->icount_decr
.u16
.low
8073 + env
->icount_extra
);
8074 env
->icount_decr
.u32
= 0;
8075 env
->icount_extra
= 0;
8077 next_cpu
= env
->next_cpu
?: first_cpu
;
8078 if (event_pending
&& likely(ret
!= EXCP_DEBUG
)) {
8079 ret
= EXCP_INTERRUPT
;
8083 if (ret
== EXCP_HLT
) {
8084 /* Give the next CPU a chance to run. */
8088 if (ret
!= EXCP_HALTED
)
8090 /* all CPUs are halted ? */
8096 if (shutdown_requested
) {
8097 ret
= EXCP_INTERRUPT
;
8105 if (reset_requested
) {
8106 reset_requested
= 0;
8107 qemu_system_reset();
8108 ret
= EXCP_INTERRUPT
;
8110 if (powerdown_requested
) {
8111 powerdown_requested
= 0;
8112 qemu_system_powerdown();
8113 ret
= EXCP_INTERRUPT
;
8115 if (unlikely(ret
== EXCP_DEBUG
)) {
8116 vm_stop(EXCP_DEBUG
);
8118 /* If all cpus are halted then wait until the next IRQ */
8119 /* XXX: use timeout computed from timers */
8120 if (ret
== EXCP_HALTED
) {
8124 /* Advance virtual time to the next event. */
8125 if (use_icount
== 1) {
8126 /* When not using an adaptive execution frequency
8127 we tend to get badly out of sync with real time,
8128 so just delay for a reasonable amount of time. */
8131 delta
= cpu_get_icount() - cpu_get_clock();
8134 /* If virtual time is ahead of real time then just
8136 timeout
= (delta
/ 1000000) + 1;
8138 /* Wait for either IO to occur or the next
8140 add
= qemu_next_deadline();
8141 /* We advance the timer before checking for IO.
8142 Limit the amount we advance so that early IO
8143 activity won't get the guest too far ahead. */
8147 add
= (add
+ (1 << icount_time_shift
) - 1)
8148 >> icount_time_shift
;
8150 timeout
= delta
/ 1000000;
8161 if (shutdown_requested
) {
8162 ret
= EXCP_INTERRUPT
;
8167 #ifdef CONFIG_PROFILER
8168 ti
= profile_getclock();
8170 main_loop_wait(timeout
);
8171 #ifdef CONFIG_PROFILER
8172 dev_time
+= profile_getclock() - ti
;
8175 cpu_disable_ticks();
8179 static void help(int exitcode
)
8181 printf("QEMU PC emulator version " QEMU_VERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n"
8182 "usage: %s [options] [disk_image]\n"
8184 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
8186 "Standard options:\n"
8187 "-M machine select emulated machine (-M ? for list)\n"
8188 "-cpu cpu select CPU (-cpu ? for list)\n"
8189 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
8190 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
8191 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
8192 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
8193 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
8194 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
8195 " [,cache=writethrough|writeback|none][,format=f]\n"
8196 " use 'file' as a drive image\n"
8197 "-mtdblock file use 'file' as on-board Flash memory image\n"
8198 "-sd file use 'file' as SecureDigital card image\n"
8199 "-pflash file use 'file' as a parallel flash image\n"
8200 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
8201 "-snapshot write to temporary files instead of disk image files\n"
8203 "-no-frame open SDL window without a frame and window decorations\n"
8204 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
8205 "-no-quit disable SDL window close capability\n"
8208 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
8210 "-m megs set virtual RAM size to megs MB [default=%d]\n"
8211 "-smp n set the number of CPUs to 'n' [default=1]\n"
8212 "-nographic disable graphical output and redirect serial I/Os to console\n"
8213 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
8215 "-k language use keyboard layout (for example \"fr\" for French)\n"
8218 "-audio-help print list of audio drivers and their options\n"
8219 "-soundhw c1,... enable audio support\n"
8220 " and only specified sound cards (comma separated list)\n"
8221 " use -soundhw ? to get the list of supported cards\n"
8222 " use -soundhw all to enable all of them\n"
8224 "-vga [std|cirrus|vmware]\n"
8225 " select video card type\n"
8226 "-localtime set the real time clock to local time [default=utc]\n"
8227 "-full-screen start in full screen\n"
8229 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
8231 "-usb enable the USB driver (will be the default soon)\n"
8232 "-usbdevice name add the host or guest USB device 'name'\n"
8233 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8234 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
8236 "-name string set the name of the guest\n"
8237 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
8239 "Network options:\n"
8240 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
8241 " create a new Network Interface Card and connect it to VLAN 'n'\n"
8243 "-net user[,vlan=n][,hostname=host]\n"
8244 " connect the user mode network stack to VLAN 'n' and send\n"
8245 " hostname 'host' to DHCP clients\n"
8248 "-net tap[,vlan=n],ifname=name\n"
8249 " connect the host TAP network interface to VLAN 'n'\n"
8251 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
8252 " connect the host TAP network interface to VLAN 'n' and use the\n"
8253 " network scripts 'file' (default=%s)\n"
8254 " and 'dfile' (default=%s);\n"
8255 " use '[down]script=no' to disable script execution;\n"
8256 " use 'fd=h' to connect to an already opened TAP interface\n"
8258 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
8259 " connect the vlan 'n' to another VLAN using a socket connection\n"
8260 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
8261 " connect the vlan 'n' to multicast maddr and port\n"
8263 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
8264 " connect the vlan 'n' to port 'n' of a vde switch running\n"
8265 " on host and listening for incoming connections on 'socketpath'.\n"
8266 " Use group 'groupname' and mode 'octalmode' to change default\n"
8267 " ownership and permissions for communication port.\n"
8269 "-net none use it alone to have zero network devices; if no -net option\n"
8270 " is provided, the default is '-net nic -net user'\n"
8273 "-tftp dir allow tftp access to files in dir [-net user]\n"
8274 "-bootp file advertise file in BOOTP replies\n"
8276 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
8278 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
8279 " redirect TCP or UDP connections from host to guest [-net user]\n"
8282 "Linux boot specific:\n"
8283 "-kernel bzImage use 'bzImage' as kernel image\n"
8284 "-append cmdline use 'cmdline' as kernel command line\n"
8285 "-initrd file use 'file' as initial ram disk\n"
8287 "Debug/Expert options:\n"
8288 "-monitor dev redirect the monitor to char device 'dev'\n"
8289 "-serial dev redirect the serial port to char device 'dev'\n"
8290 "-parallel dev redirect the parallel port to char device 'dev'\n"
8291 "-pidfile file Write PID to 'file'\n"
8292 "-S freeze CPU at startup (use 'c' to start execution)\n"
8293 "-s wait gdb connection to port\n"
8294 "-p port set gdb connection port [default=%s]\n"
8295 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
8296 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
8297 " translation (t=none or lba) (usually qemu can guess them)\n"
8298 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
8300 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
8301 "-no-kqemu disable KQEMU kernel module usage\n"
8304 "-no-acpi disable ACPI\n"
8306 #ifdef CONFIG_CURSES
8307 "-curses use a curses/ncurses interface instead of SDL\n"
8309 "-no-reboot exit instead of rebooting\n"
8310 "-no-shutdown stop before shutdown\n"
8311 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
8312 "-vnc display start a VNC server on display\n"
8314 "-daemonize daemonize QEMU after initializing\n"
8316 "-option-rom rom load a file, rom, into the option ROM space\n"
8318 "-prom-env variable=value set OpenBIOS nvram variables\n"
8320 "-clock force the use of the given methods for timer alarm.\n"
8321 " To see what timers are available use -clock ?\n"
8322 "-startdate select initial date of the clock\n"
8323 "-icount [N|auto]\n"
8324 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
8326 "During emulation, the following keys are useful:\n"
8327 "ctrl-alt-f toggle full screen\n"
8328 "ctrl-alt-n switch to virtual console 'n'\n"
8329 "ctrl-alt toggle mouse and keyboard grab\n"
8331 "When using -nographic, press 'ctrl-a h' to get some help.\n"
8336 DEFAULT_NETWORK_SCRIPT
,
8337 DEFAULT_NETWORK_DOWN_SCRIPT
,
8339 DEFAULT_GDBSTUB_PORT
,
8344 #define HAS_ARG 0x0001
8359 QEMU_OPTION_mtdblock
,
8363 QEMU_OPTION_snapshot
,
8365 QEMU_OPTION_no_fd_bootchk
,
8368 QEMU_OPTION_nographic
,
8369 QEMU_OPTION_portrait
,
8371 QEMU_OPTION_audio_help
,
8372 QEMU_OPTION_soundhw
,
8393 QEMU_OPTION_localtime
,
8397 QEMU_OPTION_monitor
,
8399 QEMU_OPTION_parallel
,
8401 QEMU_OPTION_full_screen
,
8402 QEMU_OPTION_no_frame
,
8403 QEMU_OPTION_alt_grab
,
8404 QEMU_OPTION_no_quit
,
8405 QEMU_OPTION_pidfile
,
8406 QEMU_OPTION_no_kqemu
,
8407 QEMU_OPTION_kernel_kqemu
,
8408 QEMU_OPTION_win2k_hack
,
8410 QEMU_OPTION_usbdevice
,
8413 QEMU_OPTION_no_acpi
,
8415 QEMU_OPTION_no_reboot
,
8416 QEMU_OPTION_no_shutdown
,
8417 QEMU_OPTION_show_cursor
,
8418 QEMU_OPTION_daemonize
,
8419 QEMU_OPTION_option_rom
,
8420 QEMU_OPTION_semihosting
,
8422 QEMU_OPTION_prom_env
,
8423 QEMU_OPTION_old_param
,
8425 QEMU_OPTION_startdate
,
8426 QEMU_OPTION_tb_size
,
8429 QEMU_OPTION_incoming
,
8432 typedef struct QEMUOption
{
8438 static const QEMUOption qemu_options
[] = {
8439 { "h", 0, QEMU_OPTION_h
},
8440 { "help", 0, QEMU_OPTION_h
},
8442 { "M", HAS_ARG
, QEMU_OPTION_M
},
8443 { "cpu", HAS_ARG
, QEMU_OPTION_cpu
},
8444 { "fda", HAS_ARG
, QEMU_OPTION_fda
},
8445 { "fdb", HAS_ARG
, QEMU_OPTION_fdb
},
8446 { "hda", HAS_ARG
, QEMU_OPTION_hda
},
8447 { "hdb", HAS_ARG
, QEMU_OPTION_hdb
},
8448 { "hdc", HAS_ARG
, QEMU_OPTION_hdc
},
8449 { "hdd", HAS_ARG
, QEMU_OPTION_hdd
},
8450 { "drive", HAS_ARG
, QEMU_OPTION_drive
},
8451 { "cdrom", HAS_ARG
, QEMU_OPTION_cdrom
},
8452 { "mtdblock", HAS_ARG
, QEMU_OPTION_mtdblock
},
8453 { "sd", HAS_ARG
, QEMU_OPTION_sd
},
8454 { "pflash", HAS_ARG
, QEMU_OPTION_pflash
},
8455 { "boot", HAS_ARG
, QEMU_OPTION_boot
},
8456 { "snapshot", 0, QEMU_OPTION_snapshot
},
8458 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk
},
8460 { "m", HAS_ARG
, QEMU_OPTION_m
},
8461 { "nographic", 0, QEMU_OPTION_nographic
},
8462 { "portrait", 0, QEMU_OPTION_portrait
},
8463 { "k", HAS_ARG
, QEMU_OPTION_k
},
8465 { "audio-help", 0, QEMU_OPTION_audio_help
},
8466 { "soundhw", HAS_ARG
, QEMU_OPTION_soundhw
},
8469 { "net", HAS_ARG
, QEMU_OPTION_net
},
8471 { "tftp", HAS_ARG
, QEMU_OPTION_tftp
},
8472 { "bootp", HAS_ARG
, QEMU_OPTION_bootp
},
8474 { "smb", HAS_ARG
, QEMU_OPTION_smb
},
8476 { "redir", HAS_ARG
, QEMU_OPTION_redir
},
8479 { "kernel", HAS_ARG
, QEMU_OPTION_kernel
},
8480 { "append", HAS_ARG
, QEMU_OPTION_append
},
8481 { "initrd", HAS_ARG
, QEMU_OPTION_initrd
},
8483 { "S", 0, QEMU_OPTION_S
},
8484 { "s", 0, QEMU_OPTION_s
},
8485 { "p", HAS_ARG
, QEMU_OPTION_p
},
8486 { "d", HAS_ARG
, QEMU_OPTION_d
},
8487 { "hdachs", HAS_ARG
, QEMU_OPTION_hdachs
},
8488 { "L", HAS_ARG
, QEMU_OPTION_L
},
8489 { "bios", HAS_ARG
, QEMU_OPTION_bios
},
8491 { "no-kqemu", 0, QEMU_OPTION_no_kqemu
},
8492 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu
},
8494 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8495 { "g", 1, QEMU_OPTION_g
},
8497 { "localtime", 0, QEMU_OPTION_localtime
},
8498 { "vga", HAS_ARG
, QEMU_OPTION_vga
},
8499 { "echr", HAS_ARG
, QEMU_OPTION_echr
},
8500 { "monitor", HAS_ARG
, QEMU_OPTION_monitor
},
8501 { "serial", HAS_ARG
, QEMU_OPTION_serial
},
8502 { "parallel", HAS_ARG
, QEMU_OPTION_parallel
},
8503 { "loadvm", HAS_ARG
, QEMU_OPTION_loadvm
},
8504 { "full-screen", 0, QEMU_OPTION_full_screen
},
8506 { "no-frame", 0, QEMU_OPTION_no_frame
},
8507 { "alt-grab", 0, QEMU_OPTION_alt_grab
},
8508 { "no-quit", 0, QEMU_OPTION_no_quit
},
8510 { "pidfile", HAS_ARG
, QEMU_OPTION_pidfile
},
8511 { "win2k-hack", 0, QEMU_OPTION_win2k_hack
},
8512 { "usbdevice", HAS_ARG
, QEMU_OPTION_usbdevice
},
8513 { "smp", HAS_ARG
, QEMU_OPTION_smp
},
8514 { "vnc", HAS_ARG
, QEMU_OPTION_vnc
},
8515 #ifdef CONFIG_CURSES
8516 { "curses", 0, QEMU_OPTION_curses
},
8518 { "uuid", HAS_ARG
, QEMU_OPTION_uuid
},
8520 /* temporary options */
8521 { "usb", 0, QEMU_OPTION_usb
},
8522 { "no-acpi", 0, QEMU_OPTION_no_acpi
},
8523 { "no-reboot", 0, QEMU_OPTION_no_reboot
},
8524 { "no-shutdown", 0, QEMU_OPTION_no_shutdown
},
8525 { "show-cursor", 0, QEMU_OPTION_show_cursor
},
8526 { "daemonize", 0, QEMU_OPTION_daemonize
},
8527 { "option-rom", HAS_ARG
, QEMU_OPTION_option_rom
},
8528 #if defined(TARGET_ARM) || defined(TARGET_M68K)
8529 { "semihosting", 0, QEMU_OPTION_semihosting
},
8531 { "name", HAS_ARG
, QEMU_OPTION_name
},
8532 #if defined(TARGET_SPARC)
8533 { "prom-env", HAS_ARG
, QEMU_OPTION_prom_env
},
8535 #if defined(TARGET_ARM)
8536 { "old-param", 0, QEMU_OPTION_old_param
},
8538 { "clock", HAS_ARG
, QEMU_OPTION_clock
},
8539 { "startdate", HAS_ARG
, QEMU_OPTION_startdate
},
8540 { "tb-size", HAS_ARG
, QEMU_OPTION_tb_size
},
8541 { "icount", HAS_ARG
, QEMU_OPTION_icount
},
8542 { "incoming", HAS_ARG
, QEMU_OPTION_incoming
},
8546 /* password input */
8548 int qemu_key_check(BlockDriverState
*bs
, const char *name
)
8553 if (!bdrv_is_encrypted(bs
))
8556 term_printf("%s is encrypted.\n", name
);
8557 for(i
= 0; i
< 3; i
++) {
8558 monitor_readline("Password: ", 1, password
, sizeof(password
));
8559 if (bdrv_set_key(bs
, password
) == 0)
8561 term_printf("invalid password\n");
8566 static BlockDriverState
*get_bdrv(int index
)
8568 if (index
> nb_drives
)
8570 return drives_table
[index
].bdrv
;
8573 static void read_passwords(void)
8575 BlockDriverState
*bs
;
8578 for(i
= 0; i
< 6; i
++) {
8581 qemu_key_check(bs
, bdrv_get_device_name(bs
));
8586 struct soundhw soundhw
[] = {
8587 #ifdef HAS_AUDIO_CHOICE
8588 #if defined(TARGET_I386) || defined(TARGET_MIPS)
8594 { .init_isa
= pcspk_audio_init
}
8599 "Creative Sound Blaster 16",
8602 { .init_isa
= SB16_init
}
8605 #ifdef CONFIG_CS4231A
8611 { .init_isa
= cs4231a_init
}
8619 "Yamaha YMF262 (OPL3)",
8621 "Yamaha YM3812 (OPL2)",
8625 { .init_isa
= Adlib_init
}
8632 "Gravis Ultrasound GF1",
8635 { .init_isa
= GUS_init
}
8642 "Intel 82801AA AC97 Audio",
8645 { .init_pci
= ac97_init
}
8651 "ENSONIQ AudioPCI ES1370",
8654 { .init_pci
= es1370_init
}
8658 { NULL
, NULL
, 0, 0, { NULL
} }
8661 static void select_soundhw (const char *optarg
)
8665 if (*optarg
== '?') {
8668 printf ("Valid sound card names (comma separated):\n");
8669 for (c
= soundhw
; c
->name
; ++c
) {
8670 printf ("%-11s %s\n", c
->name
, c
->descr
);
8672 printf ("\n-soundhw all will enable all of the above\n");
8673 exit (*optarg
!= '?');
8681 if (!strcmp (optarg
, "all")) {
8682 for (c
= soundhw
; c
->name
; ++c
) {
8690 e
= strchr (p
, ',');
8691 l
= !e
? strlen (p
) : (size_t) (e
- p
);
8693 for (c
= soundhw
; c
->name
; ++c
) {
8694 if (!strncmp (c
->name
, p
, l
)) {
8703 "Unknown sound card name (too big to show)\n");
8706 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
8711 p
+= l
+ (e
!= NULL
);
8715 goto show_valid_cards
;
8720 static void select_vgahw (const char *p
)
8724 if (strstart(p
, "std", &opts
)) {
8725 cirrus_vga_enabled
= 0;
8727 } else if (strstart(p
, "cirrus", &opts
)) {
8728 cirrus_vga_enabled
= 1;
8730 } else if (strstart(p
, "vmware", &opts
)) {
8731 cirrus_vga_enabled
= 0;
8735 fprintf(stderr
, "Unknown vga type: %s\n", p
);
8739 const char *nextopt
;
8741 if (strstart(opts
, ",retrace=", &nextopt
)) {
8743 if (strstart(opts
, "dumb", &nextopt
))
8744 vga_retrace_method
= VGA_RETRACE_DUMB
;
8745 else if (strstart(opts
, "precise", &nextopt
))
8746 vga_retrace_method
= VGA_RETRACE_PRECISE
;
8747 else goto invalid_vga
;
8748 } else goto invalid_vga
;
8754 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
8756 exit(STATUS_CONTROL_C_EXIT
);
8761 static int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
8765 if(strlen(str
) != 36)
8768 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
8769 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
8770 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
8778 #define MAX_NET_CLIENTS 32
8782 static void termsig_handler(int signal
)
8784 qemu_system_shutdown_request();
8787 static void termsig_setup(void)
8789 struct sigaction act
;
8791 memset(&act
, 0, sizeof(act
));
8792 act
.sa_handler
= termsig_handler
;
8793 sigaction(SIGINT
, &act
, NULL
);
8794 sigaction(SIGHUP
, &act
, NULL
);
8795 sigaction(SIGTERM
, &act
, NULL
);
8800 int main(int argc
, char **argv
)
8802 #ifdef CONFIG_GDBSTUB
8804 const char *gdbstub_port
;
8806 uint32_t boot_devices_bitmap
= 0;
8808 int snapshot
, linux_boot
, net_boot
;
8809 const char *initrd_filename
;
8810 const char *kernel_filename
, *kernel_cmdline
;
8811 const char *boot_devices
= "";
8812 DisplayState
*ds
= &display_state
;
8813 int cyls
, heads
, secs
, translation
;
8814 const char *net_clients
[MAX_NET_CLIENTS
];
8818 const char *r
, *optarg
;
8819 CharDriverState
*monitor_hd
;
8820 const char *monitor_device
;
8821 const char *serial_devices
[MAX_SERIAL_PORTS
];
8822 int serial_device_index
;
8823 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
8824 int parallel_device_index
;
8825 const char *loadvm
= NULL
;
8826 QEMUMachine
*machine
;
8827 const char *cpu_model
;
8828 const char *usb_devices
[MAX_USB_CMDLINE
];
8829 int usb_devices_index
;
8832 const char *pid_file
= NULL
;
8835 const char *incoming
= NULL
;
8837 LIST_INIT (&vm_change_state_head
);
8840 struct sigaction act
;
8841 sigfillset(&act
.sa_mask
);
8843 act
.sa_handler
= SIG_IGN
;
8844 sigaction(SIGPIPE
, &act
, NULL
);
8847 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
8848 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8849 QEMU to run on a single CPU */
8854 h
= GetCurrentProcess();
8855 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
8856 for(i
= 0; i
< 32; i
++) {
8857 if (mask
& (1 << i
))
8862 SetProcessAffinityMask(h
, mask
);
8868 register_machines();
8869 machine
= first_machine
;
8871 initrd_filename
= NULL
;
8873 vga_ram_size
= VGA_RAM_SIZE
;
8874 #ifdef CONFIG_GDBSTUB
8876 gdbstub_port
= DEFAULT_GDBSTUB_PORT
;
8881 kernel_filename
= NULL
;
8882 kernel_cmdline
= "";
8883 cyls
= heads
= secs
= 0;
8884 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8885 monitor_device
= "vc";
8887 serial_devices
[0] = "vc:80Cx24C";
8888 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
8889 serial_devices
[i
] = NULL
;
8890 serial_device_index
= 0;
8892 parallel_devices
[0] = "vc:640x480";
8893 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
8894 parallel_devices
[i
] = NULL
;
8895 parallel_device_index
= 0;
8897 usb_devices_index
= 0;
8915 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
8917 const QEMUOption
*popt
;
8920 /* Treat --foo the same as -foo. */
8923 popt
= qemu_options
;
8926 fprintf(stderr
, "%s: invalid option -- '%s'\n",
8930 if (!strcmp(popt
->name
, r
+ 1))
8934 if (popt
->flags
& HAS_ARG
) {
8935 if (optind
>= argc
) {
8936 fprintf(stderr
, "%s: option '%s' requires an argument\n",
8940 optarg
= argv
[optind
++];
8945 switch(popt
->index
) {
8947 machine
= find_machine(optarg
);
8950 printf("Supported machines are:\n");
8951 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
8952 printf("%-10s %s%s\n",
8954 m
== first_machine
? " (default)" : "");
8956 exit(*optarg
!= '?');
8959 case QEMU_OPTION_cpu
:
8960 /* hw initialization will check this */
8961 if (*optarg
== '?') {
8962 /* XXX: implement xxx_cpu_list for targets that still miss it */
8963 #if defined(cpu_list)
8964 cpu_list(stdout
, &fprintf
);
8971 case QEMU_OPTION_initrd
:
8972 initrd_filename
= optarg
;
8974 case QEMU_OPTION_hda
:
8976 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
8978 hda_index
= drive_add(optarg
, HD_ALIAS
8979 ",cyls=%d,heads=%d,secs=%d%s",
8980 0, cyls
, heads
, secs
,
8981 translation
== BIOS_ATA_TRANSLATION_LBA
?
8983 translation
== BIOS_ATA_TRANSLATION_NONE
?
8984 ",trans=none" : "");
8986 case QEMU_OPTION_hdb
:
8987 case QEMU_OPTION_hdc
:
8988 case QEMU_OPTION_hdd
:
8989 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
8991 case QEMU_OPTION_drive
:
8992 drive_add(NULL
, "%s", optarg
);
8994 case QEMU_OPTION_mtdblock
:
8995 drive_add(optarg
, MTD_ALIAS
);
8997 case QEMU_OPTION_sd
:
8998 drive_add(optarg
, SD_ALIAS
);
9000 case QEMU_OPTION_pflash
:
9001 drive_add(optarg
, PFLASH_ALIAS
);
9003 case QEMU_OPTION_snapshot
:
9006 case QEMU_OPTION_hdachs
:
9010 cyls
= strtol(p
, (char **)&p
, 0);
9011 if (cyls
< 1 || cyls
> 16383)
9016 heads
= strtol(p
, (char **)&p
, 0);
9017 if (heads
< 1 || heads
> 16)
9022 secs
= strtol(p
, (char **)&p
, 0);
9023 if (secs
< 1 || secs
> 63)
9027 if (!strcmp(p
, "none"))
9028 translation
= BIOS_ATA_TRANSLATION_NONE
;
9029 else if (!strcmp(p
, "lba"))
9030 translation
= BIOS_ATA_TRANSLATION_LBA
;
9031 else if (!strcmp(p
, "auto"))
9032 translation
= BIOS_ATA_TRANSLATION_AUTO
;
9035 } else if (*p
!= '\0') {
9037 fprintf(stderr
, "qemu: invalid physical CHS format\n");
9040 if (hda_index
!= -1)
9041 snprintf(drives_opt
[hda_index
].opt
,
9042 sizeof(drives_opt
[hda_index
].opt
),
9043 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
9044 0, cyls
, heads
, secs
,
9045 translation
== BIOS_ATA_TRANSLATION_LBA
?
9047 translation
== BIOS_ATA_TRANSLATION_NONE
?
9048 ",trans=none" : "");
9051 case QEMU_OPTION_nographic
:
9054 #ifdef CONFIG_CURSES
9055 case QEMU_OPTION_curses
:
9059 case QEMU_OPTION_portrait
:
9062 case QEMU_OPTION_kernel
:
9063 kernel_filename
= optarg
;
9065 case QEMU_OPTION_append
:
9066 kernel_cmdline
= optarg
;
9068 case QEMU_OPTION_cdrom
:
9069 drive_add(optarg
, CDROM_ALIAS
);
9071 case QEMU_OPTION_boot
:
9072 boot_devices
= optarg
;
9073 /* We just do some generic consistency checks */
9075 /* Could easily be extended to 64 devices if needed */
9078 boot_devices_bitmap
= 0;
9079 for (p
= boot_devices
; *p
!= '\0'; p
++) {
9080 /* Allowed boot devices are:
9081 * a b : floppy disk drives
9082 * c ... f : IDE disk drives
9083 * g ... m : machine implementation dependant drives
9084 * n ... p : network devices
9085 * It's up to each machine implementation to check
9086 * if the given boot devices match the actual hardware
9087 * implementation and firmware features.
9089 if (*p
< 'a' || *p
> 'q') {
9090 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
9093 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
9095 "Boot device '%c' was given twice\n",*p
);
9098 boot_devices_bitmap
|= 1 << (*p
- 'a');
9102 case QEMU_OPTION_fda
:
9103 case QEMU_OPTION_fdb
:
9104 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
9107 case QEMU_OPTION_no_fd_bootchk
:
9111 case QEMU_OPTION_net
:
9112 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
9113 fprintf(stderr
, "qemu: too many network clients\n");
9116 net_clients
[nb_net_clients
] = optarg
;
9120 case QEMU_OPTION_tftp
:
9121 tftp_prefix
= optarg
;
9123 case QEMU_OPTION_bootp
:
9124 bootp_filename
= optarg
;
9127 case QEMU_OPTION_smb
:
9128 net_slirp_smb(optarg
);
9131 case QEMU_OPTION_redir
:
9132 net_slirp_redir(optarg
);
9136 case QEMU_OPTION_audio_help
:
9140 case QEMU_OPTION_soundhw
:
9141 select_soundhw (optarg
);
9147 case QEMU_OPTION_m
: {
9151 value
= strtoul(optarg
, &ptr
, 10);
9153 case 0: case 'M': case 'm':
9160 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
9164 /* On 32-bit hosts, QEMU is limited by virtual address space */
9165 if (value
> (2047 << 20)
9167 && HOST_LONG_BITS
== 32
9170 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
9173 if (value
!= (uint64_t)(ram_addr_t
)value
) {
9174 fprintf(stderr
, "qemu: ram size too large\n");
9183 const CPULogItem
*item
;
9185 mask
= cpu_str_to_log_mask(optarg
);
9187 printf("Log items (comma separated):\n");
9188 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
9189 printf("%-10s %s\n", item
->name
, item
->help
);
9196 #ifdef CONFIG_GDBSTUB
9201 gdbstub_port
= optarg
;
9207 case QEMU_OPTION_bios
:
9214 keyboard_layout
= optarg
;
9216 case QEMU_OPTION_localtime
:
9219 case QEMU_OPTION_vga
:
9220 select_vgahw (optarg
);
9227 w
= strtol(p
, (char **)&p
, 10);
9230 fprintf(stderr
, "qemu: invalid resolution or depth\n");
9236 h
= strtol(p
, (char **)&p
, 10);
9241 depth
= strtol(p
, (char **)&p
, 10);
9242 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
9243 depth
!= 24 && depth
!= 32)
9245 } else if (*p
== '\0') {
9246 depth
= graphic_depth
;
9253 graphic_depth
= depth
;
9256 case QEMU_OPTION_echr
:
9259 term_escape_char
= strtol(optarg
, &r
, 0);
9261 printf("Bad argument to echr\n");
9264 case QEMU_OPTION_monitor
:
9265 monitor_device
= optarg
;
9267 case QEMU_OPTION_serial
:
9268 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
9269 fprintf(stderr
, "qemu: too many serial ports\n");
9272 serial_devices
[serial_device_index
] = optarg
;
9273 serial_device_index
++;
9275 case QEMU_OPTION_parallel
:
9276 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
9277 fprintf(stderr
, "qemu: too many parallel ports\n");
9280 parallel_devices
[parallel_device_index
] = optarg
;
9281 parallel_device_index
++;
9283 case QEMU_OPTION_loadvm
:
9286 case QEMU_OPTION_full_screen
:
9290 case QEMU_OPTION_no_frame
:
9293 case QEMU_OPTION_alt_grab
:
9296 case QEMU_OPTION_no_quit
:
9300 case QEMU_OPTION_pidfile
:
9304 case QEMU_OPTION_win2k_hack
:
9305 win2k_install_hack
= 1;
9309 case QEMU_OPTION_no_kqemu
:
9312 case QEMU_OPTION_kernel_kqemu
:
9316 case QEMU_OPTION_usb
:
9319 case QEMU_OPTION_usbdevice
:
9321 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
9322 fprintf(stderr
, "Too many USB devices\n");
9325 usb_devices
[usb_devices_index
] = optarg
;
9326 usb_devices_index
++;
9328 case QEMU_OPTION_smp
:
9329 smp_cpus
= atoi(optarg
);
9331 fprintf(stderr
, "Invalid number of CPUs\n");
9335 case QEMU_OPTION_vnc
:
9336 vnc_display
= optarg
;
9338 case QEMU_OPTION_no_acpi
:
9341 case QEMU_OPTION_no_reboot
:
9344 case QEMU_OPTION_no_shutdown
:
9347 case QEMU_OPTION_show_cursor
:
9350 case QEMU_OPTION_uuid
:
9351 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
9352 fprintf(stderr
, "Fail to parse UUID string."
9353 " Wrong format.\n");
9357 case QEMU_OPTION_daemonize
:
9360 case QEMU_OPTION_option_rom
:
9361 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9362 fprintf(stderr
, "Too many option ROMs\n");
9365 option_rom
[nb_option_roms
] = optarg
;
9368 case QEMU_OPTION_semihosting
:
9369 semihosting_enabled
= 1;
9371 case QEMU_OPTION_name
:
9375 case QEMU_OPTION_prom_env
:
9376 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
9377 fprintf(stderr
, "Too many prom variables\n");
9380 prom_envs
[nb_prom_envs
] = optarg
;
9385 case QEMU_OPTION_old_param
:
9389 case QEMU_OPTION_clock
:
9390 configure_alarms(optarg
);
9392 case QEMU_OPTION_startdate
:
9395 time_t rtc_start_date
;
9396 if (!strcmp(optarg
, "now")) {
9397 rtc_date_offset
= -1;
9399 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
9407 } else if (sscanf(optarg
, "%d-%d-%d",
9410 &tm
.tm_mday
) == 3) {
9419 rtc_start_date
= mktimegm(&tm
);
9420 if (rtc_start_date
== -1) {
9422 fprintf(stderr
, "Invalid date format. Valid format are:\n"
9423 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9426 rtc_date_offset
= time(NULL
) - rtc_start_date
;
9430 case QEMU_OPTION_tb_size
:
9431 tb_size
= strtol(optarg
, NULL
, 0);
9435 case QEMU_OPTION_icount
:
9437 if (strcmp(optarg
, "auto") == 0) {
9438 icount_time_shift
= -1;
9440 icount_time_shift
= strtol(optarg
, NULL
, 0);
9443 case QEMU_OPTION_incoming
:
9450 machine
->max_cpus
= machine
->max_cpus
?: 1; /* Default to UP */
9451 if (smp_cpus
> machine
->max_cpus
) {
9452 fprintf(stderr
, "Number of SMP cpus requested (%d), exceeds max cpus "
9453 "supported by machine `%s' (%d)\n", smp_cpus
, machine
->name
,
9459 if (serial_device_index
== 0)
9460 serial_devices
[0] = "stdio";
9461 if (parallel_device_index
== 0)
9462 parallel_devices
[0] = "null";
9463 if (strncmp(monitor_device
, "vc", 2) == 0)
9464 monitor_device
= "stdio";
9471 if (pipe(fds
) == -1)
9482 len
= read(fds
[0], &status
, 1);
9483 if (len
== -1 && (errno
== EINTR
))
9488 else if (status
== 1) {
9489 fprintf(stderr
, "Could not acquire pidfile\n");
9506 signal(SIGTSTP
, SIG_IGN
);
9507 signal(SIGTTOU
, SIG_IGN
);
9508 signal(SIGTTIN
, SIG_IGN
);
9512 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
9515 write(fds
[1], &status
, 1);
9517 fprintf(stderr
, "Could not acquire pid file\n");
9525 linux_boot
= (kernel_filename
!= NULL
);
9526 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
9528 if (!linux_boot
&& net_boot
== 0 &&
9529 !machine
->nodisk_ok
&& nb_drives_opt
== 0)
9532 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
9533 fprintf(stderr
, "-append only allowed with -kernel option\n");
9537 if (!linux_boot
&& initrd_filename
!= NULL
) {
9538 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
9542 /* boot to floppy or the default cd if no hard disk defined yet */
9543 if (!boot_devices
[0]) {
9544 boot_devices
= "cad";
9546 setvbuf(stdout
, NULL
, _IOLBF
, 0);
9550 if (use_icount
&& icount_time_shift
< 0) {
9552 /* 125MIPS seems a reasonable initial guess at the guest speed.
9553 It will be corrected fairly quickly anyway. */
9554 icount_time_shift
= 3;
9555 init_icount_adjust();
9562 /* init network clients */
9563 if (nb_net_clients
== 0) {
9564 /* if no clients, we use a default config */
9565 net_clients
[nb_net_clients
++] = "nic";
9567 net_clients
[nb_net_clients
++] = "user";
9571 for(i
= 0;i
< nb_net_clients
; i
++) {
9572 if (net_client_parse(net_clients
[i
]) < 0)
9575 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
9576 if (vlan
->nb_guest_devs
== 0 && vlan
->nb_host_devs
== 0)
9578 if (vlan
->nb_guest_devs
== 0)
9579 fprintf(stderr
, "Warning: vlan %d with no nics\n", vlan
->id
);
9580 if (vlan
->nb_host_devs
== 0)
9582 "Warning: vlan %d is not connected to host network\n",
9587 /* XXX: this should be moved in the PC machine instantiation code */
9588 if (net_boot
!= 0) {
9590 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
9591 const char *model
= nd_table
[i
].model
;
9593 if (net_boot
& (1 << i
)) {
9596 snprintf(buf
, sizeof(buf
), "%s/pxe-%s.bin", bios_dir
, model
);
9597 if (get_image_size(buf
) > 0) {
9598 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9599 fprintf(stderr
, "Too many option ROMs\n");
9602 option_rom
[nb_option_roms
] = strdup(buf
);
9609 fprintf(stderr
, "No valid PXE rom found for network device\n");
9615 /* init the memory */
9616 phys_ram_size
= machine
->ram_require
& ~RAMSIZE_FIXED
;
9618 if (machine
->ram_require
& RAMSIZE_FIXED
) {
9620 if (ram_size
< phys_ram_size
) {
9621 fprintf(stderr
, "Machine `%s' requires %llu bytes of memory\n",
9622 machine
->name
, (unsigned long long) phys_ram_size
);
9626 phys_ram_size
= ram_size
;
9628 ram_size
= phys_ram_size
;
9631 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
9633 phys_ram_size
+= ram_size
;
9636 phys_ram_base
= qemu_vmalloc(phys_ram_size
);
9637 if (!phys_ram_base
) {
9638 fprintf(stderr
, "Could not allocate physical memory\n");
9642 /* init the dynamic translator */
9643 cpu_exec_init_all(tb_size
* 1024 * 1024);
9647 /* we always create the cdrom drive, even if no disk is there */
9649 if (nb_drives_opt
< MAX_DRIVES
)
9650 drive_add(NULL
, CDROM_ALIAS
);
9652 /* we always create at least one floppy */
9654 if (nb_drives_opt
< MAX_DRIVES
)
9655 drive_add(NULL
, FD_ALIAS
, 0);
9657 /* we always create one sd slot, even if no card is in it */
9659 if (nb_drives_opt
< MAX_DRIVES
)
9660 drive_add(NULL
, SD_ALIAS
);
9662 /* open the virtual block devices */
9664 for(i
= 0; i
< nb_drives_opt
; i
++)
9665 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
9668 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
9669 register_savevm_live("ram", 0, 3, ram_save_live
, NULL
, ram_load
, NULL
);
9672 memset(&display_state
, 0, sizeof(display_state
));
9675 fprintf(stderr
, "fatal: -nographic can't be used with -curses\n");
9678 /* nearly nothing to do */
9679 dumb_display_init(ds
);
9680 } else if (vnc_display
!= NULL
) {
9681 vnc_display_init(ds
);
9682 if (vnc_display_open(ds
, vnc_display
) < 0)
9685 #if defined(CONFIG_CURSES)
9687 curses_display_init(ds
, full_screen
);
9691 #if defined(CONFIG_SDL)
9692 sdl_display_init(ds
, full_screen
, no_frame
);
9693 #elif defined(CONFIG_COCOA)
9694 cocoa_display_init(ds
, full_screen
);
9696 dumb_display_init(ds
);
9701 /* must be after terminal init, SDL library changes signal handlers */
9705 /* Maintain compatibility with multiple stdio monitors */
9706 if (!strcmp(monitor_device
,"stdio")) {
9707 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
9708 const char *devname
= serial_devices
[i
];
9709 if (devname
&& !strcmp(devname
,"mon:stdio")) {
9710 monitor_device
= NULL
;
9712 } else if (devname
&& !strcmp(devname
,"stdio")) {
9713 monitor_device
= NULL
;
9714 serial_devices
[i
] = "mon:stdio";
9719 if (monitor_device
) {
9720 monitor_hd
= qemu_chr_open("monitor", monitor_device
);
9722 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
9725 monitor_init(monitor_hd
, !nographic
);
9728 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
9729 const char *devname
= serial_devices
[i
];
9730 if (devname
&& strcmp(devname
, "none")) {
9732 snprintf(label
, sizeof(label
), "serial%d", i
);
9733 serial_hds
[i
] = qemu_chr_open(label
, devname
);
9734 if (!serial_hds
[i
]) {
9735 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
9739 if (strstart(devname
, "vc", 0))
9740 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
9744 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
9745 const char *devname
= parallel_devices
[i
];
9746 if (devname
&& strcmp(devname
, "none")) {
9748 snprintf(label
, sizeof(label
), "parallel%d", i
);
9749 parallel_hds
[i
] = qemu_chr_open(label
, devname
);
9750 if (!parallel_hds
[i
]) {
9751 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
9755 if (strstart(devname
, "vc", 0))
9756 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
9760 machine
->init(ram_size
, vga_ram_size
, boot_devices
, ds
,
9761 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
9763 /* init USB devices */
9765 for(i
= 0; i
< usb_devices_index
; i
++) {
9766 if (usb_device_add(usb_devices
[i
]) < 0) {
9767 fprintf(stderr
, "Warning: could not add USB device %s\n",
9773 if (display_state
.dpy_refresh
) {
9774 display_state
.gui_timer
= qemu_new_timer(rt_clock
, gui_update
, &display_state
);
9775 qemu_mod_timer(display_state
.gui_timer
, qemu_get_clock(rt_clock
));
9778 #ifdef CONFIG_GDBSTUB
9780 /* XXX: use standard host:port notation and modify options
9782 if (gdbserver_start(gdbstub_port
) < 0) {
9783 fprintf(stderr
, "qemu: could not open gdbstub device on port '%s'\n",
9794 autostart
= 0; /* fixme how to deal with -daemonize */
9795 qemu_start_incoming_migration(incoming
);
9799 /* XXX: simplify init */
9812 len
= write(fds
[1], &status
, 1);
9813 if (len
== -1 && (errno
== EINTR
))
9820 TFR(fd
= open("/dev/null", O_RDWR
));
9834 #if !defined(_WIN32)
9835 /* close network clients */
9836 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
9837 VLANClientState
*vc
;
9839 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
9840 if (vc
->fd_read
== tap_receive
) {
9842 TAPState
*s
= vc
->opaque
;
9844 if (sscanf(vc
->info_str
, "tap: ifname=%63s ", ifname
) == 1 &&
9846 launch_script(s
->down_script
, ifname
, s
->fd
);
9848 #if defined(CONFIG_VDE)
9849 if (vc
->fd_read
== vde_from_qemu
) {
9850 VDEState
*s
= vc
->opaque
;