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