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