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