4 * Copyright (c) 2003-2008 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "hw/boards.h"
27 #include "hw/pcmcia.h"
29 #include "hw/audiodev.h"
37 #include "qemu-timer.h"
38 #include "qemu-char.h"
40 #include "audio/audio.h"
41 #include "migration.h"
54 #include <sys/times.h>
58 #include <sys/ioctl.h>
59 #include <sys/socket.h>
60 #include <netinet/in.h>
63 #include <sys/select.h>
64 #include <arpa/inet.h>
67 #if !defined(__APPLE__) && !defined(__OpenBSD__)
73 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
74 #include <freebsd/stdlib.h>
78 #include <linux/if_tun.h>
81 #include <linux/rtc.h>
83 /* For the benefit of older linux systems which don't supply it,
84 we use a local copy of hpet.h. */
85 /* #include <linux/hpet.h> */
88 #include <linux/ppdev.h>
89 #include <linux/parport.h>
93 #include <sys/ethernet.h>
94 #include <sys/sockio.h>
95 #include <netinet/arp.h>
96 #include <netinet/in.h>
97 #include <netinet/in_systm.h>
98 #include <netinet/ip.h>
99 #include <netinet/ip_icmp.h> // must come after ip.h
100 #include <netinet/udp.h>
101 #include <netinet/tcp.h>
109 #include "qemu_socket.h"
111 #if defined(CONFIG_SLIRP)
112 #include "libslirp.h"
115 #if defined(__OpenBSD__)
119 #if defined(CONFIG_VDE)
120 #include <libvdeplug.h>
125 #include <sys/timeb.h>
126 #include <mmsystem.h>
127 #define getopt_long_only getopt_long
128 #define memalign(align, size) malloc(size)
135 #endif /* CONFIG_SDL */
139 #define main qemu_main
140 #endif /* CONFIG_COCOA */
144 #include "exec-all.h"
146 #include "qemu-kvm.h"
148 #define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
149 #define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
151 #define SMBD_COMMAND "/usr/sfw/sbin/smbd"
153 #define SMBD_COMMAND "/usr/sbin/smbd"
156 //#define DEBUG_UNUSED_IOPORT
157 //#define DEBUG_IOPORT
159 //#define DEBUG_SLIRP
162 #define DEFAULT_RAM_SIZE 144
164 #define DEFAULT_RAM_SIZE 128
167 /* Max number of USB devices that can be specified on the commandline. */
168 #define MAX_USB_CMDLINE 8
170 /* XXX: use a two level table to limit memory usage */
171 #define MAX_IOPORTS 65536
173 const char *bios_dir
= CONFIG_QEMU_SHAREDIR
;
174 const char *bios_name
= NULL
;
175 static void *ioport_opaque
[MAX_IOPORTS
];
176 static IOPortReadFunc
*ioport_read_table
[3][MAX_IOPORTS
];
177 static IOPortWriteFunc
*ioport_write_table
[3][MAX_IOPORTS
];
178 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
179 to store the VM snapshots */
180 DriveInfo drives_table
[MAX_DRIVES
+1];
182 int extboot_drive
= -1;
183 /* point to the block driver where the snapshots are managed */
184 static BlockDriverState
*bs_snapshots
;
185 static int vga_ram_size
;
186 enum vga_retrace_method vga_retrace_method
= VGA_RETRACE_DUMB
;
187 static DisplayState display_state
;
190 const char* keyboard_layout
= NULL
;
191 int64_t ticks_per_sec
;
194 NICInfo nd_table
[MAX_NICS
];
196 static int rtc_utc
= 1;
197 static int rtc_date_offset
= -1; /* -1 means no change */
198 int cirrus_vga_enabled
= 1;
199 int vmsvga_enabled
= 0;
201 int graphic_width
= 1024;
202 int graphic_height
= 768;
203 int graphic_depth
= 8;
205 int graphic_width
= 800;
206 int graphic_height
= 600;
207 int graphic_depth
= 15;
209 static int full_screen
= 0;
210 static int no_frame
= 0;
212 CharDriverState
*serial_hds
[MAX_SERIAL_PORTS
];
213 CharDriverState
*parallel_hds
[MAX_PARALLEL_PORTS
];
215 int win2k_install_hack
= 0;
218 static VLANState
*first_vlan
;
220 const char *vnc_display
;
221 int acpi_enabled
= 1;
226 int graphic_rotate
= 0;
228 const char *incoming
;
229 const char *option_rom
[MAX_OPTION_ROMS
];
231 int semihosting_enabled
= 0;
232 int time_drift_fix
= 0;
233 unsigned int kvm_shadow_memory
= 0;
234 const char *mem_path
= NULL
;
236 const char *cpu_vendor_string
;
240 const char *qemu_name
;
243 unsigned int nb_prom_envs
= 0;
244 const char *prom_envs
[MAX_PROM_ENVS
];
247 struct drive_opt 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 /* KVM runs the main loop in a separate thread. If we update one of the lists
266 * that are polled before or after select(), we need to make sure to break out
267 * of the select() to ensure the new item is serviced.
269 static void main_loop_break(void)
272 qemu_kvm_notify_work();
275 /***********************************************************/
276 /* x86 ISA bus support */
278 target_phys_addr_t isa_mem_base
= 0;
281 static IOPortReadFunc default_ioport_readb
, default_ioport_readw
, default_ioport_readl
;
282 static IOPortWriteFunc default_ioport_writeb
, default_ioport_writew
, default_ioport_writel
;
284 static uint32_t ioport_read(int index
, uint32_t address
)
286 static IOPortReadFunc
*default_func
[3] = {
287 default_ioport_readb
,
288 default_ioport_readw
,
291 IOPortReadFunc
*func
= ioport_read_table
[index
][address
];
293 func
= default_func
[index
];
294 return func(ioport_opaque
[address
], address
);
297 static void ioport_write(int index
, uint32_t address
, uint32_t data
)
299 static IOPortWriteFunc
*default_func
[3] = {
300 default_ioport_writeb
,
301 default_ioport_writew
,
302 default_ioport_writel
304 IOPortWriteFunc
*func
= ioport_write_table
[index
][address
];
306 func
= default_func
[index
];
307 func(ioport_opaque
[address
], address
, data
);
310 static uint32_t default_ioport_readb(void *opaque
, uint32_t address
)
312 #ifdef DEBUG_UNUSED_IOPORT
313 fprintf(stderr
, "unused inb: port=0x%04x\n", address
);
318 static void default_ioport_writeb(void *opaque
, uint32_t address
, uint32_t data
)
320 #ifdef DEBUG_UNUSED_IOPORT
321 fprintf(stderr
, "unused outb: port=0x%04x data=0x%02x\n", address
, data
);
325 /* default is to make two byte accesses */
326 static uint32_t default_ioport_readw(void *opaque
, uint32_t address
)
329 data
= ioport_read(0, address
);
330 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
331 data
|= ioport_read(0, address
) << 8;
335 static void default_ioport_writew(void *opaque
, uint32_t address
, uint32_t data
)
337 ioport_write(0, address
, data
& 0xff);
338 address
= (address
+ 1) & (MAX_IOPORTS
- 1);
339 ioport_write(0, address
, (data
>> 8) & 0xff);
342 static uint32_t default_ioport_readl(void *opaque
, uint32_t address
)
344 #ifdef DEBUG_UNUSED_IOPORT
345 fprintf(stderr
, "unused inl: port=0x%04x\n", address
);
350 static void default_ioport_writel(void *opaque
, uint32_t address
, uint32_t data
)
352 #ifdef DEBUG_UNUSED_IOPORT
353 fprintf(stderr
, "unused outl: port=0x%04x data=0x%02x\n", address
, data
);
357 /* size is the word size in byte */
358 int register_ioport_read(int start
, int length
, int size
,
359 IOPortReadFunc
*func
, void *opaque
)
365 } else if (size
== 2) {
367 } else if (size
== 4) {
370 hw_error("register_ioport_read: invalid size");
373 for(i
= start
; i
< start
+ length
; i
+= size
) {
374 ioport_read_table
[bsize
][i
] = func
;
375 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
376 hw_error("register_ioport_read: invalid opaque");
377 ioport_opaque
[i
] = opaque
;
382 /* size is the word size in byte */
383 int register_ioport_write(int start
, int length
, int size
,
384 IOPortWriteFunc
*func
, void *opaque
)
390 } else if (size
== 2) {
392 } else if (size
== 4) {
395 hw_error("register_ioport_write: invalid size");
398 for(i
= start
; i
< start
+ length
; i
+= size
) {
399 ioport_write_table
[bsize
][i
] = func
;
400 if (ioport_opaque
[i
] != NULL
&& ioport_opaque
[i
] != opaque
)
401 hw_error("register_ioport_write: invalid opaque");
402 ioport_opaque
[i
] = opaque
;
407 void isa_unassign_ioport(int start
, int length
)
411 for(i
= start
; i
< start
+ length
; i
++) {
412 ioport_read_table
[0][i
] = default_ioport_readb
;
413 ioport_read_table
[1][i
] = default_ioport_readw
;
414 ioport_read_table
[2][i
] = default_ioport_readl
;
416 ioport_write_table
[0][i
] = default_ioport_writeb
;
417 ioport_write_table
[1][i
] = default_ioport_writew
;
418 ioport_write_table
[2][i
] = default_ioport_writel
;
420 ioport_opaque
[i
] = NULL
;
424 /***********************************************************/
426 void cpu_outb(CPUState
*env
, int addr
, int val
)
429 if (loglevel
& CPU_LOG_IOPORT
)
430 fprintf(logfile
, "outb: %04x %02x\n", addr
, val
);
432 ioport_write(0, addr
, val
);
435 env
->last_io_time
= cpu_get_time_fast();
439 void cpu_outw(CPUState
*env
, int addr
, int val
)
442 if (loglevel
& CPU_LOG_IOPORT
)
443 fprintf(logfile
, "outw: %04x %04x\n", addr
, val
);
445 ioport_write(1, addr
, val
);
448 env
->last_io_time
= cpu_get_time_fast();
452 void cpu_outl(CPUState
*env
, int addr
, int val
)
455 if (loglevel
& CPU_LOG_IOPORT
)
456 fprintf(logfile
, "outl: %04x %08x\n", addr
, val
);
458 ioport_write(2, addr
, val
);
461 env
->last_io_time
= cpu_get_time_fast();
465 int cpu_inb(CPUState
*env
, int addr
)
468 val
= ioport_read(0, addr
);
470 if (loglevel
& CPU_LOG_IOPORT
)
471 fprintf(logfile
, "inb : %04x %02x\n", addr
, val
);
475 env
->last_io_time
= cpu_get_time_fast();
480 int cpu_inw(CPUState
*env
, int addr
)
483 val
= ioport_read(1, addr
);
485 if (loglevel
& CPU_LOG_IOPORT
)
486 fprintf(logfile
, "inw : %04x %04x\n", addr
, val
);
490 env
->last_io_time
= cpu_get_time_fast();
495 int cpu_inl(CPUState
*env
, int addr
)
498 val
= ioport_read(2, addr
);
500 if (loglevel
& CPU_LOG_IOPORT
)
501 fprintf(logfile
, "inl : %04x %08x\n", addr
, val
);
505 env
->last_io_time
= cpu_get_time_fast();
510 /***********************************************************/
511 void hw_error(const char *fmt
, ...)
517 fprintf(stderr
, "qemu: hardware error: ");
518 vfprintf(stderr
, fmt
, ap
);
519 fprintf(stderr
, "\n");
520 for(env
= first_cpu
; env
!= NULL
; env
= env
->next_cpu
) {
521 fprintf(stderr
, "CPU #%d:\n", env
->cpu_index
);
523 cpu_dump_state(env
, stderr
, fprintf
, X86_DUMP_FPU
);
525 cpu_dump_state(env
, stderr
, fprintf
, 0);
535 static QEMUBalloonEvent
*qemu_balloon_event
;
536 void *qemu_balloon_event_opaque
;
538 void qemu_add_balloon_handler(QEMUBalloonEvent
*func
, void *opaque
)
540 qemu_balloon_event
= func
;
541 qemu_balloon_event_opaque
= opaque
;
544 void qemu_balloon(ram_addr_t target
)
546 if (qemu_balloon_event
)
547 qemu_balloon_event(qemu_balloon_event_opaque
, target
);
550 ram_addr_t
qemu_balloon_status(void)
552 if (qemu_balloon_event
)
553 return qemu_balloon_event(qemu_balloon_event_opaque
, 0);
557 /***********************************************************/
560 static QEMUPutKBDEvent
*qemu_put_kbd_event
;
561 static void *qemu_put_kbd_event_opaque
;
562 static QEMUPutMouseEntry
*qemu_put_mouse_event_head
;
563 static QEMUPutMouseEntry
*qemu_put_mouse_event_current
;
565 void qemu_add_kbd_event_handler(QEMUPutKBDEvent
*func
, void *opaque
)
567 qemu_put_kbd_event_opaque
= opaque
;
568 qemu_put_kbd_event
= func
;
571 QEMUPutMouseEntry
*qemu_add_mouse_event_handler(QEMUPutMouseEvent
*func
,
572 void *opaque
, int absolute
,
575 QEMUPutMouseEntry
*s
, *cursor
;
577 s
= qemu_mallocz(sizeof(QEMUPutMouseEntry
));
581 s
->qemu_put_mouse_event
= func
;
582 s
->qemu_put_mouse_event_opaque
= opaque
;
583 s
->qemu_put_mouse_event_absolute
= absolute
;
584 s
->qemu_put_mouse_event_name
= qemu_strdup(name
);
587 if (!qemu_put_mouse_event_head
) {
588 qemu_put_mouse_event_head
= qemu_put_mouse_event_current
= s
;
592 cursor
= qemu_put_mouse_event_head
;
593 while (cursor
->next
!= NULL
)
594 cursor
= cursor
->next
;
597 qemu_put_mouse_event_current
= s
;
602 void qemu_remove_mouse_event_handler(QEMUPutMouseEntry
*entry
)
604 QEMUPutMouseEntry
*prev
= NULL
, *cursor
;
606 if (!qemu_put_mouse_event_head
|| entry
== NULL
)
609 cursor
= qemu_put_mouse_event_head
;
610 while (cursor
!= NULL
&& cursor
!= entry
) {
612 cursor
= cursor
->next
;
615 if (cursor
== NULL
) // does not exist or list empty
617 else if (prev
== NULL
) { // entry is head
618 qemu_put_mouse_event_head
= cursor
->next
;
619 if (qemu_put_mouse_event_current
== entry
)
620 qemu_put_mouse_event_current
= cursor
->next
;
621 qemu_free(entry
->qemu_put_mouse_event_name
);
626 prev
->next
= entry
->next
;
628 if (qemu_put_mouse_event_current
== entry
)
629 qemu_put_mouse_event_current
= prev
;
631 qemu_free(entry
->qemu_put_mouse_event_name
);
635 void kbd_put_keycode(int keycode
)
637 if (qemu_put_kbd_event
) {
638 qemu_put_kbd_event(qemu_put_kbd_event_opaque
, keycode
);
642 void kbd_mouse_event(int dx
, int dy
, int dz
, int buttons_state
)
644 QEMUPutMouseEvent
*mouse_event
;
645 void *mouse_event_opaque
;
648 if (!qemu_put_mouse_event_current
) {
653 qemu_put_mouse_event_current
->qemu_put_mouse_event
;
655 qemu_put_mouse_event_current
->qemu_put_mouse_event_opaque
;
658 if (graphic_rotate
) {
659 if (qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
)
662 width
= graphic_width
- 1;
663 mouse_event(mouse_event_opaque
,
664 width
- dy
, dx
, dz
, buttons_state
);
666 mouse_event(mouse_event_opaque
,
667 dx
, dy
, dz
, buttons_state
);
671 int kbd_mouse_is_absolute(void)
673 if (!qemu_put_mouse_event_current
)
676 return qemu_put_mouse_event_current
->qemu_put_mouse_event_absolute
;
679 void do_info_mice(void)
681 QEMUPutMouseEntry
*cursor
;
684 if (!qemu_put_mouse_event_head
) {
685 term_printf("No mouse devices connected\n");
689 term_printf("Mouse devices available:\n");
690 cursor
= qemu_put_mouse_event_head
;
691 while (cursor
!= NULL
) {
692 term_printf("%c Mouse #%d: %s\n",
693 (cursor
== qemu_put_mouse_event_current
? '*' : ' '),
694 index
, cursor
->qemu_put_mouse_event_name
);
696 cursor
= cursor
->next
;
700 void do_mouse_set(int index
)
702 QEMUPutMouseEntry
*cursor
;
705 if (!qemu_put_mouse_event_head
) {
706 term_printf("No mouse devices connected\n");
710 cursor
= qemu_put_mouse_event_head
;
711 while (cursor
!= NULL
&& index
!= i
) {
713 cursor
= cursor
->next
;
717 qemu_put_mouse_event_current
= cursor
;
719 term_printf("Mouse at given index not found\n");
722 /* compute with 96 bit intermediate result: (a*b)/c */
723 uint64_t muldiv64(uint64_t a
, uint32_t b
, uint32_t c
)
728 #ifdef WORDS_BIGENDIAN
738 rl
= (uint64_t)u
.l
.low
* (uint64_t)b
;
739 rh
= (uint64_t)u
.l
.high
* (uint64_t)b
;
742 res
.l
.low
= (((rh
% c
) << 32) + (rl
& 0xffffffff)) / c
;
746 /***********************************************************/
747 /* real time host monotonic timer */
749 #define QEMU_TIMER_BASE 1000000000LL
753 static int64_t clock_freq
;
755 static void init_get_clock(void)
759 ret
= QueryPerformanceFrequency(&freq
);
761 fprintf(stderr
, "Could not calibrate ticks\n");
764 clock_freq
= freq
.QuadPart
;
767 static int64_t get_clock(void)
770 QueryPerformanceCounter(&ti
);
771 return muldiv64(ti
.QuadPart
, QEMU_TIMER_BASE
, clock_freq
);
776 static int use_rt_clock
;
778 static void init_get_clock(void)
781 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
784 if (clock_gettime(CLOCK_MONOTONIC
, &ts
) == 0) {
791 static int64_t get_clock(void)
793 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
796 clock_gettime(CLOCK_MONOTONIC
, &ts
);
797 return ts
.tv_sec
* 1000000000LL + ts
.tv_nsec
;
801 /* XXX: using gettimeofday leads to problems if the date
802 changes, so it should be avoided. */
804 gettimeofday(&tv
, NULL
);
805 return tv
.tv_sec
* 1000000000LL + (tv
.tv_usec
* 1000);
810 /* Return the virtual CPU time, based on the instruction counter. */
811 static int64_t cpu_get_icount(void)
814 CPUState
*env
= cpu_single_env
;;
815 icount
= qemu_icount
;
818 fprintf(stderr
, "Bad clock read\n");
819 icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
821 return qemu_icount_bias
+ (icount
<< icount_time_shift
);
824 /***********************************************************/
825 /* guest cycle counter */
827 static int64_t cpu_ticks_prev
;
828 static int64_t cpu_ticks_offset
;
829 static int64_t cpu_clock_offset
;
830 static int cpu_ticks_enabled
;
832 /* return the host CPU cycle counter and handle stop/restart */
833 int64_t cpu_get_ticks(void)
836 return cpu_get_icount();
838 if (!cpu_ticks_enabled
) {
839 return cpu_ticks_offset
;
842 ticks
= cpu_get_real_ticks();
843 if (cpu_ticks_prev
> ticks
) {
844 /* Note: non increasing ticks may happen if the host uses
846 cpu_ticks_offset
+= cpu_ticks_prev
- ticks
;
848 cpu_ticks_prev
= ticks
;
849 return ticks
+ cpu_ticks_offset
;
853 /* return the host CPU monotonic timer and handle stop/restart */
854 static int64_t cpu_get_clock(void)
857 if (!cpu_ticks_enabled
) {
858 return cpu_clock_offset
;
861 return ti
+ cpu_clock_offset
;
865 /* enable cpu_get_ticks() */
866 void cpu_enable_ticks(void)
868 if (!cpu_ticks_enabled
) {
869 cpu_ticks_offset
-= cpu_get_real_ticks();
870 cpu_clock_offset
-= get_clock();
871 cpu_ticks_enabled
= 1;
875 /* disable cpu_get_ticks() : the clock is stopped. You must not call
876 cpu_get_ticks() after that. */
877 void cpu_disable_ticks(void)
879 if (cpu_ticks_enabled
) {
880 cpu_ticks_offset
= cpu_get_ticks();
881 cpu_clock_offset
= cpu_get_clock();
882 cpu_ticks_enabled
= 0;
886 /***********************************************************/
889 #define QEMU_TIMER_REALTIME 0
890 #define QEMU_TIMER_VIRTUAL 1
894 /* XXX: add frequency */
902 struct QEMUTimer
*next
;
905 struct qemu_alarm_timer
{
909 int (*start
)(struct qemu_alarm_timer
*t
);
910 void (*stop
)(struct qemu_alarm_timer
*t
);
911 void (*rearm
)(struct qemu_alarm_timer
*t
);
915 #define ALARM_FLAG_DYNTICKS 0x1
916 #define ALARM_FLAG_EXPIRED 0x2
918 static inline int alarm_has_dynticks(struct qemu_alarm_timer
*t
)
920 return t
->flags
& ALARM_FLAG_DYNTICKS
;
923 static void qemu_rearm_alarm_timer(struct qemu_alarm_timer
*t
)
925 if (!alarm_has_dynticks(t
))
931 /* TODO: MIN_TIMER_REARM_US should be optimized */
932 #define MIN_TIMER_REARM_US 250
934 static struct qemu_alarm_timer
*alarm_timer
;
938 struct qemu_alarm_win32
{
942 } alarm_win32_data
= {0, NULL
, -1};
944 static int win32_start_timer(struct qemu_alarm_timer
*t
);
945 static void win32_stop_timer(struct qemu_alarm_timer
*t
);
946 static void win32_rearm_timer(struct qemu_alarm_timer
*t
);
950 static int unix_start_timer(struct qemu_alarm_timer
*t
);
951 static void unix_stop_timer(struct qemu_alarm_timer
*t
);
955 static int dynticks_start_timer(struct qemu_alarm_timer
*t
);
956 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
);
957 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
);
959 static int hpet_start_timer(struct qemu_alarm_timer
*t
);
960 static void hpet_stop_timer(struct qemu_alarm_timer
*t
);
962 static int rtc_start_timer(struct qemu_alarm_timer
*t
);
963 static void rtc_stop_timer(struct qemu_alarm_timer
*t
);
965 #endif /* __linux__ */
969 /* Correlation between real and virtual time is always going to be
970 fairly approximate, so ignore small variation.
971 When the guest is idle real and virtual time will be aligned in
973 #define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
975 static void icount_adjust(void)
980 static int64_t last_delta
;
981 /* If the VM is not running, then do nothing. */
985 cur_time
= cpu_get_clock();
986 cur_icount
= qemu_get_clock(vm_clock
);
987 delta
= cur_icount
- cur_time
;
988 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
990 && last_delta
+ ICOUNT_WOBBLE
< delta
* 2
991 && icount_time_shift
> 0) {
992 /* The guest is getting too far ahead. Slow time down. */
996 && last_delta
- ICOUNT_WOBBLE
> delta
* 2
997 && icount_time_shift
< MAX_ICOUNT_SHIFT
) {
998 /* The guest is getting too far behind. Speed time up. */
1002 qemu_icount_bias
= cur_icount
- (qemu_icount
<< icount_time_shift
);
1005 static void icount_adjust_rt(void * opaque
)
1007 qemu_mod_timer(icount_rt_timer
,
1008 qemu_get_clock(rt_clock
) + 1000);
1012 static void icount_adjust_vm(void * opaque
)
1014 qemu_mod_timer(icount_vm_timer
,
1015 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
1019 static void init_icount_adjust(void)
1021 /* Have both realtime and virtual time triggers for speed adjustment.
1022 The realtime trigger catches emulated time passing too slowly,
1023 the virtual time trigger catches emulated time passing too fast.
1024 Realtime triggers occur even when idle, so use them less frequently
1025 than VM triggers. */
1026 icount_rt_timer
= qemu_new_timer(rt_clock
, icount_adjust_rt
, NULL
);
1027 qemu_mod_timer(icount_rt_timer
,
1028 qemu_get_clock(rt_clock
) + 1000);
1029 icount_vm_timer
= qemu_new_timer(vm_clock
, icount_adjust_vm
, NULL
);
1030 qemu_mod_timer(icount_vm_timer
,
1031 qemu_get_clock(vm_clock
) + QEMU_TIMER_BASE
/ 10);
1034 static struct qemu_alarm_timer alarm_timers
[] = {
1037 {"dynticks", ALARM_FLAG_DYNTICKS
, dynticks_start_timer
,
1038 dynticks_stop_timer
, dynticks_rearm_timer
, NULL
},
1039 /* HPET - if available - is preferred */
1040 {"hpet", 0, hpet_start_timer
, hpet_stop_timer
, NULL
, NULL
},
1041 /* ...otherwise try RTC */
1042 {"rtc", 0, rtc_start_timer
, rtc_stop_timer
, NULL
, NULL
},
1044 {"unix", 0, unix_start_timer
, unix_stop_timer
, NULL
, NULL
},
1046 {"dynticks", ALARM_FLAG_DYNTICKS
, win32_start_timer
,
1047 win32_stop_timer
, win32_rearm_timer
, &alarm_win32_data
},
1048 {"win32", 0, win32_start_timer
,
1049 win32_stop_timer
, NULL
, &alarm_win32_data
},
1054 static void show_available_alarms(void)
1058 printf("Available alarm timers, in order of precedence:\n");
1059 for (i
= 0; alarm_timers
[i
].name
; i
++)
1060 printf("%s\n", alarm_timers
[i
].name
);
1063 static void configure_alarms(char const *opt
)
1067 int count
= (sizeof(alarm_timers
) / sizeof(*alarm_timers
)) - 1;
1070 struct qemu_alarm_timer tmp
;
1072 if (!strcmp(opt
, "?")) {
1073 show_available_alarms();
1079 /* Reorder the array */
1080 name
= strtok(arg
, ",");
1082 for (i
= 0; i
< count
&& alarm_timers
[i
].name
; i
++) {
1083 if (!strcmp(alarm_timers
[i
].name
, name
))
1088 fprintf(stderr
, "Unknown clock %s\n", name
);
1097 tmp
= alarm_timers
[i
];
1098 alarm_timers
[i
] = alarm_timers
[cur
];
1099 alarm_timers
[cur
] = tmp
;
1103 name
= strtok(NULL
, ",");
1109 /* Disable remaining timers */
1110 for (i
= cur
; i
< count
; i
++)
1111 alarm_timers
[i
].name
= NULL
;
1113 show_available_alarms();
1118 QEMUClock
*rt_clock
;
1119 QEMUClock
*vm_clock
;
1121 static QEMUTimer
*active_timers
[2];
1123 static QEMUClock
*qemu_new_clock(int type
)
1126 clock
= qemu_mallocz(sizeof(QEMUClock
));
1133 QEMUTimer
*qemu_new_timer(QEMUClock
*clock
, QEMUTimerCB
*cb
, void *opaque
)
1137 ts
= qemu_mallocz(sizeof(QEMUTimer
));
1140 ts
->opaque
= opaque
;
1144 void qemu_free_timer(QEMUTimer
*ts
)
1149 /* stop a timer, but do not dealloc it */
1150 void qemu_del_timer(QEMUTimer
*ts
)
1154 /* NOTE: this code must be signal safe because
1155 qemu_timer_expired() can be called from a signal. */
1156 pt
= &active_timers
[ts
->clock
->type
];
1169 /* modify the current timer so that it will be fired when current_time
1170 >= expire_time. The corresponding callback will be called. */
1171 void qemu_mod_timer(QEMUTimer
*ts
, int64_t expire_time
)
1177 /* add the timer in the sorted list */
1178 /* NOTE: this code must be signal safe because
1179 qemu_timer_expired() can be called from a signal. */
1180 pt
= &active_timers
[ts
->clock
->type
];
1185 if (t
->expire_time
> expire_time
)
1189 ts
->expire_time
= expire_time
;
1193 /* Rearm if necessary */
1194 if (pt
== &active_timers
[ts
->clock
->type
]) {
1195 if ((alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) == 0) {
1196 qemu_rearm_alarm_timer(alarm_timer
);
1198 /* Interrupt execution to force deadline recalculation. */
1199 if (use_icount
&& cpu_single_env
) {
1200 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
1205 int qemu_timer_pending(QEMUTimer
*ts
)
1208 for(t
= active_timers
[ts
->clock
->type
]; t
!= NULL
; t
= t
->next
) {
1215 static inline int qemu_timer_expired(QEMUTimer
*timer_head
, int64_t current_time
)
1219 return (timer_head
->expire_time
<= current_time
);
1222 static void qemu_run_timers(QEMUTimer
**ptimer_head
, int64_t current_time
)
1228 if (!ts
|| ts
->expire_time
> current_time
)
1230 /* remove timer from the list before calling the callback */
1231 *ptimer_head
= ts
->next
;
1234 /* run the callback (the timer list can be modified) */
1239 int64_t qemu_get_clock(QEMUClock
*clock
)
1241 switch(clock
->type
) {
1242 case QEMU_TIMER_REALTIME
:
1243 return get_clock() / 1000000;
1245 case QEMU_TIMER_VIRTUAL
:
1247 return cpu_get_icount();
1249 return cpu_get_clock();
1254 static void init_timers(void)
1257 ticks_per_sec
= QEMU_TIMER_BASE
;
1258 rt_clock
= qemu_new_clock(QEMU_TIMER_REALTIME
);
1259 vm_clock
= qemu_new_clock(QEMU_TIMER_VIRTUAL
);
1263 void qemu_put_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1265 uint64_t expire_time
;
1267 if (qemu_timer_pending(ts
)) {
1268 expire_time
= ts
->expire_time
;
1272 qemu_put_be64(f
, expire_time
);
1275 void qemu_get_timer(QEMUFile
*f
, QEMUTimer
*ts
)
1277 uint64_t expire_time
;
1279 expire_time
= qemu_get_be64(f
);
1280 if (expire_time
!= -1) {
1281 qemu_mod_timer(ts
, expire_time
);
1287 static void timer_save(QEMUFile
*f
, void *opaque
)
1289 if (cpu_ticks_enabled
) {
1290 hw_error("cannot save state if virtual timers are running");
1292 qemu_put_be64(f
, cpu_ticks_offset
);
1293 qemu_put_be64(f
, ticks_per_sec
);
1294 qemu_put_be64(f
, cpu_clock_offset
);
1297 static int timer_load(QEMUFile
*f
, void *opaque
, int version_id
)
1299 if (version_id
!= 1 && version_id
!= 2)
1301 if (cpu_ticks_enabled
) {
1304 cpu_ticks_offset
=qemu_get_be64(f
);
1305 ticks_per_sec
=qemu_get_be64(f
);
1306 if (version_id
== 2) {
1307 cpu_clock_offset
=qemu_get_be64(f
);
1313 void CALLBACK
host_alarm_handler(UINT uTimerID
, UINT uMsg
,
1314 DWORD_PTR dwUser
, DWORD_PTR dw1
, DWORD_PTR dw2
)
1316 static void host_alarm_handler(int host_signum
)
1320 #define DISP_FREQ 1000
1322 static int64_t delta_min
= INT64_MAX
;
1323 static int64_t delta_max
, delta_cum
, last_clock
, delta
, ti
;
1325 ti
= qemu_get_clock(vm_clock
);
1326 if (last_clock
!= 0) {
1327 delta
= ti
- last_clock
;
1328 if (delta
< delta_min
)
1330 if (delta
> delta_max
)
1333 if (++count
== DISP_FREQ
) {
1334 printf("timer: min=%" PRId64
" us max=%" PRId64
" us avg=%" PRId64
" us avg_freq=%0.3f Hz\n",
1335 muldiv64(delta_min
, 1000000, ticks_per_sec
),
1336 muldiv64(delta_max
, 1000000, ticks_per_sec
),
1337 muldiv64(delta_cum
, 1000000 / DISP_FREQ
, ticks_per_sec
),
1338 (double)ticks_per_sec
/ ((double)delta_cum
/ DISP_FREQ
));
1340 delta_min
= INT64_MAX
;
1349 alarm_has_dynticks(alarm_timer
) ||
1351 qemu_timer_expired(active_timers
[QEMU_TIMER_VIRTUAL
],
1352 qemu_get_clock(vm_clock
))) ||
1353 qemu_timer_expired(active_timers
[QEMU_TIMER_REALTIME
],
1354 qemu_get_clock(rt_clock
))) {
1356 struct qemu_alarm_win32
*data
= ((struct qemu_alarm_timer
*)dwUser
)->priv
;
1357 SetEvent(data
->host_alarm
);
1359 CPUState
*env
= next_cpu
;
1361 alarm_timer
->flags
|= ALARM_FLAG_EXPIRED
;
1364 /* stop the currently executing cpu because a timer occured */
1365 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
1367 if (env
->kqemu_enabled
) {
1368 kqemu_cpu_interrupt(env
);
1376 static int64_t qemu_next_deadline(void)
1380 if (active_timers
[QEMU_TIMER_VIRTUAL
]) {
1381 delta
= active_timers
[QEMU_TIMER_VIRTUAL
]->expire_time
-
1382 qemu_get_clock(vm_clock
);
1384 /* To avoid problems with overflow limit this to 2^32. */
1394 #if defined(__linux__) || defined(_WIN32)
1395 static uint64_t qemu_next_deadline_dyntick(void)
1403 delta
= (qemu_next_deadline() + 999) / 1000;
1405 if (active_timers
[QEMU_TIMER_REALTIME
]) {
1406 rtdelta
= (active_timers
[QEMU_TIMER_REALTIME
]->expire_time
-
1407 qemu_get_clock(rt_clock
))*1000;
1408 if (rtdelta
< delta
)
1412 if (delta
< MIN_TIMER_REARM_US
)
1413 delta
= MIN_TIMER_REARM_US
;
1421 #if defined(__linux__)
1423 #define RTC_FREQ 1024
1425 static void enable_sigio_timer(int fd
)
1427 struct sigaction act
;
1430 sigfillset(&act
.sa_mask
);
1432 act
.sa_handler
= host_alarm_handler
;
1434 sigaction(SIGIO
, &act
, NULL
);
1435 fcntl(fd
, F_SETFL
, O_ASYNC
);
1436 fcntl(fd
, F_SETOWN
, getpid());
1439 static int hpet_start_timer(struct qemu_alarm_timer
*t
)
1441 struct hpet_info info
;
1444 fd
= open("/dev/hpet", O_RDONLY
);
1449 r
= ioctl(fd
, HPET_IRQFREQ
, RTC_FREQ
);
1451 fprintf(stderr
, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1452 "error, but for better emulation accuracy type:\n"
1453 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1457 /* Check capabilities */
1458 r
= ioctl(fd
, HPET_INFO
, &info
);
1462 /* Enable periodic mode */
1463 r
= ioctl(fd
, HPET_EPI
, 0);
1464 if (info
.hi_flags
&& (r
< 0))
1467 /* Enable interrupt */
1468 r
= ioctl(fd
, HPET_IE_ON
, 0);
1472 enable_sigio_timer(fd
);
1473 t
->priv
= (void *)(long)fd
;
1481 static void hpet_stop_timer(struct qemu_alarm_timer
*t
)
1483 int fd
= (long)t
->priv
;
1488 static int rtc_start_timer(struct qemu_alarm_timer
*t
)
1491 unsigned long current_rtc_freq
= 0;
1493 TFR(rtc_fd
= open("/dev/rtc", O_RDONLY
));
1496 ioctl(rtc_fd
, RTC_IRQP_READ
, ¤t_rtc_freq
);
1497 if (current_rtc_freq
!= RTC_FREQ
&&
1498 ioctl(rtc_fd
, RTC_IRQP_SET
, RTC_FREQ
) < 0) {
1499 fprintf(stderr
, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1500 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1501 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1504 if (ioctl(rtc_fd
, RTC_PIE_ON
, 0) < 0) {
1510 enable_sigio_timer(rtc_fd
);
1512 t
->priv
= (void *)(long)rtc_fd
;
1517 static void rtc_stop_timer(struct qemu_alarm_timer
*t
)
1519 int rtc_fd
= (long)t
->priv
;
1524 static int dynticks_start_timer(struct qemu_alarm_timer
*t
)
1528 struct sigaction act
;
1530 sigfillset(&act
.sa_mask
);
1532 act
.sa_handler
= host_alarm_handler
;
1534 sigaction(SIGALRM
, &act
, NULL
);
1536 ev
.sigev_value
.sival_int
= 0;
1537 ev
.sigev_notify
= SIGEV_SIGNAL
;
1538 ev
.sigev_signo
= SIGALRM
;
1540 if (timer_create(CLOCK_REALTIME
, &ev
, &host_timer
)) {
1541 perror("timer_create");
1543 /* disable dynticks */
1544 fprintf(stderr
, "Dynamic Ticks disabled\n");
1549 t
->priv
= (void *)host_timer
;
1554 static void dynticks_stop_timer(struct qemu_alarm_timer
*t
)
1556 timer_t host_timer
= (timer_t
)t
->priv
;
1558 timer_delete(host_timer
);
1561 static void dynticks_rearm_timer(struct qemu_alarm_timer
*t
)
1563 timer_t host_timer
= (timer_t
)t
->priv
;
1564 struct itimerspec timeout
;
1565 int64_t nearest_delta_us
= INT64_MAX
;
1568 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1569 !active_timers
[QEMU_TIMER_VIRTUAL
])
1572 nearest_delta_us
= qemu_next_deadline_dyntick();
1574 /* check whether a timer is already running */
1575 if (timer_gettime(host_timer
, &timeout
)) {
1577 fprintf(stderr
, "Internal timer error: aborting\n");
1580 current_us
= timeout
.it_value
.tv_sec
* 1000000 + timeout
.it_value
.tv_nsec
/1000;
1581 if (current_us
&& current_us
<= nearest_delta_us
)
1584 timeout
.it_interval
.tv_sec
= 0;
1585 timeout
.it_interval
.tv_nsec
= 0; /* 0 for one-shot timer */
1586 timeout
.it_value
.tv_sec
= nearest_delta_us
/ 1000000;
1587 timeout
.it_value
.tv_nsec
= (nearest_delta_us
% 1000000) * 1000;
1588 if (timer_settime(host_timer
, 0 /* RELATIVE */, &timeout
, NULL
)) {
1590 fprintf(stderr
, "Internal timer error: aborting\n");
1595 #endif /* defined(__linux__) */
1597 static int unix_start_timer(struct qemu_alarm_timer
*t
)
1599 struct sigaction act
;
1600 struct itimerval itv
;
1604 sigfillset(&act
.sa_mask
);
1606 act
.sa_handler
= host_alarm_handler
;
1608 sigaction(SIGALRM
, &act
, NULL
);
1610 itv
.it_interval
.tv_sec
= 0;
1611 /* for i386 kernel 2.6 to get 1 ms */
1612 itv
.it_interval
.tv_usec
= 999;
1613 itv
.it_value
.tv_sec
= 0;
1614 itv
.it_value
.tv_usec
= 10 * 1000;
1616 err
= setitimer(ITIMER_REAL
, &itv
, NULL
);
1623 static void unix_stop_timer(struct qemu_alarm_timer
*t
)
1625 struct itimerval itv
;
1627 memset(&itv
, 0, sizeof(itv
));
1628 setitimer(ITIMER_REAL
, &itv
, NULL
);
1631 #endif /* !defined(_WIN32) */
1635 static int win32_start_timer(struct qemu_alarm_timer
*t
)
1638 struct qemu_alarm_win32
*data
= t
->priv
;
1641 data
->host_alarm
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
1642 if (!data
->host_alarm
) {
1643 perror("Failed CreateEvent");
1647 memset(&tc
, 0, sizeof(tc
));
1648 timeGetDevCaps(&tc
, sizeof(tc
));
1650 if (data
->period
< tc
.wPeriodMin
)
1651 data
->period
= tc
.wPeriodMin
;
1653 timeBeginPeriod(data
->period
);
1655 flags
= TIME_CALLBACK_FUNCTION
;
1656 if (alarm_has_dynticks(t
))
1657 flags
|= TIME_ONESHOT
;
1659 flags
|= TIME_PERIODIC
;
1661 data
->timerId
= timeSetEvent(1, // interval (ms)
1662 data
->period
, // resolution
1663 host_alarm_handler
, // function
1664 (DWORD
)t
, // parameter
1667 if (!data
->timerId
) {
1668 perror("Failed to initialize win32 alarm timer");
1670 timeEndPeriod(data
->period
);
1671 CloseHandle(data
->host_alarm
);
1675 qemu_add_wait_object(data
->host_alarm
, NULL
, NULL
);
1680 static void win32_stop_timer(struct qemu_alarm_timer
*t
)
1682 struct qemu_alarm_win32
*data
= t
->priv
;
1684 timeKillEvent(data
->timerId
);
1685 timeEndPeriod(data
->period
);
1687 CloseHandle(data
->host_alarm
);
1690 static void win32_rearm_timer(struct qemu_alarm_timer
*t
)
1692 struct qemu_alarm_win32
*data
= t
->priv
;
1693 uint64_t nearest_delta_us
;
1695 if (!active_timers
[QEMU_TIMER_REALTIME
] &&
1696 !active_timers
[QEMU_TIMER_VIRTUAL
])
1699 nearest_delta_us
= qemu_next_deadline_dyntick();
1700 nearest_delta_us
/= 1000;
1702 timeKillEvent(data
->timerId
);
1704 data
->timerId
= timeSetEvent(1,
1708 TIME_ONESHOT
| TIME_PERIODIC
);
1710 if (!data
->timerId
) {
1711 perror("Failed to re-arm win32 alarm timer");
1713 timeEndPeriod(data
->period
);
1714 CloseHandle(data
->host_alarm
);
1721 static void init_timer_alarm(void)
1723 struct qemu_alarm_timer
*t
= NULL
;
1726 for (i
= 0; alarm_timers
[i
].name
; i
++) {
1727 t
= &alarm_timers
[i
];
1735 fprintf(stderr
, "Unable to find any suitable alarm timer.\n");
1736 fprintf(stderr
, "Terminating\n");
1743 static void quit_timers(void)
1745 alarm_timer
->stop(alarm_timer
);
1749 /***********************************************************/
1750 /* host time/date access */
1751 void qemu_get_timedate(struct tm
*tm
, int offset
)
1758 if (rtc_date_offset
== -1) {
1762 ret
= localtime(&ti
);
1764 ti
-= rtc_date_offset
;
1768 memcpy(tm
, ret
, sizeof(struct tm
));
1771 int qemu_timedate_diff(struct tm
*tm
)
1775 if (rtc_date_offset
== -1)
1777 seconds
= mktimegm(tm
);
1779 seconds
= mktime(tm
);
1781 seconds
= mktimegm(tm
) + rtc_date_offset
;
1783 return seconds
- time(NULL
);
1786 /***********************************************************/
1787 /* character device */
1789 static void qemu_chr_event(CharDriverState
*s
, int event
)
1793 s
->chr_event(s
->handler_opaque
, event
);
1796 static void qemu_chr_reset_bh(void *opaque
)
1798 CharDriverState
*s
= opaque
;
1799 qemu_chr_event(s
, CHR_EVENT_RESET
);
1800 qemu_bh_delete(s
->bh
);
1804 void qemu_chr_reset(CharDriverState
*s
)
1806 if (s
->bh
== NULL
) {
1807 s
->bh
= qemu_bh_new(qemu_chr_reset_bh
, s
);
1808 qemu_bh_schedule(s
->bh
);
1812 int qemu_chr_write(CharDriverState
*s
, const uint8_t *buf
, int len
)
1814 return s
->chr_write(s
, buf
, len
);
1817 int qemu_chr_ioctl(CharDriverState
*s
, int cmd
, void *arg
)
1821 return s
->chr_ioctl(s
, cmd
, arg
);
1824 int qemu_chr_can_read(CharDriverState
*s
)
1826 if (!s
->chr_can_read
)
1828 return s
->chr_can_read(s
->handler_opaque
);
1831 void qemu_chr_read(CharDriverState
*s
, uint8_t *buf
, int len
)
1833 s
->chr_read(s
->handler_opaque
, buf
, len
);
1836 void qemu_chr_accept_input(CharDriverState
*s
)
1838 if (s
->chr_accept_input
)
1839 s
->chr_accept_input(s
);
1842 void qemu_chr_printf(CharDriverState
*s
, const char *fmt
, ...)
1847 vsnprintf(buf
, sizeof(buf
), fmt
, ap
);
1848 qemu_chr_write(s
, (uint8_t *)buf
, strlen(buf
));
1852 void qemu_chr_send_event(CharDriverState
*s
, int event
)
1854 if (s
->chr_send_event
)
1855 s
->chr_send_event(s
, event
);
1858 void qemu_chr_add_handlers(CharDriverState
*s
,
1859 IOCanRWHandler
*fd_can_read
,
1860 IOReadHandler
*fd_read
,
1861 IOEventHandler
*fd_event
,
1864 s
->chr_can_read
= fd_can_read
;
1865 s
->chr_read
= fd_read
;
1866 s
->chr_event
= fd_event
;
1867 s
->handler_opaque
= opaque
;
1868 if (s
->chr_update_read_handler
)
1869 s
->chr_update_read_handler(s
);
1872 static int null_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1877 static CharDriverState
*qemu_chr_open_null(void)
1879 CharDriverState
*chr
;
1881 chr
= qemu_mallocz(sizeof(CharDriverState
));
1884 chr
->chr_write
= null_chr_write
;
1888 /* MUX driver for serial I/O splitting */
1889 static int term_timestamps
;
1890 static int64_t term_timestamps_start
;
1892 #define MUX_BUFFER_SIZE 32 /* Must be a power of 2. */
1893 #define MUX_BUFFER_MASK (MUX_BUFFER_SIZE - 1)
1895 IOCanRWHandler
*chr_can_read
[MAX_MUX
];
1896 IOReadHandler
*chr_read
[MAX_MUX
];
1897 IOEventHandler
*chr_event
[MAX_MUX
];
1898 void *ext_opaque
[MAX_MUX
];
1899 CharDriverState
*drv
;
1900 unsigned char buffer
[MUX_BUFFER_SIZE
];
1904 int term_got_escape
;
1909 static int mux_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
1911 MuxDriver
*d
= chr
->opaque
;
1913 if (!term_timestamps
) {
1914 ret
= d
->drv
->chr_write(d
->drv
, buf
, len
);
1919 for(i
= 0; i
< len
; i
++) {
1920 ret
+= d
->drv
->chr_write(d
->drv
, buf
+i
, 1);
1921 if (buf
[i
] == '\n') {
1927 if (term_timestamps_start
== -1)
1928 term_timestamps_start
= ti
;
1929 ti
-= term_timestamps_start
;
1930 secs
= ti
/ 1000000000;
1931 snprintf(buf1
, sizeof(buf1
),
1932 "[%02d:%02d:%02d.%03d] ",
1936 (int)((ti
/ 1000000) % 1000));
1937 d
->drv
->chr_write(d
->drv
, (uint8_t *)buf1
, strlen(buf1
));
1944 static const char * const mux_help
[] = {
1945 "% h print this help\n\r",
1946 "% x exit emulator\n\r",
1947 "% s save disk data back to file (if -snapshot)\n\r",
1948 "% t toggle console timestamps\n\r"
1949 "% b send break (magic sysrq)\n\r",
1950 "% c switch between console and monitor\n\r",
1955 static int term_escape_char
= 0x01; /* ctrl-a is used for escape */
1956 static void mux_print_help(CharDriverState
*chr
)
1959 char ebuf
[15] = "Escape-Char";
1960 char cbuf
[50] = "\n\r";
1962 if (term_escape_char
> 0 && term_escape_char
< 26) {
1963 snprintf(cbuf
, sizeof(cbuf
), "\n\r");
1964 snprintf(ebuf
, sizeof(ebuf
), "C-%c", term_escape_char
- 1 + 'a');
1966 snprintf(cbuf
, sizeof(cbuf
),
1967 "\n\rEscape-Char set to Ascii: 0x%02x\n\r\n\r",
1970 chr
->chr_write(chr
, (uint8_t *)cbuf
, strlen(cbuf
));
1971 for (i
= 0; mux_help
[i
] != NULL
; i
++) {
1972 for (j
=0; mux_help
[i
][j
] != '\0'; j
++) {
1973 if (mux_help
[i
][j
] == '%')
1974 chr
->chr_write(chr
, (uint8_t *)ebuf
, strlen(ebuf
));
1976 chr
->chr_write(chr
, (uint8_t *)&mux_help
[i
][j
], 1);
1981 static int mux_proc_byte(CharDriverState
*chr
, MuxDriver
*d
, int ch
)
1983 if (d
->term_got_escape
) {
1984 d
->term_got_escape
= 0;
1985 if (ch
== term_escape_char
)
1990 mux_print_help(chr
);
1994 const char *term
= "QEMU: Terminated\n\r";
1995 chr
->chr_write(chr
,(uint8_t *)term
,strlen(term
));
2002 for (i
= 0; i
< nb_drives
; i
++) {
2003 bdrv_commit(drives_table
[i
].bdrv
);
2008 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
2011 /* Switch to the next registered device */
2013 if (chr
->focus
>= d
->mux_cnt
)
2017 term_timestamps
= !term_timestamps
;
2018 term_timestamps_start
= -1;
2021 } else if (ch
== term_escape_char
) {
2022 d
->term_got_escape
= 1;
2030 static void mux_chr_accept_input(CharDriverState
*chr
)
2033 MuxDriver
*d
= chr
->opaque
;
2035 while (d
->prod
!= d
->cons
&&
2036 d
->chr_can_read
[m
] &&
2037 d
->chr_can_read
[m
](d
->ext_opaque
[m
])) {
2038 d
->chr_read
[m
](d
->ext_opaque
[m
],
2039 &d
->buffer
[d
->cons
++ & MUX_BUFFER_MASK
], 1);
2043 static int mux_chr_can_read(void *opaque
)
2045 CharDriverState
*chr
= opaque
;
2046 MuxDriver
*d
= chr
->opaque
;
2048 if ((d
->prod
- d
->cons
) < MUX_BUFFER_SIZE
)
2050 if (d
->chr_can_read
[chr
->focus
])
2051 return d
->chr_can_read
[chr
->focus
](d
->ext_opaque
[chr
->focus
]);
2055 static void mux_chr_read(void *opaque
, const uint8_t *buf
, int size
)
2057 CharDriverState
*chr
= opaque
;
2058 MuxDriver
*d
= chr
->opaque
;
2062 mux_chr_accept_input (opaque
);
2064 for(i
= 0; i
< size
; i
++)
2065 if (mux_proc_byte(chr
, d
, buf
[i
])) {
2066 if (d
->prod
== d
->cons
&&
2067 d
->chr_can_read
[m
] &&
2068 d
->chr_can_read
[m
](d
->ext_opaque
[m
]))
2069 d
->chr_read
[m
](d
->ext_opaque
[m
], &buf
[i
], 1);
2071 d
->buffer
[d
->prod
++ & MUX_BUFFER_MASK
] = buf
[i
];
2075 static void mux_chr_event(void *opaque
, int event
)
2077 CharDriverState
*chr
= opaque
;
2078 MuxDriver
*d
= chr
->opaque
;
2081 /* Send the event to all registered listeners */
2082 for (i
= 0; i
< d
->mux_cnt
; i
++)
2083 if (d
->chr_event
[i
])
2084 d
->chr_event
[i
](d
->ext_opaque
[i
], event
);
2087 static void mux_chr_update_read_handler(CharDriverState
*chr
)
2089 MuxDriver
*d
= chr
->opaque
;
2091 if (d
->mux_cnt
>= MAX_MUX
) {
2092 fprintf(stderr
, "Cannot add I/O handlers, MUX array is full\n");
2095 d
->ext_opaque
[d
->mux_cnt
] = chr
->handler_opaque
;
2096 d
->chr_can_read
[d
->mux_cnt
] = chr
->chr_can_read
;
2097 d
->chr_read
[d
->mux_cnt
] = chr
->chr_read
;
2098 d
->chr_event
[d
->mux_cnt
] = chr
->chr_event
;
2099 /* Fix up the real driver with mux routines */
2100 if (d
->mux_cnt
== 0) {
2101 qemu_chr_add_handlers(d
->drv
, mux_chr_can_read
, mux_chr_read
,
2102 mux_chr_event
, chr
);
2104 chr
->focus
= d
->mux_cnt
;
2108 static CharDriverState
*qemu_chr_open_mux(CharDriverState
*drv
)
2110 CharDriverState
*chr
;
2113 chr
= qemu_mallocz(sizeof(CharDriverState
));
2116 d
= qemu_mallocz(sizeof(MuxDriver
));
2125 chr
->chr_write
= mux_chr_write
;
2126 chr
->chr_update_read_handler
= mux_chr_update_read_handler
;
2127 chr
->chr_accept_input
= mux_chr_accept_input
;
2134 static void socket_cleanup(void)
2139 static int socket_init(void)
2144 ret
= WSAStartup(MAKEWORD(2,2), &Data
);
2146 err
= WSAGetLastError();
2147 fprintf(stderr
, "WSAStartup: %d\n", err
);
2150 atexit(socket_cleanup
);
2154 static int send_all(int fd
, const uint8_t *buf
, int len1
)
2160 ret
= send(fd
, buf
, len
, 0);
2163 errno
= WSAGetLastError();
2164 if (errno
!= WSAEWOULDBLOCK
) {
2167 } else if (ret
== 0) {
2179 static int unix_write(int fd
, const uint8_t *buf
, int len1
)
2185 ret
= write(fd
, buf
, len
);
2187 if (errno
!= EINTR
&& errno
!= EAGAIN
)
2189 } else if (ret
== 0) {
2199 static inline int send_all(int fd
, const uint8_t *buf
, int len1
)
2201 return unix_write(fd
, buf
, len1
);
2203 #endif /* !_WIN32 */
2212 #define STDIO_MAX_CLIENTS 1
2213 static int stdio_nb_clients
= 0;
2215 static int fd_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2217 FDCharDriver
*s
= chr
->opaque
;
2218 return unix_write(s
->fd_out
, buf
, len
);
2221 static int fd_chr_read_poll(void *opaque
)
2223 CharDriverState
*chr
= opaque
;
2224 FDCharDriver
*s
= chr
->opaque
;
2226 s
->max_size
= qemu_chr_can_read(chr
);
2230 static void fd_chr_read(void *opaque
)
2232 CharDriverState
*chr
= opaque
;
2233 FDCharDriver
*s
= chr
->opaque
;
2238 if (len
> s
->max_size
)
2242 size
= read(s
->fd_in
, buf
, len
);
2244 /* FD has been closed. Remove it from the active list. */
2245 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2249 qemu_chr_read(chr
, buf
, size
);
2253 static void fd_chr_update_read_handler(CharDriverState
*chr
)
2255 FDCharDriver
*s
= chr
->opaque
;
2257 if (s
->fd_in
>= 0) {
2258 if (nographic
&& s
->fd_in
== 0) {
2260 qemu_set_fd_handler2(s
->fd_in
, fd_chr_read_poll
,
2261 fd_chr_read
, NULL
, chr
);
2266 static void fd_chr_close(struct CharDriverState
*chr
)
2268 FDCharDriver
*s
= chr
->opaque
;
2270 if (s
->fd_in
>= 0) {
2271 if (nographic
&& s
->fd_in
== 0) {
2273 qemu_set_fd_handler2(s
->fd_in
, NULL
, NULL
, NULL
, NULL
);
2280 /* open a character device to a unix fd */
2281 static CharDriverState
*qemu_chr_open_fd(int fd_in
, int fd_out
)
2283 CharDriverState
*chr
;
2286 chr
= qemu_mallocz(sizeof(CharDriverState
));
2289 s
= qemu_mallocz(sizeof(FDCharDriver
));
2297 chr
->chr_write
= fd_chr_write
;
2298 chr
->chr_update_read_handler
= fd_chr_update_read_handler
;
2299 chr
->chr_close
= fd_chr_close
;
2301 qemu_chr_reset(chr
);
2306 static CharDriverState
*qemu_chr_open_file_out(const char *file_out
)
2310 TFR(fd_out
= open(file_out
, O_WRONLY
| O_TRUNC
| O_CREAT
| O_BINARY
, 0666));
2313 return qemu_chr_open_fd(-1, fd_out
);
2316 static CharDriverState
*qemu_chr_open_pipe(const char *filename
)
2319 char filename_in
[256], filename_out
[256];
2321 snprintf(filename_in
, 256, "%s.in", filename
);
2322 snprintf(filename_out
, 256, "%s.out", filename
);
2323 TFR(fd_in
= open(filename_in
, O_RDWR
| O_BINARY
));
2324 TFR(fd_out
= open(filename_out
, O_RDWR
| O_BINARY
));
2325 if (fd_in
< 0 || fd_out
< 0) {
2330 TFR(fd_in
= fd_out
= open(filename
, O_RDWR
| O_BINARY
));
2334 return qemu_chr_open_fd(fd_in
, fd_out
);
2338 /* for STDIO, we handle the case where several clients use it
2341 #define TERM_FIFO_MAX_SIZE 1
2343 static uint8_t term_fifo
[TERM_FIFO_MAX_SIZE
];
2344 static int term_fifo_size
;
2346 static int stdio_read_poll(void *opaque
)
2348 CharDriverState
*chr
= opaque
;
2350 /* try to flush the queue if needed */
2351 if (term_fifo_size
!= 0 && qemu_chr_can_read(chr
) > 0) {
2352 qemu_chr_read(chr
, term_fifo
, 1);
2355 /* see if we can absorb more chars */
2356 if (term_fifo_size
== 0)
2362 static void stdio_read(void *opaque
)
2366 CharDriverState
*chr
= opaque
;
2368 size
= read(0, buf
, 1);
2370 /* stdin has been closed. Remove it from the active list. */
2371 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2375 if (qemu_chr_can_read(chr
) > 0) {
2376 qemu_chr_read(chr
, buf
, 1);
2377 } else if (term_fifo_size
== 0) {
2378 term_fifo
[term_fifo_size
++] = buf
[0];
2383 /* init terminal so that we can grab keys */
2384 static struct termios oldtty
;
2385 static int old_fd0_flags
;
2386 static int term_atexit_done
;
2388 static void term_exit(void)
2390 tcsetattr (0, TCSANOW
, &oldtty
);
2391 fcntl(0, F_SETFL
, old_fd0_flags
);
2394 static void term_init(void)
2398 tcgetattr (0, &tty
);
2400 old_fd0_flags
= fcntl(0, F_GETFL
);
2402 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2403 |INLCR
|IGNCR
|ICRNL
|IXON
);
2404 tty
.c_oflag
|= OPOST
;
2405 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
);
2406 /* if graphical mode, we allow Ctrl-C handling */
2408 tty
.c_lflag
&= ~ISIG
;
2409 tty
.c_cflag
&= ~(CSIZE
|PARENB
);
2412 tty
.c_cc
[VTIME
] = 0;
2414 tcsetattr (0, TCSANOW
, &tty
);
2416 if (!term_atexit_done
++)
2419 fcntl(0, F_SETFL
, O_NONBLOCK
);
2422 static void qemu_chr_close_stdio(struct CharDriverState
*chr
)
2426 qemu_set_fd_handler2(0, NULL
, NULL
, NULL
, NULL
);
2430 static CharDriverState
*qemu_chr_open_stdio(void)
2432 CharDriverState
*chr
;
2434 if (stdio_nb_clients
>= STDIO_MAX_CLIENTS
)
2436 chr
= qemu_chr_open_fd(0, 1);
2437 chr
->chr_close
= qemu_chr_close_stdio
;
2438 qemu_set_fd_handler2(0, stdio_read_poll
, stdio_read
, NULL
, chr
);
2446 /* Once Solaris has openpty(), this is going to be removed. */
2447 int openpty(int *amaster
, int *aslave
, char *name
,
2448 struct termios
*termp
, struct winsize
*winp
)
2451 int mfd
= -1, sfd
= -1;
2453 *amaster
= *aslave
= -1;
2455 mfd
= open("/dev/ptmx", O_RDWR
| O_NOCTTY
);
2459 if (grantpt(mfd
) == -1 || unlockpt(mfd
) == -1)
2462 if ((slave
= ptsname(mfd
)) == NULL
)
2465 if ((sfd
= open(slave
, O_RDONLY
| O_NOCTTY
)) == -1)
2468 if (ioctl(sfd
, I_PUSH
, "ptem") == -1 ||
2469 (termp
!= NULL
&& tcgetattr(sfd
, termp
) < 0))
2477 ioctl(sfd
, TIOCSWINSZ
, winp
);
2488 void cfmakeraw (struct termios
*termios_p
)
2490 termios_p
->c_iflag
&=
2491 ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
|INLCR
|IGNCR
|ICRNL
|IXON
);
2492 termios_p
->c_oflag
&= ~OPOST
;
2493 termios_p
->c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|ISIG
|IEXTEN
);
2494 termios_p
->c_cflag
&= ~(CSIZE
|PARENB
);
2495 termios_p
->c_cflag
|= CS8
;
2497 termios_p
->c_cc
[VMIN
] = 0;
2498 termios_p
->c_cc
[VTIME
] = 0;
2502 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
2503 || defined(__NetBSD__) || defined(__OpenBSD__)
2513 static void pty_chr_update_read_handler(CharDriverState
*chr
);
2514 static void pty_chr_state(CharDriverState
*chr
, int connected
);
2516 static int pty_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
2518 PtyCharDriver
*s
= chr
->opaque
;
2520 if (!s
->connected
) {
2521 /* guest sends data, check for (re-)connect */
2522 pty_chr_update_read_handler(chr
);
2525 return unix_write(s
->fd
, buf
, len
);
2528 static int pty_chr_read_poll(void *opaque
)
2530 CharDriverState
*chr
= opaque
;
2531 PtyCharDriver
*s
= chr
->opaque
;
2533 s
->read_bytes
= qemu_chr_can_read(chr
);
2534 return s
->read_bytes
;
2537 static void pty_chr_read(void *opaque
)
2539 CharDriverState
*chr
= opaque
;
2540 PtyCharDriver
*s
= chr
->opaque
;
2545 if (len
> s
->read_bytes
)
2546 len
= s
->read_bytes
;
2549 size
= read(s
->fd
, buf
, len
);
2550 if ((size
== -1 && errno
== EIO
) ||
2552 pty_chr_state(chr
, 0);
2556 pty_chr_state(chr
, 1);
2557 qemu_chr_read(chr
, buf
, size
);
2561 static void pty_chr_update_read_handler(CharDriverState
*chr
)
2563 PtyCharDriver
*s
= chr
->opaque
;
2565 qemu_set_fd_handler2(s
->fd
, pty_chr_read_poll
,
2566 pty_chr_read
, NULL
, chr
);
2569 * Short timeout here: just need wait long enougth that qemu makes
2570 * it through the poll loop once. When reconnected we want a
2571 * short timeout so we notice it almost instantly. Otherwise
2572 * read() gives us -EIO instantly, making pty_chr_state() reset the
2573 * timeout to the normal (much longer) poll interval before the
2576 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 10);
2579 static void pty_chr_state(CharDriverState
*chr
, int connected
)
2581 PtyCharDriver
*s
= chr
->opaque
;
2584 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2587 /* (re-)connect poll interval for idle guests: once per second.
2588 * We check more frequently in case the guests sends data to
2589 * the virtual device linked to our pty. */
2590 qemu_mod_timer(s
->timer
, qemu_get_clock(rt_clock
) + 1000);
2593 qemu_chr_reset(chr
);
2598 static void pty_chr_timer(void *opaque
)
2600 struct CharDriverState
*chr
= opaque
;
2601 PtyCharDriver
*s
= chr
->opaque
;
2606 /* If we arrive here without polling being cleared due
2607 * read returning -EIO, then we are (re-)connected */
2608 pty_chr_state(chr
, 1);
2613 pty_chr_update_read_handler(chr
);
2616 static void pty_chr_close(struct CharDriverState
*chr
)
2618 PtyCharDriver
*s
= chr
->opaque
;
2620 qemu_set_fd_handler2(s
->fd
, NULL
, NULL
, NULL
, NULL
);
2625 static CharDriverState
*qemu_chr_open_pty(void)
2627 CharDriverState
*chr
;
2631 #if defined(__OpenBSD__)
2632 char pty_name
[PATH_MAX
];
2633 #define q_ptsname(x) pty_name
2635 char *pty_name
= NULL
;
2636 #define q_ptsname(x) ptsname(x)
2639 chr
= qemu_mallocz(sizeof(CharDriverState
));
2642 s
= qemu_mallocz(sizeof(PtyCharDriver
));
2648 if (openpty(&s
->fd
, &slave_fd
, pty_name
, NULL
, NULL
) < 0) {
2652 /* Set raw attributes on the pty. */
2654 tcsetattr(slave_fd
, TCSAFLUSH
, &tty
);
2657 fprintf(stderr
, "char device redirected to %s\n", q_ptsname(s
->fd
));
2660 chr
->chr_write
= pty_chr_write
;
2661 chr
->chr_update_read_handler
= pty_chr_update_read_handler
;
2662 chr
->chr_close
= pty_chr_close
;
2664 s
->timer
= qemu_new_timer(rt_clock
, pty_chr_timer
, chr
);
2669 static void tty_serial_init(int fd
, int speed
,
2670 int parity
, int data_bits
, int stop_bits
)
2676 printf("tty_serial_init: speed=%d parity=%c data=%d stop=%d\n",
2677 speed
, parity
, data_bits
, stop_bits
);
2679 tcgetattr (fd
, &tty
);
2682 if (speed
<= 50 * MARGIN
)
2684 else if (speed
<= 75 * MARGIN
)
2686 else if (speed
<= 300 * MARGIN
)
2688 else if (speed
<= 600 * MARGIN
)
2690 else if (speed
<= 1200 * MARGIN
)
2692 else if (speed
<= 2400 * MARGIN
)
2694 else if (speed
<= 4800 * MARGIN
)
2696 else if (speed
<= 9600 * MARGIN
)
2698 else if (speed
<= 19200 * MARGIN
)
2700 else if (speed
<= 38400 * MARGIN
)
2702 else if (speed
<= 57600 * MARGIN
)
2704 else if (speed
<= 115200 * MARGIN
)
2709 cfsetispeed(&tty
, spd
);
2710 cfsetospeed(&tty
, spd
);
2712 tty
.c_iflag
&= ~(IGNBRK
|BRKINT
|PARMRK
|ISTRIP
2713 |INLCR
|IGNCR
|ICRNL
|IXON
);
2714 tty
.c_oflag
|= OPOST
;
2715 tty
.c_lflag
&= ~(ECHO
|ECHONL
|ICANON
|IEXTEN
|ISIG
);
2716 tty
.c_cflag
&= ~(CSIZE
|PARENB
|PARODD
|CRTSCTS
|CSTOPB
);
2737 tty
.c_cflag
|= PARENB
;
2740 tty
.c_cflag
|= PARENB
| PARODD
;
2744 tty
.c_cflag
|= CSTOPB
;
2746 tcsetattr (fd
, TCSANOW
, &tty
);
2749 static int tty_serial_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2751 FDCharDriver
*s
= chr
->opaque
;
2754 case CHR_IOCTL_SERIAL_SET_PARAMS
:
2756 QEMUSerialSetParams
*ssp
= arg
;
2757 tty_serial_init(s
->fd_in
, ssp
->speed
, ssp
->parity
,
2758 ssp
->data_bits
, ssp
->stop_bits
);
2761 case CHR_IOCTL_SERIAL_SET_BREAK
:
2763 int enable
= *(int *)arg
;
2765 tcsendbreak(s
->fd_in
, 1);
2768 case CHR_IOCTL_SERIAL_GET_TIOCM
:
2771 int *targ
= (int *)arg
;
2772 ioctl(s
->fd_in
, TIOCMGET
, &sarg
);
2774 if (sarg
| TIOCM_CTS
)
2775 *targ
|= CHR_TIOCM_CTS
;
2776 if (sarg
| TIOCM_CAR
)
2777 *targ
|= CHR_TIOCM_CAR
;
2778 if (sarg
| TIOCM_DSR
)
2779 *targ
|= CHR_TIOCM_DSR
;
2780 if (sarg
| TIOCM_RI
)
2781 *targ
|= CHR_TIOCM_RI
;
2782 if (sarg
| TIOCM_DTR
)
2783 *targ
|= CHR_TIOCM_DTR
;
2784 if (sarg
| TIOCM_RTS
)
2785 *targ
|= CHR_TIOCM_RTS
;
2788 case CHR_IOCTL_SERIAL_SET_TIOCM
:
2790 int sarg
= *(int *)arg
;
2792 if (sarg
| CHR_TIOCM_DTR
)
2794 if (sarg
| CHR_TIOCM_RTS
)
2796 ioctl(s
->fd_in
, TIOCMSET
, &targ
);
2805 static CharDriverState
*qemu_chr_open_tty(const char *filename
)
2807 CharDriverState
*chr
;
2810 TFR(fd
= open(filename
, O_RDWR
| O_NONBLOCK
));
2811 tty_serial_init(fd
, 115200, 'N', 8, 1);
2812 chr
= qemu_chr_open_fd(fd
, fd
);
2817 chr
->chr_ioctl
= tty_serial_ioctl
;
2818 qemu_chr_reset(chr
);
2821 #else /* ! __linux__ && ! __sun__ */
2822 static CharDriverState
*qemu_chr_open_pty(void)
2826 #endif /* __linux__ || __sun__ */
2828 #if defined(__linux__)
2832 } ParallelCharDriver
;
2834 static int pp_hw_mode(ParallelCharDriver
*s
, uint16_t mode
)
2836 if (s
->mode
!= mode
) {
2838 if (ioctl(s
->fd
, PPSETMODE
, &m
) < 0)
2845 static int pp_ioctl(CharDriverState
*chr
, int cmd
, void *arg
)
2847 ParallelCharDriver
*drv
= chr
->opaque
;
2852 case CHR_IOCTL_PP_READ_DATA
:
2853 if (ioctl(fd
, PPRDATA
, &b
) < 0)
2855 *(uint8_t *)arg
= b
;
2857 case CHR_IOCTL_PP_WRITE_DATA
:
2858 b
= *(uint8_t *)arg
;
2859 if (ioctl(fd
, PPWDATA
, &b
) < 0)
2862 case CHR_IOCTL_PP_READ_CONTROL
:
2863 if (ioctl(fd
, PPRCONTROL
, &b
) < 0)
2865 /* Linux gives only the lowest bits, and no way to know data
2866 direction! For better compatibility set the fixed upper
2868 *(uint8_t *)arg
= b
| 0xc0;
2870 case CHR_IOCTL_PP_WRITE_CONTROL
:
2871 b
= *(uint8_t *)arg
;
2872 if (ioctl(fd
, PPWCONTROL
, &b
) < 0)
2875 case CHR_IOCTL_PP_READ_STATUS
:
2876 if (ioctl(fd
, PPRSTATUS
, &b
) < 0)
2878 *(uint8_t *)arg
= b
;
2880 case CHR_IOCTL_PP_DATA_DIR
:
2881 if (ioctl(fd
, PPDATADIR
, (int *)arg
) < 0)
2884 case CHR_IOCTL_PP_EPP_READ_ADDR
:
2885 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2886 struct ParallelIOArg
*parg
= arg
;
2887 int n
= read(fd
, parg
->buffer
, parg
->count
);
2888 if (n
!= parg
->count
) {
2893 case CHR_IOCTL_PP_EPP_READ
:
2894 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2895 struct ParallelIOArg
*parg
= arg
;
2896 int n
= read(fd
, parg
->buffer
, parg
->count
);
2897 if (n
!= parg
->count
) {
2902 case CHR_IOCTL_PP_EPP_WRITE_ADDR
:
2903 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
|IEEE1284_ADDR
)) {
2904 struct ParallelIOArg
*parg
= arg
;
2905 int n
= write(fd
, parg
->buffer
, parg
->count
);
2906 if (n
!= parg
->count
) {
2911 case CHR_IOCTL_PP_EPP_WRITE
:
2912 if (pp_hw_mode(drv
, IEEE1284_MODE_EPP
)) {
2913 struct ParallelIOArg
*parg
= arg
;
2914 int n
= write(fd
, parg
->buffer
, parg
->count
);
2915 if (n
!= parg
->count
) {
2926 static void pp_close(CharDriverState
*chr
)
2928 ParallelCharDriver
*drv
= chr
->opaque
;
2931 pp_hw_mode(drv
, IEEE1284_MODE_COMPAT
);
2932 ioctl(fd
, PPRELEASE
);
2937 static CharDriverState
*qemu_chr_open_pp(const char *filename
)
2939 CharDriverState
*chr
;
2940 ParallelCharDriver
*drv
;
2943 TFR(fd
= open(filename
, O_RDWR
));
2947 if (ioctl(fd
, PPCLAIM
) < 0) {
2952 drv
= qemu_mallocz(sizeof(ParallelCharDriver
));
2958 drv
->mode
= IEEE1284_MODE_COMPAT
;
2960 chr
= qemu_mallocz(sizeof(CharDriverState
));
2966 chr
->chr_write
= null_chr_write
;
2967 chr
->chr_ioctl
= pp_ioctl
;
2968 chr
->chr_close
= pp_close
;
2971 qemu_chr_reset(chr
);
2975 #endif /* __linux__ */
2981 HANDLE hcom
, hrecv
, hsend
;
2982 OVERLAPPED orecv
, osend
;
2987 #define NSENDBUF 2048
2988 #define NRECVBUF 2048
2989 #define MAXCONNECT 1
2990 #define NTIMEOUT 5000
2992 static int win_chr_poll(void *opaque
);
2993 static int win_chr_pipe_poll(void *opaque
);
2995 static void win_chr_close(CharDriverState
*chr
)
2997 WinCharState
*s
= chr
->opaque
;
3000 CloseHandle(s
->hsend
);
3004 CloseHandle(s
->hrecv
);
3008 CloseHandle(s
->hcom
);
3012 qemu_del_polling_cb(win_chr_pipe_poll
, chr
);
3014 qemu_del_polling_cb(win_chr_poll
, chr
);
3017 static int win_chr_init(CharDriverState
*chr
, const char *filename
)
3019 WinCharState
*s
= chr
->opaque
;
3021 COMMTIMEOUTS cto
= { 0, 0, 0, 0, 0};
3026 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3028 fprintf(stderr
, "Failed CreateEvent\n");
3031 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3033 fprintf(stderr
, "Failed CreateEvent\n");
3037 s
->hcom
= CreateFile(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
3038 OPEN_EXISTING
, FILE_FLAG_OVERLAPPED
, 0);
3039 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3040 fprintf(stderr
, "Failed CreateFile (%lu)\n", GetLastError());
3045 if (!SetupComm(s
->hcom
, NRECVBUF
, NSENDBUF
)) {
3046 fprintf(stderr
, "Failed SetupComm\n");
3050 ZeroMemory(&comcfg
, sizeof(COMMCONFIG
));
3051 size
= sizeof(COMMCONFIG
);
3052 GetDefaultCommConfig(filename
, &comcfg
, &size
);
3053 comcfg
.dcb
.DCBlength
= sizeof(DCB
);
3054 CommConfigDialog(filename
, NULL
, &comcfg
);
3056 if (!SetCommState(s
->hcom
, &comcfg
.dcb
)) {
3057 fprintf(stderr
, "Failed SetCommState\n");
3061 if (!SetCommMask(s
->hcom
, EV_ERR
)) {
3062 fprintf(stderr
, "Failed SetCommMask\n");
3066 cto
.ReadIntervalTimeout
= MAXDWORD
;
3067 if (!SetCommTimeouts(s
->hcom
, &cto
)) {
3068 fprintf(stderr
, "Failed SetCommTimeouts\n");
3072 if (!ClearCommError(s
->hcom
, &err
, &comstat
)) {
3073 fprintf(stderr
, "Failed ClearCommError\n");
3076 qemu_add_polling_cb(win_chr_poll
, chr
);
3084 static int win_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len1
)
3086 WinCharState
*s
= chr
->opaque
;
3087 DWORD len
, ret
, size
, err
;
3090 ZeroMemory(&s
->osend
, sizeof(s
->osend
));
3091 s
->osend
.hEvent
= s
->hsend
;
3094 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, &s
->osend
);
3096 ret
= WriteFile(s
->hcom
, buf
, len
, &size
, NULL
);
3098 err
= GetLastError();
3099 if (err
== ERROR_IO_PENDING
) {
3100 ret
= GetOverlappedResult(s
->hcom
, &s
->osend
, &size
, TRUE
);
3118 static int win_chr_read_poll(CharDriverState
*chr
)
3120 WinCharState
*s
= chr
->opaque
;
3122 s
->max_size
= qemu_chr_can_read(chr
);
3126 static void win_chr_readfile(CharDriverState
*chr
)
3128 WinCharState
*s
= chr
->opaque
;
3133 ZeroMemory(&s
->orecv
, sizeof(s
->orecv
));
3134 s
->orecv
.hEvent
= s
->hrecv
;
3135 ret
= ReadFile(s
->hcom
, buf
, s
->len
, &size
, &s
->orecv
);
3137 err
= GetLastError();
3138 if (err
== ERROR_IO_PENDING
) {
3139 ret
= GetOverlappedResult(s
->hcom
, &s
->orecv
, &size
, TRUE
);
3144 qemu_chr_read(chr
, buf
, size
);
3148 static void win_chr_read(CharDriverState
*chr
)
3150 WinCharState
*s
= chr
->opaque
;
3152 if (s
->len
> s
->max_size
)
3153 s
->len
= s
->max_size
;
3157 win_chr_readfile(chr
);
3160 static int win_chr_poll(void *opaque
)
3162 CharDriverState
*chr
= opaque
;
3163 WinCharState
*s
= chr
->opaque
;
3167 ClearCommError(s
->hcom
, &comerr
, &status
);
3168 if (status
.cbInQue
> 0) {
3169 s
->len
= status
.cbInQue
;
3170 win_chr_read_poll(chr
);
3177 static CharDriverState
*qemu_chr_open_win(const char *filename
)
3179 CharDriverState
*chr
;
3182 chr
= qemu_mallocz(sizeof(CharDriverState
));
3185 s
= qemu_mallocz(sizeof(WinCharState
));
3191 chr
->chr_write
= win_chr_write
;
3192 chr
->chr_close
= win_chr_close
;
3194 if (win_chr_init(chr
, filename
) < 0) {
3199 qemu_chr_reset(chr
);
3203 static int win_chr_pipe_poll(void *opaque
)
3205 CharDriverState
*chr
= opaque
;
3206 WinCharState
*s
= chr
->opaque
;
3209 PeekNamedPipe(s
->hcom
, NULL
, 0, NULL
, &size
, NULL
);
3212 win_chr_read_poll(chr
);
3219 static int win_chr_pipe_init(CharDriverState
*chr
, const char *filename
)
3221 WinCharState
*s
= chr
->opaque
;
3229 s
->hsend
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3231 fprintf(stderr
, "Failed CreateEvent\n");
3234 s
->hrecv
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3236 fprintf(stderr
, "Failed CreateEvent\n");
3240 snprintf(openname
, sizeof(openname
), "\\\\.\\pipe\\%s", filename
);
3241 s
->hcom
= CreateNamedPipe(openname
, PIPE_ACCESS_DUPLEX
| FILE_FLAG_OVERLAPPED
,
3242 PIPE_TYPE_BYTE
| PIPE_READMODE_BYTE
|
3244 MAXCONNECT
, NSENDBUF
, NRECVBUF
, NTIMEOUT
, NULL
);
3245 if (s
->hcom
== INVALID_HANDLE_VALUE
) {
3246 fprintf(stderr
, "Failed CreateNamedPipe (%lu)\n", GetLastError());
3251 ZeroMemory(&ov
, sizeof(ov
));
3252 ov
.hEvent
= CreateEvent(NULL
, TRUE
, FALSE
, NULL
);
3253 ret
= ConnectNamedPipe(s
->hcom
, &ov
);
3255 fprintf(stderr
, "Failed ConnectNamedPipe\n");
3259 ret
= GetOverlappedResult(s
->hcom
, &ov
, &size
, TRUE
);
3261 fprintf(stderr
, "Failed GetOverlappedResult\n");
3263 CloseHandle(ov
.hEvent
);
3270 CloseHandle(ov
.hEvent
);
3273 qemu_add_polling_cb(win_chr_pipe_poll
, chr
);
3282 static CharDriverState
*qemu_chr_open_win_pipe(const char *filename
)
3284 CharDriverState
*chr
;
3287 chr
= qemu_mallocz(sizeof(CharDriverState
));
3290 s
= qemu_mallocz(sizeof(WinCharState
));
3296 chr
->chr_write
= win_chr_write
;
3297 chr
->chr_close
= win_chr_close
;
3299 if (win_chr_pipe_init(chr
, filename
) < 0) {
3304 qemu_chr_reset(chr
);
3308 static CharDriverState
*qemu_chr_open_win_file(HANDLE fd_out
)
3310 CharDriverState
*chr
;
3313 chr
= qemu_mallocz(sizeof(CharDriverState
));
3316 s
= qemu_mallocz(sizeof(WinCharState
));
3323 chr
->chr_write
= win_chr_write
;
3324 qemu_chr_reset(chr
);
3328 static CharDriverState
*qemu_chr_open_win_con(const char *filename
)
3330 return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE
));
3333 static CharDriverState
*qemu_chr_open_win_file_out(const char *file_out
)
3337 fd_out
= CreateFile(file_out
, GENERIC_WRITE
, FILE_SHARE_READ
, NULL
,
3338 OPEN_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3339 if (fd_out
== INVALID_HANDLE_VALUE
)
3342 return qemu_chr_open_win_file(fd_out
);
3344 #endif /* !_WIN32 */
3346 /***********************************************************/
3347 /* UDP Net console */
3351 struct sockaddr_in daddr
;
3358 static int udp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3360 NetCharDriver
*s
= chr
->opaque
;
3362 return sendto(s
->fd
, buf
, len
, 0,
3363 (struct sockaddr
*)&s
->daddr
, sizeof(struct sockaddr_in
));
3366 static int udp_chr_read_poll(void *opaque
)
3368 CharDriverState
*chr
= opaque
;
3369 NetCharDriver
*s
= chr
->opaque
;
3371 s
->max_size
= qemu_chr_can_read(chr
);
3373 /* If there were any stray characters in the queue process them
3376 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3377 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3379 s
->max_size
= qemu_chr_can_read(chr
);
3384 static void udp_chr_read(void *opaque
)
3386 CharDriverState
*chr
= opaque
;
3387 NetCharDriver
*s
= chr
->opaque
;
3389 if (s
->max_size
== 0)
3391 s
->bufcnt
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
3392 s
->bufptr
= s
->bufcnt
;
3397 while (s
->max_size
> 0 && s
->bufptr
< s
->bufcnt
) {
3398 qemu_chr_read(chr
, &s
->buf
[s
->bufptr
], 1);
3400 s
->max_size
= qemu_chr_can_read(chr
);
3404 static void udp_chr_update_read_handler(CharDriverState
*chr
)
3406 NetCharDriver
*s
= chr
->opaque
;
3409 qemu_set_fd_handler2(s
->fd
, udp_chr_read_poll
,
3410 udp_chr_read
, NULL
, chr
);
3415 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
);
3417 int parse_host_src_port(struct sockaddr_in
*haddr
,
3418 struct sockaddr_in
*saddr
,
3421 static CharDriverState
*qemu_chr_open_udp(const char *def
)
3423 CharDriverState
*chr
= NULL
;
3424 NetCharDriver
*s
= NULL
;
3426 struct sockaddr_in saddr
;
3428 chr
= qemu_mallocz(sizeof(CharDriverState
));
3431 s
= qemu_mallocz(sizeof(NetCharDriver
));
3435 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
3437 perror("socket(PF_INET, SOCK_DGRAM)");
3441 if (parse_host_src_port(&s
->daddr
, &saddr
, def
) < 0) {
3442 printf("Could not parse: %s\n", def
);
3446 if (bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
)) < 0)
3456 chr
->chr_write
= udp_chr_write
;
3457 chr
->chr_update_read_handler
= udp_chr_update_read_handler
;
3470 /***********************************************************/
3471 /* TCP Net console */
3482 static void tcp_chr_accept(void *opaque
);
3484 static int tcp_chr_write(CharDriverState
*chr
, const uint8_t *buf
, int len
)
3486 TCPCharDriver
*s
= chr
->opaque
;
3488 return send_all(s
->fd
, buf
, len
);
3490 /* XXX: indicate an error ? */
3495 static int tcp_chr_read_poll(void *opaque
)
3497 CharDriverState
*chr
= opaque
;
3498 TCPCharDriver
*s
= chr
->opaque
;
3501 s
->max_size
= qemu_chr_can_read(chr
);
3506 #define IAC_BREAK 243
3507 static void tcp_chr_process_IAC_bytes(CharDriverState
*chr
,
3509 uint8_t *buf
, int *size
)
3511 /* Handle any telnet client's basic IAC options to satisfy char by
3512 * char mode with no echo. All IAC options will be removed from
3513 * the buf and the do_telnetopt variable will be used to track the
3514 * state of the width of the IAC information.
3516 * IAC commands come in sets of 3 bytes with the exception of the
3517 * "IAC BREAK" command and the double IAC.
3523 for (i
= 0; i
< *size
; i
++) {
3524 if (s
->do_telnetopt
> 1) {
3525 if ((unsigned char)buf
[i
] == IAC
&& s
->do_telnetopt
== 2) {
3526 /* Double IAC means send an IAC */
3530 s
->do_telnetopt
= 1;
3532 if ((unsigned char)buf
[i
] == IAC_BREAK
&& s
->do_telnetopt
== 2) {
3533 /* Handle IAC break commands by sending a serial break */
3534 qemu_chr_event(chr
, CHR_EVENT_BREAK
);
3539 if (s
->do_telnetopt
>= 4) {
3540 s
->do_telnetopt
= 1;
3543 if ((unsigned char)buf
[i
] == IAC
) {
3544 s
->do_telnetopt
= 2;
3555 static void tcp_chr_read(void *opaque
)
3557 CharDriverState
*chr
= opaque
;
3558 TCPCharDriver
*s
= chr
->opaque
;
3562 if (!s
->connected
|| s
->max_size
<= 0)
3565 if (len
> s
->max_size
)
3567 size
= recv(s
->fd
, buf
, len
, 0);
3569 /* connection closed */
3571 if (s
->listen_fd
>= 0) {
3572 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3574 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
3577 } else if (size
> 0) {
3578 if (s
->do_telnetopt
)
3579 tcp_chr_process_IAC_bytes(chr
, s
, buf
, &size
);
3581 qemu_chr_read(chr
, buf
, size
);
3585 static void tcp_chr_connect(void *opaque
)
3587 CharDriverState
*chr
= opaque
;
3588 TCPCharDriver
*s
= chr
->opaque
;
3591 qemu_set_fd_handler2(s
->fd
, tcp_chr_read_poll
,
3592 tcp_chr_read
, NULL
, chr
);
3593 qemu_chr_reset(chr
);
3596 #define IACSET(x,a,b,c) x[0] = a; x[1] = b; x[2] = c;
3597 static void tcp_chr_telnet_init(int fd
)
3600 /* Send the telnet negotion to put telnet in binary, no echo, single char mode */
3601 IACSET(buf
, 0xff, 0xfb, 0x01); /* IAC WILL ECHO */
3602 send(fd
, (char *)buf
, 3, 0);
3603 IACSET(buf
, 0xff, 0xfb, 0x03); /* IAC WILL Suppress go ahead */
3604 send(fd
, (char *)buf
, 3, 0);
3605 IACSET(buf
, 0xff, 0xfb, 0x00); /* IAC WILL Binary */
3606 send(fd
, (char *)buf
, 3, 0);
3607 IACSET(buf
, 0xff, 0xfd, 0x00); /* IAC DO Binary */
3608 send(fd
, (char *)buf
, 3, 0);
3611 static void socket_set_nodelay(int fd
)
3614 setsockopt(fd
, IPPROTO_TCP
, TCP_NODELAY
, (char *)&val
, sizeof(val
));
3617 static void tcp_chr_accept(void *opaque
)
3619 CharDriverState
*chr
= opaque
;
3620 TCPCharDriver
*s
= chr
->opaque
;
3621 struct sockaddr_in saddr
;
3623 struct sockaddr_un uaddr
;
3625 struct sockaddr
*addr
;
3632 len
= sizeof(uaddr
);
3633 addr
= (struct sockaddr
*)&uaddr
;
3637 len
= sizeof(saddr
);
3638 addr
= (struct sockaddr
*)&saddr
;
3640 fd
= accept(s
->listen_fd
, addr
, &len
);
3641 if (fd
< 0 && errno
!= EINTR
) {
3643 } else if (fd
>= 0) {
3644 if (s
->do_telnetopt
)
3645 tcp_chr_telnet_init(fd
);
3649 socket_set_nonblock(fd
);
3651 socket_set_nodelay(fd
);
3653 qemu_set_fd_handler(s
->listen_fd
, NULL
, NULL
, NULL
);
3654 tcp_chr_connect(chr
);
3657 static void tcp_chr_close(CharDriverState
*chr
)
3659 TCPCharDriver
*s
= chr
->opaque
;
3662 if (s
->listen_fd
>= 0)
3663 closesocket(s
->listen_fd
);
3667 static CharDriverState
*qemu_chr_open_tcp(const char *host_str
,
3671 CharDriverState
*chr
= NULL
;
3672 TCPCharDriver
*s
= NULL
;
3673 int fd
= -1, ret
, err
, val
;
3675 int is_waitconnect
= 1;
3678 struct sockaddr_in saddr
;
3680 struct sockaddr_un uaddr
;
3682 struct sockaddr
*addr
;
3687 addr
= (struct sockaddr
*)&uaddr
;
3688 addrlen
= sizeof(uaddr
);
3689 if (parse_unix_path(&uaddr
, host_str
) < 0)
3694 addr
= (struct sockaddr
*)&saddr
;
3695 addrlen
= sizeof(saddr
);
3696 if (parse_host_port(&saddr
, host_str
) < 0)
3701 while((ptr
= strchr(ptr
,','))) {
3703 if (!strncmp(ptr
,"server",6)) {
3705 } else if (!strncmp(ptr
,"nowait",6)) {
3707 } else if (!strncmp(ptr
,"nodelay",6)) {
3710 printf("Unknown option: %s\n", ptr
);
3717 chr
= qemu_mallocz(sizeof(CharDriverState
));
3720 s
= qemu_mallocz(sizeof(TCPCharDriver
));
3726 fd
= socket(PF_UNIX
, SOCK_STREAM
, 0);
3729 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
3734 if (!is_waitconnect
)
3735 socket_set_nonblock(fd
);
3740 s
->is_unix
= is_unix
;
3741 s
->do_nodelay
= do_nodelay
&& !is_unix
;
3744 chr
->chr_write
= tcp_chr_write
;
3745 chr
->chr_close
= tcp_chr_close
;
3748 /* allow fast reuse */
3752 pstrcpy(path
, sizeof(path
), uaddr
.sun_path
);
3758 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
3761 ret
= bind(fd
, addr
, addrlen
);
3765 ret
= listen(fd
, 0);
3770 qemu_set_fd_handler(s
->listen_fd
, tcp_chr_accept
, NULL
, chr
);
3772 s
->do_telnetopt
= 1;
3775 ret
= connect(fd
, addr
, addrlen
);
3777 err
= socket_error();
3778 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
3779 } else if (err
== EINPROGRESS
) {
3782 } else if (err
== WSAEALREADY
) {
3794 socket_set_nodelay(fd
);
3796 tcp_chr_connect(chr
);
3798 qemu_set_fd_handler(s
->fd
, NULL
, tcp_chr_connect
, chr
);
3801 if (is_listen
&& is_waitconnect
) {
3802 printf("QEMU waiting for connection on: %s\n", host_str
);
3803 tcp_chr_accept(chr
);
3804 socket_set_nonblock(s
->listen_fd
);
3816 CharDriverState
*qemu_chr_open(const char *filename
)
3820 if (!strcmp(filename
, "vc")) {
3821 return text_console_init(&display_state
, 0);
3822 } else if (strstart(filename
, "vc:", &p
)) {
3823 return text_console_init(&display_state
, p
);
3824 } else if (!strcmp(filename
, "null")) {
3825 return qemu_chr_open_null();
3827 if (strstart(filename
, "tcp:", &p
)) {
3828 return qemu_chr_open_tcp(p
, 0, 0);
3830 if (strstart(filename
, "telnet:", &p
)) {
3831 return qemu_chr_open_tcp(p
, 1, 0);
3833 if (strstart(filename
, "udp:", &p
)) {
3834 return qemu_chr_open_udp(p
);
3836 if (strstart(filename
, "mon:", &p
)) {
3837 CharDriverState
*drv
= qemu_chr_open(p
);
3839 drv
= qemu_chr_open_mux(drv
);
3840 monitor_init(drv
, !nographic
);
3843 printf("Unable to open driver: %s\n", p
);
3847 if (strstart(filename
, "unix:", &p
)) {
3848 return qemu_chr_open_tcp(p
, 0, 1);
3849 } else if (strstart(filename
, "file:", &p
)) {
3850 return qemu_chr_open_file_out(p
);
3851 } else if (strstart(filename
, "pipe:", &p
)) {
3852 return qemu_chr_open_pipe(p
);
3853 } else if (!strcmp(filename
, "pty")) {
3854 return qemu_chr_open_pty();
3855 } else if (!strcmp(filename
, "stdio")) {
3856 return qemu_chr_open_stdio();
3858 #if defined(__linux__)
3859 if (strstart(filename
, "/dev/parport", NULL
)) {
3860 return qemu_chr_open_pp(filename
);
3863 #if defined(__linux__) || defined(__sun__) || defined(__FreeBSD__) \
3864 || defined(__NetBSD__) || defined(__OpenBSD__)
3865 if (strstart(filename
, "/dev/", NULL
)) {
3866 return qemu_chr_open_tty(filename
);
3870 if (strstart(filename
, "COM", NULL
)) {
3871 return qemu_chr_open_win(filename
);
3873 if (strstart(filename
, "pipe:", &p
)) {
3874 return qemu_chr_open_win_pipe(p
);
3876 if (strstart(filename
, "con:", NULL
)) {
3877 return qemu_chr_open_win_con(filename
);
3879 if (strstart(filename
, "file:", &p
)) {
3880 return qemu_chr_open_win_file_out(p
);
3883 #ifdef CONFIG_BRLAPI
3884 if (!strcmp(filename
, "braille")) {
3885 return chr_baum_init();
3893 void qemu_chr_close(CharDriverState
*chr
)
3896 chr
->chr_close(chr
);
3900 /***********************************************************/
3901 /* network device redirectors */
3903 #if defined(DEBUG_NET) || defined(DEBUG_SLIRP)
3904 static void hex_dump(FILE *f
, const uint8_t *buf
, int size
)
3908 for(i
=0;i
<size
;i
+=16) {
3912 fprintf(f
, "%08x ", i
);
3915 fprintf(f
, " %02x", buf
[i
+j
]);
3920 for(j
=0;j
<len
;j
++) {
3922 if (c
< ' ' || c
> '~')
3924 fprintf(f
, "%c", c
);
3931 static int parse_macaddr(uint8_t *macaddr
, const char *p
)
3938 offset
= strtol(p
, &last_char
, 0);
3939 if (0 == errno
&& '\0' == *last_char
&&
3940 offset
>= 0 && offset
<= 0xFFFFFF) {
3941 macaddr
[3] = (offset
& 0xFF0000) >> 16;
3942 macaddr
[4] = (offset
& 0xFF00) >> 8;
3943 macaddr
[5] = offset
& 0xFF;
3946 for(i
= 0; i
< 6; i
++) {
3947 macaddr
[i
] = strtol(p
, (char **)&p
, 16);
3952 if (*p
!= ':' && *p
!= '-')
3963 static int get_str_sep(char *buf
, int buf_size
, const char **pp
, int sep
)
3968 p1
= strchr(p
, sep
);
3974 if (len
> buf_size
- 1)
3976 memcpy(buf
, p
, len
);
3983 int parse_host_src_port(struct sockaddr_in
*haddr
,
3984 struct sockaddr_in
*saddr
,
3985 const char *input_str
)
3987 char *str
= strdup(input_str
);
3988 char *host_str
= str
;
3990 const char *src_str2
;
3994 * Chop off any extra arguments at the end of the string which
3995 * would start with a comma, then fill in the src port information
3996 * if it was provided else use the "any address" and "any port".
3998 if ((ptr
= strchr(str
,',')))
4001 if ((src_str
= strchr(input_str
,'@'))) {
4006 if (parse_host_port(haddr
, host_str
) < 0)
4010 if (!src_str
|| *src_str
== '\0')
4013 if (parse_host_port(saddr
, src_str2
) < 0)
4024 int parse_host_port(struct sockaddr_in
*saddr
, const char *str
)
4032 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4034 saddr
->sin_family
= AF_INET
;
4035 if (buf
[0] == '\0') {
4036 saddr
->sin_addr
.s_addr
= 0;
4038 if (isdigit(buf
[0])) {
4039 if (!inet_aton(buf
, &saddr
->sin_addr
))
4042 if ((he
= gethostbyname(buf
)) == NULL
)
4044 saddr
->sin_addr
= *(struct in_addr
*)he
->h_addr
;
4047 port
= strtol(p
, (char **)&r
, 0);
4050 saddr
->sin_port
= htons(port
);
4055 static int parse_unix_path(struct sockaddr_un
*uaddr
, const char *str
)
4060 len
= MIN(108, strlen(str
));
4061 p
= strchr(str
, ',');
4063 len
= MIN(len
, p
- str
);
4065 memset(uaddr
, 0, sizeof(*uaddr
));
4067 uaddr
->sun_family
= AF_UNIX
;
4068 memcpy(uaddr
->sun_path
, str
, len
);
4074 /* find or alloc a new VLAN */
4075 VLANState
*qemu_find_vlan(int id
)
4077 VLANState
**pvlan
, *vlan
;
4078 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
4082 vlan
= qemu_mallocz(sizeof(VLANState
));
4087 pvlan
= &first_vlan
;
4088 while (*pvlan
!= NULL
)
4089 pvlan
= &(*pvlan
)->next
;
4094 VLANClientState
*qemu_new_vlan_client(VLANState
*vlan
,
4095 IOReadHandler
*fd_read
,
4096 IOCanRWHandler
*fd_can_read
,
4099 VLANClientState
*vc
, **pvc
;
4100 vc
= qemu_mallocz(sizeof(VLANClientState
));
4103 vc
->fd_read
= fd_read
;
4104 vc
->fd_can_read
= fd_can_read
;
4105 vc
->opaque
= opaque
;
4109 pvc
= &vlan
->first_client
;
4110 while (*pvc
!= NULL
)
4111 pvc
= &(*pvc
)->next
;
4116 void qemu_del_vlan_client(VLANClientState
*vc
)
4118 VLANClientState
**pvc
= &vc
->vlan
->first_client
;
4120 while (*pvc
!= NULL
)
4126 pvc
= &(*pvc
)->next
;
4129 int qemu_can_send_packet(VLANClientState
*vc1
)
4131 VLANState
*vlan
= vc1
->vlan
;
4132 VLANClientState
*vc
;
4134 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4136 if (vc
->fd_can_read
&& vc
->fd_can_read(vc
->opaque
))
4143 int qemu_send_packet(VLANClientState
*vc1
, const uint8_t *buf
, int size
)
4145 VLANState
*vlan
= vc1
->vlan
;
4146 VLANClientState
*vc
;
4150 printf("vlan %d send:\n", vlan
->id
);
4151 hex_dump(stdout
, buf
, size
);
4153 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4155 if (!vc
->fd_can_read
|| vc
->fd_can_read(vc
->opaque
)) {
4156 vc
->fd_read(vc
->opaque
, buf
, size
);
4165 static ssize_t
vc_sendv_compat(VLANClientState
*vc
, const struct iovec
*iov
,
4172 for (i
= 0; i
< iovcnt
; i
++) {
4175 len
= MIN(sizeof(buffer
) - offset
, iov
[i
].iov_len
);
4176 memcpy(buffer
+ offset
, iov
[i
].iov_base
, len
);
4180 vc
->fd_read(vc
->opaque
, buffer
, offset
);
4185 ssize_t
qemu_sendv_packet(VLANClientState
*vc1
, const struct iovec
*iov
,
4188 VLANState
*vlan
= vc1
->vlan
;
4189 VLANClientState
*vc
;
4190 ssize_t max_len
= 0;
4192 for (vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
4199 len
= vc
->fd_readv(vc
->opaque
, iov
, iovcnt
);
4200 else if (vc
->fd_read
)
4201 len
= vc_sendv_compat(vc
, iov
, iovcnt
);
4203 max_len
= MAX(max_len
, len
);
4209 #if defined(CONFIG_SLIRP)
4211 /* slirp network adapter */
4213 static int slirp_inited
;
4214 static VLANClientState
*slirp_vc
;
4216 int slirp_can_output(void)
4218 return !slirp_vc
|| qemu_can_send_packet(slirp_vc
);
4221 void slirp_output(const uint8_t *pkt
, int pkt_len
)
4224 printf("slirp output:\n");
4225 hex_dump(stdout
, pkt
, pkt_len
);
4229 qemu_send_packet(slirp_vc
, pkt
, pkt_len
);
4232 static void slirp_receive(void *opaque
, const uint8_t *buf
, int size
)
4235 printf("slirp input:\n");
4236 hex_dump(stdout
, buf
, size
);
4238 slirp_input(buf
, size
);
4241 static int net_slirp_init(VLANState
*vlan
)
4243 if (!slirp_inited
) {
4247 slirp_vc
= qemu_new_vlan_client(vlan
,
4248 slirp_receive
, NULL
, NULL
);
4249 snprintf(slirp_vc
->info_str
, sizeof(slirp_vc
->info_str
), "user redirector");
4253 static void net_slirp_redir(const char *redir_str
)
4258 struct in_addr guest_addr
;
4259 int host_port
, guest_port
;
4261 if (!slirp_inited
) {
4267 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4269 if (!strcmp(buf
, "tcp")) {
4271 } else if (!strcmp(buf
, "udp")) {
4277 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4279 host_port
= strtol(buf
, &r
, 0);
4283 if (get_str_sep(buf
, sizeof(buf
), &p
, ':') < 0)
4285 if (buf
[0] == '\0') {
4286 pstrcpy(buf
, sizeof(buf
), "10.0.2.15");
4288 if (!inet_aton(buf
, &guest_addr
))
4291 guest_port
= strtol(p
, &r
, 0);
4295 if (slirp_redir(is_udp
, host_port
, guest_addr
, guest_port
) < 0) {
4296 fprintf(stderr
, "qemu: could not set up redirection\n");
4301 fprintf(stderr
, "qemu: syntax: -redir [tcp|udp]:host-port:[guest-host]:guest-port\n");
4307 static char smb_dir
[1024];
4309 static void erase_dir(char *dir_name
)
4313 char filename
[1024];
4315 /* erase all the files in the directory */
4316 if ((d
= opendir(dir_name
)) != 0) {
4321 if (strcmp(de
->d_name
, ".") != 0 &&
4322 strcmp(de
->d_name
, "..") != 0) {
4323 snprintf(filename
, sizeof(filename
), "%s/%s",
4324 smb_dir
, de
->d_name
);
4325 if (unlink(filename
) != 0) /* is it a directory? */
4326 erase_dir(filename
);
4334 /* automatic user mode samba server configuration */
4335 static void smb_exit(void)
4340 /* automatic user mode samba server configuration */
4341 static void net_slirp_smb(const char *exported_dir
)
4343 char smb_conf
[1024];
4344 char smb_cmdline
[1024];
4347 if (!slirp_inited
) {
4352 /* XXX: better tmp dir construction */
4353 snprintf(smb_dir
, sizeof(smb_dir
), "/tmp/qemu-smb.%d", getpid());
4354 if (mkdir(smb_dir
, 0700) < 0) {
4355 fprintf(stderr
, "qemu: could not create samba server dir '%s'\n", smb_dir
);
4358 snprintf(smb_conf
, sizeof(smb_conf
), "%s/%s", smb_dir
, "smb.conf");
4360 f
= fopen(smb_conf
, "w");
4362 fprintf(stderr
, "qemu: could not create samba server configuration file '%s'\n", smb_conf
);
4369 "socket address=127.0.0.1\n"
4370 "pid directory=%s\n"
4371 "lock directory=%s\n"
4372 "log file=%s/log.smbd\n"
4373 "smb passwd file=%s/smbpasswd\n"
4374 "security = share\n"
4389 snprintf(smb_cmdline
, sizeof(smb_cmdline
), "%s -s %s",
4390 SMBD_COMMAND
, smb_conf
);
4392 slirp_add_exec(0, smb_cmdline
, 4, 139);
4395 #endif /* !defined(_WIN32) */
4396 void do_info_slirp(void)
4401 #endif /* CONFIG_SLIRP */
4405 int tap_has_vnet_hdr(void *opaque
)
4410 void tap_using_vnet_hdr(void *opaque
, int using_vnet_hdr
)
4414 #else /* !defined(_WIN32) */
4416 #ifndef IFF_VNET_HDR
4417 #define TAP_BUFSIZE 4096
4419 #include <linux/virtio_net.h>
4421 #define ETH_DATA_LEN 1500
4422 #define MAX_PACKET_LEN (ETH_HLEN + ETH_DATA_LEN)
4423 #define MAX_SKB_FRAGS ((65536/TARGET_PAGE_SIZE) + 2)
4424 #define TAP_BUFSIZE (sizeof(struct virtio_net_hdr) + MAX_PACKET_LEN + (MAX_SKB_FRAGS*TARGET_PAGE_SIZE))
4427 typedef struct TAPState
{
4428 VLANClientState
*vc
;
4430 char down_script
[1024];
4431 char buf
[TAP_BUFSIZE
];
4433 unsigned int has_vnet_hdr
: 1;
4434 unsigned int using_vnet_hdr
: 1;
4437 static ssize_t
tap_writev(void *opaque
, const struct iovec
*iov
,
4440 TAPState
*s
= opaque
;
4444 len
= writev(s
->fd
, iov
, iovcnt
);
4445 } while (len
== -1 && (errno
== EINTR
|| errno
== EAGAIN
));
4450 static ssize_t
tap_receive_iov(void *opaque
, const struct iovec
*iov
,
4454 TAPState
*s
= opaque
;
4456 if (s
->has_vnet_hdr
&& !s
->using_vnet_hdr
) {
4457 struct iovec
*iov_copy
;
4458 struct virtio_net_hdr hdr
= { 0, };
4460 iov_copy
= alloca(sizeof(struct iovec
) * (iovcnt
+ 1));
4462 iov_copy
[0].iov_base
= &hdr
;
4463 iov_copy
[0].iov_len
= sizeof(hdr
);
4465 memcpy(&iov_copy
[1], iov
, sizeof(struct iovec
) * iovcnt
);
4467 return tap_writev(opaque
, iov_copy
, iovcnt
+ 1);
4471 return tap_writev(opaque
, iov
, iovcnt
);
4474 static void tap_receive(void *opaque
, const uint8_t *buf
, int size
)
4476 struct iovec iov
[2];
4480 TAPState
*s
= opaque
;
4481 struct virtio_net_hdr hdr
= { 0, };
4483 if (s
->has_vnet_hdr
&& !s
->using_vnet_hdr
) {
4484 iov
[i
].iov_base
= &hdr
;
4485 iov
[i
].iov_len
= sizeof(hdr
);
4490 iov
[i
].iov_base
= (char *) buf
;
4491 iov
[i
].iov_len
= size
;
4494 tap_writev(opaque
, iov
, i
);
4497 static int tap_can_send(void *opaque
)
4499 TAPState
*s
= opaque
;
4500 VLANClientState
*vc
;
4501 int can_receive
= 0;
4503 /* Check to see if any of our clients can receive a packet */
4504 for (vc
= s
->vc
->vlan
->first_client
; vc
; vc
= vc
->next
) {
4505 /* Skip ourselves */
4509 if (!vc
->fd_can_read
) {
4510 /* no fd_can_read handler, they always can receive */
4513 can_receive
= vc
->fd_can_read(vc
->opaque
);
4515 /* Once someone can receive, we try to send a packet */
4523 static int tap_send_packet(TAPState
*s
)
4525 uint8_t *buf
= s
->buf
;
4529 if (s
->has_vnet_hdr
&& !s
->using_vnet_hdr
) {
4530 buf
+= sizeof(struct virtio_net_hdr
);
4531 size
-= sizeof(struct virtio_net_hdr
);
4535 return qemu_send_packet(s
->vc
, buf
, size
);
4538 static void tap_send(void *opaque
)
4540 TAPState
*s
= opaque
;
4542 /* First try to send any buffered packet */
4546 /* If noone can receive the packet, buffer it */
4547 err
= tap_send_packet(s
);
4552 /* Read packets until we hit EAGAIN */
4557 sbuf
.maxlen
= sizeof(s
->buf
);
4559 s
->size
= getmsg(s
->fd
, NULL
, &sbuf
, &f
) >=0 ? sbuf
.len
: -1;
4562 s
->size
= read(s
->fd
, s
->buf
, sizeof(s
->buf
));
4566 if (s
->size
== -1 && errno
== EINTR
)
4572 /* If noone can receive the packet, buffer it */
4573 err
= tap_send_packet(s
);
4577 } while (s
->size
> 0);
4580 int tap_has_vnet_hdr(void *opaque
)
4582 VLANClientState
*vc
= opaque
;
4583 TAPState
*s
= vc
->opaque
;
4585 return s
? s
->has_vnet_hdr
: 0;
4588 void tap_using_vnet_hdr(void *opaque
, int using_vnet_hdr
)
4590 VLANClientState
*vc
= opaque
;
4591 TAPState
*s
= vc
->opaque
;
4593 if (!s
|| !s
->has_vnet_hdr
)
4596 s
->using_vnet_hdr
= using_vnet_hdr
!= 0;
4599 static int tap_probe_vnet_hdr(int fd
)
4601 #if defined(TUNGETIFF) && defined(IFF_VNET_HDR)
4604 if (ioctl(fd
, TUNGETIFF
, &ifr
) != 0) {
4605 fprintf(stderr
, "TUNGETIFF ioctl() failed: %s\n", strerror(errno
));
4609 return ifr
.ifr_flags
& IFF_VNET_HDR
;
4615 #ifdef TUNSETOFFLOAD
4616 static void tap_set_offload(VLANClientState
*vc
, int csum
, int tso4
, int tso6
,
4619 TAPState
*s
= vc
->opaque
;
4620 unsigned int offload
= 0;
4623 offload
|= TUN_F_CSUM
;
4625 offload
|= TUN_F_TSO4
;
4627 offload
|= TUN_F_TSO6
;
4628 if ((tso4
|| tso6
) && ecn
)
4629 offload
|= TUN_F_TSO_ECN
;
4632 if (ioctl(s
->fd
, TUNSETOFFLOAD
, offload
) != 0)
4633 fprintf(stderr
, "TUNSETOFFLOAD ioctl() failed: %s\n",
4636 #endif /* TUNSETOFFLOAD */
4640 static TAPState
*net_tap_fd_init(VLANState
*vlan
, int fd
, int vnet_hdr
)
4644 s
= qemu_mallocz(sizeof(TAPState
));
4648 s
->has_vnet_hdr
= vnet_hdr
!= 0;
4649 s
->vc
= qemu_new_vlan_client(vlan
, tap_receive
, NULL
, s
);
4650 s
->vc
->fd_readv
= tap_receive_iov
;
4651 #ifdef TUNSETOFFLOAD
4652 s
->vc
->set_offload
= tap_set_offload
;
4654 qemu_set_fd_handler2(s
->fd
, tap_can_send
, tap_send
, NULL
, s
);
4655 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "tap: fd=%d", fd
);
4659 #if defined (_BSD) || defined (__FreeBSD_kernel__)
4660 static int tap_open(char *ifname
, int ifname_size
, int *vnet_hdr
)
4666 TFR(fd
= open("/dev/tap", O_RDWR
));
4668 fprintf(stderr
, "warning: could not open /dev/tap: no virtual network emulation\n");
4673 dev
= devname(s
.st_rdev
, S_IFCHR
);
4674 pstrcpy(ifname
, ifname_size
, dev
);
4676 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4679 #elif defined(__sun__)
4680 #define TUNNEWPPA (('T'<<16) | 0x0001)
4682 * Allocate TAP device, returns opened fd.
4683 * Stores dev name in the first arg(must be large enough).
4685 int tap_alloc(char *dev
, size_t dev_size
)
4687 int tap_fd
, if_fd
, ppa
= -1;
4688 static int ip_fd
= 0;
4691 static int arp_fd
= 0;
4692 int ip_muxid
, arp_muxid
;
4693 struct strioctl strioc_if
, strioc_ppa
;
4694 int link_type
= I_PLINK
;;
4696 char actual_name
[32] = "";
4698 memset(&ifr
, 0x0, sizeof(ifr
));
4702 while( *ptr
&& !isdigit((int)*ptr
) ) ptr
++;
4706 /* Check if IP device was opened */
4710 TFR(ip_fd
= open("/dev/udp", O_RDWR
, 0));
4712 syslog(LOG_ERR
, "Can't open /dev/ip (actually /dev/udp)");
4716 TFR(tap_fd
= open("/dev/tap", O_RDWR
, 0));
4718 syslog(LOG_ERR
, "Can't open /dev/tap");
4722 /* Assign a new PPA and get its unit number. */
4723 strioc_ppa
.ic_cmd
= TUNNEWPPA
;
4724 strioc_ppa
.ic_timout
= 0;
4725 strioc_ppa
.ic_len
= sizeof(ppa
);
4726 strioc_ppa
.ic_dp
= (char *)&ppa
;
4727 if ((ppa
= ioctl (tap_fd
, I_STR
, &strioc_ppa
)) < 0)
4728 syslog (LOG_ERR
, "Can't assign new interface");
4730 TFR(if_fd
= open("/dev/tap", O_RDWR
, 0));
4732 syslog(LOG_ERR
, "Can't open /dev/tap (2)");
4735 if(ioctl(if_fd
, I_PUSH
, "ip") < 0){
4736 syslog(LOG_ERR
, "Can't push IP module");
4740 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) < 0)
4741 syslog(LOG_ERR
, "Can't get flags\n");
4743 snprintf (actual_name
, 32, "tap%d", ppa
);
4744 pstrcpy(ifr
.lifr_name
, sizeof(ifr
.lifr_name
), actual_name
);
4747 /* Assign ppa according to the unit number returned by tun device */
4749 if (ioctl (if_fd
, SIOCSLIFNAME
, &ifr
) < 0)
4750 syslog (LOG_ERR
, "Can't set PPA %d", ppa
);
4751 if (ioctl(if_fd
, SIOCGLIFFLAGS
, &ifr
) <0)
4752 syslog (LOG_ERR
, "Can't get flags\n");
4753 /* Push arp module to if_fd */
4754 if (ioctl (if_fd
, I_PUSH
, "arp") < 0)
4755 syslog (LOG_ERR
, "Can't push ARP module (2)");
4757 /* Push arp module to ip_fd */
4758 if (ioctl (ip_fd
, I_POP
, NULL
) < 0)
4759 syslog (LOG_ERR
, "I_POP failed\n");
4760 if (ioctl (ip_fd
, I_PUSH
, "arp") < 0)
4761 syslog (LOG_ERR
, "Can't push ARP module (3)\n");
4763 TFR(arp_fd
= open ("/dev/tap", O_RDWR
, 0));
4765 syslog (LOG_ERR
, "Can't open %s\n", "/dev/tap");
4767 /* Set ifname to arp */
4768 strioc_if
.ic_cmd
= SIOCSLIFNAME
;
4769 strioc_if
.ic_timout
= 0;
4770 strioc_if
.ic_len
= sizeof(ifr
);
4771 strioc_if
.ic_dp
= (char *)&ifr
;
4772 if (ioctl(arp_fd
, I_STR
, &strioc_if
) < 0){
4773 syslog (LOG_ERR
, "Can't set ifname to arp\n");
4776 if((ip_muxid
= ioctl(ip_fd
, I_LINK
, if_fd
)) < 0){
4777 syslog(LOG_ERR
, "Can't link TAP device to IP");
4781 if ((arp_muxid
= ioctl (ip_fd
, link_type
, arp_fd
)) < 0)
4782 syslog (LOG_ERR
, "Can't link TAP device to ARP");
4786 memset(&ifr
, 0x0, sizeof(ifr
));
4787 pstrcpy(ifr
.lifr_name
, sizeof(ifr
.lifr_name
), actual_name
);
4788 ifr
.lifr_ip_muxid
= ip_muxid
;
4789 ifr
.lifr_arp_muxid
= arp_muxid
;
4791 if (ioctl (ip_fd
, SIOCSLIFMUXID
, &ifr
) < 0)
4793 ioctl (ip_fd
, I_PUNLINK
, arp_muxid
);
4794 ioctl (ip_fd
, I_PUNLINK
, ip_muxid
);
4795 syslog (LOG_ERR
, "Can't set multiplexor id");
4798 snprintf(dev
, dev_size
, "tap%d", ppa
);
4802 static int tap_open(char *ifname
, int ifname_size
, int *vnet_hdr
)
4806 if( (fd
= tap_alloc(dev
, sizeof(dev
))) < 0 ){
4807 fprintf(stderr
, "Cannot allocate TAP device\n");
4810 pstrcpy(ifname
, ifname_size
, dev
);
4811 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4815 static int tap_open(char *ifname
, int ifname_size
, int *vnet_hdr
)
4820 TFR(fd
= open("/dev/net/tun", O_RDWR
));
4822 fprintf(stderr
, "warning: could not open /dev/net/tun: no virtual network emulation\n");
4825 memset(&ifr
, 0, sizeof(ifr
));
4826 ifr
.ifr_flags
= IFF_TAP
| IFF_NO_PI
;
4828 #if defined(TUNGETFEATURES) && defined(IFF_VNET_HDR)
4830 unsigned int features
;
4832 if (ioctl(fd
, TUNGETFEATURES
, &features
) == 0 &&
4833 features
& IFF_VNET_HDR
) {
4835 ifr
.ifr_flags
|= IFF_VNET_HDR
;
4840 if (ifname
[0] != '\0')
4841 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, ifname
);
4843 pstrcpy(ifr
.ifr_name
, IFNAMSIZ
, "tap%d");
4844 ret
= ioctl(fd
, TUNSETIFF
, (void *) &ifr
);
4846 fprintf(stderr
, "warning: could not configure /dev/net/tun: no virtual network emulation\n");
4850 pstrcpy(ifname
, ifname_size
, ifr
.ifr_name
);
4851 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
4856 static int launch_script(const char *setup_script
, const char *ifname
, int fd
)
4862 /* try to launch network script */
4866 int open_max
= sysconf (_SC_OPEN_MAX
), i
;
4867 for (i
= 0; i
< open_max
; i
++)
4868 if (i
!= STDIN_FILENO
&&
4869 i
!= STDOUT_FILENO
&&
4870 i
!= STDERR_FILENO
&&
4875 *parg
++ = (char *)setup_script
;
4876 *parg
++ = (char *)ifname
;
4878 execv(setup_script
, args
);
4881 while (waitpid(pid
, &status
, 0) != pid
);
4882 if (!WIFEXITED(status
) ||
4883 WEXITSTATUS(status
) != 0) {
4884 fprintf(stderr
, "%s: could not launch network script\n",
4892 static int net_tap_init(VLANState
*vlan
, const char *ifname1
,
4893 const char *setup_script
, const char *down_script
)
4900 if (ifname1
!= NULL
)
4901 pstrcpy(ifname
, sizeof(ifname
), ifname1
);
4905 TFR(fd
= tap_open(ifname
, sizeof(ifname
), &vnet_hdr
));
4909 if (!setup_script
|| !strcmp(setup_script
, "no"))
4911 if (setup_script
[0] != '\0') {
4912 if (launch_script(setup_script
, ifname
, fd
))
4915 s
= net_tap_fd_init(vlan
, fd
, vnet_hdr
);
4919 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
4920 "tap: ifname=%s setup_script=%s", ifname
, setup_script
);
4921 if (down_script
&& strcmp(down_script
, "no"))
4922 snprintf(s
->down_script
, sizeof(s
->down_script
), "%s", down_script
);
4926 #endif /* !_WIN32 */
4928 #if defined(CONFIG_VDE)
4929 typedef struct VDEState
{
4930 VLANClientState
*vc
;
4934 static void vde_to_qemu(void *opaque
)
4936 VDEState
*s
= opaque
;
4940 size
= vde_recv(s
->vde
, buf
, sizeof(buf
), 0);
4942 qemu_send_packet(s
->vc
, buf
, size
);
4946 static void vde_from_qemu(void *opaque
, const uint8_t *buf
, int size
)
4948 VDEState
*s
= opaque
;
4951 ret
= vde_send(s
->vde
, buf
, size
, 0);
4952 if (ret
< 0 && errno
== EINTR
) {
4959 static int net_vde_init(VLANState
*vlan
, const char *sock
, int port
,
4960 const char *group
, int mode
)
4963 char *init_group
= strlen(group
) ? (char *)group
: NULL
;
4964 char *init_sock
= strlen(sock
) ? (char *)sock
: NULL
;
4966 struct vde_open_args args
= {
4968 .group
= init_group
,
4972 s
= qemu_mallocz(sizeof(VDEState
));
4975 s
->vde
= vde_open(init_sock
, "QEMU", &args
);
4980 s
->vc
= qemu_new_vlan_client(vlan
, vde_from_qemu
, NULL
, s
);
4981 qemu_set_fd_handler(vde_datafd(s
->vde
), vde_to_qemu
, NULL
, s
);
4982 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
), "vde: sock=%s fd=%d",
4983 sock
, vde_datafd(s
->vde
));
4988 /* network connection */
4989 typedef struct NetSocketState
{
4990 VLANClientState
*vc
;
4992 int state
; /* 0 = getting length, 1 = getting data */
4996 struct sockaddr_in dgram_dst
; /* contains inet host and port destination iff connectionless (SOCK_DGRAM) */
4999 typedef struct NetSocketListenState
{
5002 } NetSocketListenState
;
5004 /* XXX: we consider we can send the whole packet without blocking */
5005 static void net_socket_receive(void *opaque
, const uint8_t *buf
, int size
)
5007 NetSocketState
*s
= opaque
;
5011 send_all(s
->fd
, (const uint8_t *)&len
, sizeof(len
));
5012 send_all(s
->fd
, buf
, size
);
5015 static void net_socket_receive_dgram(void *opaque
, const uint8_t *buf
, int size
)
5017 NetSocketState
*s
= opaque
;
5018 sendto(s
->fd
, buf
, size
, 0,
5019 (struct sockaddr
*)&s
->dgram_dst
, sizeof(s
->dgram_dst
));
5022 static void net_socket_send(void *opaque
)
5024 NetSocketState
*s
= opaque
;
5029 size
= recv(s
->fd
, buf1
, sizeof(buf1
), 0);
5031 err
= socket_error();
5032 if (err
!= EWOULDBLOCK
)
5034 } else if (size
== 0) {
5035 /* end of connection */
5037 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
5043 /* reassemble a packet from the network */
5049 memcpy(s
->buf
+ s
->index
, buf
, l
);
5053 if (s
->index
== 4) {
5055 s
->packet_len
= ntohl(*(uint32_t *)s
->buf
);
5061 l
= s
->packet_len
- s
->index
;
5064 memcpy(s
->buf
+ s
->index
, buf
, l
);
5068 if (s
->index
>= s
->packet_len
) {
5069 qemu_send_packet(s
->vc
, s
->buf
, s
->packet_len
);
5078 static void net_socket_send_dgram(void *opaque
)
5080 NetSocketState
*s
= opaque
;
5083 size
= recv(s
->fd
, s
->buf
, sizeof(s
->buf
), 0);
5087 /* end of connection */
5088 qemu_set_fd_handler(s
->fd
, NULL
, NULL
, NULL
);
5091 qemu_send_packet(s
->vc
, s
->buf
, size
);
5094 static int net_socket_mcast_create(struct sockaddr_in
*mcastaddr
)
5099 if (!IN_MULTICAST(ntohl(mcastaddr
->sin_addr
.s_addr
))) {
5100 fprintf(stderr
, "qemu: error: specified mcastaddr \"%s\" (0x%08x) does not contain a multicast address\n",
5101 inet_ntoa(mcastaddr
->sin_addr
),
5102 (int)ntohl(mcastaddr
->sin_addr
.s_addr
));
5106 fd
= socket(PF_INET
, SOCK_DGRAM
, 0);
5108 perror("socket(PF_INET, SOCK_DGRAM)");
5113 ret
=setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
,
5114 (const char *)&val
, sizeof(val
));
5116 perror("setsockopt(SOL_SOCKET, SO_REUSEADDR)");
5120 ret
= bind(fd
, (struct sockaddr
*)mcastaddr
, sizeof(*mcastaddr
));
5126 /* Add host to multicast group */
5127 imr
.imr_multiaddr
= mcastaddr
->sin_addr
;
5128 imr
.imr_interface
.s_addr
= htonl(INADDR_ANY
);
5130 ret
= setsockopt(fd
, IPPROTO_IP
, IP_ADD_MEMBERSHIP
,
5131 (const char *)&imr
, sizeof(struct ip_mreq
));
5133 perror("setsockopt(IP_ADD_MEMBERSHIP)");
5137 /* Force mcast msgs to loopback (eg. several QEMUs in same host */
5139 ret
=setsockopt(fd
, IPPROTO_IP
, IP_MULTICAST_LOOP
,
5140 (const char *)&val
, sizeof(val
));
5142 perror("setsockopt(SOL_IP, IP_MULTICAST_LOOP)");
5146 socket_set_nonblock(fd
);
5154 static NetSocketState
*net_socket_fd_init_dgram(VLANState
*vlan
, int fd
,
5157 struct sockaddr_in saddr
;
5159 socklen_t saddr_len
;
5162 /* fd passed: multicast: "learn" dgram_dst address from bound address and save it
5163 * Because this may be "shared" socket from a "master" process, datagrams would be recv()
5164 * by ONLY ONE process: we must "clone" this dgram socket --jjo
5168 if (getsockname(fd
, (struct sockaddr
*) &saddr
, &saddr_len
) == 0) {
5170 if (saddr
.sin_addr
.s_addr
==0) {
5171 fprintf(stderr
, "qemu: error: init_dgram: fd=%d unbound, cannot setup multicast dst addr\n",
5175 /* clone dgram socket */
5176 newfd
= net_socket_mcast_create(&saddr
);
5178 /* error already reported by net_socket_mcast_create() */
5182 /* clone newfd to fd, close newfd */
5187 fprintf(stderr
, "qemu: error: init_dgram: fd=%d failed getsockname(): %s\n",
5188 fd
, strerror(errno
));
5193 s
= qemu_mallocz(sizeof(NetSocketState
));
5198 s
->vc
= qemu_new_vlan_client(vlan
, net_socket_receive_dgram
, NULL
, s
);
5199 qemu_set_fd_handler(s
->fd
, net_socket_send_dgram
, NULL
, s
);
5201 /* mcast: save bound address as dst */
5202 if (is_connected
) s
->dgram_dst
=saddr
;
5204 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5205 "socket: fd=%d (%s mcast=%s:%d)",
5206 fd
, is_connected
? "cloned" : "",
5207 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5211 static void net_socket_connect(void *opaque
)
5213 NetSocketState
*s
= opaque
;
5214 qemu_set_fd_handler(s
->fd
, net_socket_send
, NULL
, s
);
5217 static NetSocketState
*net_socket_fd_init_stream(VLANState
*vlan
, int fd
,
5221 s
= qemu_mallocz(sizeof(NetSocketState
));
5225 s
->vc
= qemu_new_vlan_client(vlan
,
5226 net_socket_receive
, NULL
, s
);
5227 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5228 "socket: fd=%d", fd
);
5230 net_socket_connect(s
);
5232 qemu_set_fd_handler(s
->fd
, NULL
, net_socket_connect
, s
);
5237 static NetSocketState
*net_socket_fd_init(VLANState
*vlan
, int fd
,
5240 int so_type
=-1, optlen
=sizeof(so_type
);
5242 if(getsockopt(fd
, SOL_SOCKET
, SO_TYPE
, (char *)&so_type
,
5243 (socklen_t
*)&optlen
)< 0) {
5244 fprintf(stderr
, "qemu: error: getsockopt(SO_TYPE) for fd=%d failed\n", fd
);
5249 return net_socket_fd_init_dgram(vlan
, fd
, is_connected
);
5251 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
5253 /* who knows ... this could be a eg. a pty, do warn and continue as stream */
5254 fprintf(stderr
, "qemu: warning: socket type=%d for fd=%d is not SOCK_DGRAM or SOCK_STREAM\n", so_type
, fd
);
5255 return net_socket_fd_init_stream(vlan
, fd
, is_connected
);
5260 static void net_socket_accept(void *opaque
)
5262 NetSocketListenState
*s
= opaque
;
5264 struct sockaddr_in saddr
;
5269 len
= sizeof(saddr
);
5270 fd
= accept(s
->fd
, (struct sockaddr
*)&saddr
, &len
);
5271 if (fd
< 0 && errno
!= EINTR
) {
5273 } else if (fd
>= 0) {
5277 s1
= net_socket_fd_init(s
->vlan
, fd
, 1);
5281 snprintf(s1
->vc
->info_str
, sizeof(s1
->vc
->info_str
),
5282 "socket: connection from %s:%d",
5283 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5287 static int net_socket_listen_init(VLANState
*vlan
, const char *host_str
)
5289 NetSocketListenState
*s
;
5291 struct sockaddr_in saddr
;
5293 if (parse_host_port(&saddr
, host_str
) < 0)
5296 s
= qemu_mallocz(sizeof(NetSocketListenState
));
5300 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5305 socket_set_nonblock(fd
);
5307 /* allow fast reuse */
5309 setsockopt(fd
, SOL_SOCKET
, SO_REUSEADDR
, (const char *)&val
, sizeof(val
));
5311 ret
= bind(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5316 ret
= listen(fd
, 0);
5323 qemu_set_fd_handler(fd
, net_socket_accept
, NULL
, s
);
5327 static int net_socket_connect_init(VLANState
*vlan
, const char *host_str
)
5330 int fd
, connected
, ret
, err
;
5331 struct sockaddr_in saddr
;
5333 if (parse_host_port(&saddr
, host_str
) < 0)
5336 fd
= socket(PF_INET
, SOCK_STREAM
, 0);
5341 socket_set_nonblock(fd
);
5345 ret
= connect(fd
, (struct sockaddr
*)&saddr
, sizeof(saddr
));
5347 err
= socket_error();
5348 if (err
== EINTR
|| err
== EWOULDBLOCK
) {
5349 } else if (err
== EINPROGRESS
) {
5352 } else if (err
== WSAEALREADY
) {
5365 s
= net_socket_fd_init(vlan
, fd
, connected
);
5368 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5369 "socket: connect to %s:%d",
5370 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5374 static int net_socket_mcast_init(VLANState
*vlan
, const char *host_str
)
5378 struct sockaddr_in saddr
;
5380 if (parse_host_port(&saddr
, host_str
) < 0)
5384 fd
= net_socket_mcast_create(&saddr
);
5388 s
= net_socket_fd_init(vlan
, fd
, 0);
5392 s
->dgram_dst
= saddr
;
5394 snprintf(s
->vc
->info_str
, sizeof(s
->vc
->info_str
),
5395 "socket: mcast=%s:%d",
5396 inet_ntoa(saddr
.sin_addr
), ntohs(saddr
.sin_port
));
5401 static const char *get_opt_name(char *buf
, int buf_size
, const char *p
)
5406 while (*p
!= '\0' && *p
!= '=') {
5407 if (q
&& (q
- buf
) < buf_size
- 1)
5417 static const char *get_opt_value(char *buf
, int buf_size
, const char *p
)
5422 while (*p
!= '\0') {
5424 if (*(p
+ 1) != ',')
5428 if (q
&& (q
- buf
) < buf_size
- 1)
5438 int get_param_value(char *buf
, int buf_size
,
5439 const char *tag
, const char *str
)
5446 p
= get_opt_name(option
, sizeof(option
), p
);
5450 if (!strcmp(tag
, option
)) {
5451 (void)get_opt_value(buf
, buf_size
, p
);
5454 p
= get_opt_value(NULL
, 0, p
);
5463 int check_params(char *buf
, int buf_size
,
5464 const char * const *params
, const char *str
)
5471 p
= get_opt_name(buf
, buf_size
, p
);
5475 for(i
= 0; params
[i
] != NULL
; i
++)
5476 if (!strcmp(params
[i
], buf
))
5478 if (params
[i
] == NULL
)
5480 p
= get_opt_value(NULL
, 0, p
);
5488 static int nic_get_free_idx(void)
5492 for (index
= 0; index
< MAX_NICS
; index
++)
5493 if (!nd_table
[index
].used
)
5498 int net_client_init(const char *device
, const char *p
)
5505 if (get_param_value(buf
, sizeof(buf
), "vlan", p
)) {
5506 vlan_id
= strtol(buf
, NULL
, 0);
5508 vlan
= qemu_find_vlan(vlan_id
);
5510 fprintf(stderr
, "Could not create vlan %d\n", vlan_id
);
5513 if (!strcmp(device
, "nic")) {
5516 int idx
= nic_get_free_idx();
5518 if (idx
== -1 || nb_nics
>= MAX_NICS
) {
5519 fprintf(stderr
, "Too Many NICs\n");
5522 nd
= &nd_table
[idx
];
5523 macaddr
= nd
->macaddr
;
5529 macaddr
[5] = 0x56 + idx
;
5531 if (get_param_value(buf
, sizeof(buf
), "macaddr", p
)) {
5532 if (parse_macaddr(macaddr
, buf
) < 0) {
5533 fprintf(stderr
, "invalid syntax for ethernet address\n");
5537 if (get_param_value(buf
, sizeof(buf
), "model", p
)) {
5538 nd
->model
= strdup(buf
);
5543 vlan
->nb_guest_devs
++;
5546 if (!strcmp(device
, "none")) {
5547 /* does nothing. It is needed to signal that no network cards
5552 if (!strcmp(device
, "user")) {
5553 if (get_param_value(buf
, sizeof(buf
), "hostname", p
)) {
5554 pstrcpy(slirp_hostname
, sizeof(slirp_hostname
), buf
);
5556 vlan
->nb_host_devs
++;
5557 ret
= net_slirp_init(vlan
);
5561 if (!strcmp(device
, "tap")) {
5563 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5564 fprintf(stderr
, "tap: no interface name\n");
5567 vlan
->nb_host_devs
++;
5568 ret
= tap_win32_init(vlan
, ifname
);
5571 if (!strcmp(device
, "tap")) {
5573 char setup_script
[1024], down_script
[1024];
5575 vlan
->nb_host_devs
++;
5576 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5577 fd
= strtol(buf
, NULL
, 0);
5578 fcntl(fd
, F_SETFL
, O_NONBLOCK
);
5580 if (net_tap_fd_init(vlan
, fd
, tap_probe_vnet_hdr(fd
)))
5583 if (get_param_value(ifname
, sizeof(ifname
), "ifname", p
) <= 0) {
5586 if (get_param_value(setup_script
, sizeof(setup_script
), "script", p
) == 0) {
5587 pstrcpy(setup_script
, sizeof(setup_script
), DEFAULT_NETWORK_SCRIPT
);
5589 if (get_param_value(down_script
, sizeof(down_script
), "downscript", p
) == 0) {
5590 pstrcpy(down_script
, sizeof(down_script
), DEFAULT_NETWORK_DOWN_SCRIPT
);
5592 ret
= net_tap_init(vlan
, ifname
, setup_script
, down_script
);
5596 if (!strcmp(device
, "socket")) {
5597 if (get_param_value(buf
, sizeof(buf
), "fd", p
) > 0) {
5599 fd
= strtol(buf
, NULL
, 0);
5601 if (net_socket_fd_init(vlan
, fd
, 1))
5603 } else if (get_param_value(buf
, sizeof(buf
), "listen", p
) > 0) {
5604 ret
= net_socket_listen_init(vlan
, buf
);
5605 } else if (get_param_value(buf
, sizeof(buf
), "connect", p
) > 0) {
5606 ret
= net_socket_connect_init(vlan
, buf
);
5607 } else if (get_param_value(buf
, sizeof(buf
), "mcast", p
) > 0) {
5608 ret
= net_socket_mcast_init(vlan
, buf
);
5610 fprintf(stderr
, "Unknown socket options: %s\n", p
);
5613 vlan
->nb_host_devs
++;
5616 if (!strcmp(device
, "vde")) {
5617 char vde_sock
[1024], vde_group
[512];
5618 int vde_port
, vde_mode
;
5619 vlan
->nb_host_devs
++;
5620 if (get_param_value(vde_sock
, sizeof(vde_sock
), "sock", p
) <= 0) {
5623 if (get_param_value(buf
, sizeof(buf
), "port", p
) > 0) {
5624 vde_port
= strtol(buf
, NULL
, 10);
5628 if (get_param_value(vde_group
, sizeof(vde_group
), "group", p
) <= 0) {
5629 vde_group
[0] = '\0';
5631 if (get_param_value(buf
, sizeof(buf
), "mode", p
) > 0) {
5632 vde_mode
= strtol(buf
, NULL
, 8);
5636 ret
= net_vde_init(vlan
, vde_sock
, vde_port
, vde_group
, vde_mode
);
5640 fprintf(stderr
, "Unknown network device: %s\n", device
);
5644 fprintf(stderr
, "Could not initialize device '%s'\n", device
);
5650 void net_client_uninit(NICInfo
*nd
)
5652 nd
->vlan
->nb_guest_devs
--; /* XXX: free vlan on last reference */
5655 free((void *)nd
->model
);
5658 static int net_client_parse(const char *str
)
5666 while (*p
!= '\0' && *p
!= ',') {
5667 if ((q
- device
) < sizeof(device
) - 1)
5675 return net_client_init(device
, p
);
5678 void do_info_network(void)
5681 VLANClientState
*vc
;
5683 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5684 term_printf("VLAN %d devices:\n", vlan
->id
);
5685 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
)
5686 term_printf(" %s\n", vc
->info_str
);
5690 /***********************************************************/
5691 /* Bluetooth support */
5694 static struct HCIInfo
*hci_table
[MAX_NICS
];
5696 static struct bt_vlan_s
{
5697 struct bt_scatternet_s net
;
5699 struct bt_vlan_s
*next
;
5702 /* find or alloc a new bluetooth "VLAN" */
5703 static struct bt_scatternet_s
*qemu_find_bt_vlan(int id
)
5705 struct bt_vlan_s
**pvlan
, *vlan
;
5706 for (vlan
= first_bt_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
5710 vlan
= qemu_mallocz(sizeof(struct bt_vlan_s
));
5712 pvlan
= &first_bt_vlan
;
5713 while (*pvlan
!= NULL
)
5714 pvlan
= &(*pvlan
)->next
;
5720 static void null_hci_send(struct HCIInfo
*hci
, const uint8_t *data
, int len
)
5724 static int null_hci_addr_set(struct HCIInfo
*hci
, const uint8_t *bd_addr
)
5729 static struct HCIInfo null_hci
= {
5730 .cmd_send
= null_hci_send
,
5731 .sco_send
= null_hci_send
,
5732 .acl_send
= null_hci_send
,
5733 .bdaddr_set
= null_hci_addr_set
,
5736 struct HCIInfo
*qemu_next_hci(void)
5738 if (cur_hci
== nb_hcis
)
5741 return hci_table
[cur_hci
++];
5744 /***********************************************************/
5745 /* QEMU Block devices */
5747 #define HD_ALIAS "index=%d,media=disk"
5749 #define CDROM_ALIAS "index=1,media=cdrom"
5751 #define CDROM_ALIAS "index=2,media=cdrom"
5753 #define FD_ALIAS "index=%d,if=floppy"
5754 #define PFLASH_ALIAS "if=pflash"
5755 #define MTD_ALIAS "if=mtd"
5756 #define SD_ALIAS "index=0,if=sd"
5758 static int drive_opt_get_free_idx(void)
5762 for (index
= 0; index
< MAX_DRIVES
; index
++)
5763 if (!drives_opt
[index
].used
) {
5764 drives_opt
[index
].used
= 1;
5771 static int drive_get_free_idx(void)
5775 for (index
= 0; index
< MAX_DRIVES
; index
++)
5776 if (!drives_table
[index
].used
) {
5777 drives_table
[index
].used
= 1;
5784 int drive_add(const char *file
, const char *fmt
, ...)
5787 int index
= drive_opt_get_free_idx();
5789 if (nb_drives_opt
>= MAX_DRIVES
|| index
== -1) {
5790 fprintf(stderr
, "qemu: too many drives\n");
5794 drives_opt
[index
].file
= file
;
5796 vsnprintf(drives_opt
[index
].opt
,
5797 sizeof(drives_opt
[0].opt
), fmt
, ap
);
5804 void drive_remove(int index
)
5806 drives_opt
[index
].used
= 0;
5810 int drive_get_index(BlockInterfaceType type
, int bus
, int unit
)
5814 /* seek interface, bus and unit */
5816 for (index
= 0; index
< MAX_DRIVES
; index
++)
5817 if (drives_table
[index
].type
== type
&&
5818 drives_table
[index
].bus
== bus
&&
5819 drives_table
[index
].unit
== unit
&&
5820 drives_table
[index
].used
)
5826 int drive_get_max_bus(BlockInterfaceType type
)
5832 for (index
= 0; index
< nb_drives
; index
++) {
5833 if(drives_table
[index
].type
== type
&&
5834 drives_table
[index
].bus
> max_bus
)
5835 max_bus
= drives_table
[index
].bus
;
5840 static void bdrv_format_print(void *opaque
, const char *name
)
5842 fprintf(stderr
, " %s", name
);
5845 void drive_uninit(BlockDriverState
*bdrv
)
5849 for (i
= 0; i
< MAX_DRIVES
; i
++)
5850 if (drives_table
[i
].bdrv
== bdrv
) {
5851 drives_table
[i
].bdrv
= NULL
;
5852 drives_table
[i
].used
= 0;
5853 drive_remove(drives_table
[i
].drive_opt_idx
);
5859 int drive_init(struct drive_opt
*arg
, int snapshot
,
5860 QEMUMachine
*machine
)
5865 const char *mediastr
= "";
5866 BlockInterfaceType type
;
5867 enum { MEDIA_DISK
, MEDIA_CDROM
} media
;
5868 int bus_id
, unit_id
;
5869 int cyls
, heads
, secs
, translation
;
5870 BlockDriverState
*bdrv
;
5871 BlockDriver
*drv
= NULL
;
5876 int drives_table_idx
;
5877 char *str
= arg
->opt
;
5878 static const char * const params
[] = { "bus", "unit", "if", "index",
5879 "cyls", "heads", "secs", "trans",
5880 "media", "snapshot", "file",
5881 "cache", "format", "boot", NULL
};
5883 if (check_params(buf
, sizeof(buf
), params
, str
) < 0) {
5884 fprintf(stderr
, "qemu: unknown parameter '%s' in '%s'\n",
5890 cyls
= heads
= secs
= 0;
5893 translation
= BIOS_ATA_TRANSLATION_AUTO
;
5897 if (machine
->use_scsi
) {
5899 max_devs
= MAX_SCSI_DEVS
;
5900 pstrcpy(devname
, sizeof(devname
), "scsi");
5903 max_devs
= MAX_IDE_DEVS
;
5904 pstrcpy(devname
, sizeof(devname
), "ide");
5908 /* extract parameters */
5910 if (get_param_value(buf
, sizeof(buf
), "bus", str
)) {
5911 bus_id
= strtol(buf
, NULL
, 0);
5913 fprintf(stderr
, "qemu: '%s' invalid bus id\n", str
);
5918 if (get_param_value(buf
, sizeof(buf
), "unit", str
)) {
5919 unit_id
= strtol(buf
, NULL
, 0);
5921 fprintf(stderr
, "qemu: '%s' invalid unit id\n", str
);
5926 if (get_param_value(buf
, sizeof(buf
), "if", str
)) {
5927 pstrcpy(devname
, sizeof(devname
), buf
);
5928 if (!strcmp(buf
, "ide")) {
5930 max_devs
= MAX_IDE_DEVS
;
5931 } else if (!strcmp(buf
, "scsi")) {
5933 max_devs
= MAX_SCSI_DEVS
;
5934 } else if (!strcmp(buf
, "floppy")) {
5937 } else if (!strcmp(buf
, "pflash")) {
5940 } else if (!strcmp(buf
, "mtd")) {
5943 } else if (!strcmp(buf
, "sd")) {
5946 } else if (!strcmp(buf
, "virtio")) {
5950 fprintf(stderr
, "qemu: '%s' unsupported bus type '%s'\n", str
, buf
);
5955 if (get_param_value(buf
, sizeof(buf
), "index", str
)) {
5956 index
= strtol(buf
, NULL
, 0);
5958 fprintf(stderr
, "qemu: '%s' invalid index\n", str
);
5963 if (get_param_value(buf
, sizeof(buf
), "cyls", str
)) {
5964 cyls
= strtol(buf
, NULL
, 0);
5967 if (get_param_value(buf
, sizeof(buf
), "heads", str
)) {
5968 heads
= strtol(buf
, NULL
, 0);
5971 if (get_param_value(buf
, sizeof(buf
), "secs", str
)) {
5972 secs
= strtol(buf
, NULL
, 0);
5975 if (cyls
|| heads
|| secs
) {
5976 if (cyls
< 1 || cyls
> 16383) {
5977 fprintf(stderr
, "qemu: '%s' invalid physical cyls number\n", str
);
5980 if (heads
< 1 || heads
> 16) {
5981 fprintf(stderr
, "qemu: '%s' invalid physical heads number\n", str
);
5984 if (secs
< 1 || secs
> 63) {
5985 fprintf(stderr
, "qemu: '%s' invalid physical secs number\n", str
);
5990 if (get_param_value(buf
, sizeof(buf
), "trans", str
)) {
5993 "qemu: '%s' trans must be used with cyls,heads and secs\n",
5997 if (!strcmp(buf
, "none"))
5998 translation
= BIOS_ATA_TRANSLATION_NONE
;
5999 else if (!strcmp(buf
, "lba"))
6000 translation
= BIOS_ATA_TRANSLATION_LBA
;
6001 else if (!strcmp(buf
, "auto"))
6002 translation
= BIOS_ATA_TRANSLATION_AUTO
;
6004 fprintf(stderr
, "qemu: '%s' invalid translation type\n", str
);
6009 if (get_param_value(buf
, sizeof(buf
), "media", str
)) {
6010 if (!strcmp(buf
, "disk")) {
6012 } else if (!strcmp(buf
, "cdrom")) {
6013 if (cyls
|| secs
|| heads
) {
6015 "qemu: '%s' invalid physical CHS format\n", str
);
6018 media
= MEDIA_CDROM
;
6020 fprintf(stderr
, "qemu: '%s' invalid media\n", str
);
6025 if (get_param_value(buf
, sizeof(buf
), "snapshot", str
)) {
6026 if (!strcmp(buf
, "on"))
6028 else if (!strcmp(buf
, "off"))
6031 fprintf(stderr
, "qemu: '%s' invalid snapshot option\n", str
);
6036 if (get_param_value(buf
, sizeof(buf
), "cache", str
)) {
6037 if (!strcmp(buf
, "off") || !strcmp(buf
, "none"))
6039 else if (!strcmp(buf
, "writethrough"))
6041 else if (!strcmp(buf
, "writeback"))
6044 fprintf(stderr
, "qemu: invalid cache option\n");
6049 if (get_param_value(buf
, sizeof(buf
), "format", str
)) {
6050 if (strcmp(buf
, "?") == 0) {
6051 fprintf(stderr
, "qemu: Supported formats:");
6052 bdrv_iterate_format(bdrv_format_print
, NULL
);
6053 fprintf(stderr
, "\n");
6056 drv
= bdrv_find_format(buf
);
6058 fprintf(stderr
, "qemu: '%s' invalid format\n", buf
);
6063 if (get_param_value(buf
, sizeof(buf
), "boot", str
)) {
6064 if (!strcmp(buf
, "on")) {
6065 if (extboot_drive
!= -1) {
6066 fprintf(stderr
, "qemu: two bootable drives specified\n");
6069 extboot_drive
= nb_drives
;
6070 } else if (strcmp(buf
, "off")) {
6071 fprintf(stderr
, "qemu: '%s' invalid boot option\n", str
);
6076 if (arg
->file
== NULL
)
6077 get_param_value(file
, sizeof(file
), "file", str
);
6079 pstrcpy(file
, sizeof(file
), arg
->file
);
6081 /* compute bus and unit according index */
6084 if (bus_id
!= 0 || unit_id
!= -1) {
6086 "qemu: '%s' index cannot be used with bus and unit\n", str
);
6094 unit_id
= index
% max_devs
;
6095 bus_id
= index
/ max_devs
;
6099 /* if user doesn't specify a unit_id,
6100 * try to find the first free
6103 if (unit_id
== -1) {
6105 while (drive_get_index(type
, bus_id
, unit_id
) != -1) {
6107 if (max_devs
&& unit_id
>= max_devs
) {
6108 unit_id
-= max_devs
;
6116 if (max_devs
&& unit_id
>= max_devs
) {
6117 fprintf(stderr
, "qemu: '%s' unit %d too big (max is %d)\n",
6118 str
, unit_id
, max_devs
- 1);
6123 * ignore multiple definitions
6126 if (drive_get_index(type
, bus_id
, unit_id
) != -1)
6131 if (type
== IF_IDE
|| type
== IF_SCSI
)
6132 mediastr
= (media
== MEDIA_CDROM
) ? "-cd" : "-hd";
6134 snprintf(buf
, sizeof(buf
), "%s%i%s%i",
6135 devname
, bus_id
, mediastr
, unit_id
);
6137 snprintf(buf
, sizeof(buf
), "%s%s%i",
6138 devname
, mediastr
, unit_id
);
6139 bdrv
= bdrv_new(buf
);
6140 drives_table_idx
= drive_get_free_idx();
6141 drives_table
[drives_table_idx
].bdrv
= bdrv
;
6142 drives_table
[drives_table_idx
].type
= type
;
6143 drives_table
[drives_table_idx
].bus
= bus_id
;
6144 drives_table
[drives_table_idx
].unit
= unit_id
;
6145 drives_table
[drives_table_idx
].drive_opt_idx
= arg
- drives_opt
;
6154 bdrv_set_geometry_hint(bdrv
, cyls
, heads
, secs
);
6155 bdrv_set_translation_hint(bdrv
, translation
);
6159 bdrv_set_type_hint(bdrv
, BDRV_TYPE_CDROM
);
6164 /* FIXME: This isn't really a floppy, but it's a reasonable
6167 bdrv_set_type_hint(bdrv
, BDRV_TYPE_FLOPPY
);
6178 bdrv_flags
|= BDRV_O_SNAPSHOT
;
6179 cache
= 2; /* always use write-back with snapshot */
6181 if (cache
== 0) /* no caching */
6182 bdrv_flags
|= BDRV_O_NOCACHE
;
6183 else if (cache
== 2) /* write-back */
6184 bdrv_flags
|= BDRV_O_CACHE_WB
;
6185 if (bdrv_open2(bdrv
, file
, bdrv_flags
, drv
) < 0 || qemu_key_check(bdrv
, file
)) {
6186 fprintf(stderr
, "qemu: could not open disk image %s\n",
6190 return drives_table_idx
;
6193 /***********************************************************/
6196 static USBPort
*used_usb_ports
;
6197 static USBPort
*free_usb_ports
;
6199 /* ??? Maybe change this to register a hub to keep track of the topology. */
6200 void qemu_register_usb_port(USBPort
*port
, void *opaque
, int index
,
6201 usb_attachfn attach
)
6203 port
->opaque
= opaque
;
6204 port
->index
= index
;
6205 port
->attach
= attach
;
6206 port
->next
= free_usb_ports
;
6207 free_usb_ports
= port
;
6210 int usb_device_add_dev(USBDevice
*dev
)
6214 /* Find a USB port to add the device to. */
6215 port
= free_usb_ports
;
6219 /* Create a new hub and chain it on. */
6220 free_usb_ports
= NULL
;
6221 port
->next
= used_usb_ports
;
6222 used_usb_ports
= port
;
6224 hub
= usb_hub_init(VM_USB_HUB_SIZE
);
6225 usb_attach(port
, hub
);
6226 port
= free_usb_ports
;
6229 free_usb_ports
= port
->next
;
6230 port
->next
= used_usb_ports
;
6231 used_usb_ports
= port
;
6232 usb_attach(port
, dev
);
6236 static int usb_device_add(const char *devname
)
6241 if (!free_usb_ports
)
6244 if (strstart(devname
, "host:", &p
)) {
6245 dev
= usb_host_device_open(p
);
6246 } else if (!strcmp(devname
, "mouse")) {
6247 dev
= usb_mouse_init();
6248 } else if (!strcmp(devname
, "tablet")) {
6249 dev
= usb_tablet_init();
6250 } else if (!strcmp(devname
, "keyboard")) {
6251 dev
= usb_keyboard_init();
6252 } else if (strstart(devname
, "disk:", &p
)) {
6253 dev
= usb_msd_init(p
);
6254 } else if (!strcmp(devname
, "wacom-tablet")) {
6255 dev
= usb_wacom_init();
6256 } else if (strstart(devname
, "serial:", &p
)) {
6257 dev
= usb_serial_init(p
);
6258 #ifdef CONFIG_BRLAPI
6259 } else if (!strcmp(devname
, "braille")) {
6260 dev
= usb_baum_init();
6262 } else if (strstart(devname
, "net:", &p
)) {
6265 if (net_client_init("nic", p
) < 0)
6267 nd_table
[nic
].model
= "usb";
6268 dev
= usb_net_init(&nd_table
[nic
]);
6275 return usb_device_add_dev(dev
);
6278 int usb_device_del_addr(int bus_num
, int addr
)
6284 if (!used_usb_ports
)
6290 lastp
= &used_usb_ports
;
6291 port
= used_usb_ports
;
6292 while (port
&& port
->dev
->addr
!= addr
) {
6293 lastp
= &port
->next
;
6301 *lastp
= port
->next
;
6302 usb_attach(port
, NULL
);
6303 dev
->handle_destroy(dev
);
6304 port
->next
= free_usb_ports
;
6305 free_usb_ports
= port
;
6309 static int usb_device_del(const char *devname
)
6314 if (strstart(devname
, "host:", &p
))
6315 return usb_host_device_close(p
);
6317 if (!used_usb_ports
)
6320 p
= strchr(devname
, '.');
6323 bus_num
= strtoul(devname
, NULL
, 0);
6324 addr
= strtoul(p
+ 1, NULL
, 0);
6326 return usb_device_del_addr(bus_num
, addr
);
6329 void do_usb_add(const char *devname
)
6331 usb_device_add(devname
);
6334 void do_usb_del(const char *devname
)
6336 usb_device_del(devname
);
6343 const char *speed_str
;
6346 term_printf("USB support not enabled\n");
6350 for (port
= used_usb_ports
; port
; port
= port
->next
) {
6354 switch(dev
->speed
) {
6358 case USB_SPEED_FULL
:
6361 case USB_SPEED_HIGH
:
6368 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
6369 0, dev
->addr
, speed_str
, dev
->devname
);
6373 /***********************************************************/
6374 /* PCMCIA/Cardbus */
6376 static struct pcmcia_socket_entry_s
{
6377 struct pcmcia_socket_s
*socket
;
6378 struct pcmcia_socket_entry_s
*next
;
6379 } *pcmcia_sockets
= 0;
6381 void pcmcia_socket_register(struct pcmcia_socket_s
*socket
)
6383 struct pcmcia_socket_entry_s
*entry
;
6385 entry
= qemu_malloc(sizeof(struct pcmcia_socket_entry_s
));
6386 entry
->socket
= socket
;
6387 entry
->next
= pcmcia_sockets
;
6388 pcmcia_sockets
= entry
;
6391 void pcmcia_socket_unregister(struct pcmcia_socket_s
*socket
)
6393 struct pcmcia_socket_entry_s
*entry
, **ptr
;
6395 ptr
= &pcmcia_sockets
;
6396 for (entry
= *ptr
; entry
; ptr
= &entry
->next
, entry
= *ptr
)
6397 if (entry
->socket
== socket
) {
6403 void pcmcia_info(void)
6405 struct pcmcia_socket_entry_s
*iter
;
6406 if (!pcmcia_sockets
)
6407 term_printf("No PCMCIA sockets\n");
6409 for (iter
= pcmcia_sockets
; iter
; iter
= iter
->next
)
6410 term_printf("%s: %s\n", iter
->socket
->slot_string
,
6411 iter
->socket
->attached
? iter
->socket
->card_string
:
6415 /***********************************************************/
6418 static void dumb_update(DisplayState
*ds
, int x
, int y
, int w
, int h
)
6422 static void dumb_resize(DisplayState
*ds
, int w
, int h
)
6426 static void dumb_refresh(DisplayState
*ds
)
6428 #if defined(CONFIG_SDL)
6433 static void dumb_display_init(DisplayState
*ds
)
6438 ds
->dpy_update
= dumb_update
;
6439 ds
->dpy_resize
= dumb_resize
;
6440 ds
->dpy_refresh
= dumb_refresh
;
6441 ds
->gui_timer_interval
= 500;
6445 /***********************************************************/
6448 #define MAX_IO_HANDLERS 64
6450 typedef struct IOHandlerRecord
{
6452 IOCanRWHandler
*fd_read_poll
;
6454 IOHandler
*fd_write
;
6457 /* temporary data */
6459 struct IOHandlerRecord
*next
;
6462 static IOHandlerRecord
*first_io_handler
;
6464 /* XXX: fd_read_poll should be suppressed, but an API change is
6465 necessary in the character devices to suppress fd_can_read(). */
6466 int qemu_set_fd_handler2(int fd
,
6467 IOCanRWHandler
*fd_read_poll
,
6469 IOHandler
*fd_write
,
6472 IOHandlerRecord
**pioh
, *ioh
;
6474 if (!fd_read
&& !fd_write
) {
6475 pioh
= &first_io_handler
;
6480 if (ioh
->fd
== fd
) {
6487 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
6491 ioh
= qemu_mallocz(sizeof(IOHandlerRecord
));
6494 ioh
->next
= first_io_handler
;
6495 first_io_handler
= ioh
;
6498 ioh
->fd_read_poll
= fd_read_poll
;
6499 ioh
->fd_read
= fd_read
;
6500 ioh
->fd_write
= fd_write
;
6501 ioh
->opaque
= opaque
;
6508 int qemu_set_fd_handler(int fd
,
6510 IOHandler
*fd_write
,
6513 return qemu_set_fd_handler2(fd
, NULL
, fd_read
, fd_write
, opaque
);
6516 /***********************************************************/
6517 /* Polling handling */
6519 typedef struct PollingEntry
{
6522 struct PollingEntry
*next
;
6525 static PollingEntry
*first_polling_entry
;
6527 int qemu_add_polling_cb(PollingFunc
*func
, void *opaque
)
6529 PollingEntry
**ppe
, *pe
;
6530 pe
= qemu_mallocz(sizeof(PollingEntry
));
6534 pe
->opaque
= opaque
;
6535 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
);
6540 void qemu_del_polling_cb(PollingFunc
*func
, void *opaque
)
6542 PollingEntry
**ppe
, *pe
;
6543 for(ppe
= &first_polling_entry
; *ppe
!= NULL
; ppe
= &(*ppe
)->next
) {
6545 if (pe
->func
== func
&& pe
->opaque
== opaque
) {
6554 /***********************************************************/
6555 /* Wait objects support */
6556 typedef struct WaitObjects
{
6558 HANDLE events
[MAXIMUM_WAIT_OBJECTS
+ 1];
6559 WaitObjectFunc
*func
[MAXIMUM_WAIT_OBJECTS
+ 1];
6560 void *opaque
[MAXIMUM_WAIT_OBJECTS
+ 1];
6563 static WaitObjects wait_objects
= {0};
6565 int qemu_add_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6567 WaitObjects
*w
= &wait_objects
;
6569 if (w
->num
>= MAXIMUM_WAIT_OBJECTS
)
6571 w
->events
[w
->num
] = handle
;
6572 w
->func
[w
->num
] = func
;
6573 w
->opaque
[w
->num
] = opaque
;
6578 void qemu_del_wait_object(HANDLE handle
, WaitObjectFunc
*func
, void *opaque
)
6581 WaitObjects
*w
= &wait_objects
;
6584 for (i
= 0; i
< w
->num
; i
++) {
6585 if (w
->events
[i
] == handle
)
6588 w
->events
[i
] = w
->events
[i
+ 1];
6589 w
->func
[i
] = w
->func
[i
+ 1];
6590 w
->opaque
[i
] = w
->opaque
[i
+ 1];
6598 #define SELF_ANNOUNCE_ROUNDS 5
6599 #define ETH_P_EXPERIMENTAL 0x01F1 /* just a number */
6600 //#define ETH_P_EXPERIMENTAL 0x0012 /* make it the size of the packet */
6601 #define EXPERIMENTAL_MAGIC 0xf1f23f4f
6603 static int announce_self_create(uint8_t *buf
,
6606 uint32_t magic
= EXPERIMENTAL_MAGIC
;
6607 uint16_t proto
= htons(ETH_P_EXPERIMENTAL
);
6609 /* FIXME: should we send a different packet (arp/rarp/ping)? */
6611 memset(buf
, 0xff, 6); /* h_dst */
6612 memcpy(buf
+ 6, mac_addr
, 6); /* h_src */
6613 memcpy(buf
+ 12, &proto
, 2); /* h_proto */
6614 memcpy(buf
+ 14, &magic
, 4); /* magic */
6616 return 18; /* len */
6619 void qemu_announce_self(void)
6623 VLANClientState
*vc
;
6626 for (i
= 0; i
< nb_nics
; i
++) {
6627 len
= announce_self_create(buf
, nd_table
[i
].macaddr
);
6628 vlan
= nd_table
[i
].vlan
;
6629 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
6630 for (j
=0; j
< SELF_ANNOUNCE_ROUNDS
; j
++)
6631 vc
->fd_read(vc
->opaque
, buf
, len
);
6636 /***********************************************************/
6637 /* savevm/loadvm support */
6639 #define IO_BUF_SIZE 32768
6642 QEMUFilePutBufferFunc
*put_buffer
;
6643 QEMUFileGetBufferFunc
*get_buffer
;
6644 QEMUFileCloseFunc
*close
;
6645 QEMUFileRateLimit
*rate_limit
;
6649 int64_t buf_offset
; /* start of buffer when writing, end of buffer
6652 int buf_size
; /* 0 when writing */
6653 uint8_t buf
[IO_BUF_SIZE
];
6658 typedef struct QEMUFileSocket
6664 static int socket_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6666 QEMUFileSocket
*s
= opaque
;
6670 len
= recv(s
->fd
, buf
, size
, 0);
6671 } while (len
== -1 && socket_error() == EINTR
);
6674 len
= -socket_error();
6679 static int socket_close(void *opaque
)
6681 QEMUFileSocket
*s
= opaque
;
6686 QEMUFile
*qemu_fopen_socket(int fd
)
6688 QEMUFileSocket
*s
= qemu_mallocz(sizeof(QEMUFileSocket
));
6694 s
->file
= qemu_fopen_ops(s
, NULL
, socket_get_buffer
, socket_close
, NULL
);
6698 typedef struct QEMUFileStdio
6703 static int file_put_buffer(void *opaque
, const uint8_t *buf
,
6704 int64_t pos
, int size
)
6706 QEMUFileStdio
*s
= opaque
;
6707 fseek(s
->outfile
, pos
, SEEK_SET
);
6708 fwrite(buf
, 1, size
, s
->outfile
);
6712 static int file_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6714 QEMUFileStdio
*s
= opaque
;
6715 fseek(s
->outfile
, pos
, SEEK_SET
);
6716 return fread(buf
, 1, size
, s
->outfile
);
6719 static int file_close(void *opaque
)
6721 QEMUFileStdio
*s
= opaque
;
6727 QEMUFile
*qemu_fopen(const char *filename
, const char *mode
)
6731 s
= qemu_mallocz(sizeof(QEMUFileStdio
));
6735 s
->outfile
= fopen(filename
, mode
);
6739 if (!strcmp(mode
, "wb"))
6740 return qemu_fopen_ops(s
, file_put_buffer
, NULL
, file_close
, NULL
);
6741 else if (!strcmp(mode
, "rb"))
6742 return qemu_fopen_ops(s
, NULL
, file_get_buffer
, file_close
, NULL
);
6751 typedef struct QEMUFileBdrv
6753 BlockDriverState
*bs
;
6754 int64_t base_offset
;
6757 static int bdrv_put_buffer(void *opaque
, const uint8_t *buf
,
6758 int64_t pos
, int size
)
6760 QEMUFileBdrv
*s
= opaque
;
6761 bdrv_pwrite(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6765 static int bdrv_get_buffer(void *opaque
, uint8_t *buf
, int64_t pos
, int size
)
6767 QEMUFileBdrv
*s
= opaque
;
6768 return bdrv_pread(s
->bs
, s
->base_offset
+ pos
, buf
, size
);
6771 static int bdrv_fclose(void *opaque
)
6773 QEMUFileBdrv
*s
= opaque
;
6778 static QEMUFile
*qemu_fopen_bdrv(BlockDriverState
*bs
, int64_t offset
, int is_writable
)
6782 s
= qemu_mallocz(sizeof(QEMUFileBdrv
));
6787 s
->base_offset
= offset
;
6790 return qemu_fopen_ops(s
, bdrv_put_buffer
, NULL
, bdrv_fclose
, NULL
);
6792 return qemu_fopen_ops(s
, NULL
, bdrv_get_buffer
, bdrv_fclose
, NULL
);
6795 QEMUFile
*qemu_fopen_ops(void *opaque
, QEMUFilePutBufferFunc
*put_buffer
,
6796 QEMUFileGetBufferFunc
*get_buffer
,
6797 QEMUFileCloseFunc
*close
,
6798 QEMUFileRateLimit
*rate_limit
)
6802 f
= qemu_mallocz(sizeof(QEMUFile
));
6807 f
->put_buffer
= put_buffer
;
6808 f
->get_buffer
= get_buffer
;
6810 f
->rate_limit
= rate_limit
;
6816 int qemu_file_has_error(QEMUFile
*f
)
6818 return f
->has_error
;
6821 void qemu_fflush(QEMUFile
*f
)
6826 if (f
->is_write
&& f
->buf_index
> 0) {
6829 len
= f
->put_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, f
->buf_index
);
6831 f
->buf_offset
+= f
->buf_index
;
6838 static void qemu_fill_buffer(QEMUFile
*f
)
6848 len
= f
->get_buffer(f
->opaque
, f
->buf
, f
->buf_offset
, IO_BUF_SIZE
);
6852 f
->buf_offset
+= len
;
6853 } else if (len
!= -EAGAIN
)
6857 int qemu_fclose(QEMUFile
*f
)
6862 ret
= f
->close(f
->opaque
);
6867 void qemu_file_put_notify(QEMUFile
*f
)
6869 f
->put_buffer(f
->opaque
, NULL
, 0, 0);
6872 void qemu_put_buffer(QEMUFile
*f
, const uint8_t *buf
, int size
)
6876 if (!f
->has_error
&& f
->is_write
== 0 && f
->buf_index
> 0) {
6878 "Attempted to write to buffer while read buffer is not empty\n");
6882 while (!f
->has_error
&& size
> 0) {
6883 l
= IO_BUF_SIZE
- f
->buf_index
;
6886 memcpy(f
->buf
+ f
->buf_index
, buf
, l
);
6891 if (f
->buf_index
>= IO_BUF_SIZE
)
6896 void qemu_put_byte(QEMUFile
*f
, int v
)
6898 if (!f
->has_error
&& f
->is_write
== 0 && f
->buf_index
> 0) {
6900 "Attempted to write to buffer while read buffer is not empty\n");
6904 f
->buf
[f
->buf_index
++] = v
;
6906 if (f
->buf_index
>= IO_BUF_SIZE
)
6910 int qemu_get_buffer(QEMUFile
*f
, uint8_t *buf
, int size1
)
6919 l
= f
->buf_size
- f
->buf_index
;
6921 qemu_fill_buffer(f
);
6922 l
= f
->buf_size
- f
->buf_index
;
6928 memcpy(buf
, f
->buf
+ f
->buf_index
, l
);
6933 return size1
- size
;
6936 int qemu_get_byte(QEMUFile
*f
)
6941 if (f
->buf_index
>= f
->buf_size
) {
6942 qemu_fill_buffer(f
);
6943 if (f
->buf_index
>= f
->buf_size
)
6946 return f
->buf
[f
->buf_index
++];
6949 int64_t qemu_ftell(QEMUFile
*f
)
6951 return f
->buf_offset
- f
->buf_size
+ f
->buf_index
;
6954 int64_t qemu_fseek(QEMUFile
*f
, int64_t pos
, int whence
)
6956 if (whence
== SEEK_SET
) {
6958 } else if (whence
== SEEK_CUR
) {
6959 pos
+= qemu_ftell(f
);
6961 /* SEEK_END not supported */
6964 if (f
->put_buffer
) {
6966 f
->buf_offset
= pos
;
6968 f
->buf_offset
= pos
;
6975 int qemu_file_rate_limit(QEMUFile
*f
)
6978 return f
->rate_limit(f
->opaque
);
6983 void qemu_put_be16(QEMUFile
*f
, unsigned int v
)
6985 qemu_put_byte(f
, v
>> 8);
6986 qemu_put_byte(f
, v
);
6989 void qemu_put_be32(QEMUFile
*f
, unsigned int v
)
6991 qemu_put_byte(f
, v
>> 24);
6992 qemu_put_byte(f
, v
>> 16);
6993 qemu_put_byte(f
, v
>> 8);
6994 qemu_put_byte(f
, v
);
6997 void qemu_put_be64(QEMUFile
*f
, uint64_t v
)
6999 qemu_put_be32(f
, v
>> 32);
7000 qemu_put_be32(f
, v
);
7003 unsigned int qemu_get_be16(QEMUFile
*f
)
7006 v
= qemu_get_byte(f
) << 8;
7007 v
|= qemu_get_byte(f
);
7011 unsigned int qemu_get_be32(QEMUFile
*f
)
7014 v
= qemu_get_byte(f
) << 24;
7015 v
|= qemu_get_byte(f
) << 16;
7016 v
|= qemu_get_byte(f
) << 8;
7017 v
|= qemu_get_byte(f
);
7021 uint64_t qemu_get_be64(QEMUFile
*f
)
7024 v
= (uint64_t)qemu_get_be32(f
) << 32;
7025 v
|= qemu_get_be32(f
);
7029 typedef struct SaveStateEntry
{
7034 SaveLiveStateHandler
*save_live_state
;
7035 SaveStateHandler
*save_state
;
7036 LoadStateHandler
*load_state
;
7038 struct SaveStateEntry
*next
;
7041 static SaveStateEntry
*first_se
;
7043 /* TODO: Individual devices generally have very little idea about the rest
7044 of the system, so instance_id should be removed/replaced.
7045 Meanwhile pass -1 as instance_id if you do not already have a clearly
7046 distinguishing id for all instances of your device class. */
7047 int register_savevm_live(const char *idstr
,
7050 SaveLiveStateHandler
*save_live_state
,
7051 SaveStateHandler
*save_state
,
7052 LoadStateHandler
*load_state
,
7055 SaveStateEntry
*se
, **pse
;
7056 static int global_section_id
;
7058 se
= qemu_malloc(sizeof(SaveStateEntry
));
7061 pstrcpy(se
->idstr
, sizeof(se
->idstr
), idstr
);
7062 se
->instance_id
= (instance_id
== -1) ? 0 : instance_id
;
7063 se
->version_id
= version_id
;
7064 se
->section_id
= global_section_id
++;
7065 se
->save_live_state
= save_live_state
;
7066 se
->save_state
= save_state
;
7067 se
->load_state
= load_state
;
7068 se
->opaque
= opaque
;
7071 /* add at the end of list */
7073 while (*pse
!= NULL
) {
7074 if (instance_id
== -1
7075 && strcmp(se
->idstr
, (*pse
)->idstr
) == 0
7076 && se
->instance_id
<= (*pse
)->instance_id
)
7077 se
->instance_id
= (*pse
)->instance_id
+ 1;
7078 pse
= &(*pse
)->next
;
7084 int register_savevm(const char *idstr
,
7087 SaveStateHandler
*save_state
,
7088 LoadStateHandler
*load_state
,
7091 return register_savevm_live(idstr
, instance_id
, version_id
,
7092 NULL
, save_state
, load_state
, opaque
);
7095 #define QEMU_VM_FILE_MAGIC 0x5145564d
7096 #define QEMU_VM_FILE_VERSION_COMPAT 0x00000002
7097 #define QEMU_VM_FILE_VERSION 0x00000003
7099 #define QEMU_VM_EOF 0x00
7100 #define QEMU_VM_SECTION_START 0x01
7101 #define QEMU_VM_SECTION_PART 0x02
7102 #define QEMU_VM_SECTION_END 0x03
7103 #define QEMU_VM_SECTION_FULL 0x04
7105 int qemu_savevm_state_begin(QEMUFile
*f
)
7109 qemu_put_be32(f
, QEMU_VM_FILE_MAGIC
);
7110 qemu_put_be32(f
, QEMU_VM_FILE_VERSION
);
7112 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
7115 if (se
->save_live_state
== NULL
)
7119 qemu_put_byte(f
, QEMU_VM_SECTION_START
);
7120 qemu_put_be32(f
, se
->section_id
);
7123 len
= strlen(se
->idstr
);
7124 qemu_put_byte(f
, len
);
7125 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
7127 qemu_put_be32(f
, se
->instance_id
);
7128 qemu_put_be32(f
, se
->version_id
);
7130 se
->save_live_state(f
, QEMU_VM_SECTION_START
, se
->opaque
);
7133 if (qemu_file_has_error(f
))
7139 int qemu_savevm_state_iterate(QEMUFile
*f
)
7144 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
7145 if (se
->save_live_state
== NULL
)
7149 qemu_put_byte(f
, QEMU_VM_SECTION_PART
);
7150 qemu_put_be32(f
, se
->section_id
);
7152 ret
&= !!se
->save_live_state(f
, QEMU_VM_SECTION_PART
, se
->opaque
);
7158 if (qemu_file_has_error(f
))
7164 int qemu_savevm_state_complete(QEMUFile
*f
)
7168 for (se
= first_se
; se
!= NULL
; se
= se
->next
) {
7169 if (se
->save_live_state
== NULL
)
7173 qemu_put_byte(f
, QEMU_VM_SECTION_END
);
7174 qemu_put_be32(f
, se
->section_id
);
7176 se
->save_live_state(f
, QEMU_VM_SECTION_END
, se
->opaque
);
7179 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
7182 if (se
->save_state
== NULL
)
7186 qemu_put_byte(f
, QEMU_VM_SECTION_FULL
);
7187 qemu_put_be32(f
, se
->section_id
);
7190 len
= strlen(se
->idstr
);
7191 qemu_put_byte(f
, len
);
7192 qemu_put_buffer(f
, (uint8_t *)se
->idstr
, len
);
7194 qemu_put_be32(f
, se
->instance_id
);
7195 qemu_put_be32(f
, se
->version_id
);
7197 se
->save_state(f
, se
->opaque
);
7200 qemu_put_byte(f
, QEMU_VM_EOF
);
7202 if (qemu_file_has_error(f
))
7208 int qemu_savevm_state(QEMUFile
*f
)
7210 int saved_vm_running
;
7213 saved_vm_running
= vm_running
;
7218 ret
= qemu_savevm_state_begin(f
);
7223 ret
= qemu_savevm_state_iterate(f
);
7228 ret
= qemu_savevm_state_complete(f
);
7231 if (qemu_file_has_error(f
))
7234 if (!ret
&& saved_vm_running
)
7240 static SaveStateEntry
*find_se(const char *idstr
, int instance_id
)
7244 for(se
= first_se
; se
!= NULL
; se
= se
->next
) {
7245 if (!strcmp(se
->idstr
, idstr
) &&
7246 instance_id
== se
->instance_id
)
7252 typedef struct LoadStateEntry
{
7256 struct LoadStateEntry
*next
;
7259 static int qemu_loadvm_state_v2(QEMUFile
*f
)
7262 int len
, ret
, instance_id
, record_len
, version_id
;
7263 int64_t total_len
, end_pos
, cur_pos
;
7266 total_len
= qemu_get_be64(f
);
7267 end_pos
= total_len
+ qemu_ftell(f
);
7269 if (qemu_ftell(f
) >= end_pos
)
7271 len
= qemu_get_byte(f
);
7272 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
7274 instance_id
= qemu_get_be32(f
);
7275 version_id
= qemu_get_be32(f
);
7276 record_len
= qemu_get_be32(f
);
7277 cur_pos
= qemu_ftell(f
);
7278 se
= find_se(idstr
, instance_id
);
7280 fprintf(stderr
, "qemu: warning: instance 0x%x of device '%s' not present in current VM\n",
7281 instance_id
, idstr
);
7283 ret
= se
->load_state(f
, se
->opaque
, version_id
);
7285 fprintf(stderr
, "qemu: warning: error while loading state for instance 0x%x of device '%s'\n",
7286 instance_id
, idstr
);
7290 /* always seek to exact end of record */
7291 qemu_fseek(f
, cur_pos
+ record_len
, SEEK_SET
);
7298 int qemu_loadvm_state(QEMUFile
*f
)
7300 LoadStateEntry
*first_le
= NULL
;
7301 uint8_t section_type
;
7305 v
= qemu_get_be32(f
);
7306 if (v
!= QEMU_VM_FILE_MAGIC
)
7309 v
= qemu_get_be32(f
);
7310 if (v
== QEMU_VM_FILE_VERSION_COMPAT
)
7311 return qemu_loadvm_state_v2(f
);
7312 if (v
!= QEMU_VM_FILE_VERSION
)
7315 while ((section_type
= qemu_get_byte(f
)) != QEMU_VM_EOF
) {
7316 uint32_t instance_id
, version_id
, section_id
;
7322 switch (section_type
) {
7323 case QEMU_VM_SECTION_START
:
7324 case QEMU_VM_SECTION_FULL
:
7325 /* Read section start */
7326 section_id
= qemu_get_be32(f
);
7327 len
= qemu_get_byte(f
);
7328 qemu_get_buffer(f
, (uint8_t *)idstr
, len
);
7330 instance_id
= qemu_get_be32(f
);
7331 version_id
= qemu_get_be32(f
);
7333 /* Find savevm section */
7334 se
= find_se(idstr
, instance_id
);
7336 fprintf(stderr
, "Unknown savevm section or instance '%s' %d\n", idstr
, instance_id
);
7341 /* Validate version */
7342 if (version_id
> se
->version_id
) {
7343 fprintf(stderr
, "savevm: unsupported version %d for '%s' v%d\n",
7344 version_id
, idstr
, se
->version_id
);
7350 le
= qemu_mallocz(sizeof(*le
));
7357 le
->section_id
= section_id
;
7358 le
->version_id
= version_id
;
7359 le
->next
= first_le
;
7362 le
->se
->load_state(f
, le
->se
->opaque
, le
->version_id
);
7364 case QEMU_VM_SECTION_PART
:
7365 case QEMU_VM_SECTION_END
:
7366 section_id
= qemu_get_be32(f
);
7368 for (le
= first_le
; le
&& le
->section_id
!= section_id
; le
= le
->next
);
7370 fprintf(stderr
, "Unknown savevm section %d\n", section_id
);
7375 le
->se
->load_state(f
, le
->se
->opaque
, le
->version_id
);
7378 fprintf(stderr
, "Unknown savevm section type %d\n", section_type
);
7388 LoadStateEntry
*le
= first_le
;
7389 first_le
= first_le
->next
;
7393 if (qemu_file_has_error(f
))
7399 /* device can contain snapshots */
7400 static int bdrv_can_snapshot(BlockDriverState
*bs
)
7403 !bdrv_is_removable(bs
) &&
7404 !bdrv_is_read_only(bs
));
7407 /* device must be snapshots in order to have a reliable snapshot */
7408 static int bdrv_has_snapshot(BlockDriverState
*bs
)
7411 !bdrv_is_removable(bs
) &&
7412 !bdrv_is_read_only(bs
));
7415 static BlockDriverState
*get_bs_snapshots(void)
7417 BlockDriverState
*bs
;
7421 return bs_snapshots
;
7422 for(i
= 0; i
<= nb_drives
; i
++) {
7423 bs
= drives_table
[i
].bdrv
;
7424 if (bdrv_can_snapshot(bs
))
7433 static int bdrv_snapshot_find(BlockDriverState
*bs
, QEMUSnapshotInfo
*sn_info
,
7436 QEMUSnapshotInfo
*sn_tab
, *sn
;
7440 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
7443 for(i
= 0; i
< nb_sns
; i
++) {
7445 if (!strcmp(sn
->id_str
, name
) || !strcmp(sn
->name
, name
)) {
7455 void do_savevm(const char *name
)
7457 BlockDriverState
*bs
, *bs1
;
7458 QEMUSnapshotInfo sn1
, *sn
= &sn1
, old_sn1
, *old_sn
= &old_sn1
;
7459 int must_delete
, ret
, i
;
7460 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
7462 int saved_vm_running
;
7469 bs
= get_bs_snapshots();
7471 term_printf("No block device can accept snapshots\n");
7475 /* ??? Should this occur after vm_stop? */
7478 saved_vm_running
= vm_running
;
7483 ret
= bdrv_snapshot_find(bs
, old_sn
, name
);
7488 memset(sn
, 0, sizeof(*sn
));
7490 pstrcpy(sn
->name
, sizeof(sn
->name
), old_sn
->name
);
7491 pstrcpy(sn
->id_str
, sizeof(sn
->id_str
), old_sn
->id_str
);
7494 pstrcpy(sn
->name
, sizeof(sn
->name
), name
);
7497 /* fill auxiliary fields */
7500 sn
->date_sec
= tb
.time
;
7501 sn
->date_nsec
= tb
.millitm
* 1000000;
7503 gettimeofday(&tv
, NULL
);
7504 sn
->date_sec
= tv
.tv_sec
;
7505 sn
->date_nsec
= tv
.tv_usec
* 1000;
7507 sn
->vm_clock_nsec
= qemu_get_clock(vm_clock
);
7509 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
7510 term_printf("Device %s does not support VM state snapshots\n",
7511 bdrv_get_device_name(bs
));
7515 /* save the VM state */
7516 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 1);
7518 term_printf("Could not open VM state file\n");
7521 ret
= qemu_savevm_state(f
);
7522 sn
->vm_state_size
= qemu_ftell(f
);
7525 term_printf("Error %d while writing VM\n", ret
);
7529 /* create the snapshots */
7531 for(i
= 0; i
< nb_drives
; i
++) {
7532 bs1
= drives_table
[i
].bdrv
;
7533 if (bdrv_has_snapshot(bs1
)) {
7535 ret
= bdrv_snapshot_delete(bs1
, old_sn
->id_str
);
7537 term_printf("Error while deleting snapshot on '%s'\n",
7538 bdrv_get_device_name(bs1
));
7541 ret
= bdrv_snapshot_create(bs1
, sn
);
7543 term_printf("Error while creating snapshot on '%s'\n",
7544 bdrv_get_device_name(bs1
));
7550 if (saved_vm_running
)
7554 void do_loadvm(const char *name
)
7556 BlockDriverState
*bs
, *bs1
;
7557 BlockDriverInfo bdi1
, *bdi
= &bdi1
;
7560 int saved_vm_running
;
7562 bs
= get_bs_snapshots();
7564 term_printf("No block device supports snapshots\n");
7568 /* Flush all IO requests so they don't interfere with the new state. */
7571 saved_vm_running
= vm_running
;
7574 for(i
= 0; i
<= nb_drives
; i
++) {
7575 bs1
= drives_table
[i
].bdrv
;
7576 if (bdrv_has_snapshot(bs1
)) {
7577 ret
= bdrv_snapshot_goto(bs1
, name
);
7580 term_printf("Warning: ");
7583 term_printf("Snapshots not supported on device '%s'\n",
7584 bdrv_get_device_name(bs1
));
7587 term_printf("Could not find snapshot '%s' on device '%s'\n",
7588 name
, bdrv_get_device_name(bs1
));
7591 term_printf("Error %d while activating snapshot on '%s'\n",
7592 ret
, bdrv_get_device_name(bs1
));
7595 /* fatal on snapshot block device */
7602 if (bdrv_get_info(bs
, bdi
) < 0 || bdi
->vm_state_offset
<= 0) {
7603 term_printf("Device %s does not support VM state snapshots\n",
7604 bdrv_get_device_name(bs
));
7608 /* restore the VM state */
7609 f
= qemu_fopen_bdrv(bs
, bdi
->vm_state_offset
, 0);
7611 term_printf("Could not open VM state file\n");
7614 ret
= qemu_loadvm_state(f
);
7617 term_printf("Error %d while loading VM state\n", ret
);
7620 if (saved_vm_running
)
7624 void do_delvm(const char *name
)
7626 BlockDriverState
*bs
, *bs1
;
7629 bs
= get_bs_snapshots();
7631 term_printf("No block device supports snapshots\n");
7635 for(i
= 0; i
<= nb_drives
; i
++) {
7636 bs1
= drives_table
[i
].bdrv
;
7637 if (bdrv_has_snapshot(bs1
)) {
7638 ret
= bdrv_snapshot_delete(bs1
, name
);
7640 if (ret
== -ENOTSUP
)
7641 term_printf("Snapshots not supported on device '%s'\n",
7642 bdrv_get_device_name(bs1
));
7644 term_printf("Error %d while deleting snapshot on '%s'\n",
7645 ret
, bdrv_get_device_name(bs1
));
7651 void do_info_snapshots(void)
7653 BlockDriverState
*bs
, *bs1
;
7654 QEMUSnapshotInfo
*sn_tab
, *sn
;
7658 bs
= get_bs_snapshots();
7660 term_printf("No available block device supports snapshots\n");
7663 term_printf("Snapshot devices:");
7664 for(i
= 0; i
<= nb_drives
; i
++) {
7665 bs1
= drives_table
[i
].bdrv
;
7666 if (bdrv_has_snapshot(bs1
)) {
7668 term_printf(" %s", bdrv_get_device_name(bs1
));
7673 nb_sns
= bdrv_snapshot_list(bs
, &sn_tab
);
7675 term_printf("bdrv_snapshot_list: error %d\n", nb_sns
);
7678 term_printf("Snapshot list (from %s):\n", bdrv_get_device_name(bs
));
7679 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), NULL
));
7680 for(i
= 0; i
< nb_sns
; i
++) {
7682 term_printf("%s\n", bdrv_snapshot_dump(buf
, sizeof(buf
), sn
));
7687 /***********************************************************/
7688 /* ram save/restore */
7690 static int ram_get_page(QEMUFile
*f
, uint8_t *buf
, int len
)
7694 v
= qemu_get_byte(f
);
7697 if (qemu_get_buffer(f
, buf
, len
) != len
)
7701 v
= qemu_get_byte(f
);
7702 memset(buf
, v
, len
);
7708 if (qemu_file_has_error(f
))
7714 static int ram_load_v1(QEMUFile
*f
, void *opaque
)
7719 if (qemu_get_be32(f
) != phys_ram_size
)
7721 for(i
= 0; i
< phys_ram_size
; i
+= TARGET_PAGE_SIZE
) {
7722 if (kvm_enabled() && (i
>=0xa0000) && (i
<0xc0000)) /* do not access video-addresses */
7724 ret
= ram_get_page(f
, phys_ram_base
+ i
, TARGET_PAGE_SIZE
);
7731 #define BDRV_HASH_BLOCK_SIZE 1024
7732 #define IOBUF_SIZE 4096
7733 #define RAM_CBLOCK_MAGIC 0xfabe
7735 typedef struct RamDecompressState
{
7738 uint8_t buf
[IOBUF_SIZE
];
7739 } RamDecompressState
;
7741 static int ram_decompress_open(RamDecompressState
*s
, QEMUFile
*f
)
7744 memset(s
, 0, sizeof(*s
));
7746 ret
= inflateInit(&s
->zstream
);
7752 static int ram_decompress_buf(RamDecompressState
*s
, uint8_t *buf
, int len
)
7756 s
->zstream
.avail_out
= len
;
7757 s
->zstream
.next_out
= buf
;
7758 while (s
->zstream
.avail_out
> 0) {
7759 if (s
->zstream
.avail_in
== 0) {
7760 if (qemu_get_be16(s
->f
) != RAM_CBLOCK_MAGIC
)
7762 clen
= qemu_get_be16(s
->f
);
7763 if (clen
> IOBUF_SIZE
)
7765 qemu_get_buffer(s
->f
, s
->buf
, clen
);
7766 s
->zstream
.avail_in
= clen
;
7767 s
->zstream
.next_in
= s
->buf
;
7769 ret
= inflate(&s
->zstream
, Z_PARTIAL_FLUSH
);
7770 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
) {
7777 static void ram_decompress_close(RamDecompressState
*s
)
7779 inflateEnd(&s
->zstream
);
7782 #define RAM_SAVE_FLAG_FULL 0x01
7783 #define RAM_SAVE_FLAG_COMPRESS 0x02
7784 #define RAM_SAVE_FLAG_MEM_SIZE 0x04
7785 #define RAM_SAVE_FLAG_PAGE 0x08
7786 #define RAM_SAVE_FLAG_EOS 0x10
7788 static int is_dup_page(uint8_t *page
, uint8_t ch
)
7790 uint32_t val
= ch
<< 24 | ch
<< 16 | ch
<< 8 | ch
;
7791 uint32_t *array
= (uint32_t *)page
;
7794 for (i
= 0; i
< (TARGET_PAGE_SIZE
/ 4); i
++) {
7795 if (array
[i
] != val
)
7802 static int ram_save_block(QEMUFile
*f
)
7804 static ram_addr_t current_addr
= 0;
7805 ram_addr_t saved_addr
= current_addr
;
7806 ram_addr_t addr
= 0;
7809 while (addr
< phys_ram_size
) {
7810 if (kvm_enabled() && current_addr
== 0)
7811 kvm_update_dirty_pages_log(); /* FIXME: propagate errors */
7812 if (cpu_physical_memory_get_dirty(current_addr
, MIGRATION_DIRTY_FLAG
)) {
7815 cpu_physical_memory_reset_dirty(current_addr
,
7816 current_addr
+ TARGET_PAGE_SIZE
,
7817 MIGRATION_DIRTY_FLAG
);
7819 ch
= *(phys_ram_base
+ current_addr
);
7821 if (is_dup_page(phys_ram_base
+ current_addr
, ch
)) {
7822 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_COMPRESS
);
7823 qemu_put_byte(f
, ch
);
7825 qemu_put_be64(f
, current_addr
| RAM_SAVE_FLAG_PAGE
);
7826 qemu_put_buffer(f
, phys_ram_base
+ current_addr
, TARGET_PAGE_SIZE
);
7832 addr
+= TARGET_PAGE_SIZE
;
7833 current_addr
= (saved_addr
+ addr
) % phys_ram_size
;
7839 static ram_addr_t ram_save_threshold
= 10;
7841 static ram_addr_t
ram_save_remaining(void)
7844 ram_addr_t count
= 0;
7846 for (addr
= 0; addr
< phys_ram_size
; addr
+= TARGET_PAGE_SIZE
) {
7847 if (cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
7854 static int ram_save_live(QEMUFile
*f
, int stage
, void *opaque
)
7859 /* Make sure all dirty bits are set */
7860 for (addr
= 0; addr
< phys_ram_size
; addr
+= TARGET_PAGE_SIZE
) {
7861 if (!cpu_physical_memory_get_dirty(addr
, MIGRATION_DIRTY_FLAG
))
7862 cpu_physical_memory_set_dirty(addr
);
7865 /* Enable dirty memory tracking */
7866 cpu_physical_memory_set_dirty_tracking(1);
7868 qemu_put_be64(f
, phys_ram_size
| RAM_SAVE_FLAG_MEM_SIZE
);
7871 while (!qemu_file_rate_limit(f
)) {
7874 ret
= ram_save_block(f
);
7875 if (ret
== 0) /* no more blocks */
7879 /* try transferring iterative blocks of memory */
7882 cpu_physical_memory_set_dirty_tracking(0);
7884 /* flush all remaining blocks regardless of rate limiting */
7885 while (ram_save_block(f
) != 0);
7888 qemu_put_be64(f
, RAM_SAVE_FLAG_EOS
);
7890 return (stage
== 2) && (ram_save_remaining() < ram_save_threshold
);
7893 static int ram_load_dead(QEMUFile
*f
, void *opaque
)
7895 RamDecompressState s1
, *s
= &s1
;
7899 if (ram_decompress_open(s
, f
) < 0)
7901 for(i
= 0; i
< phys_ram_size
; i
+= BDRV_HASH_BLOCK_SIZE
) {
7902 if (kvm_enabled() && (i
>=0xa0000) && (i
<0xc0000)) /* do not access video-addresses */
7904 if (ram_decompress_buf(s
, buf
, 1) < 0) {
7905 fprintf(stderr
, "Error while reading ram block header\n");
7909 if (ram_decompress_buf(s
, phys_ram_base
+ i
, BDRV_HASH_BLOCK_SIZE
) < 0) {
7910 fprintf(stderr
, "Error while reading ram block address=0x%08" PRIx64
, (uint64_t)i
);
7915 printf("Error block header\n");
7919 ram_decompress_close(s
);
7924 static int ram_load(QEMUFile
*f
, void *opaque
, int version_id
)
7929 if (version_id
== 1)
7930 return ram_load_v1(f
, opaque
);
7932 if (version_id
== 2) {
7933 if (qemu_get_be32(f
) != phys_ram_size
)
7935 return ram_load_dead(f
, opaque
);
7938 if (version_id
!= 3)
7942 addr
= qemu_get_be64(f
);
7944 flags
= addr
& ~TARGET_PAGE_MASK
;
7945 addr
&= TARGET_PAGE_MASK
;
7947 if (flags
& RAM_SAVE_FLAG_MEM_SIZE
) {
7948 if (addr
!= phys_ram_size
)
7952 if (flags
& RAM_SAVE_FLAG_FULL
) {
7953 if (ram_load_dead(f
, opaque
) < 0)
7957 if (flags
& RAM_SAVE_FLAG_COMPRESS
) {
7958 uint8_t ch
= qemu_get_byte(f
);
7959 memset(phys_ram_base
+ addr
, ch
, TARGET_PAGE_SIZE
);
7960 } else if (flags
& RAM_SAVE_FLAG_PAGE
)
7961 qemu_get_buffer(f
, phys_ram_base
+ addr
, TARGET_PAGE_SIZE
);
7962 } while (!(flags
& RAM_SAVE_FLAG_EOS
));
7967 /***********************************************************/
7968 /* bottom halves (can be seen as timers which expire ASAP) */
7977 static QEMUBH
*first_bh
= NULL
;
7979 QEMUBH
*qemu_bh_new(QEMUBHFunc
*cb
, void *opaque
)
7982 bh
= qemu_mallocz(sizeof(QEMUBH
));
7986 bh
->opaque
= opaque
;
7990 int qemu_bh_poll(void)
8009 void qemu_bh_schedule(QEMUBH
*bh
)
8011 CPUState
*env
= cpu_single_env
;
8015 bh
->next
= first_bh
;
8018 /* stop the currently executing CPU to execute the BH ASAP */
8020 cpu_interrupt(env
, CPU_INTERRUPT_EXIT
);
8025 void qemu_bh_cancel(QEMUBH
*bh
)
8028 if (bh
->scheduled
) {
8031 pbh
= &(*pbh
)->next
;
8037 void qemu_bh_delete(QEMUBH
*bh
)
8043 /***********************************************************/
8044 /* machine registration */
8046 static QEMUMachine
*first_machine
= NULL
;
8047 QEMUMachine
*current_machine
= NULL
;
8049 int qemu_register_machine(QEMUMachine
*m
)
8052 pm
= &first_machine
;
8060 static QEMUMachine
*find_machine(const char *name
)
8064 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
8065 if (!strcmp(m
->name
, name
))
8071 /***********************************************************/
8072 /* main execution loop */
8074 static void gui_update(void *opaque
)
8076 DisplayState
*ds
= opaque
;
8077 ds
->dpy_refresh(ds
);
8078 qemu_mod_timer(ds
->gui_timer
,
8079 (ds
->gui_timer_interval
?
8080 ds
->gui_timer_interval
:
8081 GUI_REFRESH_INTERVAL
)
8082 + qemu_get_clock(rt_clock
));
8085 struct vm_change_state_entry
{
8086 VMChangeStateHandler
*cb
;
8088 LIST_ENTRY (vm_change_state_entry
) entries
;
8091 static LIST_HEAD(vm_change_state_head
, vm_change_state_entry
) vm_change_state_head
;
8093 VMChangeStateEntry
*qemu_add_vm_change_state_handler(VMChangeStateHandler
*cb
,
8096 VMChangeStateEntry
*e
;
8098 e
= qemu_mallocz(sizeof (*e
));
8104 LIST_INSERT_HEAD(&vm_change_state_head
, e
, entries
);
8108 void qemu_del_vm_change_state_handler(VMChangeStateEntry
*e
)
8110 LIST_REMOVE (e
, entries
);
8114 static void vm_state_notify(int running
)
8116 VMChangeStateEntry
*e
;
8118 for (e
= vm_change_state_head
.lh_first
; e
; e
= e
->entries
.le_next
) {
8119 e
->cb(e
->opaque
, running
);
8123 /* XXX: support several handlers */
8124 static VMStopHandler
*vm_stop_cb
;
8125 static void *vm_stop_opaque
;
8127 int qemu_add_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
8130 vm_stop_opaque
= opaque
;
8134 void qemu_del_vm_stop_handler(VMStopHandler
*cb
, void *opaque
)
8145 qemu_rearm_alarm_timer(alarm_timer
);
8149 void vm_stop(int reason
)
8152 cpu_disable_ticks();
8156 vm_stop_cb(vm_stop_opaque
, reason
);
8163 /* reset/shutdown handler */
8165 typedef struct QEMUResetEntry
{
8166 QEMUResetHandler
*func
;
8168 struct QEMUResetEntry
*next
;
8171 static QEMUResetEntry
*first_reset_entry
;
8172 static int reset_requested
;
8173 static int shutdown_requested
;
8174 static int powerdown_requested
;
8176 int qemu_shutdown_requested(void)
8178 int r
= shutdown_requested
;
8179 shutdown_requested
= 0;
8183 int qemu_reset_requested(void)
8185 int r
= reset_requested
;
8186 reset_requested
= 0;
8190 int qemu_powerdown_requested(void)
8192 int r
= powerdown_requested
;
8193 powerdown_requested
= 0;
8197 void qemu_register_reset(QEMUResetHandler
*func
, void *opaque
)
8199 QEMUResetEntry
**pre
, *re
;
8201 pre
= &first_reset_entry
;
8202 while (*pre
!= NULL
)
8203 pre
= &(*pre
)->next
;
8204 re
= qemu_mallocz(sizeof(QEMUResetEntry
));
8206 re
->opaque
= opaque
;
8211 void qemu_system_reset(void)
8215 /* reset all devices */
8216 for(re
= first_reset_entry
; re
!= NULL
; re
= re
->next
) {
8217 re
->func(re
->opaque
);
8221 void qemu_system_reset_request(void)
8224 shutdown_requested
= 1;
8226 reset_requested
= 1;
8229 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
8233 void qemu_system_shutdown_request(void)
8235 shutdown_requested
= 1;
8237 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
8240 void qemu_system_powerdown_request(void)
8242 powerdown_requested
= 1;
8244 cpu_interrupt(cpu_single_env
, CPU_INTERRUPT_EXIT
);
8247 static int qemu_select(int max_fd
, fd_set
*rfds
, fd_set
*wfds
, fd_set
*xfds
,
8252 /* KVM holds a mutex while QEMU code is running, we need hooks to
8253 release the mutex whenever QEMU code sleeps. */
8257 ret
= select(max_fd
, rfds
, wfds
, xfds
, tv
);
8264 void main_loop_wait(int timeout
)
8266 IOHandlerRecord
*ioh
;
8267 fd_set rfds
, wfds
, xfds
;
8276 /* XXX: need to suppress polling by better using win32 events */
8278 for(pe
= first_polling_entry
; pe
!= NULL
; pe
= pe
->next
) {
8279 ret
|= pe
->func(pe
->opaque
);
8284 WaitObjects
*w
= &wait_objects
;
8286 ret
= WaitForMultipleObjects(w
->num
, w
->events
, FALSE
, timeout
);
8287 if (WAIT_OBJECT_0
+ 0 <= ret
&& ret
<= WAIT_OBJECT_0
+ w
->num
- 1) {
8288 if (w
->func
[ret
- WAIT_OBJECT_0
])
8289 w
->func
[ret
- WAIT_OBJECT_0
](w
->opaque
[ret
- WAIT_OBJECT_0
]);
8291 /* Check for additional signaled events */
8292 for(i
= (ret
- WAIT_OBJECT_0
+ 1); i
< w
->num
; i
++) {
8294 /* Check if event is signaled */
8295 ret2
= WaitForSingleObject(w
->events
[i
], 0);
8296 if(ret2
== WAIT_OBJECT_0
) {
8298 w
->func
[i
](w
->opaque
[i
]);
8299 } else if (ret2
== WAIT_TIMEOUT
) {
8301 err
= GetLastError();
8302 fprintf(stderr
, "WaitForSingleObject error %d %d\n", i
, err
);
8305 } else if (ret
== WAIT_TIMEOUT
) {
8307 err
= GetLastError();
8308 fprintf(stderr
, "WaitForMultipleObjects error %d %d\n", ret
, err
);
8312 /* poll any events */
8313 /* XXX: separate device handlers from system ones */
8318 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
8322 (!ioh
->fd_read_poll
||
8323 ioh
->fd_read_poll(ioh
->opaque
) != 0)) {
8324 FD_SET(ioh
->fd
, &rfds
);
8328 if (ioh
->fd_write
) {
8329 FD_SET(ioh
->fd
, &wfds
);
8339 tv
.tv_sec
= timeout
/ 1000;
8340 tv
.tv_usec
= (timeout
% 1000) * 1000;
8342 #if defined(CONFIG_SLIRP)
8344 slirp_select_fill(&nfds
, &rfds
, &wfds
, &xfds
);
8347 ret
= qemu_select(nfds
+ 1, &rfds
, &wfds
, &xfds
, &tv
);
8349 IOHandlerRecord
**pioh
;
8351 for(ioh
= first_io_handler
; ioh
!= NULL
; ioh
= ioh
->next
) {
8352 if (!ioh
->deleted
&& ioh
->fd_read
&& FD_ISSET(ioh
->fd
, &rfds
)) {
8353 ioh
->fd_read(ioh
->opaque
);
8354 if (!(ioh
->fd_read_poll
&& ioh
->fd_read_poll(ioh
->opaque
)))
8355 FD_CLR(ioh
->fd
, &rfds
);
8357 if (!ioh
->deleted
&& ioh
->fd_write
&& FD_ISSET(ioh
->fd
, &wfds
)) {
8358 ioh
->fd_write(ioh
->opaque
);
8362 /* remove deleted IO handlers */
8363 pioh
= &first_io_handler
;
8373 #if defined(CONFIG_SLIRP)
8380 slirp_select_poll(&rfds
, &wfds
, &xfds
);
8385 if (likely(!cur_cpu
|| !(cur_cpu
->singlestep_enabled
& SSTEP_NOTIMER
)))
8386 qemu_run_timers(&active_timers
[QEMU_TIMER_VIRTUAL
],
8387 qemu_get_clock(vm_clock
));
8388 /* run dma transfers, if any */
8392 /* real time timers */
8393 qemu_run_timers(&active_timers
[QEMU_TIMER_REALTIME
],
8394 qemu_get_clock(rt_clock
));
8396 if (alarm_timer
->flags
& ALARM_FLAG_EXPIRED
) {
8397 alarm_timer
->flags
&= ~(ALARM_FLAG_EXPIRED
);
8398 qemu_rearm_alarm_timer(alarm_timer
);
8401 /* Check bottom-halves last in case any of the earlier events triggered
8407 static int main_loop(void)
8410 #ifdef CONFIG_PROFILER
8416 if (kvm_enabled()) {
8418 cpu_disable_ticks();
8422 cur_cpu
= first_cpu
;
8423 next_cpu
= cur_cpu
->next_cpu
?: first_cpu
;
8430 #ifdef CONFIG_PROFILER
8431 ti
= profile_getclock();
8436 qemu_icount
-= (env
->icount_decr
.u16
.low
+ env
->icount_extra
);
8437 env
->icount_decr
.u16
.low
= 0;
8438 env
->icount_extra
= 0;
8439 count
= qemu_next_deadline();
8440 count
= (count
+ (1 << icount_time_shift
) - 1)
8441 >> icount_time_shift
;
8442 qemu_icount
+= count
;
8443 decr
= (count
> 0xffff) ? 0xffff : count
;
8445 env
->icount_decr
.u16
.low
= decr
;
8446 env
->icount_extra
= count
;
8448 ret
= cpu_exec(env
);
8449 #ifdef CONFIG_PROFILER
8450 qemu_time
+= profile_getclock() - ti
;
8453 /* Fold pending instructions back into the
8454 instruction counter, and clear the interrupt flag. */
8455 qemu_icount
-= (env
->icount_decr
.u16
.low
8456 + env
->icount_extra
);
8457 env
->icount_decr
.u32
= 0;
8458 env
->icount_extra
= 0;
8460 next_cpu
= env
->next_cpu
?: first_cpu
;
8461 if (event_pending
&& likely(ret
!= EXCP_DEBUG
)) {
8462 ret
= EXCP_INTERRUPT
;
8466 if (ret
== EXCP_HLT
) {
8467 /* Give the next CPU a chance to run. */
8471 if (ret
!= EXCP_HALTED
)
8473 /* all CPUs are halted ? */
8479 if (shutdown_requested
) {
8480 ret
= EXCP_INTERRUPT
;
8488 if (reset_requested
) {
8489 reset_requested
= 0;
8490 qemu_system_reset();
8492 kvm_load_registers(env
);
8493 ret
= EXCP_INTERRUPT
;
8495 if (powerdown_requested
) {
8496 powerdown_requested
= 0;
8497 qemu_system_powerdown();
8498 ret
= EXCP_INTERRUPT
;
8500 if (unlikely(ret
== EXCP_DEBUG
)) {
8501 vm_stop(EXCP_DEBUG
);
8503 /* If all cpus are halted then wait until the next IRQ */
8504 /* XXX: use timeout computed from timers */
8505 if (ret
== EXCP_HALTED
) {
8509 /* Advance virtual time to the next event. */
8510 if (use_icount
== 1) {
8511 /* When not using an adaptive execution frequency
8512 we tend to get badly out of sync with real time,
8513 so just delay for a reasonable amount of time. */
8516 delta
= cpu_get_icount() - cpu_get_clock();
8519 /* If virtual time is ahead of real time then just
8521 timeout
= (delta
/ 1000000) + 1;
8523 /* Wait for either IO to occur or the next
8525 add
= qemu_next_deadline();
8526 /* We advance the timer before checking for IO.
8527 Limit the amount we advance so that early IO
8528 activity won't get the guest too far ahead. */
8532 add
= (add
+ (1 << icount_time_shift
) - 1)
8533 >> icount_time_shift
;
8535 timeout
= delta
/ 1000000;
8546 if (shutdown_requested
) {
8547 ret
= EXCP_INTERRUPT
;
8552 #ifdef CONFIG_PROFILER
8553 ti
= profile_getclock();
8555 main_loop_wait(timeout
);
8556 #ifdef CONFIG_PROFILER
8557 dev_time
+= profile_getclock() - ti
;
8560 cpu_disable_ticks();
8564 static void help(int exitcode
)
8566 printf("QEMU PC emulator version " QEMU_VERSION
" (" KVM_VERSION
")"
8567 ", Copyright (c) 2003-2008 Fabrice Bellard\n"
8568 "usage: %s [options] [disk_image]\n"
8570 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
8572 "Standard options:\n"
8573 "-M machine select emulated machine (-M ? for list)\n"
8574 "-cpu cpu select CPU (-cpu ? for list)\n"
8575 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
8576 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
8577 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
8578 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
8579 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
8580 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
8581 " [,cache=writethrough|writeback|none][,format=f]\n"
8583 " use 'file' as a drive image\n"
8584 "-mtdblock file use 'file' as on-board Flash memory image\n"
8585 "-sd file use 'file' as SecureDigital card image\n"
8586 "-pflash file use 'file' as a parallel flash image\n"
8587 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
8588 "-snapshot write to temporary files instead of disk image files\n"
8590 "-no-frame open SDL window without a frame and window decorations\n"
8591 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
8592 "-no-quit disable SDL window close capability\n"
8595 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
8597 "-m megs set virtual RAM size to megs MB [default=%d]\n"
8598 "-smp n set the number of CPUs to 'n' [default=1]\n"
8599 "-nographic disable graphical output and redirect serial I/Os to console\n"
8600 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
8602 "-k language use keyboard layout (for example \"fr\" for French)\n"
8605 "-audio-help print list of audio drivers and their options\n"
8606 "-soundhw c1,... enable audio support\n"
8607 " and only specified sound cards (comma separated list)\n"
8608 " use -soundhw ? to get the list of supported cards\n"
8609 " use -soundhw all to enable all of them\n"
8611 "-vga [std|cirrus|vmware]\n"
8612 " select video card type\n"
8613 "-localtime set the real time clock to local time [default=utc]\n"
8614 "-full-screen start in full screen\n"
8616 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
8618 "-usb enable the USB driver (will be the default soon)\n"
8619 "-usbdevice name add the host or guest USB device 'name'\n"
8620 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8621 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
8623 "-name string set the name of the guest\n"
8624 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
8626 "Network options:\n"
8627 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
8628 " create a new Network Interface Card and connect it to VLAN 'n'\n"
8630 "-net user[,vlan=n][,hostname=host]\n"
8631 " connect the user mode network stack to VLAN 'n' and send\n"
8632 " hostname 'host' to DHCP clients\n"
8635 "-net tap[,vlan=n],ifname=name\n"
8636 " connect the host TAP network interface to VLAN 'n'\n"
8638 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
8639 " connect the host TAP network interface to VLAN 'n' and use the\n"
8640 " network scripts 'file' (default=%s)\n"
8641 " and 'dfile' (default=%s);\n"
8642 " use '[down]script=no' to disable script execution;\n"
8643 " use 'fd=h' to connect to an already opened TAP interface\n"
8645 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
8646 " connect the vlan 'n' to another VLAN using a socket connection\n"
8647 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
8648 " connect the vlan 'n' to multicast maddr and port\n"
8650 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
8651 " connect the vlan 'n' to port 'n' of a vde switch running\n"
8652 " on host and listening for incoming connections on 'socketpath'.\n"
8653 " Use group 'groupname' and mode 'octalmode' to change default\n"
8654 " ownership and permissions for communication port.\n"
8656 "-net none use it alone to have zero network devices; if no -net option\n"
8657 " is provided, the default is '-net nic -net user'\n"
8660 "-tftp dir allow tftp access to files in dir [-net user]\n"
8661 "-bootp file advertise file in BOOTP replies\n"
8663 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
8665 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
8666 " redirect TCP or UDP connections from host to guest [-net user]\n"
8669 "Linux boot specific:\n"
8670 "-kernel bzImage use 'bzImage' as kernel image\n"
8671 "-append cmdline use 'cmdline' as kernel command line\n"
8672 "-initrd file use 'file' as initial ram disk\n"
8674 "Debug/Expert options:\n"
8675 "-monitor dev redirect the monitor to char device 'dev'\n"
8676 "-serial dev redirect the serial port to char device 'dev'\n"
8677 "-parallel dev redirect the parallel port to char device 'dev'\n"
8678 "-pidfile file Write PID to 'file'\n"
8679 "-S freeze CPU at startup (use 'c' to start execution)\n"
8680 "-s wait gdb connection to port\n"
8681 "-p port set gdb connection port [default=%s]\n"
8682 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
8683 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
8684 " translation (t=none or lba) (usually qemu can guess them)\n"
8685 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
8687 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
8688 "-no-kqemu disable KQEMU kernel module usage\n"
8691 #ifndef NO_CPU_EMULATION
8692 "-no-kvm disable KVM hardware virtualization\n"
8694 "-no-kvm-irqchip disable KVM kernel mode PIC/IOAPIC/LAPIC\n"
8695 "-no-kvm-pit disable KVM kernel mode PIT\n"
8698 "-no-acpi disable ACPI\n"
8700 #ifdef CONFIG_CURSES
8701 "-curses use a curses/ncurses interface instead of SDL\n"
8703 "-no-reboot exit instead of rebooting\n"
8704 "-no-shutdown stop before shutdown\n"
8705 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
8706 "-vnc display start a VNC server on display\n"
8708 "-daemonize daemonize QEMU after initializing\n"
8710 "-tdf inject timer interrupts that got lost\n"
8711 "-kvm-shadow-memory megs set the amount of shadow pages to be allocated\n"
8712 "-mem-path set the path to hugetlbfs/tmpfs mounted directory, also enables allocation of guest memory with huge pages\n"
8713 "-option-rom rom load a file, rom, into the option ROM space\n"
8715 "-prom-env variable=value set OpenBIOS nvram variables\n"
8717 "-clock force the use of the given methods for timer alarm.\n"
8718 " To see what timers are available use -clock ?\n"
8719 "-startdate select initial date of the clock\n"
8720 "-icount [N|auto]\n"
8721 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
8723 "During emulation, the following keys are useful:\n"
8724 "ctrl-alt-f toggle full screen\n"
8725 "ctrl-alt-n switch to virtual console 'n'\n"
8726 "ctrl-alt toggle mouse and keyboard grab\n"
8728 "When using -nographic, press 'ctrl-a h' to get some help.\n"
8733 DEFAULT_NETWORK_SCRIPT
,
8734 DEFAULT_NETWORK_DOWN_SCRIPT
,
8736 DEFAULT_GDBSTUB_PORT
,
8741 #define HAS_ARG 0x0001
8756 QEMU_OPTION_mtdblock
,
8760 QEMU_OPTION_snapshot
,
8762 QEMU_OPTION_no_fd_bootchk
,
8765 QEMU_OPTION_nographic
,
8766 QEMU_OPTION_portrait
,
8768 QEMU_OPTION_audio_help
,
8769 QEMU_OPTION_soundhw
,
8790 QEMU_OPTION_localtime
,
8794 QEMU_OPTION_monitor
,
8796 QEMU_OPTION_parallel
,
8798 QEMU_OPTION_full_screen
,
8799 QEMU_OPTION_no_frame
,
8800 QEMU_OPTION_alt_grab
,
8801 QEMU_OPTION_no_quit
,
8802 QEMU_OPTION_pidfile
,
8803 QEMU_OPTION_no_kqemu
,
8804 QEMU_OPTION_kernel_kqemu
,
8805 QEMU_OPTION_win2k_hack
,
8807 QEMU_OPTION_usbdevice
,
8810 QEMU_OPTION_no_acpi
,
8813 QEMU_OPTION_no_kvm_irqchip
,
8814 QEMU_OPTION_no_kvm_pit
,
8815 QEMU_OPTION_no_reboot
,
8816 QEMU_OPTION_no_shutdown
,
8817 QEMU_OPTION_show_cursor
,
8818 QEMU_OPTION_daemonize
,
8819 QEMU_OPTION_option_rom
,
8820 QEMU_OPTION_semihosting
,
8821 QEMU_OPTION_cpu_vendor
,
8823 QEMU_OPTION_prom_env
,
8824 QEMU_OPTION_old_param
,
8826 QEMU_OPTION_startdate
,
8827 QEMU_OPTION_tb_size
,
8830 QEMU_OPTION_incoming
,
8832 QEMU_OPTION_kvm_shadow_memory
,
8833 QEMU_OPTION_mempath
,
8836 typedef struct QEMUOption
{
8842 static const QEMUOption qemu_options
[] = {
8843 { "h", 0, QEMU_OPTION_h
},
8844 { "help", 0, QEMU_OPTION_h
},
8846 { "M", HAS_ARG
, QEMU_OPTION_M
},
8847 { "cpu", HAS_ARG
, QEMU_OPTION_cpu
},
8848 { "fda", HAS_ARG
, QEMU_OPTION_fda
},
8849 { "fdb", HAS_ARG
, QEMU_OPTION_fdb
},
8850 { "hda", HAS_ARG
, QEMU_OPTION_hda
},
8851 { "hdb", HAS_ARG
, QEMU_OPTION_hdb
},
8852 { "hdc", HAS_ARG
, QEMU_OPTION_hdc
},
8853 { "hdd", HAS_ARG
, QEMU_OPTION_hdd
},
8854 { "drive", HAS_ARG
, QEMU_OPTION_drive
},
8855 { "cdrom", HAS_ARG
, QEMU_OPTION_cdrom
},
8856 { "mtdblock", HAS_ARG
, QEMU_OPTION_mtdblock
},
8857 { "sd", HAS_ARG
, QEMU_OPTION_sd
},
8858 { "pflash", HAS_ARG
, QEMU_OPTION_pflash
},
8859 { "boot", HAS_ARG
, QEMU_OPTION_boot
},
8860 { "snapshot", 0, QEMU_OPTION_snapshot
},
8862 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk
},
8864 { "m", HAS_ARG
, QEMU_OPTION_m
},
8865 { "nographic", 0, QEMU_OPTION_nographic
},
8866 { "portrait", 0, QEMU_OPTION_portrait
},
8867 { "k", HAS_ARG
, QEMU_OPTION_k
},
8869 { "audio-help", 0, QEMU_OPTION_audio_help
},
8870 { "soundhw", HAS_ARG
, QEMU_OPTION_soundhw
},
8873 { "net", HAS_ARG
, QEMU_OPTION_net
},
8875 { "tftp", HAS_ARG
, QEMU_OPTION_tftp
},
8876 { "bootp", HAS_ARG
, QEMU_OPTION_bootp
},
8878 { "smb", HAS_ARG
, QEMU_OPTION_smb
},
8880 { "redir", HAS_ARG
, QEMU_OPTION_redir
},
8883 { "kernel", HAS_ARG
, QEMU_OPTION_kernel
},
8884 { "append", HAS_ARG
, QEMU_OPTION_append
},
8885 { "initrd", HAS_ARG
, QEMU_OPTION_initrd
},
8887 { "S", 0, QEMU_OPTION_S
},
8888 { "s", 0, QEMU_OPTION_s
},
8889 { "p", HAS_ARG
, QEMU_OPTION_p
},
8890 { "d", HAS_ARG
, QEMU_OPTION_d
},
8891 { "hdachs", HAS_ARG
, QEMU_OPTION_hdachs
},
8892 { "L", HAS_ARG
, QEMU_OPTION_L
},
8893 { "bios", HAS_ARG
, QEMU_OPTION_bios
},
8895 { "no-kqemu", 0, QEMU_OPTION_no_kqemu
},
8896 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu
},
8899 #ifndef NO_CPU_EMULATION
8900 { "no-kvm", 0, QEMU_OPTION_no_kvm
},
8902 { "no-kvm-irqchip", 0, QEMU_OPTION_no_kvm_irqchip
},
8903 { "no-kvm-pit", 0, QEMU_OPTION_no_kvm_pit
},
8905 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
8906 { "g", 1, QEMU_OPTION_g
},
8908 { "localtime", 0, QEMU_OPTION_localtime
},
8909 { "vga", HAS_ARG
, QEMU_OPTION_vga
},
8910 { "echr", HAS_ARG
, QEMU_OPTION_echr
},
8911 { "monitor", HAS_ARG
, QEMU_OPTION_monitor
},
8912 { "serial", HAS_ARG
, QEMU_OPTION_serial
},
8913 { "parallel", HAS_ARG
, QEMU_OPTION_parallel
},
8914 { "loadvm", HAS_ARG
, QEMU_OPTION_loadvm
},
8915 { "incoming", 1, QEMU_OPTION_incoming
},
8916 { "full-screen", 0, QEMU_OPTION_full_screen
},
8918 { "no-frame", 0, QEMU_OPTION_no_frame
},
8919 { "alt-grab", 0, QEMU_OPTION_alt_grab
},
8920 { "no-quit", 0, QEMU_OPTION_no_quit
},
8922 { "pidfile", HAS_ARG
, QEMU_OPTION_pidfile
},
8923 { "win2k-hack", 0, QEMU_OPTION_win2k_hack
},
8924 { "usbdevice", HAS_ARG
, QEMU_OPTION_usbdevice
},
8925 { "smp", HAS_ARG
, QEMU_OPTION_smp
},
8926 { "vnc", HAS_ARG
, QEMU_OPTION_vnc
},
8927 #ifdef CONFIG_CURSES
8928 { "curses", 0, QEMU_OPTION_curses
},
8930 { "uuid", HAS_ARG
, QEMU_OPTION_uuid
},
8932 /* temporary options */
8933 { "usb", 0, QEMU_OPTION_usb
},
8934 { "no-acpi", 0, QEMU_OPTION_no_acpi
},
8935 { "no-reboot", 0, QEMU_OPTION_no_reboot
},
8936 { "no-shutdown", 0, QEMU_OPTION_no_shutdown
},
8937 { "show-cursor", 0, QEMU_OPTION_show_cursor
},
8938 { "daemonize", 0, QEMU_OPTION_daemonize
},
8939 { "option-rom", HAS_ARG
, QEMU_OPTION_option_rom
},
8940 #if defined(TARGET_ARM) || defined(TARGET_M68K)
8941 { "semihosting", 0, QEMU_OPTION_semihosting
},
8943 { "tdf", 0, QEMU_OPTION_tdf
}, /* enable time drift fix */
8944 { "kvm-shadow-memory", HAS_ARG
, QEMU_OPTION_kvm_shadow_memory
},
8945 { "name", HAS_ARG
, QEMU_OPTION_name
},
8946 #if defined(TARGET_SPARC)
8947 { "prom-env", HAS_ARG
, QEMU_OPTION_prom_env
},
8949 { "cpu-vendor", HAS_ARG
, QEMU_OPTION_cpu_vendor
},
8950 #if defined(TARGET_ARM)
8951 { "old-param", 0, QEMU_OPTION_old_param
},
8953 { "clock", HAS_ARG
, QEMU_OPTION_clock
},
8954 { "startdate", HAS_ARG
, QEMU_OPTION_startdate
},
8955 { "tb-size", HAS_ARG
, QEMU_OPTION_tb_size
},
8956 { "icount", HAS_ARG
, QEMU_OPTION_icount
},
8957 { "incoming", HAS_ARG
, QEMU_OPTION_incoming
},
8958 { "mem-path", HAS_ARG
, QEMU_OPTION_mempath
},
8962 /* password input */
8964 int qemu_key_check(BlockDriverState
*bs
, const char *name
)
8969 if (!bdrv_is_encrypted(bs
))
8972 term_printf("%s is encrypted.\n", name
);
8973 for(i
= 0; i
< 3; i
++) {
8974 monitor_readline("Password: ", 1, password
, sizeof(password
));
8975 if (bdrv_set_key(bs
, password
) == 0)
8977 term_printf("invalid password\n");
8982 static BlockDriverState
*get_bdrv(int index
)
8984 if (index
> nb_drives
)
8986 return drives_table
[index
].bdrv
;
8989 static void read_passwords(void)
8991 BlockDriverState
*bs
;
8994 for(i
= 0; i
< 6; i
++) {
8997 qemu_key_check(bs
, bdrv_get_device_name(bs
));
9002 struct soundhw soundhw
[] = {
9003 #ifdef HAS_AUDIO_CHOICE
9004 #if defined(TARGET_I386) || defined(TARGET_MIPS)
9010 { .init_isa
= pcspk_audio_init
}
9015 "Creative Sound Blaster 16",
9018 { .init_isa
= SB16_init
}
9021 #ifdef CONFIG_CS4231A
9027 { .init_isa
= cs4231a_init
}
9035 "Yamaha YMF262 (OPL3)",
9037 "Yamaha YM3812 (OPL2)",
9041 { .init_isa
= Adlib_init
}
9048 "Gravis Ultrasound GF1",
9051 { .init_isa
= GUS_init
}
9058 "Intel 82801AA AC97 Audio",
9061 { .init_pci
= ac97_init
}
9067 "ENSONIQ AudioPCI ES1370",
9070 { .init_pci
= es1370_init
}
9074 { NULL
, NULL
, 0, 0, { NULL
} }
9077 static void select_soundhw (const char *optarg
)
9081 if (*optarg
== '?') {
9084 printf ("Valid sound card names (comma separated):\n");
9085 for (c
= soundhw
; c
->name
; ++c
) {
9086 printf ("%-11s %s\n", c
->name
, c
->descr
);
9088 printf ("\n-soundhw all will enable all of the above\n");
9089 exit (*optarg
!= '?');
9097 if (!strcmp (optarg
, "all")) {
9098 for (c
= soundhw
; c
->name
; ++c
) {
9106 e
= strchr (p
, ',');
9107 l
= !e
? strlen (p
) : (size_t) (e
- p
);
9109 for (c
= soundhw
; c
->name
; ++c
) {
9110 if (!strncmp (c
->name
, p
, l
)) {
9119 "Unknown sound card name (too big to show)\n");
9122 fprintf (stderr
, "Unknown sound card name `%.*s'\n",
9127 p
+= l
+ (e
!= NULL
);
9131 goto show_valid_cards
;
9136 static void select_vgahw (const char *p
)
9140 if (strstart(p
, "std", &opts
)) {
9141 cirrus_vga_enabled
= 0;
9143 } else if (strstart(p
, "cirrus", &opts
)) {
9144 cirrus_vga_enabled
= 1;
9146 } else if (strstart(p
, "vmware", &opts
)) {
9147 cirrus_vga_enabled
= 0;
9151 fprintf(stderr
, "Unknown vga type: %s\n", p
);
9155 const char *nextopt
;
9157 if (strstart(opts
, ",retrace=", &nextopt
)) {
9159 if (strstart(opts
, "dumb", &nextopt
))
9160 vga_retrace_method
= VGA_RETRACE_DUMB
;
9161 else if (strstart(opts
, "precise", &nextopt
))
9162 vga_retrace_method
= VGA_RETRACE_PRECISE
;
9163 else goto invalid_vga
;
9164 } else goto invalid_vga
;
9170 static BOOL WINAPI
qemu_ctrl_handler(DWORD type
)
9172 exit(STATUS_CONTROL_C_EXIT
);
9177 static int qemu_uuid_parse(const char *str
, uint8_t *uuid
)
9181 if(strlen(str
) != 36)
9184 ret
= sscanf(str
, UUID_FMT
, &uuid
[0], &uuid
[1], &uuid
[2], &uuid
[3],
9185 &uuid
[4], &uuid
[5], &uuid
[6], &uuid
[7], &uuid
[8], &uuid
[9],
9186 &uuid
[10], &uuid
[11], &uuid
[12], &uuid
[13], &uuid
[14], &uuid
[15]);
9194 #define MAX_NET_CLIENTS 32
9196 static int saved_argc
;
9197 static char **saved_argv
;
9199 void qemu_get_launch_info(int *argc
, char ***argv
, int *opt_daemonize
, const char **opt_incoming
)
9203 *opt_daemonize
= daemonize
;
9204 *opt_incoming
= incoming
;
9208 static int gethugepagesize(void)
9212 char *needle
= "Hugepagesize:";
9214 unsigned long hugepagesize
;
9216 fd
= open("/proc/meminfo", O_RDONLY
);
9222 ret
= read(fd
, buf
, sizeof(buf
));
9228 size
= strstr(buf
, needle
);
9231 size
+= strlen(needle
);
9232 hugepagesize
= strtol(size
, NULL
, 0);
9233 return hugepagesize
;
9236 void *alloc_mem_area(size_t memory
, unsigned long *len
, const char *path
)
9242 if (asprintf(&filename
, "%s/kvm.XXXXXX", path
) == -1)
9245 hpagesize
= gethugepagesize() * 1024;
9249 fd
= mkstemp(filename
);
9258 memory
= (memory
+hpagesize
-1) & ~(hpagesize
-1);
9261 * ftruncate is not supported by hugetlbfs in older
9262 * hosts, so don't bother checking for errors.
9263 * If anything goes wrong with it under other filesystems,
9266 ftruncate(fd
, memory
);
9268 area
= mmap(0, memory
, PROT_READ
|PROT_WRITE
, MAP_PRIVATE
, fd
, 0);
9269 if (area
== MAP_FAILED
) {
9279 void *qemu_alloc_physram(unsigned long memory
)
9282 unsigned long map_len
= memory
;
9286 area
= alloc_mem_area(memory
, &map_len
, mem_path
);
9289 area
= qemu_vmalloc(memory
);
9291 if (kvm_setup_guest_memory(area
, map_len
))
9299 static void termsig_handler(int signal
)
9301 qemu_system_shutdown_request();
9304 static void termsig_setup(void)
9306 struct sigaction act
;
9308 memset(&act
, 0, sizeof(act
));
9309 act
.sa_handler
= termsig_handler
;
9310 sigaction(SIGINT
, &act
, NULL
);
9311 sigaction(SIGHUP
, &act
, NULL
);
9312 sigaction(SIGTERM
, &act
, NULL
);
9317 int main(int argc
, char **argv
)
9319 #ifdef CONFIG_GDBSTUB
9321 const char *gdbstub_port
;
9323 uint32_t boot_devices_bitmap
= 0;
9325 int snapshot
, linux_boot
, net_boot
;
9326 const char *initrd_filename
;
9327 const char *kernel_filename
, *kernel_cmdline
;
9328 const char *boot_devices
= "";
9329 DisplayState
*ds
= &display_state
;
9330 int cyls
, heads
, secs
, translation
;
9331 const char *net_clients
[MAX_NET_CLIENTS
];
9335 const char *r
, *optarg
;
9336 CharDriverState
*monitor_hd
;
9337 const char *monitor_device
;
9338 const char *serial_devices
[MAX_SERIAL_PORTS
];
9339 int serial_device_index
;
9340 const char *parallel_devices
[MAX_PARALLEL_PORTS
];
9341 int parallel_device_index
;
9342 const char *loadvm
= NULL
;
9343 QEMUMachine
*machine
;
9344 const char *cpu_model
;
9345 const char *usb_devices
[MAX_USB_CMDLINE
];
9346 int usb_devices_index
;
9349 const char *pid_file
= NULL
;
9352 const char *incoming
= NULL
;
9354 LIST_INIT (&vm_change_state_head
);
9357 struct sigaction act
;
9358 sigfillset(&act
.sa_mask
);
9360 act
.sa_handler
= SIG_IGN
;
9361 sigaction(SIGPIPE
, &act
, NULL
);
9364 SetConsoleCtrlHandler(qemu_ctrl_handler
, TRUE
);
9365 /* Note: cpu_interrupt() is currently not SMP safe, so we force
9366 QEMU to run on a single CPU */
9371 h
= GetCurrentProcess();
9372 if (GetProcessAffinityMask(h
, &mask
, &smask
)) {
9373 for(i
= 0; i
< 32; i
++) {
9374 if (mask
& (1 << i
))
9379 SetProcessAffinityMask(h
, mask
);
9385 register_machines();
9386 machine
= first_machine
;
9388 initrd_filename
= NULL
;
9390 vga_ram_size
= VGA_RAM_SIZE
;
9391 #ifdef CONFIG_GDBSTUB
9393 gdbstub_port
= DEFAULT_GDBSTUB_PORT
;
9398 kernel_filename
= NULL
;
9399 kernel_cmdline
= "";
9400 cyls
= heads
= secs
= 0;
9401 translation
= BIOS_ATA_TRANSLATION_AUTO
;
9402 monitor_device
= "vc";
9404 serial_devices
[0] = "vc:80Cx24C";
9405 for(i
= 1; i
< MAX_SERIAL_PORTS
; i
++)
9406 serial_devices
[i
] = NULL
;
9407 serial_device_index
= 0;
9409 parallel_devices
[0] = "vc:640x480";
9410 for(i
= 1; i
< MAX_PARALLEL_PORTS
; i
++)
9411 parallel_devices
[i
] = NULL
;
9412 parallel_device_index
= 0;
9414 usb_devices_index
= 0;
9432 hda_index
= drive_add(argv
[optind
++], HD_ALIAS
, 0);
9434 const QEMUOption
*popt
;
9437 /* Treat --foo the same as -foo. */
9440 popt
= qemu_options
;
9443 fprintf(stderr
, "%s: invalid option -- '%s'\n",
9447 if (!strcmp(popt
->name
, r
+ 1))
9451 if (popt
->flags
& HAS_ARG
) {
9452 if (optind
>= argc
) {
9453 fprintf(stderr
, "%s: option '%s' requires an argument\n",
9457 optarg
= argv
[optind
++];
9462 switch(popt
->index
) {
9464 machine
= find_machine(optarg
);
9467 printf("Supported machines are:\n");
9468 for(m
= first_machine
; m
!= NULL
; m
= m
->next
) {
9469 printf("%-10s %s%s\n",
9471 m
== first_machine
? " (default)" : "");
9473 exit(*optarg
!= '?');
9476 case QEMU_OPTION_cpu
:
9477 /* hw initialization will check this */
9478 if (*optarg
== '?') {
9479 /* XXX: implement xxx_cpu_list for targets that still miss it */
9480 #if defined(cpu_list)
9481 cpu_list(stdout
, &fprintf
);
9488 case QEMU_OPTION_initrd
:
9489 initrd_filename
= optarg
;
9491 case QEMU_OPTION_hda
:
9493 hda_index
= drive_add(optarg
, HD_ALIAS
, 0);
9495 hda_index
= drive_add(optarg
, HD_ALIAS
9496 ",cyls=%d,heads=%d,secs=%d%s",
9497 0, cyls
, heads
, secs
,
9498 translation
== BIOS_ATA_TRANSLATION_LBA
?
9500 translation
== BIOS_ATA_TRANSLATION_NONE
?
9501 ",trans=none" : "");
9503 case QEMU_OPTION_hdb
:
9504 case QEMU_OPTION_hdc
:
9505 case QEMU_OPTION_hdd
:
9506 drive_add(optarg
, HD_ALIAS
, popt
->index
- QEMU_OPTION_hda
);
9508 case QEMU_OPTION_drive
:
9509 drive_add(NULL
, "%s", optarg
);
9511 case QEMU_OPTION_mtdblock
:
9512 drive_add(optarg
, MTD_ALIAS
);
9514 case QEMU_OPTION_sd
:
9515 drive_add(optarg
, SD_ALIAS
);
9517 case QEMU_OPTION_pflash
:
9518 drive_add(optarg
, PFLASH_ALIAS
);
9520 case QEMU_OPTION_snapshot
:
9523 case QEMU_OPTION_hdachs
:
9527 cyls
= strtol(p
, (char **)&p
, 0);
9528 if (cyls
< 1 || cyls
> 16383)
9533 heads
= strtol(p
, (char **)&p
, 0);
9534 if (heads
< 1 || heads
> 16)
9539 secs
= strtol(p
, (char **)&p
, 0);
9540 if (secs
< 1 || secs
> 63)
9544 if (!strcmp(p
, "none"))
9545 translation
= BIOS_ATA_TRANSLATION_NONE
;
9546 else if (!strcmp(p
, "lba"))
9547 translation
= BIOS_ATA_TRANSLATION_LBA
;
9548 else if (!strcmp(p
, "auto"))
9549 translation
= BIOS_ATA_TRANSLATION_AUTO
;
9552 } else if (*p
!= '\0') {
9554 fprintf(stderr
, "qemu: invalid physical CHS format\n");
9557 if (hda_index
!= -1)
9558 snprintf(drives_opt
[hda_index
].opt
,
9559 sizeof(drives_opt
[hda_index
].opt
),
9560 HD_ALIAS
",cyls=%d,heads=%d,secs=%d%s",
9561 0, cyls
, heads
, secs
,
9562 translation
== BIOS_ATA_TRANSLATION_LBA
?
9564 translation
== BIOS_ATA_TRANSLATION_NONE
?
9565 ",trans=none" : "");
9568 case QEMU_OPTION_nographic
:
9571 #ifdef CONFIG_CURSES
9572 case QEMU_OPTION_curses
:
9576 case QEMU_OPTION_portrait
:
9579 case QEMU_OPTION_kernel
:
9580 kernel_filename
= optarg
;
9582 case QEMU_OPTION_append
:
9583 kernel_cmdline
= optarg
;
9585 case QEMU_OPTION_cdrom
:
9586 drive_add(optarg
, CDROM_ALIAS
);
9588 case QEMU_OPTION_boot
:
9589 boot_devices
= optarg
;
9590 /* We just do some generic consistency checks */
9592 /* Could easily be extended to 64 devices if needed */
9595 boot_devices_bitmap
= 0;
9596 for (p
= boot_devices
; *p
!= '\0'; p
++) {
9597 /* Allowed boot devices are:
9598 * a b : floppy disk drives
9599 * c ... f : IDE disk drives
9600 * g ... m : machine implementation dependant drives
9601 * n ... p : network devices
9602 * It's up to each machine implementation to check
9603 * if the given boot devices match the actual hardware
9604 * implementation and firmware features.
9606 if (*p
< 'a' || *p
> 'q') {
9607 fprintf(stderr
, "Invalid boot device '%c'\n", *p
);
9610 if (boot_devices_bitmap
& (1 << (*p
- 'a'))) {
9612 "Boot device '%c' was given twice\n",*p
);
9615 boot_devices_bitmap
|= 1 << (*p
- 'a');
9619 case QEMU_OPTION_fda
:
9620 case QEMU_OPTION_fdb
:
9621 drive_add(optarg
, FD_ALIAS
, popt
->index
- QEMU_OPTION_fda
);
9624 case QEMU_OPTION_no_fd_bootchk
:
9628 case QEMU_OPTION_net
:
9629 if (nb_net_clients
>= MAX_NET_CLIENTS
) {
9630 fprintf(stderr
, "qemu: too many network clients\n");
9633 net_clients
[nb_net_clients
] = optarg
;
9637 case QEMU_OPTION_tftp
:
9638 tftp_prefix
= optarg
;
9640 case QEMU_OPTION_bootp
:
9641 bootp_filename
= optarg
;
9644 case QEMU_OPTION_smb
:
9645 net_slirp_smb(optarg
);
9648 case QEMU_OPTION_redir
:
9649 net_slirp_redir(optarg
);
9653 case QEMU_OPTION_audio_help
:
9657 case QEMU_OPTION_soundhw
:
9658 select_soundhw (optarg
);
9664 case QEMU_OPTION_m
: {
9668 value
= strtoul(optarg
, &ptr
, 10);
9670 case 0: case 'M': case 'm':
9677 fprintf(stderr
, "qemu: invalid ram size: %s\n", optarg
);
9681 /* On 32-bit hosts, QEMU is limited by virtual address space */
9682 if (value
> (2047 << 20)
9684 && HOST_LONG_BITS
== 32
9687 fprintf(stderr
, "qemu: at most 2047 MB RAM can be simulated\n");
9690 if (value
!= (uint64_t)(ram_addr_t
)value
) {
9691 fprintf(stderr
, "qemu: ram size too large\n");
9700 const CPULogItem
*item
;
9702 mask
= cpu_str_to_log_mask(optarg
);
9704 printf("Log items (comma separated):\n");
9705 for(item
= cpu_log_items
; item
->mask
!= 0; item
++) {
9706 printf("%-10s %s\n", item
->name
, item
->help
);
9713 #ifdef CONFIG_GDBSTUB
9718 gdbstub_port
= optarg
;
9724 case QEMU_OPTION_bios
:
9731 keyboard_layout
= optarg
;
9733 case QEMU_OPTION_localtime
:
9736 case QEMU_OPTION_vga
:
9737 select_vgahw (optarg
);
9744 w
= strtol(p
, (char **)&p
, 10);
9747 fprintf(stderr
, "qemu: invalid resolution or depth\n");
9753 h
= strtol(p
, (char **)&p
, 10);
9758 depth
= strtol(p
, (char **)&p
, 10);
9759 if (depth
!= 8 && depth
!= 15 && depth
!= 16 &&
9760 depth
!= 24 && depth
!= 32)
9762 } else if (*p
== '\0') {
9763 depth
= graphic_depth
;
9770 graphic_depth
= depth
;
9773 case QEMU_OPTION_echr
:
9776 term_escape_char
= strtol(optarg
, &r
, 0);
9778 printf("Bad argument to echr\n");
9781 case QEMU_OPTION_monitor
:
9782 monitor_device
= optarg
;
9784 case QEMU_OPTION_serial
:
9785 if (serial_device_index
>= MAX_SERIAL_PORTS
) {
9786 fprintf(stderr
, "qemu: too many serial ports\n");
9789 serial_devices
[serial_device_index
] = optarg
;
9790 serial_device_index
++;
9792 case QEMU_OPTION_parallel
:
9793 if (parallel_device_index
>= MAX_PARALLEL_PORTS
) {
9794 fprintf(stderr
, "qemu: too many parallel ports\n");
9797 parallel_devices
[parallel_device_index
] = optarg
;
9798 parallel_device_index
++;
9800 case QEMU_OPTION_loadvm
:
9803 case QEMU_OPTION_full_screen
:
9807 case QEMU_OPTION_no_frame
:
9810 case QEMU_OPTION_alt_grab
:
9813 case QEMU_OPTION_no_quit
:
9817 case QEMU_OPTION_pidfile
:
9821 case QEMU_OPTION_win2k_hack
:
9822 win2k_install_hack
= 1;
9826 case QEMU_OPTION_no_kqemu
:
9829 case QEMU_OPTION_kernel_kqemu
:
9834 case QEMU_OPTION_no_kvm
:
9837 case QEMU_OPTION_no_kvm_irqchip
: {
9838 extern int kvm_irqchip
, kvm_pit
;
9843 case QEMU_OPTION_no_kvm_pit
: {
9849 case QEMU_OPTION_usb
:
9852 case QEMU_OPTION_usbdevice
:
9854 if (usb_devices_index
>= MAX_USB_CMDLINE
) {
9855 fprintf(stderr
, "Too many USB devices\n");
9858 usb_devices
[usb_devices_index
] = optarg
;
9859 usb_devices_index
++;
9861 case QEMU_OPTION_smp
:
9862 smp_cpus
= atoi(optarg
);
9864 fprintf(stderr
, "Invalid number of CPUs\n");
9868 case QEMU_OPTION_vnc
:
9869 vnc_display
= optarg
;
9871 case QEMU_OPTION_no_acpi
:
9874 case QEMU_OPTION_no_reboot
:
9877 case QEMU_OPTION_no_shutdown
:
9880 case QEMU_OPTION_show_cursor
:
9883 case QEMU_OPTION_uuid
:
9884 if(qemu_uuid_parse(optarg
, qemu_uuid
) < 0) {
9885 fprintf(stderr
, "Fail to parse UUID string."
9886 " Wrong format.\n");
9890 case QEMU_OPTION_daemonize
:
9893 case QEMU_OPTION_option_rom
:
9894 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
9895 fprintf(stderr
, "Too many option ROMs\n");
9898 option_rom
[nb_option_roms
] = optarg
;
9901 case QEMU_OPTION_semihosting
:
9902 semihosting_enabled
= 1;
9904 case QEMU_OPTION_tdf
:
9907 case QEMU_OPTION_kvm_shadow_memory
:
9908 kvm_shadow_memory
= (int64_t)atoi(optarg
) * 1024 * 1024 / 4096;
9910 case QEMU_OPTION_mempath
:
9913 case QEMU_OPTION_name
:
9917 case QEMU_OPTION_prom_env
:
9918 if (nb_prom_envs
>= MAX_PROM_ENVS
) {
9919 fprintf(stderr
, "Too many prom variables\n");
9922 prom_envs
[nb_prom_envs
] = optarg
;
9926 case QEMU_OPTION_cpu_vendor
:
9927 cpu_vendor_string
= optarg
;
9930 case QEMU_OPTION_old_param
:
9934 case QEMU_OPTION_clock
:
9935 configure_alarms(optarg
);
9937 case QEMU_OPTION_startdate
:
9940 time_t rtc_start_date
;
9941 if (!strcmp(optarg
, "now")) {
9942 rtc_date_offset
= -1;
9944 if (sscanf(optarg
, "%d-%d-%dT%d:%d:%d",
9952 } else if (sscanf(optarg
, "%d-%d-%d",
9955 &tm
.tm_mday
) == 3) {
9964 rtc_start_date
= mktimegm(&tm
);
9965 if (rtc_start_date
== -1) {
9967 fprintf(stderr
, "Invalid date format. Valid format are:\n"
9968 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
9971 rtc_date_offset
= time(NULL
) - rtc_start_date
;
9975 case QEMU_OPTION_tb_size
:
9976 tb_size
= strtol(optarg
, NULL
, 0);
9980 case QEMU_OPTION_icount
:
9982 if (strcmp(optarg
, "auto") == 0) {
9983 icount_time_shift
= -1;
9985 icount_time_shift
= strtol(optarg
, NULL
, 0);
9988 case QEMU_OPTION_incoming
:
9995 if (smp_cpus
> machine
->max_cpus
) {
9996 fprintf(stderr
, "Number of SMP cpus requested (%d), exceeds max cpus "
9997 "supported by machine `%s' (%d)\n", smp_cpus
, machine
->name
,
10003 if (serial_device_index
== 0)
10004 serial_devices
[0] = "stdio";
10005 if (parallel_device_index
== 0)
10006 parallel_devices
[0] = "null";
10007 if (strncmp(monitor_device
, "vc", 2) == 0)
10008 monitor_device
= "stdio";
10015 if (pipe(fds
) == -1)
10026 len
= read(fds
[0], &status
, 1);
10027 if (len
== -1 && (errno
== EINTR
))
10032 else if (status
== 1) {
10033 fprintf(stderr
, "Could not acquire pidfile\n");
10037 } else if (pid
< 0)
10050 signal(SIGTSTP
, SIG_IGN
);
10051 signal(SIGTTOU
, SIG_IGN
);
10052 signal(SIGTTIN
, SIG_IGN
);
10057 if (kvm_enabled()) {
10058 if (kvm_qemu_init() < 0) {
10059 extern int kvm_allowed
;
10060 fprintf(stderr
, "Could not initialize KVM, will disable KVM support\n");
10061 #ifdef NO_CPU_EMULATION
10062 fprintf(stderr
, "Compiled with --disable-cpu-emulation, exiting.\n");
10070 if (pid_file
&& qemu_create_pidfile(pid_file
) != 0) {
10072 uint8_t status
= 1;
10073 write(fds
[1], &status
, 1);
10075 fprintf(stderr
, "Could not acquire pid file\n");
10083 linux_boot
= (kernel_filename
!= NULL
);
10084 net_boot
= (boot_devices_bitmap
>> ('n' - 'a')) & 0xF;
10086 if (!linux_boot
&& net_boot
== 0 &&
10087 !machine
->nodisk_ok
&& nb_drives_opt
== 0)
10090 if (!linux_boot
&& *kernel_cmdline
!= '\0') {
10091 fprintf(stderr
, "-append only allowed with -kernel option\n");
10095 if (!linux_boot
&& initrd_filename
!= NULL
) {
10096 fprintf(stderr
, "-initrd only allowed with -kernel option\n");
10100 /* boot to floppy or the default cd if no hard disk defined yet */
10101 if (!boot_devices
[0]) {
10102 boot_devices
= "cad";
10104 setvbuf(stdout
, NULL
, _IOLBF
, 0);
10107 init_timer_alarm();
10108 if (use_icount
&& icount_time_shift
< 0) {
10110 /* 125MIPS seems a reasonable initial guess at the guest speed.
10111 It will be corrected fairly quickly anyway. */
10112 icount_time_shift
= 3;
10113 init_icount_adjust();
10120 /* init network clients */
10121 if (nb_net_clients
== 0) {
10122 /* if no clients, we use a default config */
10123 net_clients
[nb_net_clients
++] = "nic";
10124 #ifdef CONFIG_SLIRP
10125 net_clients
[nb_net_clients
++] = "user";
10129 for(i
= 0;i
< nb_net_clients
; i
++) {
10130 if (net_client_parse(net_clients
[i
]) < 0)
10133 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
10134 if (vlan
->nb_guest_devs
== 0 && vlan
->nb_host_devs
== 0)
10136 if (vlan
->nb_guest_devs
== 0)
10137 fprintf(stderr
, "Warning: vlan %d with no nics\n", vlan
->id
);
10138 if (vlan
->nb_host_devs
== 0)
10140 "Warning: vlan %d is not connected to host network\n",
10145 /* XXX: this should be moved in the PC machine instantiation code */
10146 if (net_boot
!= 0) {
10148 for (i
= 0; i
< nb_nics
&& i
< 4; i
++) {
10149 const char *model
= nd_table
[i
].model
;
10151 if (net_boot
& (1 << i
)) {
10154 snprintf(buf
, sizeof(buf
), "%s/pxe-%s.bin", bios_dir
, model
);
10155 if (get_image_size(buf
) > 0) {
10156 if (nb_option_roms
>= MAX_OPTION_ROMS
) {
10157 fprintf(stderr
, "Too many option ROMs\n");
10160 option_rom
[nb_option_roms
] = strdup(buf
);
10166 if (netroms
== 0) {
10167 fprintf(stderr
, "No valid PXE rom found for network device\n");
10173 /* init the memory */
10174 phys_ram_size
= machine
->ram_require
& ~RAMSIZE_FIXED
;
10176 if (machine
->ram_require
& RAMSIZE_FIXED
) {
10177 if (ram_size
> 0) {
10178 if (ram_size
< phys_ram_size
) {
10179 fprintf(stderr
, "Machine `%s' requires %llu bytes of memory\n",
10180 machine
->name
, (unsigned long long) phys_ram_size
);
10184 phys_ram_size
= ram_size
;
10186 ram_size
= phys_ram_size
;
10189 ram_size
= DEFAULT_RAM_SIZE
* 1024 * 1024;
10191 phys_ram_size
+= ram_size
;
10194 /* Initialize kvm */
10195 #if defined(TARGET_I386) || defined(TARGET_X86_64)
10196 #define KVM_EXTRA_PAGES 3
10198 #define KVM_EXTRA_PAGES 0
10200 if (kvm_enabled()) {
10201 phys_ram_size
+= KVM_EXTRA_PAGES
* TARGET_PAGE_SIZE
;
10202 if (kvm_qemu_create_context() < 0) {
10203 fprintf(stderr
, "Could not create KVM context\n");
10208 phys_ram_base
= qemu_alloc_physram(phys_ram_size
);
10209 if (!phys_ram_base
) {
10210 fprintf(stderr
, "Could not allocate physical memory\n");
10214 /* init the dynamic translator */
10215 cpu_exec_init_all(tb_size
* 1024 * 1024);
10219 /* we always create the cdrom drive, even if no disk is there */
10221 if (nb_drives_opt
< MAX_DRIVES
)
10222 drive_add(NULL
, CDROM_ALIAS
);
10224 /* we always create at least one floppy */
10226 if (nb_drives_opt
< MAX_DRIVES
)
10227 drive_add(NULL
, FD_ALIAS
, 0);
10229 /* we always create one sd slot, even if no card is in it */
10231 if (nb_drives_opt
< MAX_DRIVES
)
10232 drive_add(NULL
, SD_ALIAS
);
10234 /* open the virtual block devices
10235 * note that migration with device
10236 * hot add/remove is broken.
10238 for(i
= 0; i
< nb_drives_opt
; i
++)
10239 if (drive_init(&drives_opt
[i
], snapshot
, machine
) == -1)
10242 register_savevm("timer", 0, 2, timer_save
, timer_load
, NULL
);
10243 register_savevm_live("ram", 0, 3, ram_save_live
, NULL
, ram_load
, NULL
);
10245 /* terminal init */
10246 memset(&display_state
, 0, sizeof(display_state
));
10249 fprintf(stderr
, "fatal: -nographic can't be used with -curses\n");
10252 /* nearly nothing to do */
10253 dumb_display_init(ds
);
10254 } else if (vnc_display
!= NULL
) {
10255 vnc_display_init(ds
);
10256 if (vnc_display_open(ds
, vnc_display
) < 0)
10259 #if defined(CONFIG_CURSES)
10261 curses_display_init(ds
, full_screen
);
10265 #if defined(CONFIG_SDL)
10266 sdl_display_init(ds
, full_screen
, no_frame
);
10267 #elif defined(CONFIG_COCOA)
10268 cocoa_display_init(ds
, full_screen
);
10270 dumb_display_init(ds
);
10275 /* must be after terminal init, SDL library changes signal handlers */
10279 /* Maintain compatibility with multiple stdio monitors */
10280 if (!strcmp(monitor_device
,"stdio")) {
10281 for (i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
10282 const char *devname
= serial_devices
[i
];
10283 if (devname
&& !strcmp(devname
,"mon:stdio")) {
10284 monitor_device
= NULL
;
10286 } else if (devname
&& !strcmp(devname
,"stdio")) {
10287 monitor_device
= NULL
;
10288 serial_devices
[i
] = "mon:stdio";
10293 if (monitor_device
) {
10294 monitor_hd
= qemu_chr_open(monitor_device
);
10296 fprintf(stderr
, "qemu: could not open monitor device '%s'\n", monitor_device
);
10299 monitor_init(monitor_hd
, !nographic
);
10302 for(i
= 0; i
< MAX_SERIAL_PORTS
; i
++) {
10303 const char *devname
= serial_devices
[i
];
10304 if (devname
&& strcmp(devname
, "none")) {
10305 serial_hds
[i
] = qemu_chr_open(devname
);
10306 if (!serial_hds
[i
]) {
10307 fprintf(stderr
, "qemu: could not open serial device '%s'\n",
10311 if (strstart(devname
, "vc", 0))
10312 qemu_chr_printf(serial_hds
[i
], "serial%d console\r\n", i
);
10316 for(i
= 0; i
< MAX_PARALLEL_PORTS
; i
++) {
10317 const char *devname
= parallel_devices
[i
];
10318 if (devname
&& strcmp(devname
, "none")) {
10319 parallel_hds
[i
] = qemu_chr_open(devname
);
10320 if (!parallel_hds
[i
]) {
10321 fprintf(stderr
, "qemu: could not open parallel device '%s'\n",
10325 if (strstart(devname
, "vc", 0))
10326 qemu_chr_printf(parallel_hds
[i
], "parallel%d console\r\n", i
);
10333 machine
->init(ram_size
, vga_ram_size
, boot_devices
, ds
,
10334 kernel_filename
, kernel_cmdline
, initrd_filename
, cpu_model
);
10336 current_machine
= machine
;
10338 /* init USB devices */
10340 for(i
= 0; i
< usb_devices_index
; i
++) {
10341 if (usb_device_add(usb_devices
[i
]) < 0) {
10342 fprintf(stderr
, "Warning: could not add USB device %s\n",
10348 if (display_state
.dpy_refresh
) {
10349 display_state
.gui_timer
= qemu_new_timer(rt_clock
, gui_update
, &display_state
);
10350 qemu_mod_timer(display_state
.gui_timer
, qemu_get_clock(rt_clock
));
10353 #ifdef CONFIG_GDBSTUB
10355 /* XXX: use standard host:port notation and modify options
10357 if (gdbserver_start(gdbstub_port
) < 0) {
10358 fprintf(stderr
, "qemu: could not open gdbstub device on port '%s'\n",
10369 autostart
= 0; /* fixme how to deal with -daemonize */
10370 qemu_start_incoming_migration(incoming
);
10374 /* XXX: simplify init */
10382 uint8_t status
= 0;
10387 len
= write(fds
[1], &status
, 1);
10388 if (len
== -1 && (errno
== EINTR
))
10395 TFR(fd
= open("/dev/null", O_RDWR
));
10409 #if !defined(_WIN32)
10410 /* close network clients */
10411 for(vlan
= first_vlan
; vlan
!= NULL
; vlan
= vlan
->next
) {
10412 VLANClientState
*vc
;
10414 for(vc
= vlan
->first_client
; vc
!= NULL
; vc
= vc
->next
) {
10415 if (vc
->fd_read
== tap_receive
) {
10417 TAPState
*s
= vc
->opaque
;
10419 if (sscanf(vc
->info_str
, "tap: ifname=%63s ", ifname
) == 1 &&
10421 launch_script(s
->down_script
, ifname
, s
->fd
);
10423 #if defined(CONFIG_VDE)
10424 if (vc
->fd_read
== vde_from_qemu
) {
10425 VDEState
*s
= vc
->opaque
;