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