4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "hw/boards.h"
27 #include "hw/pcmcia.h"
29 #include "hw/audiodev.h"
37 #include "qemu-timer.h"
38 #include "qemu-char.h"
40 #include "audio/audio.h"
51 #include <sys/times.h>
56 #include <sys/ioctl.h>
57 #include <sys/socket.h>
58 #include <netinet/in.h>
61 #include <sys/select.h>
62 #include <arpa/inet.h>
65 #if !defined(__APPLE__) && !defined(__OpenBSD__)
71 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
72 #include <freebsd/stdlib.h>
76 #include <linux/if_tun.h>
79 #include <linux/rtc.h>
81 /* For the benefit of older linux systems which don't supply it,
82 we use a local copy of hpet.h. */
83 /* #include <linux/hpet.h> */
86 #include <linux/ppdev.h>
87 #include <linux/parport.h>
91 #include <sys/ethernet.h>
92 #include <sys/sockio.h>
93 #include <netinet/arp.h>
94 #include <netinet/in.h>
95 #include <netinet/in_systm.h>
96 #include <netinet/ip.h>
97 #include <netinet/ip_icmp.h> // must come after ip.h
98 #include <netinet/udp.h>
99 #include <netinet/tcp.h>
107 #include "qemu_socket.h"
109 #if defined(CONFIG_SLIRP)
110 #include "libslirp.h"
113 #if defined(__OpenBSD__)
117 #if defined(CONFIG_VDE)
118 #include <libvdeplug.h>
123 #include <sys/timeb.h>
124 #include <mmsystem.h>
125 #define getopt_long_only getopt_long
126 #define memalign(align, size) malloc(size)
133 #endif /* CONFIG_SDL */
137 #define main qemu_main
138 #endif /* CONFIG_COCOA */
142 #include "exec-all.h"
144 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
145 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
147 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
149 #define SMBD_COMMAND "/usr/sbin/smbd"
152 //#define DEBUG_UNUSED_IOPORT
153 //#define DEBUG_IOPORT
155 //#define DEBUG_SLIRP
158 #define DEFAULT_RAM_SIZE 144
160 #define DEFAULT_RAM_SIZE 128
163 /* Max number of USB devices that can be specified on the commandline. */
164 #define MAX_USB_CMDLINE 8
166 /* XXX: use a two level table to limit memory usage */
167 #define MAX_IOPORTS 65536
169 const char *bios_dir
= CONFIG_QEMU_SHAREDIR
;
170 const char *bios_name
= NULL
;
171 static void *ioport_opaque
[MAX_IOPORTS
];
172 static IOPortReadFunc
*ioport_read_table
[3][MAX_IOPORTS
];
173 static IOPortWriteFunc
*ioport_write_table
[3][MAX_IOPORTS
];
174 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
175 to store the VM snapshots */
176 DriveInfo drives_table
[MAX_DRIVES
+1];
178 /* point to the block driver where the snapshots are managed */
179 static BlockDriverState
*bs_snapshots
;
180 static int vga_ram_size
;
181 enum vga_retrace_method vga_retrace_method
= VGA_RETRACE_DUMB
;
182 static DisplayState display_state
;
185 const char* keyboard_layout
= NULL
;
186 int64_t ticks_per_sec
;
189 NICInfo nd_table
[MAX_NICS
];
191 static int rtc_utc
= 1;
192 static int rtc_date_offset
= -1; /* -1 means no change */
193 int cirrus_vga_enabled
= 1;
194 int vmsvga_enabled
= 0;
196 int graphic_width
= 1024;
197 int graphic_height
= 768;
198 int graphic_depth
= 8;
200 int graphic_width
= 800;
201 int graphic_height
= 600;
202 int graphic_depth
= 15;
204 static int full_screen
= 0;
205 static int no_frame
= 0;
207 CharDriverState
*serial_hds
[MAX_SERIAL_PORTS
];
208 CharDriverState
*parallel_hds
[MAX_PARALLEL_PORTS
];
210 int win2k_install_hack
= 0;
213 static VLANState
*first_vlan
;
215 const char *vnc_display
;
216 #if defined(TARGET_SPARC)
218 #elif defined(TARGET_I386)
223 int acpi_enabled
= 1;
228 int graphic_rotate
= 0;
230 const char *option_rom
[MAX_OPTION_ROMS
];
232 int semihosting_enabled
= 0;
237 const char *qemu_name
;
240 unsigned int nb_prom_envs
= 0;
241 const char *prom_envs
[MAX_PROM_ENVS
];
243 static int nb_drives_opt
;
244 static struct drive_opt
{
247 } drives_opt
[MAX_DRIVES
];
249 static CPUState
*cur_cpu
;
250 static CPUState
*next_cpu
;
251 static int event_pending
= 1;
252 /* Conversion factor from emulated instructions to virtual clock ticks. */
253 static int icount_time_shift
;
254 /* Arbitrarily pick 1MIPS as the minimum allowable speed. */
255 #define MAX_ICOUNT_SHIFT 10
256 /* Compensate for varying guest execution speed. */
257 static int64_t qemu_icount_bias
;
258 static QEMUTimer
*icount_rt_timer
;
259 static QEMUTimer
*icount_vm_timer
;
261 uint8_t qemu_uuid
[16];
263 #define TFR(expr) do { if ((expr) != -1) break; } while (errno == EINTR)
265 /***********************************************************/
266 /* x86 ISA bus support */
268 target_phys_addr_t isa_mem_base
= 0;
271 static IOPortReadFunc default_ioport_readb
, default_ioport_readw
, default_ioport_readl
;
272 static IOPortWriteFunc default_ioport_writeb
, default_ioport_writew
, default_ioport_writel
;
274 static uint32_t ioport_read(int index
, uint32_t address
)
276 static IOPortReadFunc
*default_func
[3] = {
277 default_ioport_readb
,
278 default_ioport_readw
,
281 IOPortReadFunc
*func
= ioport_read_table
[index
][address
];
283 func
= default_func
[index
];
284 return func(ioport_opaque
[address
], address
);
287 static void ioport_write(int index
, uint32_t address
, uint32_t data
)
289 static IOPortWriteFunc
*default_func
[3] = {
290 default_ioport_writeb
,
291 default_ioport_writew
,
292 default_ioport_writel
294 IOPortWriteFunc
*func
= ioport_write_table
[index
][address
];
296 func
= default_func
[index
];
297 func(ioport_opaque
[address
], address
, data
);
300 static uint32_t default_ioport_readb(void *opaque
, uint32_t address
)
302 #ifdef DEBUG_UNUSED_IOPORT
303 fprintf(stderr
, "unused inb: port=0x%04x\n", address
);
308 static void default_ioport_writeb(void *opaque
, uint32_t address
, uint32_t data
)
310 #ifdef DEBUG_UNUSED_IOPORT
311 fprintf(stderr
, "unused outb: port=0x%04x data=0x%02x\n", address
, data
);
315 /* default is to make two byte accesses */
316 static uint32_t default_ioport_readw(void *opaque
, uint32_t address
)
319 data
= ioport_read(0, address
);
320 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
321 data
|= ioport_read(0, address
) << 8;
325 static void default_ioport_writew(void *opaque
, uint32_t address
, uint32_t data
)
327 ioport_write(0, address
, data
& 0xff);
328 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
329 ioport_write(0, address
, (data
>> 8) & 0xff);
332 static uint32_t default_ioport_readl(void *opaque
, uint32_t address
)
334 #ifdef DEBUG_UNUSED_IOPORT
335 fprintf(stderr
, "unused inl: port=0x%04x\n", address
);
340 static void default_ioport_writel(void *opaque
, uint32_t address
, uint32_t data
)
342 #ifdef DEBUG_UNUSED_IOPORT
343 fprintf(stderr
, "unused outl: port=0x%04x data=0x%02x\n", address
, data
);
347 /* size is the word size in byte */
348 int register_ioport_read(int start
, int length
, int size
,
349 IOPortReadFunc
*func
, void *opaque
)
355 } else if (size
== 2) {
357 } else if (size
== 4) {
360 hw_error("register_ioport_read: invalid size");
363 for(i
= start
; i
< start
+ length
; i
+= size
) {
364 ioport_read_table
[bsize
][i
] = func
;
365 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
366 hw_error("register_ioport_read: invalid opaque");
367 ioport_opaque
[i
] = opaque
;
372 /* size is the word size in byte */
373 int register_ioport_write(int start
, int length
, int size
,
374 IOPortWriteFunc
*func
, void *opaque
)
380 } else if (size
== 2) {
382 } else if (size
== 4) {
385 hw_error("register_ioport_write: invalid size");
388 for(i
= start
; i
< start
+ length
; i
+= size
) {
389 ioport_write_table
[bsize
][i
] = func
;
390 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
391 hw_error("register_ioport_write: invalid opaque");
392 ioport_opaque
[i
] = opaque
;
397 void isa_unassign_ioport(int start
, int length
)
401 for(i
= start
; i
< start
+ length
; i
++) {
402 ioport_read_table
[0][i
] = default_ioport_readb
;
403 ioport_read_table
[1][i
] = default_ioport_readw
;
404 ioport_read_table
[2][i
] = default_ioport_readl
;
406 ioport_write_table
[0][i
] = default_ioport_writeb
;
407 ioport_write_table
[1][i
] = default_ioport_writew
;
408 ioport_write_table
[2][i
] = default_ioport_writel
;
412 /***********************************************************/
414 void cpu_outb(CPUState
*env
, int addr
, int val
)
417 if (loglevel
& CPU_LOG_IOPORT
)
418 fprintf(logfile
, "outb: %04x %02x\n", addr
, val
);
420 ioport_write(0, addr
, val
);
423 env
->last_io_time
= cpu_get_time_fast();
427 void cpu_outw(CPUState
*env
, int addr
, int val
)
430 if (loglevel
& CPU_LOG_IOPORT
)
431 fprintf(logfile
, "outw: %04x %04x\n", addr
, val
);
433 ioport_write(1, addr
, val
);
436 env
->last_io_time
= cpu_get_time_fast();
440 void cpu_outl(CPUState
*env
, int addr
, int val
)
443 if (loglevel
& CPU_LOG_IOPORT
)
444 fprintf(logfile
, "outl: %04x %08x\n", addr
, val
);
446 ioport_write(2, addr
, val
);
449 env
->last_io_time
= cpu_get_time_fast();
453 int cpu_inb(CPUState
*env
, int addr
)
456 val
= ioport_read(0, addr
);
458 if (loglevel
& CPU_LOG_IOPORT
)
459 fprintf(logfile
, "inb : %04x %02x\n", addr
, val
);
463 env
->last_io_time
= cpu_get_time_fast();
468 int cpu_inw(CPUState
*env
, int addr
)
471 val
= ioport_read(1, addr
);
473 if (loglevel
& CPU_LOG_IOPORT
)
474 fprintf(logfile
, "inw : %04x %04x\n", addr
, val
);
478 env
->last_io_time
= cpu_get_time_fast();
483 int cpu_inl(CPUState
*env
, int addr
)
486 val
= ioport_read(2, addr
);
488 if (loglevel
& CPU_LOG_IOPORT
)
489 fprintf(logfile
, "inl : %04x %08x\n", addr
, val
);
493 env
->last_io_time
= cpu_get_time_fast();
498 /***********************************************************/
499 void hw_error(const char *fmt
, ...)
505 fprintf(stderr
, "qemu: hardware error: ");
506 vfprintf(stderr
, fmt
, ap
);
507 fprintf(stderr
, "\n");
508 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
509 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
511 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
513 cpu_dump_state(env
, stderr
, fprintf
, 0);
520 /***********************************************************/
523 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
524 static void *qemu_put_kbd_event_opaque
;
525 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
526 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
528 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
530 qemu_put_kbd_event_opaque
= opaque
;
531 qemu_put_kbd_event
= func
;
534 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
535 void *opaque
, int absolute
,
538 QEMUPutMouseEntry
*s
, *cursor
;
540 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
544 s
->qemu_put_mouse_event
= func
;
545 s
->qemu_put_mouse_event_opaque
= opaque
;
546 s
->qemu_put_mouse_event_absolute
= absolute
;
547 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
550 if (!qemu_put_mouse_event_head
) {
551 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
555 cursor
= qemu_put_mouse_event_head
;
556 while (cursor
->next
!= NULL
)
557 cursor
= cursor
->next
;
560 qemu_put_mouse_event_current
= s
;
565 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
567 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
569 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
572 cursor
= qemu_put_mouse_event_head
;
573 while (cursor
!= NULL
&& cursor
!= entry
) {
575 cursor
= cursor
->next
;
578 if (cursor
== NULL
) // does not exist or list empty
580 else if (prev
== NULL
) { // entry is head
581 qemu_put_mouse_event_head
= cursor
->next
;
582 if (qemu_put_mouse_event_current
== entry
)
583 qemu_put_mouse_event_current
= cursor
->next
;
584 qemu_free(entry
->qemu_put_mouse_event_name
);
589 prev
->next
= entry
->next
;
591 if (qemu_put_mouse_event_current
== entry
)
592 qemu_put_mouse_event_current
= prev
;
594 qemu_free(entry
->qemu_put_mouse_event_name
);
598 void kbd_put_keycode(int keycode
)
600 if (qemu_put_kbd_event
) {
601 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
605 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
607 QEMUPutMouseEvent
*mouse_event
;
608 void *mouse_event_opaque
;
611 if (!qemu_put_mouse_event_current
) {
616 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
618 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
621 if (graphic_rotate
) {
622 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
625 width
= graphic_width
- 1;
626 mouse_event(mouse_event_opaque
,
627 width
- dy
, dx
, dz
, buttons_state
);
629 mouse_event(mouse_event_opaque
,
630 dx
, dy
, dz
, buttons_state
);
634 int kbd_mouse_is_absolute(void)
636 if (!qemu_put_mouse_event_current
)
639 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
642 void do_info_mice(void)
644 QEMUPutMouseEntry
*cursor
;
647 if (!qemu_put_mouse_event_head
) {
648 term_printf("No mouse devices connected\n");
652 term_printf("Mouse devices available:\n");
653 cursor
= qemu_put_mouse_event_head
;
654 while (cursor
!= NULL
) {
655 term_printf("%c Mouse #%d: %s\n",
656 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
657 index
, cursor
->qemu_put_mouse_event_name
);
659 cursor
= cursor
->next
;
663 void do_mouse_set(int index
)
665 QEMUPutMouseEntry
*cursor
;
668 if (!qemu_put_mouse_event_head
) {
669 term_printf("No mouse devices connected\n");
673 cursor
= qemu_put_mouse_event_head
;
674 while (cursor
!= NULL
&& index
!= i
) {
676 cursor
= cursor
->next
;
680 qemu_put_mouse_event_current
= cursor
;
682 term_printf("Mouse at given index not found\n");
685 /* compute with 96 bit intermediate result: (a*b)/c */
686 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
691 #ifdef WORDS_BIGENDIAN
701 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
702 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
705 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
709 /***********************************************************/
710 /* real time host monotonic timer */
712 #define QEMU_TIMER_BASE 1000000000LL
716 static int64_t clock_freq
;
718 static void init_get_clock(void)
722 ret
= QueryPerformanceFrequency(&freq
);
724 fprintf(stderr
, "Could not calibrate ticks\n");
727 clock_freq
= freq
.QuadPart
;
730 static int64_t get_clock(void)
733 QueryPerformanceCounter(&ti
);
734 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
739 static int use_rt_clock
;
741 static void init_get_clock(void)
744 #if defined(__linux__)
747 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
754 static int64_t get_clock(void)
756 #if defined(__linux__)
759 clock_gettime(CLOCK_MONOTONIC
, &ts
);
760 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
764 /* XXX: using gettimeofday leads to problems if the date
765 changes, so it should be avoided. */
767 gettimeofday(&tv
, NULL
);
768 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
773 /* Return the virtual CPU time, based on the instruction counter. */
774 static int64_t cpu_get_icount(void)
777 CPUState
*env
= cpu_single_env
;;
778 icount
= qemu_icount
;
781 fprintf(stderr
, "Bad clock read\n");
782 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
784 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
787 /***********************************************************/
788 /* guest cycle counter */
790 static int64_t cpu_ticks_prev
;
791 static int64_t cpu_ticks_offset
;
792 static int64_t cpu_clock_offset
;
793 static int cpu_ticks_enabled
;
795 /* return the host CPU cycle counter and handle stop/restart */
796 int64_t cpu_get_ticks(void)
799 return cpu_get_icount();
801 if (!cpu_ticks_enabled
) {
802 return cpu_ticks_offset
;
805 ticks
= cpu_get_real_ticks();
806 if (cpu_ticks_prev
> ticks
) {
807 /* Note: non increasing ticks may happen if the host uses
809 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
811 cpu_ticks_prev
= ticks
;
812 return ticks
+ cpu_ticks_offset
;
816 /* return the host CPU monotonic timer and handle stop/restart */
817 static int64_t cpu_get_clock(void)
820 if (!cpu_ticks_enabled
) {
821 return cpu_clock_offset
;
824 return ti
+ cpu_clock_offset
;
828 /* enable cpu_get_ticks() */
829 void cpu_enable_ticks(void)
831 if (!cpu_ticks_enabled
) {
832 cpu_ticks_offset
-= cpu_get_real_ticks();
833 cpu_clock_offset
-= get_clock();
834 cpu_ticks_enabled
= 1;
838 /* disable cpu_get_ticks() : the clock is stopped. You must not call
839 cpu_get_ticks() after that. */
840 void cpu_disable_ticks(void)
842 if (cpu_ticks_enabled
) {
843 cpu_ticks_offset
= cpu_get_ticks();
844 cpu_clock_offset
= cpu_get_clock();
845 cpu_ticks_enabled
= 0;
849 /***********************************************************/
852 #define QEMU_TIMER_REALTIME 0
853 #define QEMU_TIMER_VIRTUAL 1
857 /* XXX: add frequency */
865 struct QEMUTimer
*next
;
868 struct qemu_alarm_timer
{
872 int (*start
)(struct qemu_alarm_timer
*t
);
873 void (*stop
)(struct qemu_alarm_timer
*t
);
874 void (*rearm
)(struct qemu_alarm_timer
*t
);
878 #define ALARM_FLAG_DYNTICKS 0x1
879 #define ALARM_FLAG_EXPIRED 0x2
881 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
883 return t
->flags
& ALARM_FLAG_DYNTICKS
;
886 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
888 if (!alarm_has_dynticks(t
))
894 /* TODO: MIN_TIMER_REARM_US should be optimized */
895 #define MIN_TIMER_REARM_US 250
897 static struct qemu_alarm_timer
*alarm_timer
;
901 struct qemu_alarm_win32
{
905 } alarm_win32_data
= {0, NULL
, -1};
907 static int win32_start_timer(struct qemu_alarm_timer
*t
);
908 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
909 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
913 static int unix_start_timer(struct qemu_alarm_timer
*t
);
914 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
918 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
919 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
920 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
922 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
923 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
925 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
926 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
928 #endif /* __linux__ */
932 /* Correlation between real and virtual time is always going to be
933 fairly approximate, so ignore small variation.
934 When the guest is idle real and virtual time will be aligned in
936 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
938 static void icount_adjust(void)
943 static int64_t last_delta
;
944 /* If the VM is not running, then do nothing. */
948 cur_time
= cpu_get_clock();
949 cur_icount
= qemu_get_clock(vm_clock
);
950 delta
= cur_icount
- cur_time
;
951 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
953 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
954 && icount_time_shift
> 0) {
955 /* The guest is getting too far ahead. Slow time down. */
959 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
960 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
961 /* The guest is getting too far behind. Speed time up. */
965 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
968 static void icount_adjust_rt(void * opaque
)
970 qemu_mod_timer(icount_rt_timer
,
971 qemu_get_clock(rt_clock
) + 1000);
975 static void icount_adjust_vm(void * opaque
)
977 qemu_mod_timer(icount_vm_timer
,
978 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
982 static void init_icount_adjust(void)
984 /* Have both realtime and virtual time triggers for speed adjustment.
985 The realtime trigger catches emulated time passing too slowly,
986 the virtual time trigger catches emulated time passing too fast.
987 Realtime triggers occur even when idle, so use them less frequently
989 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
990 qemu_mod_timer(icount_rt_timer
,
991 qemu_get_clock(rt_clock
) + 1000);
992 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
993 qemu_mod_timer(icount_vm_timer
,
994 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
997 static struct qemu_alarm_timer alarm_timers
[] = {
1000 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
1001 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
1002 /* HPET - if available - is preferred */
1003 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
1004 /* ...otherwise try RTC */
1005 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
1007 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
1009 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
1010 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
1011 {"win32", 0, win32_start_timer
,
1012 win32_stop_timer
, NULL
, &alarm_win32_data
},
1017 static void show_available_alarms(void)
1021 printf("Available alarm timers, in order of precedence:\n");
1022 for (i
= 0; alarm_timers
[i
].name
; i
++)
1023 printf("%s\n", alarm_timers
[i
].name
);
1026 static void configure_alarms(char const *opt
)
1030 int count
= (sizeof(alarm_timers
) / sizeof(*alarm_timers
)) - 1;
1033 struct qemu_alarm_timer tmp
;
1035 if (!strcmp(opt
, "?")) {
1036 show_available_alarms();
1042 /* Reorder the array */
1043 name
= strtok(arg
, ",");
1045 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
1046 if (!strcmp(alarm_timers
[i
].name
, name
))
1051 fprintf(stderr
, "Unknown clock %s\n", name
);
1060 tmp
= alarm_timers
[i
];
1061 alarm_timers
[i
] = alarm_timers
[cur
];
1062 alarm_timers
[cur
] = tmp
;
1066 name
= strtok(NULL
, ",");
1072 /* Disable remaining timers */
1073 for (i
= cur
; i
< count
; i
++)
1074 alarm_timers
[i
].name
= NULL
;
1076 show_available_alarms();
1081 QEMUClock
*rt_clock
;
1082 QEMUClock
*vm_clock
;
1084 static QEMUTimer
*active_timers
[2];
1086 static QEMUClock
*qemu_new_clock(int type
)
1089 clock
= qemu_mallocz(sizeof(QEMUClock
));
1096 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
1100 ts
= qemu_mallocz(sizeof(QEMUTimer
));
1103 ts
->opaque
= opaque
;
1107 void qemu_free_timer(QEMUTimer
*ts
)
1112 /* stop a timer, but do not dealloc it */
1113 void qemu_del_timer(QEMUTimer
*ts
)
1117 /* NOTE: this code must be signal safe because
1118 qemu_timer_expired() can be called from a signal. */
1119 pt
= &active_timers
[ts
->clock
->type
];
1132 /* modify the current timer so that it will be fired when current_time
1133 >= expire_time. The corresponding callback will be called. */
1134 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
1140 /* add the timer in the sorted list */
1141 /* NOTE: this code must be signal safe because
1142 qemu_timer_expired() can be called from a signal. */
1143 pt
= &active_timers
[ts
->clock
->type
];
1148 if (t
->expire_time
> expire_time
)
1152 ts
->expire_time
= expire_time
;
1156 /* Rearm if necessary */
1157 if (pt
== &active_timers
[ts
->clock
->type
]) {
1158 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
1159 qemu_rearm_alarm_timer(alarm_timer
);
1161 /* Interrupt execution to force deadline recalculation. */
1162 if (use_icount
&& cpu_single_env
) {
1163 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
1168 int qemu_timer_pending(QEMUTimer
*ts
)
1171 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1178 static inline int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1182 return (timer_head
->expire_time
<= current_time
);
1185 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1191 if (!ts
|| ts
->expire_time
> current_time
)
1193 /* remove timer from the list before calling the callback */
1194 *ptimer_head
= ts
->next
;
1197 /* run the callback (the timer list can be modified) */
1202 int64_t qemu_get_clock(QEMUClock
*clock
)
1204 switch(clock
->type
) {
1205 case QEMU_TIMER_REALTIME
:
1206 return get_clock() / 1000000;
1208 case QEMU_TIMER_VIRTUAL
:
1210 return cpu_get_icount();
1212 return cpu_get_clock();
1217 static void init_timers(void)
1220 ticks_per_sec
= QEMU_TIMER_BASE
;
1221 rt_clock
= qemu_new_clock(QEMU_TIMER_REALTIME
);
1222 vm_clock
= qemu_new_clock(QEMU_TIMER_VIRTUAL
);
1226 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1228 uint64_t expire_time
;
1230 if (qemu_timer_pending(ts
)) {
1231 expire_time
= ts
->expire_time
;
1235 qemu_put_be64(f
, expire_time
);
1238 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1240 uint64_t expire_time
;
1242 expire_time
= qemu_get_be64(f
);
1243 if (expire_time
!= -1) {
1244 qemu_mod_timer(ts
, expire_time
);
1250 static void timer_save(QEMUFile
*f
, void *opaque
)
1252 if (cpu_ticks_enabled
) {
1253 hw_error("cannot save state if virtual timers are running");
1255 qemu_put_be64(f
, cpu_ticks_offset
);
1256 qemu_put_be64(f
, ticks_per_sec
);
1257 qemu_put_be64(f
, cpu_clock_offset
);
1260 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1262 if (version_id
!= 1 && version_id
!= 2)
1264 if (cpu_ticks_enabled
) {
1267 cpu_ticks_offset
=qemu_get_be64(f
);
1268 ticks_per_sec
=qemu_get_be64(f
);
1269 if (version_id
== 2) {
1270 cpu_clock_offset
=qemu_get_be64(f
);
1276 void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1277 DWORD_PTR dwUser
, DWORD_PTR dw1
, DWORD_PTR dw2
)
1279 static void host_alarm_handler(int host_signum
)
1283 #define DISP_FREQ 1000
1285 static int64_t delta_min
= INT64_MAX
;
1286 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1288 ti
= qemu_get_clock(vm_clock
);
1289 if (last_clock
!= 0) {
1290 delta
= ti
- last_clock
;
1291 if (delta
< delta_min
)
1293 if (delta
> delta_max
)
1296 if (++count
== DISP_FREQ
) {
1297 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1298 muldiv64(delta_min
, 1000000, ticks_per_sec
),
1299 muldiv64(delta_max
, 1000000, ticks_per_sec
),
1300 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, ticks_per_sec
),
1301 (double)ticks_per_sec
/ ((double)delta_cum
/ DISP_FREQ
));
1303 delta_min
= INT64_MAX
;
1311 if (alarm_has_dynticks(alarm_timer
) ||
1313 qemu_timer_expired(active_timers
[QEMU_TIMER_VIRTUAL
],
1314 qemu_get_clock(vm_clock
))) ||
1315 qemu_timer_expired(active_timers
[QEMU_TIMER_REALTIME
],
1316 qemu_get_clock(rt_clock
))) {
1318 struct qemu_alarm_win32
*data
= ((struct qemu_alarm_timer
*)dwUser
)->priv
;
1319 SetEvent(data
->host_alarm
);
1321 CPUState
*env
= next_cpu
;
1323 alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1326 /* stop the currently executing cpu because a timer occured */
1327 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
1329 if (env
->kqemu_enabled
) {
1330 kqemu_cpu_interrupt(env
);
1338 static int64_t qemu_next_deadline(void)
1342 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1343 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1344 qemu_get_clock(vm_clock
);
1346 /* To avoid problems with overflow limit this to 2^32. */
1356 #if defined(__linux__) || defined(_WIN32)
1357 static uint64_t qemu_next_deadline_dyntick(void)
1365 delta
= (qemu_next_deadline() + 999) / 1000;
1367 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1368 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1369 qemu_get_clock(rt_clock
))*1000;
1370 if (rtdelta
< delta
)
1374 if (delta
< MIN_TIMER_REARM_US
)
1375 delta
= MIN_TIMER_REARM_US
;
1383 #if defined(__linux__)
1385 #define RTC_FREQ 1024
1387 static void enable_sigio_timer(int fd
)
1389 struct sigaction act
;
1392 sigfillset(&act
.sa_mask
);
1394 act
.sa_handler
= host_alarm_handler
;
1396 sigaction(SIGIO
, &act
, NULL
);
1397 fcntl(fd
, F_SETFL
, O_ASYNC
);
1398 fcntl(fd
, F_SETOWN
, getpid());
1401 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1403 struct hpet_info info
;
1406 fd
= open("/dev/hpet", O_RDONLY
);
1411 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1413 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1414 "error, but for better emulation accuracy type:\n"
1415 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1419 /* Check capabilities */
1420 r
= ioctl(fd
, HPET_INFO
, &info
);
1424 /* Enable periodic mode */
1425 r
= ioctl(fd
, HPET_EPI
, 0);
1426 if (info
.hi_flags
&& (r
< 0))
1429 /* Enable interrupt */
1430 r
= ioctl(fd
, HPET_IE_ON
, 0);
1434 enable_sigio_timer(fd
);
1435 t
->priv
= (void *)(long)fd
;
1443 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1445 int fd
= (long)t
->priv
;
1450 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1453 unsigned long current_rtc_freq
= 0;
1455 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1458 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1459 if (current_rtc_freq
!= RTC_FREQ
&&
1460 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1461 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1462 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1463 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1466 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1472 enable_sigio_timer(rtc_fd
);
1474 t
->priv
= (void *)(long)rtc_fd
;
1479 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1481 int rtc_fd
= (long)t
->priv
;
1486 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1490 struct sigaction act
;
1492 sigfillset(&act
.sa_mask
);
1494 act
.sa_handler
= host_alarm_handler
;
1496 sigaction(SIGALRM
, &act
, NULL
);
1498 ev
.sigev_value
.sival_int
= 0;
1499 ev
.sigev_notify
= SIGEV_SIGNAL
;
1500 ev
.sigev_signo
= SIGALRM
;
1502 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1503 perror("timer_create");
1505 /* disable dynticks */
1506 fprintf(stderr
, "Dynamic Ticks disabled\n");
1511 t
->priv
= (void *)host_timer
;
1516 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1518 timer_t host_timer
= (timer_t
)t
->priv
;
1520 timer_delete(host_timer
);
1523 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1525 timer_t host_timer
= (timer_t
)t
->priv
;
1526 struct itimerspec timeout
;
1527 int64_t nearest_delta_us
= INT64_MAX
;
1530 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1531 !active_timers
[QEMU_TIMER_VIRTUAL
])
1534 nearest_delta_us
= qemu_next_deadline_dyntick();
1536 /* check whether a timer is already running */
1537 if (timer_gettime(host_timer
, &timeout
)) {
1539 fprintf(stderr
, "Internal timer error: aborting\n");
1542 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1543 if (current_us
&& current_us
<= nearest_delta_us
)
1546 timeout
.it_interval
.tv_sec
= 0;
1547 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1548 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1549 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1550 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1552 fprintf(stderr
, "Internal timer error: aborting\n");
1557 #endif /* defined(__linux__) */
1559 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1561 struct sigaction act
;
1562 struct itimerval itv
;
1566 sigfillset(&act
.sa_mask
);
1568 act
.sa_handler
= host_alarm_handler
;
1570 sigaction(SIGALRM
, &act
, NULL
);
1572 itv
.it_interval
.tv_sec
= 0;
1573 /* for i386 kernel 2.6 to get 1 ms */
1574 itv
.it_interval
.tv_usec
= 999;
1575 itv
.it_value
.tv_sec
= 0;
1576 itv
.it_value
.tv_usec
= 10 * 1000;
1578 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1585 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1587 struct itimerval itv
;
1589 memset(&itv
, 0, sizeof(itv
));
1590 setitimer(ITIMER_REAL
, &itv
, NULL
);
1593 #endif /* !defined(_WIN32) */
1597 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1600 struct qemu_alarm_win32
*data
= t
->priv
;
1603 data
->host_alarm
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1604 if (!data
->host_alarm
) {
1605 perror("Failed CreateEvent");
1609 memset(&tc
, 0, sizeof(tc
));
1610 timeGetDevCaps(&tc
, sizeof(tc
));
1612 if (data
->period
< tc
.wPeriodMin
)
1613 data
->period
= tc
.wPeriodMin
;
1615 timeBeginPeriod(data
->period
);
1617 flags
= TIME_CALLBACK_FUNCTION
;
1618 if (alarm_has_dynticks(t
))
1619 flags
|= TIME_ONESHOT
;
1621 flags
|= TIME_PERIODIC
;
1623 data
->timerId
= timeSetEvent(1, // interval (ms)
1624 data
->period
, // resolution
1625 host_alarm_handler
, // function
1626 (DWORD
)t
, // parameter
1629 if (!data
->timerId
) {
1630 perror("Failed to initialize win32 alarm timer");
1632 timeEndPeriod(data
->period
);
1633 CloseHandle(data
->host_alarm
);
1637 qemu_add_wait_object(data
->host_alarm
, NULL
, NULL
);
1642 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1644 struct qemu_alarm_win32
*data
= t
->priv
;
1646 timeKillEvent(data
->timerId
);
1647 timeEndPeriod(data
->period
);
1649 CloseHandle(data
->host_alarm
);
1652 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1654 struct qemu_alarm_win32
*data
= t
->priv
;
1655 uint64_t nearest_delta_us
;
1657 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1658 !active_timers
[QEMU_TIMER_VIRTUAL
])
1661 nearest_delta_us
= qemu_next_deadline_dyntick();
1662 nearest_delta_us
/= 1000;
1664 timeKillEvent(data
->timerId
);
1666 data
->timerId
= timeSetEvent(1,
1670 TIME_ONESHOT
| TIME_PERIODIC
);
1672 if (!data
->timerId
) {
1673 perror("Failed to re-arm win32 alarm timer");
1675 timeEndPeriod(data
->period
);
1676 CloseHandle(data
->host_alarm
);
1683 static void init_timer_alarm(void)
1685 struct qemu_alarm_timer
*t
= NULL
;
1688 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1689 t
= &alarm_timers
[i
];
1697 fprintf(stderr
, "Unable to find any suitable alarm timer.\n");
1698 fprintf(stderr
, "Terminating\n");
1705 static void quit_timers(void)
1707 alarm_timer
->stop(alarm_timer
);
1711 /***********************************************************/
1712 /* host time/date access */
1713 void qemu_get_timedate(struct tm
*tm
, int offset
)
1720 if (rtc_date_offset
== -1) {
1724 ret
= localtime(&ti
);
1726 ti
-= rtc_date_offset
;
1730 memcpy(tm
, ret
, sizeof(struct tm
));
1733 int qemu_timedate_diff(struct tm
*tm
)
1737 if (rtc_date_offset
== -1)
1739 seconds
= mktimegm(tm
);
1741 seconds
= mktime(tm
);
1743 seconds
= mktimegm(tm
) + rtc_date_offset
;
1745 return seconds
- time(NULL
);
1748 /***********************************************************/
1749 /* character device */
1751 static void qemu_chr_event(CharDriverState
*s
, int event
)
1755 s
->chr_event(s
->handler_opaque
, event
);
1758 static void qemu_chr_reset_bh(void *opaque
)
1760 CharDriverState
*s
= opaque
;
1761 qemu_chr_event(s
, CHR_EVENT_RESET
);
1762 qemu_bh_delete(s
->bh
);
1766 void qemu_chr_reset(CharDriverState
*s
)
1768 if (s
->bh
== NULL
) {
1769 s
->bh
= qemu_bh_new(qemu_chr_reset_bh
, s
);
1770 qemu_bh_schedule(s
->bh
);
1774 int qemu_chr_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
1776 return s
->chr_write(s
, buf
, len
);
1779 int qemu_chr_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
1783 return s
->chr_ioctl(s
, cmd
, arg
);
1786 int qemu_chr_can_read(CharDriverState
*s
)
1788 if (!s
->chr_can_read
)
1790 return s
->chr_can_read(s
->handler_opaque
);
1793 void qemu_chr_read(CharDriverState
*s
, uint8_t *buf
, int len
)
1795 s
->chr_read(s
->handler_opaque
, buf
, len
);
1798 void qemu_chr_accept_input(CharDriverState
*s
)
1800 if (s
->chr_accept_input
)
1801 s
->chr_accept_input(s
);
1804 void qemu_chr_printf(CharDriverState
*s
, const char *fmt
, ...)
1809 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
1810 qemu_chr_write(s
, (uint8_t *)buf
, strlen(buf
));
1814 void qemu_chr_send_event(CharDriverState
*s
, int event
)
1816 if (s
->chr_send_event
)
1817 s
->chr_send_event(s
, event
);
1820 void qemu_chr_add_handlers(CharDriverState
*s
,
1821 IOCanRWHandler
*fd_can_read
,
1822 IOReadHandler
*fd_read
,
1823 IOEventHandler
*fd_event
,
1826 s
->chr_can_read
= fd_can_read
;
1827 s
->chr_read
= fd_read
;
1828 s
->chr_event
= fd_event
;
1829 s
->handler_opaque
= opaque
;
1830 if (s
->chr_update_read_handler
)
1831 s
->chr_update_read_handler(s
);
1834 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1839 static CharDriverState
*qemu_chr_open_null(void)
1841 CharDriverState
*chr
;
1843 chr
= qemu_mallocz(sizeof(CharDriverState
));
1846 chr
->chr_write
= null_chr_write
;
1850 /* MUX driver for serial I/O splitting */
1851 static int term_timestamps
;
1852 static int64_t term_timestamps_start
;
1854 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1855 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1857 IOCanRWHandler
*chr_can_read
[MAX_MUX
];
1858 IOReadHandler
*chr_read
[MAX_MUX
];
1859 IOEventHandler
*chr_event
[MAX_MUX
];
1860 void *ext_opaque
[MAX_MUX
];
1861 CharDriverState
*drv
;
1862 unsigned char buffer
[MUX_BUFFER_SIZE
];
1866 int term_got_escape
;
1871 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1873 MuxDriver
*d
= chr
->opaque
;
1875 if (!term_timestamps
) {
1876 ret
= d
->drv
->chr_write(d
->drv
, buf
, len
);
1881 for(i
= 0; i
< len
; i
++) {
1882 ret
+= d
->drv
->chr_write(d
->drv
, buf
+i
, 1);
1883 if (buf
[i
] == '\n') {
1889 if (term_timestamps_start
== -1)
1890 term_timestamps_start
= ti
;
1891 ti
-= term_timestamps_start
;
1892 secs
= ti
/ 1000000000;
1893 snprintf(buf1
, sizeof(buf1
),
1894 "[%02d:%02d:%02d.%03d] ",
1898 (int)((ti
/ 1000000) % 1000));
1899 d
->drv
->chr_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
1906 static const char * const mux_help
[] = {
1907 "% h print this help\n\r",
1908 "% x exit emulator\n\r",
1909 "% s save disk data back to file (if -snapshot)\n\r",
1910 "% t toggle console timestamps\n\r"
1911 "% b send break (magic sysrq)\n\r",
1912 "% c switch between console and monitor\n\r",
1917 static int term_escape_char
= 0x01; /* ctrl-a is used for escape */
1918 static void mux_print_help(CharDriverState
*chr
)
1921 char ebuf
[15] = "Escape-Char";
1922 char cbuf
[50] = "\n\r";
1924 if (term_escape_char
> 0 && term_escape_char
< 26) {
1925 snprintf(cbuf
, sizeof(cbuf
), "\n\r");
1926 snprintf(ebuf
, sizeof(ebuf
), "C-%c", term_escape_char
- 1 + 'a');
1928 snprintf(cbuf
, sizeof(cbuf
),
1929 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1932 chr
->chr_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
1933 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
1934 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
1935 if (mux_help
[i
][j
] == '%')
1936 chr
->chr_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
1938 chr
->chr_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
1943 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
1945 if (d
->term_got_escape
) {
1946 d
->term_got_escape
= 0;
1947 if (ch
== term_escape_char
)
1952 mux_print_help(chr
);
1956 const char *term
= "QEMU: Terminated\n\r";
1957 chr
->chr_write(chr
,(uint8_t *)term
,strlen(term
));
1964 for (i
= 0; i
< nb_drives
; i
++) {
1965 bdrv_commit(drives_table
[i
].bdrv
);
1970 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
1973 /* Switch to the next registered device */
1975 if (chr
->focus
>= d
->mux_cnt
)
1979 term_timestamps
= !term_timestamps
;
1980 term_timestamps_start
= -1;
1983 } else if (ch
== term_escape_char
) {
1984 d
->term_got_escape
= 1;
1992 static void mux_chr_accept_input(CharDriverState
*chr
)
1995 MuxDriver
*d
= chr
->opaque
;
1997 while (d
->prod
!= d
->cons
&&
1998 d
->chr_can_read
[m
] &&
1999 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
2000 d
->chr_read
[m
](d
->ext_opaque
[m
],
2001 &d
->buffer
[d
->cons
++ & MUX_BUFFER_MASK
], 1);
2005 static int mux_chr_can_read(void *opaque
)
2007 CharDriverState
*chr
= opaque
;
2008 MuxDriver
*d
= chr
->opaque
;
2010 if ((d
->prod
- d
->cons
) < MUX_BUFFER_SIZE
)
2012 if (d
->chr_can_read
[chr
->focus
])
2013 return d
->chr_can_read
[chr
->focus
](d
->ext_opaque
[chr
->focus
]);
2017 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
2019 CharDriverState
*chr
= opaque
;
2020 MuxDriver
*d
= chr
->opaque
;
2024 mux_chr_accept_input (opaque
);
2026 for(i
= 0; i
< size
; i
++)
2027 if (mux_proc_byte(chr
, d
, buf
[i
])) {
2028 if (d
->prod
== d
->cons
&&
2029 d
->chr_can_read
[m
] &&
2030 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
2031 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
2033 d
->buffer
[d
->prod
++ & MUX_BUFFER_MASK
] = buf
[i
];
2037 static void mux_chr_event(void *opaque
, int event
)
2039 CharDriverState
*chr
= opaque
;
2040 MuxDriver
*d
= chr
->opaque
;
2043 /* Send the event to all registered listeners */
2044 for (i
= 0; i
< d
->mux_cnt
; i
++)
2045 if (d
->chr_event
[i
])
2046 d
->chr_event
[i
](d
->ext_opaque
[i
], event
);
2049 static void mux_chr_update_read_handler(CharDriverState
*chr
)
2051 MuxDriver
*d
= chr
->opaque
;
2053 if (d
->mux_cnt
>= MAX_MUX
) {
2054 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
2057 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
2058 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
2059 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
2060 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
2061 /* Fix up the real driver with mux routines */
2062 if (d
->mux_cnt
== 0) {
2063 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
2064 mux_chr_event
, chr
);
2066 chr
->focus
= d
->mux_cnt
;
2070 static CharDriverState
*qemu_chr_open_mux(CharDriverState
*drv
)
2072 CharDriverState
*chr
;
2075 chr
= qemu_mallocz(sizeof(CharDriverState
));
2078 d
= qemu_mallocz(sizeof(MuxDriver
));
2087 chr
->chr_write
= mux_chr_write
;
2088 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
2089 chr
->chr_accept_input
= mux_chr_accept_input
;
2096 static void socket_cleanup(void)
2101 static int socket_init(void)
2106 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
2108 err
= WSAGetLastError();
2109 fprintf(stderr
, "WSAStartup: %d\n", err
);
2112 atexit(socket_cleanup
);
2116 static int send_all(int fd
, const uint8_t *buf
, int len1
)
2122 ret
= send(fd
, buf
, len
, 0);
2125 errno
= WSAGetLastError();
2126 if (errno
!= WSAEWOULDBLOCK
) {
2129 } else if (ret
== 0) {
2141 static int unix_write(int fd
, const uint8_t *buf
, int len1
)
2147 ret
= write(fd
, buf
, len
);
2149 if (errno
!= EINTR
&& errno
!= EAGAIN
)
2151 } else if (ret
== 0) {
2161 static inline int send_all(int fd
, const uint8_t *buf
, int len1
)
2163 return unix_write(fd
, buf
, len1
);
2165 #endif /* !_WIN32 */
2174 #define STDIO_MAX_CLIENTS 1
2175 static int stdio_nb_clients
= 0;
2177 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2179 FDCharDriver
*s
= chr
->opaque
;
2180 return unix_write(s
->fd_out
, buf
, len
);
2183 static int fd_chr_read_poll(void *opaque
)
2185 CharDriverState
*chr
= opaque
;
2186 FDCharDriver
*s
= chr
->opaque
;
2188 s
->max_size
= qemu_chr_can_read(chr
);
2192 static void fd_chr_read(void *opaque
)
2194 CharDriverState
*chr
= opaque
;
2195 FDCharDriver
*s
= chr
->opaque
;
2200 if (len
> s
->max_size
)
2204 size
= read(s
->fd_in
, buf
, len
);
2206 /* FD has been closed. Remove it from the active list. */
2207 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2211 qemu_chr_read(chr
, buf
, size
);
2215 static void fd_chr_update_read_handler(CharDriverState
*chr
)
2217 FDCharDriver
*s
= chr
->opaque
;
2219 if (s
->fd_in
>= 0) {
2220 if (nographic
&& s
->fd_in
== 0) {
2222 qemu_set_fd_handler2(s
->fd_in
, fd_chr_read_poll
,
2223 fd_chr_read
, NULL
, chr
);
2228 static void fd_chr_close(struct CharDriverState
*chr
)
2230 FDCharDriver
*s
= chr
->opaque
;
2232 if (s
->fd_in
>= 0) {
2233 if (nographic
&& s
->fd_in
== 0) {
2235 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2242 /* open a character device to a unix fd */
2243 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
)
2245 CharDriverState
*chr
;
2248 chr
= qemu_mallocz(sizeof(CharDriverState
));
2251 s
= qemu_mallocz(sizeof(FDCharDriver
));
2259 chr
->chr_write
= fd_chr_write
;
2260 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
2261 chr
->chr_close
= fd_chr_close
;
2263 qemu_chr_reset(chr
);
2268 static CharDriverState
*qemu_chr_open_file_out(const char *file_out
)
2272 TFR(fd_out
= open(file_out
, O_WRONLY
| O_TRUNC
| O_CREAT
| O_BINARY
, 0666));
2275 return qemu_chr_open_fd(-1, fd_out
);
2278 static CharDriverState
*qemu_chr_open_pipe(const char *filename
)
2281 char filename_in
[256], filename_out
[256];
2283 snprintf(filename_in
, 256, "%s.in", filename
);
2284 snprintf(filename_out
, 256, "%s.out", filename
);
2285 TFR(fd_in
= open(filename_in
, O_RDWR
| O_BINARY
));
2286 TFR(fd_out
= open(filename_out
, O_RDWR
| O_BINARY
));
2287 if (fd_in
< 0 || fd_out
< 0) {
2292 TFR(fd_in
= fd_out
= open(filename
, O_RDWR
| O_BINARY
));
2296 return qemu_chr_open_fd(fd_in
, fd_out
);
2300 /* for STDIO, we handle the case where several clients use it
2303 #define TERM_FIFO_MAX_SIZE 1
2305 static uint8_t term_fifo
[TERM_FIFO_MAX_SIZE
];
2306 static int term_fifo_size
;
2308 static int stdio_read_poll(void *opaque
)
2310 CharDriverState
*chr
= opaque
;
2312 /* try to flush the queue if needed */
2313 if (term_fifo_size
!= 0 && qemu_chr_can_read(chr
) > 0) {
2314 qemu_chr_read(chr
, term_fifo
, 1);
2317 /* see if we can absorb more chars */
2318 if (term_fifo_size
== 0)
2324 static void stdio_read(void *opaque
)
2328 CharDriverState
*chr
= opaque
;
2330 size
= read(0, buf
, 1);
2332 /* stdin has been closed. Remove it from the active list. */
2333 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2337 if (qemu_chr_can_read(chr
) > 0) {
2338 qemu_chr_read(chr
, buf
, 1);
2339 } else if (term_fifo_size
== 0) {
2340 term_fifo
[term_fifo_size
++] = buf
[0];
2345 /* init terminal so that we can grab keys */
2346 static struct termios oldtty
;
2347 static int old_fd0_flags
;
2348 static int term_atexit_done
;
2350 static void term_exit(void)
2352 tcsetattr (0, TCSANOW
, &oldtty
);
2353 fcntl(0, F_SETFL
, old_fd0_flags
);
2356 static void term_init(void)
2360 tcgetattr (0, &tty
);
2362 old_fd0_flags
= fcntl(0, F_GETFL
);
2364 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2365 |INLCR
|IGNCR
|ICRNL
|IXON
);
2366 tty
.c_oflag
|= OPOST
;
2367 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
2368 /* if graphical mode, we allow Ctrl-C handling */
2370 tty
.c_lflag
&= ~ISIG
;
2371 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
2374 tty
.c_cc
[VTIME
] = 0;
2376 tcsetattr (0, TCSANOW
, &tty
);
2378 if (!term_atexit_done
++)
2381 fcntl(0, F_SETFL
, O_NONBLOCK
);
2384 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
2388 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2392 static CharDriverState
*qemu_chr_open_stdio(void)
2394 CharDriverState
*chr
;
2396 if (stdio_nb_clients
>= STDIO_MAX_CLIENTS
)
2398 chr
= qemu_chr_open_fd(0, 1);
2399 chr
->chr_close
= qemu_chr_close_stdio
;
2400 qemu_set_fd_handler2(0, stdio_read_poll
, stdio_read
, NULL
, chr
);
2408 /* Once Solaris has openpty(), this is going to be removed. */
2409 int openpty(int *amaster
, int *aslave
, char *name
,
2410 struct termios
*termp
, struct winsize
*winp
)
2413 int mfd
= -1, sfd
= -1;
2415 *amaster
= *aslave
= -1;
2417 mfd
= open("/dev/ptmx", O_RDWR
| O_NOCTTY
);
2421 if (grantpt(mfd
) == -1 || unlockpt(mfd
) == -1)
2424 if ((slave
= ptsname(mfd
)) == NULL
)
2427 if ((sfd
= open(slave
, O_RDONLY
| O_NOCTTY
)) == -1)
2430 if (ioctl(sfd
, I_PUSH
, "ptem") == -1 ||
2431 (termp
!= NULL
&& tcgetattr(sfd
, termp
) < 0))
2439 ioctl(sfd
, TIOCSWINSZ
, winp
);
2450 void cfmakeraw (struct termios
*termios_p
)
2452 termios_p
->c_iflag
&=
2453 ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2454 termios_p
->c_oflag
&= ~OPOST
;
2455 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2456 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2457 termios_p
->c_cflag
|= CS8
;
2459 termios_p
->c_cc
[VMIN
] = 0;
2460 termios_p
->c_cc
[VTIME
] = 0;
2464 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2465 || defined(__NetBSD__) || defined(__OpenBSD__)
2475 static void pty_chr_update_read_handler(CharDriverState
*chr
);
2476 static void pty_chr_state(CharDriverState
*chr
, int connected
);
2478 static int pty_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2480 PtyCharDriver
*s
= chr
->opaque
;
2482 if (!s
->connected
) {
2483 /* guest sends data, check for (re-)connect */
2484 pty_chr_update_read_handler(chr
);
2487 return unix_write(s
->fd
, buf
, len
);
2490 static int pty_chr_read_poll(void *opaque
)
2492 CharDriverState
*chr
= opaque
;
2493 PtyCharDriver
*s
= chr
->opaque
;
2495 s
->read_bytes
= qemu_chr_can_read(chr
);
2496 return s
->read_bytes
;
2499 static void pty_chr_read(void *opaque
)
2501 CharDriverState
*chr
= opaque
;
2502 PtyCharDriver
*s
= chr
->opaque
;
2507 if (len
> s
->read_bytes
)
2508 len
= s
->read_bytes
;
2511 size
= read(s
->fd
, buf
, len
);
2512 if ((size
== -1 && errno
== EIO
) ||
2514 pty_chr_state(chr
, 0);
2518 pty_chr_state(chr
, 1);
2519 qemu_chr_read(chr
, buf
, size
);
2523 static void pty_chr_update_read_handler(CharDriverState
*chr
)
2525 PtyCharDriver
*s
= chr
->opaque
;
2527 qemu_set_fd_handler2(s
->fd
, pty_chr_read_poll
,
2528 pty_chr_read
, NULL
, chr
);
2531 * Short timeout here: just need wait long enougth that qemu makes
2532 * it through the poll loop once. When reconnected we want a
2533 * short timeout so we notice it almost instantly. Otherwise
2534 * read() gives us -EIO instantly, making pty_chr_state() reset the
2535 * timeout to the normal (much longer) poll interval before the
2538 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 10);
2541 static void pty_chr_state(CharDriverState
*chr
, int connected
)
2543 PtyCharDriver
*s
= chr
->opaque
;
2546 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2549 /* (re-)connect poll interval for idle guests: once per second.
2550 * We check more frequently in case the guests sends data to
2551 * the virtual device linked to our pty. */
2552 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 1000);
2555 qemu_chr_reset(chr
);
2560 static void pty_chr_timer(void *opaque
)
2562 struct CharDriverState
*chr
= opaque
;
2563 PtyCharDriver
*s
= chr
->opaque
;
2568 /* If we arrive here without polling being cleared due
2569 * read returning -EIO, then we are (re-)connected */
2570 pty_chr_state(chr
, 1);
2575 pty_chr_update_read_handler(chr
);
2578 static void pty_chr_close(struct CharDriverState
*chr
)
2580 PtyCharDriver
*s
= chr
->opaque
;
2582 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2587 static CharDriverState
*qemu_chr_open_pty(void)
2589 CharDriverState
*chr
;
2593 #if defined(__OpenBSD__)
2594 char pty_name
[PATH_MAX
];
2595 #define q_ptsname(x) pty_name
2597 char *pty_name
= NULL
;
2598 #define q_ptsname(x) ptsname(x)
2601 chr
= qemu_mallocz(sizeof(CharDriverState
));
2604 s
= qemu_mallocz(sizeof(PtyCharDriver
));
2610 if (openpty(&s
->fd
, &slave_fd
, pty_name
, NULL
, NULL
) < 0) {
2614 /* Set raw attributes on the pty. */
2616 tcsetattr(slave_fd
, TCSAFLUSH
, &tty
);
2619 fprintf(stderr
, "char device redirected to %s\n", q_ptsname(s
->fd
));
2622 chr
->chr_write
= pty_chr_write
;
2623 chr
->chr_update_read_handler
= pty_chr_update_read_handler
;
2624 chr
->chr_close
= pty_chr_close
;
2626 s
->timer
= qemu_new_timer(rt_clock
, pty_chr_timer
, chr
);
2631 static void tty_serial_init(int fd
, int speed
,
2632 int parity
, int data_bits
, int stop_bits
)
2638 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2639 speed
, parity
, data_bits
, stop_bits
);
2641 tcgetattr (fd
, &tty
);
2644 if (speed
<= 50 * MARGIN
)
2646 else if (speed
<= 75 * MARGIN
)
2648 else if (speed
<= 300 * MARGIN
)
2650 else if (speed
<= 600 * MARGIN
)
2652 else if (speed
<= 1200 * MARGIN
)
2654 else if (speed
<= 2400 * MARGIN
)
2656 else if (speed
<= 4800 * MARGIN
)
2658 else if (speed
<= 9600 * MARGIN
)
2660 else if (speed
<= 19200 * MARGIN
)
2662 else if (speed
<= 38400 * MARGIN
)
2664 else if (speed
<= 57600 * MARGIN
)
2666 else if (speed
<= 115200 * MARGIN
)
2671 cfsetispeed(&tty
, spd
);
2672 cfsetospeed(&tty
, spd
);
2674 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2675 |INLCR
|IGNCR
|ICRNL
|IXON
);
2676 tty
.c_oflag
|= OPOST
;
2677 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
2678 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
2699 tty
.c_cflag
|= PARENB
;
2702 tty
.c_cflag
|= PARENB
| PARODD
;
2706 tty
.c_cflag
|= CSTOPB
;
2708 tcsetattr (fd
, TCSANOW
, &tty
);
2711 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2713 FDCharDriver
*s
= chr
->opaque
;
2716 case CHR_IOCTL_SERIAL_SET_PARAMS
:
2718 QEMUSerialSetParams
*ssp
= arg
;
2719 tty_serial_init(s
->fd_in
, ssp
->speed
, ssp
->parity
,
2720 ssp
->data_bits
, ssp
->stop_bits
);
2723 case CHR_IOCTL_SERIAL_SET_BREAK
:
2725 int enable
= *(int *)arg
;
2727 tcsendbreak(s
->fd_in
, 1);
2730 case CHR_IOCTL_SERIAL_GET_TIOCM
:
2733 int *targ
= (int *)arg
;
2734 ioctl(s
->fd_in
, TIOCMGET
, &sarg
);
2736 if (sarg
| TIOCM_CTS
)
2737 *targ
|= CHR_TIOCM_CTS
;
2738 if (sarg
| TIOCM_CAR
)
2739 *targ
|= CHR_TIOCM_CAR
;
2740 if (sarg
| TIOCM_DSR
)
2741 *targ
|= CHR_TIOCM_DSR
;
2742 if (sarg
| TIOCM_RI
)
2743 *targ
|= CHR_TIOCM_RI
;
2744 if (sarg
| TIOCM_DTR
)
2745 *targ
|= CHR_TIOCM_DTR
;
2746 if (sarg
| TIOCM_RTS
)
2747 *targ
|= CHR_TIOCM_RTS
;
2750 case CHR_IOCTL_SERIAL_SET_TIOCM
:
2752 int sarg
= *(int *)arg
;
2754 if (sarg
| CHR_TIOCM_DTR
)
2756 if (sarg
| CHR_TIOCM_RTS
)
2758 ioctl(s
->fd_in
, TIOCMSET
, &targ
);
2767 static CharDriverState
*qemu_chr_open_tty(const char *filename
)
2769 CharDriverState
*chr
;
2772 TFR(fd
= open(filename
, O_RDWR
| O_NONBLOCK
));
2773 tty_serial_init(fd
, 115200, 'N', 8, 1);
2774 chr
= qemu_chr_open_fd(fd
, fd
);
2779 chr
->chr_ioctl
= tty_serial_ioctl
;
2780 qemu_chr_reset(chr
);
2783 #else /* ! __linux__ && ! __sun__ */
2784 static CharDriverState
*qemu_chr_open_pty(void)
2788 #endif /* __linux__ || __sun__ */
2790 #if defined(__linux__)
2794 } ParallelCharDriver
;
2796 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
2798 if (s
->mode
!= mode
) {
2800 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
2807 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2809 ParallelCharDriver
*drv
= chr
->opaque
;
2814 case CHR_IOCTL_PP_READ_DATA
:
2815 if (ioctl(fd
, PPRDATA
, &b
) < 0)
2817 *(uint8_t *)arg
= b
;
2819 case CHR_IOCTL_PP_WRITE_DATA
:
2820 b
= *(uint8_t *)arg
;
2821 if (ioctl(fd
, PPWDATA
, &b
) < 0)
2824 case CHR_IOCTL_PP_READ_CONTROL
:
2825 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
2827 /* Linux gives only the lowest bits, and no way to know data
2828 direction! For better compatibility set the fixed upper
2830 *(uint8_t *)arg
= b
| 0xc0;
2832 case CHR_IOCTL_PP_WRITE_CONTROL
:
2833 b
= *(uint8_t *)arg
;
2834 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
2837 case CHR_IOCTL_PP_READ_STATUS
:
2838 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
2840 *(uint8_t *)arg
= b
;
2842 case CHR_IOCTL_PP_DATA_DIR
:
2843 if (ioctl(fd
, PPDATADIR
, (int *)arg
) < 0)
2846 case CHR_IOCTL_PP_EPP_READ_ADDR
:
2847 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2848 struct ParallelIOArg
*parg
= arg
;
2849 int n
= read(fd
, parg
->buffer
, parg
->count
);
2850 if (n
!= parg
->count
) {
2855 case CHR_IOCTL_PP_EPP_READ
:
2856 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2857 struct ParallelIOArg
*parg
= arg
;
2858 int n
= read(fd
, parg
->buffer
, parg
->count
);
2859 if (n
!= parg
->count
) {
2864 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
2865 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2866 struct ParallelIOArg
*parg
= arg
;
2867 int n
= write(fd
, parg
->buffer
, parg
->count
);
2868 if (n
!= parg
->count
) {
2873 case CHR_IOCTL_PP_EPP_WRITE
:
2874 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2875 struct ParallelIOArg
*parg
= arg
;
2876 int n
= write(fd
, parg
->buffer
, parg
->count
);
2877 if (n
!= parg
->count
) {
2888 static void pp_close(CharDriverState
*chr
)
2890 ParallelCharDriver
*drv
= chr
->opaque
;
2893 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
2894 ioctl(fd
, PPRELEASE
);
2899 static CharDriverState
*qemu_chr_open_pp(const char *filename
)
2901 CharDriverState
*chr
;
2902 ParallelCharDriver
*drv
;
2905 TFR(fd
= open(filename
, O_RDWR
));
2909 if (ioctl(fd
, PPCLAIM
) < 0) {
2914 drv
= qemu_mallocz(sizeof(ParallelCharDriver
));
2920 drv
->mode
= IEEE1284_MODE_COMPAT
;
2922 chr
= qemu_mallocz(sizeof(CharDriverState
));
2928 chr
->chr_write
= null_chr_write
;
2929 chr
->chr_ioctl
= pp_ioctl
;
2930 chr
->chr_close
= pp_close
;
2933 qemu_chr_reset(chr
);
2937 #endif /* __linux__ */
2943 HANDLE hcom
, hrecv
, hsend
;
2944 OVERLAPPED orecv
, osend
;
2949 #define NSENDBUF 2048
2950 #define NRECVBUF 2048
2951 #define MAXCONNECT 1
2952 #define NTIMEOUT 5000
2954 static int win_chr_poll(void *opaque
);
2955 static int win_chr_pipe_poll(void *opaque
);
2957 static void win_chr_close(CharDriverState
*chr
)
2959 WinCharState
*s
= chr
->opaque
;
2962 CloseHandle(s
->hsend
);
2966 CloseHandle(s
->hrecv
);
2970 CloseHandle(s
->hcom
);
2974 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
2976 qemu_del_polling_cb(win_chr_poll
, chr
);
2979 static int win_chr_init(CharDriverState
*chr
, const char *filename
)
2981 WinCharState
*s
= chr
->opaque
;
2983 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
2988 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2990 fprintf(stderr
, "Failed CreateEvent\n");
2993 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
2995 fprintf(stderr
, "Failed CreateEvent\n");
2999 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
3000 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
3001 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3002 fprintf(stderr
, "Failed CreateFile (%lu)\n", GetLastError());
3007 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
3008 fprintf(stderr
, "Failed SetupComm\n");
3012 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
3013 size
= sizeof(COMMCONFIG
);
3014 GetDefaultCommConfig(filename
, &comcfg
, &size
);
3015 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
3016 CommConfigDialog(filename
, NULL
, &comcfg
);
3018 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
3019 fprintf(stderr
, "Failed SetCommState\n");
3023 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
3024 fprintf(stderr
, "Failed SetCommMask\n");
3028 cto
.ReadIntervalTimeout
= MAXDWORD
;
3029 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
3030 fprintf(stderr
, "Failed SetCommTimeouts\n");
3034 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
3035 fprintf(stderr
, "Failed ClearCommError\n");
3038 qemu_add_polling_cb(win_chr_poll
, chr
);
3046 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
3048 WinCharState
*s
= chr
->opaque
;
3049 DWORD len
, ret
, size
, err
;
3052 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
3053 s
->osend
.hEvent
= s
->hsend
;
3056 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
3058 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
3060 err
= GetLastError();
3061 if (err
== ERROR_IO_PENDING
) {
3062 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
3080 static int win_chr_read_poll(CharDriverState
*chr
)
3082 WinCharState
*s
= chr
->opaque
;
3084 s
->max_size
= qemu_chr_can_read(chr
);
3088 static void win_chr_readfile(CharDriverState
*chr
)
3090 WinCharState
*s
= chr
->opaque
;
3095 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
3096 s
->orecv
.hEvent
= s
->hrecv
;
3097 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
3099 err
= GetLastError();
3100 if (err
== ERROR_IO_PENDING
) {
3101 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
3106 qemu_chr_read(chr
, buf
, size
);
3110 static void win_chr_read(CharDriverState
*chr
)
3112 WinCharState
*s
= chr
->opaque
;
3114 if (s
->len
> s
->max_size
)
3115 s
->len
= s
->max_size
;
3119 win_chr_readfile(chr
);
3122 static int win_chr_poll(void *opaque
)
3124 CharDriverState
*chr
= opaque
;
3125 WinCharState
*s
= chr
->opaque
;
3129 ClearCommError(s
->hcom
, &comerr
, &status
);
3130 if (status
.cbInQue
> 0) {
3131 s
->len
= status
.cbInQue
;
3132 win_chr_read_poll(chr
);
3139 static CharDriverState
*qemu_chr_open_win(const char *filename
)
3141 CharDriverState
*chr
;
3144 chr
= qemu_mallocz(sizeof(CharDriverState
));
3147 s
= qemu_mallocz(sizeof(WinCharState
));
3153 chr
->chr_write
= win_chr_write
;
3154 chr
->chr_close
= win_chr_close
;
3156 if (win_chr_init(chr
, filename
) < 0) {
3161 qemu_chr_reset(chr
);
3165 static int win_chr_pipe_poll(void *opaque
)
3167 CharDriverState
*chr
= opaque
;
3168 WinCharState
*s
= chr
->opaque
;
3171 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
3174 win_chr_read_poll(chr
);
3181 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
)
3183 WinCharState
*s
= chr
->opaque
;
3191 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3193 fprintf(stderr
, "Failed CreateEvent\n");
3196 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3198 fprintf(stderr
, "Failed CreateEvent\n");
3202 snprintf(openname
, sizeof(openname
), "\\\\.\\pipe\\%s", filename
);
3203 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
3204 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
3206 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
3207 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3208 fprintf(stderr
, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3213 ZeroMemory(&ov
, sizeof(ov
));
3214 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3215 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
3217 fprintf(stderr
, "Failed ConnectNamedPipe\n");
3221 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
3223 fprintf(stderr
, "Failed GetOverlappedResult\n");
3225 CloseHandle(ov
.hEvent
);
3232 CloseHandle(ov
.hEvent
);
3235 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
3244 static CharDriverState
*qemu_chr_open_win_pipe(const char *filename
)
3246 CharDriverState
*chr
;
3249 chr
= qemu_mallocz(sizeof(CharDriverState
));
3252 s
= qemu_mallocz(sizeof(WinCharState
));
3258 chr
->chr_write
= win_chr_write
;
3259 chr
->chr_close
= win_chr_close
;
3261 if (win_chr_pipe_init(chr
, filename
) < 0) {
3266 qemu_chr_reset(chr
);
3270 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
)
3272 CharDriverState
*chr
;
3275 chr
= qemu_mallocz(sizeof(CharDriverState
));
3278 s
= qemu_mallocz(sizeof(WinCharState
));
3285 chr
->chr_write
= win_chr_write
;
3286 qemu_chr_reset(chr
);
3290 static CharDriverState
*qemu_chr_open_win_con(const char *filename
)
3292 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
));
3295 static CharDriverState
*qemu_chr_open_win_file_out(const char *file_out
)
3299 fd_out
= CreateFile(file_out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
3300 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3301 if (fd_out
== INVALID_HANDLE_VALUE
)
3304 return qemu_chr_open_win_file(fd_out
);
3306 #endif /* !_WIN32 */
3308 /***********************************************************/
3309 /* UDP Net console */
3313 struct sockaddr_in daddr
;
3320 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3322 NetCharDriver
*s
= chr
->opaque
;
3324 return sendto(s
->fd
, buf
, len
, 0,
3325 (struct sockaddr
*)&s
->daddr
, sizeof(struct sockaddr_in
));
3328 static int udp_chr_read_poll(void *opaque
)
3330 CharDriverState
*chr
= opaque
;
3331 NetCharDriver
*s
= chr
->opaque
;
3333 s
->max_size
= qemu_chr_can_read(chr
);
3335 /* If there were any stray characters in the queue process them
3338 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3339 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3341 s
->max_size
= qemu_chr_can_read(chr
);
3346 static void udp_chr_read(void *opaque
)
3348 CharDriverState
*chr
= opaque
;
3349 NetCharDriver
*s
= chr
->opaque
;
3351 if (s
->max_size
== 0)
3353 s
->bufcnt
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
3354 s
->bufptr
= s
->bufcnt
;
3359 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3360 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3362 s
->max_size
= qemu_chr_can_read(chr
);
3366 static void udp_chr_update_read_handler(CharDriverState
*chr
)
3368 NetCharDriver
*s
= chr
->opaque
;
3371 qemu_set_fd_handler2(s
->fd
, udp_chr_read_poll
,
3372 udp_chr_read
, NULL
, chr
);
3376 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
);
3378 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
);
3380 int parse_host_src_port(struct sockaddr_in
*haddr
,
3381 struct sockaddr_in
*saddr
,
3384 static CharDriverState
*qemu_chr_open_udp(const char *def
)
3386 CharDriverState
*chr
= NULL
;
3387 NetCharDriver
*s
= NULL
;
3389 struct sockaddr_in saddr
;
3391 chr
= qemu_mallocz(sizeof(CharDriverState
));
3394 s
= qemu_mallocz(sizeof(NetCharDriver
));
3398 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
3400 perror("socket(PF_INET, SOCK_DGRAM)");
3404 if (parse_host_src_port(&s
->daddr
, &saddr
, def
) < 0) {
3405 printf("Could not parse: %s\n", def
);
3409 if (bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
)) < 0)
3419 chr
->chr_write
= udp_chr_write
;
3420 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
3433 /***********************************************************/
3434 /* TCP Net console */
3445 static void tcp_chr_accept(void *opaque
);
3447 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3449 TCPCharDriver
*s
= chr
->opaque
;
3451 return send_all(s
->fd
, buf
, len
);
3453 /* XXX: indicate an error ? */
3458 static int tcp_chr_read_poll(void *opaque
)
3460 CharDriverState
*chr
= opaque
;
3461 TCPCharDriver
*s
= chr
->opaque
;
3464 s
->max_size
= qemu_chr_can_read(chr
);
3469 #define IAC_BREAK 243
3470 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
3472 uint8_t *buf
, int *size
)
3474 /* Handle any telnet client's basic IAC options to satisfy char by
3475 * char mode with no echo. All IAC options will be removed from
3476 * the buf and the do_telnetopt variable will be used to track the
3477 * state of the width of the IAC information.
3479 * IAC commands come in sets of 3 bytes with the exception of the
3480 * "IAC BREAK" command and the double IAC.
3486 for (i
= 0; i
< *size
; i
++) {
3487 if (s
->do_telnetopt
> 1) {
3488 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
3489 /* Double IAC means send an IAC */
3493 s
->do_telnetopt
= 1;
3495 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
3496 /* Handle IAC break commands by sending a serial break */
3497 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
3502 if (s
->do_telnetopt
>= 4) {
3503 s
->do_telnetopt
= 1;
3506 if ((unsigned char)buf
[i
] == IAC
) {
3507 s
->do_telnetopt
= 2;
3518 static void tcp_chr_read(void *opaque
)
3520 CharDriverState
*chr
= opaque
;
3521 TCPCharDriver
*s
= chr
->opaque
;
3525 if (!s
->connected
|| s
->max_size
<= 0)
3528 if (len
> s
->max_size
)
3530 size
= recv(s
->fd
, buf
, len
, 0);
3532 /* connection closed */
3534 if (s
->listen_fd
>= 0) {
3535 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3537 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
3540 } else if (size
> 0) {
3541 if (s
->do_telnetopt
)
3542 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
3544 qemu_chr_read(chr
, buf
, size
);
3548 static void tcp_chr_connect(void *opaque
)
3550 CharDriverState
*chr
= opaque
;
3551 TCPCharDriver
*s
= chr
->opaque
;
3554 qemu_set_fd_handler2(s
->fd
, tcp_chr_read_poll
,
3555 tcp_chr_read
, NULL
, chr
);
3556 qemu_chr_reset(chr
);
3559 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3560 static void tcp_chr_telnet_init(int fd
)
3563 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3564 IACSET(buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3565 send(fd
, (char *)buf
, 3, 0);
3566 IACSET(buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3567 send(fd
, (char *)buf
, 3, 0);
3568 IACSET(buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3569 send(fd
, (char *)buf
, 3, 0);
3570 IACSET(buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3571 send(fd
, (char *)buf
, 3, 0);
3574 static void socket_set_nodelay(int fd
)
3577 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
3580 static void tcp_chr_accept(void *opaque
)
3582 CharDriverState
*chr
= opaque
;
3583 TCPCharDriver
*s
= chr
->opaque
;
3584 struct sockaddr_in saddr
;
3586 struct sockaddr_un uaddr
;
3588 struct sockaddr
*addr
;
3595 len
= sizeof(uaddr
);
3596 addr
= (struct sockaddr
*)&uaddr
;
3600 len
= sizeof(saddr
);
3601 addr
= (struct sockaddr
*)&saddr
;
3603 fd
= accept(s
->listen_fd
, addr
, &len
);
3604 if (fd
< 0 && errno
!= EINTR
) {
3606 } else if (fd
>= 0) {
3607 if (s
->do_telnetopt
)
3608 tcp_chr_telnet_init(fd
);
3612 socket_set_nonblock(fd
);
3614 socket_set_nodelay(fd
);
3616 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
3617 tcp_chr_connect(chr
);
3620 static void tcp_chr_close(CharDriverState
*chr
)
3622 TCPCharDriver
*s
= chr
->opaque
;
3625 if (s
->listen_fd
>= 0)
3626 closesocket(s
->listen_fd
);
3630 static CharDriverState
*qemu_chr_open_tcp(const char *host_str
,
3634 CharDriverState
*chr
= NULL
;
3635 TCPCharDriver
*s
= NULL
;
3636 int fd
= -1, ret
, err
, val
;
3638 int is_waitconnect
= 1;
3641 struct sockaddr_in saddr
;
3643 struct sockaddr_un uaddr
;
3645 struct sockaddr
*addr
;
3650 addr
= (struct sockaddr
*)&uaddr
;
3651 addrlen
= sizeof(uaddr
);
3652 if (parse_unix_path(&uaddr
, host_str
) < 0)
3657 addr
= (struct sockaddr
*)&saddr
;
3658 addrlen
= sizeof(saddr
);
3659 if (parse_host_port(&saddr
, host_str
) < 0)
3664 while((ptr
= strchr(ptr
,','))) {
3666 if (!strncmp(ptr
,"server",6)) {
3668 } else if (!strncmp(ptr
,"nowait",6)) {
3670 } else if (!strncmp(ptr
,"nodelay",6)) {
3673 printf("Unknown option: %s\n", ptr
);
3680 chr
= qemu_mallocz(sizeof(CharDriverState
));
3683 s
= qemu_mallocz(sizeof(TCPCharDriver
));
3689 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
3692 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
3697 if (!is_waitconnect
)
3698 socket_set_nonblock(fd
);
3703 s
->is_unix
= is_unix
;
3704 s
->do_nodelay
= do_nodelay
&& !is_unix
;
3707 chr
->chr_write
= tcp_chr_write
;
3708 chr
->chr_close
= tcp_chr_close
;
3711 /* allow fast reuse */
3715 pstrcpy(path
, sizeof(path
), uaddr
.sun_path
);
3721 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
3724 ret
= bind(fd
, addr
, addrlen
);
3728 ret
= listen(fd
, 0);
3733 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3735 s
->do_telnetopt
= 1;
3738 ret
= connect(fd
, addr
, addrlen
);
3740 err
= socket_error();
3741 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
3742 } else if (err
== EINPROGRESS
) {
3745 } else if (err
== WSAEALREADY
) {
3757 socket_set_nodelay(fd
);
3759 tcp_chr_connect(chr
);
3761 qemu_set_fd_handler(s
->fd
, NULL
, tcp_chr_connect
, chr
);
3764 if (is_listen
&& is_waitconnect
) {
3765 printf("QEMU waiting for connection on: %s\n", host_str
);
3766 tcp_chr_accept(chr
);
3767 socket_set_nonblock(s
->listen_fd
);
3779 CharDriverState
*qemu_chr_open(const char *filename
)
3783 if (!strcmp(filename
, "vc")) {
3784 return text_console_init(&display_state
, 0);
3785 } else if (strstart(filename
, "vc:", &p
)) {
3786 return text_console_init(&display_state
, p
);
3787 } else if (!strcmp(filename
, "null")) {
3788 return qemu_chr_open_null();
3790 if (strstart(filename
, "tcp:", &p
)) {
3791 return qemu_chr_open_tcp(p
, 0, 0);
3793 if (strstart(filename
, "telnet:", &p
)) {
3794 return qemu_chr_open_tcp(p
, 1, 0);
3796 if (strstart(filename
, "udp:", &p
)) {
3797 return qemu_chr_open_udp(p
);
3799 if (strstart(filename
, "mon:", &p
)) {
3800 CharDriverState
*drv
= qemu_chr_open(p
);
3802 drv
= qemu_chr_open_mux(drv
);
3803 monitor_init(drv
, !nographic
);
3806 printf("Unable to open driver: %s\n", p
);
3810 if (strstart(filename
, "unix:", &p
)) {
3811 return qemu_chr_open_tcp(p
, 0, 1);
3812 } else if (strstart(filename
, "file:", &p
)) {
3813 return qemu_chr_open_file_out(p
);
3814 } else if (strstart(filename
, "pipe:", &p
)) {
3815 return qemu_chr_open_pipe(p
);
3816 } else if (!strcmp(filename
, "pty")) {
3817 return qemu_chr_open_pty();
3818 } else if (!strcmp(filename
, "stdio")) {
3819 return qemu_chr_open_stdio();
3821 #if defined(__linux__)
3822 if (strstart(filename
, "/dev/parport", NULL
)) {
3823 return qemu_chr_open_pp(filename
);
3826 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3827 || defined(__NetBSD__) || defined(__OpenBSD__)
3828 if (strstart(filename
, "/dev/", NULL
)) {
3829 return qemu_chr_open_tty(filename
);
3833 if (strstart(filename
, "COM", NULL
)) {
3834 return qemu_chr_open_win(filename
);
3836 if (strstart(filename
, "pipe:", &p
)) {
3837 return qemu_chr_open_win_pipe(p
);
3839 if (strstart(filename
, "con:", NULL
)) {
3840 return qemu_chr_open_win_con(filename
);
3842 if (strstart(filename
, "file:", &p
)) {
3843 return qemu_chr_open_win_file_out(p
);
3846 #ifdef CONFIG_BRLAPI
3847 if (!strcmp(filename
, "braille")) {
3848 return chr_baum_init();
3856 void qemu_chr_close(CharDriverState
*chr
)
3859 chr
->chr_close(chr
);
3863 /***********************************************************/
3864 /* network device redirectors */
3866 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
3867 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
3871 for(i
=0;i
<size
;i
+=16) {
3875 fprintf(f
, "%08x ", i
);
3878 fprintf(f
, " %02x", buf
[i
+j
]);
3883 for(j
=0;j
<len
;j
++) {
3885 if (c
< ' ' || c
> '~')
3887 fprintf(f
, "%c", c
);
3894 static int parse_macaddr(uint8_t *macaddr
, const char *p
)
3901 offset
= strtol(p
, &last_char
, 0);
3902 if (0 == errno
&& '\0' == *last_char
&&
3903 offset
>= 0 && offset
<= 0xFFFFFF) {
3904 macaddr
[3] = (offset
& 0xFF0000) >> 16;
3905 macaddr
[4] = (offset
& 0xFF00) >> 8;
3906 macaddr
[5] = offset
& 0xFF;
3909 for(i
= 0; i
< 6; i
++) {
3910 macaddr
[i
] = strtol(p
, (char **)&p
, 16);
3915 if (*p
!= ':' && *p
!= '-')
3926 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
3931 p1
= strchr(p
, sep
);
3937 if (len
> buf_size
- 1)
3939 memcpy(buf
, p
, len
);
3946 int parse_host_src_port(struct sockaddr_in
*haddr
,
3947 struct sockaddr_in
*saddr
,
3948 const char *input_str
)
3950 char *str
= strdup(input_str
);
3951 char *host_str
= str
;
3953 const char *src_str2
;
3957 * Chop off any extra arguments at the end of the string which
3958 * would start with a comma, then fill in the src port information
3959 * if it was provided else use the "any address" and "any port".
3961 if ((ptr
= strchr(str
,',')))
3964 if ((src_str
= strchr(input_str
,'@'))) {
3969 if (parse_host_port(haddr
, host_str
) < 0)
3973 if (!src_str
|| *src_str
== '\0')
3976 if (parse_host_port(saddr
, src_str2
) < 0)
3987 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
3995 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
3997 saddr
->sin_family
= AF_INET
;
3998 if (buf
[0] == '\0') {
3999 saddr
->sin_addr
.s_addr
= 0;
4001 if (isdigit(buf
[0])) {
4002 if (!inet_aton(buf
, &saddr
->sin_addr
))
4005 if ((he
= gethostbyname(buf
)) == NULL
)
4007 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
4010 port
= strtol(p
, (char **)&r
, 0);
4013 saddr
->sin_port
= htons(port
);
4018 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
)
4023 len
= MIN(108, strlen(str
));
4024 p
= strchr(str
, ',');
4026 len
= MIN(len
, p
- str
);
4028 memset(uaddr
, 0, sizeof(*uaddr
));
4030 uaddr
->sun_family
= AF_UNIX
;
4031 memcpy(uaddr
->sun_path
, str
, len
);
4037 /* find or alloc a new VLAN */
4038 VLANState
*qemu_find_vlan(int id
)
4040 VLANState
**pvlan
, *vlan
;
4041 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
4045 vlan
= qemu_mallocz(sizeof(VLANState
));
4050 pvlan
= &first_vlan
;
4051 while (*pvlan
!= NULL
)
4052 pvlan
= &(*pvlan
)->next
;
4057 VLANClientState
*qemu_new_vlan_client(VLANState
*vlan
,
4058 IOReadHandler
*fd_read
,
4059 IOCanRWHandler
*fd_can_read
,
4062 VLANClientState
*vc
, **pvc
;
4063 vc
= qemu_mallocz(sizeof(VLANClientState
));
4066 vc
->fd_read
= fd_read
;
4067 vc
->fd_can_read
= fd_can_read
;
4068 vc
->opaque
= opaque
;
4072 pvc
= &vlan
->first_client
;
4073 while (*pvc
!= NULL
)
4074 pvc
= &(*pvc
)->next
;
4079 void qemu_del_vlan_client(VLANClientState
*vc
)
4081 VLANClientState
**pvc
= &vc
->vlan
->first_client
;
4083 while (*pvc
!= NULL
)
4089 pvc
= &(*pvc
)->next
;
4092 int qemu_can_send_packet(VLANClientState
*vc1
)
4094 VLANState
*vlan
= vc1
->vlan
;
4095 VLANClientState
*vc
;
4097 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4099 if (vc
->fd_can_read
&& vc
->fd_can_read(vc
->opaque
))
4106 void qemu_send_packet(VLANClientState
*vc1
, const uint8_t *buf
, int size
)
4108 VLANState
*vlan
= vc1
->vlan
;
4109 VLANClientState
*vc
;
4112 printf("vlan %d send:\n", vlan
->id
);
4113 hex_dump(stdout
, buf
, size
);
4115 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4117 vc
->fd_read(vc
->opaque
, buf
, size
);
4122 #if defined(CONFIG_SLIRP)
4124 /* slirp network adapter */
4126 static int slirp_inited
;
4127 static VLANClientState
*slirp_vc
;
4129 int slirp_can_output(void)
4131 return !slirp_vc
|| qemu_can_send_packet(slirp_vc
);
4134 void slirp_output(const uint8_t *pkt
, int pkt_len
)
4137 printf("slirp output:\n");
4138 hex_dump(stdout
, pkt
, pkt_len
);
4142 qemu_send_packet(slirp_vc
, pkt
, pkt_len
);
4145 static void slirp_receive(void *opaque
, const uint8_t *buf
, int size
)
4148 printf("slirp input:\n");
4149 hex_dump(stdout
, buf
, size
);
4151 slirp_input(buf
, size
);
4154 static int net_slirp_init(VLANState
*vlan
)
4156 if (!slirp_inited
) {
4160 slirp_vc
= qemu_new_vlan_client(vlan
,
4161 slirp_receive
, NULL
, NULL
);
4162 snprintf(slirp_vc
->info_str
, sizeof(slirp_vc
->info_str
), "user redirector");
4166 static void net_slirp_redir(const char *redir_str
)
4171 struct in_addr guest_addr
;
4172 int host_port
, guest_port
;
4174 if (!slirp_inited
) {
4180 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4182 if (!strcmp(buf
, "tcp")) {
4184 } else if (!strcmp(buf
, "udp")) {
4190 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4192 host_port
= strtol(buf
, &r
, 0);
4196 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4198 if (buf
[0] == '\0') {
4199 pstrcpy(buf
, sizeof(buf
), "10.0.2.15");
4201 if (!inet_aton(buf
, &guest_addr
))
4204 guest_port
= strtol(p
, &r
, 0);
4208 if (slirp_redir(is_udp
, host_port
, guest_addr
, guest_port
) < 0) {
4209 fprintf(stderr
, "qemu: could not set up redirection\n");
4214 fprintf(stderr
, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4220 static char smb_dir
[1024];
4222 static void erase_dir(char *dir_name
)
4226 char filename
[1024];
4228 /* erase all the files in the directory */
4229 if ((d
= opendir(dir_name
)) != 0) {
4234 if (strcmp(de
->d_name
, ".") != 0 &&
4235 strcmp(de
->d_name
, "..") != 0) {
4236 snprintf(filename
, sizeof(filename
), "%s/%s",
4237 smb_dir
, de
->d_name
);
4238 if (unlink(filename
) != 0) /* is it a directory? */
4239 erase_dir(filename
);
4247 /* automatic user mode samba server configuration */
4248 static void smb_exit(void)
4253 /* automatic user mode samba server configuration */
4254 static void net_slirp_smb(const char *exported_dir
)
4256 char smb_conf
[1024];
4257 char smb_cmdline
[1024];
4260 if (!slirp_inited
) {
4265 /* XXX: better tmp dir construction */
4266 snprintf(smb_dir
, sizeof(smb_dir
), "/tmp/qemu-smb.%d", getpid());
4267 if (mkdir(smb_dir
, 0700) < 0) {
4268 fprintf(stderr
, "qemu: could not create samba server dir '%s'\n", smb_dir
);
4271 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", smb_dir
, "smb.conf");
4273 f
= fopen(smb_conf
, "w");
4275 fprintf(stderr
, "qemu: could not create samba server configuration file '%s'\n", smb_conf
);
4282 "socket address=127.0.0.1\n"
4283 "pid directory=%s\n"
4284 "lock directory=%s\n"
4285 "log file=%s/log.smbd\n"
4286 "smb passwd file=%s/smbpasswd\n"
4287 "security = share\n"
4302 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -s %s",
4303 SMBD_COMMAND
, smb_conf
);
4305 slirp_add_exec(0, smb_cmdline
, 4, 139);
4308 #endif /* !defined(_WIN32) */
4309 void do_info_slirp(void)
4314 #endif /* CONFIG_SLIRP */
4316 #if !defined(_WIN32)
4318 typedef struct TAPState
{
4319 VLANClientState
*vc
;
4321 char down_script
[1024];
4324 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
4326 TAPState
*s
= opaque
;
4329 ret
= write(s
->fd
, buf
, size
);
4330 if (ret
< 0 && (errno
== EINTR
|| errno
== EAGAIN
)) {
4337 static void tap_send(void *opaque
)
4339 TAPState
*s
= opaque
;
4346 sbuf
.maxlen
= sizeof(buf
);
4348 size
= getmsg(s
->fd
, NULL
, &sbuf
, &f
) >=0 ? sbuf
.len
: -1;
4350 size
= read(s
->fd
, buf
, sizeof(buf
));
4353 qemu_send_packet(s
->vc
, buf
, size
);
4359 static TAPState
*net_tap_fd_init(VLANState
*vlan
, int fd
)
4363 s
= qemu_mallocz(sizeof(TAPState
));
4367 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
4368 qemu_set_fd_handler(s
->fd
, tap_send
, NULL
, s
);
4369 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "tap: fd=%d", fd
);
4373 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4374 static int tap_open(char *ifname
, int ifname_size
)
4380 TFR(fd
= open("/dev/tap", O_RDWR
));
4382 fprintf(stderr
, "warning: could not open /dev/tap: no virtual network emulation\n");
4387 dev
= devname(s
.st_rdev
, S_IFCHR
);
4388 pstrcpy(ifname
, ifname_size
, dev
);
4390 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4393 #elif defined(__sun__)
4394 #define TUNNEWPPA (('T'<<16) | 0x0001)
4396 * Allocate TAP device, returns opened fd.
4397 * Stores dev name in the first arg(must be large enough).
4399 int tap_alloc(char *dev
, size_t dev_size
)
4401 int tap_fd
, if_fd
, ppa
= -1;
4402 static int ip_fd
= 0;
4405 static int arp_fd
= 0;
4406 int ip_muxid
, arp_muxid
;
4407 struct strioctl strioc_if
, strioc_ppa
;
4408 int link_type
= I_PLINK
;;
4410 char actual_name
[32] = "";
4412 memset(&ifr
, 0x0, sizeof(ifr
));
4416 while( *ptr
&& !isdigit((int)*ptr
) ) ptr
++;
4420 /* Check if IP device was opened */
4424 TFR(ip_fd
= open("/dev/udp", O_RDWR
, 0));
4426 syslog(LOG_ERR
, "Can't open /dev/ip (actually /dev/udp)");
4430 TFR(tap_fd
= open("/dev/tap", O_RDWR
, 0));
4432 syslog(LOG_ERR
, "Can't open /dev/tap");
4436 /* Assign a new PPA and get its unit number. */
4437 strioc_ppa
.ic_cmd
= TUNNEWPPA
;
4438 strioc_ppa
.ic_timout
= 0;
4439 strioc_ppa
.ic_len
= sizeof(ppa
);
4440 strioc_ppa
.ic_dp
= (char *)&ppa
;
4441 if ((ppa
= ioctl (tap_fd
, I_STR
, &strioc_ppa
)) < 0)
4442 syslog (LOG_ERR
, "Can't assign new interface");
4444 TFR(if_fd
= open("/dev/tap", O_RDWR
, 0));
4446 syslog(LOG_ERR
, "Can't open /dev/tap (2)");
4449 if(ioctl(if_fd
, I_PUSH
, "ip") < 0){
4450 syslog(LOG_ERR
, "Can't push IP module");
4454 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) < 0)
4455 syslog(LOG_ERR
, "Can't get flags\n");
4457 snprintf (actual_name
, 32, "tap%d", ppa
);
4458 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4461 /* Assign ppa according to the unit number returned by tun device */
4463 if (ioctl (if_fd
, SIOCSLIFNAME
, &ifr
) < 0)
4464 syslog (LOG_ERR
, "Can't set PPA %d", ppa
);
4465 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) <0)
4466 syslog (LOG_ERR
, "Can't get flags\n");
4467 /* Push arp module to if_fd */
4468 if (ioctl (if_fd
, I_PUSH
, "arp") < 0)
4469 syslog (LOG_ERR
, "Can't push ARP module (2)");
4471 /* Push arp module to ip_fd */
4472 if (ioctl (ip_fd
, I_POP
, NULL
) < 0)
4473 syslog (LOG_ERR
, "I_POP failed\n");
4474 if (ioctl (ip_fd
, I_PUSH
, "arp") < 0)
4475 syslog (LOG_ERR
, "Can't push ARP module (3)\n");
4477 TFR(arp_fd
= open ("/dev/tap", O_RDWR
, 0));
4479 syslog (LOG_ERR
, "Can't open %s\n", "/dev/tap");
4481 /* Set ifname to arp */
4482 strioc_if
.ic_cmd
= SIOCSLIFNAME
;
4483 strioc_if
.ic_timout
= 0;
4484 strioc_if
.ic_len
= sizeof(ifr
);
4485 strioc_if
.ic_dp
= (char *)&ifr
;
4486 if (ioctl(arp_fd
, I_STR
, &strioc_if
) < 0){
4487 syslog (LOG_ERR
, "Can't set ifname to arp\n");
4490 if((ip_muxid
= ioctl(ip_fd
, I_LINK
, if_fd
)) < 0){
4491 syslog(LOG_ERR
, "Can't link TAP device to IP");
4495 if ((arp_muxid
= ioctl (ip_fd
, link_type
, arp_fd
)) < 0)
4496 syslog (LOG_ERR
, "Can't link TAP device to ARP");
4500 memset(&ifr
, 0x0, sizeof(ifr
));
4501 strncpy (ifr
.lifr_name
, actual_name
, sizeof (ifr
.lifr_name
));
4502 ifr
.lifr_ip_muxid
= ip_muxid
;
4503 ifr
.lifr_arp_muxid
= arp_muxid
;
4505 if (ioctl (ip_fd
, SIOCSLIFMUXID
, &ifr
) < 0)
4507 ioctl (ip_fd
, I_PUNLINK
, arp_muxid
);
4508 ioctl (ip_fd
, I_PUNLINK
, ip_muxid
);
4509 syslog (LOG_ERR
, "Can't set multiplexor id");
4512 snprintf(dev
, dev_size
, "tap%d", ppa
);
4516 static int tap_open(char *ifname
, int ifname_size
)
4520 if( (fd
= tap_alloc(dev
, sizeof(dev
))) < 0 ){
4521 fprintf(stderr
, "Cannot allocate TAP device\n");
4524 pstrcpy(ifname
, ifname_size
, dev
);
4525 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4529 static int tap_open(char *ifname
, int ifname_size
)
4534 TFR(fd
= open("/dev/net/tun", O_RDWR
));
4536 fprintf(stderr
, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4539 memset(&ifr
, 0, sizeof(ifr
));
4540 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
4541 if (ifname
[0] != '\0')
4542 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, ifname
);
4544 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, "tap%d");
4545 ret
= ioctl(fd
, TUNSETIFF
, (void *) &ifr
);
4547 fprintf(stderr
, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4551 pstrcpy(ifname
, ifname_size
, ifr
.ifr_name
);
4552 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4557 static int launch_script(const char *setup_script
, const char *ifname
, int fd
)
4563 /* try to launch network script */
4567 int open_max
= sysconf (_SC_OPEN_MAX
), i
;
4568 for (i
= 0; i
< open_max
; i
++)
4569 if (i
!= STDIN_FILENO
&&
4570 i
!= STDOUT_FILENO
&&
4571 i
!= STDERR_FILENO
&&
4576 *parg
++ = (char *)setup_script
;
4577 *parg
++ = (char *)ifname
;
4579 execv(setup_script
, args
);
4582 while (waitpid(pid
, &status
, 0) != pid
);
4583 if (!WIFEXITED(status
) ||
4584 WEXITSTATUS(status
) != 0) {
4585 fprintf(stderr
, "%s: could not launch network script\n",
4593 static int net_tap_init(VLANState
*vlan
, const char *ifname1
,
4594 const char *setup_script
, const char *down_script
)
4600 if (ifname1
!= NULL
)
4601 pstrcpy(ifname
, sizeof(ifname
), ifname1
);
4604 TFR(fd
= tap_open(ifname
, sizeof(ifname
)));
4608 if (!setup_script
|| !strcmp(setup_script
, "no"))
4610 if (setup_script
[0] != '\0') {
4611 if (launch_script(setup_script
, ifname
, fd
))
4614 s
= net_tap_fd_init(vlan
, fd
);
4617 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4618 "tap: ifname=%s setup_script=%s", ifname
, setup_script
);
4619 if (down_script
&& strcmp(down_script
, "no"))
4620 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", down_script
);
4624 #endif /* !_WIN32 */
4626 #if defined(CONFIG_VDE)
4627 typedef struct VDEState
{
4628 VLANClientState
*vc
;
4632 static void vde_to_qemu(void *opaque
)
4634 VDEState
*s
= opaque
;
4638 size
= vde_recv(s
->vde
, buf
, sizeof(buf
), 0);
4640 qemu_send_packet(s
->vc
, buf
, size
);
4644 static void vde_from_qemu(void *opaque
, const uint8_t *buf
, int size
)
4646 VDEState
*s
= opaque
;
4649 ret
= vde_send(s
->vde
, buf
, size
, 0);
4650 if (ret
< 0 && errno
== EINTR
) {
4657 static int net_vde_init(VLANState
*vlan
, const char *sock
, int port
,
4658 const char *group
, int mode
)
4661 char *init_group
= strlen(group
) ? (char *)group
: NULL
;
4662 char *init_sock
= strlen(sock
) ? (char *)sock
: NULL
;
4664 struct vde_open_args args
= {
4666 .group
= init_group
,
4670 s
= qemu_mallocz(sizeof(VDEState
));
4673 s
->vde
= vde_open(init_sock
, "QEMU", &args
);
4678 s
->vc
= qemu_new_vlan_client(vlan
, vde_from_qemu
, NULL
, s
);
4679 qemu_set_fd_handler(vde_datafd(s
->vde
), vde_to_qemu
, NULL
, s
);
4680 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "vde: sock=%s fd=%d",
4681 sock
, vde_datafd(s
->vde
));
4686 /* network connection */
4687 typedef struct NetSocketState
{
4688 VLANClientState
*vc
;
4690 int state
; /* 0 = getting length, 1 = getting data */
4694 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4697 typedef struct NetSocketListenState
{
4700 } NetSocketListenState
;
4702 /* XXX: we consider we can send the whole packet without blocking */
4703 static void net_socket_receive(void *opaque
, const uint8_t *buf
, int size
)
4705 NetSocketState
*s
= opaque
;
4709 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
4710 send_all(s
->fd
, buf
, size
);
4713 static void net_socket_receive_dgram(void *opaque
, const uint8_t *buf
, int size
)
4715 NetSocketState
*s
= opaque
;
4716 sendto(s
->fd
, buf
, size
, 0,
4717 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
4720 static void net_socket_send(void *opaque
)
4722 NetSocketState
*s
= opaque
;
4727 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
4729 err
= socket_error();
4730 if (err
!= EWOULDBLOCK
)
4732 } else if (size
== 0) {
4733 /* end of connection */
4735 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4741 /* reassemble a packet from the network */
4747 memcpy(s
->buf
+ s
->index
, buf
, l
);
4751 if (s
->index
== 4) {
4753 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
4759 l
= s
->packet_len
- s
->index
;
4762 memcpy(s
->buf
+ s
->index
, buf
, l
);
4766 if (s
->index
>= s
->packet_len
) {
4767 qemu_send_packet(s
->vc
, s
->buf
, s
->packet_len
);
4776 static void net_socket_send_dgram(void *opaque
)
4778 NetSocketState
*s
= opaque
;
4781 size
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
4785 /* end of connection */
4786 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
4789 qemu_send_packet(s
->vc
, s
->buf
, size
);
4792 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
)
4797 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
4798 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
4799 inet_ntoa(mcastaddr
->sin_addr
),
4800 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
4804 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
4806 perror("socket(PF_INET, SOCK_DGRAM)");
4811 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
4812 (const char *)&val
, sizeof(val
));
4814 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
4818 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
4824 /* Add host to multicast group */
4825 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
4826 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
4828 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
4829 (const char *)&imr
, sizeof(struct ip_mreq
));
4831 perror("setsockopt(IP_ADD_MEMBERSHIP)");
4835 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
4837 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
4838 (const char *)&val
, sizeof(val
));
4840 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
4844 socket_set_nonblock(fd
);
4852 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
, int fd
,
4855 struct sockaddr_in saddr
;
4857 socklen_t saddr_len
;
4860 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
4861 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
4862 * by ONLY ONE process: we must "clone" this dgram socket --jjo
4866 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
4868 if (saddr
.sin_addr
.s_addr
==0) {
4869 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
4873 /* clone dgram socket */
4874 newfd
= net_socket_mcast_create(&saddr
);
4876 /* error already reported by net_socket_mcast_create() */
4880 /* clone newfd to fd, close newfd */
4885 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
4886 fd
, strerror(errno
));
4891 s
= qemu_mallocz(sizeof(NetSocketState
));
4896 s
->vc
= qemu_new_vlan_client(vlan
, net_socket_receive_dgram
, NULL
, s
);
4897 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
4899 /* mcast: save bound address as dst */
4900 if (is_connected
) s
->dgram_dst
=saddr
;
4902 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4903 "socket: fd=%d (%s mcast=%s:%d)",
4904 fd
, is_connected
? "cloned" : "",
4905 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4909 static void net_socket_connect(void *opaque
)
4911 NetSocketState
*s
= opaque
;
4912 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
4915 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
, int fd
,
4919 s
= qemu_mallocz(sizeof(NetSocketState
));
4923 s
->vc
= qemu_new_vlan_client(vlan
,
4924 net_socket_receive
, NULL
, s
);
4925 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4926 "socket: fd=%d", fd
);
4928 net_socket_connect(s
);
4930 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
4935 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
, int fd
,
4938 int so_type
=-1, optlen
=sizeof(so_type
);
4940 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
4941 (socklen_t
*)&optlen
)< 0) {
4942 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
4947 return net_socket_fd_init_dgram(vlan
, fd
, is_connected
);
4949 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4951 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
4952 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
4953 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
4958 static void net_socket_accept(void *opaque
)
4960 NetSocketListenState
*s
= opaque
;
4962 struct sockaddr_in saddr
;
4967 len
= sizeof(saddr
);
4968 fd
= accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
4969 if (fd
< 0 && errno
!= EINTR
) {
4971 } else if (fd
>= 0) {
4975 s1
= net_socket_fd_init(s
->vlan
, fd
, 1);
4979 snprintf(s1
->vc
->info_str
, sizeof(s1
->vc
->info_str
),
4980 "socket: connection from %s:%d",
4981 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
4985 static int net_socket_listen_init(VLANState
*vlan
, const char *host_str
)
4987 NetSocketListenState
*s
;
4989 struct sockaddr_in saddr
;
4991 if (parse_host_port(&saddr
, host_str
) < 0)
4994 s
= qemu_mallocz(sizeof(NetSocketListenState
));
4998 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5003 socket_set_nonblock(fd
);
5005 /* allow fast reuse */
5007 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
5009 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5014 ret
= listen(fd
, 0);
5021 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
5025 static int net_socket_connect_init(VLANState
*vlan
, const char *host_str
)
5028 int fd
, connected
, ret
, err
;
5029 struct sockaddr_in saddr
;
5031 if (parse_host_port(&saddr
, host_str
) < 0)
5034 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5039 socket_set_nonblock(fd
);
5043 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5045 err
= socket_error();
5046 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
5047 } else if (err
== EINPROGRESS
) {
5050 } else if (err
== WSAEALREADY
) {
5063 s
= net_socket_fd_init(vlan
, fd
, connected
);
5066 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5067 "socket: connect to %s:%d",
5068 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5072 static int net_socket_mcast_init(VLANState
*vlan
, const char *host_str
)
5076 struct sockaddr_in saddr
;
5078 if (parse_host_port(&saddr
, host_str
) < 0)
5082 fd
= net_socket_mcast_create(&saddr
);
5086 s
= net_socket_fd_init(vlan
, fd
, 0);
5090 s
->dgram_dst
= saddr
;
5092 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5093 "socket: mcast=%s:%d",
5094 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5099 static const char *get_opt_name(char *buf
, int buf_size
, const char *p
)
5104 while (*p
!= '\0' && *p
!= '=') {
5105 if (q
&& (q
- buf
) < buf_size
- 1)
5115 static const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
5120 while (*p
!= '\0') {
5122 if (*(p
+ 1) != ',')
5126 if (q
&& (q
- buf
) < buf_size
- 1)
5136 static int get_param_value(char *buf
, int buf_size
,
5137 const char *tag
, const char *str
)
5144 p
= get_opt_name(option
, sizeof(option
), p
);
5148 if (!strcmp(tag
, option
)) {
5149 (void)get_opt_value(buf
, buf_size
, p
);
5152 p
= get_opt_value(NULL
, 0, p
);
5161 static int check_params(char *buf
, int buf_size
,
5162 const char * const *params
, const char *str
)
5169 p
= get_opt_name(buf
, buf_size
, p
);
5173 for(i
= 0; params
[i
] != NULL
; i
++)
5174 if (!strcmp(params
[i
], buf
))
5176 if (params
[i
] == NULL
)
5178 p
= get_opt_value(NULL
, 0, p
);
5186 static int net_client_init(const char *device
, const char *p
)
5193 if (get_param_value(buf
, sizeof(buf
), "vlan", p
)) {
5194 vlan_id
= strtol(buf
, NULL
, 0);
5196 vlan
= qemu_find_vlan(vlan_id
);
5198 fprintf(stderr
, "Could not create vlan %d\n", vlan_id
);
5201 if (!strcmp(device
, "nic")) {
5205 if (nb_nics
>= MAX_NICS
) {
5206 fprintf(stderr
, "Too Many NICs\n");
5209 nd
= &nd_table
[nb_nics
];
5210 macaddr
= nd
->macaddr
;
5216 macaddr
[5] = 0x56 + nb_nics
;
5218 if (get_param_value(buf
, sizeof(buf
), "macaddr", p
)) {
5219 if (parse_macaddr(macaddr
, buf
) < 0) {
5220 fprintf(stderr
, "invalid syntax for ethernet address\n");
5224 if (get_param_value(buf
, sizeof(buf
), "model", p
)) {
5225 nd
->model
= strdup(buf
);
5229 vlan
->nb_guest_devs
++;
5232 if (!strcmp(device
, "none")) {
5233 /* does nothing. It is needed to signal that no network cards
5238 if (!strcmp(device
, "user")) {
5239 if (get_param_value(buf
, sizeof(buf
), "hostname", p
)) {
5240 pstrcpy(slirp_hostname
, sizeof(slirp_hostname
), buf
);
5242 vlan
->nb_host_devs
++;
5243 ret
= net_slirp_init(vlan
);
5247 if (!strcmp(device
, "tap")) {
5249 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5250 fprintf(stderr
, "tap: no interface name\n");
5253 vlan
->nb_host_devs
++;
5254 ret
= tap_win32_init(vlan
, ifname
);
5257 if (!strcmp(device
, "tap")) {
5259 char setup_script
[1024], down_script
[1024];
5261 vlan
->nb_host_devs
++;
5262 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5263 fd
= strtol(buf
, NULL
, 0);
5264 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
5266 if (net_tap_fd_init(vlan
, fd
))
5269 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5272 if (get_param_value(setup_script
, sizeof(setup_script
), "script", p
) == 0) {
5273 pstrcpy(setup_script
, sizeof(setup_script
), DEFAULT_NETWORK_SCRIPT
);
5275 if (get_param_value(down_script
, sizeof(down_script
), "downscript", p
) == 0) {
5276 pstrcpy(down_script
, sizeof(down_script
), DEFAULT_NETWORK_DOWN_SCRIPT
);
5278 ret
= net_tap_init(vlan
, ifname
, setup_script
, down_script
);
5282 if (!strcmp(device
, "socket")) {
5283 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5285 fd
= strtol(buf
, NULL
, 0);
5287 if (net_socket_fd_init(vlan
, fd
, 1))
5289 } else if (get_param_value(buf
, sizeof(buf
), "listen", p
) > 0) {
5290 ret
= net_socket_listen_init(vlan
, buf
);
5291 } else if (get_param_value(buf
, sizeof(buf
), "connect", p
) > 0) {
5292 ret
= net_socket_connect_init(vlan
, buf
);
5293 } else if (get_param_value(buf
, sizeof(buf
), "mcast", p
) > 0) {
5294 ret
= net_socket_mcast_init(vlan
, buf
);
5296 fprintf(stderr
, "Unknown socket options: %s\n", p
);
5299 vlan
->nb_host_devs
++;
5302 if (!strcmp(device
, "vde")) {
5303 char vde_sock
[1024], vde_group
[512];
5304 int vde_port
, vde_mode
;
5305 vlan
->nb_host_devs
++;
5306 if (get_param_value(vde_sock
, sizeof(vde_sock
), "sock", p
) <= 0) {
5309 if (get_param_value(buf
, sizeof(buf
), "port", p
) > 0) {
5310 vde_port
= strtol(buf
, NULL
, 10);
5314 if (get_param_value(vde_group
, sizeof(vde_group
), "group", p
) <= 0) {
5315 vde_group
[0] = '\0';
5317 if (get_param_value(buf
, sizeof(buf
), "mode", p
) > 0) {
5318 vde_mode
= strtol(buf
, NULL
, 8);
5322 ret
= net_vde_init(vlan
, vde_sock
, vde_port
, vde_group
, vde_mode
);
5326 fprintf(stderr
, "Unknown network device: %s\n", device
);
5330 fprintf(stderr
, "Could not initialize device '%s'\n", device
);
5336 static int net_client_parse(const char *str
)
5344 while (*p
!= '\0' && *p
!= ',') {
5345 if ((q
- device
) < sizeof(device
) - 1)
5353 return net_client_init(device
, p
);
5356 void do_info_network(void)
5359 VLANClientState
*vc
;
5361 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5362 term_printf("VLAN %d devices:\n", vlan
->id
);
5363 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
)
5364 term_printf(" %s\n", vc
->info_str
);
5368 /***********************************************************/
5369 /* Bluetooth support */
5372 static struct HCIInfo
*hci_table
[MAX_NICS
];
5373 static struct bt_vlan_s
{
5374 struct bt_scatternet_s net
;
5376 struct bt_vlan_s
*next
;
5379 /* find or alloc a new bluetooth "VLAN" */
5380 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
5382 struct bt_vlan_s
**pvlan
, *vlan
;
5383 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5387 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
5389 pvlan
= &first_bt_vlan
;
5390 while (*pvlan
!= NULL
)
5391 pvlan
= &(*pvlan
)->next
;
5396 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
5400 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
5405 static struct HCIInfo null_hci
= {
5406 .cmd_send
= null_hci_send
,
5407 .sco_send
= null_hci_send
,
5408 .acl_send
= null_hci_send
,
5409 .bdaddr_set
= null_hci_addr_set
,
5412 struct HCIInfo
*qemu_next_hci(void)
5414 if (cur_hci
== nb_hcis
)
5417 return hci_table
[cur_hci
++];
5420 /***********************************************************/
5421 /* QEMU Block devices */
5423 #define HD_ALIAS "index=%d,media=disk"
5425 #define CDROM_ALIAS "index=1,media=cdrom"
5427 #define CDROM_ALIAS "index=2,media=cdrom"
5429 #define FD_ALIAS "index=%d,if=floppy"
5430 #define PFLASH_ALIAS "if=pflash"
5431 #define MTD_ALIAS "if=mtd"
5432 #define SD_ALIAS "index=0,if=sd"
5434 static int drive_add(const char *file
, const char *fmt
, ...)
5438 if (nb_drives_opt
>= MAX_DRIVES
) {
5439 fprintf(stderr
, "qemu: too many drives\n");
5443 drives_opt
[nb_drives_opt
].file
= file
;
5445 vsnprintf(drives_opt
[nb_drives_opt
].opt
,
5446 sizeof(drives_opt
[0].opt
), fmt
, ap
);
5449 return nb_drives_opt
++;
5452 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
5456 /* seek interface, bus and unit */
5458 for (index
= 0; index
< nb_drives
; index
++)
5459 if (drives_table
[index
].type
== type
&&
5460 drives_table
[index
].bus
== bus
&&
5461 drives_table
[index
].unit
== unit
)
5467 int drive_get_max_bus(BlockInterfaceType type
)
5473 for (index
= 0; index
< nb_drives
; index
++) {
5474 if(drives_table
[index
].type
== type
&&
5475 drives_table
[index
].bus
> max_bus
)
5476 max_bus
= drives_table
[index
].bus
;
5481 static void bdrv_format_print(void *opaque
, const char *name
)
5483 fprintf(stderr
, " %s", name
);
5486 static int drive_init(struct drive_opt
*arg
, int snapshot
,
5487 QEMUMachine
*machine
)
5492 const char *mediastr
= "";
5493 BlockInterfaceType type
;
5494 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
5495 int bus_id
, unit_id
;
5496 int cyls
, heads
, secs
, translation
;
5497 BlockDriverState
*bdrv
;
5498 BlockDriver
*drv
= NULL
;
5503 char *str
= arg
->opt
;
5504 static const char * const params
[] = { "bus", "unit", "if", "index",
5505 "cyls", "heads", "secs", "trans",
5506 "media", "snapshot", "file",
5507 "cache", "format", NULL
};
5509 if (check_params(buf
, sizeof(buf
), params
, str
) < 0) {
5510 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
5516 cyls
= heads
= secs
= 0;
5519 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5523 if (machine
->use_scsi
) {
5525 max_devs
= MAX_SCSI_DEVS
;
5526 pstrcpy(devname
, sizeof(devname
), "scsi");
5529 max_devs
= MAX_IDE_DEVS
;
5530 pstrcpy(devname
, sizeof(devname
), "ide");
5534 /* extract parameters */
5536 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
5537 bus_id
= strtol(buf
, NULL
, 0);
5539 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
5544 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
5545 unit_id
= strtol(buf
, NULL
, 0);
5547 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
5552 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
5553 pstrcpy(devname
, sizeof(devname
), buf
);
5554 if (!strcmp(buf
, "ide")) {
5556 max_devs
= MAX_IDE_DEVS
;
5557 } else if (!strcmp(buf
, "scsi")) {
5559 max_devs
= MAX_SCSI_DEVS
;
5560 } else if (!strcmp(buf
, "floppy")) {
5563 } else if (!strcmp(buf
, "pflash")) {
5566 } else if (!strcmp(buf
, "mtd")) {
5569 } else if (!strcmp(buf
, "sd")) {
5573 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
5578 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
5579 index
= strtol(buf
, NULL
, 0);
5581 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
5586 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
5587 cyls
= strtol(buf
, NULL
, 0);
5590 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
5591 heads
= strtol(buf
, NULL
, 0);
5594 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
5595 secs
= strtol(buf
, NULL
, 0);
5598 if (cyls
|| heads
|| secs
) {
5599 if (cyls
< 1 || cyls
> 16383) {
5600 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
5603 if (heads
< 1 || heads
> 16) {
5604 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
5607 if (secs
< 1 || secs
> 63) {
5608 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
5613 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
5616 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5620 if (!strcmp(buf
, "none"))
5621 translation
= BIOS_ATA_TRANSLATION_NONE
;
5622 else if (!strcmp(buf
, "lba"))
5623 translation
= BIOS_ATA_TRANSLATION_LBA
;
5624 else if (!strcmp(buf
, "auto"))
5625 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5627 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
5632 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
5633 if (!strcmp(buf
, "disk")) {
5635 } else if (!strcmp(buf
, "cdrom")) {
5636 if (cyls
|| secs
|| heads
) {
5638 "qemu: '%s' invalid physical CHS format\n", str
);
5641 media
= MEDIA_CDROM
;
5643 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
5648 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
5649 if (!strcmp(buf
, "on"))
5651 else if (!strcmp(buf
, "off"))
5654 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
5659 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
5660 if (!strcmp(buf
, "off"))
5662 else if (!strcmp(buf
, "on"))
5665 fprintf(stderr
, "qemu: invalid cache option\n");
5670 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
5671 if (strcmp(buf
, "?") == 0) {
5672 fprintf(stderr
, "qemu: Supported formats:");
5673 bdrv_iterate_format(bdrv_format_print
, NULL
);
5674 fprintf(stderr
, "\n");
5677 drv
= bdrv_find_format(buf
);
5679 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
5684 if (arg
->file
== NULL
)
5685 get_param_value(file
, sizeof(file
), "file", str
);
5687 pstrcpy(file
, sizeof(file
), arg
->file
);
5689 /* compute bus and unit according index */
5692 if (bus_id
!= 0 || unit_id
!= -1) {
5694 "qemu: '%s' index cannot be used with bus and unit\n", str
);
5702 unit_id
= index
% max_devs
;
5703 bus_id
= index
/ max_devs
;
5707 /* if user doesn't specify a unit_id,
5708 * try to find the first free
5711 if (unit_id
== -1) {
5713 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
5715 if (max_devs
&& unit_id
>= max_devs
) {
5716 unit_id
-= max_devs
;
5724 if (max_devs
&& unit_id
>= max_devs
) {
5725 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
5726 str
, unit_id
, max_devs
- 1);
5731 * ignore multiple definitions
5734 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
5739 if (type
== IF_IDE
|| type
== IF_SCSI
)
5740 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
5742 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
5743 devname
, bus_id
, mediastr
, unit_id
);
5745 snprintf(buf
, sizeof(buf
), "%s%s%i",
5746 devname
, mediastr
, unit_id
);
5747 bdrv
= bdrv_new(buf
);
5748 drives_table
[nb_drives
].bdrv
= bdrv
;
5749 drives_table
[nb_drives
].type
= type
;
5750 drives_table
[nb_drives
].bus
= bus_id
;
5751 drives_table
[nb_drives
].unit
= unit_id
;
5760 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
5761 bdrv_set_translation_hint(bdrv
, translation
);
5765 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
5770 /* FIXME: This isn't really a floppy, but it's a reasonable
5773 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
5783 bdrv_flags
|= BDRV_O_SNAPSHOT
;
5785 bdrv_flags
|= BDRV_O_DIRECT
;
5786 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0 || qemu_key_check(bdrv
, file
)) {
5787 fprintf(stderr
, "qemu: could not open disk image %s\n",
5794 /***********************************************************/
5797 static USBPort
*used_usb_ports
;
5798 static USBPort
*free_usb_ports
;
5800 /* ??? Maybe change this to register a hub to keep track of the topology. */
5801 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
5802 usb_attachfn attach
)
5804 port
->opaque
= opaque
;
5805 port
->index
= index
;
5806 port
->attach
= attach
;
5807 port
->next
= free_usb_ports
;
5808 free_usb_ports
= port
;
5811 int usb_device_add_dev(USBDevice
*dev
)
5815 /* Find a USB port to add the device to. */
5816 port
= free_usb_ports
;
5820 /* Create a new hub and chain it on. */
5821 free_usb_ports
= NULL
;
5822 port
->next
= used_usb_ports
;
5823 used_usb_ports
= port
;
5825 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
5826 usb_attach(port
, hub
);
5827 port
= free_usb_ports
;
5830 free_usb_ports
= port
->next
;
5831 port
->next
= used_usb_ports
;
5832 used_usb_ports
= port
;
5833 usb_attach(port
, dev
);
5837 static int usb_device_add(const char *devname
)
5842 if (!free_usb_ports
)
5845 if (strstart(devname
, "host:", &p
)) {
5846 dev
= usb_host_device_open(p
);
5847 } else if (!strcmp(devname
, "mouse")) {
5848 dev
= usb_mouse_init();
5849 } else if (!strcmp(devname
, "tablet")) {
5850 dev
= usb_tablet_init();
5851 } else if (!strcmp(devname
, "keyboard")) {
5852 dev
= usb_keyboard_init();
5853 } else if (strstart(devname
, "disk:", &p
)) {
5854 dev
= usb_msd_init(p
);
5855 } else if (!strcmp(devname
, "wacom-tablet")) {
5856 dev
= usb_wacom_init();
5857 } else if (strstart(devname
, "serial:", &p
)) {
5858 dev
= usb_serial_init(p
);
5859 #ifdef CONFIG_BRLAPI
5860 } else if (!strcmp(devname
, "braille")) {
5861 dev
= usb_baum_init();
5863 } else if (strstart(devname
, "net:", &p
)) {
5866 if (net_client_init("nic", p
) < 0)
5868 nd_table
[nic
].model
= "usb";
5869 dev
= usb_net_init(&nd_table
[nic
]);
5876 return usb_device_add_dev(dev
);
5879 int usb_device_del_addr(int bus_num
, int addr
)
5885 if (!used_usb_ports
)
5891 lastp
= &used_usb_ports
;
5892 port
= used_usb_ports
;
5893 while (port
&& port
->dev
->addr
!= addr
) {
5894 lastp
= &port
->next
;
5902 *lastp
= port
->next
;
5903 usb_attach(port
, NULL
);
5904 dev
->handle_destroy(dev
);
5905 port
->next
= free_usb_ports
;
5906 free_usb_ports
= port
;
5910 static int usb_device_del(const char *devname
)
5915 if (strstart(devname
, "host:", &p
))
5916 return usb_host_device_close(p
);
5918 if (!used_usb_ports
)
5921 p
= strchr(devname
, '.');
5924 bus_num
= strtoul(devname
, NULL
, 0);
5925 addr
= strtoul(p
+ 1, NULL
, 0);
5927 return usb_device_del_addr(bus_num
, addr
);
5930 void do_usb_add(const char *devname
)
5932 usb_device_add(devname
);
5935 void do_usb_del(const char *devname
)
5937 usb_device_del(devname
);
5944 const char *speed_str
;
5947 term_printf("USB support not enabled\n");
5951 for (port
= used_usb_ports
; port
; port
= port
->next
) {
5955 switch(dev
->speed
) {
5959 case USB_SPEED_FULL
:
5962 case USB_SPEED_HIGH
:
5969 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
5970 0, dev
->addr
, speed_str
, dev
->devname
);
5974 /***********************************************************/
5975 /* PCMCIA/Cardbus */
5977 static struct pcmcia_socket_entry_s
{
5978 struct pcmcia_socket_s
*socket
;
5979 struct pcmcia_socket_entry_s
*next
;
5980 } *pcmcia_sockets
= 0;
5982 void pcmcia_socket_register(struct pcmcia_socket_s
*socket
)
5984 struct pcmcia_socket_entry_s
*entry
;
5986 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
5987 entry
->socket
= socket
;
5988 entry
->next
= pcmcia_sockets
;
5989 pcmcia_sockets
= entry
;
5992 void pcmcia_socket_unregister(struct pcmcia_socket_s
*socket
)
5994 struct pcmcia_socket_entry_s
*entry
, **ptr
;
5996 ptr
= &pcmcia_sockets
;
5997 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
5998 if (entry
->socket
== socket
) {
6004 void pcmcia_info(void)
6006 struct pcmcia_socket_entry_s
*iter
;
6007 if (!pcmcia_sockets
)
6008 term_printf("No PCMCIA sockets\n");
6010 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
6011 term_printf("%s: %s\n", iter
->socket
->slot_string
,
6012 iter
->socket
->attached
? iter
->socket
->card_string
:
6016 /***********************************************************/
6019 static void dumb_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
6023 static void dumb_resize(DisplayState
*ds
, int w
, int h
)
6027 static void dumb_refresh(DisplayState
*ds
)
6029 #if defined(CONFIG_SDL)
6034 static void dumb_display_init(DisplayState
*ds
)
6039 ds
->dpy_update
= dumb_update
;
6040 ds
->dpy_resize
= dumb_resize
;
6041 ds
->dpy_refresh
= dumb_refresh
;
6042 ds
->gui_timer_interval
= 500;
6046 /***********************************************************/
6049 #define MAX_IO_HANDLERS 64
6051 typedef struct IOHandlerRecord
{
6053 IOCanRWHandler
*fd_read_poll
;
6055 IOHandler
*fd_write
;
6058 /* temporary data */
6060 struct IOHandlerRecord
*next
;
6063 static IOHandlerRecord
*first_io_handler
;
6065 /* XXX: fd_read_poll should be suppressed, but an API change is
6066 necessary in the character devices to suppress fd_can_read(). */
6067 int qemu_set_fd_handler2(int fd
,
6068 IOCanRWHandler
*fd_read_poll
,
6070 IOHandler
*fd_write
,
6073 IOHandlerRecord
**pioh
, *ioh
;
6075 if (!fd_read
&& !fd_write
) {
6076 pioh
= &first_io_handler
;
6081 if (ioh
->fd
== fd
) {
6088 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
6092 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
6095 ioh
->next
= first_io_handler
;
6096 first_io_handler
= ioh
;
6099 ioh
->fd_read_poll
= fd_read_poll
;
6100 ioh
->fd_read
= fd_read
;
6101 ioh
->fd_write
= fd_write
;
6102 ioh
->opaque
= opaque
;
6108 int qemu_set_fd_handler(int fd
,
6110 IOHandler
*fd_write
,
6113 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
6116 /***********************************************************/
6117 /* Polling handling */
6119 typedef struct PollingEntry
{
6122 struct PollingEntry
*next
;
6125 static PollingEntry
*first_polling_entry
;
6127 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
6129 PollingEntry
**ppe
, *pe
;
6130 pe
= qemu_mallocz(sizeof(PollingEntry
));
6134 pe
->opaque
= opaque
;
6135 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
6140 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
6142 PollingEntry
**ppe
, *pe
;
6143 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
6145 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
6154 /***********************************************************/
6155 /* Wait objects support */
6156 typedef struct WaitObjects
{
6158 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
6159 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
6160 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
6163 static WaitObjects wait_objects
= {0};
6165 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6167 WaitObjects
*w
= &wait_objects
;
6169 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
6171 w
->events
[w
->num
] = handle
;
6172 w
->func
[w
->num
] = func
;
6173 w
->opaque
[w
->num
] = opaque
;
6178 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6181 WaitObjects
*w
= &wait_objects
;
6184 for (i
= 0; i
< w
->num
; i
++) {
6185 if (w
->events
[i
] == handle
)
6188 w
->events
[i
] = w
->events
[i
+ 1];
6189 w
->func
[i
] = w
->func
[i
+ 1];
6190 w
->opaque
[i
] = w
->opaque
[i
+ 1];
6198 /***********************************************************/
6199 /* savevm/loadvm support */
6201 #define IO_BUF_SIZE 32768
6204 QEMUFilePutBufferFunc
*put_buffer
;
6205 QEMUFileGetBufferFunc
*get_buffer
;
6206 QEMUFileCloseFunc
*close
;
6207 QEMUFileRateLimit
*rate_limit
;
6210 int64_t buf_offset
; /* start of buffer when writing, end of buffer
6213 int buf_size
; /* 0 when writing */
6214 uint8_t buf
[IO_BUF_SIZE
];
6217 typedef struct QEMUFileFD
6223 static void fd_put_notify(void *opaque
)
6225 QEMUFileFD
*s
= opaque
;
6227 /* Remove writable callback and do a put notify */
6228 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
6229 qemu_file_put_notify(s
->file
);
6232 static void fd_put_buffer(void *opaque
, const uint8_t *buf
,
6233 int64_t pos
, int size
)
6235 QEMUFileFD
*s
= opaque
;
6239 len
= write(s
->fd
, buf
, size
);
6240 } while (len
== -1 && errno
== EINTR
);
6245 /* When the fd becomes writable again, register a callback to do
6248 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, fd_put_notify
, s
);
6251 static int fd_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6253 QEMUFileFD
*s
= opaque
;
6257 len
= read(s
->fd
, buf
, size
);
6258 } while (len
== -1 && errno
== EINTR
);
6266 static int fd_close(void *opaque
)
6268 QEMUFileFD
*s
= opaque
;
6273 QEMUFile
*qemu_fopen_fd(int fd
)
6275 QEMUFileFD
*s
= qemu_mallocz(sizeof(QEMUFileFD
));
6281 s
->file
= qemu_fopen_ops(s
, fd_put_buffer
, fd_get_buffer
, fd_close
, NULL
);
6285 typedef struct QEMUFileStdio
6290 static void file_put_buffer(void *opaque
, const uint8_t *buf
,
6291 int64_t pos
, int size
)
6293 QEMUFileStdio
*s
= opaque
;
6294 fseek(s
->outfile
, pos
, SEEK_SET
);
6295 fwrite(buf
, 1, size
, s
->outfile
);
6298 static int file_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6300 QEMUFileStdio
*s
= opaque
;
6301 fseek(s
->outfile
, pos
, SEEK_SET
);
6302 return fread(buf
, 1, size
, s
->outfile
);
6305 static int file_close(void *opaque
)
6307 QEMUFileStdio
*s
= opaque
;
6313 QEMUFile
*qemu_fopen(const char *filename
, const char *mode
)
6317 s
= qemu_mallocz(sizeof(QEMUFileStdio
));
6321 s
->outfile
= fopen(filename
, mode
);
6325 if (!strcmp(mode
, "wb"))
6326 return qemu_fopen_ops(s
, file_put_buffer
, NULL
, file_close
, NULL
);
6327 else if (!strcmp(mode
, "rb"))
6328 return qemu_fopen_ops(s
, NULL
, file_get_buffer
, file_close
, NULL
);
6337 typedef struct QEMUFileBdrv
6339 BlockDriverState
*bs
;
6340 int64_t base_offset
;
6343 static void bdrv_put_buffer(void *opaque
, const uint8_t *buf
,
6344 int64_t pos
, int size
)
6346 QEMUFileBdrv
*s
= opaque
;
6347 bdrv_pwrite(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6350 static int bdrv_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6352 QEMUFileBdrv
*s
= opaque
;
6353 return bdrv_pread(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6356 static int bdrv_fclose(void *opaque
)
6358 QEMUFileBdrv
*s
= opaque
;
6363 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int64_t offset
, int is_writable
)
6367 s
= qemu_mallocz(sizeof(QEMUFileBdrv
));
6372 s
->base_offset
= offset
;
6375 return qemu_fopen_ops(s
, bdrv_put_buffer
, NULL
, bdrv_fclose
, NULL
);
6377 return qemu_fopen_ops(s
, NULL
, bdrv_get_buffer
, bdrv_fclose
, NULL
);
6380 QEMUFile
*qemu_fopen_ops(void *opaque
, QEMUFilePutBufferFunc
*put_buffer
,
6381 QEMUFileGetBufferFunc
*get_buffer
,
6382 QEMUFileCloseFunc
*close
,
6383 QEMUFileRateLimit
*rate_limit
)
6387 f
= qemu_mallocz(sizeof(QEMUFile
));
6392 f
->put_buffer
= put_buffer
;
6393 f
->get_buffer
= get_buffer
;
6395 f
->rate_limit
= rate_limit
;
6400 void qemu_fflush(QEMUFile
*f
)
6405 if (f
->buf_index
> 0) {
6406 f
->put_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, f
->buf_index
);
6407 f
->buf_offset
+= f
->buf_index
;
6412 static void qemu_fill_buffer(QEMUFile
*f
)
6419 len
= f
->get_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, IO_BUF_SIZE
);
6425 f
->buf_offset
+= len
;
6428 int qemu_fclose(QEMUFile
*f
)
6433 ret
= f
->close(f
->opaque
);
6438 void qemu_file_put_notify(QEMUFile
*f
)
6440 f
->put_buffer(f
->opaque
, NULL
, 0, 0);
6443 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, int size
)
6447 l
= IO_BUF_SIZE
- f
->buf_index
;
6450 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
6454 if (f
->buf_index
>= IO_BUF_SIZE
)
6459 void qemu_put_byte(QEMUFile
*f
, int v
)
6461 f
->buf
[f
->buf_index
++] = v
;
6462 if (f
->buf_index
>= IO_BUF_SIZE
)
6466 int qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, int size1
)
6472 l
= f
->buf_size
- f
->buf_index
;
6474 qemu_fill_buffer(f
);
6475 l
= f
->buf_size
- f
->buf_index
;
6481 memcpy(buf
, f
->buf
+ f
->buf_index
, l
);
6486 return size1
- size
;
6489 int qemu_get_byte(QEMUFile
*f
)
6491 if (f
->buf_index
>= f
->buf_size
) {
6492 qemu_fill_buffer(f
);
6493 if (f
->buf_index
>= f
->buf_size
)
6496 return f
->buf
[f
->buf_index
++];
6499 int64_t qemu_ftell(QEMUFile
*f
)
6501 return f
->buf_offset
- f
->buf_size
+ f
->buf_index
;
6504 int64_t qemu_fseek(QEMUFile
*f
, int64_t pos
, int whence
)
6506 if (whence
== SEEK_SET
) {
6508 } else if (whence
== SEEK_CUR
) {
6509 pos
+= qemu_ftell(f
);
6511 /* SEEK_END not supported */
6514 if (f
->put_buffer
) {
6516 f
->buf_offset
= pos
;
6518 f
->buf_offset
= pos
;
6525 int qemu_file_rate_limit(QEMUFile
*f
)
6528 return f
->rate_limit(f
->opaque
);
6533 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
6535 qemu_put_byte(f
, v
>> 8);
6536 qemu_put_byte(f
, v
);
6539 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
6541 qemu_put_byte(f
, v
>> 24);
6542 qemu_put_byte(f
, v
>> 16);
6543 qemu_put_byte(f
, v
>> 8);
6544 qemu_put_byte(f
, v
);
6547 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
6549 qemu_put_be32(f
, v
>> 32);
6550 qemu_put_be32(f
, v
);
6553 unsigned int qemu_get_be16(QEMUFile
*f
)
6556 v
= qemu_get_byte(f
) << 8;
6557 v
|= qemu_get_byte(f
);
6561 unsigned int qemu_get_be32(QEMUFile
*f
)
6564 v
= qemu_get_byte(f
) << 24;
6565 v
|= qemu_get_byte(f
) << 16;
6566 v
|= qemu_get_byte(f
) << 8;
6567 v
|= qemu_get_byte(f
);
6571 uint64_t qemu_get_be64(QEMUFile
*f
)
6574 v
= (uint64_t)qemu_get_be32(f
) << 32;
6575 v
|= qemu_get_be32(f
);
6579 typedef struct SaveStateEntry
{
6583 SaveStateHandler
*save_state
;
6584 LoadStateHandler
*load_state
;
6586 struct SaveStateEntry
*next
;
6589 static SaveStateEntry
*first_se
;
6591 /* TODO: Individual devices generally have very little idea about the rest
6592 of the system, so instance_id should be removed/replaced.
6593 Meanwhile pass -1 as instance_id if you do not already have a clearly
6594 distinguishing id for all instances of your device class. */
6595 int register_savevm(const char *idstr
,
6598 SaveStateHandler
*save_state
,
6599 LoadStateHandler
*load_state
,
6602 SaveStateEntry
*se
, **pse
;
6604 se
= qemu_malloc(sizeof(SaveStateEntry
));
6607 pstrcpy(se
->idstr
, sizeof(se
->idstr
), idstr
);
6608 se
->instance_id
= (instance_id
== -1) ? 0 : instance_id
;
6609 se
->version_id
= version_id
;
6610 se
->save_state
= save_state
;
6611 se
->load_state
= load_state
;
6612 se
->opaque
= opaque
;
6615 /* add at the end of list */
6617 while (*pse
!= NULL
) {
6618 if (instance_id
== -1
6619 && strcmp(se
->idstr
, (*pse
)->idstr
) == 0
6620 && se
->instance_id
<= (*pse
)->instance_id
)
6621 se
->instance_id
= (*pse
)->instance_id
+ 1;
6622 pse
= &(*pse
)->next
;
6628 #define QEMU_VM_FILE_MAGIC 0x5145564d
6629 #define QEMU_VM_FILE_VERSION 0x00000002
6631 static int qemu_savevm_state(QEMUFile
*f
)
6635 int64_t cur_pos
, len_pos
, total_len_pos
;
6637 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
6638 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
6639 total_len_pos
= qemu_ftell(f
);
6640 qemu_put_be64(f
, 0); /* total size */
6642 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6643 if (se
->save_state
== NULL
)
6644 /* this one has a loader only, for backwards compatibility */
6648 len
= strlen(se
->idstr
);
6649 qemu_put_byte(f
, len
);
6650 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
6652 qemu_put_be32(f
, se
->instance_id
);
6653 qemu_put_be32(f
, se
->version_id
);
6655 /* record size: filled later */
6656 len_pos
= qemu_ftell(f
);
6657 qemu_put_be32(f
, 0);
6658 se
->save_state(f
, se
->opaque
);
6660 /* fill record size */
6661 cur_pos
= qemu_ftell(f
);
6662 len
= cur_pos
- len_pos
- 4;
6663 qemu_fseek(f
, len_pos
, SEEK_SET
);
6664 qemu_put_be32(f
, len
);
6665 qemu_fseek(f
, cur_pos
, SEEK_SET
);
6667 cur_pos
= qemu_ftell(f
);
6668 qemu_fseek(f
, total_len_pos
, SEEK_SET
);
6669 qemu_put_be64(f
, cur_pos
- total_len_pos
- 8);
6670 qemu_fseek(f
, cur_pos
, SEEK_SET
);
6676 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
6680 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
6681 if (!strcmp(se
->idstr
, idstr
) &&
6682 instance_id
== se
->instance_id
)
6688 static int qemu_loadvm_state(QEMUFile
*f
)
6691 int len
, ret
, instance_id
, record_len
, version_id
;
6692 int64_t total_len
, end_pos
, cur_pos
;
6696 v
= qemu_get_be32(f
);
6697 if (v
!= QEMU_VM_FILE_MAGIC
)
6699 v
= qemu_get_be32(f
);
6700 if (v
!= QEMU_VM_FILE_VERSION
) {
6705 total_len
= qemu_get_be64(f
);
6706 end_pos
= total_len
+ qemu_ftell(f
);
6708 if (qemu_ftell(f
) >= end_pos
)
6710 len
= qemu_get_byte(f
);
6711 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
6713 instance_id
= qemu_get_be32(f
);
6714 version_id
= qemu_get_be32(f
);
6715 record_len
= qemu_get_be32(f
);
6717 printf("idstr=%s instance=0x%x version=%d len=%d\n",
6718 idstr
, instance_id
, version_id
, record_len
);
6720 cur_pos
= qemu_ftell(f
);
6721 se
= find_se(idstr
, instance_id
);
6723 fprintf(stderr
, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
6724 instance_id
, idstr
);
6726 ret
= se
->load_state(f
, se
->opaque
, version_id
);
6728 fprintf(stderr
, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
6729 instance_id
, idstr
);
6732 /* always seek to exact end of record */
6733 qemu_fseek(f
, cur_pos
+ record_len
, SEEK_SET
);
6740 /* device can contain snapshots */
6741 static int bdrv_can_snapshot(BlockDriverState
*bs
)
6744 !bdrv_is_removable(bs
) &&
6745 !bdrv_is_read_only(bs
));
6748 /* device must be snapshots in order to have a reliable snapshot */
6749 static int bdrv_has_snapshot(BlockDriverState
*bs
)
6752 !bdrv_is_removable(bs
) &&
6753 !bdrv_is_read_only(bs
));
6756 static BlockDriverState
*get_bs_snapshots(void)
6758 BlockDriverState
*bs
;
6762 return bs_snapshots
;
6763 for(i
= 0; i
<= nb_drives
; i
++) {
6764 bs
= drives_table
[i
].bdrv
;
6765 if (bdrv_can_snapshot(bs
))
6774 static int bdrv_snapshot_find(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
,
6777 QEMUSnapshotInfo
*sn_tab
, *sn
;
6781 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
6784 for(i
= 0; i
< nb_sns
; i
++) {
6786 if (!strcmp(sn
->id_str
, name
) || !strcmp(sn
->name
, name
)) {
6796 void do_savevm(const char *name
)
6798 BlockDriverState
*bs
, *bs1
;
6799 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
6800 int must_delete
, ret
, i
;
6801 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6803 int saved_vm_running
;
6810 bs
= get_bs_snapshots();
6812 term_printf("No block device can accept snapshots\n");
6816 /* ??? Should this occur after vm_stop? */
6819 saved_vm_running
= vm_running
;
6824 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
6829 memset(sn
, 0, sizeof(*sn
));
6831 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
6832 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
6835 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
6838 /* fill auxiliary fields */
6841 sn
->date_sec
= tb
.time
;
6842 sn
->date_nsec
= tb
.millitm
* 1000000;
6844 gettimeofday(&tv
, NULL
);
6845 sn
->date_sec
= tv
.tv_sec
;
6846 sn
->date_nsec
= tv
.tv_usec
* 1000;
6848 sn
->vm_clock_nsec
= qemu_get_clock(vm_clock
);
6850 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
6851 term_printf("Device %s does not support VM state snapshots\n",
6852 bdrv_get_device_name(bs
));
6856 /* save the VM state */
6857 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 1);
6859 term_printf("Could not open VM state file\n");
6862 ret
= qemu_savevm_state(f
);
6863 sn
->vm_state_size
= qemu_ftell(f
);
6866 term_printf("Error %d while writing VM\n", ret
);
6870 /* create the snapshots */
6872 for(i
= 0; i
< nb_drives
; i
++) {
6873 bs1
= drives_table
[i
].bdrv
;
6874 if (bdrv_has_snapshot(bs1
)) {
6876 ret
= bdrv_snapshot_delete(bs1
, old_sn
->id_str
);
6878 term_printf("Error while deleting snapshot on '%s'\n",
6879 bdrv_get_device_name(bs1
));
6882 ret
= bdrv_snapshot_create(bs1
, sn
);
6884 term_printf("Error while creating snapshot on '%s'\n",
6885 bdrv_get_device_name(bs1
));
6891 if (saved_vm_running
)
6895 void do_loadvm(const char *name
)
6897 BlockDriverState
*bs
, *bs1
;
6898 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
6901 int saved_vm_running
;
6903 bs
= get_bs_snapshots();
6905 term_printf("No block device supports snapshots\n");
6909 /* Flush all IO requests so they don't interfere with the new state. */
6912 saved_vm_running
= vm_running
;
6915 for(i
= 0; i
<= nb_drives
; i
++) {
6916 bs1
= drives_table
[i
].bdrv
;
6917 if (bdrv_has_snapshot(bs1
)) {
6918 ret
= bdrv_snapshot_goto(bs1
, name
);
6921 term_printf("Warning: ");
6924 term_printf("Snapshots not supported on device '%s'\n",
6925 bdrv_get_device_name(bs1
));
6928 term_printf("Could not find snapshot '%s' on device '%s'\n",
6929 name
, bdrv_get_device_name(bs1
));
6932 term_printf("Error %d while activating snapshot on '%s'\n",
6933 ret
, bdrv_get_device_name(bs1
));
6936 /* fatal on snapshot block device */
6943 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
6944 term_printf("Device %s does not support VM state snapshots\n",
6945 bdrv_get_device_name(bs
));
6949 /* restore the VM state */
6950 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 0);
6952 term_printf("Could not open VM state file\n");
6955 ret
= qemu_loadvm_state(f
);
6958 term_printf("Error %d while loading VM state\n", ret
);
6961 if (saved_vm_running
)
6965 void do_delvm(const char *name
)
6967 BlockDriverState
*bs
, *bs1
;
6970 bs
= get_bs_snapshots();
6972 term_printf("No block device supports snapshots\n");
6976 for(i
= 0; i
<= nb_drives
; i
++) {
6977 bs1
= drives_table
[i
].bdrv
;
6978 if (bdrv_has_snapshot(bs1
)) {
6979 ret
= bdrv_snapshot_delete(bs1
, name
);
6981 if (ret
== -ENOTSUP
)
6982 term_printf("Snapshots not supported on device '%s'\n",
6983 bdrv_get_device_name(bs1
));
6985 term_printf("Error %d while deleting snapshot on '%s'\n",
6986 ret
, bdrv_get_device_name(bs1
));
6992 void do_info_snapshots(void)
6994 BlockDriverState
*bs
, *bs1
;
6995 QEMUSnapshotInfo
*sn_tab
, *sn
;
6999 bs
= get_bs_snapshots();
7001 term_printf("No available block device supports snapshots\n");
7004 term_printf("Snapshot devices:");
7005 for(i
= 0; i
<= nb_drives
; i
++) {
7006 bs1
= drives_table
[i
].bdrv
;
7007 if (bdrv_has_snapshot(bs1
)) {
7009 term_printf(" %s", bdrv_get_device_name(bs1
));
7014 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
7016 term_printf("bdrv_snapshot_list: error %d\n", nb_sns
);
7019 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs
));
7020 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
7021 for(i
= 0; i
< nb_sns
; i
++) {
7023 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
7028 /***********************************************************/
7029 /* ram save/restore */
7031 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
7035 v
= qemu_get_byte(f
);
7038 if (qemu_get_buffer(f
, buf
, len
) != len
)
7042 v
= qemu_get_byte(f
);
7043 memset(buf
, v
, len
);
7051 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
7056 if (qemu_get_be32(f
) != phys_ram_size
)
7058 for(i
= 0; i
< phys_ram_size
; i
+= TARGET_PAGE_SIZE
) {
7059 ret
= ram_get_page(f
, phys_ram_base
+ i
, TARGET_PAGE_SIZE
);
7066 #define BDRV_HASH_BLOCK_SIZE 1024
7067 #define IOBUF_SIZE 4096
7068 #define RAM_CBLOCK_MAGIC 0xfabe
7070 typedef struct RamCompressState
{
7073 uint8_t buf
[IOBUF_SIZE
];
7076 static int ram_compress_open(RamCompressState
*s
, QEMUFile
*f
)
7079 memset(s
, 0, sizeof(*s
));
7081 ret
= deflateInit2(&s
->zstream
, 1,
7083 9, Z_DEFAULT_STRATEGY
);
7086 s
->zstream
.avail_out
= IOBUF_SIZE
;
7087 s
->zstream
.next_out
= s
->buf
;
7091 static void ram_put_cblock(RamCompressState
*s
, const uint8_t *buf
, int len
)
7093 qemu_put_be16(s
->f
, RAM_CBLOCK_MAGIC
);
7094 qemu_put_be16(s
->f
, len
);
7095 qemu_put_buffer(s
->f
, buf
, len
);
7098 static int ram_compress_buf(RamCompressState
*s
, const uint8_t *buf
, int len
)
7102 s
->zstream
.avail_in
= len
;
7103 s
->zstream
.next_in
= (uint8_t *)buf
;
7104 while (s
->zstream
.avail_in
> 0) {
7105 ret
= deflate(&s
->zstream
, Z_NO_FLUSH
);
7108 if (s
->zstream
.avail_out
== 0) {
7109 ram_put_cblock(s
, s
->buf
, IOBUF_SIZE
);
7110 s
->zstream
.avail_out
= IOBUF_SIZE
;
7111 s
->zstream
.next_out
= s
->buf
;
7117 static void ram_compress_close(RamCompressState
*s
)
7121 /* compress last bytes */
7123 ret
= deflate(&s
->zstream
, Z_FINISH
);
7124 if (ret
== Z_OK
|| ret
== Z_STREAM_END
) {
7125 len
= IOBUF_SIZE
- s
->zstream
.avail_out
;
7127 ram_put_cblock(s
, s
->buf
, len
);
7129 s
->zstream
.avail_out
= IOBUF_SIZE
;
7130 s
->zstream
.next_out
= s
->buf
;
7131 if (ret
== Z_STREAM_END
)
7138 deflateEnd(&s
->zstream
);
7141 typedef struct RamDecompressState
{
7144 uint8_t buf
[IOBUF_SIZE
];
7145 } RamDecompressState
;
7147 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
7150 memset(s
, 0, sizeof(*s
));
7152 ret
= inflateInit(&s
->zstream
);
7158 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
7162 s
->zstream
.avail_out
= len
;
7163 s
->zstream
.next_out
= buf
;
7164 while (s
->zstream
.avail_out
> 0) {
7165 if (s
->zstream
.avail_in
== 0) {
7166 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
7168 clen
= qemu_get_be16(s
->f
);
7169 if (clen
> IOBUF_SIZE
)
7171 qemu_get_buffer(s
->f
, s
->buf
, clen
);
7172 s
->zstream
.avail_in
= clen
;
7173 s
->zstream
.next_in
= s
->buf
;
7175 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
7176 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
7183 static void ram_decompress_close(RamDecompressState
*s
)
7185 inflateEnd(&s
->zstream
);
7188 static void ram_save(QEMUFile
*f
, void *opaque
)
7191 RamCompressState s1
, *s
= &s1
;
7194 qemu_put_be32(f
, phys_ram_size
);
7195 if (ram_compress_open(s
, f
) < 0)
7197 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
7199 if (tight_savevm_enabled
) {
7203 /* find if the memory block is available on a virtual
7206 for(j
= 0; j
< nb_drives
; j
++) {
7207 sector_num
= bdrv_hash_find(drives_table
[j
].bdrv
,
7209 BDRV_HASH_BLOCK_SIZE
);
7210 if (sector_num
>= 0)
7214 goto normal_compress
;
7217 cpu_to_be64wu((uint64_t *)(buf
+ 2), sector_num
);
7218 ram_compress_buf(s
, buf
, 10);
7224 ram_compress_buf(s
, buf
, 1);
7225 ram_compress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
);
7228 ram_compress_close(s
);
7231 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
7233 RamDecompressState s1
, *s
= &s1
;
7237 if (version_id
== 1)
7238 return ram_load_v1(f
, opaque
);
7239 if (version_id
!= 2)
7241 if (qemu_get_be32(f
) != phys_ram_size
)
7243 if (ram_decompress_open(s
, f
) < 0)
7245 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
7246 if (ram_decompress_buf(s
, buf
, 1) < 0) {
7247 fprintf(stderr
, "Error while reading ram block header\n");
7251 if (ram_decompress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
) < 0) {
7252 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
7261 ram_decompress_buf(s
, buf
+ 1, 9);
7263 sector_num
= be64_to_cpupu((const uint64_t *)(buf
+ 2));
7264 if (bs_index
>= nb_drives
) {
7265 fprintf(stderr
, "Invalid block device index %d\n", bs_index
);
7268 if (bdrv_read(drives_table
[bs_index
].bdrv
, sector_num
,
7270 BDRV_HASH_BLOCK_SIZE
/ 512) < 0) {
7271 fprintf(stderr
, "Error while reading sector %d:%" PRId64
"\n",
7272 bs_index
, sector_num
);
7279 printf("Error block header\n");
7283 ram_decompress_close(s
);
7287 /***********************************************************/
7288 /* bottom halves (can be seen as timers which expire ASAP) */
7297 static QEMUBH
*first_bh
= NULL
;
7299 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
7302 bh
= qemu_mallocz(sizeof(QEMUBH
));
7306 bh
->opaque
= opaque
;
7310 int qemu_bh_poll(void)
7329 void qemu_bh_schedule(QEMUBH
*bh
)
7331 CPUState
*env
= cpu_single_env
;
7335 bh
->next
= first_bh
;
7338 /* stop the currently executing CPU to execute the BH ASAP */
7340 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
7344 void qemu_bh_cancel(QEMUBH
*bh
)
7347 if (bh
->scheduled
) {
7350 pbh
= &(*pbh
)->next
;
7356 void qemu_bh_delete(QEMUBH
*bh
)
7362 /***********************************************************/
7363 /* machine registration */
7365 static QEMUMachine
*first_machine
= NULL
;
7367 int qemu_register_machine(QEMUMachine
*m
)
7370 pm
= &first_machine
;
7378 static QEMUMachine
*find_machine(const char *name
)
7382 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
7383 if (!strcmp(m
->name
, name
))
7389 /***********************************************************/
7390 /* main execution loop */
7392 static void gui_update(void *opaque
)
7394 DisplayState
*ds
= opaque
;
7395 ds
->dpy_refresh(ds
);
7396 qemu_mod_timer(ds
->gui_timer
,
7397 (ds
->gui_timer_interval
?
7398 ds
->gui_timer_interval
:
7399 GUI_REFRESH_INTERVAL
)
7400 + qemu_get_clock(rt_clock
));
7403 struct vm_change_state_entry
{
7404 VMChangeStateHandler
*cb
;
7406 LIST_ENTRY (vm_change_state_entry
) entries
;
7409 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
7411 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
7414 VMChangeStateEntry
*e
;
7416 e
= qemu_mallocz(sizeof (*e
));
7422 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
7426 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
7428 LIST_REMOVE (e
, entries
);
7432 static void vm_state_notify(int running
)
7434 VMChangeStateEntry
*e
;
7436 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
7437 e
->cb(e
->opaque
, running
);
7441 /* XXX: support several handlers */
7442 static VMStopHandler
*vm_stop_cb
;
7443 static void *vm_stop_opaque
;
7445 int qemu_add_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
7448 vm_stop_opaque
= opaque
;
7452 void qemu_del_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
7463 qemu_rearm_alarm_timer(alarm_timer
);
7467 void vm_stop(int reason
)
7470 cpu_disable_ticks();
7474 vm_stop_cb(vm_stop_opaque
, reason
);
7481 /* reset/shutdown handler */
7483 typedef struct QEMUResetEntry
{
7484 QEMUResetHandler
*func
;
7486 struct QEMUResetEntry
*next
;
7489 static QEMUResetEntry
*first_reset_entry
;
7490 static int reset_requested
;
7491 static int shutdown_requested
;
7492 static int powerdown_requested
;
7494 int qemu_shutdown_requested(void)
7496 int r
= shutdown_requested
;
7497 shutdown_requested
= 0;
7501 int qemu_reset_requested(void)
7503 int r
= reset_requested
;
7504 reset_requested
= 0;
7508 int qemu_powerdown_requested(void)
7510 int r
= powerdown_requested
;
7511 powerdown_requested
= 0;
7515 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
7517 QEMUResetEntry
**pre
, *re
;
7519 pre
= &first_reset_entry
;
7520 while (*pre
!= NULL
)
7521 pre
= &(*pre
)->next
;
7522 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
7524 re
->opaque
= opaque
;
7529 void qemu_system_reset(void)
7533 /* reset all devices */
7534 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
7535 re
->func(re
->opaque
);
7539 void qemu_system_reset_request(void)
7542 shutdown_requested
= 1;
7544 reset_requested
= 1;
7547 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7550 void qemu_system_shutdown_request(void)
7552 shutdown_requested
= 1;
7554 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7557 void qemu_system_powerdown_request(void)
7559 powerdown_requested
= 1;
7561 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
7564 void main_loop_wait(int timeout
)
7566 IOHandlerRecord
*ioh
;
7567 fd_set rfds
, wfds
, xfds
;
7576 /* XXX: need to suppress polling by better using win32 events */
7578 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
7579 ret
|= pe
->func(pe
->opaque
);
7584 WaitObjects
*w
= &wait_objects
;
7586 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, timeout
);
7587 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
7588 if (w
->func
[ret
- WAIT_OBJECT_0
])
7589 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
7591 /* Check for additional signaled events */
7592 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
7594 /* Check if event is signaled */
7595 ret2
= WaitForSingleObject(w
->events
[i
], 0);
7596 if(ret2
== WAIT_OBJECT_0
) {
7598 w
->func
[i
](w
->opaque
[i
]);
7599 } else if (ret2
== WAIT_TIMEOUT
) {
7601 err
= GetLastError();
7602 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
7605 } else if (ret
== WAIT_TIMEOUT
) {
7607 err
= GetLastError();
7608 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
7612 /* poll any events */
7613 /* XXX: separate device handlers from system ones */
7618 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7622 (!ioh
->fd_read_poll
||
7623 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
7624 FD_SET(ioh
->fd
, &rfds
);
7628 if (ioh
->fd_write
) {
7629 FD_SET(ioh
->fd
, &wfds
);
7639 tv
.tv_usec
= timeout
* 1000;
7641 #if defined(CONFIG_SLIRP)
7643 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
7646 ret
= select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
7648 IOHandlerRecord
**pioh
;
7650 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
7651 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
7652 ioh
->fd_read(ioh
->opaque
);
7654 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
7655 ioh
->fd_write(ioh
->opaque
);
7659 /* remove deleted IO handlers */
7660 pioh
= &first_io_handler
;
7670 #if defined(CONFIG_SLIRP)
7677 slirp_select_poll(&rfds
, &wfds
, &xfds
);
7682 if (likely(!(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
7683 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
7684 qemu_get_clock(vm_clock
));
7685 /* run dma transfers, if any */
7689 /* real time timers */
7690 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
7691 qemu_get_clock(rt_clock
));
7693 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
7694 alarm_timer
->flags
&= ~(ALARM_FLAG_EXPIRED
);
7695 qemu_rearm_alarm_timer(alarm_timer
);
7698 /* Check bottom-halves last in case any of the earlier events triggered
7704 static int main_loop(void)
7707 #ifdef CONFIG_PROFILER
7712 cur_cpu
= first_cpu
;
7713 next_cpu
= cur_cpu
->next_cpu
?: first_cpu
;
7720 #ifdef CONFIG_PROFILER
7721 ti
= profile_getclock();
7726 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
7727 env
->icount_decr
.u16
.low
= 0;
7728 env
->icount_extra
= 0;
7729 count
= qemu_next_deadline();
7730 count
= (count
+ (1 << icount_time_shift
) - 1)
7731 >> icount_time_shift
;
7732 qemu_icount
+= count
;
7733 decr
= (count
> 0xffff) ? 0xffff : count
;
7735 env
->icount_decr
.u16
.low
= decr
;
7736 env
->icount_extra
= count
;
7738 ret
= cpu_exec(env
);
7739 #ifdef CONFIG_PROFILER
7740 qemu_time
+= profile_getclock() - ti
;
7743 /* Fold pending instructions back into the
7744 instruction counter, and clear the interrupt flag. */
7745 qemu_icount
-= (env
->icount_decr
.u16
.low
7746 + env
->icount_extra
);
7747 env
->icount_decr
.u32
= 0;
7748 env
->icount_extra
= 0;
7750 next_cpu
= env
->next_cpu
?: first_cpu
;
7751 if (event_pending
&& likely(ret
!= EXCP_DEBUG
)) {
7752 ret
= EXCP_INTERRUPT
;
7756 if (ret
== EXCP_HLT
) {
7757 /* Give the next CPU a chance to run. */
7761 if (ret
!= EXCP_HALTED
)
7763 /* all CPUs are halted ? */
7769 if (shutdown_requested
) {
7770 ret
= EXCP_INTERRUPT
;
7778 if (reset_requested
) {
7779 reset_requested
= 0;
7780 qemu_system_reset();
7781 ret
= EXCP_INTERRUPT
;
7783 if (powerdown_requested
) {
7784 powerdown_requested
= 0;
7785 qemu_system_powerdown();
7786 ret
= EXCP_INTERRUPT
;
7788 if (unlikely(ret
== EXCP_DEBUG
)) {
7789 vm_stop(EXCP_DEBUG
);
7791 /* If all cpus are halted then wait until the next IRQ */
7792 /* XXX: use timeout computed from timers */
7793 if (ret
== EXCP_HALTED
) {
7797 /* Advance virtual time to the next event. */
7798 if (use_icount
== 1) {
7799 /* When not using an adaptive execution frequency
7800 we tend to get badly out of sync with real time,
7801 so just delay for a reasonable amount of time. */
7804 delta
= cpu_get_icount() - cpu_get_clock();
7807 /* If virtual time is ahead of real time then just
7809 timeout
= (delta
/ 1000000) + 1;
7811 /* Wait for either IO to occur or the next
7813 add
= qemu_next_deadline();
7814 /* We advance the timer before checking for IO.
7815 Limit the amount we advance so that early IO
7816 activity won't get the guest too far ahead. */
7820 add
= (add
+ (1 << icount_time_shift
) - 1)
7821 >> icount_time_shift
;
7823 timeout
= delta
/ 1000000;
7834 if (shutdown_requested
) {
7835 ret
= EXCP_INTERRUPT
;
7840 #ifdef CONFIG_PROFILER
7841 ti
= profile_getclock();
7843 main_loop_wait(timeout
);
7844 #ifdef CONFIG_PROFILER
7845 dev_time
+= profile_getclock() - ti
;
7848 cpu_disable_ticks();
7852 static void help(int exitcode
)
7854 printf("QEMU PC emulator version " QEMU_VERSION
", Copyright (c) 2003-2008 Fabrice Bellard\n"
7855 "usage: %s [options] [disk_image]\n"
7857 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
7859 "Standard options:\n"
7860 "-M machine select emulated machine (-M ? for list)\n"
7861 "-cpu cpu select CPU (-cpu ? for list)\n"
7862 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
7863 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
7864 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
7865 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
7866 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
7867 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
7868 " [,cache=on|off][,format=f]\n"
7869 " use 'file' as a drive image\n"
7870 "-mtdblock file use 'file' as on-board Flash memory image\n"
7871 "-sd file use 'file' as SecureDigital card image\n"
7872 "-pflash file use 'file' as a parallel flash image\n"
7873 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
7874 "-snapshot write to temporary files instead of disk image files\n"
7876 "-no-frame open SDL window without a frame and window decorations\n"
7877 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
7878 "-no-quit disable SDL window close capability\n"
7881 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
7883 "-m megs set virtual RAM size to megs MB [default=%d]\n"
7884 "-smp n set the number of CPUs to 'n' [default=1]\n"
7885 "-nographic disable graphical output and redirect serial I/Os to console\n"
7886 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
7888 "-k language use keyboard layout (for example \"fr\" for French)\n"
7891 "-audio-help print list of audio drivers and their options\n"
7892 "-soundhw c1,... enable audio support\n"
7893 " and only specified sound cards (comma separated list)\n"
7894 " use -soundhw ? to get the list of supported cards\n"
7895 " use -soundhw all to enable all of them\n"
7897 "-vga [std|cirrus|vmware]\n"
7898 " select video card type\n"
7899 "-localtime set the real time clock to local time [default=utc]\n"
7900 "-full-screen start in full screen\n"
7902 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
7904 "-usb enable the USB driver (will be the default soon)\n"
7905 "-usbdevice name add the host or guest USB device 'name'\n"
7906 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
7907 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
7909 "-name string set the name of the guest\n"
7910 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
7912 "Network options:\n"
7913 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7914 " create a new Network Interface Card and connect it to VLAN 'n'\n"
7916 "-net user[,vlan=n][,hostname=host]\n"
7917 " connect the user mode network stack to VLAN 'n' and send\n"
7918 " hostname 'host' to DHCP clients\n"
7921 "-net tap[,vlan=n],ifname=name\n"
7922 " connect the host TAP network interface to VLAN 'n'\n"
7924 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
7925 " connect the host TAP network interface to VLAN 'n' and use the\n"
7926 " network scripts 'file' (default=%s)\n"
7927 " and 'dfile' (default=%s);\n"
7928 " use '[down]script=no' to disable script execution;\n"
7929 " use 'fd=h' to connect to an already opened TAP interface\n"
7931 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7932 " connect the vlan 'n' to another VLAN using a socket connection\n"
7933 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
7934 " connect the vlan 'n' to multicast maddr and port\n"
7936 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
7937 " connect the vlan 'n' to port 'n' of a vde switch running\n"
7938 " on host and listening for incoming connections on 'socketpath'.\n"
7939 " Use group 'groupname' and mode 'octalmode' to change default\n"
7940 " ownership and permissions for communication port.\n"
7942 "-net none use it alone to have zero network devices; if no -net option\n"
7943 " is provided, the default is '-net nic -net user'\n"
7946 "-tftp dir allow tftp access to files in dir [-net user]\n"
7947 "-bootp file advertise file in BOOTP replies\n"
7949 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
7951 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7952 " redirect TCP or UDP connections from host to guest [-net user]\n"
7955 "Linux boot specific:\n"
7956 "-kernel bzImage use 'bzImage' as kernel image\n"
7957 "-append cmdline use 'cmdline' as kernel command line\n"
7958 "-initrd file use 'file' as initial ram disk\n"
7960 "Debug/Expert options:\n"
7961 "-monitor dev redirect the monitor to char device 'dev'\n"
7962 "-serial dev redirect the serial port to char device 'dev'\n"
7963 "-parallel dev redirect the parallel port to char device 'dev'\n"
7964 "-pidfile file Write PID to 'file'\n"
7965 "-S freeze CPU at startup (use 'c' to start execution)\n"
7966 "-s wait gdb connection to port\n"
7967 "-p port set gdb connection port [default=%s]\n"
7968 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
7969 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
7970 " translation (t=none or lba) (usually qemu can guess them)\n"
7971 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
7973 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
7974 "-no-kqemu disable KQEMU kernel module usage\n"
7977 "-no-acpi disable ACPI\n"
7979 #ifdef CONFIG_CURSES
7980 "-curses use a curses/ncurses interface instead of SDL\n"
7982 "-no-reboot exit instead of rebooting\n"
7983 "-no-shutdown stop before shutdown\n"
7984 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
7985 "-vnc display start a VNC server on display\n"
7987 "-daemonize daemonize QEMU after initializing\n"
7989 "-option-rom rom load a file, rom, into the option ROM space\n"
7991 "-prom-env variable=value set OpenBIOS nvram variables\n"
7993 "-clock force the use of the given methods for timer alarm.\n"
7994 " To see what timers are available use -clock ?\n"
7995 "-startdate select initial date of the clock\n"
7996 "-icount [N|auto]\n"
7997 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
7999 "During emulation, the following keys are useful:\n"
8000 "ctrl-alt-f toggle full screen\n"
8001 "ctrl-alt-n switch to virtual console 'n'\n"
8002 "ctrl-alt toggle mouse and keyboard grab\n"
8004 "When using -nographic, press 'ctrl-a h' to get some help.\n"
8009 DEFAULT_NETWORK_SCRIPT
,
8010 DEFAULT_NETWORK_DOWN_SCRIPT
,
8012 DEFAULT_GDBSTUB_PORT
,
8017 #define HAS_ARG 0x0001
8032 QEMU_OPTION_mtdblock
,
8036 QEMU_OPTION_snapshot
,
8038 QEMU_OPTION_no_fd_bootchk
,
8041 QEMU_OPTION_nographic
,
8042 QEMU_OPTION_portrait
,
8044 QEMU_OPTION_audio_help
,
8045 QEMU_OPTION_soundhw
,
8066 QEMU_OPTION_localtime
,
8070 QEMU_OPTION_monitor
,
8072 QEMU_OPTION_parallel
,
8074 QEMU_OPTION_full_screen
,
8075 QEMU_OPTION_no_frame
,
8076 QEMU_OPTION_alt_grab
,
8077 QEMU_OPTION_no_quit
,
8078 QEMU_OPTION_pidfile
,
8079 QEMU_OPTION_no_kqemu
,
8080 QEMU_OPTION_kernel_kqemu
,
8081 QEMU_OPTION_win2k_hack
,
8083 QEMU_OPTION_usbdevice
,
8086 QEMU_OPTION_no_acpi
,
8088 QEMU_OPTION_no_reboot
,
8089 QEMU_OPTION_no_shutdown
,
8090 QEMU_OPTION_show_cursor
,
8091 QEMU_OPTION_daemonize
,
8092 QEMU_OPTION_option_rom
,
8093 QEMU_OPTION_semihosting
,
8095 QEMU_OPTION_prom_env
,
8096 QEMU_OPTION_old_param
,
8098 QEMU_OPTION_startdate
,
8099 QEMU_OPTION_tb_size
,
8104 typedef struct QEMUOption
{
8110 static const QEMUOption qemu_options
[] = {
8111 { "h", 0, QEMU_OPTION_h
},
8112 { "help", 0, QEMU_OPTION_h
},
8114 { "M", HAS_ARG
, QEMU_OPTION_M
},
8115 { "cpu", HAS_ARG
, QEMU_OPTION_cpu
},
8116 { "fda", HAS_ARG
, QEMU_OPTION_fda
},
8117 { "fdb", HAS_ARG
, QEMU_OPTION_fdb
},
8118 { "hda", HAS_ARG
, QEMU_OPTION_hda
},
8119 { "hdb", HAS_ARG
, QEMU_OPTION_hdb
},
8120 { "hdc", HAS_ARG
, QEMU_OPTION_hdc
},
8121 { "hdd", HAS_ARG
, QEMU_OPTION_hdd
},
8122 { "drive", HAS_ARG
, QEMU_OPTION_drive
},
8123 { "cdrom", HAS_ARG
, QEMU_OPTION_cdrom
},
8124 { "mtdblock", HAS_ARG
, QEMU_OPTION_mtdblock
},
8125 { "sd", HAS_ARG
, QEMU_OPTION_sd
},
8126 { "pflash", HAS_ARG
, QEMU_OPTION_pflash
},
8127 { "boot", HAS_ARG
, QEMU_OPTION_boot
},
8128 { "snapshot", 0, QEMU_OPTION_snapshot
},
8130 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk
},
8132 { "m", HAS_ARG
, QEMU_OPTION_m
},
8133 { "nographic", 0, QEMU_OPTION_nographic
},
8134 { "portrait", 0, QEMU_OPTION_portrait
},
8135 { "k", HAS_ARG
, QEMU_OPTION_k
},
8137 { "audio-help", 0, QEMU_OPTION_audio_help
},
8138 { "soundhw", HAS_ARG
, QEMU_OPTION_soundhw
},
8141 { "net", HAS_ARG
, QEMU_OPTION_net
},
8143 { "tftp", HAS_ARG
, QEMU_OPTION_tftp
},
8144 { "bootp", HAS_ARG
, QEMU_OPTION_bootp
},
8146 { "smb", HAS_ARG
, QEMU_OPTION_smb
},
8148 { "redir", HAS_ARG
, QEMU_OPTION_redir
},
8151 { "kernel", HAS_ARG
, QEMU_OPTION_kernel
},
8152 { "append", HAS_ARG
, QEMU_OPTION_append
},
8153 { "initrd", HAS_ARG
, QEMU_OPTION_initrd
},
8155 { "S", 0, QEMU_OPTION_S
},
8156 { "s", 0, QEMU_OPTION_s
},
8157 { "p", HAS_ARG
, QEMU_OPTION_p
},
8158 { "d", HAS_ARG
, QEMU_OPTION_d
},
8159 { "hdachs", HAS_ARG
, QEMU_OPTION_hdachs
},
8160 { "L", HAS_ARG
, QEMU_OPTION_L
},
8161 { "bios", HAS_ARG
, QEMU_OPTION_bios
},
8163 { "no-kqemu", 0, QEMU_OPTION_no_kqemu
},
8164 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu
},
8166 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8167 { "g", 1, QEMU_OPTION_g
},
8169 { "localtime", 0, QEMU_OPTION_localtime
},
8170 { "vga", HAS_ARG
, QEMU_OPTION_vga
},
8171 { "echr", HAS_ARG
, QEMU_OPTION_echr
},
8172 { "monitor", HAS_ARG
, QEMU_OPTION_monitor
},
8173 { "serial", HAS_ARG
, QEMU_OPTION_serial
},
8174 { "parallel", HAS_ARG
, QEMU_OPTION_parallel
},
8175 { "loadvm", HAS_ARG
, QEMU_OPTION_loadvm
},
8176 { "full-screen", 0, QEMU_OPTION_full_screen
},
8178 { "no-frame", 0, QEMU_OPTION_no_frame
},
8179 { "alt-grab", 0, QEMU_OPTION_alt_grab
},
8180 { "no-quit", 0, QEMU_OPTION_no_quit
},
8182 { "pidfile", HAS_ARG
, QEMU_OPTION_pidfile
},
8183 { "win2k-hack", 0, QEMU_OPTION_win2k_hack
},
8184 { "usbdevice", HAS_ARG
, QEMU_OPTION_usbdevice
},
8185 { "smp", HAS_ARG
, QEMU_OPTION_smp
},
8186 { "vnc", HAS_ARG
, QEMU_OPTION_vnc
},
8187 #ifdef CONFIG_CURSES
8188 { "curses", 0, QEMU_OPTION_curses
},
8190 { "uuid", HAS_ARG
, QEMU_OPTION_uuid
},
8192 /* temporary options */
8193 { "usb", 0, QEMU_OPTION_usb
},
8194 { "no-acpi", 0, QEMU_OPTION_no_acpi
},
8195 { "no-reboot", 0, QEMU_OPTION_no_reboot
},
8196 { "no-shutdown", 0, QEMU_OPTION_no_shutdown
},
8197 { "show-cursor", 0, QEMU_OPTION_show_cursor
},
8198 { "daemonize", 0, QEMU_OPTION_daemonize
},
8199 { "option-rom", HAS_ARG
, QEMU_OPTION_option_rom
},
8200 #if defined(TARGET_ARM) || defined(TARGET_M68K)
8201 { "semihosting", 0, QEMU_OPTION_semihosting
},
8203 { "name", HAS_ARG
, QEMU_OPTION_name
},
8204 #if defined(TARGET_SPARC)
8205 { "prom-env", HAS_ARG
, QEMU_OPTION_prom_env
},
8207 #if defined(TARGET_ARM)
8208 { "old-param", 0, QEMU_OPTION_old_param
},
8210 { "clock", HAS_ARG
, QEMU_OPTION_clock
},
8211 { "startdate", HAS_ARG
, QEMU_OPTION_startdate
},
8212 { "tb-size", HAS_ARG
, QEMU_OPTION_tb_size
},
8213 { "icount", HAS_ARG
, QEMU_OPTION_icount
},
8217 /* password input */
8219 int qemu_key_check(BlockDriverState
*bs
, const char *name
)
8224 if (!bdrv_is_encrypted(bs
))
8227 term_printf("%s is encrypted.\n", name
);
8228 for(i
= 0; i
< 3; i
++) {
8229 monitor_readline("Password: ", 1, password
, sizeof(password
));
8230 if (bdrv_set_key(bs
, password
) == 0)
8232 term_printf("invalid password\n");
8237 static BlockDriverState
*get_bdrv(int index
)
8239 if (index
> nb_drives
)
8241 return drives_table
[index
].bdrv
;
8244 static void read_passwords(void)
8246 BlockDriverState
*bs
;
8249 for(i
= 0; i
< 6; i
++) {
8252 qemu_key_check(bs
, bdrv_get_device_name(bs
));
8257 struct soundhw soundhw
[] = {
8258 #ifdef HAS_AUDIO_CHOICE
8259 #if defined(TARGET_I386) || defined(TARGET_MIPS)
8265 { .init_isa
= pcspk_audio_init
}
8270 "Creative Sound Blaster 16",
8273 { .init_isa
= SB16_init
}
8276 #ifdef CONFIG_CS4231A
8282 { .init_isa
= cs4231a_init
}
8290 "Yamaha YMF262 (OPL3)",
8292 "Yamaha YM3812 (OPL2)",
8296 { .init_isa
= Adlib_init
}
8303 "Gravis Ultrasound GF1",
8306 { .init_isa
= GUS_init
}
8313 "Intel 82801AA AC97 Audio",
8316 { .init_pci
= ac97_init
}
8322 "ENSONIQ AudioPCI ES1370",
8325 { .init_pci
= es1370_init
}
8329 { NULL
, NULL
, 0, 0, { NULL
} }
8332 static void select_soundhw (const char *optarg
)
8336 if (*optarg
== '?') {
8339 printf ("Valid sound card names (comma separated):\n");
8340 for (c
= soundhw
; c
->name
; ++c
) {
8341 printf ("%-11s %s\n", c
->name
, c
->descr
);
8343 printf ("\n-soundhw all will enable all of the above\n");
8344 exit (*optarg
!= '?');
8352 if (!strcmp (optarg
, "all")) {
8353 for (c
= soundhw
; c
->name
; ++c
) {
8361 e
= strchr (p
, ',');
8362 l
= !e
? strlen (p
) : (size_t) (e
- p
);
8364 for (c
= soundhw
; c
->name
; ++c
) {
8365 if (!strncmp (c
->name
, p
, l
)) {
8374 "Unknown sound card name (too big to show)\n");
8377 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
8382 p
+= l
+ (e
!= NULL
);
8386 goto show_valid_cards
;
8391 static void select_vgahw (const char *p
)
8395 if (strstart(p
, "std", &opts
)) {
8396 cirrus_vga_enabled
= 0;
8398 } else if (strstart(p
, "cirrus", &opts
)) {
8399 cirrus_vga_enabled
= 1;
8401 } else if (strstart(p
, "vmware", &opts
)) {
8402 cirrus_vga_enabled
= 0;
8406 fprintf(stderr
, "Unknown vga type: %s\n", p
);
8410 const char *nextopt
;
8412 if (strstart(opts
, ",retrace=", &nextopt
)) {
8414 if (strstart(opts
, "dumb", &nextopt
))
8415 vga_retrace_method
= VGA_RETRACE_DUMB
;
8416 else if (strstart(opts
, "precise", &nextopt
))
8417 vga_retrace_method
= VGA_RETRACE_PRECISE
;
8418 else goto invalid_vga
;
8419 } else goto invalid_vga
;
8425 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
8427 exit(STATUS_CONTROL_C_EXIT
);
8432 static int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
8436 if(strlen(str
) != 36)
8439 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
8440 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
8441 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
8449 #define MAX_NET_CLIENTS 32
8453 static void termsig_handler(int signal
)
8455 qemu_system_shutdown_request();
8458 static void termsig_setup(void)
8460 struct sigaction act
;
8462 memset(&act
, 0, sizeof(act
));
8463 act
.sa_handler
= termsig_handler
;
8464 sigaction(SIGINT
, &act
, NULL
);
8465 sigaction(SIGHUP
, &act
, NULL
);
8466 sigaction(SIGTERM
, &act
, NULL
);
8471 int main(int argc
, char **argv
)
8473 #ifdef CONFIG_GDBSTUB
8475 const char *gdbstub_port
;
8477 uint32_t boot_devices_bitmap
= 0;
8479 int snapshot
, linux_boot
, net_boot
;
8480 const char *initrd_filename
;
8481 const char *kernel_filename
, *kernel_cmdline
;
8482 const char *boot_devices
= "";
8483 DisplayState
*ds
= &display_state
;
8484 int cyls
, heads
, secs
, translation
;
8485 const char *net_clients
[MAX_NET_CLIENTS
];
8489 const char *r
, *optarg
;
8490 CharDriverState
*monitor_hd
;
8491 const char *monitor_device
;
8492 const char *serial_devices
[MAX_SERIAL_PORTS
];
8493 int serial_device_index
;
8494 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
8495 int parallel_device_index
;
8496 const char *loadvm
= NULL
;
8497 QEMUMachine
*machine
;
8498 const char *cpu_model
;
8499 const char *usb_devices
[MAX_USB_CMDLINE
];
8500 int usb_devices_index
;
8503 const char *pid_file
= NULL
;
8506 LIST_INIT (&vm_change_state_head
);
8509 struct sigaction act
;
8510 sigfillset(&act
.sa_mask
);
8512 act
.sa_handler
= SIG_IGN
;
8513 sigaction(SIGPIPE
, &act
, NULL
);
8516 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
8517 /* Note: cpu_interrupt() is currently not SMP safe, so we force
8518 QEMU to run on a single CPU */
8523 h
= GetCurrentProcess();
8524 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
8525 for(i
= 0; i
< 32; i
++) {
8526 if (mask
& (1 << i
))
8531 SetProcessAffinityMask(h
, mask
);
8537 register_machines();
8538 machine
= first_machine
;
8540 initrd_filename
= NULL
;
8542 vga_ram_size
= VGA_RAM_SIZE
;
8543 #ifdef CONFIG_GDBSTUB
8545 gdbstub_port
= DEFAULT_GDBSTUB_PORT
;
8550 kernel_filename
= NULL
;
8551 kernel_cmdline
= "";
8552 cyls
= heads
= secs
= 0;
8553 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8554 monitor_device
= "vc";
8556 serial_devices
[0] = "vc:80Cx24C";
8557 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
8558 serial_devices
[i
] = NULL
;
8559 serial_device_index
= 0;
8561 parallel_devices
[0] = "vc:640x480";
8562 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
8563 parallel_devices
[i
] = NULL
;
8564 parallel_device_index
= 0;
8566 usb_devices_index
= 0;
8583 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
8585 const QEMUOption
*popt
;
8588 /* Treat --foo the same as -foo. */
8591 popt
= qemu_options
;
8594 fprintf(stderr
, "%s: invalid option -- '%s'\n",
8598 if (!strcmp(popt
->name
, r
+ 1))
8602 if (popt
->flags
& HAS_ARG
) {
8603 if (optind
>= argc
) {
8604 fprintf(stderr
, "%s: option '%s' requires an argument\n",
8608 optarg
= argv
[optind
++];
8613 switch(popt
->index
) {
8615 machine
= find_machine(optarg
);
8618 printf("Supported machines are:\n");
8619 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
8620 printf("%-10s %s%s\n",
8622 m
== first_machine
? " (default)" : "");
8624 exit(*optarg
!= '?');
8627 case QEMU_OPTION_cpu
:
8628 /* hw initialization will check this */
8629 if (*optarg
== '?') {
8630 /* XXX: implement xxx_cpu_list for targets that still miss it */
8631 #if defined(cpu_list)
8632 cpu_list(stdout
, &fprintf
);
8639 case QEMU_OPTION_initrd
:
8640 initrd_filename
= optarg
;
8642 case QEMU_OPTION_hda
:
8644 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
8646 hda_index
= drive_add(optarg
, HD_ALIAS
8647 ",cyls=%d,heads=%d,secs=%d%s",
8648 0, cyls
, heads
, secs
,
8649 translation
== BIOS_ATA_TRANSLATION_LBA
?
8651 translation
== BIOS_ATA_TRANSLATION_NONE
?
8652 ",trans=none" : "");
8654 case QEMU_OPTION_hdb
:
8655 case QEMU_OPTION_hdc
:
8656 case QEMU_OPTION_hdd
:
8657 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
8659 case QEMU_OPTION_drive
:
8660 drive_add(NULL
, "%s", optarg
);
8662 case QEMU_OPTION_mtdblock
:
8663 drive_add(optarg
, MTD_ALIAS
);
8665 case QEMU_OPTION_sd
:
8666 drive_add(optarg
, SD_ALIAS
);
8668 case QEMU_OPTION_pflash
:
8669 drive_add(optarg
, PFLASH_ALIAS
);
8671 case QEMU_OPTION_snapshot
:
8674 case QEMU_OPTION_hdachs
:
8678 cyls
= strtol(p
, (char **)&p
, 0);
8679 if (cyls
< 1 || cyls
> 16383)
8684 heads
= strtol(p
, (char **)&p
, 0);
8685 if (heads
< 1 || heads
> 16)
8690 secs
= strtol(p
, (char **)&p
, 0);
8691 if (secs
< 1 || secs
> 63)
8695 if (!strcmp(p
, "none"))
8696 translation
= BIOS_ATA_TRANSLATION_NONE
;
8697 else if (!strcmp(p
, "lba"))
8698 translation
= BIOS_ATA_TRANSLATION_LBA
;
8699 else if (!strcmp(p
, "auto"))
8700 translation
= BIOS_ATA_TRANSLATION_AUTO
;
8703 } else if (*p
!= '\0') {
8705 fprintf(stderr
, "qemu: invalid physical CHS format\n");
8708 if (hda_index
!= -1)
8709 snprintf(drives_opt
[hda_index
].opt
,
8710 sizeof(drives_opt
[hda_index
].opt
),
8711 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
8712 0, cyls
, heads
, secs
,
8713 translation
== BIOS_ATA_TRANSLATION_LBA
?
8715 translation
== BIOS_ATA_TRANSLATION_NONE
?
8716 ",trans=none" : "");
8719 case QEMU_OPTION_nographic
:
8722 #ifdef CONFIG_CURSES
8723 case QEMU_OPTION_curses
:
8727 case QEMU_OPTION_portrait
:
8730 case QEMU_OPTION_kernel
:
8731 kernel_filename
= optarg
;
8733 case QEMU_OPTION_append
:
8734 kernel_cmdline
= optarg
;
8736 case QEMU_OPTION_cdrom
:
8737 drive_add(optarg
, CDROM_ALIAS
);
8739 case QEMU_OPTION_boot
:
8740 boot_devices
= optarg
;
8741 /* We just do some generic consistency checks */
8743 /* Could easily be extended to 64 devices if needed */
8746 boot_devices_bitmap
= 0;
8747 for (p
= boot_devices
; *p
!= '\0'; p
++) {
8748 /* Allowed boot devices are:
8749 * a b : floppy disk drives
8750 * c ... f : IDE disk drives
8751 * g ... m : machine implementation dependant drives
8752 * n ... p : network devices
8753 * It's up to each machine implementation to check
8754 * if the given boot devices match the actual hardware
8755 * implementation and firmware features.
8757 if (*p
< 'a' || *p
> 'q') {
8758 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
8761 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
8763 "Boot device '%c' was given twice\n",*p
);
8766 boot_devices_bitmap
|= 1 << (*p
- 'a');
8770 case QEMU_OPTION_fda
:
8771 case QEMU_OPTION_fdb
:
8772 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
8775 case QEMU_OPTION_no_fd_bootchk
:
8779 case QEMU_OPTION_net
:
8780 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
8781 fprintf(stderr
, "qemu: too many network clients\n");
8784 net_clients
[nb_net_clients
] = optarg
;
8788 case QEMU_OPTION_tftp
:
8789 tftp_prefix
= optarg
;
8791 case QEMU_OPTION_bootp
:
8792 bootp_filename
= optarg
;
8795 case QEMU_OPTION_smb
:
8796 net_slirp_smb(optarg
);
8799 case QEMU_OPTION_redir
:
8800 net_slirp_redir(optarg
);
8804 case QEMU_OPTION_audio_help
:
8808 case QEMU_OPTION_soundhw
:
8809 select_soundhw (optarg
);
8815 case QEMU_OPTION_m
: {
8819 value
= strtoul(optarg
, &ptr
, 10);
8821 case 0: case 'M': case 'm':
8828 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
8832 /* On 32-bit hosts, QEMU is limited by virtual address space */
8833 if (value
> (2047 << 20)
8835 && HOST_LONG_BITS
== 32
8838 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
8841 if (value
!= (uint64_t)(ram_addr_t
)value
) {
8842 fprintf(stderr
, "qemu: ram size too large\n");
8851 const CPULogItem
*item
;
8853 mask
= cpu_str_to_log_mask(optarg
);
8855 printf("Log items (comma separated):\n");
8856 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
8857 printf("%-10s %s\n", item
->name
, item
->help
);
8864 #ifdef CONFIG_GDBSTUB
8869 gdbstub_port
= optarg
;
8875 case QEMU_OPTION_bios
:
8882 keyboard_layout
= optarg
;
8884 case QEMU_OPTION_localtime
:
8887 case QEMU_OPTION_vga
:
8888 select_vgahw (optarg
);
8895 w
= strtol(p
, (char **)&p
, 10);
8898 fprintf(stderr
, "qemu: invalid resolution or depth\n");
8904 h
= strtol(p
, (char **)&p
, 10);
8909 depth
= strtol(p
, (char **)&p
, 10);
8910 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
8911 depth
!= 24 && depth
!= 32)
8913 } else if (*p
== '\0') {
8914 depth
= graphic_depth
;
8921 graphic_depth
= depth
;
8924 case QEMU_OPTION_echr
:
8927 term_escape_char
= strtol(optarg
, &r
, 0);
8929 printf("Bad argument to echr\n");
8932 case QEMU_OPTION_monitor
:
8933 monitor_device
= optarg
;
8935 case QEMU_OPTION_serial
:
8936 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
8937 fprintf(stderr
, "qemu: too many serial ports\n");
8940 serial_devices
[serial_device_index
] = optarg
;
8941 serial_device_index
++;
8943 case QEMU_OPTION_parallel
:
8944 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
8945 fprintf(stderr
, "qemu: too many parallel ports\n");
8948 parallel_devices
[parallel_device_index
] = optarg
;
8949 parallel_device_index
++;
8951 case QEMU_OPTION_loadvm
:
8954 case QEMU_OPTION_full_screen
:
8958 case QEMU_OPTION_no_frame
:
8961 case QEMU_OPTION_alt_grab
:
8964 case QEMU_OPTION_no_quit
:
8968 case QEMU_OPTION_pidfile
:
8972 case QEMU_OPTION_win2k_hack
:
8973 win2k_install_hack
= 1;
8977 case QEMU_OPTION_no_kqemu
:
8980 case QEMU_OPTION_kernel_kqemu
:
8984 case QEMU_OPTION_usb
:
8987 case QEMU_OPTION_usbdevice
:
8989 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
8990 fprintf(stderr
, "Too many USB devices\n");
8993 usb_devices
[usb_devices_index
] = optarg
;
8994 usb_devices_index
++;
8996 case QEMU_OPTION_smp
:
8997 smp_cpus
= atoi(optarg
);
8998 if (smp_cpus
< 1 || smp_cpus
> MAX_CPUS
) {
8999 fprintf(stderr
, "Invalid number of CPUs\n");
9003 case QEMU_OPTION_vnc
:
9004 vnc_display
= optarg
;
9006 case QEMU_OPTION_no_acpi
:
9009 case QEMU_OPTION_no_reboot
:
9012 case QEMU_OPTION_no_shutdown
:
9015 case QEMU_OPTION_show_cursor
:
9018 case QEMU_OPTION_uuid
:
9019 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
9020 fprintf(stderr
, "Fail to parse UUID string."
9021 " Wrong format.\n");
9025 case QEMU_OPTION_daemonize
:
9028 case QEMU_OPTION_option_rom
:
9029 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9030 fprintf(stderr
, "Too many option ROMs\n");
9033 option_rom
[nb_option_roms
] = optarg
;
9036 case QEMU_OPTION_semihosting
:
9037 semihosting_enabled
= 1;
9039 case QEMU_OPTION_name
:
9043 case QEMU_OPTION_prom_env
:
9044 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
9045 fprintf(stderr
, "Too many prom variables\n");
9048 prom_envs
[nb_prom_envs
] = optarg
;
9053 case QEMU_OPTION_old_param
:
9057 case QEMU_OPTION_clock
:
9058 configure_alarms(optarg
);
9060 case QEMU_OPTION_startdate
:
9063 time_t rtc_start_date
;
9064 if (!strcmp(optarg
, "now")) {
9065 rtc_date_offset
= -1;
9067 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
9075 } else if (sscanf(optarg
, "%d-%d-%d",
9078 &tm
.tm_mday
) == 3) {
9087 rtc_start_date
= mktimegm(&tm
);
9088 if (rtc_start_date
== -1) {
9090 fprintf(stderr
, "Invalid date format. Valid format are:\n"
9091 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9094 rtc_date_offset
= time(NULL
) - rtc_start_date
;
9098 case QEMU_OPTION_tb_size
:
9099 tb_size
= strtol(optarg
, NULL
, 0);
9103 case QEMU_OPTION_icount
:
9105 if (strcmp(optarg
, "auto") == 0) {
9106 icount_time_shift
= -1;
9108 icount_time_shift
= strtol(optarg
, NULL
, 0);
9116 if (serial_device_index
== 0)
9117 serial_devices
[0] = "stdio";
9118 if (parallel_device_index
== 0)
9119 parallel_devices
[0] = "null";
9120 if (strncmp(monitor_device
, "vc", 2) == 0)
9121 monitor_device
= "stdio";
9128 if (pipe(fds
) == -1)
9139 len
= read(fds
[0], &status
, 1);
9140 if (len
== -1 && (errno
== EINTR
))
9145 else if (status
== 1) {
9146 fprintf(stderr
, "Could not acquire pidfile\n");
9163 signal(SIGTSTP
, SIG_IGN
);
9164 signal(SIGTTOU
, SIG_IGN
);
9165 signal(SIGTTIN
, SIG_IGN
);
9169 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
9172 write(fds
[1], &status
, 1);
9174 fprintf(stderr
, "Could not acquire pid file\n");
9182 linux_boot
= (kernel_filename
!= NULL
);
9183 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
9185 if (!linux_boot
&& net_boot
== 0 &&
9186 !machine
->nodisk_ok
&& nb_drives_opt
== 0)
9189 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
9190 fprintf(stderr
, "-append only allowed with -kernel option\n");
9194 if (!linux_boot
&& initrd_filename
!= NULL
) {
9195 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
9199 /* boot to floppy or the default cd if no hard disk defined yet */
9200 if (!boot_devices
[0]) {
9201 boot_devices
= "cad";
9203 setvbuf(stdout
, NULL
, _IOLBF
, 0);
9207 if (use_icount
&& icount_time_shift
< 0) {
9209 /* 125MIPS seems a reasonable initial guess at the guest speed.
9210 It will be corrected fairly quickly anyway. */
9211 icount_time_shift
= 3;
9212 init_icount_adjust();
9219 /* init network clients */
9220 if (nb_net_clients
== 0) {
9221 /* if no clients, we use a default config */
9222 net_clients
[nb_net_clients
++] = "nic";
9224 net_clients
[nb_net_clients
++] = "user";
9228 for(i
= 0;i
< nb_net_clients
; i
++) {
9229 if (net_client_parse(net_clients
[i
]) < 0)
9232 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
9233 if (vlan
->nb_guest_devs
== 0 && vlan
->nb_host_devs
== 0)
9235 if (vlan
->nb_guest_devs
== 0)
9236 fprintf(stderr
, "Warning: vlan %d with no nics\n", vlan
->id
);
9237 if (vlan
->nb_host_devs
== 0)
9239 "Warning: vlan %d is not connected to host network\n",
9244 /* XXX: this should be moved in the PC machine instantiation code */
9245 if (net_boot
!= 0) {
9247 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
9248 const char *model
= nd_table
[i
].model
;
9250 if (net_boot
& (1 << i
)) {
9253 snprintf(buf
, sizeof(buf
), "%s/pxe-%s.bin", bios_dir
, model
);
9254 if (get_image_size(buf
) > 0) {
9255 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9256 fprintf(stderr
, "Too many option ROMs\n");
9259 option_rom
[nb_option_roms
] = strdup(buf
);
9266 fprintf(stderr
, "No valid PXE rom found for network device\n");
9272 /* init the memory */
9273 phys_ram_size
= machine
->ram_require
& ~RAMSIZE_FIXED
;
9275 if (machine
->ram_require
& RAMSIZE_FIXED
) {
9277 if (ram_size
< phys_ram_size
) {
9278 fprintf(stderr
, "Machine `%s' requires %llu bytes of memory\n",
9279 machine
->name
, (unsigned long long) phys_ram_size
);
9283 phys_ram_size
= ram_size
;
9285 ram_size
= phys_ram_size
;
9288 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
9290 phys_ram_size
+= ram_size
;
9293 phys_ram_base
= qemu_vmalloc(phys_ram_size
);
9294 if (!phys_ram_base
) {
9295 fprintf(stderr
, "Could not allocate physical memory\n");
9299 /* init the dynamic translator */
9300 cpu_exec_init_all(tb_size
* 1024 * 1024);
9304 /* we always create the cdrom drive, even if no disk is there */
9306 if (nb_drives_opt
< MAX_DRIVES
)
9307 drive_add(NULL
, CDROM_ALIAS
);
9309 /* we always create at least one floppy */
9311 if (nb_drives_opt
< MAX_DRIVES
)
9312 drive_add(NULL
, FD_ALIAS
, 0);
9314 /* we always create one sd slot, even if no card is in it */
9316 if (nb_drives_opt
< MAX_DRIVES
)
9317 drive_add(NULL
, SD_ALIAS
);
9319 /* open the virtual block devices */
9321 for(i
= 0; i
< nb_drives_opt
; i
++)
9322 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
9325 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
9326 register_savevm("ram", 0, 2, ram_save
, ram_load
, NULL
);
9329 memset(&display_state
, 0, sizeof(display_state
));
9332 fprintf(stderr
, "fatal: -nographic can't be used with -curses\n");
9335 /* nearly nothing to do */
9336 dumb_display_init(ds
);
9337 } else if (vnc_display
!= NULL
) {
9338 vnc_display_init(ds
);
9339 if (vnc_display_open(ds
, vnc_display
) < 0)
9342 #if defined(CONFIG_CURSES)
9344 curses_display_init(ds
, full_screen
);
9348 #if defined(CONFIG_SDL)
9349 sdl_display_init(ds
, full_screen
, no_frame
);
9350 #elif defined(CONFIG_COCOA)
9351 cocoa_display_init(ds
, full_screen
);
9353 dumb_display_init(ds
);
9358 /* must be after terminal init, SDL library changes signal handlers */
9362 /* Maintain compatibility with multiple stdio monitors */
9363 if (!strcmp(monitor_device
,"stdio")) {
9364 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
9365 const char *devname
= serial_devices
[i
];
9366 if (devname
&& !strcmp(devname
,"mon:stdio")) {
9367 monitor_device
= NULL
;
9369 } else if (devname
&& !strcmp(devname
,"stdio")) {
9370 monitor_device
= NULL
;
9371 serial_devices
[i
] = "mon:stdio";
9376 if (monitor_device
) {
9377 monitor_hd
= qemu_chr_open(monitor_device
);
9379 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
9382 monitor_init(monitor_hd
, !nographic
);
9385 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
9386 const char *devname
= serial_devices
[i
];
9387 if (devname
&& strcmp(devname
, "none")) {
9388 serial_hds
[i
] = qemu_chr_open(devname
);
9389 if (!serial_hds
[i
]) {
9390 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
9394 if (strstart(devname
, "vc", 0))
9395 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
9399 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
9400 const char *devname
= parallel_devices
[i
];
9401 if (devname
&& strcmp(devname
, "none")) {
9402 parallel_hds
[i
] = qemu_chr_open(devname
);
9403 if (!parallel_hds
[i
]) {
9404 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
9408 if (strstart(devname
, "vc", 0))
9409 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
9413 machine
->init(ram_size
, vga_ram_size
, boot_devices
, ds
,
9414 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
9416 /* init USB devices */
9418 for(i
= 0; i
< usb_devices_index
; i
++) {
9419 if (usb_device_add(usb_devices
[i
]) < 0) {
9420 fprintf(stderr
, "Warning: could not add USB device %s\n",
9426 if (display_state
.dpy_refresh
) {
9427 display_state
.gui_timer
= qemu_new_timer(rt_clock
, gui_update
, &display_state
);
9428 qemu_mod_timer(display_state
.gui_timer
, qemu_get_clock(rt_clock
));
9431 #ifdef CONFIG_GDBSTUB
9433 /* XXX: use standard host:port notation and modify options
9435 if (gdbserver_start(gdbstub_port
) < 0) {
9436 fprintf(stderr
, "qemu: could not open gdbstub device on port '%s'\n",
9447 /* XXX: simplify init */
9460 len
= write(fds
[1], &status
, 1);
9461 if (len
== -1 && (errno
== EINTR
))
9468 TFR(fd
= open("/dev/null", O_RDWR
));
9482 #if !defined(_WIN32)
9483 /* close network clients */
9484 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
9485 VLANClientState
*vc
;
9487 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
9488 if (vc
->fd_read
== tap_receive
) {
9490 TAPState
*s
= vc
->opaque
;
9492 if (sscanf(vc
->info_str
, "tap: ifname=%63s ", ifname
) == 1 &&
9494 launch_script(s
->down_script
, ifname
, s
->fd
);
9496 #if defined(CONFIG_VDE)
9497 if (vc
->fd_read
== vde_from_qemu
) {
9498 VDEState
*s
= vc
->opaque
;