]> Git Repo - qemu.git/blame - vl.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Include <strings.h> for ffs().
[qemu.git] / vl.c
CommitLineData
0824d6fc 1/*
80cabfad 2 * QEMU System Emulator
5fafdf24 3 *
68d0f70e 4 * Copyright (c) 2003-2008 Fabrice Bellard
5fafdf24 5 *
1df912cf
FB		 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:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
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
22 * THE SOFTWARE.
0824d6fc 23 */
87ecb68b
PB		 24#include "hw/hw.h"
25#include "hw/boards.h"
26#include "hw/usb.h"
27#include "hw/pcmcia.h"
28#include "hw/pc.h"
87ecb68b
PB		 29#include "hw/audiodev.h"
30#include "hw/isa.h"
2e4d9fb1 31#include "hw/baum.h"
1ae26a18 32#include "hw/bt.h"
87ecb68b
PB		 33#include "net.h"
34#include "console.h"
35#include "sysemu.h"
36#include "gdbstub.h"
37#include "qemu-timer.h"
38#include "qemu-char.h"
39#include "block.h"
40#include "audio/audio.h"
5bb7910a 41#include "migration.h"
7ba1e619 42#include "kvm.h"
67b915a5 43
0824d6fc 44#include <unistd.h>
0824d6fc
FB		 45#include <fcntl.h>
46#include <signal.h>
47#include <time.h>
0824d6fc 48#include <errno.h>
67b915a5 49#include <sys/time.h>
c88676f8 50#include <zlib.h>
67b915a5
FB		 51
52#ifndef _WIN32
53#include <sys/times.h>
f1510b2c 54#include <sys/wait.h>
67b915a5 55#include <termios.h>
67b915a5 56#include <sys/mman.h>
f1510b2c 57#include <sys/ioctl.h>
24646c7e 58#include <sys/resource.h>
f1510b2c 59#include <sys/socket.h>
c94c8d64 60#include <netinet/in.h>
24646c7e
BS		 61#include <net/if.h>
62#if defined(__NetBSD__)
63#include <net/if_tap.h>
64#endif
65#ifdef __linux__
66#include <linux/if_tun.h>
67#endif
68#include <arpa/inet.h>
9d728e8c 69#include <dirent.h>
7c9d8e07 70#include <netdb.h>
cb4b976b 71#include <sys/select.h>
7d3505c5
FB		 72#ifdef _BSD
73#include <sys/stat.h>
24646c7e 74#ifdef __FreeBSD__
7d3505c5 75#include <libutil.h>
24646c7e
BS		 76#else
77#include <util.h>
128ab2ff 78#endif
5c40d2bd
TS		 79#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
80#include <freebsd/stdlib.h>
7d3505c5 81#else
223f0d72 82#ifdef __linux__
7d3505c5
FB		 83#include <pty.h>
84#include <malloc.h>
fd872598 85#include <linux/rtc.h>
bd494f4c
TS		 86
87/* For the benefit of older linux systems which don't supply it,
88 we use a local copy of hpet.h. */
89/* #include <linux/hpet.h> */
90#include "hpet.h"
91
e57a8c0e 92#include <linux/ppdev.h>
5867c88a 93#include <linux/parport.h>
223f0d72
BS		 94#endif
95#ifdef __sun__
d5d10bc3
TS		 96#include <sys/stat.h>
97#include <sys/ethernet.h>
98#include <sys/sockio.h>
d5d10bc3
TS		 99#include <netinet/arp.h>
100#include <netinet/in.h>
101#include <netinet/in_systm.h>
102#include <netinet/ip.h>
103#include <netinet/ip_icmp.h> // must come after ip.h
104#include <netinet/udp.h>
105#include <netinet/tcp.h>
106#include <net/if.h>
107#include <syslog.h>
108#include <stropts.h>
67b915a5 109#endif
7d3505c5 110#endif
ec530c81 111#endif
67b915a5 112
03ff3ca3
AL		 113#include "qemu_socket.h"
114
c20709aa
FB		 115#if defined(CONFIG_SLIRP)
116#include "libslirp.h"
117#endif
118
9892fbfb
BS		 119#if defined(__OpenBSD__)
120#include <util.h>
121#endif
122
8a16d273
TS		 123#if defined(CONFIG_VDE)
124#include <libvdeplug.h>
125#endif
126
67b915a5 127#ifdef _WIN32
7d3505c5 128#include <malloc.h>
67b915a5 129#include <sys/timeb.h>
4fddf62a 130#include <mmsystem.h>
67b915a5
FB		 131#define getopt_long_only getopt_long
132#define memalign(align, size) malloc(size)
133#endif
134
73332e5c 135#ifdef CONFIG_SDL
96bcd4f8 136#ifdef __APPLE__
83fb7adf 137#include <SDL/SDL.h>
96bcd4f8 138#endif
73332e5c 139#endif /* CONFIG_SDL */
0824d6fc 140
5b0753e0
FB		 141#ifdef CONFIG_COCOA
142#undef main
143#define main qemu_main
144#endif /* CONFIG_COCOA */
145
0824d6fc 146#include "disas.h"
fc01f7e7 147
8a7ddc38 148#include "exec-all.h"
0824d6fc 149
5a67135a 150#define DEFAULT_NETWORK_SCRIPT "/etc/qemu-ifup"
b46a8906 151#define DEFAULT_NETWORK_DOWN_SCRIPT "/etc/qemu-ifdown"
a14d6c8c
PB		 152#ifdef __sun__
153#define SMBD_COMMAND "/usr/sfw/sbin/smbd"
154#else
155#define SMBD_COMMAND "/usr/sbin/smbd"
156#endif
f1510b2c 157
0824d6fc 158//#define DEBUG_UNUSED_IOPORT
fd872598 159//#define DEBUG_IOPORT
9dc63a1e
BS		 160//#define DEBUG_NET
161//#define DEBUG_SLIRP
330d0414 162
77d4bc34
FB		 163#ifdef TARGET_PPC
164#define DEFAULT_RAM_SIZE 144
165#else
1bfe856e 166#define DEFAULT_RAM_SIZE 128
77d4bc34 167#endif
313aa567 168
0d92ed30
PB		 169/* Max number of USB devices that can be specified on the commandline. */
170#define MAX_USB_CMDLINE 8
171
dc72ac14
AZ		 172/* Max number of bluetooth switches on the commandline. */
173#define MAX_BT_CMDLINE 10
174
7dea1da4
FB		 175/* XXX: use a two level table to limit memory usage */
176#define MAX_IOPORTS 65536
0824d6fc 177
80cabfad 178const char *bios_dir = CONFIG_QEMU_SHAREDIR;
1192dad8 179const char *bios_name = NULL;
dbed7e40
BS		 180static void *ioport_opaque[MAX_IOPORTS];
181static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
182static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
e4bcb14c 183/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
faea38e7 184 to store the VM snapshots */
e4bcb14c
TS		 185DriveInfo drives_table[MAX_DRIVES+1];
186int nb_drives;
dbed7e40 187static int vga_ram_size;
cb5a7aa8 188enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
0e82f34d 189DisplayState display_state;
a20dd508 190int nographic;
dbed7e40 191static int curses;
3d11d0eb 192const char* keyboard_layout = NULL;
313aa567 193int64_t ticks_per_sec;
00f82b8a 194ram_addr_t ram_size;
c4b1fcc0 195int nb_nics;
7c9d8e07 196NICInfo nd_table[MAX_NICS];
8a7ddc38 197int vm_running;
f6503059
AZ		 198static int rtc_utc = 1;
199static int rtc_date_offset = -1; /* -1 means no change */
1bfe856e 200int cirrus_vga_enabled = 1;
d34cab9f 201int vmsvga_enabled = 0;
d827220b
FB		 202#ifdef TARGET_SPARC
203int graphic_width = 1024;
204int graphic_height = 768;
eee0b836 205int graphic_depth = 8;
d827220b 206#else
1bfe856e
FB		 207int graphic_width = 800;
208int graphic_height = 600;
e9b137c2 209int graphic_depth = 15;
eee0b836 210#endif
dbed7e40
BS		 211static int full_screen = 0;
212static int no_frame = 0;
667accab 213int no_quit = 0;
8d11df9e 214CharDriverState *serial_hds[MAX_SERIAL_PORTS];
6508fe59 215CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
a09db21f
FB		 216#ifdef TARGET_I386
217int win2k_install_hack = 0;
218#endif
bb36d470 219int usb_enabled = 0;
6a00d601 220int smp_cpus = 1;
73fc9742 221const char *vnc_display;
6515b203 222int acpi_enabled = 1;
52ca8d6a 223int fd_bootchk = 1;
d1beab82 224int no_reboot = 0;
b2f76161 225int no_shutdown = 0;
9467cd46 226int cursor_hide = 1;
a171fe39 227int graphic_rotate = 0;
71e3ceb8 228int daemonize = 0;
9ae02555
TS		 229const char *option_rom[MAX_OPTION_ROMS];
230int nb_option_roms;
8e71621f 231int semihosting_enabled = 0;
2b8f2d41
AZ		 232#ifdef TARGET_ARM
233int old_param = 0;
234#endif
c35734b2 235const char *qemu_name;
3780e197 236int alt_grab = 0;
66508601
BS		 237#ifdef TARGET_SPARC
238unsigned int nb_prom_envs = 0;
239const char *prom_envs[MAX_PROM_ENVS];
240#endif
dbed7e40
BS		 241static int nb_drives_opt;
242static struct drive_opt {
609497ab
AZ		 243 const char *file;
244 char opt[1024];
245} drives_opt[MAX_DRIVES];
0824d6fc 246
ee5605e5
AZ		 247static CPUState *cur_cpu;
248static CPUState *next_cpu;
76ea08f9 249static int event_pending = 1;
bf20dc07 250/* Conversion factor from emulated instructions to virtual clock ticks. */
2e70f6ef 251static int icount_time_shift;
bf20dc07 252/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
2e70f6ef
PB		 253#define MAX_ICOUNT_SHIFT 10
254/* Compensate for varying guest execution speed. */
255static int64_t qemu_icount_bias;
dbed7e40
BS		 256static QEMUTimer *icount_rt_timer;
257static QEMUTimer *icount_vm_timer;
ee5605e5 258
8fcb1b90
BS		 259uint8_t qemu_uuid[16];
260
0824d6fc 261/***********************************************************/
26aa7d72
FB		 262/* x86 ISA bus support */
263
264target_phys_addr_t isa_mem_base = 0;
3de388f6 265PicState2 *isa_pic;
0824d6fc 266
477e3edf
AL		 267static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
268static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
269
270static uint32_t ioport_read(int index, uint32_t address)
271{
272 static IOPortReadFunc *default_func[3] = {
273 default_ioport_readb,
274 default_ioport_readw,
275 default_ioport_readl
276 };
277 IOPortReadFunc *func = ioport_read_table[index][address];
278 if (!func)
279 func = default_func[index];
280 return func(ioport_opaque[address], address);
281}
282
283static void ioport_write(int index, uint32_t address, uint32_t data)
284{
285 static IOPortWriteFunc *default_func[3] = {
286 default_ioport_writeb,
287 default_ioport_writew,
288 default_ioport_writel
289 };
290 IOPortWriteFunc *func = ioport_write_table[index][address];
291 if (!func)
292 func = default_func[index];
293 func(ioport_opaque[address], address, data);
294}
295
9596ebb7 296static uint32_t default_ioport_readb(void *opaque, uint32_t address)
0824d6fc
FB		 297{
298#ifdef DEBUG_UNUSED_IOPORT
1196be37 299 fprintf(stderr, "unused inb: port=0x%04x\n", address);
0824d6fc 300#endif
fc01f7e7 301 return 0xff;
0824d6fc
FB		 302}
303
9596ebb7 304static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
0824d6fc
FB		 305{
306#ifdef DEBUG_UNUSED_IOPORT
1196be37 307 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
0824d6fc
FB		 308#endif
309}
310
311/* default is to make two byte accesses */
9596ebb7 312static uint32_t default_ioport_readw(void *opaque, uint32_t address)
0824d6fc
FB		 313{
314 uint32_t data;
477e3edf 315 data = ioport_read(0, address);
db45c29a 316 address = (address + 1) & (MAX_IOPORTS - 1);
477e3edf 317 data |= ioport_read(0, address) << 8;
0824d6fc
FB		 318 return data;
319}
320
9596ebb7 321static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
0824d6fc 322{
477e3edf 323 ioport_write(0, address, data & 0xff);
db45c29a 324 address = (address + 1) & (MAX_IOPORTS - 1);
477e3edf 325 ioport_write(0, address, (data >> 8) & 0xff);
0824d6fc
FB		 326}
327
9596ebb7 328static uint32_t default_ioport_readl(void *opaque, uint32_t address)
0824d6fc 329{
fc01f7e7 330#ifdef DEBUG_UNUSED_IOPORT
1196be37 331 fprintf(stderr, "unused inl: port=0x%04x\n", address);
fc01f7e7
FB		 332#endif
333 return 0xffffffff;
0824d6fc
FB		 334}
335
9596ebb7 336static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
0824d6fc 337{
fc01f7e7 338#ifdef DEBUG_UNUSED_IOPORT
1196be37 339 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
fc01f7e7 340#endif
0824d6fc
FB		 341}
342
fc01f7e7 343/* size is the word size in byte */
5fafdf24 344int register_ioport_read(int start, int length, int size,
c4b1fcc0 345 IOPortReadFunc *func, void *opaque)
f1510b2c 346{
fc01f7e7 347 int i, bsize;
f1510b2c 348
c4b1fcc0 349 if (size == 1) {
fc01f7e7 350 bsize = 0;
c4b1fcc0 351 } else if (size == 2) {
fc01f7e7 352 bsize = 1;
c4b1fcc0 353 } else if (size == 4) {
fc01f7e7 354 bsize = 2;
c4b1fcc0 355 } else {
88fdf56f 356 hw_error("register_ioport_read: invalid size");
fc01f7e7 357 return -1;
c4b1fcc0
FB		 358 }
359 for(i = start; i < start + length; i += size) {
fc01f7e7 360 ioport_read_table[bsize][i] = func;
c4b1fcc0 361 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
88fdf56f 362 hw_error("register_ioport_read: invalid opaque");
c4b1fcc0
FB		 363 ioport_opaque[i] = opaque;
364 }
f1510b2c
FB		 365 return 0;
366}
367
fc01f7e7 368/* size is the word size in byte */
5fafdf24 369int register_ioport_write(int start, int length, int size,
c4b1fcc0 370 IOPortWriteFunc *func, void *opaque)
f1510b2c 371{
fc01f7e7 372 int i, bsize;
f1510b2c 373
c4b1fcc0 374 if (size == 1) {
fc01f7e7 375 bsize = 0;
c4b1fcc0 376 } else if (size == 2) {
fc01f7e7 377 bsize = 1;
c4b1fcc0 378 } else if (size == 4) {
fc01f7e7 379 bsize = 2;
c4b1fcc0 380 } else {
88fdf56f 381 hw_error("register_ioport_write: invalid size");
fc01f7e7 382 return -1;
c4b1fcc0
FB		 383 }
384 for(i = start; i < start + length; i += size) {
fc01f7e7 385 ioport_write_table[bsize][i] = func;
88fdf56f
AZ		 386 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
387 hw_error("register_ioport_write: invalid opaque");
c4b1fcc0
FB		 388 ioport_opaque[i] = opaque;
389 }
f1510b2c
FB		 390 return 0;
391}
392
69b91039
FB		 393void isa_unassign_ioport(int start, int length)
394{
395 int i;
396
397 for(i = start; i < start + length; i++) {
398 ioport_read_table[0][i] = default_ioport_readb;
399 ioport_read_table[1][i] = default_ioport_readw;
400 ioport_read_table[2][i] = default_ioport_readl;
401
402 ioport_write_table[0][i] = default_ioport_writeb;
403 ioport_write_table[1][i] = default_ioport_writew;
404 ioport_write_table[2][i] = default_ioport_writel;
405 }
406}
407
20f32282
FB		 408/***********************************************************/
409
c45886db 410void cpu_outb(CPUState *env, int addr, int val)
0824d6fc 411{
fd872598
FB		 412#ifdef DEBUG_IOPORT
413 if (loglevel & CPU_LOG_IOPORT)
414 fprintf(logfile, "outb: %04x %02x\n", addr, val);
3b46e624 415#endif
477e3edf 416 ioport_write(0, addr, val);
89bfc105
FB		 417#ifdef USE_KQEMU
418 if (env)
419 env->last_io_time = cpu_get_time_fast();
420#endif
0824d6fc
FB		 421}
422
c45886db 423void cpu_outw(CPUState *env, int addr, int val)
0824d6fc 424{
fd872598
FB		 425#ifdef DEBUG_IOPORT
426 if (loglevel & CPU_LOG_IOPORT)
427 fprintf(logfile, "outw: %04x %04x\n", addr, val);
3b46e624 428#endif
477e3edf 429 ioport_write(1, addr, val);
89bfc105
FB		 430#ifdef USE_KQEMU
431 if (env)
432 env->last_io_time = cpu_get_time_fast();
433#endif
0824d6fc
FB		 434}
435
c45886db 436void cpu_outl(CPUState *env, int addr, int val)
0824d6fc 437{
fd872598
FB		 438#ifdef DEBUG_IOPORT
439 if (loglevel & CPU_LOG_IOPORT)
440 fprintf(logfile, "outl: %04x %08x\n", addr, val);
441#endif
477e3edf 442 ioport_write(2, addr, val);
89bfc105
FB		 443#ifdef USE_KQEMU
444 if (env)
445 env->last_io_time = cpu_get_time_fast();
446#endif
0824d6fc
FB		 447}
448
c45886db 449int cpu_inb(CPUState *env, int addr)
0824d6fc 450{
fd872598 451 int val;
477e3edf 452 val = ioport_read(0, addr);
fd872598
FB		 453#ifdef DEBUG_IOPORT
454 if (loglevel & CPU_LOG_IOPORT)
455 fprintf(logfile, "inb : %04x %02x\n", addr, val);
89bfc105
FB		 456#endif
457#ifdef USE_KQEMU
458 if (env)
459 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 460#endif
461 return val;
0824d6fc
FB		 462}
463
c45886db 464int cpu_inw(CPUState *env, int addr)
0824d6fc 465{
fd872598 466 int val;
477e3edf 467 val = ioport_read(1, addr);
fd872598
FB		 468#ifdef DEBUG_IOPORT
469 if (loglevel & CPU_LOG_IOPORT)
470 fprintf(logfile, "inw : %04x %04x\n", addr, val);
89bfc105
FB		 471#endif
472#ifdef USE_KQEMU
473 if (env)
474 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 475#endif
476 return val;
0824d6fc
FB		 477}
478
c45886db 479int cpu_inl(CPUState *env, int addr)
0824d6fc 480{
fd872598 481 int val;
477e3edf 482 val = ioport_read(2, addr);
fd872598
FB		 483#ifdef DEBUG_IOPORT
484 if (loglevel & CPU_LOG_IOPORT)
485 fprintf(logfile, "inl : %04x %08x\n", addr, val);
89bfc105
FB		 486#endif
487#ifdef USE_KQEMU
488 if (env)
489 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 490#endif
491 return val;
0824d6fc
FB		 492}
493
494/***********************************************************/
0824d6fc
FB		 495void hw_error(const char *fmt, ...)
496{
497 va_list ap;
6a00d601 498 CPUState *env;
0824d6fc
FB		 499
500 va_start(ap, fmt);
501 fprintf(stderr, "qemu: hardware error: ");
502 vfprintf(stderr, fmt, ap);
503 fprintf(stderr, "\n");
6a00d601
FB		 504 for(env = first_cpu; env != NULL; env = env->next_cpu) {
505 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
0824d6fc 506#ifdef TARGET_I386
6a00d601 507 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
c45886db 508#else
6a00d601 509 cpu_dump_state(env, stderr, fprintf, 0);
0824d6fc 510#endif
6a00d601 511 }
0824d6fc
FB		 512 va_end(ap);
513 abort();
514}
515
63066f4f
FB		 516/***********************************************************/
517/* keyboard/mouse */
518
519static QEMUPutKBDEvent *qemu_put_kbd_event;
520static void *qemu_put_kbd_event_opaque;
455204eb
TS		 521static QEMUPutMouseEntry *qemu_put_mouse_event_head;
522static QEMUPutMouseEntry *qemu_put_mouse_event_current;
63066f4f
FB		 523
524void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
525{
526 qemu_put_kbd_event_opaque = opaque;
527 qemu_put_kbd_event = func;
528}
529
455204eb
TS		 530QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
531 void *opaque, int absolute,
532 const char *name)
63066f4f 533{
455204eb
TS		 534 QEMUPutMouseEntry *s, *cursor;
535
536 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
537 if (!s)
538 return NULL;
539
540 s->qemu_put_mouse_event = func;
541 s->qemu_put_mouse_event_opaque = opaque;
542 s->qemu_put_mouse_event_absolute = absolute;
543 s->qemu_put_mouse_event_name = qemu_strdup(name);
544 s->next = NULL;
545
546 if (!qemu_put_mouse_event_head) {
547 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
548 return s;
549 }
550
551 cursor = qemu_put_mouse_event_head;
552 while (cursor->next != NULL)
553 cursor = cursor->next;
554
555 cursor->next = s;
556 qemu_put_mouse_event_current = s;
557
558 return s;
559}
560
561void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
562{
563 QEMUPutMouseEntry *prev = NULL, *cursor;
564
565 if (!qemu_put_mouse_event_head || entry == NULL)
566 return;
567
568 cursor = qemu_put_mouse_event_head;
569 while (cursor != NULL && cursor != entry) {
570 prev = cursor;
571 cursor = cursor->next;
572 }
573
574 if (cursor == NULL) // does not exist or list empty
575 return;
576 else if (prev == NULL) { // entry is head
577 qemu_put_mouse_event_head = cursor->next;
578 if (qemu_put_mouse_event_current == entry)
579 qemu_put_mouse_event_current = cursor->next;
580 qemu_free(entry->qemu_put_mouse_event_name);
581 qemu_free(entry);
582 return;
583 }
584
585 prev->next = entry->next;
586
587 if (qemu_put_mouse_event_current == entry)
588 qemu_put_mouse_event_current = prev;
589
590 qemu_free(entry->qemu_put_mouse_event_name);
591 qemu_free(entry);
63066f4f
FB		 592}
593
594void kbd_put_keycode(int keycode)
595{
596 if (qemu_put_kbd_event) {
597 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
598 }
599}
600
601void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
602{
455204eb
TS		 603 QEMUPutMouseEvent *mouse_event;
604 void *mouse_event_opaque;
a171fe39 605 int width;
455204eb
TS		 606
607 if (!qemu_put_mouse_event_current) {
608 return;
609 }
610
611 mouse_event =
612 qemu_put_mouse_event_current->qemu_put_mouse_event;
613 mouse_event_opaque =
614 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
615
616 if (mouse_event) {
a171fe39
AZ		 617 if (graphic_rotate) {
618 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
619 width = 0x7fff;
620 else
b94ed577 621 width = graphic_width - 1;
a171fe39
AZ		 622 mouse_event(mouse_event_opaque,
623 width - dy, dx, dz, buttons_state);
624 } else
625 mouse_event(mouse_event_opaque,
626 dx, dy, dz, buttons_state);
63066f4f
FB		 627 }
628}
629
09b26c5e
FB		 630int kbd_mouse_is_absolute(void)
631{
455204eb
TS		 632 if (!qemu_put_mouse_event_current)
633 return 0;
634
635 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
636}
637
638void do_info_mice(void)
639{
640 QEMUPutMouseEntry *cursor;
641 int index = 0;
642
643 if (!qemu_put_mouse_event_head) {
644 term_printf("No mouse devices connected\n");
645 return;
646 }
647
648 term_printf("Mouse devices available:\n");
649 cursor = qemu_put_mouse_event_head;
650 while (cursor != NULL) {
651 term_printf("%c Mouse #%d: %s\n",
652 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
653 index, cursor->qemu_put_mouse_event_name);
654 index++;
655 cursor = cursor->next;
656 }
657}
658
659void do_mouse_set(int index)
660{
661 QEMUPutMouseEntry *cursor;
662 int i = 0;
663
664 if (!qemu_put_mouse_event_head) {
665 term_printf("No mouse devices connected\n");
666 return;
667 }
668
669 cursor = qemu_put_mouse_event_head;
670 while (cursor != NULL && index != i) {
671 i++;
672 cursor = cursor->next;
673 }
674
675 if (cursor != NULL)
676 qemu_put_mouse_event_current = cursor;
677 else
678 term_printf("Mouse at given index not found\n");
09b26c5e
FB		 679}
680
1dce7c3c
FB		 681/* compute with 96 bit intermediate result: (a*b)/c */
682uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
0824d6fc 683{
1dce7c3c
FB		 684 union {
685 uint64_t ll;
686 struct {
687#ifdef WORDS_BIGENDIAN
688 uint32_t high, low;
689#else
690 uint32_t low, high;
3b46e624 691#endif
1dce7c3c
FB		 692 } l;
693 } u, res;
694 uint64_t rl, rh;
0824d6fc 695
1dce7c3c
FB		 696 u.ll = a;
697 rl = (uint64_t)u.l.low * (uint64_t)b;
698 rh = (uint64_t)u.l.high * (uint64_t)b;
699 rh += (rl >> 32);
700 res.l.high = rh / c;
701 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
702 return res.ll;
34865134
FB		 703}
704
1dce7c3c
FB		 705/***********************************************************/
706/* real time host monotonic timer */
34865134 707
1dce7c3c 708#define QEMU_TIMER_BASE 1000000000LL
34865134 709
1dce7c3c 710#ifdef WIN32
0824d6fc 711
1dce7c3c 712static int64_t clock_freq;
1115dde7 713
1dce7c3c 714static void init_get_clock(void)
1115dde7 715{
a8e5ac33
FB		 716 LARGE_INTEGER freq;
717 int ret;
1dce7c3c
FB		 718 ret = QueryPerformanceFrequency(&freq);
719 if (ret == 0) {
720 fprintf(stderr, "Could not calibrate ticks\n");
721 exit(1);
722 }
723 clock_freq = freq.QuadPart;
1115dde7
FB		 724}
725
1dce7c3c 726static int64_t get_clock(void)
b8076a74 727{
1dce7c3c
FB		 728 LARGE_INTEGER ti;
729 QueryPerformanceCounter(&ti);
730 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
b8076a74
FB		 731}
732
1dce7c3c 733#else
90cb9493 734
1dce7c3c
FB		 735static int use_rt_clock;
736
737static void init_get_clock(void)
90cb9493 738{
1dce7c3c 739 use_rt_clock = 0;
60759371 740#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
1dce7c3c
FB		 741 {
742 struct timespec ts;
743 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
744 use_rt_clock = 1;
745 }
746 }
747#endif
90cb9493
FB		 748}
749
1dce7c3c 750static int64_t get_clock(void)
fdbb4691 751{
60759371 752#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000)
1dce7c3c
FB		 753 if (use_rt_clock) {
754 struct timespec ts;
755 clock_gettime(CLOCK_MONOTONIC, &ts);
756 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
5fafdf24 757 } else
fdbb4691 758#endif
1dce7c3c
FB		 759 {
760 /* XXX: using gettimeofday leads to problems if the date
761 changes, so it should be avoided. */
762 struct timeval tv;
763 gettimeofday(&tv, NULL);
764 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
765 }
fdbb4691 766}
34865134
FB		 767#endif
768
2e70f6ef
PB		 769/* Return the virtual CPU time, based on the instruction counter. */
770static int64_t cpu_get_icount(void)
771{
772 int64_t icount;
773 CPUState *env = cpu_single_env;;
774 icount = qemu_icount;
775 if (env) {
776 if (!can_do_io(env))
777 fprintf(stderr, "Bad clock read\n");
778 icount -= (env->icount_decr.u16.low + env->icount_extra);
779 }
780 return qemu_icount_bias + (icount << icount_time_shift);
781}
782
1dce7c3c
FB		 783/***********************************************************/
784/* guest cycle counter */
785
eade0f19 786static int64_t cpu_ticks_prev;
34865134 787static int64_t cpu_ticks_offset;
1dce7c3c 788static int64_t cpu_clock_offset;
8a7ddc38 789static int cpu_ticks_enabled;
34865134 790
1dce7c3c
FB		 791/* return the host CPU cycle counter and handle stop/restart */
792int64_t cpu_get_ticks(void)
34865134 793{
2e70f6ef
PB		 794 if (use_icount) {
795 return cpu_get_icount();
796 }
8a7ddc38
FB		 797 if (!cpu_ticks_enabled) {
798 return cpu_ticks_offset;
799 } else {
eade0f19
FB		 800 int64_t ticks;
801 ticks = cpu_get_real_ticks();
802 if (cpu_ticks_prev > ticks) {
803 /* Note: non increasing ticks may happen if the host uses
804 software suspend */
805 cpu_ticks_offset += cpu_ticks_prev - ticks;
806 }
807 cpu_ticks_prev = ticks;
808 return ticks + cpu_ticks_offset;
8a7ddc38 809 }
34865134
FB		 810}
811
1dce7c3c
FB		 812/* return the host CPU monotonic timer and handle stop/restart */
813static int64_t cpu_get_clock(void)
814{
815 int64_t ti;
816 if (!cpu_ticks_enabled) {
817 return cpu_clock_offset;
818 } else {
819 ti = get_clock();
820 return ti + cpu_clock_offset;
821 }
822}
823
34865134
FB		 824/* enable cpu_get_ticks() */
825void cpu_enable_ticks(void)
826{
8a7ddc38
FB		 827 if (!cpu_ticks_enabled) {
828 cpu_ticks_offset -= cpu_get_real_ticks();
1dce7c3c 829 cpu_clock_offset -= get_clock();
8a7ddc38
FB		 830 cpu_ticks_enabled = 1;
831 }
34865134
FB		 832}
833
834/* disable cpu_get_ticks() : the clock is stopped. You must not call
835 cpu_get_ticks() after that. */
836void cpu_disable_ticks(void)
837{
8a7ddc38
FB		 838 if (cpu_ticks_enabled) {
839 cpu_ticks_offset = cpu_get_ticks();
1dce7c3c 840 cpu_clock_offset = cpu_get_clock();
8a7ddc38
FB		 841 cpu_ticks_enabled = 0;
842 }
34865134
FB		 843}
844
1dce7c3c
FB		 845/***********************************************************/
846/* timers */
5fafdf24 847
8a7ddc38
FB		 848#define QEMU_TIMER_REALTIME 0
849#define QEMU_TIMER_VIRTUAL 1
850
851struct QEMUClock {
852 int type;
853 /* XXX: add frequency */
854};
855
856struct QEMUTimer {
857 QEMUClock *clock;
858 int64_t expire_time;
859 QEMUTimerCB *cb;
860 void *opaque;
861 struct QEMUTimer *next;
862};
863
c8994013
TS		 864struct qemu_alarm_timer {
865 char const *name;
efe75411 866 unsigned int flags;
c8994013
TS		 867
868 int (*start)(struct qemu_alarm_timer *t);
869 void (*stop)(struct qemu_alarm_timer *t);
efe75411 870 void (*rearm)(struct qemu_alarm_timer *t);
c8994013
TS		 871 void *priv;
872};
873
efe75411 874#define ALARM_FLAG_DYNTICKS 0x1
d5d08334 875#define ALARM_FLAG_EXPIRED 0x2
efe75411
TS		 876
877static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
878{
879 return t->flags & ALARM_FLAG_DYNTICKS;
880}
881
882static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
883{
884 if (!alarm_has_dynticks(t))
885 return;
886
887 t->rearm(t);
888}
889
890/* TODO: MIN_TIMER_REARM_US should be optimized */
891#define MIN_TIMER_REARM_US 250
892
c8994013 893static struct qemu_alarm_timer *alarm_timer;
f49e58dc 894#ifndef _WIN32
c96f1a48 895static int alarm_timer_rfd, alarm_timer_wfd;
f49e58dc 896#endif
8a7ddc38 897
40c3bac3 898#ifdef _WIN32
c8994013
TS		 899
900struct qemu_alarm_win32 {
901 MMRESULT timerId;
902 HANDLE host_alarm;
903 unsigned int period;
904} alarm_win32_data = {0, NULL, -1};
905
906static int win32_start_timer(struct qemu_alarm_timer *t);
907static void win32_stop_timer(struct qemu_alarm_timer *t);
efe75411 908static void win32_rearm_timer(struct qemu_alarm_timer *t);
c8994013 909
40c3bac3 910#else
c8994013
TS		 911
912static int unix_start_timer(struct qemu_alarm_timer *t);
913static void unix_stop_timer(struct qemu_alarm_timer *t);
914
231c6586
TS		 915#ifdef __linux__
916
efe75411
TS		 917static int dynticks_start_timer(struct qemu_alarm_timer *t);
918static void dynticks_stop_timer(struct qemu_alarm_timer *t);
919static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
920
c40ec5a9
TS		 921static int hpet_start_timer(struct qemu_alarm_timer *t);
922static void hpet_stop_timer(struct qemu_alarm_timer *t);
923
c8994013
TS		 924static int rtc_start_timer(struct qemu_alarm_timer *t);
925static void rtc_stop_timer(struct qemu_alarm_timer *t);
926
efe75411 927#endif /* __linux__ */
8a7ddc38 928
c8994013
TS		 929#endif /* _WIN32 */
930
2e70f6ef 931/* Correlation between real and virtual time is always going to be
bf20dc07 932 fairly approximate, so ignore small variation.
2e70f6ef
PB		 933 When the guest is idle real and virtual time will be aligned in
934 the IO wait loop. */
935#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
936
937static void icount_adjust(void)
938{
939 int64_t cur_time;
940 int64_t cur_icount;
941 int64_t delta;
942 static int64_t last_delta;
943 /* If the VM is not running, then do nothing. */
944 if (!vm_running)
945 return;
946
947 cur_time = cpu_get_clock();
948 cur_icount = qemu_get_clock(vm_clock);
949 delta = cur_icount - cur_time;
950 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
951 if (delta > 0
952 && last_delta + ICOUNT_WOBBLE < delta * 2
953 && icount_time_shift > 0) {
954 /* The guest is getting too far ahead. Slow time down. */
955 icount_time_shift--;
956 }
957 if (delta < 0
958 && last_delta - ICOUNT_WOBBLE > delta * 2
959 && icount_time_shift < MAX_ICOUNT_SHIFT) {
960 /* The guest is getting too far behind. Speed time up. */
961 icount_time_shift++;
962 }
963 last_delta = delta;
964 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
965}
966
967static void icount_adjust_rt(void * opaque)
968{
969 qemu_mod_timer(icount_rt_timer,
970 qemu_get_clock(rt_clock) + 1000);
971 icount_adjust();
972}
973
974static void icount_adjust_vm(void * opaque)
975{
976 qemu_mod_timer(icount_vm_timer,
977 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
978 icount_adjust();
979}
980
981static void init_icount_adjust(void)
982{
983 /* Have both realtime and virtual time triggers for speed adjustment.
984 The realtime trigger catches emulated time passing too slowly,
985 the virtual time trigger catches emulated time passing too fast.
986 Realtime triggers occur even when idle, so use them less frequently
987 than VM triggers. */
988 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
989 qemu_mod_timer(icount_rt_timer,
990 qemu_get_clock(rt_clock) + 1000);
991 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
992 qemu_mod_timer(icount_vm_timer,
993 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
994}
995
c8994013 996static struct qemu_alarm_timer alarm_timers[] = {
efe75411 997#ifndef _WIN32
231c6586 998#ifdef __linux__
efe75411
TS		 999 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1000 dynticks_stop_timer, dynticks_rearm_timer, NULL},
c40ec5a9 1001 /* HPET - if available - is preferred */
efe75411 1002 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
c40ec5a9 1003 /* ...otherwise try RTC */
efe75411 1004 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
c8994013 1005#endif
efe75411 1006 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
c8994013 1007#else
efe75411
TS		 1008 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1009 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1010 {"win32", 0, win32_start_timer,
1011 win32_stop_timer, NULL, &alarm_win32_data},
c8994013
TS		 1012#endif
1013 {NULL, }
1014};
1015
3f47aa8c 1016static void show_available_alarms(void)
f3dcfada
TS		 1017{
1018 int i;
1019
1020 printf("Available alarm timers, in order of precedence:\n");
1021 for (i = 0; alarm_timers[i].name; i++)
1022 printf("%s\n", alarm_timers[i].name);
1023}
1024
1025static void configure_alarms(char const *opt)
1026{
1027 int i;
1028 int cur = 0;
1029 int count = (sizeof(alarm_timers) / sizeof(*alarm_timers)) - 1;
1030 char *arg;
1031 char *name;
2e70f6ef 1032 struct qemu_alarm_timer tmp;
f3dcfada 1033
3adda04c 1034 if (!strcmp(opt, "?")) {
f3dcfada
TS		 1035 show_available_alarms();
1036 exit(0);
1037 }
1038
1039 arg = strdup(opt);
1040
1041 /* Reorder the array */
1042 name = strtok(arg, ",");
1043 while (name) {
e2b577e5 1044 for (i = 0; i < count && alarm_timers[i].name; i++) {
f3dcfada
TS		 1045 if (!strcmp(alarm_timers[i].name, name))
1046 break;
1047 }
1048
1049 if (i == count) {
1050 fprintf(stderr, "Unknown clock %s\n", name);
1051 goto next;
1052 }
1053
1054 if (i < cur)
1055 /* Ignore */
1056 goto next;
1057
1058 /* Swap */
1059 tmp = alarm_timers[i];
1060 alarm_timers[i] = alarm_timers[cur];
1061 alarm_timers[cur] = tmp;
1062
1063 cur++;
1064next:
1065 name = strtok(NULL, ",");
1066 }
1067
1068 free(arg);
1069
1070 if (cur) {
2e70f6ef 1071 /* Disable remaining timers */
f3dcfada
TS		 1072 for (i = cur; i < count; i++)
1073 alarm_timers[i].name = NULL;
3adda04c
AJ		 1074 } else {
1075 show_available_alarms();
1076 exit(1);
f3dcfada 1077 }
f3dcfada
TS		 1078}
1079
c8994013
TS		 1080QEMUClock *rt_clock;
1081QEMUClock *vm_clock;
1082
1083static QEMUTimer *active_timers[2];
1084
9596ebb7 1085static QEMUClock *qemu_new_clock(int type)
8a7ddc38
FB		 1086{
1087 QEMUClock *clock;
1088 clock = qemu_mallocz(sizeof(QEMUClock));
1089 if (!clock)
1090 return NULL;
1091 clock->type = type;
1092 return clock;
1093}
1094
1095QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1096{
1097 QEMUTimer *ts;
1098
1099 ts = qemu_mallocz(sizeof(QEMUTimer));
1100 ts->clock = clock;
1101 ts->cb = cb;
1102 ts->opaque = opaque;
1103 return ts;
1104}
1105
1106void qemu_free_timer(QEMUTimer *ts)
1107{
1108 qemu_free(ts);
1109}
1110
1111/* stop a timer, but do not dealloc it */
1112void qemu_del_timer(QEMUTimer *ts)
1113{
1114 QEMUTimer **pt, *t;
1115
1116 /* NOTE: this code must be signal safe because
1117 qemu_timer_expired() can be called from a signal. */
1118 pt = &active_timers[ts->clock->type];
1119 for(;;) {
1120 t = *pt;
1121 if (!t)
1122 break;
1123 if (t == ts) {
1124 *pt = t->next;
1125 break;
1126 }
1127 pt = &t->next;
1128 }
1129}
1130
1131/* modify the current timer so that it will be fired when current_time
1132 >= expire_time. The corresponding callback will be called. */
1133void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1134{
1135 QEMUTimer **pt, *t;
1136
1137 qemu_del_timer(ts);
1138
1139 /* add the timer in the sorted list */
1140 /* NOTE: this code must be signal safe because
1141 qemu_timer_expired() can be called from a signal. */
1142 pt = &active_timers[ts->clock->type];
1143 for(;;) {
1144 t = *pt;
1145 if (!t)
1146 break;
5fafdf24 1147 if (t->expire_time > expire_time)
8a7ddc38
FB		 1148 break;
1149 pt = &t->next;
1150 }
1151 ts->expire_time = expire_time;
1152 ts->next = *pt;
1153 *pt = ts;
d5d08334
AZ		 1154
1155 /* Rearm if necessary */
2e70f6ef
PB		 1156 if (pt == &active_timers[ts->clock->type]) {
1157 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1158 qemu_rearm_alarm_timer(alarm_timer);
1159 }
1160 /* Interrupt execution to force deadline recalculation. */
1161 if (use_icount && cpu_single_env) {
1162 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
1163 }
1164 }
8a7ddc38
FB		 1165}
1166
1167int qemu_timer_pending(QEMUTimer *ts)
1168{
1169 QEMUTimer *t;
1170 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1171 if (t == ts)
1172 return 1;
1173 }
1174 return 0;
1175}
1176
1177static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1178{
1179 if (!timer_head)
1180 return 0;
1181 return (timer_head->expire_time <= current_time);
1182}
1183
1184static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1185{
1186 QEMUTimer *ts;
3b46e624 1187
8a7ddc38
FB		 1188 for(;;) {
1189 ts = *ptimer_head;
e95c8d51 1190 if (!ts || ts->expire_time > current_time)
8a7ddc38
FB		 1191 break;
1192 /* remove timer from the list before calling the callback */
1193 *ptimer_head = ts->next;
1194 ts->next = NULL;
3b46e624 1195
8a7ddc38
FB		 1196 /* run the callback (the timer list can be modified) */
1197 ts->cb(ts->opaque);
1198 }
1199}
1200
1201int64_t qemu_get_clock(QEMUClock *clock)
1202{
1203 switch(clock->type) {
1204 case QEMU_TIMER_REALTIME:
1dce7c3c 1205 return get_clock() / 1000000;
8a7ddc38
FB		 1206 default:
1207 case QEMU_TIMER_VIRTUAL:
2e70f6ef
PB		 1208 if (use_icount) {
1209 return cpu_get_icount();
1210 } else {
1211 return cpu_get_clock();
1212 }
8a7ddc38
FB		 1213 }
1214}
1215
1dce7c3c
FB		 1216static void init_timers(void)
1217{
1218 init_get_clock();
1219 ticks_per_sec = QEMU_TIMER_BASE;
1220 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1221 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1222}
1223
8a7ddc38
FB		 1224/* save a timer */
1225void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1226{
1227 uint64_t expire_time;
1228
1229 if (qemu_timer_pending(ts)) {
1230 expire_time = ts->expire_time;
1231 } else {
1232 expire_time = -1;
1233 }
1234 qemu_put_be64(f, expire_time);
1235}
1236
1237void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1238{
1239 uint64_t expire_time;
1240
1241 expire_time = qemu_get_be64(f);
1242 if (expire_time != -1) {
1243 qemu_mod_timer(ts, expire_time);
1244 } else {
1245 qemu_del_timer(ts);
1246 }
1247}
1248
1249static void timer_save(QEMUFile *f, void *opaque)
1250{
1251 if (cpu_ticks_enabled) {
1252 hw_error("cannot save state if virtual timers are running");
1253 }
bee8d684
TS		 1254 qemu_put_be64(f, cpu_ticks_offset);
1255 qemu_put_be64(f, ticks_per_sec);
1256 qemu_put_be64(f, cpu_clock_offset);
8a7ddc38
FB		 1257}
1258
1259static int timer_load(QEMUFile *f, void *opaque, int version_id)
1260{
c88676f8 1261 if (version_id != 1 && version_id != 2)
8a7ddc38
FB		 1262 return -EINVAL;
1263 if (cpu_ticks_enabled) {
1264 return -EINVAL;
1265 }
bee8d684
TS		 1266 cpu_ticks_offset=qemu_get_be64(f);
1267 ticks_per_sec=qemu_get_be64(f);
c88676f8 1268 if (version_id == 2) {
bee8d684 1269 cpu_clock_offset=qemu_get_be64(f);
c88676f8 1270 }
8a7ddc38
FB		 1271 return 0;
1272}
1273
67b915a5 1274#ifdef _WIN32
5fafdf24 1275void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
67b915a5
FB		 1276 DWORD_PTR dwUser, DWORD_PTR dw1, DWORD_PTR dw2)
1277#else
8a7ddc38 1278static void host_alarm_handler(int host_signum)
67b915a5 1279#endif
8a7ddc38 1280{
02ba45c5
FB		 1281#if 0
1282#define DISP_FREQ 1000
1283 {
1284 static int64_t delta_min = INT64_MAX;
1285 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1286 static int count;
1287 ti = qemu_get_clock(vm_clock);
1288 if (last_clock != 0) {
1289 delta = ti - last_clock;
1290 if (delta < delta_min)
1291 delta_min = delta;
1292 if (delta > delta_max)
1293 delta_max = delta;
1294 delta_cum += delta;
1295 if (++count == DISP_FREQ) {
26a76461 1296 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
02ba45c5
FB		 1297 muldiv64(delta_min, 1000000, ticks_per_sec),
1298 muldiv64(delta_max, 1000000, ticks_per_sec),
1299 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1300 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1301 count = 0;
1302 delta_min = INT64_MAX;
1303 delta_max = 0;
1304 delta_cum = 0;
1305 }
1306 }
1307 last_clock = ti;
1308 }
1309#endif
efe75411 1310 if (alarm_has_dynticks(alarm_timer) ||
2e70f6ef
PB		 1311 (!use_icount &&
1312 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1313 qemu_get_clock(vm_clock))) ||
8a7ddc38
FB		 1314 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1315 qemu_get_clock(rt_clock))) {
c96f1a48 1316 CPUState *env = next_cpu;
c96f1a48 1317
06d9f2f7 1318#ifdef _WIN32
c8994013
TS		 1319 struct qemu_alarm_win32 *data = ((struct qemu_alarm_timer*)dwUser)->priv;
1320 SetEvent(data->host_alarm);
f49e58dc
AL		 1321#else
1322 static const char byte = 0;
c96f1a48 1323 write(alarm_timer_wfd, &byte, sizeof(byte));
f49e58dc 1324#endif
d5d08334
AZ		 1325 alarm_timer->flags |= ALARM_FLAG_EXPIRED;
1326
4f8eb8da
AZ		 1327 if (env) {
1328 /* stop the currently executing cpu because a timer occured */
1329 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
a332e112 1330#ifdef USE_KQEMU
4f8eb8da
AZ		 1331 if (env->kqemu_enabled) {
1332 kqemu_cpu_interrupt(env);
1333 }
ee5605e5 1334#endif
4f8eb8da 1335 }
ee5605e5 1336 event_pending = 1;
8a7ddc38
FB		 1337 }
1338}
1339
2e70f6ef 1340static int64_t qemu_next_deadline(void)
efe75411 1341{
2e70f6ef 1342 int64_t delta;
efe75411
TS		 1343
1344 if (active_timers[QEMU_TIMER_VIRTUAL]) {
2e70f6ef
PB		 1345 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1346 qemu_get_clock(vm_clock);
1347 } else {
1348 /* To avoid problems with overflow limit this to 2^32. */
1349 delta = INT32_MAX;
efe75411
TS		 1350 }
1351
2e70f6ef
PB		 1352 if (delta < 0)
1353 delta = 0;
efe75411 1354
2e70f6ef
PB		 1355 return delta;
1356}
1357
8632fb9a 1358#if defined(__linux__) || defined(_WIN32)
2e70f6ef
PB		 1359static uint64_t qemu_next_deadline_dyntick(void)
1360{
1361 int64_t delta;
1362 int64_t rtdelta;
1363
1364 if (use_icount)
1365 delta = INT32_MAX;
1366 else
1367 delta = (qemu_next_deadline() + 999) / 1000;
1368
1369 if (active_timers[QEMU_TIMER_REALTIME]) {
1370 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1371 qemu_get_clock(rt_clock))*1000;
1372 if (rtdelta < delta)
1373 delta = rtdelta;
1374 }
1375
1376 if (delta < MIN_TIMER_REARM_US)
1377 delta = MIN_TIMER_REARM_US;
1378
1379 return delta;
efe75411 1380}
8632fb9a 1381#endif
efe75411 1382
fd872598
FB		 1383#ifndef _WIN32
1384
7183b4b4
AL		 1385/* Sets a specific flag */
1386static int fcntl_setfl(int fd, int flag)
1387{
1388 int flags;
1389
1390 flags = fcntl(fd, F_GETFL);
1391 if (flags == -1)
1392 return -errno;
1393
1394 if (fcntl(fd, F_SETFL, flags | flag) == -1)
1395 return -errno;
1396
1397 return 0;
1398}
1399
829309c7
FB		 1400#if defined(__linux__)
1401
fd872598
FB		 1402#define RTC_FREQ 1024
1403
de9a95f0 1404static void enable_sigio_timer(int fd)
c8994013
TS		 1405{
1406 struct sigaction act;
1407
1408 /* timer signal */
1409 sigfillset(&act.sa_mask);
1410 act.sa_flags = 0;
c8994013
TS		 1411 act.sa_handler = host_alarm_handler;
1412
1413 sigaction(SIGIO, &act, NULL);
7183b4b4 1414 fcntl_setfl(fd, O_ASYNC);
c8994013
TS		 1415 fcntl(fd, F_SETOWN, getpid());
1416}
829309c7 1417
c40ec5a9
TS		 1418static int hpet_start_timer(struct qemu_alarm_timer *t)
1419{
1420 struct hpet_info info;
1421 int r, fd;
1422
1423 fd = open("/dev/hpet", O_RDONLY);
1424 if (fd < 0)
1425 return -1;
1426
1427 /* Set frequency */
1428 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1429 if (r < 0) {
1430 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1431 "error, but for better emulation accuracy type:\n"
1432 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1433 goto fail;
1434 }
1435
1436 /* Check capabilities */
1437 r = ioctl(fd, HPET_INFO, &info);
1438 if (r < 0)
1439 goto fail;
1440
1441 /* Enable periodic mode */
1442 r = ioctl(fd, HPET_EPI, 0);
1443 if (info.hi_flags && (r < 0))
1444 goto fail;
1445
1446 /* Enable interrupt */
1447 r = ioctl(fd, HPET_IE_ON, 0);
1448 if (r < 0)
1449 goto fail;
1450
1451 enable_sigio_timer(fd);
fcdc2129 1452 t->priv = (void *)(long)fd;
c40ec5a9
TS		 1453
1454 return 0;
1455fail:
1456 close(fd);
1457 return -1;
1458}
1459
1460static void hpet_stop_timer(struct qemu_alarm_timer *t)
1461{
fcdc2129 1462 int fd = (long)t->priv;
c40ec5a9
TS		 1463
1464 close(fd);
1465}
1466
c8994013 1467static int rtc_start_timer(struct qemu_alarm_timer *t)
fd872598 1468{
c8994013 1469 int rtc_fd;
b5a23ad4 1470 unsigned long current_rtc_freq = 0;
c8994013 1471
aeb30be6 1472 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
fd872598
FB		 1473 if (rtc_fd < 0)
1474 return -1;
b5a23ad4
AZ		 1475 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1476 if (current_rtc_freq != RTC_FREQ &&
1477 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
fd872598
FB		 1478 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1479 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1480 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1481 goto fail;
1482 }
1483 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1484 fail:
1485 close(rtc_fd);
1486 return -1;
1487 }
c8994013
TS		 1488
1489 enable_sigio_timer(rtc_fd);
1490
fcdc2129 1491 t->priv = (void *)(long)rtc_fd;
c8994013 1492
fd872598
FB		 1493 return 0;
1494}
1495
c8994013 1496static void rtc_stop_timer(struct qemu_alarm_timer *t)
829309c7 1497{
fcdc2129 1498 int rtc_fd = (long)t->priv;
c8994013
TS		 1499
1500 close(rtc_fd);
829309c7
FB		 1501}
1502
efe75411
TS		 1503static int dynticks_start_timer(struct qemu_alarm_timer *t)
1504{
1505 struct sigevent ev;
1506 timer_t host_timer;
1507 struct sigaction act;
1508
1509 sigfillset(&act.sa_mask);
1510 act.sa_flags = 0;
efe75411
TS		 1511 act.sa_handler = host_alarm_handler;
1512
1513 sigaction(SIGALRM, &act, NULL);
1514
1515 ev.sigev_value.sival_int = 0;
1516 ev.sigev_notify = SIGEV_SIGNAL;
1517 ev.sigev_signo = SIGALRM;
1518
1519 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1520 perror("timer_create");
1521
1522 /* disable dynticks */
1523 fprintf(stderr, "Dynamic Ticks disabled\n");
1524
1525 return -1;
1526 }
1527
1528 t->priv = (void *)host_timer;
1529
1530 return 0;
1531}
1532
1533static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1534{
1535 timer_t host_timer = (timer_t)t->priv;
1536
1537 timer_delete(host_timer);
1538}
1539
1540static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1541{
1542 timer_t host_timer = (timer_t)t->priv;
1543 struct itimerspec timeout;
1544 int64_t nearest_delta_us = INT64_MAX;
1545 int64_t current_us;
1546
1547 if (!active_timers[QEMU_TIMER_REALTIME] &&
1548 !active_timers[QEMU_TIMER_VIRTUAL])
d5d08334 1549 return;
efe75411 1550
2e70f6ef 1551 nearest_delta_us = qemu_next_deadline_dyntick();
efe75411
TS		 1552
1553 /* check whether a timer is already running */
1554 if (timer_gettime(host_timer, &timeout)) {
1555 perror("gettime");
1556 fprintf(stderr, "Internal timer error: aborting\n");
1557 exit(1);
1558 }
1559 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1560 if (current_us && current_us <= nearest_delta_us)
1561 return;
1562
1563 timeout.it_interval.tv_sec = 0;
1564 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1565 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1566 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1567 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1568 perror("settime");
1569 fprintf(stderr, "Internal timer error: aborting\n");
1570 exit(1);
1571 }
1572}
1573
70744b3a 1574#endif /* defined(__linux__) */
231c6586 1575
c8994013
TS		 1576static int unix_start_timer(struct qemu_alarm_timer *t)
1577{
1578 struct sigaction act;
1579 struct itimerval itv;
1580 int err;
1581
1582 /* timer signal */
1583 sigfillset(&act.sa_mask);
1584 act.sa_flags = 0;
c8994013
TS		 1585 act.sa_handler = host_alarm_handler;
1586
1587 sigaction(SIGALRM, &act, NULL);
1588
1589 itv.it_interval.tv_sec = 0;
1590 /* for i386 kernel 2.6 to get 1 ms */
1591 itv.it_interval.tv_usec = 999;
1592 itv.it_value.tv_sec = 0;
1593 itv.it_value.tv_usec = 10 * 1000;
1594
1595 err = setitimer(ITIMER_REAL, &itv, NULL);
1596 if (err)
1597 return -1;
1598
1599 return 0;
1600}
1601
1602static void unix_stop_timer(struct qemu_alarm_timer *t)
1603{
1604 struct itimerval itv;
1605
1606 memset(&itv, 0, sizeof(itv));
1607 setitimer(ITIMER_REAL, &itv, NULL);
1608}
1609
829309c7 1610#endif /* !defined(_WIN32) */
fd872598 1611
f49e58dc
AL		 1612static void try_to_rearm_timer(void *opaque)
1613{
1614 struct qemu_alarm_timer *t = opaque;
1615#ifndef _WIN32
1616 ssize_t len;
1617
1618 /* Drain the notify pipe */
1619 do {
1620 char buffer[512];
1621 len = read(alarm_timer_rfd, buffer, sizeof(buffer));
1622 } while ((len == -1 && errno == EINTR) || len > 0);
1623#endif
1624
1625 /* vm time timers */
1626 if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
1627 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
1628 qemu_get_clock(vm_clock));
1629
1630 /* real time timers */
1631 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
1632 qemu_get_clock(rt_clock));
1633
1634 if (t->flags & ALARM_FLAG_EXPIRED) {
1635 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
1636 qemu_rearm_alarm_timer(alarm_timer);
1637 }
1638}
1639
c8994013
TS		 1640#ifdef _WIN32
1641
1642static int win32_start_timer(struct qemu_alarm_timer *t)
1643{
1644 TIMECAPS tc;
1645 struct qemu_alarm_win32 *data = t->priv;
efe75411 1646 UINT flags;
c8994013
TS		 1647
1648 data->host_alarm = CreateEvent(NULL, FALSE, FALSE, NULL);
1649 if (!data->host_alarm) {
1650 perror("Failed CreateEvent");
c396a7f0 1651 return -1;
c8994013
TS		 1652 }
1653
1654 memset(&tc, 0, sizeof(tc));
1655 timeGetDevCaps(&tc, sizeof(tc));
1656
1657 if (data->period < tc.wPeriodMin)
1658 data->period = tc.wPeriodMin;
1659
1660 timeBeginPeriod(data->period);
1661
efe75411
TS		 1662 flags = TIME_CALLBACK_FUNCTION;
1663 if (alarm_has_dynticks(t))
1664 flags |= TIME_ONESHOT;
1665 else
1666 flags |= TIME_PERIODIC;
1667
c8994013
TS		 1668 data->timerId = timeSetEvent(1, // interval (ms)
1669 data->period, // resolution
1670 host_alarm_handler, // function
1671 (DWORD)t, // parameter
efe75411 1672 flags);
c8994013
TS		 1673
1674 if (!data->timerId) {
1675 perror("Failed to initialize win32 alarm timer");
1676
1677 timeEndPeriod(data->period);
1678 CloseHandle(data->host_alarm);
1679 return -1;
1680 }
1681
f49e58dc 1682 qemu_add_wait_object(data->host_alarm, try_to_rearm_timer, t);
c8994013
TS		 1683
1684 return 0;
1685}
1686
1687static void win32_stop_timer(struct qemu_alarm_timer *t)
1688{
1689 struct qemu_alarm_win32 *data = t->priv;
1690
1691 timeKillEvent(data->timerId);
1692 timeEndPeriod(data->period);
1693
1694 CloseHandle(data->host_alarm);
1695}
1696
efe75411
TS		 1697static void win32_rearm_timer(struct qemu_alarm_timer *t)
1698{
1699 struct qemu_alarm_win32 *data = t->priv;
1700 uint64_t nearest_delta_us;
1701
1702 if (!active_timers[QEMU_TIMER_REALTIME] &&
1703 !active_timers[QEMU_TIMER_VIRTUAL])
d5d08334 1704 return;
efe75411 1705
2e70f6ef 1706 nearest_delta_us = qemu_next_deadline_dyntick();
efe75411
TS		 1707 nearest_delta_us /= 1000;
1708
1709 timeKillEvent(data->timerId);
1710
1711 data->timerId = timeSetEvent(1,
1712 data->period,
1713 host_alarm_handler,
1714 (DWORD)t,
1715 TIME_ONESHOT | TIME_PERIODIC);
1716
1717 if (!data->timerId) {
1718 perror("Failed to re-arm win32 alarm timer");
1719
1720 timeEndPeriod(data->period);
1721 CloseHandle(data->host_alarm);
1722 exit(1);
1723 }
1724}
1725
c8994013
TS		 1726#endif /* _WIN32 */
1727
7183b4b4 1728static int init_timer_alarm(void)
8a7ddc38 1729{
223f0d72 1730 struct qemu_alarm_timer *t = NULL;
c8994013 1731 int i, err = -1;
f49e58dc
AL		 1732
1733#ifndef _WIN32
c96f1a48
AL		 1734 int fds[2];
1735
7183b4b4
AL		 1736 err = pipe(fds);
1737 if (err == -1)
1738 return -errno;
1739
1740 err = fcntl_setfl(fds[0], O_NONBLOCK);
1741 if (err < 0)
1742 goto fail;
1743
1744 err = fcntl_setfl(fds[1], O_NONBLOCK);
1745 if (err < 0)
1746 goto fail;
1747
c96f1a48
AL		 1748 alarm_timer_rfd = fds[0];
1749 alarm_timer_wfd = fds[1];
f49e58dc 1750#endif
c8994013
TS		 1751
1752 for (i = 0; alarm_timers[i].name; i++) {
1753 t = &alarm_timers[i];
1754
c8994013
TS		 1755 err = t->start(t);
1756 if (!err)
1757 break;
67b915a5 1758 }
fd872598 1759
c8994013 1760 if (err) {
7183b4b4
AL		 1761 err = -ENOENT;
1762 goto fail;
67b915a5 1763 }
c8994013 1764
f49e58dc 1765#ifndef _WIN32
6abfbd79
AL		 1766 qemu_set_fd_handler2(alarm_timer_rfd, NULL,
1767 try_to_rearm_timer, NULL, t);
f49e58dc 1768#endif
6abfbd79 1769
c8994013 1770 alarm_timer = t;
7183b4b4 1771
6abfbd79 1772 return 0;
7183b4b4
AL		 1773
1774fail:
f49e58dc 1775#ifndef _WIN32
7183b4b4
AL		 1776 close(fds[0]);
1777 close(fds[1]);
f49e58dc 1778#endif
7183b4b4 1779 return err;
8a7ddc38
FB		 1780}
1781
9596ebb7 1782static void quit_timers(void)
40c3bac3 1783{
c8994013
TS		 1784 alarm_timer->stop(alarm_timer);
1785 alarm_timer = NULL;
40c3bac3
FB		 1786}
1787
f6503059
AZ		 1788/***********************************************************/
1789/* host time/date access */
1790void qemu_get_timedate(struct tm *tm, int offset)
1791{
1792 time_t ti;
1793 struct tm *ret;
1794
1795 time(&ti);
1796 ti += offset;
1797 if (rtc_date_offset == -1) {
1798 if (rtc_utc)
1799 ret = gmtime(&ti);
1800 else
1801 ret = localtime(&ti);
1802 } else {
1803 ti -= rtc_date_offset;
1804 ret = gmtime(&ti);
1805 }
1806
1807 memcpy(tm, ret, sizeof(struct tm));
1808}
1809
1810int qemu_timedate_diff(struct tm *tm)
1811{
1812 time_t seconds;
1813
1814 if (rtc_date_offset == -1)
1815 if (rtc_utc)
1816 seconds = mktimegm(tm);
1817 else
1818 seconds = mktime(tm);
1819 else
1820 seconds = mktimegm(tm) + rtc_date_offset;
1821
1822 return seconds - time(NULL);
1823}
1824
fd1dff4b 1825#ifdef _WIN32
fd1dff4b
FB		 1826static void socket_cleanup(void)
1827{
1828 WSACleanup();
1829}
82c643ff 1830
fd1dff4b
FB		 1831static int socket_init(void)
1832{
1833 WSADATA Data;
1834 int ret, err;
1835
1836 ret = WSAStartup(MAKEWORD(2,2), &Data);
1837 if (ret != 0) {
1838 err = WSAGetLastError();
1839 fprintf(stderr, "WSAStartup: %d\n", err);
1840 return -1;
1841 }
1842 atexit(socket_cleanup);
1843 return 0;
1844}
64b7b733
AJ		 1845#endif
1846
63a01ef8 1847const char *get_opt_name(char *buf, int buf_size, const char *p)
609497ab
AZ		 1848{
1849 char *q;
1850
1851 q = buf;
1852 while (*p != '\0' && *p != '=') {
1853 if (q && (q - buf) < buf_size - 1)
1854 *q++ = *p;
1855 p++;
1856 }
1857 if (q)
1858 *q = '\0';
1859
1860 return p;
1861}
1862
63a01ef8 1863const char *get_opt_value(char *buf, int buf_size, const char *p)
e4bcb14c
TS		 1864{
1865 char *q;
e4bcb14c 1866
e4bcb14c
TS		 1867 q = buf;
1868 while (*p != '\0') {
609497ab
AZ		 1869 if (*p == ',') {
1870 if (*(p + 1) != ',')
e4bcb14c 1871 break;
e4bcb14c 1872 p++;
609497ab 1873 }
e4bcb14c
TS		 1874 if (q && (q - buf) < buf_size - 1)
1875 *q++ = *p;
1876 p++;
1877 }
1878 if (q)
1879 *q = '\0';
1880
1881 return p;
1882}
1883
63a01ef8
AL		 1884int get_param_value(char *buf, int buf_size,
1885 const char *tag, const char *str)
7c9d8e07
FB		 1886{
1887 const char *p;
7c9d8e07
FB		 1888 char option[128];
1889
1890 p = str;
1891 for(;;) {
609497ab 1892 p = get_opt_name(option, sizeof(option), p);
7c9d8e07
FB		 1893 if (*p != '=')
1894 break;
1895 p++;
1896 if (!strcmp(tag, option)) {
609497ab 1897 (void)get_opt_value(buf, buf_size, p);
e4bcb14c 1898 return strlen(buf);
7c9d8e07 1899 } else {
609497ab 1900 p = get_opt_value(NULL, 0, p);
7c9d8e07
FB		 1901 }
1902 if (*p != ',')
1903 break;
1904 p++;
1905 }
1906 return 0;
1907}
1908
63a01ef8
AL		 1909int check_params(char *buf, int buf_size,
1910 const char * const *params, const char *str)
e4bcb14c
TS		 1911{
1912 const char *p;
1913 int i;
1914
1915 p = str;
1916 for(;;) {
609497ab 1917 p = get_opt_name(buf, buf_size, p);
e4bcb14c
TS		 1918 if (*p != '=')
1919 return -1;
1920 p++;
1921 for(i = 0; params[i] != NULL; i++)
1922 if (!strcmp(params[i], buf))
1923 break;
1924 if (params[i] == NULL)
1925 return -1;
609497ab 1926 p = get_opt_value(NULL, 0, p);
e4bcb14c
TS		 1927 if (*p != ',')
1928 break;
1929 p++;
1930 }
1931 return 0;
1932}
1933
1ae26a18
AZ		 1934/***********************************************************/
1935/* Bluetooth support */
1936static int nb_hcis;
1937static int cur_hci;
1938static struct HCIInfo *hci_table[MAX_NICS];
dc72ac14 1939
1ae26a18
AZ		 1940static struct bt_vlan_s {
1941 struct bt_scatternet_s net;
1942 int id;
1943 struct bt_vlan_s *next;
1944} *first_bt_vlan;
1945
1946/* find or alloc a new bluetooth "VLAN" */
674bb261 1947static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1ae26a18
AZ		 1948{
1949 struct bt_vlan_s **pvlan, *vlan;
1950 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1951 if (vlan->id == id)
1952 return &vlan->net;
1953 }
1954 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1955 vlan->id = id;
1956 pvlan = &first_bt_vlan;
1957 while (*pvlan != NULL)
1958 pvlan = &(*pvlan)->next;
1959 *pvlan = vlan;
1960 return &vlan->net;
1961}
1962
1963static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1964{
1965}
1966
1967static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1968{
1969 return -ENOTSUP;
1970}
1971
1972static struct HCIInfo null_hci = {
1973 .cmd_send = null_hci_send,
1974 .sco_send = null_hci_send,
1975 .acl_send = null_hci_send,
1976 .bdaddr_set = null_hci_addr_set,
1977};
1978
1979struct HCIInfo *qemu_next_hci(void)
1980{
1981 if (cur_hci == nb_hcis)
1982 return &null_hci;
1983
1984 return hci_table[cur_hci++];
1985}
1986
dc72ac14
AZ		 1987static struct HCIInfo *hci_init(const char *str)
1988{
1989 char *endp;
1990 struct bt_scatternet_s *vlan = 0;
1991
1992 if (!strcmp(str, "null"))
1993 /* null */
1994 return &null_hci;
1995 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1996 /* host[:hciN] */
1997 return bt_host_hci(str[4] ? str + 5 : "hci0");
1998 else if (!strncmp(str, "hci", 3)) {
1999 /* hci[,vlan=n] */
2000 if (str[3]) {
2001 if (!strncmp(str + 3, ",vlan=", 6)) {
2002 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
2003 if (*endp)
2004 vlan = 0;
2005 }
2006 } else
2007 vlan = qemu_find_bt_vlan(0);
2008 if (vlan)
2009 return bt_new_hci(vlan);
2010 }
2011
2012 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
2013
2014 return 0;
2015}
2016
2017static int bt_hci_parse(const char *str)
2018{
2019 struct HCIInfo *hci;
2020 bdaddr_t bdaddr;
2021
2022 if (nb_hcis >= MAX_NICS) {
2023 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
2024 return -1;
2025 }
2026
2027 hci = hci_init(str);
2028 if (!hci)
2029 return -1;
2030
2031 bdaddr.b[0] = 0x52;
2032 bdaddr.b[1] = 0x54;
2033 bdaddr.b[2] = 0x00;
2034 bdaddr.b[3] = 0x12;
2035 bdaddr.b[4] = 0x34;
2036 bdaddr.b[5] = 0x56 + nb_hcis;
2037 hci->bdaddr_set(hci, bdaddr.b);
2038
2039 hci_table[nb_hcis++] = hci;
2040
2041 return 0;
2042}
2043
2044static void bt_vhci_add(int vlan_id)
2045{
2046 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
2047
2048 if (!vlan->slave)
2049 fprintf(stderr, "qemu: warning: adding a VHCI to "
2050 "an empty scatternet %i\n", vlan_id);
2051
2052 bt_vhci_init(bt_new_hci(vlan));
2053}
2054
2055static struct bt_device_s *bt_device_add(const char *opt)
2056{
2057 struct bt_scatternet_s *vlan;
2058 int vlan_id = 0;
2059 char *endp = strstr(opt, ",vlan=");
2060 int len = (endp ? endp - opt : strlen(opt)) + 1;
2061 char devname[10];
2062
2063 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2064
2065 if (endp) {
2066 vlan_id = strtol(endp + 6, &endp, 0);
2067 if (*endp) {
2068 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2069 return 0;
2070 }
2071 }
2072
2073 vlan = qemu_find_bt_vlan(vlan_id);
2074
2075 if (!vlan->slave)
2076 fprintf(stderr, "qemu: warning: adding a slave device to "
2077 "an empty scatternet %i\n", vlan_id);
2078
2079 if (!strcmp(devname, "keyboard"))
2080 return bt_keyboard_init(vlan);
2081
2082 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2083 return 0;
2084}
2085
2086static int bt_parse(const char *opt)
2087{
2088 const char *endp, *p;
2089 int vlan;
2090
2091 if (strstart(opt, "hci", &endp)) {
2092 if (!*endp || *endp == ',') {
2093 if (*endp)
2094 if (!strstart(endp, ",vlan=", 0))
2095 opt = endp + 1;
2096
2097 return bt_hci_parse(opt);
2098 }
2099 } else if (strstart(opt, "vhci", &endp)) {
2100 if (!*endp || *endp == ',') {
2101 if (*endp) {
2102 if (strstart(endp, ",vlan=", &p)) {
2103 vlan = strtol(p, (char **) &endp, 0);
2104 if (*endp) {
2105 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2106 return 1;
2107 }
2108 } else {
2109 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2110 return 1;
2111 }
2112 } else
2113 vlan = 0;
2114
2115 bt_vhci_add(vlan);
2116 return 0;
2117 }
2118 } else if (strstart(opt, "device:", &endp))
2119 return !bt_device_add(endp);
2120
2121 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2122 return 1;
2123}
2124
1ae26a18
AZ		 2125/***********************************************************/
2126/* QEMU Block devices */
2127
609497ab 2128#define HD_ALIAS "index=%d,media=disk"
e4bcb14c
TS		 2129#ifdef TARGET_PPC
2130#define CDROM_ALIAS "index=1,media=cdrom"
2131#else
2132#define CDROM_ALIAS "index=2,media=cdrom"
2133#endif
2134#define FD_ALIAS "index=%d,if=floppy"
609497ab
AZ		 2135#define PFLASH_ALIAS "if=pflash"
2136#define MTD_ALIAS "if=mtd"
9d413d1d 2137#define SD_ALIAS "index=0,if=sd"
e4bcb14c 2138
609497ab 2139static int drive_add(const char *file, const char *fmt, ...)
e4bcb14c
TS		 2140{
2141 va_list ap;
2142
2143 if (nb_drives_opt >= MAX_DRIVES) {
2144 fprintf(stderr, "qemu: too many drives\n");
2145 exit(1);
2146 }
2147
609497ab 2148 drives_opt[nb_drives_opt].file = file;
e4bcb14c 2149 va_start(ap, fmt);
609497ab
AZ		 2150 vsnprintf(drives_opt[nb_drives_opt].opt,
2151 sizeof(drives_opt[0].opt), fmt, ap);
e4bcb14c
TS		 2152 va_end(ap);
2153
2154 return nb_drives_opt++;
2155}
2156
f60d39bc 2157int drive_get_index(BlockInterfaceType type, int bus, int unit)
e4bcb14c
TS		 2158{
2159 int index;
2160
2161 /* seek interface, bus and unit */
2162
2163 for (index = 0; index < nb_drives; index++)
f60d39bc 2164 if (drives_table[index].type == type &&
e4bcb14c
TS		 2165 drives_table[index].bus == bus &&
2166 drives_table[index].unit == unit)
2167 return index;
2168
2169 return -1;
2170}
2171
f60d39bc 2172int drive_get_max_bus(BlockInterfaceType type)
e4bcb14c
TS		 2173{
2174 int max_bus;
2175 int index;
2176
2177 max_bus = -1;
2178 for (index = 0; index < nb_drives; index++) {
f60d39bc 2179 if(drives_table[index].type == type &&
e4bcb14c
TS		 2180 drives_table[index].bus > max_bus)
2181 max_bus = drives_table[index].bus;
2182 }
2183 return max_bus;
2184}
2185
a1620fac
AJ		 2186static void bdrv_format_print(void *opaque, const char *name)
2187{
2188 fprintf(stderr, " %s", name);
2189}
2190
609497ab
AZ		 2191static int drive_init(struct drive_opt *arg, int snapshot,
2192 QEMUMachine *machine)
e4bcb14c
TS		 2193{
2194 char buf[128];
2195 char file[1024];
c8522bdf
AZ		 2196 char devname[128];
2197 const char *mediastr = "";
f60d39bc 2198 BlockInterfaceType type;
e4bcb14c
TS		 2199 enum { MEDIA_DISK, MEDIA_CDROM } media;
2200 int bus_id, unit_id;
2201 int cyls, heads, secs, translation;
2202 BlockDriverState *bdrv;
1e72d3b7 2203 BlockDriver *drv = NULL;
e4bcb14c
TS		 2204 int max_devs;
2205 int index;
33f00271
AZ		 2206 int cache;
2207 int bdrv_flags;
609497ab 2208 char *str = arg->opt;
7ccfb2eb
BS		 2209 static const char * const params[] = { "bus", "unit", "if", "index",
2210 "cyls", "heads", "secs", "trans",
2211 "media", "snapshot", "file",
2212 "cache", "format", NULL };
e4bcb14c
TS		 2213
2214 if (check_params(buf, sizeof(buf), params, str) < 0) {
ff993638 2215 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
e4bcb14c
TS		 2216 buf, str);
2217 return -1;
2218 }
2219
2220 file[0] = 0;
2221 cyls = heads = secs = 0;
2222 bus_id = 0;
2223 unit_id = -1;
2224 translation = BIOS_ATA_TRANSLATION_AUTO;
2225 index = -1;
33f00271 2226 cache = 1;
e4bcb14c 2227
c9b1ae2c 2228 if (machine->use_scsi) {
f60d39bc 2229 type = IF_SCSI;
e4bcb14c 2230 max_devs = MAX_SCSI_DEVS;
363a37d5 2231 pstrcpy(devname, sizeof(devname), "scsi");
e4bcb14c 2232 } else {
f60d39bc 2233 type = IF_IDE;
e4bcb14c 2234 max_devs = MAX_IDE_DEVS;
363a37d5 2235 pstrcpy(devname, sizeof(devname), "ide");
e4bcb14c
TS		 2236 }
2237 media = MEDIA_DISK;
2238
2239 /* extract parameters */
2240
2241 if (get_param_value(buf, sizeof(buf), "bus", str)) {
2242 bus_id = strtol(buf, NULL, 0);
2243 if (bus_id < 0) {
2244 fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2245 return -1;
2246 }
2247 }
2248
2249 if (get_param_value(buf, sizeof(buf), "unit", str)) {
2250 unit_id = strtol(buf, NULL, 0);
2251 if (unit_id < 0) {
2252 fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2253 return -1;
2254 }
2255 }
2256
2257 if (get_param_value(buf, sizeof(buf), "if", str)) {
ae45d369 2258 pstrcpy(devname, sizeof(devname), buf);
e4bcb14c 2259 if (!strcmp(buf, "ide")) {
f60d39bc 2260 type = IF_IDE;
e4bcb14c
TS		 2261 max_devs = MAX_IDE_DEVS;
2262 } else if (!strcmp(buf, "scsi")) {
f60d39bc 2263 type = IF_SCSI;
e4bcb14c
TS		 2264 max_devs = MAX_SCSI_DEVS;
2265 } else if (!strcmp(buf, "floppy")) {
f60d39bc 2266 type = IF_FLOPPY;
e4bcb14c
TS		 2267 max_devs = 0;
2268 } else if (!strcmp(buf, "pflash")) {
f60d39bc 2269 type = IF_PFLASH;
e4bcb14c
TS		 2270 max_devs = 0;
2271 } else if (!strcmp(buf, "mtd")) {
f60d39bc 2272 type = IF_MTD;
e4bcb14c
TS		 2273 max_devs = 0;
2274 } else if (!strcmp(buf, "sd")) {
f60d39bc 2275 type = IF_SD;
e4bcb14c
TS		 2276 max_devs = 0;
2277 } else {
2278 fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2279 return -1;
2280 }
2281 }
2282
2283 if (get_param_value(buf, sizeof(buf), "index", str)) {
2284 index = strtol(buf, NULL, 0);
2285 if (index < 0) {
2286 fprintf(stderr, "qemu: '%s' invalid index\n", str);
2287 return -1;
2288 }
2289 }
2290
2291 if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2292 cyls = strtol(buf, NULL, 0);
2293 }
2294
2295 if (get_param_value(buf, sizeof(buf), "heads", str)) {
2296 heads = strtol(buf, NULL, 0);
2297 }
2298
2299 if (get_param_value(buf, sizeof(buf), "secs", str)) {
2300 secs = strtol(buf, NULL, 0);
2301 }
2302
2303 if (cyls || heads || secs) {
2304 if (cyls < 1 || cyls > 16383) {
2305 fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2306 return -1;
2307 }
2308 if (heads < 1 || heads > 16) {
2309 fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2310 return -1;
2311 }
2312 if (secs < 1 || secs > 63) {
2313 fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2314 return -1;
2315 }
2316 }
2317
2318 if (get_param_value(buf, sizeof(buf), "trans", str)) {
2319 if (!cyls) {
2320 fprintf(stderr,
2321 "qemu: '%s' trans must be used with cyls,heads and secs\n",
2322 str);
2323 return -1;
2324 }
2325 if (!strcmp(buf, "none"))
2326 translation = BIOS_ATA_TRANSLATION_NONE;
2327 else if (!strcmp(buf, "lba"))
2328 translation = BIOS_ATA_TRANSLATION_LBA;
2329 else if (!strcmp(buf, "auto"))
2330 translation = BIOS_ATA_TRANSLATION_AUTO;
2331 else {
2332 fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2333 return -1;
2334 }
2335 }
2336
2337 if (get_param_value(buf, sizeof(buf), "media", str)) {
2338 if (!strcmp(buf, "disk")) {
2339 media = MEDIA_DISK;
2340 } else if (!strcmp(buf, "cdrom")) {
2341 if (cyls || secs || heads) {
2342 fprintf(stderr,
2343 "qemu: '%s' invalid physical CHS format\n", str);
2344 return -1;
2345 }
2346 media = MEDIA_CDROM;
2347 } else {
2348 fprintf(stderr, "qemu: '%s' invalid media\n", str);
2349 return -1;
2350 }
2351 }
2352
2353 if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2354 if (!strcmp(buf, "on"))
2355 snapshot = 1;
2356 else if (!strcmp(buf, "off"))
2357 snapshot = 0;
2358 else {
2359 fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2360 return -1;
2361 }
2362 }
2363
33f00271 2364 if (get_param_value(buf, sizeof(buf), "cache", str)) {
9f7965c7 2365 if (!strcmp(buf, "off") || !strcmp(buf, "none"))
33f00271 2366 cache = 0;
9f7965c7 2367 else if (!strcmp(buf, "writethrough"))
33f00271 2368 cache = 1;
9f7965c7
AL		 2369 else if (!strcmp(buf, "writeback"))
2370 cache = 2;
33f00271
AZ		 2371 else {
2372 fprintf(stderr, "qemu: invalid cache option\n");
2373 return -1;
2374 }
2375 }
2376
1e72d3b7 2377 if (get_param_value(buf, sizeof(buf), "format", str)) {
a1620fac
AJ		 2378 if (strcmp(buf, "?") == 0) {
2379 fprintf(stderr, "qemu: Supported formats:");
2380 bdrv_iterate_format(bdrv_format_print, NULL);
2381 fprintf(stderr, "\n");
2382 return -1;
2383 }
1e72d3b7
AJ		 2384 drv = bdrv_find_format(buf);
2385 if (!drv) {
2386 fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2387 return -1;
2388 }
2389 }
2390
609497ab
AZ		 2391 if (arg->file == NULL)
2392 get_param_value(file, sizeof(file), "file", str);
2393 else
2394 pstrcpy(file, sizeof(file), arg->file);
e4bcb14c
TS		 2395
2396 /* compute bus and unit according index */
2397
2398 if (index != -1) {
2399 if (bus_id != 0 || unit_id != -1) {
2400 fprintf(stderr,
2401 "qemu: '%s' index cannot be used with bus and unit\n", str);
2402 return -1;
2403 }
2404 if (max_devs == 0)
2405 {
2406 unit_id = index;
2407 bus_id = 0;
2408 } else {
2409 unit_id = index % max_devs;
2410 bus_id = index / max_devs;
2411 }
2412 }
2413
2414 /* if user doesn't specify a unit_id,
2415 * try to find the first free
2416 */
2417
2418 if (unit_id == -1) {
2419 unit_id = 0;
f60d39bc 2420 while (drive_get_index(type, bus_id, unit_id) != -1) {
e4bcb14c
TS		 2421 unit_id++;
2422 if (max_devs && unit_id >= max_devs) {
2423 unit_id -= max_devs;
2424 bus_id++;
2425 }
2426 }
2427 }
2428
2429 /* check unit id */
2430
2431 if (max_devs && unit_id >= max_devs) {
2432 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2433 str, unit_id, max_devs - 1);
2434 return -1;
2435 }
2436
2437 /*
2438 * ignore multiple definitions
2439 */
2440
f60d39bc 2441 if (drive_get_index(type, bus_id, unit_id) != -1)
e4bcb14c
TS		 2442 return 0;
2443
2444 /* init */
2445
f60d39bc 2446 if (type == IF_IDE || type == IF_SCSI)
c8522bdf 2447 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
e6198a70
AZ		 2448 if (max_devs)
2449 snprintf(buf, sizeof(buf), "%s%i%s%i",
2450 devname, bus_id, mediastr, unit_id);
2451 else
2452 snprintf(buf, sizeof(buf), "%s%s%i",
2453 devname, mediastr, unit_id);
e4bcb14c
TS		 2454 bdrv = bdrv_new(buf);
2455 drives_table[nb_drives].bdrv = bdrv;
f60d39bc 2456 drives_table[nb_drives].type = type;
e4bcb14c
TS		 2457 drives_table[nb_drives].bus = bus_id;
2458 drives_table[nb_drives].unit = unit_id;
2459 nb_drives++;
2460
f60d39bc 2461 switch(type) {
e4bcb14c
TS		 2462 case IF_IDE:
2463 case IF_SCSI:
2464 switch(media) {
2465 case MEDIA_DISK:
2466 if (cyls != 0) {
2467 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2468 bdrv_set_translation_hint(bdrv, translation);
2469 }
2470 break;
2471 case MEDIA_CDROM:
2472 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2473 break;
2474 }
2475 break;
2476 case IF_SD:
2477 /* FIXME: This isn't really a floppy, but it's a reasonable
2478 approximation. */
2479 case IF_FLOPPY:
2480 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2481 break;
2482 case IF_PFLASH:
2483 case IF_MTD:
2484 break;
2485 }
2486 if (!file[0])
2487 return 0;
33f00271 2488 bdrv_flags = 0;
9f7965c7 2489 if (snapshot) {
33f00271 2490 bdrv_flags |= BDRV_O_SNAPSHOT;
9f7965c7
AL		 2491 cache = 2; /* always use write-back with snapshot */
2492 }
2493 if (cache == 0) /* no caching */
2494 bdrv_flags |= BDRV_O_NOCACHE;
2495 else if (cache == 2) /* write-back */
2496 bdrv_flags |= BDRV_O_CACHE_WB;
83ab7950 2497 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0 || qemu_key_check(bdrv, file)) {
e4bcb14c
TS		 2498 fprintf(stderr, "qemu: could not open disk image %s\n",
2499 file);
2500 return -1;
2501 }
2502 return 0;
2503}
2504
a594cfbf
FB		 2505/***********************************************************/
2506/* USB devices */
2507
0d92ed30
PB		 2508static USBPort *used_usb_ports;
2509static USBPort *free_usb_ports;
2510
2511/* ??? Maybe change this to register a hub to keep track of the topology. */
2512void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2513 usb_attachfn attach)
2514{
2515 port->opaque = opaque;
2516 port->index = index;
2517 port->attach = attach;
2518 port->next = free_usb_ports;
2519 free_usb_ports = port;
2520}
2521
4b096fc9
AL		 2522int usb_device_add_dev(USBDevice *dev)
2523{
2524 USBPort *port;
2525
2526 /* Find a USB port to add the device to. */
2527 port = free_usb_ports;
2528 if (!port->next) {
2529 USBDevice *hub;
2530
2531 /* Create a new hub and chain it on. */
2532 free_usb_ports = NULL;
2533 port->next = used_usb_ports;
2534 used_usb_ports = port;
2535
2536 hub = usb_hub_init(VM_USB_HUB_SIZE);
2537 usb_attach(port, hub);
2538 port = free_usb_ports;
2539 }
2540
2541 free_usb_ports = port->next;
2542 port->next = used_usb_ports;
2543 used_usb_ports = port;
2544 usb_attach(port, dev);
2545 return 0;
2546}
2547
a594cfbf
FB		 2548static int usb_device_add(const char *devname)
2549{
2550 const char *p;
2551 USBDevice *dev;
a594cfbf 2552
0d92ed30 2553 if (!free_usb_ports)
a594cfbf
FB		 2554 return -1;
2555
2556 if (strstart(devname, "host:", &p)) {
2557 dev = usb_host_device_open(p);
a594cfbf
FB		 2558 } else if (!strcmp(devname, "mouse")) {
2559 dev = usb_mouse_init();
09b26c5e 2560 } else if (!strcmp(devname, "tablet")) {
47b2d338
AZ		 2561 dev = usb_tablet_init();
2562 } else if (!strcmp(devname, "keyboard")) {
2563 dev = usb_keyboard_init();
2e5d83bb
PB		 2564 } else if (strstart(devname, "disk:", &p)) {
2565 dev = usb_msd_init(p);
f6d2a316
AZ		 2566 } else if (!strcmp(devname, "wacom-tablet")) {
2567 dev = usb_wacom_init();
a7954218
AZ		 2568 } else if (strstart(devname, "serial:", &p)) {
2569 dev = usb_serial_init(p);
2e4d9fb1
AJ		 2570#ifdef CONFIG_BRLAPI
2571 } else if (!strcmp(devname, "braille")) {
2572 dev = usb_baum_init();
2573#endif
6c9f886c 2574 } else if (strstart(devname, "net:", &p)) {
9ad97e65 2575 int nic = nb_nics;
6c9f886c 2576
9ad97e65 2577 if (net_client_init("nic", p) < 0)
6c9f886c 2578 return -1;
9ad97e65
AZ		 2579 nd_table[nic].model = "usb";
2580 dev = usb_net_init(&nd_table[nic]);
dc72ac14
AZ		 2581 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2582 dev = usb_bt_init(devname[2] ? hci_init(p) :
2583 bt_new_hci(qemu_find_bt_vlan(0)));
a594cfbf
FB		 2584 } else {
2585 return -1;
2586 }
0d92ed30
PB		 2587 if (!dev)
2588 return -1;
2589
4b096fc9 2590 return usb_device_add_dev(dev);
a594cfbf
FB		 2591}
2592
1f3870ab 2593int usb_device_del_addr(int bus_num, int addr)
a594cfbf 2594{
0d92ed30
PB		 2595 USBPort *port;
2596 USBPort **lastp;
059809e4 2597 USBDevice *dev;
a594cfbf 2598
0d92ed30 2599 if (!used_usb_ports)
a594cfbf
FB		 2600 return -1;
2601
a594cfbf
FB		 2602 if (bus_num != 0)
2603 return -1;
0d92ed30
PB		 2604
2605 lastp = &used_usb_ports;
2606 port = used_usb_ports;
2607 while (port && port->dev->addr != addr) {
2608 lastp = &port->next;
2609 port = port->next;
a594cfbf 2610 }
0d92ed30
PB		 2611
2612 if (!port)
a594cfbf 2613 return -1;
0d92ed30 2614
059809e4 2615 dev = port->dev;
0d92ed30
PB		 2616 *lastp = port->next;
2617 usb_attach(port, NULL);
059809e4 2618 dev->handle_destroy(dev);
0d92ed30
PB		 2619 port->next = free_usb_ports;
2620 free_usb_ports = port;
a594cfbf
FB		 2621 return 0;
2622}
2623
1f3870ab
AL		 2624static int usb_device_del(const char *devname)
2625{
2626 int bus_num, addr;
2627 const char *p;
2628
5d0c5750
AL		 2629 if (strstart(devname, "host:", &p))
2630 return usb_host_device_close(p);
2631
1f3870ab
AL		 2632 if (!used_usb_ports)
2633 return -1;
2634
2635 p = strchr(devname, '.');
2636 if (!p)
2637 return -1;
2638 bus_num = strtoul(devname, NULL, 0);
2639 addr = strtoul(p + 1, NULL, 0);
2640
2641 return usb_device_del_addr(bus_num, addr);
2642}
2643
a594cfbf
FB		 2644void do_usb_add(const char *devname)
2645{
4b096fc9 2646 usb_device_add(devname);
a594cfbf
FB		 2647}
2648
2649void do_usb_del(const char *devname)
2650{
4b096fc9 2651 usb_device_del(devname);
a594cfbf
FB		 2652}
2653
2654void usb_info(void)
2655{
2656 USBDevice *dev;
0d92ed30 2657 USBPort *port;
a594cfbf
FB		 2658 const char *speed_str;
2659
0d92ed30 2660 if (!usb_enabled) {
a594cfbf
FB		 2661 term_printf("USB support not enabled\n");
2662 return;
2663 }
2664
0d92ed30
PB		 2665 for (port = used_usb_ports; port; port = port->next) {
2666 dev = port->dev;
2667 if (!dev)
2668 continue;
2669 switch(dev->speed) {
5fafdf24
TS		 2670 case USB_SPEED_LOW:
2671 speed_str = "1.5";
0d92ed30 2672 break;
5fafdf24
TS		 2673 case USB_SPEED_FULL:
2674 speed_str = "12";
0d92ed30 2675 break;
5fafdf24
TS		 2676 case USB_SPEED_HIGH:
2677 speed_str = "480";
0d92ed30
PB		 2678 break;
2679 default:
5fafdf24 2680 speed_str = "?";
0d92ed30 2681 break;
a594cfbf 2682 }
5fafdf24 2683 term_printf(" Device %d.%d, Speed %s Mb/s, Product %s\n",
1f6e24e7 2684 0, dev->addr, speed_str, dev->devname);
a594cfbf
FB		 2685 }
2686}
2687
201a51fc
AZ		 2688/***********************************************************/
2689/* PCMCIA/Cardbus */
2690
2691static struct pcmcia_socket_entry_s {
2692 struct pcmcia_socket_s *socket;
2693 struct pcmcia_socket_entry_s *next;
2694} *pcmcia_sockets = 0;
2695
2696void pcmcia_socket_register(struct pcmcia_socket_s *socket)
2697{
2698 struct pcmcia_socket_entry_s *entry;
2699
2700 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2701 entry->socket = socket;
2702 entry->next = pcmcia_sockets;
2703 pcmcia_sockets = entry;
2704}
2705
2706void pcmcia_socket_unregister(struct pcmcia_socket_s *socket)
2707{
2708 struct pcmcia_socket_entry_s *entry, **ptr;
2709
2710 ptr = &pcmcia_sockets;
2711 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2712 if (entry->socket == socket) {
2713 *ptr = entry->next;
2714 qemu_free(entry);
2715 }
2716}
2717
2718void pcmcia_info(void)
2719{
2720 struct pcmcia_socket_entry_s *iter;
2721 if (!pcmcia_sockets)
2722 term_printf("No PCMCIA sockets\n");
2723
2724 for (iter = pcmcia_sockets; iter; iter = iter->next)
2725 term_printf("%s: %s\n", iter->socket->slot_string,
2726 iter->socket->attached ? iter->socket->card_string :
2727 "Empty");
2728}
2729
2ff89790
TS		 2730/***********************************************************/
2731/* dumb display */
2732
2733static void dumb_update(DisplayState *ds, int x, int y, int w, int h)
2734{
2735}
2736
2737static void dumb_resize(DisplayState *ds, int w, int h)
2738{
2739}
2740
2ff89790
TS		 2741static void dumb_display_init(DisplayState *ds)
2742{
2743 ds->data = NULL;
2744 ds->linesize = 0;
2745 ds->depth = 0;
2746 ds->dpy_update = dumb_update;
2747 ds->dpy_resize = dumb_resize;
2ad1a437
AL		 2748 ds->dpy_refresh = NULL;
2749 ds->gui_timer_interval = 0;
bcfad70f 2750 ds->idle = 1;
2ff89790
TS		 2751}
2752
8a7ddc38
FB		 2753/***********************************************************/
2754/* I/O handling */
0824d6fc 2755
c4b1fcc0
FB		 2756#define MAX_IO_HANDLERS 64
2757
2758typedef struct IOHandlerRecord {
2759 int fd;
7c9d8e07
FB		 2760 IOCanRWHandler *fd_read_poll;
2761 IOHandler *fd_read;
2762 IOHandler *fd_write;
cafffd40 2763 int deleted;
c4b1fcc0
FB		 2764 void *opaque;
2765 /* temporary data */
2766 struct pollfd *ufd;
8a7ddc38 2767 struct IOHandlerRecord *next;
c4b1fcc0
FB		 2768} IOHandlerRecord;
2769
8a7ddc38 2770static IOHandlerRecord *first_io_handler;
c4b1fcc0 2771
7c9d8e07
FB		 2772/* XXX: fd_read_poll should be suppressed, but an API change is
2773 necessary in the character devices to suppress fd_can_read(). */
5fafdf24
TS		 2774int qemu_set_fd_handler2(int fd,
2775 IOCanRWHandler *fd_read_poll,
2776 IOHandler *fd_read,
2777 IOHandler *fd_write,
7c9d8e07 2778 void *opaque)
c4b1fcc0 2779{
7c9d8e07 2780 IOHandlerRecord **pioh, *ioh;
c4b1fcc0 2781
7c9d8e07
FB		 2782 if (!fd_read && !fd_write) {
2783 pioh = &first_io_handler;
2784 for(;;) {
2785 ioh = *pioh;
2786 if (ioh == NULL)
2787 break;
2788 if (ioh->fd == fd) {
cafffd40 2789 ioh->deleted = 1;
7c9d8e07
FB		 2790 break;
2791 }
2792 pioh = &ioh->next;
2793 }
2794 } else {
2795 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2796 if (ioh->fd == fd)
2797 goto found;
2798 }
2799 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2800 if (!ioh)
2801 return -1;
2802 ioh->next = first_io_handler;
2803 first_io_handler = ioh;
2804 found:
2805 ioh->fd = fd;
2806 ioh->fd_read_poll = fd_read_poll;
2807 ioh->fd_read = fd_read;
2808 ioh->fd_write = fd_write;
2809 ioh->opaque = opaque;
cafffd40 2810 ioh->deleted = 0;
7c9d8e07 2811 }
c4b1fcc0
FB		 2812 return 0;
2813}
2814
5fafdf24
TS		 2815int qemu_set_fd_handler(int fd,
2816 IOHandler *fd_read,
2817 IOHandler *fd_write,
7c9d8e07 2818 void *opaque)
8a7ddc38 2819{
7c9d8e07 2820 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
8a7ddc38
FB		 2821}
2822
56f3a5d0 2823#ifdef _WIN32
f331110f
FB		 2824/***********************************************************/
2825/* Polling handling */
2826
2827typedef struct PollingEntry {
2828 PollingFunc *func;
2829 void *opaque;
2830 struct PollingEntry *next;
2831} PollingEntry;
2832
2833static PollingEntry *first_polling_entry;
2834
2835int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2836{
2837 PollingEntry **ppe, *pe;
2838 pe = qemu_mallocz(sizeof(PollingEntry));
2839 if (!pe)
2840 return -1;
2841 pe->func = func;
2842 pe->opaque = opaque;
2843 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2844 *ppe = pe;
2845 return 0;
2846}
2847
2848void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2849{
2850 PollingEntry **ppe, *pe;
2851 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2852 pe = *ppe;
2853 if (pe->func == func && pe->opaque == opaque) {
2854 *ppe = pe->next;
2855 qemu_free(pe);
2856 break;
2857 }
2858 }
2859}
2860
a18e524a
FB		 2861/***********************************************************/
2862/* Wait objects support */
2863typedef struct WaitObjects {
2864 int num;
2865 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
2866 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
2867 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
2868} WaitObjects;
2869
2870static WaitObjects wait_objects = {0};
3b46e624 2871
a18e524a
FB		 2872int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2873{
2874 WaitObjects *w = &wait_objects;
2875
2876 if (w->num >= MAXIMUM_WAIT_OBJECTS)
2877 return -1;
2878 w->events[w->num] = handle;
2879 w->func[w->num] = func;
2880 w->opaque[w->num] = opaque;
2881 w->num++;
2882 return 0;
2883}
2884
2885void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2886{
2887 int i, found;
2888 WaitObjects *w = &wait_objects;
2889
2890 found = 0;
2891 for (i = 0; i < w->num; i++) {
2892 if (w->events[i] == handle)
2893 found = 1;
2894 if (found) {
2895 w->events[i] = w->events[i + 1];
2896 w->func[i] = w->func[i + 1];
2897 w->opaque[i] = w->opaque[i + 1];
3b46e624 2898 }
a18e524a
FB		 2899 }
2900 if (found)
2901 w->num--;
2902}
2903#endif
2904
8a7ddc38
FB		 2905/***********************************************************/
2906/* ram save/restore */
2907
8a7ddc38
FB		 2908static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
2909{
2910 int v;
2911
2912 v = qemu_get_byte(f);
2913 switch(v) {
2914 case 0:
2915 if (qemu_get_buffer(f, buf, len) != len)
2916 return -EIO;
2917 break;
2918 case 1:
2919 v = qemu_get_byte(f);
2920 memset(buf, v, len);
2921 break;
2922 default:
2923 return -EINVAL;
2924 }
871d2f07
AL		 2925
2926 if (qemu_file_has_error(f))
2927 return -EIO;
2928
8a7ddc38
FB		 2929 return 0;
2930}
2931
c88676f8
FB		 2932static int ram_load_v1(QEMUFile *f, void *opaque)
2933{
00f82b8a
AJ		 2934 int ret;
2935 ram_addr_t i;
c88676f8
FB		 2936
2937 if (qemu_get_be32(f) != phys_ram_size)
2938 return -EINVAL;
2939 for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
2940 ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
2941 if (ret)
2942 return ret;
2943 }
2944 return 0;
2945}
2946
2947#define BDRV_HASH_BLOCK_SIZE 1024
2948#define IOBUF_SIZE 4096
2949#define RAM_CBLOCK_MAGIC 0xfabe
2950
c88676f8
FB		 2951typedef struct RamDecompressState {
2952 z_stream zstream;
2953 QEMUFile *f;
2954 uint8_t buf[IOBUF_SIZE];
2955} RamDecompressState;
2956
2957static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
2958{
2959 int ret;
2960 memset(s, 0, sizeof(*s));
2961 s->f = f;
2962 ret = inflateInit(&s->zstream);
2963 if (ret != Z_OK)
2964 return -1;
2965 return 0;
2966}
2967
2968static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
2969{
2970 int ret, clen;
2971
2972 s->zstream.avail_out = len;
2973 s->zstream.next_out = buf;
2974 while (s->zstream.avail_out > 0) {
2975 if (s->zstream.avail_in == 0) {
2976 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
2977 return -1;
2978 clen = qemu_get_be16(s->f);
2979 if (clen > IOBUF_SIZE)
2980 return -1;
2981 qemu_get_buffer(s->f, s->buf, clen);
2982 s->zstream.avail_in = clen;
2983 s->zstream.next_in = s->buf;
2984 }
2985 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
2986 if (ret != Z_OK && ret != Z_STREAM_END) {
2987 return -1;
2988 }
2989 }
2990 return 0;
2991}
2992
2993static void ram_decompress_close(RamDecompressState *s)
2994{
2995 inflateEnd(&s->zstream);
2996}
2997
475e4277
AL		 2998#define RAM_SAVE_FLAG_FULL 0x01
2999#define RAM_SAVE_FLAG_COMPRESS 0x02
3000#define RAM_SAVE_FLAG_MEM_SIZE 0x04
3001#define RAM_SAVE_FLAG_PAGE 0x08
3002#define RAM_SAVE_FLAG_EOS 0x10
3003
3004static int is_dup_page(uint8_t *page, uint8_t ch)
8a7ddc38 3005{
475e4277
AL		 3006 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3007 uint32_t *array = (uint32_t *)page;
3008 int i;
3b46e624 3009
475e4277
AL		 3010 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3011 if (array[i] != val)
3012 return 0;
3013 }
3014
3015 return 1;
3016}
3017
3018static int ram_save_block(QEMUFile *f)
3019{
3020 static ram_addr_t current_addr = 0;
3021 ram_addr_t saved_addr = current_addr;
3022 ram_addr_t addr = 0;
3023 int found = 0;
3024
3025 while (addr < phys_ram_size) {
3026 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3027 uint8_t ch;
3028
3029 cpu_physical_memory_reset_dirty(current_addr,
3030 current_addr + TARGET_PAGE_SIZE,
3031 MIGRATION_DIRTY_FLAG);
3032
3033 ch = *(phys_ram_base + current_addr);
3034
3035 if (is_dup_page(phys_ram_base + current_addr, ch)) {
3036 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3037 qemu_put_byte(f, ch);
3038 } else {
3039 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3040 qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
c88676f8 3041 }
475e4277
AL		 3042
3043 found = 1;
3044 break;
c88676f8 3045 }
475e4277
AL		 3046 addr += TARGET_PAGE_SIZE;
3047 current_addr = (saved_addr + addr) % phys_ram_size;
8a7ddc38 3048 }
475e4277
AL		 3049
3050 return found;
8a7ddc38
FB		 3051}
3052
475e4277
AL		 3053static ram_addr_t ram_save_threshold = 10;
3054
3055static ram_addr_t ram_save_remaining(void)
3056{
3057 ram_addr_t addr;
3058 ram_addr_t count = 0;
3059
3060 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3061 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3062 count++;
3063 }
3064
3065 return count;
3066}
3067
3068static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3069{
3070 ram_addr_t addr;
3071
3072 if (stage == 1) {
3073 /* Make sure all dirty bits are set */
3074 for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3075 if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3076 cpu_physical_memory_set_dirty(addr);
3077 }
3078
3079 /* Enable dirty memory tracking */
3080 cpu_physical_memory_set_dirty_tracking(1);
3081
3082 qemu_put_be64(f, phys_ram_size | RAM_SAVE_FLAG_MEM_SIZE);
3083 }
3084
3085 while (!qemu_file_rate_limit(f)) {
3086 int ret;
3087
3088 ret = ram_save_block(f);
3089 if (ret == 0) /* no more blocks */
3090 break;
3091 }
3092
3093 /* try transferring iterative blocks of memory */
3094
3095 if (stage == 3) {
3096 cpu_physical_memory_set_dirty_tracking(0);
3097
3098 /* flush all remaining blocks regardless of rate limiting */
3099 while (ram_save_block(f) != 0);
3100 }
3101
3102 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3103
3104 return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3105}
3106
3107static int ram_load_dead(QEMUFile *f, void *opaque)
8a7ddc38 3108{
c88676f8
FB		 3109 RamDecompressState s1, *s = &s1;
3110 uint8_t buf[10];
00f82b8a 3111 ram_addr_t i;
8a7ddc38 3112
c88676f8
FB		 3113 if (ram_decompress_open(s, f) < 0)
3114 return -EINVAL;
3115 for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
3116 if (ram_decompress_buf(s, buf, 1) < 0) {
3117 fprintf(stderr, "Error while reading ram block header\n");
3118 goto error;
3119 }
3120 if (buf[0] == 0) {
3121 if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
00f82b8a 3122 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
c88676f8
FB		 3123 goto error;
3124 }
475e4277 3125 } else {
c88676f8
FB		 3126 error:
3127 printf("Error block header\n");
3128 return -EINVAL;
3129 }
8a7ddc38 3130 }
c88676f8 3131 ram_decompress_close(s);
475e4277
AL		 3132
3133 return 0;
3134}
3135
3136static int ram_load(QEMUFile *f, void *opaque, int version_id)
3137{
3138 ram_addr_t addr;
3139 int flags;
3140
3141 if (version_id == 1)
3142 return ram_load_v1(f, opaque);
3143
3144 if (version_id == 2) {
3145 if (qemu_get_be32(f) != phys_ram_size)
3146 return -EINVAL;
3147 return ram_load_dead(f, opaque);
3148 }
3149
3150 if (version_id != 3)
3151 return -EINVAL;
3152
3153 do {
3154 addr = qemu_get_be64(f);
3155
3156 flags = addr & ~TARGET_PAGE_MASK;
3157 addr &= TARGET_PAGE_MASK;
3158
3159 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3160 if (addr != phys_ram_size)
3161 return -EINVAL;
3162 }
3163
3164 if (flags & RAM_SAVE_FLAG_FULL) {
3165 if (ram_load_dead(f, opaque) < 0)
3166 return -EINVAL;
3167 }
3168
3169 if (flags & RAM_SAVE_FLAG_COMPRESS) {
3170 uint8_t ch = qemu_get_byte(f);
3171 memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3172 } else if (flags & RAM_SAVE_FLAG_PAGE)
3173 qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3174 } while (!(flags & RAM_SAVE_FLAG_EOS));
3175
8a7ddc38
FB		 3176 return 0;
3177}
3178
9e472e10
AL		 3179void qemu_service_io(void)
3180{
3181 CPUState *env = cpu_single_env;
3182 if (env) {
3183 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3184#ifdef USE_KQEMU
3185 if (env->kqemu_enabled) {
3186 kqemu_cpu_interrupt(env);
3187 }
3188#endif
3189 }
3190}
3191
83f64091
FB		 3192/***********************************************************/
3193/* bottom halves (can be seen as timers which expire ASAP) */
3194
3195struct QEMUBH {
3196 QEMUBHFunc *cb;
3197 void *opaque;
3198 int scheduled;
1b435b10
AL		 3199 int idle;
3200 int deleted;
83f64091
FB		 3201 QEMUBH *next;
3202};
3203
3204static QEMUBH *first_bh = NULL;
3205
3206QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3207{
3208 QEMUBH *bh;
3209 bh = qemu_mallocz(sizeof(QEMUBH));
3210 if (!bh)
3211 return NULL;
3212 bh->cb = cb;
3213 bh->opaque = opaque;
1b435b10
AL		 3214 bh->next = first_bh;
3215 first_bh = bh;
83f64091
FB		 3216 return bh;
3217}
3218
6eb5733a 3219int qemu_bh_poll(void)
83f64091 3220{
1b435b10 3221 QEMUBH *bh, **bhp;
6eb5733a 3222 int ret;
83f64091 3223
6eb5733a 3224 ret = 0;
1b435b10
AL		 3225 for (bh = first_bh; bh; bh = bh->next) {
3226 if (!bh->deleted && bh->scheduled) {
3227 bh->scheduled = 0;
3228 if (!bh->idle)
3229 ret = 1;
3230 bh->idle = 0;
3231 bh->cb(bh->opaque);
3232 }
83f64091 3233 }
1b435b10
AL		 3234
3235 /* remove deleted bhs */
3236 bhp = &first_bh;
3237 while (*bhp) {
3238 bh = *bhp;
3239 if (bh->deleted) {
3240 *bhp = bh->next;
3241 qemu_free(bh);
3242 } else
3243 bhp = &bh->next;
3244 }
3245
6eb5733a 3246 return ret;
83f64091
FB		 3247}
3248
1b435b10
AL		 3249void qemu_bh_schedule_idle(QEMUBH *bh)
3250{
3251 if (bh->scheduled)
3252 return;
3253 bh->scheduled = 1;
3254 bh->idle = 1;
3255}
3256
83f64091
FB		 3257void qemu_bh_schedule(QEMUBH *bh)
3258{
3259 CPUState *env = cpu_single_env;
3260 if (bh->scheduled)
3261 return;
3262 bh->scheduled = 1;
1b435b10 3263 bh->idle = 0;
83f64091
FB		 3264 /* stop the currently executing CPU to execute the BH ASAP */
3265 if (env) {
3266 cpu_interrupt(env, CPU_INTERRUPT_EXIT);
3267 }
3268}
3269
3270void qemu_bh_cancel(QEMUBH *bh)
3271{
1b435b10 3272 bh->scheduled = 0;
83f64091
FB		 3273}
3274
3275void qemu_bh_delete(QEMUBH *bh)
3276{
1b435b10
AL		 3277 bh->scheduled = 0;
3278 bh->deleted = 1;
83f64091
FB		 3279}
3280
56f3a5d0
AL		 3281static void qemu_bh_update_timeout(int *timeout)
3282{
3283 QEMUBH *bh;
3284
3285 for (bh = first_bh; bh; bh = bh->next) {
3286 if (!bh->deleted && bh->scheduled) {
3287 if (bh->idle) {
3288 /* idle bottom halves will be polled at least
3289 * every 10ms */
3290 *timeout = MIN(10, *timeout);
3291 } else {
3292 /* non-idle bottom halves will be executed
3293 * immediately */
3294 *timeout = 0;
3295 break;
3296 }
3297 }
3298 }
3299}
3300
cc1daa40
FB		 3301/***********************************************************/
3302/* machine registration */
3303
bdaf78e0 3304static QEMUMachine *first_machine = NULL;
cc1daa40
FB		 3305
3306int qemu_register_machine(QEMUMachine *m)
3307{
3308 QEMUMachine **pm;
3309 pm = &first_machine;
3310 while (*pm != NULL)
3311 pm = &(*pm)->next;
3312 m->next = NULL;
3313 *pm = m;
3314 return 0;
3315}
3316
9596ebb7 3317static QEMUMachine *find_machine(const char *name)
cc1daa40
FB		 3318{
3319 QEMUMachine *m;
3320
3321 for(m = first_machine; m != NULL; m = m->next) {
3322 if (!strcmp(m->name, name))
3323 return m;
3324 }
3325 return NULL;
3326}
3327
8a7ddc38
FB		 3328/***********************************************************/
3329/* main execution loop */
3330
9596ebb7 3331static void gui_update(void *opaque)
8a7ddc38 3332{
740733bb
TS		 3333 DisplayState *ds = opaque;
3334 ds->dpy_refresh(ds);
f442e08b
AJ		 3335 qemu_mod_timer(ds->gui_timer,
3336 (ds->gui_timer_interval ?
3337 ds->gui_timer_interval :
3338 GUI_REFRESH_INTERVAL)
3339 + qemu_get_clock(rt_clock));
8a7ddc38
FB		 3340}
3341
0bd48850
FB		 3342struct vm_change_state_entry {
3343 VMChangeStateHandler *cb;
3344 void *opaque;
3345 LIST_ENTRY (vm_change_state_entry) entries;
3346};
3347
3348static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3349
3350VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3351 void *opaque)
3352{
3353 VMChangeStateEntry *e;
3354
3355 e = qemu_mallocz(sizeof (*e));
3356 if (!e)
3357 return NULL;
3358
3359 e->cb = cb;
3360 e->opaque = opaque;
3361 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3362 return e;
3363}
3364
3365void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3366{
3367 LIST_REMOVE (e, entries);
3368 qemu_free (e);
3369}
3370
3371static void vm_state_notify(int running)
3372{
3373 VMChangeStateEntry *e;
3374
3375 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3376 e->cb(e->opaque, running);
3377 }
3378}
3379
8a7ddc38 3380/* XXX: support several handlers */
0bd48850
FB		 3381static VMStopHandler *vm_stop_cb;
3382static void *vm_stop_opaque;
8a7ddc38
FB		 3383
3384int qemu_add_vm_stop_handler(VMStopHandler *cb, void *opaque)
3385{
3386 vm_stop_cb = cb;
3387 vm_stop_opaque = opaque;
3388 return 0;
3389}
3390
3391void qemu_del_vm_stop_handler(VMStopHandler *cb, void *opaque)
3392{
3393 vm_stop_cb = NULL;
3394}
3395
3396void vm_start(void)
3397{
3398 if (!vm_running) {
3399 cpu_enable_ticks();
3400 vm_running = 1;
0bd48850 3401 vm_state_notify(1);
efe75411 3402 qemu_rearm_alarm_timer(alarm_timer);
8a7ddc38
FB		 3403 }
3404}
3405
5fafdf24 3406void vm_stop(int reason)
8a7ddc38
FB		 3407{
3408 if (vm_running) {
3409 cpu_disable_ticks();
3410 vm_running = 0;
3411 if (reason != 0) {
3412 if (vm_stop_cb) {
3413 vm_stop_cb(vm_stop_opaque, reason);
3414 }
34865134 3415 }
0bd48850 3416 vm_state_notify(0);
8a7ddc38
FB		 3417 }
3418}
3419
bb0c6722
FB		 3420/* reset/shutdown handler */
3421
3422typedef struct QEMUResetEntry {
3423 QEMUResetHandler *func;
3424 void *opaque;
3425 struct QEMUResetEntry *next;
3426} QEMUResetEntry;
3427
3428static QEMUResetEntry *first_reset_entry;
3429static int reset_requested;
3430static int shutdown_requested;
3475187d 3431static int powerdown_requested;
bb0c6722 3432
cf7a2fe2
AJ		 3433int qemu_shutdown_requested(void)
3434{
3435 int r = shutdown_requested;
3436 shutdown_requested = 0;
3437 return r;
3438}
3439
3440int qemu_reset_requested(void)
3441{
3442 int r = reset_requested;
3443 reset_requested = 0;
3444 return r;
3445}
3446
3447int qemu_powerdown_requested(void)
3448{
3449 int r = powerdown_requested;
3450 powerdown_requested = 0;
3451 return r;
3452}
3453
bb0c6722
FB		 3454void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3455{
3456 QEMUResetEntry **pre, *re;
3457
3458 pre = &first_reset_entry;
3459 while (*pre != NULL)
3460 pre = &(*pre)->next;
3461 re = qemu_mallocz(sizeof(QEMUResetEntry));
3462 re->func = func;
3463 re->opaque = opaque;
3464 re->next = NULL;
3465 *pre = re;
3466}
3467
cf7a2fe2 3468void qemu_system_reset(void)
bb0c6722
FB		 3469{
3470 QEMUResetEntry *re;
3471
3472 /* reset all devices */
3473 for(re = first_reset_entry; re != NULL; re = re->next) {
3474 re->func(re->opaque);
3475 }
3476}
3477
3478void qemu_system_reset_request(void)
3479{
d1beab82
FB		 3480 if (no_reboot) {
3481 shutdown_requested = 1;
3482 } else {
3483 reset_requested = 1;
3484 }
6a00d601
FB		 3485 if (cpu_single_env)
3486 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 3487}
3488
3489void qemu_system_shutdown_request(void)
3490{
3491 shutdown_requested = 1;
6a00d601
FB		 3492 if (cpu_single_env)
3493 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 3494}
3495
3475187d
FB		 3496void qemu_system_powerdown_request(void)
3497{
3498 powerdown_requested = 1;
6a00d601
FB		 3499 if (cpu_single_env)
3500 cpu_interrupt(cpu_single_env, CPU_INTERRUPT_EXIT);
bb0c6722
FB		 3501}
3502
877cf882 3503#ifdef _WIN32
56f3a5d0
AL		 3504void host_main_loop_wait(int *timeout)
3505{
3506 int ret, ret2, i;
f331110f
FB		 3507 PollingEntry *pe;
3508
c4b1fcc0 3509
f331110f
FB		 3510 /* XXX: need to suppress polling by better using win32 events */
3511 ret = 0;
3512 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3513 ret |= pe->func(pe->opaque);
3514 }
e6b1e558 3515 if (ret == 0) {
a18e524a
FB		 3516 int err;
3517 WaitObjects *w = &wait_objects;
3b46e624 3518
56f3a5d0 3519 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
a18e524a
FB		 3520 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3521 if (w->func[ret - WAIT_OBJECT_0])
3522 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3b46e624 3523
5fafdf24 3524 /* Check for additional signaled events */
e6b1e558 3525 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3b46e624 3526
e6b1e558
TS		 3527 /* Check if event is signaled */
3528 ret2 = WaitForSingleObject(w->events[i], 0);
3529 if(ret2 == WAIT_OBJECT_0) {
3530 if (w->func[i])
3531 w->func[i](w->opaque[i]);
3532 } else if (ret2 == WAIT_TIMEOUT) {
3533 } else {
3534 err = GetLastError();
3535 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3b46e624
TS		 3536 }
3537 }
a18e524a
FB		 3538 } else if (ret == WAIT_TIMEOUT) {
3539 } else {
3540 err = GetLastError();
e6b1e558 3541 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
a18e524a 3542 }
f331110f 3543 }
56f3a5d0
AL		 3544
3545 *timeout = 0;
3546}
3547#else
3548void host_main_loop_wait(int *timeout)
3549{
3550}
fd1dff4b 3551#endif
56f3a5d0
AL		 3552
3553void main_loop_wait(int timeout)
3554{
3555 IOHandlerRecord *ioh;
3556 fd_set rfds, wfds, xfds;
3557 int ret, nfds;
3558 struct timeval tv;
3559
3560 qemu_bh_update_timeout(&timeout);
3561
3562 host_main_loop_wait(&timeout);
3563
fd1dff4b
FB		 3564 /* poll any events */
3565 /* XXX: separate device handlers from system ones */
6abfbd79 3566 nfds = -1;
fd1dff4b
FB		 3567 FD_ZERO(&rfds);
3568 FD_ZERO(&wfds);
e035649e 3569 FD_ZERO(&xfds);
fd1dff4b 3570 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
cafffd40
TS		 3571 if (ioh->deleted)
3572 continue;
fd1dff4b
FB		 3573 if (ioh->fd_read &&
3574 (!ioh->fd_read_poll ||
3575 ioh->fd_read_poll(ioh->opaque) != 0)) {
3576 FD_SET(ioh->fd, &rfds);
3577 if (ioh->fd > nfds)
3578 nfds = ioh->fd;
3579 }
3580 if (ioh->fd_write) {
3581 FD_SET(ioh->fd, &wfds);
3582 if (ioh->fd > nfds)
3583 nfds = ioh->fd;
3584 }
3585 }
3b46e624 3586
56f3a5d0
AL		 3587 tv.tv_sec = timeout / 1000;
3588 tv.tv_usec = (timeout % 1000) * 1000;
3589
e035649e 3590#if defined(CONFIG_SLIRP)
63a01ef8 3591 if (slirp_is_inited()) {
e035649e
FB		 3592 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3593 }
3594#endif
3595 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
fd1dff4b 3596 if (ret > 0) {
cafffd40
TS		 3597 IOHandlerRecord **pioh;
3598
3599 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6ab43fdc 3600 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
fd1dff4b 3601 ioh->fd_read(ioh->opaque);
7c9d8e07 3602 }
6ab43fdc 3603 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
fd1dff4b 3604 ioh->fd_write(ioh->opaque);
c4b1fcc0 3605 }
b4608c04 3606 }
cafffd40
TS		 3607
3608 /* remove deleted IO handlers */
3609 pioh = &first_io_handler;
3610 while (*pioh) {
3611 ioh = *pioh;
3612 if (ioh->deleted) {
3613 *pioh = ioh->next;
3614 qemu_free(ioh);
5fafdf24 3615 } else
cafffd40
TS		 3616 pioh = &ioh->next;
3617 }
fd1dff4b 3618 }
c20709aa 3619#if defined(CONFIG_SLIRP)
63a01ef8 3620 if (slirp_is_inited()) {
e035649e
FB		 3621 if (ret < 0) {
3622 FD_ZERO(&rfds);
3623 FD_ZERO(&wfds);
3624 FD_ZERO(&xfds);
c20709aa 3625 }
e035649e 3626 slirp_select_poll(&rfds, &wfds, &xfds);
fd1dff4b 3627 }
e035649e 3628#endif
b4608c04 3629
423f0742
PB		 3630 /* Check bottom-halves last in case any of the earlier events triggered
3631 them. */
3632 qemu_bh_poll();
3b46e624 3633
5905b2e5
FB		 3634}
3635
9596ebb7 3636static int main_loop(void)
5905b2e5
FB		 3637{
3638 int ret, timeout;
89bfc105
FB		 3639#ifdef CONFIG_PROFILER
3640 int64_t ti;
3641#endif
6a00d601 3642 CPUState *env;
5905b2e5 3643
6a00d601 3644 cur_cpu = first_cpu;
ee5605e5 3645 next_cpu = cur_cpu->next_cpu ?: first_cpu;
5905b2e5
FB		 3646 for(;;) {
3647 if (vm_running) {
15a76449 3648
15a76449
FB		 3649 for(;;) {
3650 /* get next cpu */
ee5605e5 3651 env = next_cpu;
89bfc105
FB		 3652#ifdef CONFIG_PROFILER
3653 ti = profile_getclock();
3654#endif
2e70f6ef
PB		 3655 if (use_icount) {
3656 int64_t count;
3657 int decr;
3658 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3659 env->icount_decr.u16.low = 0;
3660 env->icount_extra = 0;
3661 count = qemu_next_deadline();
3662 count = (count + (1 << icount_time_shift) - 1)
3663 >> icount_time_shift;
3664 qemu_icount += count;
3665 decr = (count > 0xffff) ? 0xffff : count;
3666 count -= decr;
3667 env->icount_decr.u16.low = decr;
3668 env->icount_extra = count;
3669 }
6a00d601 3670 ret = cpu_exec(env);
89bfc105
FB		 3671#ifdef CONFIG_PROFILER
3672 qemu_time += profile_getclock() - ti;
3673#endif
2e70f6ef
PB		 3674 if (use_icount) {
3675 /* Fold pending instructions back into the
3676 instruction counter, and clear the interrupt flag. */
3677 qemu_icount -= (env->icount_decr.u16.low
3678 + env->icount_extra);
3679 env->icount_decr.u32 = 0;
3680 env->icount_extra = 0;
3681 }
ee5605e5 3682 next_cpu = env->next_cpu ?: first_cpu;
95b01009 3683 if (event_pending && likely(ret != EXCP_DEBUG)) {
ee5605e5
AZ		 3684 ret = EXCP_INTERRUPT;
3685 event_pending = 0;
3686 break;
3687 }
bd967e05
PB		 3688 if (ret == EXCP_HLT) {
3689 /* Give the next CPU a chance to run. */
3690 cur_cpu = env;
3691 continue;
3692 }
15a76449
FB		 3693 if (ret != EXCP_HALTED)
3694 break;
3695 /* all CPUs are halted ? */
bd967e05 3696 if (env == cur_cpu)
15a76449 3697 break;
15a76449
FB		 3698 }
3699 cur_cpu = env;
3700
5905b2e5 3701 if (shutdown_requested) {
3475187d 3702 ret = EXCP_INTERRUPT;
b2f76161
AJ		 3703 if (no_shutdown) {
3704 vm_stop(0);
3705 no_shutdown = 0;
3706 }
3707 else
3708 break;
5905b2e5
FB		 3709 }
3710 if (reset_requested) {
3711 reset_requested = 0;
3712 qemu_system_reset();
3475187d
FB		 3713 ret = EXCP_INTERRUPT;
3714 }
3715 if (powerdown_requested) {
3716 powerdown_requested = 0;
3717 qemu_system_powerdown();
3718 ret = EXCP_INTERRUPT;
5905b2e5 3719 }
95b01009 3720 if (unlikely(ret == EXCP_DEBUG)) {
5905b2e5
FB		 3721 vm_stop(EXCP_DEBUG);
3722 }
bd967e05 3723 /* If all cpus are halted then wait until the next IRQ */
5905b2e5 3724 /* XXX: use timeout computed from timers */
2e70f6ef
PB		 3725 if (ret == EXCP_HALTED) {
3726 if (use_icount) {
3727 int64_t add;
3728 int64_t delta;
3729 /* Advance virtual time to the next event. */
3730 if (use_icount == 1) {
3731 /* When not using an adaptive execution frequency
3732 we tend to get badly out of sync with real time,
bf20dc07 3733 so just delay for a reasonable amount of time. */
2e70f6ef
PB		 3734 delta = 0;
3735 } else {
3736 delta = cpu_get_icount() - cpu_get_clock();
3737 }
3738 if (delta > 0) {
3739 /* If virtual time is ahead of real time then just
3740 wait for IO. */
3741 timeout = (delta / 1000000) + 1;
3742 } else {
3743 /* Wait for either IO to occur or the next
3744 timer event. */
3745 add = qemu_next_deadline();
3746 /* We advance the timer before checking for IO.
3747 Limit the amount we advance so that early IO
3748 activity won't get the guest too far ahead. */
3749 if (add > 10000000)
3750 add = 10000000;
3751 delta += add;
3752 add = (add + (1 << icount_time_shift) - 1)
3753 >> icount_time_shift;
3754 qemu_icount += add;
3755 timeout = delta / 1000000;
3756 if (timeout < 0)
3757 timeout = 0;
3758 }
3759 } else {
0a1af395 3760 timeout = 5000;
2e70f6ef
PB		 3761 }
3762 } else {
5905b2e5 3763 timeout = 0;
2e70f6ef 3764 }
5905b2e5 3765 } else {
98448f58
BS		 3766 if (shutdown_requested) {
3767 ret = EXCP_INTERRUPT;
5b08fc10 3768 break;
98448f58 3769 }
0a1af395 3770 timeout = 5000;
5905b2e5 3771 }
89bfc105
FB		 3772#ifdef CONFIG_PROFILER
3773 ti = profile_getclock();
3774#endif
5905b2e5 3775 main_loop_wait(timeout);
89bfc105
FB		 3776#ifdef CONFIG_PROFILER
3777 dev_time += profile_getclock() - ti;
3778#endif
b4608c04 3779 }
34865134
FB		 3780 cpu_disable_ticks();
3781 return ret;
b4608c04
FB		 3782}
3783
15f82208 3784static void help(int exitcode)
0824d6fc 3785{
68d0f70e 3786 printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
0db63474 3787 "usage: %s [options] [disk_image]\n"
0824d6fc 3788 "\n"
a20dd508 3789 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
fc01f7e7 3790 "\n"
a20dd508 3791 "Standard options:\n"
cc1daa40 3792 "-M machine select emulated machine (-M ? for list)\n"
5adb4839 3793 "-cpu cpu select CPU (-cpu ? for list)\n"
c45886db 3794 "-fda/-fdb file use 'file' as floppy disk 0/1 image\n"
36b486bb
FB		 3795 "-hda/-hdb file use 'file' as IDE hard disk 0/1 image\n"
3796 "-hdc/-hdd file use 'file' as IDE hard disk 2/3 image\n"
c4b1fcc0 3797 "-cdrom file use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
a1620fac
AJ		 3798 "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
3799 " [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
9f7965c7 3800 " [,cache=writethrough|writeback|none][,format=f]\n"
e4bcb14c 3801 " use 'file' as a drive image\n"
3e3d5815 3802 "-mtdblock file use 'file' as on-board Flash memory image\n"
a1bb27b1 3803 "-sd file use 'file' as SecureDigital card image\n"
86f55663 3804 "-pflash file use 'file' as a parallel flash image\n"
eec85c2a 3805 "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
667accab
TS		 3806 "-snapshot write to temporary files instead of disk image files\n"
3807#ifdef CONFIG_SDL
43523e93 3808 "-no-frame open SDL window without a frame and window decorations\n"
3780e197 3809 "-alt-grab use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
667accab
TS		 3810 "-no-quit disable SDL window close capability\n"
3811#endif
52ca8d6a
FB		 3812#ifdef TARGET_I386
3813 "-no-fd-bootchk disable boot signature checking for floppy disks\n"
3814#endif
a00bad7e 3815 "-m megs set virtual RAM size to megs MB [default=%d]\n"
91fc2119 3816 "-smp n set the number of CPUs to 'n' [default=1]\n"
c4b1fcc0 3817 "-nographic disable graphical output and redirect serial I/Os to console\n"
a171fe39 3818 "-portrait rotate graphical output 90 deg left (only PXA LCD)\n"
4ca0074c 3819#ifndef _WIN32
667accab 3820 "-k language use keyboard layout (for example \"fr\" for French)\n"
4ca0074c 3821#endif
1d14ffa9 3822#ifdef HAS_AUDIO
1d14ffa9 3823 "-audio-help print list of audio drivers and their options\n"
c0fe3827
FB		 3824 "-soundhw c1,... enable audio support\n"
3825 " and only specified sound cards (comma separated list)\n"
3826 " use -soundhw ? to get the list of supported cards\n"
6a36d84e 3827 " use -soundhw all to enable all of them\n"
1d14ffa9 3828#endif
3893c124 3829 "-vga [std|cirrus|vmware]\n"
3830 " select video card type\n"
89980284 3831 "-localtime set the real time clock to local time [default=utc]\n"
d63d307f 3832 "-full-screen start in full screen\n"
a09db21f
FB		 3833#ifdef TARGET_I386
3834 "-win2k-hack use it when installing Windows 2000 to avoid a disk full bug\n"
3835#endif
b389dbfb
FB		 3836 "-usb enable the USB driver (will be the default soon)\n"
3837 "-usbdevice name add the host or guest USB device 'name'\n"
6f7e9aec
FB		 3838#if defined(TARGET_PPC) || defined(TARGET_SPARC)
3839 "-g WxH[xDEPTH] Set the initial graphical resolution and depth\n"
bb0c6722 3840#endif
c35734b2 3841 "-name string set the name of the guest\n"
8fcb1b90 3842 "-uuid %%08x-%%04x-%%04x-%%04x-%%012x specify machine UUID\n"
c4b1fcc0
FB		 3843 "\n"
3844 "Network options:\n"
a41b2ff2 3845 "-net nic[,vlan=n][,macaddr=addr][,model=type]\n"
7c9d8e07 3846 " create a new Network Interface Card and connect it to VLAN 'n'\n"
c20709aa 3847#ifdef CONFIG_SLIRP
115defd1
PB		 3848 "-net user[,vlan=n][,hostname=host]\n"
3849 " connect the user mode network stack to VLAN 'n' and send\n"
3850 " hostname 'host' to DHCP clients\n"
7c9d8e07 3851#endif
7fb843f8
FB		 3852#ifdef _WIN32
3853 "-net tap[,vlan=n],ifname=name\n"
3854 " connect the host TAP network interface to VLAN 'n'\n"
3855#else
b46a8906
TS		 3856 "-net tap[,vlan=n][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
3857 " connect the host TAP network interface to VLAN 'n' and use the\n"
3858 " network scripts 'file' (default=%s)\n"
3859 " and 'dfile' (default=%s);\n"
3860 " use '[down]script=no' to disable script execution;\n"
7c9d8e07 3861 " use 'fd=h' to connect to an already opened TAP interface\n"
7fb843f8 3862#endif
6a00d601 3863 "-net socket[,vlan=n][,fd=h][,listen=[host]:port][,connect=host:port]\n"
7c9d8e07 3864 " connect the vlan 'n' to another VLAN using a socket connection\n"
3d830459
FB		 3865 "-net socket[,vlan=n][,fd=h][,mcast=maddr:port]\n"
3866 " connect the vlan 'n' to multicast maddr and port\n"
8a16d273
TS		 3867#ifdef CONFIG_VDE
3868 "-net vde[,vlan=n][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
3869 " connect the vlan 'n' to port 'n' of a vde switch running\n"
3870 " on host and listening for incoming connections on 'socketpath'.\n"
3871 " Use group 'groupname' and mode 'octalmode' to change default\n"
3872 " ownership and permissions for communication port.\n"
3873#endif
7c9d8e07
FB		 3874 "-net none use it alone to have zero network devices; if no -net option\n"
3875 " is provided, the default is '-net nic -net user'\n"
3876 "\n"
dc72ac14
AZ		 3877 "-bt hci,null Dumb bluetooth HCI - doesn't respond to commands\n"
3878 "-bt hci,host[:id]\n"
3879 " Use host's HCI with the given name\n"
3880 "-bt hci[,vlan=n]\n"
3881 " Emulate a standard HCI in virtual scatternet 'n'\n"
3882 "-bt vhci[,vlan=n]\n"
3883 " Add host computer to virtual scatternet 'n' using VHCI\n"
3884 "-bt device:dev[,vlan=n]\n"
3885 " Emulate a bluetooth device 'dev' in scatternet 'n'\n"
3886 "\n"
7c9d8e07 3887#ifdef CONFIG_SLIRP
0db1137d 3888 "-tftp dir allow tftp access to files in dir [-net user]\n"
47d5d01a 3889 "-bootp file advertise file in BOOTP replies\n"
7c9d8e07
FB		 3890#ifndef _WIN32
3891 "-smb dir allow SMB access to files in 'dir' [-net user]\n"
c94c8d64 3892#endif
9bf05444 3893 "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
7c9d8e07 3894 " redirect TCP or UDP connections from host to guest [-net user]\n"
c20709aa 3895#endif
a20dd508 3896 "\n"
c4b1fcc0 3897 "Linux boot specific:\n"
a20dd508
FB		 3898 "-kernel bzImage use 'bzImage' as kernel image\n"
3899 "-append cmdline use 'cmdline' as kernel command line\n"
3900 "-initrd file use 'file' as initial ram disk\n"
fc01f7e7 3901 "\n"
330d0414 3902 "Debug/Expert options:\n"
82c643ff
FB		 3903 "-monitor dev redirect the monitor to char device 'dev'\n"
3904 "-serial dev redirect the serial port to char device 'dev'\n"
6508fe59 3905 "-parallel dev redirect the parallel port to char device 'dev'\n"
f7cce898 3906 "-pidfile file Write PID to 'file'\n"
cd6f1169 3907 "-S freeze CPU at startup (use 'c' to start execution)\n"
cfc3475a
PB		 3908 "-s wait gdb connection to port\n"
3909 "-p port set gdb connection port [default=%s]\n"
f193c797 3910 "-d item1,... output log to %s (use -d ? for a list of log items)\n"
46d4767d
FB		 3911 "-hdachs c,h,s[,t] force hard disk 0 physical geometry and the optional BIOS\n"
3912 " translation (t=none or lba) (usually qemu can guess them)\n"
87b47350 3913 "-L path set the directory for the BIOS, VGA BIOS and keymaps\n"
d993e026 3914#ifdef USE_KQEMU
6515b203 3915 "-kernel-kqemu enable KQEMU full virtualization (default is user mode only)\n"
d993e026
FB		 3916 "-no-kqemu disable KQEMU kernel module usage\n"
3917#endif
7ba1e619
AL		 3918#ifdef CONFIG_KVM
3919 "-enable-kvm enable KVM full virtualization support\n"
3920#endif
bb0c6722 3921#ifdef TARGET_I386
6515b203 3922 "-no-acpi disable ACPI\n"
4d3b6f6e
AZ		 3923#endif
3924#ifdef CONFIG_CURSES
3925 "-curses use a curses/ncurses interface instead of SDL\n"
bb0c6722 3926#endif
d1beab82 3927 "-no-reboot exit instead of rebooting\n"
b2f76161 3928 "-no-shutdown stop before shutdown\n"
a8080006 3929 "-loadvm [tag|id] start right away with a saved state (loadvm in monitor)\n"
24236869 3930 "-vnc display start a VNC server on display\n"
71e3ceb8
TS		 3931#ifndef _WIN32
3932 "-daemonize daemonize QEMU after initializing\n"
3933#endif
9ae02555 3934 "-option-rom rom load a file, rom, into the option ROM space\n"
66508601
BS		 3935#ifdef TARGET_SPARC
3936 "-prom-env variable=value set OpenBIOS nvram variables\n"
3937#endif
f3dcfada 3938 "-clock force the use of the given methods for timer alarm.\n"
3adda04c 3939 " To see what timers are available use -clock ?\n"
bce61846 3940 "-startdate select initial date of the clock\n"
2e70f6ef 3941 "-icount [N|auto]\n"
dd5d6fe9 3942 " Enable virtual instruction counter with 2^N clock ticks per instruction\n"
0824d6fc 3943 "\n"
82c643ff 3944 "During emulation, the following keys are useful:\n"
032a8c9e
FB		 3945 "ctrl-alt-f toggle full screen\n"
3946 "ctrl-alt-n switch to virtual console 'n'\n"
3947 "ctrl-alt toggle mouse and keyboard grab\n"
82c643ff
FB		 3948 "\n"
3949 "When using -nographic, press 'ctrl-a h' to get some help.\n"
3950 ,
0db63474 3951 "qemu",
a00bad7e 3952 DEFAULT_RAM_SIZE,
7c9d8e07 3953#ifndef _WIN32
a00bad7e 3954 DEFAULT_NETWORK_SCRIPT,
b46a8906 3955 DEFAULT_NETWORK_DOWN_SCRIPT,
7c9d8e07 3956#endif
6e44ba7f 3957 DEFAULT_GDBSTUB_PORT,
bce61846 3958 "/tmp/qemu.log");
15f82208 3959 exit(exitcode);
0824d6fc
FB		 3960}
3961
cd6f1169
FB		 3962#define HAS_ARG 0x0001
3963
3964enum {
3965 QEMU_OPTION_h,
3966
cc1daa40 3967 QEMU_OPTION_M,
94fc95cd 3968 QEMU_OPTION_cpu,
cd6f1169
FB		 3969 QEMU_OPTION_fda,
3970 QEMU_OPTION_fdb,
3971 QEMU_OPTION_hda,
3972 QEMU_OPTION_hdb,
3973 QEMU_OPTION_hdc,
3974 QEMU_OPTION_hdd,
e4bcb14c 3975 QEMU_OPTION_drive,
cd6f1169 3976 QEMU_OPTION_cdrom,
3e3d5815 3977 QEMU_OPTION_mtdblock,
a1bb27b1 3978 QEMU_OPTION_sd,
86f55663 3979 QEMU_OPTION_pflash,
cd6f1169
FB		 3980 QEMU_OPTION_boot,
3981 QEMU_OPTION_snapshot,
52ca8d6a
FB		 3982#ifdef TARGET_I386
3983 QEMU_OPTION_no_fd_bootchk,
3984#endif
cd6f1169
FB		 3985 QEMU_OPTION_m,
3986 QEMU_OPTION_nographic,
a171fe39 3987 QEMU_OPTION_portrait,
1d14ffa9 3988#ifdef HAS_AUDIO
1d14ffa9
FB		 3989 QEMU_OPTION_audio_help,
3990 QEMU_OPTION_soundhw,
3991#endif
cd6f1169 3992
7c9d8e07 3993 QEMU_OPTION_net,
c7f74643 3994 QEMU_OPTION_tftp,
47d5d01a 3995 QEMU_OPTION_bootp,
9d728e8c 3996 QEMU_OPTION_smb,
9bf05444 3997 QEMU_OPTION_redir,
dc72ac14 3998 QEMU_OPTION_bt,
cd6f1169
FB		 3999
4000 QEMU_OPTION_kernel,
4001 QEMU_OPTION_append,
4002 QEMU_OPTION_initrd,
4003
4004 QEMU_OPTION_S,
4005 QEMU_OPTION_s,
4006 QEMU_OPTION_p,
4007 QEMU_OPTION_d,
4008 QEMU_OPTION_hdachs,
4009 QEMU_OPTION_L,
1192dad8 4010 QEMU_OPTION_bios,
3d11d0eb 4011 QEMU_OPTION_k,
ee22c2f7 4012 QEMU_OPTION_localtime,
e9b137c2 4013 QEMU_OPTION_g,
3893c124 4014 QEMU_OPTION_vga,
20d8a3ed 4015 QEMU_OPTION_echr,
82c643ff
FB		 4016 QEMU_OPTION_monitor,
4017 QEMU_OPTION_serial,
6508fe59 4018 QEMU_OPTION_parallel,
d63d307f
FB		 4019 QEMU_OPTION_loadvm,
4020 QEMU_OPTION_full_screen,
43523e93 4021 QEMU_OPTION_no_frame,
3780e197 4022 QEMU_OPTION_alt_grab,
667accab 4023 QEMU_OPTION_no_quit,
f7cce898 4024 QEMU_OPTION_pidfile,
d993e026 4025 QEMU_OPTION_no_kqemu,
89bfc105 4026 QEMU_OPTION_kernel_kqemu,
7ba1e619 4027 QEMU_OPTION_enable_kvm,
a09db21f 4028 QEMU_OPTION_win2k_hack,
bb36d470 4029 QEMU_OPTION_usb,
a594cfbf 4030 QEMU_OPTION_usbdevice,
6a00d601 4031 QEMU_OPTION_smp,
24236869 4032 QEMU_OPTION_vnc,
6515b203 4033 QEMU_OPTION_no_acpi,
4d3b6f6e 4034 QEMU_OPTION_curses,
d1beab82 4035 QEMU_OPTION_no_reboot,
b2f76161 4036 QEMU_OPTION_no_shutdown,
9467cd46 4037 QEMU_OPTION_show_cursor,
71e3ceb8 4038 QEMU_OPTION_daemonize,
9ae02555 4039 QEMU_OPTION_option_rom,
c35734b2
TS		 4040 QEMU_OPTION_semihosting,
4041 QEMU_OPTION_name,
66508601 4042 QEMU_OPTION_prom_env,
2b8f2d41 4043 QEMU_OPTION_old_param,
f3dcfada 4044 QEMU_OPTION_clock,
7e0af5d0 4045 QEMU_OPTION_startdate,
26a5f13b 4046 QEMU_OPTION_tb_size,
2e70f6ef 4047 QEMU_OPTION_icount,
8fcb1b90 4048 QEMU_OPTION_uuid,
5bb7910a 4049 QEMU_OPTION_incoming,
cd6f1169
FB		 4050};
4051
4052typedef struct QEMUOption {
4053 const char *name;
4054 int flags;
4055 int index;
4056} QEMUOption;
4057
dbed7e40 4058static const QEMUOption qemu_options[] = {
cd6f1169 4059 { "h", 0, QEMU_OPTION_h },
64423fb2 4060 { "help", 0, QEMU_OPTION_h },
cd6f1169 4061
cc1daa40 4062 { "M", HAS_ARG, QEMU_OPTION_M },
94fc95cd 4063 { "cpu", HAS_ARG, QEMU_OPTION_cpu },
cd6f1169
FB		 4064 { "fda", HAS_ARG, QEMU_OPTION_fda },
4065 { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4066 { "hda", HAS_ARG, QEMU_OPTION_hda },
4067 { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4068 { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4069 { "hdd", HAS_ARG, QEMU_OPTION_hdd },
e4bcb14c 4070 { "drive", HAS_ARG, QEMU_OPTION_drive },
cd6f1169 4071 { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
3e3d5815 4072 { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
a1bb27b1 4073 { "sd", HAS_ARG, QEMU_OPTION_sd },
86f55663 4074 { "pflash", HAS_ARG, QEMU_OPTION_pflash },
cd6f1169
FB		 4075 { "boot", HAS_ARG, QEMU_OPTION_boot },
4076 { "snapshot", 0, QEMU_OPTION_snapshot },
52ca8d6a
FB		 4077#ifdef TARGET_I386
4078 { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
4079#endif
cd6f1169
FB		 4080 { "m", HAS_ARG, QEMU_OPTION_m },
4081 { "nographic", 0, QEMU_OPTION_nographic },
a171fe39 4082 { "portrait", 0, QEMU_OPTION_portrait },
3d11d0eb 4083 { "k", HAS_ARG, QEMU_OPTION_k },
1d14ffa9 4084#ifdef HAS_AUDIO
1d14ffa9
FB		 4085 { "audio-help", 0, QEMU_OPTION_audio_help },
4086 { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4087#endif
cd6f1169 4088
7c9d8e07 4089 { "net", HAS_ARG, QEMU_OPTION_net},
158156d1 4090#ifdef CONFIG_SLIRP
c7f74643 4091 { "tftp", HAS_ARG, QEMU_OPTION_tftp },
47d5d01a 4092 { "bootp", HAS_ARG, QEMU_OPTION_bootp },
c94c8d64 4093#ifndef _WIN32
9d728e8c 4094 { "smb", HAS_ARG, QEMU_OPTION_smb },
c94c8d64 4095#endif
9bf05444 4096 { "redir", HAS_ARG, QEMU_OPTION_redir },
158156d1 4097#endif
dc72ac14 4098 { "bt", HAS_ARG, QEMU_OPTION_bt },
cd6f1169
FB		 4099
4100 { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4101 { "append", HAS_ARG, QEMU_OPTION_append },
4102 { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4103
4104 { "S", 0, QEMU_OPTION_S },
4105 { "s", 0, QEMU_OPTION_s },
4106 { "p", HAS_ARG, QEMU_OPTION_p },
4107 { "d", HAS_ARG, QEMU_OPTION_d },
4108 { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4109 { "L", HAS_ARG, QEMU_OPTION_L },
1192dad8 4110 { "bios", HAS_ARG, QEMU_OPTION_bios },
d993e026
FB		 4111#ifdef USE_KQEMU
4112 { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
89bfc105 4113 { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
d993e026 4114#endif
7ba1e619
AL		 4115#ifdef CONFIG_KVM
4116 { "enable-kvm", 0, QEMU_OPTION_enable_kvm },
4117#endif
6f7e9aec 4118#if defined(TARGET_PPC) || defined(TARGET_SPARC)
e9b137c2 4119 { "g", 1, QEMU_OPTION_g },
77d4bc34 4120#endif
ee22c2f7 4121 { "localtime", 0, QEMU_OPTION_localtime },
3893c124 4122 { "vga", HAS_ARG, QEMU_OPTION_vga },
8b6e0729
AZ		 4123 { "echr", HAS_ARG, QEMU_OPTION_echr },
4124 { "monitor", HAS_ARG, QEMU_OPTION_monitor },
4125 { "serial", HAS_ARG, QEMU_OPTION_serial },
4126 { "parallel", HAS_ARG, QEMU_OPTION_parallel },
d63d307f
FB		 4127 { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4128 { "full-screen", 0, QEMU_OPTION_full_screen },
667accab 4129#ifdef CONFIG_SDL
43523e93 4130 { "no-frame", 0, QEMU_OPTION_no_frame },
3780e197 4131 { "alt-grab", 0, QEMU_OPTION_alt_grab },
667accab
TS		 4132 { "no-quit", 0, QEMU_OPTION_no_quit },
4133#endif
f7cce898 4134 { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
a09db21f 4135 { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
a594cfbf 4136 { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
6a00d601 4137 { "smp", HAS_ARG, QEMU_OPTION_smp },
24236869 4138 { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4d3b6f6e
AZ		 4139#ifdef CONFIG_CURSES
4140 { "curses", 0, QEMU_OPTION_curses },
4141#endif
8fcb1b90 4142 { "uuid", HAS_ARG, QEMU_OPTION_uuid },
96d30e48 4143
1f04275e 4144 /* temporary options */
a594cfbf 4145 { "usb", 0, QEMU_OPTION_usb },
6515b203 4146 { "no-acpi", 0, QEMU_OPTION_no_acpi },
d1beab82 4147 { "no-reboot", 0, QEMU_OPTION_no_reboot },
b2f76161 4148 { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
9467cd46 4149 { "show-cursor", 0, QEMU_OPTION_show_cursor },
71e3ceb8 4150 { "daemonize", 0, QEMU_OPTION_daemonize },
9ae02555 4151 { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
a87295e8 4152#if defined(TARGET_ARM) || defined(TARGET_M68K)
8e71621f
PB		 4153 { "semihosting", 0, QEMU_OPTION_semihosting },
4154#endif
c35734b2 4155 { "name", HAS_ARG, QEMU_OPTION_name },
66508601
BS		 4156#if defined(TARGET_SPARC)
4157 { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
2b8f2d41
AZ		 4158#endif
4159#if defined(TARGET_ARM)
4160 { "old-param", 0, QEMU_OPTION_old_param },
66508601 4161#endif
f3dcfada 4162 { "clock", HAS_ARG, QEMU_OPTION_clock },
7e0af5d0 4163 { "startdate", HAS_ARG, QEMU_OPTION_startdate },
26a5f13b 4164 { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
2e70f6ef 4165 { "icount", HAS_ARG, QEMU_OPTION_icount },
5bb7910a 4166 { "incoming", HAS_ARG, QEMU_OPTION_incoming },
cd6f1169 4167 { NULL },
fc01f7e7
FB		 4168};
4169
5905b2e5
FB		 4170/* password input */
4171
2bac6019
AZ		 4172int qemu_key_check(BlockDriverState *bs, const char *name)
4173{
4174 char password[256];
4175 int i;
4176
4177 if (!bdrv_is_encrypted(bs))
4178 return 0;
4179
4180 term_printf("%s is encrypted.\n", name);
4181 for(i = 0; i < 3; i++) {
4182 monitor_readline("Password: ", 1, password, sizeof(password));
4183 if (bdrv_set_key(bs, password) == 0)
4184 return 0;
4185 term_printf("invalid password\n");
4186 }
4187 return -EPERM;
4188}
4189
83ab7950
AL		 4190static BlockDriverState *get_bdrv(int index)
4191{
4192 if (index > nb_drives)
4193 return NULL;
4194 return drives_table[index].bdrv;
4195}
4196
5905b2e5
FB		 4197static void read_passwords(void)
4198{
4199 BlockDriverState *bs;
2bac6019 4200 int i;
5905b2e5 4201
83ab7950
AL		 4202 for(i = 0; i < 6; i++) {
4203 bs = get_bdrv(i);
4204 if (bs)
4205 qemu_key_check(bs, bdrv_get_device_name(bs));
5905b2e5
FB		 4206 }
4207}
4208
1d14ffa9 4209#ifdef HAS_AUDIO
6a36d84e 4210struct soundhw soundhw[] = {
b00052e4 4211#ifdef HAS_AUDIO_CHOICE
4ce7ff6e 4212#if defined(TARGET_I386) || defined(TARGET_MIPS)
fd06c375
FB		 4213 {
4214 "pcspk",
4215 "PC speaker",
4216 0,
4217 1,
4218 { .init_isa = pcspk_audio_init }
4219 },
4220#endif
6a36d84e
FB		 4221 {
4222 "sb16",
4223 "Creative Sound Blaster 16",
4224 0,
4225 1,
4226 { .init_isa = SB16_init }
4227 },
4228
cc53d26d 4229#ifdef CONFIG_CS4231A
4230 {
4231 "cs4231a",
4232 "CS4231A",
4233 0,
4234 1,
4235 { .init_isa = cs4231a_init }
4236 },
4237#endif
4238
1d14ffa9 4239#ifdef CONFIG_ADLIB
6a36d84e
FB		 4240 {
4241 "adlib",
1d14ffa9 4242#ifdef HAS_YMF262
6a36d84e 4243 "Yamaha YMF262 (OPL3)",
1d14ffa9 4244#else
6a36d84e 4245 "Yamaha YM3812 (OPL2)",
1d14ffa9 4246#endif
6a36d84e
FB		 4247 0,
4248 1,
4249 { .init_isa = Adlib_init }
4250 },
1d14ffa9 4251#endif
6a36d84e 4252
1d14ffa9 4253#ifdef CONFIG_GUS
6a36d84e
FB		 4254 {
4255 "gus",
4256 "Gravis Ultrasound GF1",
4257 0,
4258 1,
4259 { .init_isa = GUS_init }
4260 },
1d14ffa9 4261#endif
6a36d84e 4262
e5c9a13e
AZ		 4263#ifdef CONFIG_AC97
4264 {
4265 "ac97",
4266 "Intel 82801AA AC97 Audio",
4267 0,
4268 0,
4269 { .init_pci = ac97_init }
4270 },
4271#endif
4272
6a36d84e
FB		 4273 {
4274 "es1370",
4275 "ENSONIQ AudioPCI ES1370",
4276 0,
4277 0,
4278 { .init_pci = es1370_init }
4279 },
b00052e4 4280#endif
6a36d84e
FB		 4281
4282 { NULL, NULL, 0, 0, { NULL } }
4283};
4284
4285static void select_soundhw (const char *optarg)
4286{
4287 struct soundhw *c;
4288
4289 if (*optarg == '?') {
4290 show_valid_cards:
4291
4292 printf ("Valid sound card names (comma separated):\n");
4293 for (c = soundhw; c->name; ++c) {
4294 printf ("%-11s %s\n", c->name, c->descr);
4295 }
4296 printf ("\n-soundhw all will enable all of the above\n");
1d14ffa9
FB		 4297 exit (*optarg != '?');
4298 }
4299 else {
6a36d84e 4300 size_t l;
1d14ffa9
FB		 4301 const char *p;
4302 char *e;
4303 int bad_card = 0;
4304
6a36d84e
FB		 4305 if (!strcmp (optarg, "all")) {
4306 for (c = soundhw; c->name; ++c) {
4307 c->enabled = 1;
4308 }
4309 return;
4310 }
1d14ffa9 4311
6a36d84e 4312 p = optarg;
1d14ffa9
FB		 4313 while (*p) {
4314 e = strchr (p, ',');
4315 l = !e ? strlen (p) : (size_t) (e - p);
6a36d84e
FB		 4316
4317 for (c = soundhw; c->name; ++c) {
4318 if (!strncmp (c->name, p, l)) {
4319 c->enabled = 1;
1d14ffa9
FB		 4320 break;
4321 }
4322 }
6a36d84e
FB		 4323
4324 if (!c->name) {
1d14ffa9
FB		 4325 if (l > 80) {
4326 fprintf (stderr,
4327 "Unknown sound card name (too big to show)\n");
4328 }
4329 else {
4330 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4331 (int) l, p);
4332 }
4333 bad_card = 1;
4334 }
4335 p += l + (e != NULL);
4336 }
4337
4338 if (bad_card)
4339 goto show_valid_cards;
4340 }
4341}
4342#endif
4343
3893c124 4344static void select_vgahw (const char *p)
4345{
4346 const char *opts;
4347
4348 if (strstart(p, "std", &opts)) {
4349 cirrus_vga_enabled = 0;
4350 vmsvga_enabled = 0;
4351 } else if (strstart(p, "cirrus", &opts)) {
4352 cirrus_vga_enabled = 1;
4353 vmsvga_enabled = 0;
4354 } else if (strstart(p, "vmware", &opts)) {
4355 cirrus_vga_enabled = 0;
4356 vmsvga_enabled = 1;
4357 } else {
4358 invalid_vga:
4359 fprintf(stderr, "Unknown vga type: %s\n", p);
4360 exit(1);
4361 }
cb5a7aa8 4362 while (*opts) {
4363 const char *nextopt;
4364
4365 if (strstart(opts, ",retrace=", &nextopt)) {
4366 opts = nextopt;
4367 if (strstart(opts, "dumb", &nextopt))
4368 vga_retrace_method = VGA_RETRACE_DUMB;
4369 else if (strstart(opts, "precise", &nextopt))
4370 vga_retrace_method = VGA_RETRACE_PRECISE;
4371 else goto invalid_vga;
4372 } else goto invalid_vga;
4373 opts = nextopt;
4374 }
3893c124 4375}
4376
3587d7e6
FB		 4377#ifdef _WIN32
4378static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4379{
4380 exit(STATUS_CONTROL_C_EXIT);
4381 return TRUE;
4382}
4383#endif
4384
8fcb1b90
BS		 4385static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4386{
4387 int ret;
4388
4389 if(strlen(str) != 36)
4390 return -1;
4391
4392 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4393 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4394 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4395
4396 if(ret != 16)
4397 return -1;
4398
4399 return 0;
4400}
4401
7c9d8e07 4402#define MAX_NET_CLIENTS 32
c20709aa 4403
5b08fc10
AL		 4404#ifndef _WIN32
4405
4406static void termsig_handler(int signal)
4407{
4408 qemu_system_shutdown_request();
4409}
4410
6f9e3801 4411static void termsig_setup(void)
5b08fc10
AL		 4412{
4413 struct sigaction act;
4414
4415 memset(&act, 0, sizeof(act));
4416 act.sa_handler = termsig_handler;
4417 sigaction(SIGINT, &act, NULL);
4418 sigaction(SIGHUP, &act, NULL);
4419 sigaction(SIGTERM, &act, NULL);
4420}
4421
4422#endif
4423
0824d6fc
FB		 4424int main(int argc, char **argv)
4425{
67b915a5 4426#ifdef CONFIG_GDBSTUB
cfc3475a
PB		 4427 int use_gdbstub;
4428 const char *gdbstub_port;
67b915a5 4429#endif
28c5af54 4430 uint32_t boot_devices_bitmap = 0;
e4bcb14c 4431 int i;
28c5af54 4432 int snapshot, linux_boot, net_boot;
7f7f9873 4433 const char *initrd_filename;
a20dd508 4434 const char *kernel_filename, *kernel_cmdline;
28c5af54 4435 const char *boot_devices = "";
313aa567 4436 DisplayState *ds = &display_state;
46d4767d 4437 int cyls, heads, secs, translation;
fd5f393a 4438 const char *net_clients[MAX_NET_CLIENTS];
7c9d8e07 4439 int nb_net_clients;
dc72ac14
AZ		 4440 const char *bt_opts[MAX_BT_CMDLINE];
4441 int nb_bt_opts;
e4bcb14c 4442 int hda_index;
cd6f1169
FB		 4443 int optind;
4444 const char *r, *optarg;
82c643ff 4445 CharDriverState *monitor_hd;
fd5f393a
PB		 4446 const char *monitor_device;
4447 const char *serial_devices[MAX_SERIAL_PORTS];
8d11df9e 4448 int serial_device_index;
fd5f393a 4449 const char *parallel_devices[MAX_PARALLEL_PORTS];
6508fe59 4450 int parallel_device_index;
d63d307f 4451 const char *loadvm = NULL;
cc1daa40 4452 QEMUMachine *machine;
94fc95cd 4453 const char *cpu_model;
fd5f393a 4454 const char *usb_devices[MAX_USB_CMDLINE];
a594cfbf 4455 int usb_devices_index;
71e3ceb8 4456 int fds[2];
26a5f13b 4457 int tb_size;
93815bc2 4458 const char *pid_file = NULL;
41bd639b 4459 int autostart;
5bb7910a 4460 const char *incoming = NULL;
0bd48850
FB		 4461
4462 LIST_INIT (&vm_change_state_head);
be995c27
FB		 4463#ifndef _WIN32
4464 {
4465 struct sigaction act;
4466 sigfillset(&act.sa_mask);
4467 act.sa_flags = 0;
4468 act.sa_handler = SIG_IGN;
4469 sigaction(SIGPIPE, &act, NULL);
4470 }
3587d7e6
FB		 4471#else
4472 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
a8e5ac33
FB		 4473 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4474 QEMU to run on a single CPU */
4475 {
4476 HANDLE h;
4477 DWORD mask, smask;
4478 int i;
4479 h = GetCurrentProcess();
4480 if (GetProcessAffinityMask(h, &mask, &smask)) {
4481 for(i = 0; i < 32; i++) {
4482 if (mask & (1 << i))
4483 break;
4484 }
4485 if (i != 32) {
4486 mask = 1 << i;
4487 SetProcessAffinityMask(h, mask);
4488 }
4489 }
4490 }
67b915a5 4491#endif
be995c27 4492
cc1daa40
FB		 4493 register_machines();
4494 machine = first_machine;
94fc95cd 4495 cpu_model = NULL;
fc01f7e7 4496 initrd_filename = NULL;
4fc5d071 4497 ram_size = 0;
313aa567 4498 vga_ram_size = VGA_RAM_SIZE;
67b915a5 4499#ifdef CONFIG_GDBSTUB
b4608c04 4500 use_gdbstub = 0;
c636bb66 4501 gdbstub_port = DEFAULT_GDBSTUB_PORT;
67b915a5 4502#endif
33e3963e 4503 snapshot = 0;
a20dd508 4504 nographic = 0;
4d3b6f6e 4505 curses = 0;
a20dd508
FB		 4506 kernel_filename = NULL;
4507 kernel_cmdline = "";
c4b1fcc0 4508 cyls = heads = secs = 0;
46d4767d 4509 translation = BIOS_ATA_TRANSLATION_AUTO;
c60e08d9 4510 monitor_device = "vc";
c4b1fcc0 4511
c75a823c 4512 serial_devices[0] = "vc:80Cx24C";
8d11df9e 4513 for(i = 1; i < MAX_SERIAL_PORTS; i++)
fd5f393a 4514 serial_devices[i] = NULL;
8d11df9e 4515 serial_device_index = 0;
3b46e624 4516
c75a823c 4517 parallel_devices[0] = "vc:640x480";
6508fe59 4518 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
fd5f393a 4519 parallel_devices[i] = NULL;
6508fe59 4520 parallel_device_index = 0;
3b46e624 4521
a594cfbf 4522 usb_devices_index = 0;
3b46e624 4523
7c9d8e07 4524 nb_net_clients = 0;
dc72ac14 4525 nb_bt_opts = 0;
e4bcb14c
TS		 4526 nb_drives = 0;
4527 nb_drives_opt = 0;
4528 hda_index = -1;
7c9d8e07
FB		 4529
4530 nb_nics = 0;
3b46e624 4531
26a5f13b 4532 tb_size = 0;
41bd639b
BS		 4533 autostart= 1;
4534
cd6f1169 4535 optind = 1;
0824d6fc 4536 for(;;) {
cd6f1169 4537 if (optind >= argc)
0824d6fc 4538 break;
cd6f1169
FB		 4539 r = argv[optind];
4540 if (r[0] != '-') {
609497ab 4541 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
cd6f1169
FB		 4542 } else {
4543 const QEMUOption *popt;
4544
4545 optind++;
dff5efc8
PB		 4546 /* Treat --foo the same as -foo. */
4547 if (r[1] == '-')
4548 r++;
cd6f1169
FB		 4549 popt = qemu_options;
4550 for(;;) {
4551 if (!popt->name) {
5fafdf24 4552 fprintf(stderr, "%s: invalid option -- '%s'\n",
cd6f1169
FB		 4553 argv[0], r);
4554 exit(1);
4555 }
4556 if (!strcmp(popt->name, r + 1))
4557 break;
4558 popt++;
4559 }
4560 if (popt->flags & HAS_ARG) {
4561 if (optind >= argc) {
4562 fprintf(stderr, "%s: option '%s' requires an argument\n",
4563 argv[0], r);
4564 exit(1);
4565 }
4566 optarg = argv[optind++];
4567 } else {
4568 optarg = NULL;
4569 }
4570
4571 switch(popt->index) {
cc1daa40
FB		 4572 case QEMU_OPTION_M:
4573 machine = find_machine(optarg);
4574 if (!machine) {
4575 QEMUMachine *m;
4576 printf("Supported machines are:\n");
4577 for(m = first_machine; m != NULL; m = m->next) {
4578 printf("%-10s %s%s\n",
5fafdf24 4579 m->name, m->desc,
cc1daa40
FB		 4580 m == first_machine ? " (default)" : "");
4581 }
15f82208 4582 exit(*optarg != '?');
cc1daa40
FB		 4583 }
4584 break;
94fc95cd
JM		 4585 case QEMU_OPTION_cpu:
4586 /* hw initialization will check this */
15f82208 4587 if (*optarg == '?') {
c732abe2
JM		 4588/* XXX: implement xxx_cpu_list for targets that still miss it */
4589#if defined(cpu_list)
4590 cpu_list(stdout, &fprintf);
94fc95cd 4591#endif
15f82208 4592 exit(0);
94fc95cd
JM		 4593 } else {
4594 cpu_model = optarg;
4595 }
4596 break;
cd6f1169 4597 case QEMU_OPTION_initrd:
fc01f7e7
FB		 4598 initrd_filename = optarg;
4599 break;
cd6f1169 4600 case QEMU_OPTION_hda:
e4bcb14c 4601 if (cyls == 0)
609497ab 4602 hda_index = drive_add(optarg, HD_ALIAS, 0);
e4bcb14c 4603 else
609497ab 4604 hda_index = drive_add(optarg, HD_ALIAS
e4bcb14c 4605 ",cyls=%d,heads=%d,secs=%d%s",
609497ab 4606 0, cyls, heads, secs,
e4bcb14c
TS		 4607 translation == BIOS_ATA_TRANSLATION_LBA ?
4608 ",trans=lba" :
4609 translation == BIOS_ATA_TRANSLATION_NONE ?
4610 ",trans=none" : "");
4611 break;
cd6f1169 4612 case QEMU_OPTION_hdb:
cc1daa40
FB		 4613 case QEMU_OPTION_hdc:
4614 case QEMU_OPTION_hdd:
609497ab 4615 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
fc01f7e7 4616 break;
e4bcb14c 4617 case QEMU_OPTION_drive:
609497ab 4618 drive_add(NULL, "%s", optarg);
e4bcb14c 4619 break;
3e3d5815 4620 case QEMU_OPTION_mtdblock:
609497ab 4621 drive_add(optarg, MTD_ALIAS);
3e3d5815 4622 break;
a1bb27b1 4623 case QEMU_OPTION_sd:
609497ab 4624 drive_add(optarg, SD_ALIAS);
a1bb27b1 4625 break;
86f55663 4626 case QEMU_OPTION_pflash:
609497ab 4627 drive_add(optarg, PFLASH_ALIAS);
86f55663 4628 break;
cd6f1169 4629 case QEMU_OPTION_snapshot:
33e3963e
FB		 4630 snapshot = 1;
4631 break;
cd6f1169 4632 case QEMU_OPTION_hdachs:
330d0414 4633 {
330d0414
FB		 4634 const char *p;
4635 p = optarg;
4636 cyls = strtol(p, (char **)&p, 0);
46d4767d
FB		 4637 if (cyls < 1 || cyls > 16383)
4638 goto chs_fail;
330d0414
FB		 4639 if (*p != ',')
4640 goto chs_fail;
4641 p++;
4642 heads = strtol(p, (char **)&p, 0);
46d4767d
FB		 4643 if (heads < 1 || heads > 16)
4644 goto chs_fail;
330d0414
FB		 4645 if (*p != ',')
4646 goto chs_fail;
4647 p++;
4648 secs = strtol(p, (char **)&p, 0);
46d4767d
FB		 4649 if (secs < 1 || secs > 63)
4650 goto chs_fail;
4651 if (*p == ',') {
4652 p++;
4653 if (!strcmp(p, "none"))
4654 translation = BIOS_ATA_TRANSLATION_NONE;
4655 else if (!strcmp(p, "lba"))
4656 translation = BIOS_ATA_TRANSLATION_LBA;
4657 else if (!strcmp(p, "auto"))
4658 translation = BIOS_ATA_TRANSLATION_AUTO;
4659 else
4660 goto chs_fail;
4661 } else if (*p != '\0') {
c4b1fcc0 4662 chs_fail:
46d4767d
FB		 4663 fprintf(stderr, "qemu: invalid physical CHS format\n");
4664 exit(1);
c4b1fcc0 4665 }
e4bcb14c 4666 if (hda_index != -1)
609497ab
AZ		 4667 snprintf(drives_opt[hda_index].opt,
4668 sizeof(drives_opt[hda_index].opt),
4669 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4670 0, cyls, heads, secs,
e4bcb14c
TS		 4671 translation == BIOS_ATA_TRANSLATION_LBA ?
4672 ",trans=lba" :
4673 translation == BIOS_ATA_TRANSLATION_NONE ?
4674 ",trans=none" : "");
330d0414
FB		 4675 }
4676 break;
cd6f1169 4677 case QEMU_OPTION_nographic:
a20dd508
FB		 4678 nographic = 1;
4679 break;
4d3b6f6e
AZ		 4680#ifdef CONFIG_CURSES
4681 case QEMU_OPTION_curses:
4682 curses = 1;
4683 break;
4684#endif
a171fe39
AZ		 4685 case QEMU_OPTION_portrait:
4686 graphic_rotate = 1;
4687 break;
cd6f1169 4688 case QEMU_OPTION_kernel:
a20dd508
FB		 4689 kernel_filename = optarg;
4690 break;
cd6f1169 4691 case QEMU_OPTION_append:
a20dd508 4692 kernel_cmdline = optarg;
313aa567 4693 break;
cd6f1169 4694 case QEMU_OPTION_cdrom:
609497ab 4695 drive_add(optarg, CDROM_ALIAS);
36b486bb 4696 break;
cd6f1169 4697 case QEMU_OPTION_boot:
28c5af54
JM		 4698 boot_devices = optarg;
4699 /* We just do some generic consistency checks */
4700 {
4701 /* Could easily be extended to 64 devices if needed */
60fe76f3 4702 const char *p;
28c5af54
JM		 4703
4704 boot_devices_bitmap = 0;
4705 for (p = boot_devices; *p != '\0'; p++) {
4706 /* Allowed boot devices are:
4707 * a b : floppy disk drives
4708 * c ... f : IDE disk drives
4709 * g ... m : machine implementation dependant drives
4710 * n ... p : network devices
4711 * It's up to each machine implementation to check
4712 * if the given boot devices match the actual hardware
4713 * implementation and firmware features.
4714 */
4715 if (*p < 'a' || *p > 'q') {
4716 fprintf(stderr, "Invalid boot device '%c'\n", *p);
4717 exit(1);
4718 }
4719 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4720 fprintf(stderr,
4721 "Boot device '%c' was given twice\n",*p);
4722 exit(1);
4723 }
4724 boot_devices_bitmap |= 1 << (*p - 'a');
4725 }
36b486bb
FB		 4726 }
4727 break;
cd6f1169 4728 case QEMU_OPTION_fda:
cd6f1169 4729 case QEMU_OPTION_fdb:
609497ab 4730 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
c45886db 4731 break;
52ca8d6a
FB		 4732#ifdef TARGET_I386
4733 case QEMU_OPTION_no_fd_bootchk:
4734 fd_bootchk = 0;
4735 break;
4736#endif
7c9d8e07
FB		 4737 case QEMU_OPTION_net:
4738 if (nb_net_clients >= MAX_NET_CLIENTS) {
4739 fprintf(stderr, "qemu: too many network clients\n");
c4b1fcc0
FB		 4740 exit(1);
4741 }
fd5f393a 4742 net_clients[nb_net_clients] = optarg;
7c9d8e07 4743 nb_net_clients++;
702c651c 4744 break;
c7f74643
FB		 4745#ifdef CONFIG_SLIRP
4746 case QEMU_OPTION_tftp:
c7f74643 4747 tftp_prefix = optarg;
9bf05444 4748 break;
47d5d01a
TS		 4749 case QEMU_OPTION_bootp:
4750 bootp_filename = optarg;
4751 break;
c94c8d64 4752#ifndef _WIN32
9d728e8c
FB		 4753 case QEMU_OPTION_smb:
4754 net_slirp_smb(optarg);
4755 break;
c94c8d64 4756#endif
9bf05444 4757 case QEMU_OPTION_redir:
3b46e624 4758 net_slirp_redir(optarg);
9bf05444 4759 break;
c7f74643 4760#endif
dc72ac14
AZ		 4761 case QEMU_OPTION_bt:
4762 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4763 fprintf(stderr, "qemu: too many bluetooth options\n");
4764 exit(1);
4765 }
4766 bt_opts[nb_bt_opts++] = optarg;
4767 break;
1d14ffa9 4768#ifdef HAS_AUDIO
1d14ffa9
FB		 4769 case QEMU_OPTION_audio_help:
4770 AUD_help ();
4771 exit (0);
4772 break;
4773 case QEMU_OPTION_soundhw:
4774 select_soundhw (optarg);
4775 break;
4776#endif
cd6f1169 4777 case QEMU_OPTION_h:
15f82208 4778 help(0);
cd6f1169 4779 break;
00f82b8a
AJ		 4780 case QEMU_OPTION_m: {
4781 uint64_t value;
4782 char *ptr;
4783
4784 value = strtoul(optarg, &ptr, 10);
4785 switch (*ptr) {
4786 case 0: case 'M': case 'm':
4787 value <<= 20;
4788 break;
4789 case 'G': case 'g':
4790 value <<= 30;
4791 break;
4792 default:
4793 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
cd6f1169
FB		 4794 exit(1);
4795 }
00f82b8a
AJ		 4796
4797 /* On 32-bit hosts, QEMU is limited by virtual address space */
4798 if (value > (2047 << 20)
4799#ifndef USE_KQEMU
4800 && HOST_LONG_BITS == 32
4801#endif
4802 ) {
4803 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4804 exit(1);
4805 }
4806 if (value != (uint64_t)(ram_addr_t)value) {
4807 fprintf(stderr, "qemu: ram size too large\n");
4808 exit(1);
4809 }
4810 ram_size = value;
cd6f1169 4811 break;
00f82b8a 4812 }
cd6f1169
FB		 4813 case QEMU_OPTION_d:
4814 {
4815 int mask;
c7cd6a37 4816 const CPULogItem *item;
3b46e624 4817
cd6f1169
FB		 4818 mask = cpu_str_to_log_mask(optarg);
4819 if (!mask) {
4820 printf("Log items (comma separated):\n");
f193c797
FB		 4821 for(item = cpu_log_items; item->mask != 0; item++) {
4822 printf("%-10s %s\n", item->name, item->help);
4823 }
4824 exit(1);
cd6f1169
FB		 4825 }
4826 cpu_set_log(mask);
f193c797 4827 }
cd6f1169 4828 break;
67b915a5 4829#ifdef CONFIG_GDBSTUB
cd6f1169
FB		 4830 case QEMU_OPTION_s:
4831 use_gdbstub = 1;
4832 break;
4833 case QEMU_OPTION_p:
cfc3475a 4834 gdbstub_port = optarg;
cd6f1169 4835 break;
67b915a5 4836#endif
cd6f1169
FB		 4837 case QEMU_OPTION_L:
4838 bios_dir = optarg;
4839 break;
1192dad8
JM		 4840 case QEMU_OPTION_bios:
4841 bios_name = optarg;
4842 break;
cd6f1169 4843 case QEMU_OPTION_S:
3c07f8e8 4844 autostart = 0;
cd6f1169 4845 break;
3d11d0eb
FB		 4846 case QEMU_OPTION_k:
4847 keyboard_layout = optarg;
4848 break;
ee22c2f7
FB		 4849 case QEMU_OPTION_localtime:
4850 rtc_utc = 0;
4851 break;
3893c124 4852 case QEMU_OPTION_vga:
4853 select_vgahw (optarg);
1bfe856e 4854 break;
e9b137c2
FB		 4855 case QEMU_OPTION_g:
4856 {
4857 const char *p;
4858 int w, h, depth;
4859 p = optarg;
4860 w = strtol(p, (char **)&p, 10);
4861 if (w <= 0) {
4862 graphic_error:
4863 fprintf(stderr, "qemu: invalid resolution or depth\n");
4864 exit(1);
4865 }
4866 if (*p != 'x')
4867 goto graphic_error;
4868 p++;
4869 h = strtol(p, (char **)&p, 10);
4870 if (h <= 0)
4871 goto graphic_error;
4872 if (*p == 'x') {
4873 p++;
4874 depth = strtol(p, (char **)&p, 10);
5fafdf24 4875 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 4876 depth != 24 && depth != 32)
4877 goto graphic_error;
4878 } else if (*p == '\0') {
4879 depth = graphic_depth;
4880 } else {
4881 goto graphic_error;
4882 }
3b46e624 4883
e9b137c2
FB		 4884 graphic_width = w;
4885 graphic_height = h;
4886 graphic_depth = depth;
4887 }
4888 break;
20d8a3ed
TS		 4889 case QEMU_OPTION_echr:
4890 {
4891 char *r;
4892 term_escape_char = strtol(optarg, &r, 0);
4893 if (r == optarg)
4894 printf("Bad argument to echr\n");
4895 break;
4896 }
82c643ff 4897 case QEMU_OPTION_monitor:
fd5f393a 4898 monitor_device = optarg;
82c643ff
FB		 4899 break;
4900 case QEMU_OPTION_serial:
8d11df9e
FB		 4901 if (serial_device_index >= MAX_SERIAL_PORTS) {
4902 fprintf(stderr, "qemu: too many serial ports\n");
4903 exit(1);
4904 }
fd5f393a 4905 serial_devices[serial_device_index] = optarg;
8d11df9e 4906 serial_device_index++;
82c643ff 4907 break;
6508fe59
FB		 4908 case QEMU_OPTION_parallel:
4909 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4910 fprintf(stderr, "qemu: too many parallel ports\n");
4911 exit(1);
4912 }
fd5f393a 4913 parallel_devices[parallel_device_index] = optarg;
6508fe59
FB		 4914 parallel_device_index++;
4915 break;
d63d307f
FB		 4916 case QEMU_OPTION_loadvm:
4917 loadvm = optarg;
4918 break;
4919 case QEMU_OPTION_full_screen:
4920 full_screen = 1;
4921 break;
667accab 4922#ifdef CONFIG_SDL
43523e93
TS		 4923 case QEMU_OPTION_no_frame:
4924 no_frame = 1;
4925 break;
3780e197
TS		 4926 case QEMU_OPTION_alt_grab:
4927 alt_grab = 1;
4928 break;
667accab
TS		 4929 case QEMU_OPTION_no_quit:
4930 no_quit = 1;
4931 break;
4932#endif
f7cce898 4933 case QEMU_OPTION_pidfile:
93815bc2 4934 pid_file = optarg;
f7cce898 4935 break;
a09db21f
FB		 4936#ifdef TARGET_I386
4937 case QEMU_OPTION_win2k_hack:
4938 win2k_install_hack = 1;
4939 break;
4940#endif
d993e026
FB		 4941#ifdef USE_KQEMU
4942 case QEMU_OPTION_no_kqemu:
4943 kqemu_allowed = 0;
4944 break;
89bfc105
FB		 4945 case QEMU_OPTION_kernel_kqemu:
4946 kqemu_allowed = 2;
4947 break;
7ba1e619
AL		 4948#endif
4949#ifdef CONFIG_KVM
4950 case QEMU_OPTION_enable_kvm:
4951 kvm_allowed = 1;
4952#ifdef USE_KQEMU
4953 kqemu_allowed = 0;
4954#endif
4955 break;
d993e026 4956#endif
bb36d470
FB		 4957 case QEMU_OPTION_usb:
4958 usb_enabled = 1;
4959 break;
a594cfbf
FB		 4960 case QEMU_OPTION_usbdevice:
4961 usb_enabled = 1;
0d92ed30 4962 if (usb_devices_index >= MAX_USB_CMDLINE) {
a594cfbf
FB		 4963 fprintf(stderr, "Too many USB devices\n");
4964 exit(1);
4965 }
fd5f393a 4966 usb_devices[usb_devices_index] = optarg;
a594cfbf
FB		 4967 usb_devices_index++;
4968 break;
6a00d601
FB		 4969 case QEMU_OPTION_smp:
4970 smp_cpus = atoi(optarg);
b2097003 4971 if (smp_cpus < 1) {
6a00d601
FB		 4972 fprintf(stderr, "Invalid number of CPUs\n");
4973 exit(1);
4974 }
4975 break;
24236869 4976 case QEMU_OPTION_vnc:
73fc9742 4977 vnc_display = optarg;
24236869 4978 break;
6515b203
FB		 4979 case QEMU_OPTION_no_acpi:
4980 acpi_enabled = 0;
4981 break;
d1beab82
FB		 4982 case QEMU_OPTION_no_reboot:
4983 no_reboot = 1;
4984 break;
b2f76161
AJ		 4985 case QEMU_OPTION_no_shutdown:
4986 no_shutdown = 1;
4987 break;
9467cd46
AZ		 4988 case QEMU_OPTION_show_cursor:
4989 cursor_hide = 0;
4990 break;
8fcb1b90
BS		 4991 case QEMU_OPTION_uuid:
4992 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
4993 fprintf(stderr, "Fail to parse UUID string."
4994 " Wrong format.\n");
4995 exit(1);
4996 }
4997 break;
71e3ceb8
TS		 4998 case QEMU_OPTION_daemonize:
4999 daemonize = 1;
5000 break;
9ae02555
TS		 5001 case QEMU_OPTION_option_rom:
5002 if (nb_option_roms >= MAX_OPTION_ROMS) {
5003 fprintf(stderr, "Too many option ROMs\n");
5004 exit(1);
5005 }
5006 option_rom[nb_option_roms] = optarg;
5007 nb_option_roms++;
5008 break;
8e71621f
PB		 5009 case QEMU_OPTION_semihosting:
5010 semihosting_enabled = 1;
5011 break;
c35734b2
TS		 5012 case QEMU_OPTION_name:
5013 qemu_name = optarg;
5014 break;
66508601
BS		 5015#ifdef TARGET_SPARC
5016 case QEMU_OPTION_prom_env:
5017 if (nb_prom_envs >= MAX_PROM_ENVS) {
5018 fprintf(stderr, "Too many prom variables\n");
5019 exit(1);
5020 }
5021 prom_envs[nb_prom_envs] = optarg;
5022 nb_prom_envs++;
5023 break;
2b8f2d41
AZ		 5024#endif
5025#ifdef TARGET_ARM
5026 case QEMU_OPTION_old_param:
5027 old_param = 1;
05ebd537 5028 break;
66508601 5029#endif
f3dcfada
TS		 5030 case QEMU_OPTION_clock:
5031 configure_alarms(optarg);
5032 break;
7e0af5d0
FB		 5033 case QEMU_OPTION_startdate:
5034 {
5035 struct tm tm;
f6503059 5036 time_t rtc_start_date;
7e0af5d0 5037 if (!strcmp(optarg, "now")) {
f6503059 5038 rtc_date_offset = -1;
7e0af5d0
FB		 5039 } else {
5040 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5041 &tm.tm_year,
5042 &tm.tm_mon,
5043 &tm.tm_mday,
5044 &tm.tm_hour,
5045 &tm.tm_min,
5046 &tm.tm_sec) == 6) {
5047 /* OK */
5048 } else if (sscanf(optarg, "%d-%d-%d",
5049 &tm.tm_year,
5050 &tm.tm_mon,
5051 &tm.tm_mday) == 3) {
5052 tm.tm_hour = 0;
5053 tm.tm_min = 0;
5054 tm.tm_sec = 0;
5055 } else {
5056 goto date_fail;
5057 }
5058 tm.tm_year -= 1900;
5059 tm.tm_mon--;
3c6b2088 5060 rtc_start_date = mktimegm(&tm);
7e0af5d0
FB		 5061 if (rtc_start_date == -1) {
5062 date_fail:
5063 fprintf(stderr, "Invalid date format. Valid format are:\n"
5064 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5065 exit(1);
5066 }
f6503059 5067 rtc_date_offset = time(NULL) - rtc_start_date;
7e0af5d0
FB		 5068 }
5069 }
5070 break;
26a5f13b
FB		 5071 case QEMU_OPTION_tb_size:
5072 tb_size = strtol(optarg, NULL, 0);
5073 if (tb_size < 0)
5074 tb_size = 0;
5075 break;
2e70f6ef
PB		 5076 case QEMU_OPTION_icount:
5077 use_icount = 1;
5078 if (strcmp(optarg, "auto") == 0) {
5079 icount_time_shift = -1;
5080 } else {
5081 icount_time_shift = strtol(optarg, NULL, 0);
5082 }
5083 break;
5bb7910a
AL		 5084 case QEMU_OPTION_incoming:
5085 incoming = optarg;
5086 break;
cd6f1169 5087 }
0824d6fc
FB		 5088 }
5089 }
330d0414 5090
7ba1e619
AL		 5091#if defined(CONFIG_KVM) && defined(USE_KQEMU)
5092 if (kvm_allowed && kqemu_allowed) {
5093 fprintf(stderr,
5094 "You can not enable both KVM and kqemu at the same time\n");
5095 exit(1);
5096 }
5097#endif
5098
3d878caa 5099 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
b2097003
AL		 5100 if (smp_cpus > machine->max_cpus) {
5101 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5102 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5103 machine->max_cpus);
5104 exit(1);
5105 }
5106
bc0129d9
AL		 5107 if (nographic) {
5108 if (serial_device_index == 0)
5109 serial_devices[0] = "stdio";
5110 if (parallel_device_index == 0)
5111 parallel_devices[0] = "null";
5112 if (strncmp(monitor_device, "vc", 2) == 0)
5113 monitor_device = "stdio";
5114 }
5115
71e3ceb8 5116#ifndef _WIN32
71e3ceb8
TS		 5117 if (daemonize) {
5118 pid_t pid;
5119
5120 if (pipe(fds) == -1)
5121 exit(1);
5122
5123 pid = fork();
5124 if (pid > 0) {
5125 uint8_t status;
5126 ssize_t len;
5127
5128 close(fds[1]);
5129
5130 again:
93815bc2
TS		 5131 len = read(fds[0], &status, 1);
5132 if (len == -1 && (errno == EINTR))
5133 goto again;
5134
5135 if (len != 1)
5136 exit(1);
5137 else if (status == 1) {
5138 fprintf(stderr, "Could not acquire pidfile\n");
5139 exit(1);
5140 } else
5141 exit(0);
71e3ceb8 5142 } else if (pid < 0)
93815bc2 5143 exit(1);
71e3ceb8
TS		 5144
5145 setsid();
5146
5147 pid = fork();
5148 if (pid > 0)
5149 exit(0);
5150 else if (pid < 0)
5151 exit(1);
5152
5153 umask(027);
71e3ceb8
TS		 5154
5155 signal(SIGTSTP, SIG_IGN);
5156 signal(SIGTTOU, SIG_IGN);
5157 signal(SIGTTIN, SIG_IGN);
5158 }
5159#endif
5160
aa26bb2d 5161 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
93815bc2
TS		 5162 if (daemonize) {
5163 uint8_t status = 1;
5164 write(fds[1], &status, 1);
5165 } else
5166 fprintf(stderr, "Could not acquire pid file\n");
5167 exit(1);
5168 }
5169
ff3fbb30
FB		 5170#ifdef USE_KQEMU
5171 if (smp_cpus > 1)
5172 kqemu_allowed = 0;
5173#endif
a20dd508 5174 linux_boot = (kernel_filename != NULL);
7317b8ca 5175 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
6c41b272 5176
28c5af54 5177 if (!linux_boot && net_boot == 0 &&
f88e4b91 5178 !machine->nodisk_ok && nb_drives_opt == 0)
15f82208 5179 help(1);
0824d6fc 5180
f8d39c01
TS		 5181 if (!linux_boot && *kernel_cmdline != '\0') {
5182 fprintf(stderr, "-append only allowed with -kernel option\n");
5183 exit(1);
5184 }
5185
5186 if (!linux_boot && initrd_filename != NULL) {
5187 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5188 exit(1);
5189 }
5190
96d30e48 5191 /* boot to floppy or the default cd if no hard disk defined yet */
28c5af54 5192 if (!boot_devices[0]) {
e4bcb14c 5193 boot_devices = "cad";
96d30e48 5194 }
b118d61e 5195 setvbuf(stdout, NULL, _IOLBF, 0);
3b46e624 5196
634fce96 5197 init_timers();
7183b4b4
AL		 5198 if (init_timer_alarm() < 0) {
5199 fprintf(stderr, "could not initialize alarm timer\n");
5200 exit(1);
5201 }
2e70f6ef
PB		 5202 if (use_icount && icount_time_shift < 0) {
5203 use_icount = 2;
5204 /* 125MIPS seems a reasonable initial guess at the guest speed.
5205 It will be corrected fairly quickly anyway. */
5206 icount_time_shift = 3;
5207 init_icount_adjust();
5208 }
634fce96 5209
fd1dff4b
FB		 5210#ifdef _WIN32
5211 socket_init();
5212#endif
5213
7c9d8e07
FB		 5214 /* init network clients */
5215 if (nb_net_clients == 0) {
5216 /* if no clients, we use a default config */
f441b28b
AL		 5217 net_clients[nb_net_clients++] = "nic";
5218#ifdef CONFIG_SLIRP
5219 net_clients[nb_net_clients++] = "user";
5220#endif
c20709aa
FB		 5221 }
5222
7c9d8e07 5223 for(i = 0;i < nb_net_clients; i++) {
9ad97e65 5224 if (net_client_parse(net_clients[i]) < 0)
7c9d8e07 5225 exit(1);
702c651c 5226 }
63a01ef8 5227 net_client_check();
f1510b2c 5228
eec85c2a 5229#ifdef TARGET_I386
ed494d87 5230 /* XXX: this should be moved in the PC machine instantiation code */
28c5af54
JM		 5231 if (net_boot != 0) {
5232 int netroms = 0;
5233 for (i = 0; i < nb_nics && i < 4; i++) {
eec85c2a
TS		 5234 const char *model = nd_table[i].model;
5235 char buf[1024];
28c5af54
JM		 5236 if (net_boot & (1 << i)) {
5237 if (model == NULL)
5238 model = "ne2k_pci";
5239 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5240 if (get_image_size(buf) > 0) {
5241 if (nb_option_roms >= MAX_OPTION_ROMS) {
5242 fprintf(stderr, "Too many option ROMs\n");
5243 exit(1);
5244 }
5245 option_rom[nb_option_roms] = strdup(buf);
5246 nb_option_roms++;
5247 netroms++;
5248 }
5249 }
eec85c2a 5250 }
28c5af54 5251 if (netroms == 0) {
eec85c2a
TS		 5252 fprintf(stderr, "No valid PXE rom found for network device\n");
5253 exit(1);
5254 }
eec85c2a
TS		 5255 }
5256#endif
5257
dc72ac14
AZ		 5258 /* init the bluetooth world */
5259 for (i = 0; i < nb_bt_opts; i++)
5260 if (bt_parse(bt_opts[i]))
5261 exit(1);
5262
0824d6fc 5263 /* init the memory */
7fb4fdcf
AZ		 5264 phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5265
5266 if (machine->ram_require & RAMSIZE_FIXED) {
5267 if (ram_size > 0) {
5268 if (ram_size < phys_ram_size) {
cd940061
AJ		 5269 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5270 machine->name, (unsigned long long) phys_ram_size);
7fb4fdcf
AZ		 5271 exit(-1);
5272 }
5273
5274 phys_ram_size = ram_size;
5275 } else
5276 ram_size = phys_ram_size;
5277 } else {
4fc5d071 5278 if (ram_size == 0)
7fb4fdcf
AZ		 5279 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5280
5281 phys_ram_size += ram_size;
5282 }
9ae02555 5283
d993e026 5284 phys_ram_base = qemu_vmalloc(phys_ram_size);
7f7f9873
FB		 5285 if (!phys_ram_base) {
5286 fprintf(stderr, "Could not allocate physical memory\n");
0824d6fc
FB		 5287 exit(1);
5288 }
5289
26a5f13b
FB		 5290 /* init the dynamic translator */
5291 cpu_exec_init_all(tb_size * 1024 * 1024);
5292
5905b2e5 5293 bdrv_init();
c4b1fcc0 5294
e4bcb14c 5295 /* we always create the cdrom drive, even if no disk is there */
c4b1fcc0 5296
e4bcb14c 5297 if (nb_drives_opt < MAX_DRIVES)
609497ab 5298 drive_add(NULL, CDROM_ALIAS);
c4b1fcc0 5299
9d413d1d 5300 /* we always create at least one floppy */
33e3963e 5301
e4bcb14c 5302 if (nb_drives_opt < MAX_DRIVES)
609497ab 5303 drive_add(NULL, FD_ALIAS, 0);
86f55663 5304
9d413d1d
AZ		 5305 /* we always create one sd slot, even if no card is in it */
5306
5307 if (nb_drives_opt < MAX_DRIVES)
609497ab 5308 drive_add(NULL, SD_ALIAS);
9d413d1d 5309
e4bcb14c
TS		 5310 /* open the virtual block devices */
5311
5312 for(i = 0; i < nb_drives_opt; i++)
609497ab 5313 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
e4bcb14c 5314 exit(1);
3e3d5815 5315
c88676f8 5316 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
475e4277 5317 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
8a7ddc38 5318
313aa567 5319 /* terminal init */
740733bb 5320 memset(&display_state, 0, sizeof(display_state));
a20dd508 5321 if (nographic) {
4d3b6f6e
AZ		 5322 if (curses) {
5323 fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5324 exit(1);
5325 }
2ff89790
TS		 5326 /* nearly nothing to do */
5327 dumb_display_init(ds);
73fc9742 5328 } else if (vnc_display != NULL) {
71cab5ca
TS		 5329 vnc_display_init(ds);
5330 if (vnc_display_open(ds, vnc_display) < 0)
5331 exit(1);
4d3b6f6e
AZ		 5332 } else
5333#if defined(CONFIG_CURSES)
5334 if (curses) {
5335 curses_display_init(ds, full_screen);
5336 } else
5337#endif
5338 {
5b0753e0 5339#if defined(CONFIG_SDL)
43523e93 5340 sdl_display_init(ds, full_screen, no_frame);
5b0753e0
FB		 5341#elif defined(CONFIG_COCOA)
5342 cocoa_display_init(ds, full_screen);
67276f53
PB		 5343#else
5344 dumb_display_init(ds);
313aa567
FB		 5345#endif
5346 }
0824d6fc 5347
5b08fc10
AL		 5348#ifndef _WIN32
5349 /* must be after terminal init, SDL library changes signal handlers */
5350 termsig_setup();
5351#endif
5352
20d8a3ed
TS		 5353 /* Maintain compatibility with multiple stdio monitors */
5354 if (!strcmp(monitor_device,"stdio")) {
5355 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
fd5f393a
PB		 5356 const char *devname = serial_devices[i];
5357 if (devname && !strcmp(devname,"mon:stdio")) {
5358 monitor_device = NULL;
20d8a3ed 5359 break;
fd5f393a
PB		 5360 } else if (devname && !strcmp(devname,"stdio")) {
5361 monitor_device = NULL;
5362 serial_devices[i] = "mon:stdio";
20d8a3ed
TS		 5363 break;
5364 }
5365 }
5366 }
fd5f393a 5367 if (monitor_device) {
5ccfae10 5368 monitor_hd = qemu_chr_open("monitor", monitor_device);
20d8a3ed
TS		 5369 if (!monitor_hd) {
5370 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5371 exit(1);
5372 }
5373 monitor_init(monitor_hd, !nographic);
82c643ff 5374 }
82c643ff 5375
8d11df9e 5376 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
c03b0f0f 5377 const char *devname = serial_devices[i];
fd5f393a 5378 if (devname && strcmp(devname, "none")) {
5ccfae10
AL		 5379 char label[32];
5380 snprintf(label, sizeof(label), "serial%d", i);
5381 serial_hds[i] = qemu_chr_open(label, devname);
8d11df9e 5382 if (!serial_hds[i]) {
5fafdf24 5383 fprintf(stderr, "qemu: could not open serial device '%s'\n",
c03b0f0f 5384 devname);
8d11df9e
FB		 5385 exit(1);
5386 }
af3a9031 5387 if (strstart(devname, "vc", 0))
7ba1260a 5388 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8d11df9e 5389 }
82c643ff 5390 }
82c643ff 5391
6508fe59 5392 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
c03b0f0f 5393 const char *devname = parallel_devices[i];
fd5f393a 5394 if (devname && strcmp(devname, "none")) {
5ccfae10
AL		 5395 char label[32];
5396 snprintf(label, sizeof(label), "parallel%d", i);
5397 parallel_hds[i] = qemu_chr_open(label, devname);
6508fe59 5398 if (!parallel_hds[i]) {
5fafdf24 5399 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
c03b0f0f 5400 devname);
6508fe59
FB		 5401 exit(1);
5402 }
af3a9031 5403 if (strstart(devname, "vc", 0))
7ba1260a 5404 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6508fe59
FB		 5405 }
5406 }
5407
7ba1e619
AL		 5408 if (kvm_enabled()) {
5409 int ret;
5410
5411 ret = kvm_init(smp_cpus);
5412 if (ret < 0) {
5413 fprintf(stderr, "failed to initialize KVM\n");
5414 exit(1);
5415 }
5416 }
5417
b881c2c6 5418 machine->init(ram_size, vga_ram_size, boot_devices, ds,
94fc95cd 5419 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
73332e5c 5420
0d92ed30
PB		 5421 /* init USB devices */
5422 if (usb_enabled) {
5423 for(i = 0; i < usb_devices_index; i++) {
5424 if (usb_device_add(usb_devices[i]) < 0) {
5425 fprintf(stderr, "Warning: could not add USB device %s\n",
5426 usb_devices[i]);
5427 }
5428 }
5429 }
5430
740733bb
TS		 5431 if (display_state.dpy_refresh) {
5432 display_state.gui_timer = qemu_new_timer(rt_clock, gui_update, &display_state);
5433 qemu_mod_timer(display_state.gui_timer, qemu_get_clock(rt_clock));
5434 }
7f7f9873 5435
67b915a5 5436#ifdef CONFIG_GDBSTUB
b4608c04 5437 if (use_gdbstub) {
c636bb66
FB		 5438 /* XXX: use standard host:port notation and modify options
5439 accordingly. */
cfc3475a
PB		 5440 if (gdbserver_start(gdbstub_port) < 0) {
5441 fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
c636bb66 5442 gdbstub_port);
8a7ddc38 5443 exit(1);
8a7ddc38 5444 }
45669e00 5445 }
67b915a5 5446#endif
45669e00 5447
d63d307f 5448 if (loadvm)
faea38e7 5449 do_loadvm(loadvm);
d63d307f 5450
5bb7910a
AL		 5451 if (incoming) {
5452 autostart = 0; /* fixme how to deal with -daemonize */
5453 qemu_start_incoming_migration(incoming);
5454 }
5455
67b915a5 5456 {
5905b2e5 5457 /* XXX: simplify init */
83ab7950 5458 read_passwords();
3c07f8e8 5459 if (autostart) {
5905b2e5
FB		 5460 vm_start();
5461 }
0824d6fc 5462 }
ffd843bc 5463
71e3ceb8
TS		 5464 if (daemonize) {
5465 uint8_t status = 0;
5466 ssize_t len;
5467 int fd;
5468
5469 again1:
5470 len = write(fds[1], &status, 1);
5471 if (len == -1 && (errno == EINTR))
5472 goto again1;
5473
5474 if (len != 1)
5475 exit(1);
5476
bd54b863 5477 chdir("/");
aeb30be6 5478 TFR(fd = open("/dev/null", O_RDWR));
71e3ceb8
TS		 5479 if (fd == -1)
5480 exit(1);
5481
5482 dup2(fd, 0);
5483 dup2(fd, 1);
5484 dup2(fd, 2);
5485
5486 close(fd);
5487 }
5488
8a7ddc38 5489 main_loop();
40c3bac3 5490 quit_timers();
63a01ef8 5491 net_cleanup();
b46a8906 5492
0824d6fc
FB		 5493 return 0;
5494}
Empty description
This page took 1.507915 seconds and 4 git commands to generate.