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