]> git.proxmox.com Git - qemu.git/blame - vl.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
qcow2: Make cache=writethrough default
[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
59a36a2f 116#if defined(__APPLE__) || defined(main)
6693665a 117#include <SDL.h>
880fec5d 118int qemu_main(int argc, char **argv, char **envp);
119int main(int argc, char **argv)
120{
59a36a2f 121 return qemu_main(argc, argv, NULL);
880fec5d 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
d918f23e 168#include "slirp/libslirp.h"
511d2b14 169
0824d6fc 170//#define DEBUG_UNUSED_IOPORT
fd872598 171//#define DEBUG_IOPORT
9dc63a1e
BS		 172//#define DEBUG_NET
173//#define DEBUG_SLIRP
330d0414 174
d12d51d5
AL		 175
176#ifdef DEBUG_IOPORT
93fcfe39 177# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
d12d51d5
AL		 178#else
179# define LOG_IOPORT(...) do { } while (0)
180#endif
181
1bfe856e 182#define DEFAULT_RAM_SIZE 128
313aa567 183
0d92ed30
PB		 184/* Max number of USB devices that can be specified on the commandline. */
185#define MAX_USB_CMDLINE 8
186
dc72ac14
AZ		 187/* Max number of bluetooth switches on the commandline. */
188#define MAX_BT_CMDLINE 10
189
7dea1da4
FB		 190/* XXX: use a two level table to limit memory usage */
191#define MAX_IOPORTS 65536
0824d6fc 192
5cea8590 193static const char *data_dir;
1192dad8 194const char *bios_name = NULL;
dbed7e40
BS		 195static void *ioport_opaque[MAX_IOPORTS];
196static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
197static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
e4bcb14c 198/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
faea38e7 199 to store the VM snapshots */
e4bcb14c
TS		 200DriveInfo drives_table[MAX_DRIVES+1];
201int nb_drives;
cb5a7aa8 202enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
3023f332 203static DisplayState *display_state;
993fbfdb 204DisplayType display_type = DT_DEFAULT;
3d11d0eb 205const char* keyboard_layout = NULL;
313aa567 206int64_t ticks_per_sec;
00f82b8a 207ram_addr_t ram_size;
c4b1fcc0 208int nb_nics;
7c9d8e07 209NICInfo nd_table[MAX_NICS];
8a7ddc38 210int vm_running;
c0f4ce77 211static int autostart;
f6503059
AZ		 212static int rtc_utc = 1;
213static int rtc_date_offset = -1; /* -1 means no change */
1bfe856e 214int cirrus_vga_enabled = 1;
c2b3b41a 215int std_vga_enabled = 0;
d34cab9f 216int vmsvga_enabled = 0;
94909d9f 217int xenfb_enabled = 0;
d827220b
FB		 218#ifdef TARGET_SPARC
219int graphic_width = 1024;
220int graphic_height = 768;
eee0b836 221int graphic_depth = 8;
d827220b 222#else
1bfe856e
FB		 223int graphic_width = 800;
224int graphic_height = 600;
e9b137c2 225int graphic_depth = 15;
eee0b836 226#endif
dbed7e40 227static int full_screen = 0;
634a21f6 228#ifdef CONFIG_SDL
dbed7e40 229static int no_frame = 0;
634a21f6 230#endif
667accab 231int no_quit = 0;
8d11df9e 232CharDriverState *serial_hds[MAX_SERIAL_PORTS];
6508fe59 233CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
9ede2fde 234CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
a09db21f
FB		 235#ifdef TARGET_I386
236int win2k_install_hack = 0;
73822ec8 237int rtc_td_hack = 0;
a09db21f 238#endif
bb36d470 239int usb_enabled = 0;
1b530a6d 240int singlestep = 0;
6a00d601 241int smp_cpus = 1;
73fc9742 242const char *vnc_display;
6515b203 243int acpi_enabled = 1;
16b29ae1 244int no_hpet = 0;
7d4c3d53
MA		 245int virtio_balloon = 1;
246const char *virtio_balloon_devaddr;
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
5db4af8b
JK		 1814int get_next_param_value(char *buf, int buf_size,
1815 const char *tag, const char **pstr)
7c9d8e07
FB		 1816{
1817 const char *p;
7c9d8e07
FB		 1818 char option[128];
1819
5db4af8b 1820 p = *pstr;
7c9d8e07 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)) {
5db4af8b
JK		 1827 *pstr = get_opt_value(buf, buf_size, p);
1828 if (**pstr == ',') {
1829 (*pstr)++;
1830 }
e4bcb14c 1831 return strlen(buf);
7c9d8e07 1832 } else {
609497ab 1833 p = get_opt_value(NULL, 0, p);
7c9d8e07
FB		 1834 }
1835 if (*p != ',')
1836 break;
1837 p++;
1838 }
1839 return 0;
1840}
1841
5db4af8b
JK		 1842int get_param_value(char *buf, int buf_size,
1843 const char *tag, const char *str)
1844{
1845 return get_next_param_value(buf, buf_size, tag, &str);
1846}
1847
0aa7a205
JK		 1848int check_params(char *buf, int buf_size,
1849 const char * const *params, const char *str)
e4bcb14c
TS		 1850{
1851 const char *p;
0aa7a205 1852 int i;
e4bcb14c
TS		 1853
1854 p = str;
10300216 1855 while (*p != '\0') {
0aa7a205 1856 p = get_opt_name(buf, buf_size, p, '=');
ffad4116 1857 if (*p != '=') {
0aa7a205 1858 return -1;
ffad4116 1859 }
e4bcb14c 1860 p++;
0aa7a205
JK		 1861 for (i = 0; params[i] != NULL; i++) {
1862 if (!strcmp(params[i], buf)) {
e4bcb14c 1863 break;
0aa7a205
JK		 1864 }
1865 }
ffad4116 1866 if (params[i] == NULL) {
0aa7a205 1867 return -1;
ffad4116 1868 }
609497ab 1869 p = get_opt_value(NULL, 0, p);
0aa7a205 1870 if (*p != ',') {
e4bcb14c 1871 break;
0aa7a205 1872 }
e4bcb14c
TS		 1873 p++;
1874 }
0aa7a205 1875 return 0;
e4bcb14c
TS		 1876}
1877
1ae26a18
AZ		 1878/***********************************************************/
1879/* Bluetooth support */
1880static int nb_hcis;
1881static int cur_hci;
1882static struct HCIInfo *hci_table[MAX_NICS];
dc72ac14 1883
1ae26a18
AZ		 1884static struct bt_vlan_s {
1885 struct bt_scatternet_s net;
1886 int id;
1887 struct bt_vlan_s *next;
1888} *first_bt_vlan;
1889
1890/* find or alloc a new bluetooth "VLAN" */
674bb261 1891static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1ae26a18
AZ		 1892{
1893 struct bt_vlan_s **pvlan, *vlan;
1894 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1895 if (vlan->id == id)
1896 return &vlan->net;
1897 }
1898 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1899 vlan->id = id;
1900 pvlan = &first_bt_vlan;
1901 while (*pvlan != NULL)
1902 pvlan = &(*pvlan)->next;
1903 *pvlan = vlan;
1904 return &vlan->net;
1905}
1906
1907static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1908{
1909}
1910
1911static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1912{
1913 return -ENOTSUP;
1914}
1915
1916static struct HCIInfo null_hci = {
1917 .cmd_send = null_hci_send,
1918 .sco_send = null_hci_send,
1919 .acl_send = null_hci_send,
1920 .bdaddr_set = null_hci_addr_set,
1921};
1922
1923struct HCIInfo *qemu_next_hci(void)
1924{
1925 if (cur_hci == nb_hcis)
1926 return &null_hci;
1927
1928 return hci_table[cur_hci++];
1929}
1930
dc72ac14
AZ		 1931static struct HCIInfo *hci_init(const char *str)
1932{
1933 char *endp;
1934 struct bt_scatternet_s *vlan = 0;
1935
1936 if (!strcmp(str, "null"))
1937 /* null */
1938 return &null_hci;
1939 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1940 /* host[:hciN] */
1941 return bt_host_hci(str[4] ? str + 5 : "hci0");
1942 else if (!strncmp(str, "hci", 3)) {
1943 /* hci[,vlan=n] */
1944 if (str[3]) {
1945 if (!strncmp(str + 3, ",vlan=", 6)) {
1946 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1947 if (*endp)
1948 vlan = 0;
1949 }
1950 } else
1951 vlan = qemu_find_bt_vlan(0);
1952 if (vlan)
1953 return bt_new_hci(vlan);
1954 }
1955
1956 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
1957
1958 return 0;
1959}
1960
1961static int bt_hci_parse(const char *str)
1962{
1963 struct HCIInfo *hci;
1964 bdaddr_t bdaddr;
1965
1966 if (nb_hcis >= MAX_NICS) {
1967 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
1968 return -1;
1969 }
1970
1971 hci = hci_init(str);
1972 if (!hci)
1973 return -1;
1974
1975 bdaddr.b[0] = 0x52;
1976 bdaddr.b[1] = 0x54;
1977 bdaddr.b[2] = 0x00;
1978 bdaddr.b[3] = 0x12;
1979 bdaddr.b[4] = 0x34;
1980 bdaddr.b[5] = 0x56 + nb_hcis;
1981 hci->bdaddr_set(hci, bdaddr.b);
1982
1983 hci_table[nb_hcis++] = hci;
1984
1985 return 0;
1986}
1987
1988static void bt_vhci_add(int vlan_id)
1989{
1990 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1991
1992 if (!vlan->slave)
1993 fprintf(stderr, "qemu: warning: adding a VHCI to "
1994 "an empty scatternet %i\n", vlan_id);
1995
1996 bt_vhci_init(bt_new_hci(vlan));
1997}
1998
1999static struct bt_device_s *bt_device_add(const char *opt)
2000{
2001 struct bt_scatternet_s *vlan;
2002 int vlan_id = 0;
2003 char *endp = strstr(opt, ",vlan=");
2004 int len = (endp ? endp - opt : strlen(opt)) + 1;
2005 char devname[10];
2006
2007 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2008
2009 if (endp) {
2010 vlan_id = strtol(endp + 6, &endp, 0);
2011 if (*endp) {
2012 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2013 return 0;
2014 }
2015 }
2016
2017 vlan = qemu_find_bt_vlan(vlan_id);
2018
2019 if (!vlan->slave)
2020 fprintf(stderr, "qemu: warning: adding a slave device to "
2021 "an empty scatternet %i\n", vlan_id);
2022
2023 if (!strcmp(devname, "keyboard"))
2024 return bt_keyboard_init(vlan);
2025
2026 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2027 return 0;
2028}
2029
2030static int bt_parse(const char *opt)
2031{
2032 const char *endp, *p;
2033 int vlan;
2034
2035 if (strstart(opt, "hci", &endp)) {
2036 if (!*endp || *endp == ',') {
2037 if (*endp)
2038 if (!strstart(endp, ",vlan=", 0))
2039 opt = endp + 1;
2040
2041 return bt_hci_parse(opt);
2042 }
2043 } else if (strstart(opt, "vhci", &endp)) {
2044 if (!*endp || *endp == ',') {
2045 if (*endp) {
2046 if (strstart(endp, ",vlan=", &p)) {
2047 vlan = strtol(p, (char **) &endp, 0);
2048 if (*endp) {
2049 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2050 return 1;
2051 }
2052 } else {
2053 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2054 return 1;
2055 }
2056 } else
2057 vlan = 0;
2058
2059 bt_vhci_add(vlan);
2060 return 0;
2061 }
2062 } else if (strstart(opt, "device:", &endp))
2063 return !bt_device_add(endp);
2064
2065 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2066 return 1;
2067}
2068
1ae26a18
AZ		 2069/***********************************************************/
2070/* QEMU Block devices */
2071
609497ab 2072#define HD_ALIAS "index=%d,media=disk"
e4bcb14c 2073#define CDROM_ALIAS "index=2,media=cdrom"
e4bcb14c 2074#define FD_ALIAS "index=%d,if=floppy"
609497ab
AZ		 2075#define PFLASH_ALIAS "if=pflash"
2076#define MTD_ALIAS "if=mtd"
9d413d1d 2077#define SD_ALIAS "index=0,if=sd"
e4bcb14c 2078
7d5aca9e
AL		 2079static int drive_opt_get_free_idx(void)
2080{
2081 int index;
2082
2083 for (index = 0; index < MAX_DRIVES; index++)
2084 if (!drives_opt[index].used) {
2085 drives_opt[index].used = 1;
2086 return index;
2087 }
2088
2089 return -1;
2090}
2091
2092static int drive_get_free_idx(void)
2093{
2094 int index;
2095
2096 for (index = 0; index < MAX_DRIVES; index++)
2097 if (!drives_table[index].used) {
2098 drives_table[index].used = 1;
2099 return index;
2100 }
2101
2102 return -1;
2103}
2104
4d73cd3b 2105int drive_add(const char *file, const char *fmt, ...)
e4bcb14c
TS		 2106{
2107 va_list ap;
7d5aca9e 2108 int index = drive_opt_get_free_idx();
e4bcb14c 2109
7d5aca9e 2110 if (nb_drives_opt >= MAX_DRIVES || index == -1) {
e4bcb14c 2111 fprintf(stderr, "qemu: too many drives\n");
4d73cd3b 2112 return -1;
e4bcb14c
TS		 2113 }
2114
7d5aca9e 2115 drives_opt[index].file = file;
e4bcb14c 2116 va_start(ap, fmt);
7d5aca9e 2117 vsnprintf(drives_opt[index].opt,
609497ab 2118 sizeof(drives_opt[0].opt), fmt, ap);
e4bcb14c
TS		 2119 va_end(ap);
2120
7d5aca9e
AL		 2121 nb_drives_opt++;
2122 return index;
e4bcb14c
TS		 2123}
2124
b01b1111
AL		 2125void drive_remove(int index)
2126{
2127 drives_opt[index].used = 0;
2128 nb_drives_opt--;
2129}
2130
f60d39bc 2131int drive_get_index(BlockInterfaceType type, int bus, int unit)
e4bcb14c
TS		 2132{
2133 int index;
2134
2135 /* seek interface, bus and unit */
2136
7d5aca9e 2137 for (index = 0; index < MAX_DRIVES; index++)
f60d39bc 2138 if (drives_table[index].type == type &&
e4bcb14c 2139 drives_table[index].bus == bus &&
7d5aca9e
AL		 2140 drives_table[index].unit == unit &&
2141 drives_table[index].used)
e4bcb14c
TS		 2142 return index;
2143
2144 return -1;
2145}
2146
f60d39bc 2147int drive_get_max_bus(BlockInterfaceType type)
e4bcb14c
TS		 2148{
2149 int max_bus;
2150 int index;
2151
2152 max_bus = -1;
2153 for (index = 0; index < nb_drives; index++) {
f60d39bc 2154 if(drives_table[index].type == type &&
e4bcb14c
TS		 2155 drives_table[index].bus > max_bus)
2156 max_bus = drives_table[index].bus;
2157 }
2158 return max_bus;
2159}
2160
fa879c64
AL		 2161const char *drive_get_serial(BlockDriverState *bdrv)
2162{
2163 int index;
2164
2165 for (index = 0; index < nb_drives; index++)
2166 if (drives_table[index].bdrv == bdrv)
2167 return drives_table[index].serial;
2168
2169 return "\0";
2170}
2171
428c5705
AL		 2172BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2173{
2174 int index;
2175
2176 for (index = 0; index < nb_drives; index++)
2177 if (drives_table[index].bdrv == bdrv)
2178 return drives_table[index].onerror;
2179
cdad4bd8 2180 return BLOCK_ERR_STOP_ENOSPC;
428c5705
AL		 2181}
2182
a1620fac
AJ		 2183static void bdrv_format_print(void *opaque, const char *name)
2184{
2185 fprintf(stderr, " %s", name);
2186}
2187
b01b1111
AL		 2188void drive_uninit(BlockDriverState *bdrv)
2189{
2190 int i;
2191
2192 for (i = 0; i < MAX_DRIVES; i++)
2193 if (drives_table[i].bdrv == bdrv) {
2194 drives_table[i].bdrv = NULL;
2195 drives_table[i].used = 0;
2196 drive_remove(drives_table[i].drive_opt_idx);
2197 nb_drives--;
2198 break;
2199 }
2200}
2201
4d73cd3b 2202int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
e4bcb14c
TS		 2203{
2204 char buf[128];
2205 char file[1024];
c8522bdf 2206 char devname[128];
fa879c64 2207 char serial[21];
c8522bdf 2208 const char *mediastr = "";
f60d39bc 2209 BlockInterfaceType type;
e4bcb14c
TS		 2210 enum { MEDIA_DISK, MEDIA_CDROM } media;
2211 int bus_id, unit_id;
2212 int cyls, heads, secs, translation;
2213 BlockDriverState *bdrv;
1e72d3b7 2214 BlockDriver *drv = NULL;
4d73cd3b 2215 QEMUMachine *machine = opaque;
e4bcb14c
TS		 2216 int max_devs;
2217 int index;
33f00271 2218 int cache;
428c5705 2219 int bdrv_flags, onerror;
c2cc47a4 2220 const char *devaddr;
7d5aca9e 2221 int drives_table_idx;
609497ab 2222 char *str = arg->opt;
7ccfb2eb
BS		 2223 static const char * const params[] = { "bus", "unit", "if", "index",
2224 "cyls", "heads", "secs", "trans",
2225 "media", "snapshot", "file",
c2cc47a4
MA		 2226 "cache", "format", "serial",
2227 "werror", "addr",
428c5705 2228 NULL };
e4bcb14c 2229
0aa7a205 2230 if (check_params(buf, sizeof(buf), 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;
0aa217e4 2242 cache = 1;
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
c2cc47a4
MA		 2441 devaddr = NULL;
2442 if (get_param_value(buf, sizeof(buf), "addr", str)) {
2443 if (type != IF_VIRTIO) {
2444 fprintf(stderr, "addr is not supported by in '%s'\n", str);
2445 return -1;
2446 }
2447 devaddr = strdup(buf);
2448 }
2449
e4bcb14c
TS		 2450 /* compute bus and unit according index */
2451
2452 if (index != -1) {
2453 if (bus_id != 0 || unit_id != -1) {
2454 fprintf(stderr,
2455 "qemu: '%s' index cannot be used with bus and unit\n", str);
2456 return -1;
2457 }
2458 if (max_devs == 0)
2459 {
2460 unit_id = index;
2461 bus_id = 0;
2462 } else {
2463 unit_id = index % max_devs;
2464 bus_id = index / max_devs;
2465 }
2466 }
2467
2468 /* if user doesn't specify a unit_id,
2469 * try to find the first free
2470 */
2471
2472 if (unit_id == -1) {
2473 unit_id = 0;
f60d39bc 2474 while (drive_get_index(type, bus_id, unit_id) != -1) {
e4bcb14c
TS		 2475 unit_id++;
2476 if (max_devs && unit_id >= max_devs) {
2477 unit_id -= max_devs;
2478 bus_id++;
2479 }
2480 }
2481 }
2482
2483 /* check unit id */
2484
2485 if (max_devs && unit_id >= max_devs) {
2486 fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2487 str, unit_id, max_devs - 1);
2488 return -1;
2489 }
2490
2491 /*
2492 * ignore multiple definitions
2493 */
2494
f60d39bc 2495 if (drive_get_index(type, bus_id, unit_id) != -1)
4d73cd3b 2496 return -2;
e4bcb14c
TS		 2497
2498 /* init */
2499
f60d39bc 2500 if (type == IF_IDE || type == IF_SCSI)
c8522bdf 2501 mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
e6198a70
AZ		 2502 if (max_devs)
2503 snprintf(buf, sizeof(buf), "%s%i%s%i",
2504 devname, bus_id, mediastr, unit_id);
2505 else
2506 snprintf(buf, sizeof(buf), "%s%s%i",
2507 devname, mediastr, unit_id);
e4bcb14c 2508 bdrv = bdrv_new(buf);
7d5aca9e
AL		 2509 drives_table_idx = drive_get_free_idx();
2510 drives_table[drives_table_idx].bdrv = bdrv;
c2cc47a4 2511 drives_table[drives_table_idx].devaddr = devaddr;
7d5aca9e
AL		 2512 drives_table[drives_table_idx].type = type;
2513 drives_table[drives_table_idx].bus = bus_id;
2514 drives_table[drives_table_idx].unit = unit_id;
2515 drives_table[drives_table_idx].onerror = onerror;
b01b1111 2516 drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
e6a6dfe4 2517 strncpy(drives_table[drives_table_idx].serial, serial, sizeof(serial));
e4bcb14c
TS		 2518 nb_drives++;
2519
f60d39bc 2520 switch(type) {
e4bcb14c
TS		 2521 case IF_IDE:
2522 case IF_SCSI:
62d23efa 2523 case IF_XEN:
e4bcb14c
TS		 2524 switch(media) {
2525 case MEDIA_DISK:
2526 if (cyls != 0) {
2527 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2528 bdrv_set_translation_hint(bdrv, translation);
2529 }
2530 break;
2531 case MEDIA_CDROM:
2532 bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2533 break;
2534 }
2535 break;
2536 case IF_SD:
2537 /* FIXME: This isn't really a floppy, but it's a reasonable
2538 approximation. */
2539 case IF_FLOPPY:
2540 bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2541 break;
2542 case IF_PFLASH:
2543 case IF_MTD:
6e02c38d 2544 case IF_VIRTIO:
e4bcb14c 2545 break;
aae9460e
PB		 2546 case IF_COUNT:
2547 abort();
e4bcb14c
TS		 2548 }
2549 if (!file[0])
4d73cd3b 2550 return -2;
33f00271 2551 bdrv_flags = 0;
9f7965c7 2552 if (snapshot) {
33f00271 2553 bdrv_flags |= BDRV_O_SNAPSHOT;
9f7965c7
AL		 2554 cache = 2; /* always use write-back with snapshot */
2555 }
2556 if (cache == 0) /* no caching */
2557 bdrv_flags |= BDRV_O_NOCACHE;
2558 else if (cache == 2) /* write-back */
2559 bdrv_flags |= BDRV_O_CACHE_WB;
c0f4ce77 2560 if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) {
e4bcb14c
TS		 2561 fprintf(stderr, "qemu: could not open disk image %s\n",
2562 file);
2563 return -1;
2564 }
c0f4ce77
AL		 2565 if (bdrv_key_required(bdrv))
2566 autostart = 0;
4d73cd3b 2567 return drives_table_idx;
e4bcb14c
TS		 2568}
2569
268a362c
AL		 2570static void numa_add(const char *optarg)
2571{
2572 char option[128];
2573 char *endptr;
2574 unsigned long long value, endvalue;
2575 int nodenr;
2576
2577 optarg = get_opt_name(option, 128, optarg, ',') + 1;
2578 if (!strcmp(option, "node")) {
2579 if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2580 nodenr = nb_numa_nodes;
2581 } else {
2582 nodenr = strtoull(option, NULL, 10);
2583 }
2584
2585 if (get_param_value(option, 128, "mem", optarg) == 0) {
2586 node_mem[nodenr] = 0;
2587 } else {
2588 value = strtoull(option, &endptr, 0);
2589 switch (*endptr) {
2590 case 0: case 'M': case 'm':
2591 value <<= 20;
2592 break;
2593 case 'G': case 'g':
2594 value <<= 30;
2595 break;
2596 }
2597 node_mem[nodenr] = value;
2598 }
2599 if (get_param_value(option, 128, "cpus", optarg) == 0) {
2600 node_cpumask[nodenr] = 0;
2601 } else {
2602 value = strtoull(option, &endptr, 10);
2603 if (value >= 64) {
2604 value = 63;
2605 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2606 } else {
2607 if (*endptr == '-') {
2608 endvalue = strtoull(endptr+1, &endptr, 10);
2609 if (endvalue >= 63) {
2610 endvalue = 62;
2611 fprintf(stderr,
2612 "only 63 CPUs in NUMA mode supported.\n");
2613 }
2614 value = (1 << (endvalue + 1)) - (1 << value);
2615 } else {
2616 value = 1 << value;
2617 }
2618 }
2619 node_cpumask[nodenr] = value;
2620 }
2621 nb_numa_nodes++;
2622 }
2623 return;
2624}
2625
a594cfbf
FB		 2626/***********************************************************/
2627/* USB devices */
2628
0d92ed30
PB		 2629static USBPort *used_usb_ports;
2630static USBPort *free_usb_ports;
2631
2632/* ??? Maybe change this to register a hub to keep track of the topology. */
2633void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2634 usb_attachfn attach)
2635{
2636 port->opaque = opaque;
2637 port->index = index;
2638 port->attach = attach;
2639 port->next = free_usb_ports;
2640 free_usb_ports = port;
2641}
2642
4b096fc9
AL		 2643int usb_device_add_dev(USBDevice *dev)
2644{
2645 USBPort *port;
2646
2647 /* Find a USB port to add the device to. */
2648 port = free_usb_ports;
2649 if (!port->next) {
2650 USBDevice *hub;
2651
2652 /* Create a new hub and chain it on. */
2653 free_usb_ports = NULL;
2654 port->next = used_usb_ports;
2655 used_usb_ports = port;
2656
2657 hub = usb_hub_init(VM_USB_HUB_SIZE);
2658 usb_attach(port, hub);
2659 port = free_usb_ports;
2660 }
2661
2662 free_usb_ports = port->next;
2663 port->next = used_usb_ports;
2664 used_usb_ports = port;
2665 usb_attach(port, dev);
2666 return 0;
2667}
2668
bb5fc20f
AL		 2669static void usb_msd_password_cb(void *opaque, int err)
2670{
2671 USBDevice *dev = opaque;
2672
2673 if (!err)
2674 usb_device_add_dev(dev);
2675 else
2676 dev->handle_destroy(dev);
2677}
2678
c0f4ce77 2679static int usb_device_add(const char *devname, int is_hotplug)
a594cfbf
FB		 2680{
2681 const char *p;
2682 USBDevice *dev;
a594cfbf 2683
0d92ed30 2684 if (!free_usb_ports)
a594cfbf
FB		 2685 return -1;
2686
2687 if (strstart(devname, "host:", &p)) {
2688 dev = usb_host_device_open(p);
a594cfbf
FB		 2689 } else if (!strcmp(devname, "mouse")) {
2690 dev = usb_mouse_init();
09b26c5e 2691 } else if (!strcmp(devname, "tablet")) {
47b2d338
AZ		 2692 dev = usb_tablet_init();
2693 } else if (!strcmp(devname, "keyboard")) {
2694 dev = usb_keyboard_init();
2e5d83bb 2695 } else if (strstart(devname, "disk:", &p)) {
c0f4ce77
AL		 2696 BlockDriverState *bs;
2697
bb5fc20f 2698 dev = usb_msd_init(p);
c0f4ce77
AL		 2699 if (!dev)
2700 return -1;
bb5fc20f 2701 bs = usb_msd_get_bdrv(dev);
c0f4ce77
AL		 2702 if (bdrv_key_required(bs)) {
2703 autostart = 0;
bb5fc20f 2704 if (is_hotplug) {
376253ec
AL		 2705 monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2706 dev);
bb5fc20f 2707 return 0;
c0f4ce77
AL		 2708 }
2709 }
f6d2a316
AZ		 2710 } else if (!strcmp(devname, "wacom-tablet")) {
2711 dev = usb_wacom_init();
a7954218
AZ		 2712 } else if (strstart(devname, "serial:", &p)) {
2713 dev = usb_serial_init(p);
2e4d9fb1
AJ		 2714#ifdef CONFIG_BRLAPI
2715 } else if (!strcmp(devname, "braille")) {
2716 dev = usb_baum_init();
2717#endif
6c9f886c 2718 } else if (strstart(devname, "net:", &p)) {
9ad97e65 2719 int nic = nb_nics;
6c9f886c 2720
10ae5a7a 2721 if (net_client_init(NULL, "nic", p) < 0)
6c9f886c 2722 return -1;
9ad97e65
AZ		 2723 nd_table[nic].model = "usb";
2724 dev = usb_net_init(&nd_table[nic]);
dc72ac14
AZ		 2725 } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2726 dev = usb_bt_init(devname[2] ? hci_init(p) :
2727 bt_new_hci(qemu_find_bt_vlan(0)));
a594cfbf
FB		 2728 } else {
2729 return -1;
2730 }
0d92ed30
PB		 2731 if (!dev)
2732 return -1;
2733
4b096fc9 2734 return usb_device_add_dev(dev);
a594cfbf
FB		 2735}
2736
1f3870ab 2737int usb_device_del_addr(int bus_num, int addr)
a594cfbf 2738{
0d92ed30
PB		 2739 USBPort *port;
2740 USBPort **lastp;
059809e4 2741 USBDevice *dev;
a594cfbf 2742
0d92ed30 2743 if (!used_usb_ports)
a594cfbf
FB		 2744 return -1;
2745
a594cfbf
FB		 2746 if (bus_num != 0)
2747 return -1;
0d92ed30
PB		 2748
2749 lastp = &used_usb_ports;
2750 port = used_usb_ports;
2751 while (port && port->dev->addr != addr) {
2752 lastp = &port->next;
2753 port = port->next;
a594cfbf 2754 }
0d92ed30
PB		 2755
2756 if (!port)
a594cfbf 2757 return -1;
0d92ed30 2758
059809e4 2759 dev = port->dev;
0d92ed30
PB		 2760 *lastp = port->next;
2761 usb_attach(port, NULL);
059809e4 2762 dev->handle_destroy(dev);
0d92ed30
PB		 2763 port->next = free_usb_ports;
2764 free_usb_ports = port;
a594cfbf
FB		 2765 return 0;
2766}
2767
1f3870ab
AL		 2768static int usb_device_del(const char *devname)
2769{
2770 int bus_num, addr;
2771 const char *p;
2772
5d0c5750
AL		 2773 if (strstart(devname, "host:", &p))
2774 return usb_host_device_close(p);
2775
1f3870ab
AL		 2776 if (!used_usb_ports)
2777 return -1;
2778
2779 p = strchr(devname, '.');
2780 if (!p)
2781 return -1;
2782 bus_num = strtoul(devname, NULL, 0);
2783 addr = strtoul(p + 1, NULL, 0);
2784
2785 return usb_device_del_addr(bus_num, addr);
2786}
2787
376253ec 2788void do_usb_add(Monitor *mon, const char *devname)
a594cfbf 2789{
c0f4ce77 2790 usb_device_add(devname, 1);
a594cfbf
FB		 2791}
2792
376253ec 2793void do_usb_del(Monitor *mon, const char *devname)
a594cfbf 2794{
4b096fc9 2795 usb_device_del(devname);
a594cfbf
FB		 2796}
2797
376253ec 2798void usb_info(Monitor *mon)
a594cfbf
FB		 2799{
2800 USBDevice *dev;
0d92ed30 2801 USBPort *port;
a594cfbf
FB		 2802 const char *speed_str;
2803
0d92ed30 2804 if (!usb_enabled) {
376253ec 2805 monitor_printf(mon, "USB support not enabled\n");
a594cfbf
FB		 2806 return;
2807 }
2808
0d92ed30
PB		 2809 for (port = used_usb_ports; port; port = port->next) {
2810 dev = port->dev;
2811 if (!dev)
2812 continue;
2813 switch(dev->speed) {
5fafdf24
TS		 2814 case USB_SPEED_LOW:
2815 speed_str = "1.5";
0d92ed30 2816 break;
5fafdf24
TS		 2817 case USB_SPEED_FULL:
2818 speed_str = "12";
0d92ed30 2819 break;
5fafdf24
TS		 2820 case USB_SPEED_HIGH:
2821 speed_str = "480";
0d92ed30
PB		 2822 break;
2823 default:
5fafdf24 2824 speed_str = "?";
0d92ed30 2825 break;
a594cfbf 2826 }
376253ec
AL		 2827 monitor_printf(mon, " Device %d.%d, Speed %s Mb/s, Product %s\n",
2828 0, dev->addr, speed_str, dev->devname);
a594cfbf
FB		 2829 }
2830}
2831
201a51fc
AZ		 2832/***********************************************************/
2833/* PCMCIA/Cardbus */
2834
2835static struct pcmcia_socket_entry_s {
bc24a225 2836 PCMCIASocket *socket;
201a51fc
AZ		 2837 struct pcmcia_socket_entry_s *next;
2838} *pcmcia_sockets = 0;
2839
bc24a225 2840void pcmcia_socket_register(PCMCIASocket *socket)
201a51fc
AZ		 2841{
2842 struct pcmcia_socket_entry_s *entry;
2843
2844 entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2845 entry->socket = socket;
2846 entry->next = pcmcia_sockets;
2847 pcmcia_sockets = entry;
2848}
2849
bc24a225 2850void pcmcia_socket_unregister(PCMCIASocket *socket)
201a51fc
AZ		 2851{
2852 struct pcmcia_socket_entry_s *entry, **ptr;
2853
2854 ptr = &pcmcia_sockets;
2855 for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2856 if (entry->socket == socket) {
2857 *ptr = entry->next;
2858 qemu_free(entry);
2859 }
2860}
2861
376253ec 2862void pcmcia_info(Monitor *mon)
201a51fc
AZ		 2863{
2864 struct pcmcia_socket_entry_s *iter;
376253ec 2865
201a51fc 2866 if (!pcmcia_sockets)
376253ec 2867 monitor_printf(mon, "No PCMCIA sockets\n");
201a51fc
AZ		 2868
2869 for (iter = pcmcia_sockets; iter; iter = iter->next)
376253ec
AL		 2870 monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2871 iter->socket->attached ? iter->socket->card_string :
2872 "Empty");
201a51fc
AZ		 2873}
2874
2ff89790 2875/***********************************************************/
3023f332
AL		 2876/* register display */
2877
7b5d76da
AL		 2878struct DisplayAllocator default_allocator = {
2879 defaultallocator_create_displaysurface,
2880 defaultallocator_resize_displaysurface,
2881 defaultallocator_free_displaysurface
2882};
2883
3023f332
AL		 2884void register_displaystate(DisplayState *ds)
2885{
2886 DisplayState **s;
2887 s = &display_state;
2888 while (*s != NULL)
2889 s = &(*s)->next;
2890 ds->next = NULL;
2891 *s = ds;
2892}
2893
2894DisplayState *get_displaystate(void)
2895{
2896 return display_state;
2897}
2898
7b5d76da
AL		 2899DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2900{
2901 if(ds->allocator == &default_allocator) ds->allocator = da;
2902 return ds->allocator;
2903}
2904
2ff89790
TS		 2905/* dumb display */
2906
8f391ab4 2907static void dumb_display_init(void)
2ff89790 2908{
8f391ab4 2909 DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
7b5d76da
AL		 2910 ds->allocator = &default_allocator;
2911 ds->surface = qemu_create_displaysurface(ds, 640, 480);
8f391ab4 2912 register_displaystate(ds);
2ff89790
TS		 2913}
2914
8a7ddc38
FB		 2915/***********************************************************/
2916/* I/O handling */
0824d6fc 2917
c4b1fcc0
FB		 2918typedef struct IOHandlerRecord {
2919 int fd;
7c9d8e07
FB		 2920 IOCanRWHandler *fd_read_poll;
2921 IOHandler *fd_read;
2922 IOHandler *fd_write;
cafffd40 2923 int deleted;
c4b1fcc0
FB		 2924 void *opaque;
2925 /* temporary data */
2926 struct pollfd *ufd;
8a7ddc38 2927 struct IOHandlerRecord *next;
c4b1fcc0
FB		 2928} IOHandlerRecord;
2929
8a7ddc38 2930static IOHandlerRecord *first_io_handler;
c4b1fcc0 2931
7c9d8e07
FB		 2932/* XXX: fd_read_poll should be suppressed, but an API change is
2933 necessary in the character devices to suppress fd_can_read(). */
5fafdf24
TS		 2934int qemu_set_fd_handler2(int fd,
2935 IOCanRWHandler *fd_read_poll,
2936 IOHandler *fd_read,
2937 IOHandler *fd_write,
7c9d8e07 2938 void *opaque)
c4b1fcc0 2939{
7c9d8e07 2940 IOHandlerRecord **pioh, *ioh;
c4b1fcc0 2941
7c9d8e07
FB		 2942 if (!fd_read && !fd_write) {
2943 pioh = &first_io_handler;
2944 for(;;) {
2945 ioh = *pioh;
2946 if (ioh == NULL)
2947 break;
2948 if (ioh->fd == fd) {
cafffd40 2949 ioh->deleted = 1;
7c9d8e07
FB		 2950 break;
2951 }
2952 pioh = &ioh->next;
2953 }
2954 } else {
2955 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2956 if (ioh->fd == fd)
2957 goto found;
2958 }
2959 ioh = qemu_mallocz(sizeof(IOHandlerRecord));
7c9d8e07
FB		 2960 ioh->next = first_io_handler;
2961 first_io_handler = ioh;
2962 found:
2963 ioh->fd = fd;
2964 ioh->fd_read_poll = fd_read_poll;
2965 ioh->fd_read = fd_read;
2966 ioh->fd_write = fd_write;
2967 ioh->opaque = opaque;
cafffd40 2968 ioh->deleted = 0;
7c9d8e07 2969 }
c4b1fcc0
FB		 2970 return 0;
2971}
2972
5fafdf24
TS		 2973int qemu_set_fd_handler(int fd,
2974 IOHandler *fd_read,
2975 IOHandler *fd_write,
7c9d8e07 2976 void *opaque)
8a7ddc38 2977{
7c9d8e07 2978 return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
8a7ddc38
FB		 2979}
2980
56f3a5d0 2981#ifdef _WIN32
f331110f
FB		 2982/***********************************************************/
2983/* Polling handling */
2984
2985typedef struct PollingEntry {
2986 PollingFunc *func;
2987 void *opaque;
2988 struct PollingEntry *next;
2989} PollingEntry;
2990
2991static PollingEntry *first_polling_entry;
2992
2993int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2994{
2995 PollingEntry **ppe, *pe;
2996 pe = qemu_mallocz(sizeof(PollingEntry));
f331110f
FB		 2997 pe->func = func;
2998 pe->opaque = opaque;
2999 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
3000 *ppe = pe;
3001 return 0;
3002}
3003
3004void qemu_del_polling_cb(PollingFunc *func, void *opaque)
3005{
3006 PollingEntry **ppe, *pe;
3007 for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
3008 pe = *ppe;
3009 if (pe->func == func && pe->opaque == opaque) {
3010 *ppe = pe->next;
3011 qemu_free(pe);
3012 break;
3013 }
3014 }
3015}
3016
a18e524a
FB		 3017/***********************************************************/
3018/* Wait objects support */
3019typedef struct WaitObjects {
3020 int num;
3021 HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3022 WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3023 void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3024} WaitObjects;
3025
3026static WaitObjects wait_objects = {0};
3b46e624 3027
a18e524a
FB		 3028int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3029{
3030 WaitObjects *w = &wait_objects;
3031
3032 if (w->num >= MAXIMUM_WAIT_OBJECTS)
3033 return -1;
3034 w->events[w->num] = handle;
3035 w->func[w->num] = func;
3036 w->opaque[w->num] = opaque;
3037 w->num++;
3038 return 0;
3039}
3040
3041void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3042{
3043 int i, found;
3044 WaitObjects *w = &wait_objects;
3045
3046 found = 0;
3047 for (i = 0; i < w->num; i++) {
3048 if (w->events[i] == handle)
3049 found = 1;
3050 if (found) {
3051 w->events[i] = w->events[i + 1];
3052 w->func[i] = w->func[i + 1];
3053 w->opaque[i] = w->opaque[i + 1];
3b46e624 3054 }
a18e524a
FB		 3055 }
3056 if (found)
3057 w->num--;
3058}
3059#endif
3060
8a7ddc38
FB		 3061/***********************************************************/
3062/* ram save/restore */
3063
8a7ddc38
FB		 3064static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3065{
3066 int v;
3067
3068 v = qemu_get_byte(f);
3069 switch(v) {
3070 case 0:
3071 if (qemu_get_buffer(f, buf, len) != len)
3072 return -EIO;
3073 break;
3074 case 1:
3075 v = qemu_get_byte(f);
3076 memset(buf, v, len);
3077 break;
3078 default:
3079 return -EINVAL;
3080 }
871d2f07
AL		 3081
3082 if (qemu_file_has_error(f))
3083 return -EIO;
3084
8a7ddc38
FB		 3085 return 0;
3086}
3087
c88676f8
FB		 3088static int ram_load_v1(QEMUFile *f, void *opaque)
3089{
00f82b8a
AJ		 3090 int ret;
3091 ram_addr_t i;
c88676f8 3092
94a6b54f 3093 if (qemu_get_be32(f) != last_ram_offset)
c88676f8 3094 return -EINVAL;
94a6b54f 3095 for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
5579c7f3 3096 ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
c88676f8
FB		 3097 if (ret)
3098 return ret;
3099 }
3100 return 0;
3101}
3102
3103#define BDRV_HASH_BLOCK_SIZE 1024
3104#define IOBUF_SIZE 4096
3105#define RAM_CBLOCK_MAGIC 0xfabe
3106
c88676f8
FB		 3107typedef struct RamDecompressState {
3108 z_stream zstream;
3109 QEMUFile *f;
3110 uint8_t buf[IOBUF_SIZE];
3111} RamDecompressState;
3112
3113static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3114{
3115 int ret;
3116 memset(s, 0, sizeof(*s));
3117 s->f = f;
3118 ret = inflateInit(&s->zstream);
3119 if (ret != Z_OK)
3120 return -1;
3121 return 0;
3122}
3123
3124static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3125{
3126 int ret, clen;
3127
3128 s->zstream.avail_out = len;
3129 s->zstream.next_out = buf;
3130 while (s->zstream.avail_out > 0) {
3131 if (s->zstream.avail_in == 0) {
3132 if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3133 return -1;
3134 clen = qemu_get_be16(s->f);
3135 if (clen > IOBUF_SIZE)
3136 return -1;
3137 qemu_get_buffer(s->f, s->buf, clen);
3138 s->zstream.avail_in = clen;
3139 s->zstream.next_in = s->buf;
3140 }
3141 ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3142 if (ret != Z_OK && ret != Z_STREAM_END) {
3143 return -1;
3144 }
3145 }
3146 return 0;
3147}
3148
3149static void ram_decompress_close(RamDecompressState *s)
3150{
3151 inflateEnd(&s->zstream);
3152}
3153
475e4277
AL		 3154#define RAM_SAVE_FLAG_FULL 0x01
3155#define RAM_SAVE_FLAG_COMPRESS 0x02
3156#define RAM_SAVE_FLAG_MEM_SIZE 0x04
3157#define RAM_SAVE_FLAG_PAGE 0x08
3158#define RAM_SAVE_FLAG_EOS 0x10
3159
3160static int is_dup_page(uint8_t *page, uint8_t ch)
8a7ddc38 3161{
475e4277
AL		 3162 uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3163 uint32_t *array = (uint32_t *)page;
3164 int i;
3b46e624 3165
475e4277
AL		 3166 for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3167 if (array[i] != val)
3168 return 0;
3169 }
3170
3171 return 1;
3172}
3173
3174static int ram_save_block(QEMUFile *f)
3175{
3176 static ram_addr_t current_addr = 0;
3177 ram_addr_t saved_addr = current_addr;
3178 ram_addr_t addr = 0;
3179 int found = 0;
3180
94a6b54f 3181 while (addr < last_ram_offset) {
475e4277 3182 if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
5579c7f3 3183 uint8_t *p;
475e4277
AL		 3184
3185 cpu_physical_memory_reset_dirty(current_addr,
3186 current_addr + TARGET_PAGE_SIZE,
3187 MIGRATION_DIRTY_FLAG);
3188
5579c7f3 3189 p = qemu_get_ram_ptr(current_addr);
475e4277 3190
5579c7f3 3191 if (is_dup_page(p, *p)) {
475e4277 3192 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
5579c7f3 3193 qemu_put_byte(f, *p);
475e4277
AL		 3194 } else {
3195 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
5579c7f3 3196 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
c88676f8 3197 }
475e4277
AL		 3198
3199 found = 1;
3200 break;
c88676f8 3201 }
475e4277 3202 addr += TARGET_PAGE_SIZE;
94a6b54f 3203 current_addr = (saved_addr + addr) % last_ram_offset;
8a7ddc38 3204 }
475e4277
AL		 3205
3206 return found;
8a7ddc38
FB		 3207}
3208
9f9e28cd 3209static uint64_t bytes_transferred = 0;
475e4277
AL		 3210
3211static ram_addr_t ram_save_remaining(void)
3212{
3213 ram_addr_t addr;
3214 ram_addr_t count = 0;
3215
94a6b54f 3216 for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
475e4277
AL		 3217 if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3218 count++;
3219 }
3220
3221 return count;
3222}
3223
9f9e28cd
GC		 3224uint64_t ram_bytes_remaining(void)
3225{
3226 return ram_save_remaining() * TARGET_PAGE_SIZE;
3227}
3228
3229uint64_t ram_bytes_transferred(void)
3230{
3231 return bytes_transferred;
3232}
3233
3234uint64_t ram_bytes_total(void)
3235{
3236 return last_ram_offset;
3237}
3238
475e4277
AL		 3239static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3240{
3241 ram_addr_t addr;
a0a3fd60
GC		 3242 uint64_t bytes_transferred_last;
3243 double bwidth = 0;
3244 uint64_t expected_time = 0;
475e4277 3245
9fa06385 3246 if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
b0a46a33
JK		 3247 qemu_file_set_error(f);
3248 return 0;
3249 }
3250
475e4277
AL		 3251 if (stage == 1) {
3252 /* Make sure all dirty bits are set */
94a6b54f 3253 for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
475e4277
AL		 3254 if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3255 cpu_physical_memory_set_dirty(addr);
3256 }
b0a46a33 3257
475e4277
AL		 3258 /* Enable dirty memory tracking */
3259 cpu_physical_memory_set_dirty_tracking(1);
3260
94a6b54f 3261 qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
475e4277
AL		 3262 }
3263
a0a3fd60
GC		 3264 bytes_transferred_last = bytes_transferred;
3265 bwidth = get_clock();
3266
475e4277
AL		 3267 while (!qemu_file_rate_limit(f)) {
3268 int ret;
3269
3270 ret = ram_save_block(f);
9f9e28cd 3271 bytes_transferred += ret * TARGET_PAGE_SIZE;
475e4277
AL		 3272 if (ret == 0) /* no more blocks */
3273 break;
3274 }
3275
a0a3fd60
GC		 3276 bwidth = get_clock() - bwidth;
3277 bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
3278
3279 /* if we haven't transferred anything this round, force expected_time to a
3280 * a very high value, but without crashing */
3281 if (bwidth == 0)
3282 bwidth = 0.000001;
3283
475e4277
AL		 3284 /* try transferring iterative blocks of memory */
3285
3286 if (stage == 3) {
475e4277
AL		 3287
3288 /* flush all remaining blocks regardless of rate limiting */
9f9e28cd
GC		 3289 while (ram_save_block(f) != 0) {
3290 bytes_transferred += TARGET_PAGE_SIZE;
3291 }
8215e914 3292 cpu_physical_memory_set_dirty_tracking(0);
475e4277
AL		 3293 }
3294
3295 qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3296
a0a3fd60
GC		 3297 expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
3298
3299 return (stage == 2) && (expected_time <= migrate_max_downtime());
475e4277
AL		 3300}
3301
3302static int ram_load_dead(QEMUFile *f, void *opaque)
8a7ddc38 3303{
c88676f8
FB		 3304 RamDecompressState s1, *s = &s1;
3305 uint8_t buf[10];
00f82b8a 3306 ram_addr_t i;
8a7ddc38 3307
c88676f8
FB		 3308 if (ram_decompress_open(s, f) < 0)
3309 return -EINVAL;
94a6b54f 3310 for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
c88676f8
FB		 3311 if (ram_decompress_buf(s, buf, 1) < 0) {
3312 fprintf(stderr, "Error while reading ram block header\n");
3313 goto error;
3314 }
3315 if (buf[0] == 0) {
5579c7f3
PB		 3316 if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
3317 BDRV_HASH_BLOCK_SIZE) < 0) {
00f82b8a 3318 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
c88676f8
FB		 3319 goto error;
3320 }
475e4277 3321 } else {
c88676f8
FB		 3322 error:
3323 printf("Error block header\n");
3324 return -EINVAL;
3325 }
8a7ddc38 3326 }
c88676f8 3327 ram_decompress_close(s);
475e4277
AL		 3328
3329 return 0;
3330}
3331
3332static int ram_load(QEMUFile *f, void *opaque, int version_id)
3333{
3334 ram_addr_t addr;
3335 int flags;
3336
3337 if (version_id == 1)
3338 return ram_load_v1(f, opaque);
3339
3340 if (version_id == 2) {
94a6b54f 3341 if (qemu_get_be32(f) != last_ram_offset)
475e4277
AL		 3342 return -EINVAL;
3343 return ram_load_dead(f, opaque);
3344 }
3345
3346 if (version_id != 3)
3347 return -EINVAL;
3348
3349 do {
3350 addr = qemu_get_be64(f);
3351
3352 flags = addr & ~TARGET_PAGE_MASK;
3353 addr &= TARGET_PAGE_MASK;
3354
3355 if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
94a6b54f 3356 if (addr != last_ram_offset)
475e4277
AL		 3357 return -EINVAL;
3358 }
3359
3360 if (flags & RAM_SAVE_FLAG_FULL) {
3361 if (ram_load_dead(f, opaque) < 0)
3362 return -EINVAL;
3363 }
3364
3365 if (flags & RAM_SAVE_FLAG_COMPRESS) {
3366 uint8_t ch = qemu_get_byte(f);
779c6bef
AL		 3367 memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3368#ifndef _WIN32
30868442
AL		 3369 if (ch == 0 &&
3370 (!kvm_enabled() || kvm_has_sync_mmu())) {
3371 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
779c6bef 3372 }
30868442 3373#endif
475e4277 3374 } else if (flags & RAM_SAVE_FLAG_PAGE)
5579c7f3 3375 qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
475e4277
AL		 3376 } while (!(flags & RAM_SAVE_FLAG_EOS));
3377
8a7ddc38
FB		 3378 return 0;
3379}
3380
9e472e10
AL		 3381void qemu_service_io(void)
3382{
d9f75a4e 3383 qemu_notify_event();
9e472e10
AL		 3384}
3385
83f64091
FB		 3386/***********************************************************/
3387/* bottom halves (can be seen as timers which expire ASAP) */
3388
3389struct QEMUBH {
3390 QEMUBHFunc *cb;
3391 void *opaque;
3392 int scheduled;
1b435b10
AL		 3393 int idle;
3394 int deleted;
83f64091
FB		 3395 QEMUBH *next;
3396};
3397
3398static QEMUBH *first_bh = NULL;
3399
3400QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3401{
3402 QEMUBH *bh;
3403 bh = qemu_mallocz(sizeof(QEMUBH));
83f64091
FB		 3404 bh->cb = cb;
3405 bh->opaque = opaque;
1b435b10
AL		 3406 bh->next = first_bh;
3407 first_bh = bh;
83f64091
FB		 3408 return bh;
3409}
3410
6eb5733a 3411int qemu_bh_poll(void)
83f64091 3412{
1b435b10 3413 QEMUBH *bh, **bhp;
6eb5733a 3414 int ret;
83f64091 3415
6eb5733a 3416 ret = 0;
1b435b10
AL		 3417 for (bh = first_bh; bh; bh = bh->next) {
3418 if (!bh->deleted && bh->scheduled) {
3419 bh->scheduled = 0;
3420 if (!bh->idle)
3421 ret = 1;
3422 bh->idle = 0;
3423 bh->cb(bh->opaque);
3424 }
83f64091 3425 }
1b435b10
AL		 3426
3427 /* remove deleted bhs */
3428 bhp = &first_bh;
3429 while (*bhp) {
3430 bh = *bhp;
3431 if (bh->deleted) {
3432 *bhp = bh->next;
3433 qemu_free(bh);
3434 } else
3435 bhp = &bh->next;
3436 }
3437
6eb5733a 3438 return ret;
83f64091
FB		 3439}
3440
1b435b10
AL		 3441void qemu_bh_schedule_idle(QEMUBH *bh)
3442{
3443 if (bh->scheduled)
3444 return;
3445 bh->scheduled = 1;
3446 bh->idle = 1;
3447}
3448
83f64091
FB		 3449void qemu_bh_schedule(QEMUBH *bh)
3450{
83f64091
FB		 3451 if (bh->scheduled)
3452 return;
3453 bh->scheduled = 1;
1b435b10 3454 bh->idle = 0;
83f64091 3455 /* stop the currently executing CPU to execute the BH ASAP */
d9f75a4e 3456 qemu_notify_event();
83f64091
FB		 3457}
3458
3459void qemu_bh_cancel(QEMUBH *bh)
3460{
1b435b10 3461 bh->scheduled = 0;
83f64091
FB		 3462}
3463
3464void qemu_bh_delete(QEMUBH *bh)
3465{
1b435b10
AL		 3466 bh->scheduled = 0;
3467 bh->deleted = 1;
83f64091
FB		 3468}
3469
56f3a5d0
AL		 3470static void qemu_bh_update_timeout(int *timeout)
3471{
3472 QEMUBH *bh;
3473
3474 for (bh = first_bh; bh; bh = bh->next) {
3475 if (!bh->deleted && bh->scheduled) {
3476 if (bh->idle) {
3477 /* idle bottom halves will be polled at least
3478 * every 10ms */
3479 *timeout = MIN(10, *timeout);
3480 } else {
3481 /* non-idle bottom halves will be executed
3482 * immediately */
3483 *timeout = 0;
3484 break;
3485 }
3486 }
3487 }
3488}
3489
cc1daa40
FB		 3490/***********************************************************/
3491/* machine registration */
3492
bdaf78e0 3493static QEMUMachine *first_machine = NULL;
6f338c34 3494QEMUMachine *current_machine = NULL;
cc1daa40
FB		 3495
3496int qemu_register_machine(QEMUMachine *m)
3497{
3498 QEMUMachine **pm;
3499 pm = &first_machine;
3500 while (*pm != NULL)
3501 pm = &(*pm)->next;
3502 m->next = NULL;
3503 *pm = m;
3504 return 0;
3505}
3506
9596ebb7 3507static QEMUMachine *find_machine(const char *name)
cc1daa40
FB		 3508{
3509 QEMUMachine *m;
3510
3511 for(m = first_machine; m != NULL; m = m->next) {
3512 if (!strcmp(m->name, name))
3513 return m;
3514 }
3515 return NULL;
3516}
3517
0c257437
AL		 3518static QEMUMachine *find_default_machine(void)
3519{
3520 QEMUMachine *m;
3521
3522 for(m = first_machine; m != NULL; m = m->next) {
3523 if (m->is_default) {
3524 return m;
3525 }
3526 }
3527 return NULL;
3528}
3529
8a7ddc38
FB		 3530/***********************************************************/
3531/* main execution loop */
3532
9596ebb7 3533static void gui_update(void *opaque)
8a7ddc38 3534{
7d957bd8 3535 uint64_t interval = GUI_REFRESH_INTERVAL;
740733bb 3536 DisplayState *ds = opaque;
7d957bd8
AL		 3537 DisplayChangeListener *dcl = ds->listeners;
3538
3539 dpy_refresh(ds);
3540
3541 while (dcl != NULL) {
3542 if (dcl->gui_timer_interval &&
3543 dcl->gui_timer_interval < interval)
3544 interval = dcl->gui_timer_interval;
3545 dcl = dcl->next;
3546 }
3547 qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
8a7ddc38
FB		 3548}
3549
9043b62d
BS		 3550static void nographic_update(void *opaque)
3551{
3552 uint64_t interval = GUI_REFRESH_INTERVAL;
3553
3554 qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3555}
3556
0bd48850
FB		 3557struct vm_change_state_entry {
3558 VMChangeStateHandler *cb;
3559 void *opaque;
3560 LIST_ENTRY (vm_change_state_entry) entries;
3561};
3562
3563static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3564
3565VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3566 void *opaque)
3567{
3568 VMChangeStateEntry *e;
3569
3570 e = qemu_mallocz(sizeof (*e));
0bd48850
FB		 3571
3572 e->cb = cb;
3573 e->opaque = opaque;
3574 LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3575 return e;
3576}
3577
3578void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3579{
3580 LIST_REMOVE (e, entries);
3581 qemu_free (e);
3582}
3583
9781e040 3584static void vm_state_notify(int running, int reason)
0bd48850
FB		 3585{
3586 VMChangeStateEntry *e;
3587
3588 for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
9781e040 3589 e->cb(e->opaque, running, reason);
0bd48850
FB		 3590 }
3591}
3592
d6dc3d42
AL		 3593static void resume_all_vcpus(void);
3594static void pause_all_vcpus(void);
3595
8a7ddc38
FB		 3596void vm_start(void)
3597{
3598 if (!vm_running) {
3599 cpu_enable_ticks();
3600 vm_running = 1;
9781e040 3601 vm_state_notify(1, 0);
efe75411 3602 qemu_rearm_alarm_timer(alarm_timer);
d6dc3d42 3603 resume_all_vcpus();
8a7ddc38
FB		 3604 }
3605}
3606
bb0c6722
FB		 3607/* reset/shutdown handler */
3608
3609typedef struct QEMUResetEntry {
3610 QEMUResetHandler *func;
3611 void *opaque;
3612 struct QEMUResetEntry *next;
3613} QEMUResetEntry;
3614
3615static QEMUResetEntry *first_reset_entry;
3616static int reset_requested;
3617static int shutdown_requested;
3475187d 3618static int powerdown_requested;
e568902a 3619static int debug_requested;
6e29f5da 3620static int vmstop_requested;
bb0c6722 3621
cf7a2fe2
AJ		 3622int qemu_shutdown_requested(void)
3623{
3624 int r = shutdown_requested;
3625 shutdown_requested = 0;
3626 return r;
3627}
3628
3629int qemu_reset_requested(void)
3630{
3631 int r = reset_requested;
3632 reset_requested = 0;
3633 return r;
3634}
3635
3636int qemu_powerdown_requested(void)
3637{
3638 int r = powerdown_requested;
3639 powerdown_requested = 0;
3640 return r;
3641}
3642
e568902a
AL		 3643static int qemu_debug_requested(void)
3644{
3645 int r = debug_requested;
3646 debug_requested = 0;
3647 return r;
3648}
3649
6e29f5da
AL		 3650static int qemu_vmstop_requested(void)
3651{
3652 int r = vmstop_requested;
3653 vmstop_requested = 0;
3654 return r;
3655}
3656
3657static void do_vm_stop(int reason)
3658{
3659 if (vm_running) {
3660 cpu_disable_ticks();
3661 vm_running = 0;
d6dc3d42 3662 pause_all_vcpus();
6e29f5da
AL		 3663 vm_state_notify(0, reason);
3664 }
3665}
3666
a08d4367 3667void qemu_register_reset(QEMUResetHandler *func, void *opaque)
bb0c6722
FB		 3668{
3669 QEMUResetEntry **pre, *re;
3670
3671 pre = &first_reset_entry;
a08d4367 3672 while (*pre != NULL)
bb0c6722
FB		 3673 pre = &(*pre)->next;
3674 re = qemu_mallocz(sizeof(QEMUResetEntry));
3675 re->func = func;
3676 re->opaque = opaque;
3677 re->next = NULL;
3678 *pre = re;
3679}
3680
cf7a2fe2 3681void qemu_system_reset(void)
bb0c6722
FB		 3682{
3683 QEMUResetEntry *re;
3684
3685 /* reset all devices */
3686 for(re = first_reset_entry; re != NULL; re = re->next) {
3687 re->func(re->opaque);
3688 }
3689}
3690
3691void qemu_system_reset_request(void)
3692{
d1beab82
FB		 3693 if (no_reboot) {
3694 shutdown_requested = 1;
3695 } else {
3696 reset_requested = 1;
3697 }
d9f75a4e 3698 qemu_notify_event();
bb0c6722
FB		 3699}
3700
3701void qemu_system_shutdown_request(void)
3702{
3703 shutdown_requested = 1;
d9f75a4e 3704 qemu_notify_event();
bb0c6722
FB		 3705}
3706
3475187d
FB		 3707void qemu_system_powerdown_request(void)
3708{
3709 powerdown_requested = 1;
d9f75a4e
AL		 3710 qemu_notify_event();
3711}
3712
d6dc3d42
AL		 3713#ifdef CONFIG_IOTHREAD
3714static void qemu_system_vmstop_request(int reason)
d9f75a4e 3715{
d6dc3d42
AL		 3716 vmstop_requested = reason;
3717 qemu_notify_event();
bb0c6722 3718}
d6dc3d42 3719#endif
bb0c6722 3720
50317c7f
AL		 3721#ifndef _WIN32
3722static int io_thread_fd = -1;
3723
3724static void qemu_event_increment(void)
3fcf7b6b 3725{
50317c7f
AL		 3726 static const char byte = 0;
3727
3728 if (io_thread_fd == -1)
3729 return;
3730
3731 write(io_thread_fd, &byte, sizeof(byte));
3732}
3733
3734static void qemu_event_read(void *opaque)
3735{
3736 int fd = (unsigned long)opaque;
3737 ssize_t len;
3738
3739 /* Drain the notify pipe */
3740 do {
3741 char buffer[512];
3742 len = read(fd, buffer, sizeof(buffer));
3743 } while ((len == -1 && errno == EINTR) || len > 0);
3744}
3745
3746static int qemu_event_init(void)
3747{
3748 int err;
3749 int fds[2];
3750
3751 err = pipe(fds);
3752 if (err == -1)
3753 return -errno;
3754
3755 err = fcntl_setfl(fds[0], O_NONBLOCK);
3756 if (err < 0)
3757 goto fail;
3758
3759 err = fcntl_setfl(fds[1], O_NONBLOCK);
3760 if (err < 0)
3761 goto fail;
3762
3763 qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3764 (void *)(unsigned long)fds[0]);
3765
3766 io_thread_fd = fds[1];
a7e21219
JK		 3767 return 0;
3768
50317c7f
AL		 3769fail:
3770 close(fds[0]);
3771 close(fds[1]);
3772 return err;
3773}
3774#else
3775HANDLE qemu_event_handle;
3776
3777static void dummy_event_handler(void *opaque)
3778{
3779}
3780
3781static int qemu_event_init(void)
3782{
3783 qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3784 if (!qemu_event_handle) {
3785 perror("Failed CreateEvent");
3786 return -1;
3787 }
3788 qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3fcf7b6b
AL		 3789 return 0;
3790}
3791
50317c7f
AL		 3792static void qemu_event_increment(void)
3793{
3794 SetEvent(qemu_event_handle);
3795}
3796#endif
3797
d6dc3d42
AL		 3798static int cpu_can_run(CPUState *env)
3799{
3800 if (env->stop)
3801 return 0;
3802 if (env->stopped)
3803 return 0;
3804 return 1;
3805}
3806
3807#ifndef CONFIG_IOTHREAD
50317c7f
AL		 3808static int qemu_init_main_loop(void)
3809{
3810 return qemu_event_init();
3811}
3812
0bf46a40
AL		 3813void qemu_init_vcpu(void *_env)
3814{
3815 CPUState *env = _env;
3816
3817 if (kvm_enabled())
3818 kvm_init_vcpu(env);
3819 return;
3820}
3821
8edac960
AL		 3822int qemu_cpu_self(void *env)
3823{
3824 return 1;
3825}
3826
d6dc3d42
AL		 3827static void resume_all_vcpus(void)
3828{
3829}
3830
3831static void pause_all_vcpus(void)
3832{
3833}
3834
8edac960
AL		 3835void qemu_cpu_kick(void *env)
3836{
3837 return;
3838}
3839
d6dc3d42
AL		 3840void qemu_notify_event(void)
3841{
3842 CPUState *env = cpu_single_env;
3843
3844 if (env) {
3845 cpu_exit(env);
3846#ifdef USE_KQEMU
3847 if (env->kqemu_enabled)
3848 kqemu_cpu_interrupt(env);
3849#endif
3850 }
3851}
3852
4870852c
AL		 3853#define qemu_mutex_lock_iothread() do { } while (0)
3854#define qemu_mutex_unlock_iothread() do { } while (0)
3855
6e29f5da
AL		 3856void vm_stop(int reason)
3857{
3858 do_vm_stop(reason);
3859}
3860
d6dc3d42
AL		 3861#else /* CONFIG_IOTHREAD */
3862
3863#include "qemu-thread.h"
3864
3865QemuMutex qemu_global_mutex;
3866static QemuMutex qemu_fair_mutex;
3867
3868static QemuThread io_thread;
3869
3870static QemuThread *tcg_cpu_thread;
3871static QemuCond *tcg_halt_cond;
3872
3873static int qemu_system_ready;
3874/* cpu creation */
3875static QemuCond qemu_cpu_cond;
3876/* system init */
3877static QemuCond qemu_system_cond;
3878static QemuCond qemu_pause_cond;
3879
3880static void block_io_signals(void);
3881static void unblock_io_signals(void);
3882static int tcg_has_work(void);
3883
3884static int qemu_init_main_loop(void)
3885{
3886 int ret;
3887
3888 ret = qemu_event_init();
3889 if (ret)
3890 return ret;
3891
3892 qemu_cond_init(&qemu_pause_cond);
3893 qemu_mutex_init(&qemu_fair_mutex);
3894 qemu_mutex_init(&qemu_global_mutex);
3895 qemu_mutex_lock(&qemu_global_mutex);
3896
3897 unblock_io_signals();
3898 qemu_thread_self(&io_thread);
3899
3900 return 0;
3901}
3902
3903static void qemu_wait_io_event(CPUState *env)
3904{
3905 while (!tcg_has_work())
3906 qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3907
3908 qemu_mutex_unlock(&qemu_global_mutex);
3909
3910 /*
3911 * Users of qemu_global_mutex can be starved, having no chance
3912 * to acquire it since this path will get to it first.
3913 * So use another lock to provide fairness.
3914 */
3915 qemu_mutex_lock(&qemu_fair_mutex);
3916 qemu_mutex_unlock(&qemu_fair_mutex);
3917
3918 qemu_mutex_lock(&qemu_global_mutex);
3919 if (env->stop) {
3920 env->stop = 0;
3921 env->stopped = 1;
3922 qemu_cond_signal(&qemu_pause_cond);
3923 }
3924}
3925
3926static int qemu_cpu_exec(CPUState *env);
3927
3928static void *kvm_cpu_thread_fn(void *arg)
3929{
3930 CPUState *env = arg;
3931
3932 block_io_signals();
3933 qemu_thread_self(env->thread);
3934
3935 /* signal CPU creation */
3936 qemu_mutex_lock(&qemu_global_mutex);
3937 env->created = 1;
3938 qemu_cond_signal(&qemu_cpu_cond);
3939
3940 /* and wait for machine initialization */
3941 while (!qemu_system_ready)
3942 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3943
3944 while (1) {
3945 if (cpu_can_run(env))
3946 qemu_cpu_exec(env);
3947 qemu_wait_io_event(env);
3948 }
3949
3950 return NULL;
3951}
3952
3953static void tcg_cpu_exec(void);
3954
3955static void *tcg_cpu_thread_fn(void *arg)
3956{
3957 CPUState *env = arg;
3958
3959 block_io_signals();
3960 qemu_thread_self(env->thread);
3961
3962 /* signal CPU creation */
3963 qemu_mutex_lock(&qemu_global_mutex);
3964 for (env = first_cpu; env != NULL; env = env->next_cpu)
3965 env->created = 1;
3966 qemu_cond_signal(&qemu_cpu_cond);
3967
3968 /* and wait for machine initialization */
3969 while (!qemu_system_ready)
3970 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3971
3972 while (1) {
3973 tcg_cpu_exec();
3974 qemu_wait_io_event(cur_cpu);
3975 }
3976
3977 return NULL;
3978}
3979
3980void qemu_cpu_kick(void *_env)
3981{
3982 CPUState *env = _env;
3983 qemu_cond_broadcast(env->halt_cond);
3984 if (kvm_enabled())
3985 qemu_thread_signal(env->thread, SIGUSR1);
3986}
3987
3988int qemu_cpu_self(void *env)
3989{
3990 return (cpu_single_env != NULL);
3991}
3992
3993static void cpu_signal(int sig)
3994{
3995 if (cpu_single_env)
3996 cpu_exit(cpu_single_env);
3997}
3998
3999static void block_io_signals(void)
4000{
4001 sigset_t set;
4002 struct sigaction sigact;
4003
4004 sigemptyset(&set);
4005 sigaddset(&set, SIGUSR2);
4006 sigaddset(&set, SIGIO);
4007 sigaddset(&set, SIGALRM);
4008 pthread_sigmask(SIG_BLOCK, &set, NULL);
4009
4010 sigemptyset(&set);
4011 sigaddset(&set, SIGUSR1);
4012 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4013
4014 memset(&sigact, 0, sizeof(sigact));
4015 sigact.sa_handler = cpu_signal;
4016 sigaction(SIGUSR1, &sigact, NULL);
4017}
4018
4019static void unblock_io_signals(void)
4020{
4021 sigset_t set;
4022
4023 sigemptyset(&set);
4024 sigaddset(&set, SIGUSR2);
4025 sigaddset(&set, SIGIO);
4026 sigaddset(&set, SIGALRM);
4027 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4028
4029 sigemptyset(&set);
4030 sigaddset(&set, SIGUSR1);
4031 pthread_sigmask(SIG_BLOCK, &set, NULL);
4032}
4033
4034static void qemu_signal_lock(unsigned int msecs)
4035{
4036 qemu_mutex_lock(&qemu_fair_mutex);
4037
4038 while (qemu_mutex_trylock(&qemu_global_mutex)) {
4039 qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
4040 if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
4041 break;
4042 }
4043 qemu_mutex_unlock(&qemu_fair_mutex);
4044}
4045
4046static void qemu_mutex_lock_iothread(void)
4047{
4048 if (kvm_enabled()) {
4049 qemu_mutex_lock(&qemu_fair_mutex);
4050 qemu_mutex_lock(&qemu_global_mutex);
4051 qemu_mutex_unlock(&qemu_fair_mutex);
4052 } else
4053 qemu_signal_lock(100);
4054}
4055
4056static void qemu_mutex_unlock_iothread(void)
4057{
4058 qemu_mutex_unlock(&qemu_global_mutex);
4059}
4060
4061static int all_vcpus_paused(void)
4062{
4063 CPUState *penv = first_cpu;
4064
4065 while (penv) {
4066 if (!penv->stopped)
4067 return 0;
4068 penv = (CPUState *)penv->next_cpu;
4069 }
4070
4071 return 1;
4072}
4073
4074static void pause_all_vcpus(void)
4075{
4076 CPUState *penv = first_cpu;
4077
4078 while (penv) {
4079 penv->stop = 1;
4080 qemu_thread_signal(penv->thread, SIGUSR1);
4081 qemu_cpu_kick(penv);
4082 penv = (CPUState *)penv->next_cpu;
4083 }
4084
4085 while (!all_vcpus_paused()) {
4086 qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
4087 penv = first_cpu;
4088 while (penv) {
4089 qemu_thread_signal(penv->thread, SIGUSR1);
4090 penv = (CPUState *)penv->next_cpu;
4091 }
4092 }
4093}
4094
4095static void resume_all_vcpus(void)
4096{
4097 CPUState *penv = first_cpu;
4098
4099 while (penv) {
4100 penv->stop = 0;
4101 penv->stopped = 0;
4102 qemu_thread_signal(penv->thread, SIGUSR1);
4103 qemu_cpu_kick(penv);
4104 penv = (CPUState *)penv->next_cpu;
4105 }
4106}
4107
4108static void tcg_init_vcpu(void *_env)
4109{
4110 CPUState *env = _env;
4111 /* share a single thread for all cpus with TCG */
4112 if (!tcg_cpu_thread) {
4113 env->thread = qemu_mallocz(sizeof(QemuThread));
4114 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4115 qemu_cond_init(env->halt_cond);
4116 qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
4117 while (env->created == 0)
4118 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4119 tcg_cpu_thread = env->thread;
4120 tcg_halt_cond = env->halt_cond;
4121 } else {
4122 env->thread = tcg_cpu_thread;
4123 env->halt_cond = tcg_halt_cond;
4124 }
4125}
4126
4127static void kvm_start_vcpu(CPUState *env)
4128{
4129 kvm_init_vcpu(env);
4130 env->thread = qemu_mallocz(sizeof(QemuThread));
4131 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4132 qemu_cond_init(env->halt_cond);
4133 qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
4134 while (env->created == 0)
4135 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4136}
4137
4138void qemu_init_vcpu(void *_env)
4139{
4140 CPUState *env = _env;
4141
4142 if (kvm_enabled())
4143 kvm_start_vcpu(env);
4144 else
4145 tcg_init_vcpu(env);
4146}
4147
4148void qemu_notify_event(void)
4149{
4150 qemu_event_increment();
4151}
4152
4153void vm_stop(int reason)
4154{
4155 QemuThread me;
4156 qemu_thread_self(&me);
4157
4158 if (!qemu_thread_equal(&me, &io_thread)) {
4159 qemu_system_vmstop_request(reason);
4160 /*
4161 * FIXME: should not return to device code in case
4162 * vm_stop() has been requested.
4163 */
4164 if (cpu_single_env) {
4165 cpu_exit(cpu_single_env);
4166 cpu_single_env->stop = 1;
4167 }
4168 return;
4169 }
4170 do_vm_stop(reason);
4171}
4172
4173#endif
4174
4175
877cf882 4176#ifdef _WIN32
69d6451c 4177static void host_main_loop_wait(int *timeout)
56f3a5d0
AL		 4178{
4179 int ret, ret2, i;
f331110f
FB		 4180 PollingEntry *pe;
4181
c4b1fcc0 4182
f331110f
FB		 4183 /* XXX: need to suppress polling by better using win32 events */
4184 ret = 0;
4185 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
4186 ret |= pe->func(pe->opaque);
4187 }
e6b1e558 4188 if (ret == 0) {
a18e524a
FB		 4189 int err;
4190 WaitObjects *w = &wait_objects;
3b46e624 4191
56f3a5d0 4192 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
a18e524a
FB		 4193 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
4194 if (w->func[ret - WAIT_OBJECT_0])
4195 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3b46e624 4196
5fafdf24 4197 /* Check for additional signaled events */
e6b1e558 4198 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3b46e624 4199
e6b1e558
TS		 4200 /* Check if event is signaled */
4201 ret2 = WaitForSingleObject(w->events[i], 0);
4202 if(ret2 == WAIT_OBJECT_0) {
4203 if (w->func[i])
4204 w->func[i](w->opaque[i]);
4205 } else if (ret2 == WAIT_TIMEOUT) {
4206 } else {
4207 err = GetLastError();
4208 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3b46e624
TS		 4209 }
4210 }
a18e524a
FB		 4211 } else if (ret == WAIT_TIMEOUT) {
4212 } else {
4213 err = GetLastError();
e6b1e558 4214 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
a18e524a 4215 }
f331110f 4216 }
56f3a5d0
AL		 4217
4218 *timeout = 0;
4219}
4220#else
69d6451c 4221static void host_main_loop_wait(int *timeout)
56f3a5d0
AL		 4222{
4223}
fd1dff4b 4224#endif
56f3a5d0
AL		 4225
4226void main_loop_wait(int timeout)
4227{
4228 IOHandlerRecord *ioh;
4229 fd_set rfds, wfds, xfds;
4230 int ret, nfds;
4231 struct timeval tv;
4232
4233 qemu_bh_update_timeout(&timeout);
4234
4235 host_main_loop_wait(&timeout);
4236
fd1dff4b
FB		 4237 /* poll any events */
4238 /* XXX: separate device handlers from system ones */
6abfbd79 4239 nfds = -1;
fd1dff4b
FB		 4240 FD_ZERO(&rfds);
4241 FD_ZERO(&wfds);
e035649e 4242 FD_ZERO(&xfds);
fd1dff4b 4243 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
cafffd40
TS		 4244 if (ioh->deleted)
4245 continue;
fd1dff4b
FB		 4246 if (ioh->fd_read &&
4247 (!ioh->fd_read_poll ||
4248 ioh->fd_read_poll(ioh->opaque) != 0)) {
4249 FD_SET(ioh->fd, &rfds);
4250 if (ioh->fd > nfds)
4251 nfds = ioh->fd;
4252 }
4253 if (ioh->fd_write) {
4254 FD_SET(ioh->fd, &wfds);
4255 if (ioh->fd > nfds)
4256 nfds = ioh->fd;
4257 }
4258 }
3b46e624 4259
56f3a5d0
AL		 4260 tv.tv_sec = timeout / 1000;
4261 tv.tv_usec = (timeout % 1000) * 1000;
4262
d918f23e
JK		 4263 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4264
4870852c 4265 qemu_mutex_unlock_iothread();
e035649e 4266 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4870852c 4267 qemu_mutex_lock_iothread();
fd1dff4b 4268 if (ret > 0) {
cafffd40
TS		 4269 IOHandlerRecord **pioh;
4270
4271 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6ab43fdc 4272 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
fd1dff4b 4273 ioh->fd_read(ioh->opaque);
7c9d8e07 4274 }
6ab43fdc 4275 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
fd1dff4b 4276 ioh->fd_write(ioh->opaque);
c4b1fcc0 4277 }
b4608c04 4278 }
cafffd40
TS		 4279
4280 /* remove deleted IO handlers */
4281 pioh = &first_io_handler;
4282 while (*pioh) {
4283 ioh = *pioh;
4284 if (ioh->deleted) {
4285 *pioh = ioh->next;
4286 qemu_free(ioh);
5fafdf24 4287 } else
cafffd40
TS		 4288 pioh = &ioh->next;
4289 }
fd1dff4b 4290 }
d918f23e
JK		 4291
4292 slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
b4608c04 4293
50317c7f
AL		 4294 /* rearm timer, if not periodic */
4295 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
4296 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
4297 qemu_rearm_alarm_timer(alarm_timer);
4298 }
4299
357c692c 4300 /* vm time timers */
d6dc3d42
AL		 4301 if (vm_running) {
4302 if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
4303 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4304 qemu_get_clock(vm_clock));
4305 }
357c692c
AL		 4306
4307 /* real time timers */
4308 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4309 qemu_get_clock(rt_clock));
4310
423f0742
PB		 4311 /* Check bottom-halves last in case any of the earlier events triggered
4312 them. */
4313 qemu_bh_poll();
3b46e624 4314
5905b2e5
FB		 4315}
4316
43b96858 4317static int qemu_cpu_exec(CPUState *env)
5905b2e5 4318{
43b96858 4319 int ret;
89bfc105
FB		 4320#ifdef CONFIG_PROFILER
4321 int64_t ti;
4322#endif
5905b2e5 4323
89bfc105 4324#ifdef CONFIG_PROFILER
43b96858 4325 ti = profile_getclock();
89bfc105 4326#endif
43b96858
AL		 4327 if (use_icount) {
4328 int64_t count;
4329 int decr;
4330 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
4331 env->icount_decr.u16.low = 0;
4332 env->icount_extra = 0;
4333 count = qemu_next_deadline();
4334 count = (count + (1 << icount_time_shift) - 1)
4335 >> icount_time_shift;
4336 qemu_icount += count;
4337 decr = (count > 0xffff) ? 0xffff : count;
4338 count -= decr;
4339 env->icount_decr.u16.low = decr;
4340 env->icount_extra = count;
4341 }
4342 ret = cpu_exec(env);
89bfc105 4343#ifdef CONFIG_PROFILER
43b96858 4344 qemu_time += profile_getclock() - ti;
89bfc105 4345#endif
43b96858
AL		 4346 if (use_icount) {
4347 /* Fold pending instructions back into the
4348 instruction counter, and clear the interrupt flag. */
4349 qemu_icount -= (env->icount_decr.u16.low
4350 + env->icount_extra);
4351 env->icount_decr.u32 = 0;
4352 env->icount_extra = 0;
4353 }
4354 return ret;
4355}
4356
e6e35b1e
AL		 4357static void tcg_cpu_exec(void)
4358{
d6dc3d42 4359 int ret = 0;
e6e35b1e
AL		 4360
4361 if (next_cpu == NULL)
4362 next_cpu = first_cpu;
4363 for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4364 CPUState *env = cur_cpu = next_cpu;
4365
4366 if (!vm_running)
4367 break;
4368 if (timer_alarm_pending) {
4369 timer_alarm_pending = 0;
4370 break;
4371 }
d6dc3d42
AL		 4372 if (cpu_can_run(env))
4373 ret = qemu_cpu_exec(env);
e6e35b1e
AL		 4374 if (ret == EXCP_DEBUG) {
4375 gdb_set_stop_cpu(env);
4376 debug_requested = 1;
4377 break;
4378 }
4379 }
4380}
4381
43b96858
AL		 4382static int cpu_has_work(CPUState *env)
4383{
d6dc3d42
AL		 4384 if (env->stop)
4385 return 1;
4386 if (env->stopped)
4387 return 0;
43b96858
AL		 4388 if (!env->halted)
4389 return 1;
4390 if (qemu_cpu_has_work(env))
4391 return 1;
4392 return 0;
4393}
4394
4395static int tcg_has_work(void)
4396{
4397 CPUState *env;
4398
4399 for (env = first_cpu; env != NULL; env = env->next_cpu)
4400 if (cpu_has_work(env))
4401 return 1;
4402 return 0;
4403}
4404
4405static int qemu_calculate_timeout(void)
4406{
b319820d 4407#ifndef CONFIG_IOTHREAD
43b96858
AL		 4408 int timeout;
4409
4410 if (!vm_running)
4411 timeout = 5000;
4412 else if (tcg_has_work())
4413 timeout = 0;
4414 else if (!use_icount)
4415 timeout = 5000;
4416 else {
4417 /* XXX: use timeout computed from timers */
4418 int64_t add;
4419 int64_t delta;
4420 /* Advance virtual time to the next event. */
4421 if (use_icount == 1) {
4422 /* When not using an adaptive execution frequency
4423 we tend to get badly out of sync with real time,
4424 so just delay for a reasonable amount of time. */
4425 delta = 0;
4426 } else {
4427 delta = cpu_get_icount() - cpu_get_clock();
4428 }
4429 if (delta > 0) {
4430 /* If virtual time is ahead of real time then just
4431 wait for IO. */
4432 timeout = (delta / 1000000) + 1;
4433 } else {
4434 /* Wait for either IO to occur or the next
4435 timer event. */
4436 add = qemu_next_deadline();
4437 /* We advance the timer before checking for IO.
4438 Limit the amount we advance so that early IO
4439 activity won't get the guest too far ahead. */
4440 if (add > 10000000)
4441 add = 10000000;
4442 delta += add;
4443 add = (add + (1 << icount_time_shift) - 1)
4444 >> icount_time_shift;
4445 qemu_icount += add;
4446 timeout = delta / 1000000;
4447 if (timeout < 0)
4448 timeout = 0;
4449 }
4450 }
4451
4452 return timeout;
b319820d
LC		 4453#else /* CONFIG_IOTHREAD */
4454 return 1000;
4455#endif
43b96858
AL		 4456}
4457
4458static int vm_can_run(void)
4459{
4460 if (powerdown_requested)
4461 return 0;
4462 if (reset_requested)
4463 return 0;
4464 if (shutdown_requested)
4465 return 0;
e568902a
AL		 4466 if (debug_requested)
4467 return 0;
43b96858
AL		 4468 return 1;
4469}
4470
4471static void main_loop(void)
4472{
6e29f5da 4473 int r;
e6e35b1e 4474
d6dc3d42
AL		 4475#ifdef CONFIG_IOTHREAD
4476 qemu_system_ready = 1;
4477 qemu_cond_broadcast(&qemu_system_cond);
4478#endif
4479
6e29f5da 4480 for (;;) {
43b96858 4481 do {
e6e35b1e
AL		 4482#ifdef CONFIG_PROFILER
4483 int64_t ti;
4484#endif
d6dc3d42 4485#ifndef CONFIG_IOTHREAD
e6e35b1e 4486 tcg_cpu_exec();
d6dc3d42 4487#endif
89bfc105 4488#ifdef CONFIG_PROFILER
43b96858 4489 ti = profile_getclock();
89bfc105 4490#endif
43b96858 4491 main_loop_wait(qemu_calculate_timeout());
89bfc105 4492#ifdef CONFIG_PROFILER
43b96858 4493 dev_time += profile_getclock() - ti;
89bfc105 4494#endif
e568902a 4495 } while (vm_can_run());
43b96858 4496
e568902a
AL		 4497 if (qemu_debug_requested())
4498 vm_stop(EXCP_DEBUG);
43b96858
AL		 4499 if (qemu_shutdown_requested()) {
4500 if (no_shutdown) {
4501 vm_stop(0);
4502 no_shutdown = 0;
4503 } else
4504 break;
4505 }
d6dc3d42
AL		 4506 if (qemu_reset_requested()) {
4507 pause_all_vcpus();
43b96858 4508 qemu_system_reset();
d6dc3d42
AL		 4509 resume_all_vcpus();
4510 }
43b96858
AL		 4511 if (qemu_powerdown_requested())
4512 qemu_system_powerdown();
6e29f5da
AL		 4513 if ((r = qemu_vmstop_requested()))
4514 vm_stop(r);
b4608c04 4515 }
d6dc3d42 4516 pause_all_vcpus();
b4608c04
FB		 4517}
4518
9bd7e6d9
PB		 4519static void version(void)
4520{
4a19f1ec 4521 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
9bd7e6d9
PB		 4522}
4523
15f82208 4524static void help(int exitcode)
0824d6fc 4525{
9bd7e6d9
PB		 4526 version();
4527 printf("usage: %s [options] [disk_image]\n"
0824d6fc 4528 "\n"
a20dd508 4529 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
fc01f7e7 4530 "\n"
5824d651
BS		 4531#define DEF(option, opt_arg, opt_enum, opt_help) \
4532 opt_help
4533#define DEFHEADING(text) stringify(text) "\n"
4534#include "qemu-options.h"
4535#undef DEF
4536#undef DEFHEADING
4537#undef GEN_DOCS
0824d6fc 4538 "\n"
82c643ff 4539 "During emulation, the following keys are useful:\n"
032a8c9e
FB		 4540 "ctrl-alt-f toggle full screen\n"
4541 "ctrl-alt-n switch to virtual console 'n'\n"
4542 "ctrl-alt toggle mouse and keyboard grab\n"
82c643ff
FB		 4543 "\n"
4544 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4545 ,
0db63474 4546 "qemu",
a00bad7e 4547 DEFAULT_RAM_SIZE,
7c9d8e07 4548#ifndef _WIN32
a00bad7e 4549 DEFAULT_NETWORK_SCRIPT,
b46a8906 4550 DEFAULT_NETWORK_DOWN_SCRIPT,
7c9d8e07 4551#endif
6e44ba7f 4552 DEFAULT_GDBSTUB_PORT,
bce61846 4553 "/tmp/qemu.log");
15f82208 4554 exit(exitcode);
0824d6fc
FB		 4555}
4556
cd6f1169
FB		 4557#define HAS_ARG 0x0001
4558
4559enum {
5824d651
BS		 4560#define DEF(option, opt_arg, opt_enum, opt_help) \
4561 opt_enum,
4562#define DEFHEADING(text)
4563#include "qemu-options.h"
4564#undef DEF
4565#undef DEFHEADING
4566#undef GEN_DOCS
cd6f1169
FB		 4567};
4568
4569typedef struct QEMUOption {
4570 const char *name;
4571 int flags;
4572 int index;
4573} QEMUOption;
4574
dbed7e40 4575static const QEMUOption qemu_options[] = {
cd6f1169 4576 { "h", 0, QEMU_OPTION_h },
5824d651
BS		 4577#define DEF(option, opt_arg, opt_enum, opt_help) \
4578 { option, opt_arg, opt_enum },
4579#define DEFHEADING(text)
4580#include "qemu-options.h"
4581#undef DEF
4582#undef DEFHEADING
4583#undef GEN_DOCS
cd6f1169 4584 { NULL },
fc01f7e7
FB		 4585};
4586
1d14ffa9 4587#ifdef HAS_AUDIO
6a36d84e 4588struct soundhw soundhw[] = {
b00052e4 4589#ifdef HAS_AUDIO_CHOICE
4ce7ff6e 4590#if defined(TARGET_I386) || defined(TARGET_MIPS)
fd06c375
FB		 4591 {
4592 "pcspk",
4593 "PC speaker",
4594 0,
4595 1,
4596 { .init_isa = pcspk_audio_init }
4597 },
4598#endif
4c9b53e3 4599
4600#ifdef CONFIG_SB16
6a36d84e
FB		 4601 {
4602 "sb16",
4603 "Creative Sound Blaster 16",
4604 0,
4605 1,
4606 { .init_isa = SB16_init }
4607 },
4c9b53e3 4608#endif
6a36d84e 4609
cc53d26d 4610#ifdef CONFIG_CS4231A
4611 {
4612 "cs4231a",
4613 "CS4231A",
4614 0,
4615 1,
4616 { .init_isa = cs4231a_init }
4617 },
4618#endif
4619
1d14ffa9 4620#ifdef CONFIG_ADLIB
6a36d84e
FB		 4621 {
4622 "adlib",
1d14ffa9 4623#ifdef HAS_YMF262
6a36d84e 4624 "Yamaha YMF262 (OPL3)",
1d14ffa9 4625#else
6a36d84e 4626 "Yamaha YM3812 (OPL2)",
1d14ffa9 4627#endif
6a36d84e
FB		 4628 0,
4629 1,
4630 { .init_isa = Adlib_init }
4631 },
1d14ffa9 4632#endif
6a36d84e 4633
1d14ffa9 4634#ifdef CONFIG_GUS
6a36d84e
FB		 4635 {
4636 "gus",
4637 "Gravis Ultrasound GF1",
4638 0,
4639 1,
4640 { .init_isa = GUS_init }
4641 },
1d14ffa9 4642#endif
6a36d84e 4643
4c9b53e3 4644#ifdef CONFIG_AC97
e5c9a13e
AZ		 4645 {
4646 "ac97",
4647 "Intel 82801AA AC97 Audio",
4648 0,
4649 0,
4650 { .init_pci = ac97_init }
4651 },
4c9b53e3 4652#endif
e5c9a13e 4653
4c9b53e3 4654#ifdef CONFIG_ES1370
6a36d84e
FB		 4655 {
4656 "es1370",
4657 "ENSONIQ AudioPCI ES1370",
4658 0,
4659 0,
4660 { .init_pci = es1370_init }
4661 },
b00052e4 4662#endif
6a36d84e 4663
4c9b53e3 4664#endif /* HAS_AUDIO_CHOICE */
4665
6a36d84e
FB		 4666 { NULL, NULL, 0, 0, { NULL } }
4667};
4668
4669static void select_soundhw (const char *optarg)
4670{
4671 struct soundhw *c;
4672
4673 if (*optarg == '?') {
4674 show_valid_cards:
4675
4676 printf ("Valid sound card names (comma separated):\n");
4677 for (c = soundhw; c->name; ++c) {
4678 printf ("%-11s %s\n", c->name, c->descr);
4679 }
4680 printf ("\n-soundhw all will enable all of the above\n");
1d14ffa9
FB		 4681 exit (*optarg != '?');
4682 }
4683 else {
6a36d84e 4684 size_t l;
1d14ffa9
FB		 4685 const char *p;
4686 char *e;
4687 int bad_card = 0;
4688
6a36d84e
FB		 4689 if (!strcmp (optarg, "all")) {
4690 for (c = soundhw; c->name; ++c) {
4691 c->enabled = 1;
4692 }
4693 return;
4694 }
1d14ffa9 4695
6a36d84e 4696 p = optarg;
1d14ffa9
FB		 4697 while (*p) {
4698 e = strchr (p, ',');
4699 l = !e ? strlen (p) : (size_t) (e - p);
6a36d84e
FB		 4700
4701 for (c = soundhw; c->name; ++c) {
4702 if (!strncmp (c->name, p, l)) {
4703 c->enabled = 1;
1d14ffa9
FB		 4704 break;
4705 }
4706 }
6a36d84e
FB		 4707
4708 if (!c->name) {
1d14ffa9
FB		 4709 if (l > 80) {
4710 fprintf (stderr,
4711 "Unknown sound card name (too big to show)\n");
4712 }
4713 else {
4714 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4715 (int) l, p);
4716 }
4717 bad_card = 1;
4718 }
4719 p += l + (e != NULL);
4720 }
4721
4722 if (bad_card)
4723 goto show_valid_cards;
4724 }
4725}
4726#endif
4727
3893c124 4728static void select_vgahw (const char *p)
4729{
4730 const char *opts;
4731
28b85ed8
AL		 4732 cirrus_vga_enabled = 0;
4733 std_vga_enabled = 0;
4734 vmsvga_enabled = 0;
94909d9f 4735 xenfb_enabled = 0;
3893c124 4736 if (strstart(p, "std", &opts)) {
c2b3b41a 4737 std_vga_enabled = 1;
3893c124 4738 } else if (strstart(p, "cirrus", &opts)) {
4739 cirrus_vga_enabled = 1;
3893c124 4740 } else if (strstart(p, "vmware", &opts)) {
3893c124 4741 vmsvga_enabled = 1;
94909d9f
AL		 4742 } else if (strstart(p, "xenfb", &opts)) {
4743 xenfb_enabled = 1;
28b85ed8 4744 } else if (!strstart(p, "none", &opts)) {
3893c124 4745 invalid_vga:
4746 fprintf(stderr, "Unknown vga type: %s\n", p);
4747 exit(1);
4748 }
cb5a7aa8 4749 while (*opts) {
4750 const char *nextopt;
4751
4752 if (strstart(opts, ",retrace=", &nextopt)) {
4753 opts = nextopt;
4754 if (strstart(opts, "dumb", &nextopt))
4755 vga_retrace_method = VGA_RETRACE_DUMB;
4756 else if (strstart(opts, "precise", &nextopt))
4757 vga_retrace_method = VGA_RETRACE_PRECISE;
4758 else goto invalid_vga;
4759 } else goto invalid_vga;
4760 opts = nextopt;
4761 }
3893c124 4762}
4763
7d4c3d53
MA		 4764#ifdef TARGET_I386
4765static int balloon_parse(const char *arg)
4766{
4767 char buf[128];
4768 const char *p;
4769
4770 if (!strcmp(arg, "none")) {
4771 virtio_balloon = 0;
4772 } else if (!strncmp(arg, "virtio", 6)) {
4773 virtio_balloon = 1;
4774 if (arg[6] == ',') {
4775 p = arg + 7;
4776 if (get_param_value(buf, sizeof(buf), "addr", p)) {
4777 virtio_balloon_devaddr = strdup(buf);
4778 }
4779 }
4780 } else {
4781 return -1;
4782 }
4783 return 0;
4784}
4785#endif
4786
3587d7e6
FB		 4787#ifdef _WIN32
4788static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4789{
4790 exit(STATUS_CONTROL_C_EXIT);
4791 return TRUE;
4792}
4793#endif
4794
c4be29ff 4795int qemu_uuid_parse(const char *str, uint8_t *uuid)
8fcb1b90
BS		 4796{
4797 int ret;
4798
4799 if(strlen(str) != 36)
4800 return -1;
4801
4802 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4803 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4804 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4805
4806 if(ret != 16)
4807 return -1;
4808
b6f6e3d3
AL		 4809#ifdef TARGET_I386
4810 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4811#endif
4812
8fcb1b90
BS		 4813 return 0;
4814}
4815
7c9d8e07 4816#define MAX_NET_CLIENTS 32
c20709aa 4817
5b08fc10
AL		 4818#ifndef _WIN32
4819
4820static void termsig_handler(int signal)
4821{
4822 qemu_system_shutdown_request();
4823}
4824
7c3370d4
JK		 4825static void sigchld_handler(int signal)
4826{
4827 waitpid(-1, NULL, WNOHANG);
4828}
4829
4830static void sighandler_setup(void)
5b08fc10
AL		 4831{
4832 struct sigaction act;
4833
4834 memset(&act, 0, sizeof(act));
4835 act.sa_handler = termsig_handler;
4836 sigaction(SIGINT, &act, NULL);
4837 sigaction(SIGHUP, &act, NULL);
4838 sigaction(SIGTERM, &act, NULL);
7c3370d4
JK		 4839
4840 act.sa_handler = sigchld_handler;
4841 act.sa_flags = SA_NOCLDSTOP;
4842 sigaction(SIGCHLD, &act, NULL);
5b08fc10
AL		 4843}
4844
4845#endif
4846
5cea8590
PB		 4847#ifdef _WIN32
4848/* Look for support files in the same directory as the executable. */
4849static char *find_datadir(const char *argv0)
4850{
4851 char *p;
4852 char buf[MAX_PATH];
4853 DWORD len;
4854
4855 len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4856 if (len == 0) {
c5947808 4857 return NULL;
5cea8590
PB		 4858 }
4859
4860 buf[len] = 0;
4861 p = buf + len - 1;
4862 while (p != buf && *p != '\\')
4863 p--;
4864 *p = 0;
4865 if (access(buf, R_OK) == 0) {
4866 return qemu_strdup(buf);
4867 }
4868 return NULL;
4869}
4870#else /* !_WIN32 */
4871
4872/* Find a likely location for support files using the location of the binary.
4873 For installed binaries this will be "$bindir/../share/qemu". When
4874 running from the build tree this will be "$bindir/../pc-bios". */
4875#define SHARE_SUFFIX "/share/qemu"
4876#define BUILD_SUFFIX "/pc-bios"
4877static char *find_datadir(const char *argv0)
4878{
4879 char *dir;
4880 char *p = NULL;
4881 char *res;
4882#ifdef PATH_MAX
4883 char buf[PATH_MAX];
4884#endif
3a41759d 4885 size_t max_len;
5cea8590
PB		 4886
4887#if defined(__linux__)
4888 {
4889 int len;
4890 len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4891 if (len > 0) {
4892 buf[len] = 0;
4893 p = buf;
4894 }
4895 }
4896#elif defined(__FreeBSD__)
4897 {
4898 int len;
4899 len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4900 if (len > 0) {
4901 buf[len] = 0;
4902 p = buf;
4903 }
4904 }
4905#endif
4906 /* If we don't have any way of figuring out the actual executable
4907 location then try argv[0]. */
4908 if (!p) {
4909#ifdef PATH_MAX
4910 p = buf;
4911#endif
4912 p = realpath(argv0, p);
4913 if (!p) {
4914 return NULL;
4915 }
4916 }
4917 dir = dirname(p);
4918 dir = dirname(dir);
4919
3a41759d
BS		 4920 max_len = strlen(dir) +
4921 MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4922 res = qemu_mallocz(max_len);
4923 snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
5cea8590 4924 if (access(res, R_OK)) {
3a41759d 4925 snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
5cea8590
PB		 4926 if (access(res, R_OK)) {
4927 qemu_free(res);
4928 res = NULL;
4929 }
4930 }
4931#ifndef PATH_MAX
4932 free(p);
4933#endif
4934 return res;
4935}
4936#undef SHARE_SUFFIX
4937#undef BUILD_SUFFIX
4938#endif
4939
4940char *qemu_find_file(int type, const char *name)
4941{
4942 int len;
4943 const char *subdir;
4944 char *buf;
4945
4946 /* If name contains path separators then try it as a straight path. */
4947 if ((strchr(name, '/') || strchr(name, '\\'))
4948 && access(name, R_OK) == 0) {
4949 return strdup(name);
4950 }
4951 switch (type) {
4952 case QEMU_FILE_TYPE_BIOS:
4953 subdir = "";
4954 break;
4955 case QEMU_FILE_TYPE_KEYMAP:
4956 subdir = "keymaps/";
4957 break;
4958 default:
4959 abort();
4960 }
4961 len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4962 buf = qemu_mallocz(len);
3a41759d 4963 snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
5cea8590
PB		 4964 if (access(buf, R_OK)) {
4965 qemu_free(buf);
4966 return NULL;
4967 }
4968 return buf;
4969}
4970
902b3d5c 4971int main(int argc, char **argv, char **envp)
0824d6fc 4972{
59030a8c 4973 const char *gdbstub_dev = NULL;
28c5af54 4974 uint32_t boot_devices_bitmap = 0;
e4bcb14c 4975 int i;
28c5af54 4976 int snapshot, linux_boot, net_boot;
7f7f9873 4977 const char *initrd_filename;
a20dd508 4978 const char *kernel_filename, *kernel_cmdline;
28c5af54 4979 const char *boot_devices = "";
3023f332 4980 DisplayState *ds;
7d957bd8 4981 DisplayChangeListener *dcl;
46d4767d 4982 int cyls, heads, secs, translation;
fd5f393a 4983 const char *net_clients[MAX_NET_CLIENTS];
7c9d8e07 4984 int nb_net_clients;
dc72ac14
AZ		 4985 const char *bt_opts[MAX_BT_CMDLINE];
4986 int nb_bt_opts;
e4bcb14c 4987 int hda_index;
cd6f1169
FB		 4988 int optind;
4989 const char *r, *optarg;
4c621805 4990 CharDriverState *monitor_hd = NULL;
fd5f393a
PB		 4991 const char *monitor_device;
4992 const char *serial_devices[MAX_SERIAL_PORTS];
8d11df9e 4993 int serial_device_index;
fd5f393a 4994 const char *parallel_devices[MAX_PARALLEL_PORTS];
6508fe59 4995 int parallel_device_index;
9ede2fde
AL		 4996 const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4997 int virtio_console_index;
d63d307f 4998 const char *loadvm = NULL;
cc1daa40 4999 QEMUMachine *machine;
94fc95cd 5000 const char *cpu_model;
fd5f393a 5001 const char *usb_devices[MAX_USB_CMDLINE];
a594cfbf 5002 int usb_devices_index;
b9e82a59 5003#ifndef _WIN32
71e3ceb8 5004 int fds[2];
b9e82a59 5005#endif
26a5f13b 5006 int tb_size;
93815bc2 5007 const char *pid_file = NULL;
5bb7910a 5008 const char *incoming = NULL;
b9e82a59 5009#ifndef _WIN32
54042bcf
AL		 5010 int fd = 0;
5011 struct passwd *pwd = NULL;
0858532e
AL		 5012 const char *chroot_dir = NULL;
5013 const char *run_as = NULL;
b9e82a59 5014#endif
268a362c 5015 CPUState *env;
993fbfdb 5016 int show_vnc_port = 0;
0bd48850 5017
902b3d5c 5018 qemu_cache_utils_init(envp);
5019
0bd48850 5020 LIST_INIT (&vm_change_state_head);
be995c27
FB		 5021#ifndef _WIN32
5022 {
5023 struct sigaction act;
5024 sigfillset(&act.sa_mask);
5025 act.sa_flags = 0;
5026 act.sa_handler = SIG_IGN;
5027 sigaction(SIGPIPE, &act, NULL);
5028 }
3587d7e6
FB		 5029#else
5030 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
a8e5ac33
FB		 5031 /* Note: cpu_interrupt() is currently not SMP safe, so we force
5032 QEMU to run on a single CPU */
5033 {
5034 HANDLE h;
5035 DWORD mask, smask;
5036 int i;
5037 h = GetCurrentProcess();
5038 if (GetProcessAffinityMask(h, &mask, &smask)) {
5039 for(i = 0; i < 32; i++) {
5040 if (mask & (1 << i))
5041 break;
5042 }
5043 if (i != 32) {
5044 mask = 1 << i;
5045 SetProcessAffinityMask(h, mask);
5046 }
5047 }
5048 }
67b915a5 5049#endif
be995c27 5050
f80f9ec9 5051 module_call_init(MODULE_INIT_MACHINE);
0c257437 5052 machine = find_default_machine();
94fc95cd 5053 cpu_model = NULL;
fc01f7e7 5054 initrd_filename = NULL;
4fc5d071 5055 ram_size = 0;
33e3963e 5056 snapshot = 0;
a20dd508
FB		 5057 kernel_filename = NULL;
5058 kernel_cmdline = "";
c4b1fcc0 5059 cyls = heads = secs = 0;
46d4767d 5060 translation = BIOS_ATA_TRANSLATION_AUTO;
d47d13b9 5061 monitor_device = "vc:80Cx24C";
c4b1fcc0 5062
c75a823c 5063 serial_devices[0] = "vc:80Cx24C";
8d11df9e 5064 for(i = 1; i < MAX_SERIAL_PORTS; i++)
fd5f393a 5065 serial_devices[i] = NULL;
8d11df9e 5066 serial_device_index = 0;
3b46e624 5067
8290edda 5068 parallel_devices[0] = "vc:80Cx24C";
6508fe59 5069 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
fd5f393a 5070 parallel_devices[i] = NULL;
6508fe59 5071 parallel_device_index = 0;
3b46e624 5072
1b8fc811 5073 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
9ede2fde
AL		 5074 virtio_consoles[i] = NULL;
5075 virtio_console_index = 0;
5076
268a362c
AL		 5077 for (i = 0; i < MAX_NODES; i++) {
5078 node_mem[i] = 0;
5079 node_cpumask[i] = 0;
5080 }
5081
a594cfbf 5082 usb_devices_index = 0;
3b46e624 5083
7c9d8e07 5084 nb_net_clients = 0;
dc72ac14 5085 nb_bt_opts = 0;
e4bcb14c
TS		 5086 nb_drives = 0;
5087 nb_drives_opt = 0;
268a362c 5088 nb_numa_nodes = 0;
e4bcb14c 5089 hda_index = -1;
7c9d8e07
FB		 5090
5091 nb_nics = 0;
3b46e624 5092
26a5f13b 5093 tb_size = 0;
41bd639b
BS		 5094 autostart= 1;
5095
9dd986cc
RJ		 5096 register_watchdogs();
5097
cd6f1169 5098 optind = 1;
0824d6fc 5099 for(;;) {
cd6f1169 5100 if (optind >= argc)
0824d6fc 5101 break;
cd6f1169
FB		 5102 r = argv[optind];
5103 if (r[0] != '-') {
609497ab 5104 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
cd6f1169
FB		 5105 } else {
5106 const QEMUOption *popt;
5107
5108 optind++;
dff5efc8
PB		 5109 /* Treat --foo the same as -foo. */
5110 if (r[1] == '-')
5111 r++;
cd6f1169
FB		 5112 popt = qemu_options;
5113 for(;;) {
5114 if (!popt->name) {
5fafdf24 5115 fprintf(stderr, "%s: invalid option -- '%s'\n",
cd6f1169
FB		 5116 argv[0], r);
5117 exit(1);
5118 }
5119 if (!strcmp(popt->name, r + 1))
5120 break;
5121 popt++;
5122 }
5123 if (popt->flags & HAS_ARG) {
5124 if (optind >= argc) {
5125 fprintf(stderr, "%s: option '%s' requires an argument\n",
5126 argv[0], r);
5127 exit(1);
5128 }
5129 optarg = argv[optind++];
5130 } else {
5131 optarg = NULL;
5132 }
5133
5134 switch(popt->index) {
cc1daa40
FB		 5135 case QEMU_OPTION_M:
5136 machine = find_machine(optarg);
5137 if (!machine) {
5138 QEMUMachine *m;
5139 printf("Supported machines are:\n");
5140 for(m = first_machine; m != NULL; m = m->next) {
5141 printf("%-10s %s%s\n",
5fafdf24 5142 m->name, m->desc,
0c257437 5143 m->is_default ? " (default)" : "");
cc1daa40 5144 }
15f82208 5145 exit(*optarg != '?');
cc1daa40
FB		 5146 }
5147 break;
94fc95cd
JM		 5148 case QEMU_OPTION_cpu:
5149 /* hw initialization will check this */
15f82208 5150 if (*optarg == '?') {
c732abe2
JM		 5151/* XXX: implement xxx_cpu_list for targets that still miss it */
5152#if defined(cpu_list)
5153 cpu_list(stdout, &fprintf);
94fc95cd 5154#endif
15f82208 5155 exit(0);
94fc95cd
JM		 5156 } else {
5157 cpu_model = optarg;
5158 }
5159 break;
cd6f1169 5160 case QEMU_OPTION_initrd:
fc01f7e7
FB		 5161 initrd_filename = optarg;
5162 break;
cd6f1169 5163 case QEMU_OPTION_hda:
e4bcb14c 5164 if (cyls == 0)
609497ab 5165 hda_index = drive_add(optarg, HD_ALIAS, 0);
e4bcb14c 5166 else
609497ab 5167 hda_index = drive_add(optarg, HD_ALIAS
e4bcb14c 5168 ",cyls=%d,heads=%d,secs=%d%s",
609497ab 5169 0, cyls, heads, secs,
e4bcb14c
TS		 5170 translation == BIOS_ATA_TRANSLATION_LBA ?
5171 ",trans=lba" :
5172 translation == BIOS_ATA_TRANSLATION_NONE ?
5173 ",trans=none" : "");
5174 break;
cd6f1169 5175 case QEMU_OPTION_hdb:
cc1daa40
FB		 5176 case QEMU_OPTION_hdc:
5177 case QEMU_OPTION_hdd:
609497ab 5178 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
fc01f7e7 5179 break;
e4bcb14c 5180 case QEMU_OPTION_drive:
609497ab 5181 drive_add(NULL, "%s", optarg);
e4bcb14c 5182 break;
3e3d5815 5183 case QEMU_OPTION_mtdblock:
609497ab 5184 drive_add(optarg, MTD_ALIAS);
3e3d5815 5185 break;
a1bb27b1 5186 case QEMU_OPTION_sd:
609497ab 5187 drive_add(optarg, SD_ALIAS);
a1bb27b1 5188 break;
86f55663 5189 case QEMU_OPTION_pflash:
609497ab 5190 drive_add(optarg, PFLASH_ALIAS);
86f55663 5191 break;
cd6f1169 5192 case QEMU_OPTION_snapshot:
33e3963e
FB		 5193 snapshot = 1;
5194 break;
cd6f1169 5195 case QEMU_OPTION_hdachs:
330d0414 5196 {
330d0414
FB		 5197 const char *p;
5198 p = optarg;
5199 cyls = strtol(p, (char **)&p, 0);
46d4767d
FB		 5200 if (cyls < 1 || cyls > 16383)
5201 goto chs_fail;
330d0414
FB		 5202 if (*p != ',')
5203 goto chs_fail;
5204 p++;
5205 heads = strtol(p, (char **)&p, 0);
46d4767d
FB		 5206 if (heads < 1 || heads > 16)
5207 goto chs_fail;
330d0414
FB		 5208 if (*p != ',')
5209 goto chs_fail;
5210 p++;
5211 secs = strtol(p, (char **)&p, 0);
46d4767d
FB		 5212 if (secs < 1 || secs > 63)
5213 goto chs_fail;
5214 if (*p == ',') {
5215 p++;
5216 if (!strcmp(p, "none"))
5217 translation = BIOS_ATA_TRANSLATION_NONE;
5218 else if (!strcmp(p, "lba"))
5219 translation = BIOS_ATA_TRANSLATION_LBA;
5220 else if (!strcmp(p, "auto"))
5221 translation = BIOS_ATA_TRANSLATION_AUTO;
5222 else
5223 goto chs_fail;
5224 } else if (*p != '\0') {
c4b1fcc0 5225 chs_fail:
46d4767d
FB		 5226 fprintf(stderr, "qemu: invalid physical CHS format\n");
5227 exit(1);
c4b1fcc0 5228 }
e4bcb14c 5229 if (hda_index != -1)
609497ab
AZ		 5230 snprintf(drives_opt[hda_index].opt,
5231 sizeof(drives_opt[hda_index].opt),
5232 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
5233 0, cyls, heads, secs,
e4bcb14c
TS		 5234 translation == BIOS_ATA_TRANSLATION_LBA ?
5235 ",trans=lba" :
5236 translation == BIOS_ATA_TRANSLATION_NONE ?
5237 ",trans=none" : "");
330d0414
FB		 5238 }
5239 break;
268a362c
AL		 5240 case QEMU_OPTION_numa:
5241 if (nb_numa_nodes >= MAX_NODES) {
5242 fprintf(stderr, "qemu: too many NUMA nodes\n");
5243 exit(1);
5244 }
5245 numa_add(optarg);
5246 break;
cd6f1169 5247 case QEMU_OPTION_nographic:
993fbfdb 5248 display_type = DT_NOGRAPHIC;
a20dd508 5249 break;
4d3b6f6e
AZ		 5250#ifdef CONFIG_CURSES
5251 case QEMU_OPTION_curses:
993fbfdb 5252 display_type = DT_CURSES;
4d3b6f6e
AZ		 5253 break;
5254#endif
a171fe39
AZ		 5255 case QEMU_OPTION_portrait:
5256 graphic_rotate = 1;
5257 break;
cd6f1169 5258 case QEMU_OPTION_kernel:
a20dd508
FB		 5259 kernel_filename = optarg;
5260 break;
cd6f1169 5261 case QEMU_OPTION_append:
a20dd508 5262 kernel_cmdline = optarg;
313aa567 5263 break;
cd6f1169 5264 case QEMU_OPTION_cdrom:
609497ab 5265 drive_add(optarg, CDROM_ALIAS);
36b486bb 5266 break;
cd6f1169 5267 case QEMU_OPTION_boot:
28c5af54
JM		 5268 boot_devices = optarg;
5269 /* We just do some generic consistency checks */
5270 {
5271 /* Could easily be extended to 64 devices if needed */
60fe76f3 5272 const char *p;
28c5af54
JM		 5273
5274 boot_devices_bitmap = 0;
5275 for (p = boot_devices; *p != '\0'; p++) {
5276 /* Allowed boot devices are:
5277 * a b : floppy disk drives
5278 * c ... f : IDE disk drives
5279 * g ... m : machine implementation dependant drives
5280 * n ... p : network devices
5281 * It's up to each machine implementation to check
5282 * if the given boot devices match the actual hardware
5283 * implementation and firmware features.
5284 */
5285 if (*p < 'a' || *p > 'q') {
5286 fprintf(stderr, "Invalid boot device '%c'\n", *p);
5287 exit(1);
5288 }
5289 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
5290 fprintf(stderr,
5291 "Boot device '%c' was given twice\n",*p);
5292 exit(1);
5293 }
5294 boot_devices_bitmap |= 1 << (*p - 'a');
5295 }
36b486bb
FB		 5296 }
5297 break;
cd6f1169 5298 case QEMU_OPTION_fda:
cd6f1169 5299 case QEMU_OPTION_fdb:
609497ab 5300 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
c45886db 5301 break;
52ca8d6a
FB		 5302#ifdef TARGET_I386
5303 case QEMU_OPTION_no_fd_bootchk:
5304 fd_bootchk = 0;
5305 break;
5306#endif
7c9d8e07
FB		 5307 case QEMU_OPTION_net:
5308 if (nb_net_clients >= MAX_NET_CLIENTS) {
5309 fprintf(stderr, "qemu: too many network clients\n");
c4b1fcc0
FB		 5310 exit(1);
5311 }
fd5f393a 5312 net_clients[nb_net_clients] = optarg;
7c9d8e07 5313 nb_net_clients++;
702c651c 5314 break;
c7f74643
FB		 5315#ifdef CONFIG_SLIRP
5316 case QEMU_OPTION_tftp:
ad196a9d 5317 legacy_tftp_prefix = optarg;
9bf05444 5318 break;
47d5d01a 5319 case QEMU_OPTION_bootp:
ad196a9d 5320 legacy_bootp_filename = optarg;
47d5d01a 5321 break;
c94c8d64 5322#ifndef _WIN32
9d728e8c 5323 case QEMU_OPTION_smb:
ad196a9d 5324 net_slirp_smb(optarg);
9d728e8c 5325 break;
c94c8d64 5326#endif
9bf05444 5327 case QEMU_OPTION_redir:
f3546deb 5328 net_slirp_redir(optarg);
9bf05444 5329 break;
c7f74643 5330#endif
dc72ac14
AZ		 5331 case QEMU_OPTION_bt:
5332 if (nb_bt_opts >= MAX_BT_CMDLINE) {
5333 fprintf(stderr, "qemu: too many bluetooth options\n");
5334 exit(1);
5335 }
5336 bt_opts[nb_bt_opts++] = optarg;
5337 break;
1d14ffa9 5338#ifdef HAS_AUDIO
1d14ffa9
FB		 5339 case QEMU_OPTION_audio_help:
5340 AUD_help ();
5341 exit (0);
5342 break;
5343 case QEMU_OPTION_soundhw:
5344 select_soundhw (optarg);
5345 break;
5346#endif
cd6f1169 5347 case QEMU_OPTION_h:
15f82208 5348 help(0);
cd6f1169 5349 break;
9bd7e6d9
PB		 5350 case QEMU_OPTION_version:
5351 version();
5352 exit(0);
5353 break;
00f82b8a
AJ		 5354 case QEMU_OPTION_m: {
5355 uint64_t value;
5356 char *ptr;
5357
5358 value = strtoul(optarg, &ptr, 10);
5359 switch (*ptr) {
5360 case 0: case 'M': case 'm':
5361 value <<= 20;
5362 break;
5363 case 'G': case 'g':
5364 value <<= 30;
5365 break;
5366 default:
5367 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
cd6f1169
FB		 5368 exit(1);
5369 }
00f82b8a
AJ		 5370
5371 /* On 32-bit hosts, QEMU is limited by virtual address space */
5372 if (value > (2047 << 20)
640f42e4 5373#ifndef CONFIG_KQEMU
00f82b8a
AJ		 5374 && HOST_LONG_BITS == 32
5375#endif
5376 ) {
5377 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5378 exit(1);
5379 }
5380 if (value != (uint64_t)(ram_addr_t)value) {
5381 fprintf(stderr, "qemu: ram size too large\n");
5382 exit(1);
5383 }
5384 ram_size = value;
cd6f1169 5385 break;
00f82b8a 5386 }
cd6f1169
FB		 5387 case QEMU_OPTION_d:
5388 {
5389 int mask;
c7cd6a37 5390 const CPULogItem *item;
3b46e624 5391
cd6f1169
FB		 5392 mask = cpu_str_to_log_mask(optarg);
5393 if (!mask) {
5394 printf("Log items (comma separated):\n");
f193c797
FB		 5395 for(item = cpu_log_items; item->mask != 0; item++) {
5396 printf("%-10s %s\n", item->name, item->help);
5397 }
5398 exit(1);
cd6f1169
FB		 5399 }
5400 cpu_set_log(mask);
f193c797 5401 }
cd6f1169 5402 break;
cd6f1169 5403 case QEMU_OPTION_s:
59030a8c 5404 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
cd6f1169 5405 break;
59030a8c
AL		 5406 case QEMU_OPTION_gdb:
5407 gdbstub_dev = optarg;
cd6f1169 5408 break;
cd6f1169 5409 case QEMU_OPTION_L:
5cea8590 5410 data_dir = optarg;
cd6f1169 5411 break;
1192dad8
JM		 5412 case QEMU_OPTION_bios:
5413 bios_name = optarg;
5414 break;
1b530a6d
AJ		 5415 case QEMU_OPTION_singlestep:
5416 singlestep = 1;
5417 break;
cd6f1169 5418 case QEMU_OPTION_S:
3c07f8e8 5419 autostart = 0;
cd6f1169 5420 break;
5824d651 5421#ifndef _WIN32
3d11d0eb
FB		 5422 case QEMU_OPTION_k:
5423 keyboard_layout = optarg;
5424 break;
5824d651 5425#endif
ee22c2f7
FB		 5426 case QEMU_OPTION_localtime:
5427 rtc_utc = 0;
5428 break;
3893c124 5429 case QEMU_OPTION_vga:
5430 select_vgahw (optarg);
1bfe856e 5431 break;
5824d651 5432#if defined(TARGET_PPC) || defined(TARGET_SPARC)
e9b137c2
FB		 5433 case QEMU_OPTION_g:
5434 {
5435 const char *p;
5436 int w, h, depth;
5437 p = optarg;
5438 w = strtol(p, (char **)&p, 10);
5439 if (w <= 0) {
5440 graphic_error:
5441 fprintf(stderr, "qemu: invalid resolution or depth\n");
5442 exit(1);
5443 }
5444 if (*p != 'x')
5445 goto graphic_error;
5446 p++;
5447 h = strtol(p, (char **)&p, 10);
5448 if (h <= 0)
5449 goto graphic_error;
5450 if (*p == 'x') {
5451 p++;
5452 depth = strtol(p, (char **)&p, 10);
5fafdf24 5453 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 5454 depth != 24 && depth != 32)
5455 goto graphic_error;
5456 } else if (*p == '\0') {
5457 depth = graphic_depth;
5458 } else {
5459 goto graphic_error;
5460 }
3b46e624 5461
e9b137c2
FB		 5462 graphic_width = w;
5463 graphic_height = h;
5464 graphic_depth = depth;
5465 }
5466 break;
5824d651 5467#endif
20d8a3ed
TS		 5468 case QEMU_OPTION_echr:
5469 {
5470 char *r;
5471 term_escape_char = strtol(optarg, &r, 0);
5472 if (r == optarg)
5473 printf("Bad argument to echr\n");
5474 break;
5475 }
82c643ff 5476 case QEMU_OPTION_monitor:
fd5f393a 5477 monitor_device = optarg;
82c643ff
FB		 5478 break;
5479 case QEMU_OPTION_serial:
8d11df9e
FB		 5480 if (serial_device_index >= MAX_SERIAL_PORTS) {
5481 fprintf(stderr, "qemu: too many serial ports\n");
5482 exit(1);
5483 }
fd5f393a 5484 serial_devices[serial_device_index] = optarg;
8d11df9e 5485 serial_device_index++;
82c643ff 5486 break;
9dd986cc
RJ		 5487 case QEMU_OPTION_watchdog:
5488 i = select_watchdog(optarg);
5489 if (i > 0)
5490 exit (i == 1 ? 1 : 0);
5491 break;
5492 case QEMU_OPTION_watchdog_action:
5493 if (select_watchdog_action(optarg) == -1) {
5494 fprintf(stderr, "Unknown -watchdog-action parameter\n");
5495 exit(1);
5496 }
5497 break;
51ecf136
AL		 5498 case QEMU_OPTION_virtiocon:
5499 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5500 fprintf(stderr, "qemu: too many virtio consoles\n");
5501 exit(1);
5502 }
5503 virtio_consoles[virtio_console_index] = optarg;
5504 virtio_console_index++;
5505 break;
6508fe59
FB		 5506 case QEMU_OPTION_parallel:
5507 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5508 fprintf(stderr, "qemu: too many parallel ports\n");
5509 exit(1);
5510 }
fd5f393a 5511 parallel_devices[parallel_device_index] = optarg;
6508fe59
FB		 5512 parallel_device_index++;
5513 break;
d63d307f
FB		 5514 case QEMU_OPTION_loadvm:
5515 loadvm = optarg;
5516 break;
5517 case QEMU_OPTION_full_screen:
5518 full_screen = 1;
5519 break;
667accab 5520#ifdef CONFIG_SDL
43523e93
TS		 5521 case QEMU_OPTION_no_frame:
5522 no_frame = 1;
5523 break;
3780e197
TS		 5524 case QEMU_OPTION_alt_grab:
5525 alt_grab = 1;
5526 break;
667accab
TS		 5527 case QEMU_OPTION_no_quit:
5528 no_quit = 1;
5529 break;
7d957bd8 5530 case QEMU_OPTION_sdl:
993fbfdb 5531 display_type = DT_SDL;
7d957bd8 5532 break;
667accab 5533#endif
f7cce898 5534 case QEMU_OPTION_pidfile:
93815bc2 5535 pid_file = optarg;
f7cce898 5536 break;
a09db21f
FB		 5537#ifdef TARGET_I386
5538 case QEMU_OPTION_win2k_hack:
5539 win2k_install_hack = 1;
5540 break;
73822ec8
AL		 5541 case QEMU_OPTION_rtc_td_hack:
5542 rtc_td_hack = 1;
5543 break;
8a92ea2f
AL		 5544 case QEMU_OPTION_acpitable:
5545 if(acpi_table_add(optarg) < 0) {
5546 fprintf(stderr, "Wrong acpi table provided\n");
5547 exit(1);
5548 }
5549 break;
b6f6e3d3
AL		 5550 case QEMU_OPTION_smbios:
5551 if(smbios_entry_add(optarg) < 0) {
5552 fprintf(stderr, "Wrong smbios provided\n");
5553 exit(1);
5554 }
5555 break;
a09db21f 5556#endif
640f42e4 5557#ifdef CONFIG_KQEMU
d993e026
FB		 5558 case QEMU_OPTION_no_kqemu:
5559 kqemu_allowed = 0;
5560 break;
89bfc105
FB		 5561 case QEMU_OPTION_kernel_kqemu:
5562 kqemu_allowed = 2;
5563 break;
7ba1e619
AL		 5564#endif
5565#ifdef CONFIG_KVM
5566 case QEMU_OPTION_enable_kvm:
5567 kvm_allowed = 1;
640f42e4 5568#ifdef CONFIG_KQEMU
7ba1e619
AL		 5569 kqemu_allowed = 0;
5570#endif
5571 break;
d993e026 5572#endif
bb36d470
FB		 5573 case QEMU_OPTION_usb:
5574 usb_enabled = 1;
5575 break;
a594cfbf
FB		 5576 case QEMU_OPTION_usbdevice:
5577 usb_enabled = 1;
0d92ed30 5578 if (usb_devices_index >= MAX_USB_CMDLINE) {
a594cfbf
FB		 5579 fprintf(stderr, "Too many USB devices\n");
5580 exit(1);
5581 }
fd5f393a 5582 usb_devices[usb_devices_index] = optarg;
a594cfbf
FB		 5583 usb_devices_index++;
5584 break;
6a00d601
FB		 5585 case QEMU_OPTION_smp:
5586 smp_cpus = atoi(optarg);
b2097003 5587 if (smp_cpus < 1) {
6a00d601
FB		 5588 fprintf(stderr, "Invalid number of CPUs\n");
5589 exit(1);
5590 }
5591 break;
24236869 5592 case QEMU_OPTION_vnc:
993fbfdb 5593 display_type = DT_VNC;
73fc9742 5594 vnc_display = optarg;
24236869 5595 break;
5824d651 5596#ifdef TARGET_I386
6515b203
FB		 5597 case QEMU_OPTION_no_acpi:
5598 acpi_enabled = 0;
5599 break;
16b29ae1
AL		 5600 case QEMU_OPTION_no_hpet:
5601 no_hpet = 1;
5602 break;
7d4c3d53
MA		 5603 case QEMU_OPTION_balloon:
5604 if (balloon_parse(optarg) < 0) {
5605 fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5606 exit(1);
5607 }
df97b920 5608 break;
5824d651 5609#endif
d1beab82
FB		 5610 case QEMU_OPTION_no_reboot:
5611 no_reboot = 1;
5612 break;
b2f76161
AJ		 5613 case QEMU_OPTION_no_shutdown:
5614 no_shutdown = 1;
5615 break;
9467cd46
AZ		 5616 case QEMU_OPTION_show_cursor:
5617 cursor_hide = 0;
5618 break;
8fcb1b90
BS		 5619 case QEMU_OPTION_uuid:
5620 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5621 fprintf(stderr, "Fail to parse UUID string."
5622 " Wrong format.\n");
5623 exit(1);
5624 }
5625 break;
5824d651 5626#ifndef _WIN32
71e3ceb8
TS		 5627 case QEMU_OPTION_daemonize:
5628 daemonize = 1;
5629 break;
5824d651 5630#endif
9ae02555
TS		 5631 case QEMU_OPTION_option_rom:
5632 if (nb_option_roms >= MAX_OPTION_ROMS) {
5633 fprintf(stderr, "Too many option ROMs\n");
5634 exit(1);
5635 }
5636 option_rom[nb_option_roms] = optarg;
5637 nb_option_roms++;
5638 break;
5824d651 5639#if defined(TARGET_ARM) || defined(TARGET_M68K)
8e71621f
PB		 5640 case QEMU_OPTION_semihosting:
5641 semihosting_enabled = 1;
5642 break;
5824d651 5643#endif
c35734b2
TS		 5644 case QEMU_OPTION_name:
5645 qemu_name = optarg;
5646 break;
95efd11c 5647#if defined(TARGET_SPARC) || defined(TARGET_PPC)
66508601
BS		 5648 case QEMU_OPTION_prom_env:
5649 if (nb_prom_envs >= MAX_PROM_ENVS) {
5650 fprintf(stderr, "Too many prom variables\n");
5651 exit(1);
5652 }
5653 prom_envs[nb_prom_envs] = optarg;
5654 nb_prom_envs++;
5655 break;
2b8f2d41
AZ		 5656#endif
5657#ifdef TARGET_ARM
5658 case QEMU_OPTION_old_param:
5659 old_param = 1;
05ebd537 5660 break;
66508601 5661#endif
f3dcfada
TS		 5662 case QEMU_OPTION_clock:
5663 configure_alarms(optarg);
5664 break;
7e0af5d0
FB		 5665 case QEMU_OPTION_startdate:
5666 {
5667 struct tm tm;
f6503059 5668 time_t rtc_start_date;
7e0af5d0 5669 if (!strcmp(optarg, "now")) {
f6503059 5670 rtc_date_offset = -1;
7e0af5d0
FB		 5671 } else {
5672 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5673 &tm.tm_year,
5674 &tm.tm_mon,
5675 &tm.tm_mday,
5676 &tm.tm_hour,
5677 &tm.tm_min,
5678 &tm.tm_sec) == 6) {
5679 /* OK */
5680 } else if (sscanf(optarg, "%d-%d-%d",
5681 &tm.tm_year,
5682 &tm.tm_mon,
5683 &tm.tm_mday) == 3) {
5684 tm.tm_hour = 0;
5685 tm.tm_min = 0;
5686 tm.tm_sec = 0;
5687 } else {
5688 goto date_fail;
5689 }
5690 tm.tm_year -= 1900;
5691 tm.tm_mon--;
3c6b2088 5692 rtc_start_date = mktimegm(&tm);
7e0af5d0
FB		 5693 if (rtc_start_date == -1) {
5694 date_fail:
5695 fprintf(stderr, "Invalid date format. Valid format are:\n"
5696 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5697 exit(1);
5698 }
f6503059 5699 rtc_date_offset = time(NULL) - rtc_start_date;
7e0af5d0
FB		 5700 }
5701 }
5702 break;
26a5f13b
FB		 5703 case QEMU_OPTION_tb_size:
5704 tb_size = strtol(optarg, NULL, 0);
5705 if (tb_size < 0)
5706 tb_size = 0;
5707 break;
2e70f6ef
PB		 5708 case QEMU_OPTION_icount:
5709 use_icount = 1;
5710 if (strcmp(optarg, "auto") == 0) {
5711 icount_time_shift = -1;
5712 } else {
5713 icount_time_shift = strtol(optarg, NULL, 0);
5714 }
5715 break;
5bb7910a
AL		 5716 case QEMU_OPTION_incoming:
5717 incoming = optarg;
5718 break;
5824d651 5719#ifndef _WIN32
0858532e
AL		 5720 case QEMU_OPTION_chroot:
5721 chroot_dir = optarg;
5722 break;
5723 case QEMU_OPTION_runas:
5724 run_as = optarg;
5725 break;
e37630ca
AL		 5726#endif
5727#ifdef CONFIG_XEN
5728 case QEMU_OPTION_xen_domid:
5729 xen_domid = atoi(optarg);
5730 break;
5731 case QEMU_OPTION_xen_create:
5732 xen_mode = XEN_CREATE;
5733 break;
5734 case QEMU_OPTION_xen_attach:
5735 xen_mode = XEN_ATTACH;
5736 break;
5824d651 5737#endif
cd6f1169 5738 }
0824d6fc
FB		 5739 }
5740 }
330d0414 5741
5cea8590
PB		 5742 /* If no data_dir is specified then try to find it relative to the
5743 executable path. */
5744 if (!data_dir) {
5745 data_dir = find_datadir(argv[0]);
5746 }
5747 /* If all else fails use the install patch specified when building. */
5748 if (!data_dir) {
5749 data_dir = CONFIG_QEMU_SHAREDIR;
5750 }
5751
640f42e4 5752#if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
7ba1e619
AL		 5753 if (kvm_allowed && kqemu_allowed) {
5754 fprintf(stderr,
5755 "You can not enable both KVM and kqemu at the same time\n");
5756 exit(1);
5757 }
5758#endif
5759
3d878caa 5760 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
b2097003
AL		 5761 if (smp_cpus > machine->max_cpus) {
5762 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5763 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5764 machine->max_cpus);
5765 exit(1);
5766 }
5767
993fbfdb 5768 if (display_type == DT_NOGRAPHIC) {
bc0129d9
AL		 5769 if (serial_device_index == 0)
5770 serial_devices[0] = "stdio";
5771 if (parallel_device_index == 0)
5772 parallel_devices[0] = "null";
5773 if (strncmp(monitor_device, "vc", 2) == 0)
5774 monitor_device = "stdio";
5775 }
5776
71e3ceb8 5777#ifndef _WIN32
71e3ceb8
TS		 5778 if (daemonize) {
5779 pid_t pid;
5780
5781 if (pipe(fds) == -1)
5782 exit(1);
5783
5784 pid = fork();
5785 if (pid > 0) {
5786 uint8_t status;
5787 ssize_t len;
5788
5789 close(fds[1]);
5790
5791 again:
93815bc2
TS		 5792 len = read(fds[0], &status, 1);
5793 if (len == -1 && (errno == EINTR))
5794 goto again;
5795
5796 if (len != 1)
5797 exit(1);
5798 else if (status == 1) {
5799 fprintf(stderr, "Could not acquire pidfile\n");
5800 exit(1);
5801 } else
5802 exit(0);
71e3ceb8 5803 } else if (pid < 0)
93815bc2 5804 exit(1);
71e3ceb8
TS		 5805
5806 setsid();
5807
5808 pid = fork();
5809 if (pid > 0)
5810 exit(0);
5811 else if (pid < 0)
5812 exit(1);
5813
5814 umask(027);
71e3ceb8
TS		 5815
5816 signal(SIGTSTP, SIG_IGN);
5817 signal(SIGTTOU, SIG_IGN);
5818 signal(SIGTTIN, SIG_IGN);
5819 }
71e3ceb8 5820
aa26bb2d 5821 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
93815bc2
TS		 5822 if (daemonize) {
5823 uint8_t status = 1;
5824 write(fds[1], &status, 1);
5825 } else
5826 fprintf(stderr, "Could not acquire pid file\n");
5827 exit(1);
5828 }
b9e82a59 5829#endif
93815bc2 5830
640f42e4 5831#ifdef CONFIG_KQEMU
ff3fbb30
FB		 5832 if (smp_cpus > 1)
5833 kqemu_allowed = 0;
5834#endif
3fcf7b6b
AL		 5835 if (qemu_init_main_loop()) {
5836 fprintf(stderr, "qemu_init_main_loop failed\n");
5837 exit(1);
5838 }
a20dd508 5839 linux_boot = (kernel_filename != NULL);
6c41b272 5840
f8d39c01
TS		 5841 if (!linux_boot && *kernel_cmdline != '\0') {
5842 fprintf(stderr, "-append only allowed with -kernel option\n");
5843 exit(1);
5844 }
5845
5846 if (!linux_boot && initrd_filename != NULL) {
5847 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5848 exit(1);
5849 }
5850
96d30e48 5851 /* boot to floppy or the default cd if no hard disk defined yet */
28c5af54 5852 if (!boot_devices[0]) {
e4bcb14c 5853 boot_devices = "cad";
96d30e48 5854 }
b118d61e 5855 setvbuf(stdout, NULL, _IOLBF, 0);
3b46e624 5856
634fce96 5857 init_timers();
7183b4b4
AL		 5858 if (init_timer_alarm() < 0) {
5859 fprintf(stderr, "could not initialize alarm timer\n");
5860 exit(1);
5861 }
2e70f6ef
PB		 5862 if (use_icount && icount_time_shift < 0) {
5863 use_icount = 2;
5864 /* 125MIPS seems a reasonable initial guess at the guest speed.
5865 It will be corrected fairly quickly anyway. */
5866 icount_time_shift = 3;
5867 init_icount_adjust();
5868 }
634fce96 5869
fd1dff4b
FB		 5870#ifdef _WIN32
5871 socket_init();
5872#endif
5873
7c9d8e07
FB		 5874 /* init network clients */
5875 if (nb_net_clients == 0) {
5876 /* if no clients, we use a default config */
f441b28b
AL		 5877 net_clients[nb_net_clients++] = "nic";
5878#ifdef CONFIG_SLIRP
5879 net_clients[nb_net_clients++] = "user";
5880#endif
c20709aa
FB		 5881 }
5882
7c9d8e07 5883 for(i = 0;i < nb_net_clients; i++) {
9ad97e65 5884 if (net_client_parse(net_clients[i]) < 0)
7c9d8e07 5885 exit(1);
702c651c 5886 }
f1510b2c 5887
406c8df3
GC		 5888 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5889 net_set_boot_mask(net_boot);
5890
5891 net_client_check();
eec85c2a 5892
dc72ac14
AZ		 5893 /* init the bluetooth world */
5894 for (i = 0; i < nb_bt_opts; i++)
5895 if (bt_parse(bt_opts[i]))
5896 exit(1);
5897
0824d6fc 5898 /* init the memory */
94a6b54f
PB		 5899 if (ram_size == 0)
5900 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
9ae02555 5901
640f42e4 5902#ifdef CONFIG_KQEMU
94a6b54f
PB		 5903 /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5904 guest ram allocation. It needs to go away. */
5905 if (kqemu_allowed) {
4cfce484 5906 kqemu_phys_ram_size = ram_size + 8 * 1024 * 1024 + 4 * 1024 * 1024;
94a6b54f
PB		 5907 kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size);
5908 if (!kqemu_phys_ram_base) {
5909 fprintf(stderr, "Could not allocate physical memory\n");
5910 exit(1);
5911 }
0824d6fc 5912 }
94a6b54f 5913#endif
0824d6fc 5914
26a5f13b
FB		 5915 /* init the dynamic translator */
5916 cpu_exec_init_all(tb_size * 1024 * 1024);
5917
5905b2e5 5918 bdrv_init();
c4b1fcc0 5919
e4bcb14c 5920 /* we always create the cdrom drive, even if no disk is there */
c4b1fcc0 5921
e4bcb14c 5922 if (nb_drives_opt < MAX_DRIVES)
609497ab 5923 drive_add(NULL, CDROM_ALIAS);
c4b1fcc0 5924
9d413d1d 5925 /* we always create at least one floppy */
33e3963e 5926
e4bcb14c 5927 if (nb_drives_opt < MAX_DRIVES)
609497ab 5928 drive_add(NULL, FD_ALIAS, 0);
86f55663 5929
9d413d1d
AZ		 5930 /* we always create one sd slot, even if no card is in it */
5931
5932 if (nb_drives_opt < MAX_DRIVES)
609497ab 5933 drive_add(NULL, SD_ALIAS);
9d413d1d 5934
e4bcb14c
TS		 5935 /* open the virtual block devices */
5936
5937 for(i = 0; i < nb_drives_opt; i++)
609497ab 5938 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
e4bcb14c 5939 exit(1);
3e3d5815 5940
c88676f8 5941 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
475e4277 5942 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
8a7ddc38 5943
3023f332
AL		 5944#ifndef _WIN32
5945 /* must be after terminal init, SDL library changes signal handlers */
7c3370d4 5946 sighandler_setup();
3023f332
AL		 5947#endif
5948
5949 /* Maintain compatibility with multiple stdio monitors */
5950 if (!strcmp(monitor_device,"stdio")) {
5951 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5952 const char *devname = serial_devices[i];
5953 if (devname && !strcmp(devname,"mon:stdio")) {
5954 monitor_device = NULL;
5955 break;
5956 } else if (devname && !strcmp(devname,"stdio")) {
5957 monitor_device = NULL;
5958 serial_devices[i] = "mon:stdio";
5959 break;
5960 }
5961 }
5962 }
5963
268a362c
AL		 5964 if (nb_numa_nodes > 0) {
5965 int i;
5966
5967 if (nb_numa_nodes > smp_cpus) {
5968 nb_numa_nodes = smp_cpus;
5969 }
5970
5971 /* If no memory size if given for any node, assume the default case
5972 * and distribute the available memory equally across all nodes
5973 */
5974 for (i = 0; i < nb_numa_nodes; i++) {
5975 if (node_mem[i] != 0)
5976 break;
5977 }
5978 if (i == nb_numa_nodes) {
5979 uint64_t usedmem = 0;
5980
5981 /* On Linux, the each node's border has to be 8MB aligned,
5982 * the final node gets the rest.
5983 */
5984 for (i = 0; i < nb_numa_nodes - 1; i++) {
5985 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5986 usedmem += node_mem[i];
5987 }
5988 node_mem[i] = ram_size - usedmem;
5989 }
5990
5991 for (i = 0; i < nb_numa_nodes; i++) {
5992 if (node_cpumask[i] != 0)
5993 break;
5994 }
5995 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5996 * must cope with this anyway, because there are BIOSes out there in
5997 * real machines which also use this scheme.
5998 */
5999 if (i == nb_numa_nodes) {
6000 for (i = 0; i < smp_cpus; i++) {
6001 node_cpumask[i % nb_numa_nodes] |= 1 << i;
6002 }
6003 }
6004 }
6005
3023f332
AL		 6006 if (kvm_enabled()) {
6007 int ret;
6008
6009 ret = kvm_init(smp_cpus);
6010 if (ret < 0) {
6011 fprintf(stderr, "failed to initialize KVM\n");
6012 exit(1);
6013 }
6014 }
6015
4c621805 6016 if (monitor_device) {
ceecf1d1 6017 monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
4c621805
AL		 6018 if (!monitor_hd) {
6019 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
6020 exit(1);
6021 }
6022 }
6023
2796dae0
AL		 6024 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6025 const char *devname = serial_devices[i];
6026 if (devname && strcmp(devname, "none")) {
6027 char label[32];
6028 snprintf(label, sizeof(label), "serial%d", i);
ceecf1d1 6029 serial_hds[i] = qemu_chr_open(label, devname, NULL);
2796dae0
AL		 6030 if (!serial_hds[i]) {
6031 fprintf(stderr, "qemu: could not open serial device '%s'\n",
6032 devname);
6033 exit(1);
6034 }
6035 }
6036 }
6037
6038 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6039 const char *devname = parallel_devices[i];
6040 if (devname && strcmp(devname, "none")) {
6041 char label[32];
6042 snprintf(label, sizeof(label), "parallel%d", i);
ceecf1d1 6043 parallel_hds[i] = qemu_chr_open(label, devname, NULL);
2796dae0
AL		 6044 if (!parallel_hds[i]) {
6045 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
6046 devname);
6047 exit(1);
6048 }
6049 }
6050 }
6051
6052 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6053 const char *devname = virtio_consoles[i];
6054 if (devname && strcmp(devname, "none")) {
6055 char label[32];
6056 snprintf(label, sizeof(label), "virtcon%d", i);
ceecf1d1 6057 virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
2796dae0
AL		 6058 if (!virtcon_hds[i]) {
6059 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
6060 devname);
6061 exit(1);
6062 }
6063 }
6064 }
6065
aae9460e
PB		 6066 module_call_init(MODULE_INIT_DEVICE);
6067
fbe1b595 6068 machine->init(ram_size, boot_devices,
3023f332
AL		 6069 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
6070
268a362c
AL		 6071
6072 for (env = first_cpu; env != NULL; env = env->next_cpu) {
6073 for (i = 0; i < nb_numa_nodes; i++) {
6074 if (node_cpumask[i] & (1 << env->cpu_index)) {
6075 env->numa_node = i;
6076 }
6077 }
6078 }
6079
6f338c34
AL		 6080 current_machine = machine;
6081
3023f332
AL		 6082 /* init USB devices */
6083 if (usb_enabled) {
6084 for(i = 0; i < usb_devices_index; i++) {
c0f4ce77 6085 if (usb_device_add(usb_devices[i], 0) < 0) {
3023f332
AL		 6086 fprintf(stderr, "Warning: could not add USB device %s\n",
6087 usb_devices[i]);
6088 }
6089 }
6090 }
6091
8f391ab4
AL		 6092 if (!display_state)
6093 dumb_display_init();
3023f332
AL		 6094 /* just use the first displaystate for the moment */
6095 ds = display_state;
993fbfdb
AL		 6096
6097 if (display_type == DT_DEFAULT) {
6098#if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
6099 display_type = DT_SDL;
6100#else
6101 display_type = DT_VNC;
6102 vnc_display = "localhost:0,to=99";
6103 show_vnc_port = 1;
6104#endif
6105 }
6106
6107
6108 switch (display_type) {
6109 case DT_NOGRAPHIC:
6110 break;
4d3b6f6e 6111#if defined(CONFIG_CURSES)
993fbfdb
AL		 6112 case DT_CURSES:
6113 curses_display_init(ds, full_screen);
6114 break;
4d3b6f6e 6115#endif
5b0753e0 6116#if defined(CONFIG_SDL)
993fbfdb
AL		 6117 case DT_SDL:
6118 sdl_display_init(ds, full_screen, no_frame);
6119 break;
5b0753e0 6120#elif defined(CONFIG_COCOA)
993fbfdb
AL		 6121 case DT_SDL:
6122 cocoa_display_init(ds, full_screen);
6123 break;
313aa567 6124#endif
993fbfdb
AL		 6125 case DT_VNC:
6126 vnc_display_init(ds);
6127 if (vnc_display_open(ds, vnc_display) < 0)
6128 exit(1);
f92f8afe 6129
993fbfdb
AL		 6130 if (show_vnc_port) {
6131 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
f92f8afe 6132 }
993fbfdb
AL		 6133 break;
6134 default:
6135 break;
313aa567 6136 }
7d957bd8 6137 dpy_resize(ds);
5b08fc10 6138
3023f332
AL		 6139 dcl = ds->listeners;
6140 while (dcl != NULL) {
6141 if (dcl->dpy_refresh != NULL) {
6142 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
6143 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
20d8a3ed 6144 }
3023f332 6145 dcl = dcl->next;
20d8a3ed 6146 }
3023f332 6147
993fbfdb 6148 if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
9043b62d
BS		 6149 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6150 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6151 }
6152
2796dae0 6153 text_consoles_set_display(display_state);
2970a6c9 6154 qemu_chr_initial_reset();
2796dae0 6155
4c621805 6156 if (monitor_device && monitor_hd)
cde76ee1 6157 monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
82c643ff 6158
8d11df9e 6159 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
c03b0f0f 6160 const char *devname = serial_devices[i];
fd5f393a 6161 if (devname && strcmp(devname, "none")) {
af3a9031 6162 if (strstart(devname, "vc", 0))
7ba1260a 6163 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8d11df9e 6164 }
82c643ff 6165 }
82c643ff 6166
6508fe59 6167 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
c03b0f0f 6168 const char *devname = parallel_devices[i];
fd5f393a 6169 if (devname && strcmp(devname, "none")) {
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 if (strstart(devname, "vc", 0))
6179 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
6180 }
6181 }
6182
59030a8c
AL		 6183 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6184 fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6185 gdbstub_dev);
6186 exit(1);
45669e00 6187 }
45669e00 6188
d63d307f 6189 if (loadvm)
376253ec 6190 do_loadvm(cur_mon, loadvm);
d63d307f 6191
5bb7910a
AL		 6192 if (incoming) {
6193 autostart = 0; /* fixme how to deal with -daemonize */
6194 qemu_start_incoming_migration(incoming);
6195 }
6196
c0f4ce77
AL		 6197 if (autostart)
6198 vm_start();
ffd843bc 6199
b9e82a59 6200#ifndef _WIN32
71e3ceb8
TS		 6201 if (daemonize) {
6202 uint8_t status = 0;
6203 ssize_t len;
71e3ceb8
TS		 6204
6205 again1:
6206 len = write(fds[1], &status, 1);
6207 if (len == -1 && (errno == EINTR))
6208 goto again1;
6209
6210 if (len != 1)
6211 exit(1);
6212
bd54b863 6213 chdir("/");
aeb30be6 6214 TFR(fd = open("/dev/null", O_RDWR));
71e3ceb8
TS		 6215 if (fd == -1)
6216 exit(1);
0858532e 6217 }
71e3ceb8 6218
0858532e
AL		 6219 if (run_as) {
6220 pwd = getpwnam(run_as);
6221 if (!pwd) {
6222 fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6223 exit(1);
6224 }
6225 }
6226
6227 if (chroot_dir) {
6228 if (chroot(chroot_dir) < 0) {
6229 fprintf(stderr, "chroot failed\n");
6230 exit(1);
6231 }
6232 chdir("/");
6233 }
6234
6235 if (run_as) {
6236 if (setgid(pwd->pw_gid) < 0) {
6237 fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6238 exit(1);
6239 }
6240 if (setuid(pwd->pw_uid) < 0) {
6241 fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6242 exit(1);
6243 }
6244 if (setuid(0) != -1) {
6245 fprintf(stderr, "Dropping privileges failed\n");
6246 exit(1);
6247 }
6248 }
0858532e
AL		 6249
6250 if (daemonize) {
6251 dup2(fd, 0);
6252 dup2(fd, 1);
6253 dup2(fd, 2);
71e3ceb8 6254
0858532e 6255 close(fd);
71e3ceb8 6256 }
b9e82a59 6257#endif
71e3ceb8 6258
8a7ddc38 6259 main_loop();
40c3bac3 6260 quit_timers();
63a01ef8 6261 net_cleanup();
b46a8906 6262
0824d6fc
FB		 6263 return 0;
6264}
Qemu copy for testing