]> git.proxmox.com Git - mirror_qemu.git/blame - vl.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Introduce reset notifier order
[mirror_qemu.git] / vl.c
CommitLineData
0824d6fc 1/*
80cabfad 2 * QEMU System Emulator
5fafdf24 3 *
68d0f70e 4 * Copyright (c) 2003-2008 Fabrice Bellard
5fafdf24 5 *
1df912cf
FB		 6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
0824d6fc 23 */
0824d6fc 24#include <unistd.h>
0824d6fc
FB		 25#include <fcntl.h>
26#include <signal.h>
27#include <time.h>
0824d6fc 28#include <errno.h>
67b915a5 29#include <sys/time.h>
c88676f8 30#include <zlib.h>
67b915a5 31
179a2c19 32/* Needed early for HOST_BSD etc. */
d40cdb10
BS		 33#include "config-host.h"
34
67b915a5 35#ifndef _WIN32
0858532e 36#include <pwd.h>
67b915a5 37#include <sys/times.h>
f1510b2c 38#include <sys/wait.h>
67b915a5 39#include <termios.h>
67b915a5 40#include <sys/mman.h>
f1510b2c 41#include <sys/ioctl.h>
24646c7e 42#include <sys/resource.h>
f1510b2c 43#include <sys/socket.h>
c94c8d64 44#include <netinet/in.h>
24646c7e
BS		 45#include <net/if.h>
46#if defined(__NetBSD__)
47#include <net/if_tap.h>
48#endif
49#ifdef __linux__
50#include <linux/if_tun.h>
51#endif
52#include <arpa/inet.h>
9d728e8c 53#include <dirent.h>
7c9d8e07 54#include <netdb.h>
cb4b976b 55#include <sys/select.h>
179a2c19 56#ifdef HOST_BSD
7d3505c5 57#include <sys/stat.h>
c5e97233 58#if defined(__FreeBSD__) || defined(__DragonFly__)
7d3505c5 59#include <libutil.h>
24646c7e
BS		 60#else
61#include <util.h>
128ab2ff 62#endif
5c40d2bd
TS		 63#elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
64#include <freebsd/stdlib.h>
7d3505c5 65#else
223f0d72 66#ifdef __linux__
7d3505c5
FB		 67#include <pty.h>
68#include <malloc.h>
fd872598 69#include <linux/rtc.h>
bd494f4c
TS		 70
71/* For the benefit of older linux systems which don't supply it,
72 we use a local copy of hpet.h. */
73/* #include <linux/hpet.h> */
74#include "hpet.h"
75
e57a8c0e 76#include <linux/ppdev.h>
5867c88a 77#include <linux/parport.h>
223f0d72
BS		 78#endif
79#ifdef __sun__
d5d10bc3
TS		 80#include <sys/stat.h>
81#include <sys/ethernet.h>
82#include <sys/sockio.h>
d5d10bc3
TS		 83#include <netinet/arp.h>
84#include <netinet/in.h>
85#include <netinet/in_systm.h>
86#include <netinet/ip.h>
87#include <netinet/ip_icmp.h> // must come after ip.h
88#include <netinet/udp.h>
89#include <netinet/tcp.h>
90#include <net/if.h>
91#include <syslog.h>
92#include <stropts.h>
67b915a5 93#endif
7d3505c5 94#endif
ec530c81 95#endif
67b915a5 96
9892fbfb
BS		 97#if defined(__OpenBSD__)
98#include <util.h>
99#endif
100
8a16d273
TS		 101#if defined(CONFIG_VDE)
102#include <libvdeplug.h>
103#endif
104
67b915a5 105#ifdef _WIN32
49dc768d 106#include <windows.h>
7d3505c5 107#include <malloc.h>
67b915a5 108#include <sys/timeb.h>
4fddf62a 109#include <mmsystem.h>
67b915a5
FB		 110#define getopt_long_only getopt_long
111#define memalign(align, size) malloc(size)
112#endif
113
73332e5c 114#ifdef CONFIG_SDL
96bcd4f8 115#ifdef __APPLE__
83fb7adf 116#include <SDL/SDL.h>
880fec5d 117int qemu_main(int argc, char **argv, char **envp);
118int main(int argc, char **argv)
119{
120 qemu_main(argc, argv, NULL);
121}
122#undef main
123#define main qemu_main
96bcd4f8 124#endif
73332e5c 125#endif /* CONFIG_SDL */
0824d6fc 126
5b0753e0
FB		 127#ifdef CONFIG_COCOA
128#undef main
129#define main qemu_main
130#endif /* CONFIG_COCOA */
131
511d2b14
BS		 132#include "hw/hw.h"
133#include "hw/boards.h"
134#include "hw/usb.h"
135#include "hw/pcmcia.h"
136#include "hw/pc.h"
137#include "hw/audiodev.h"
138#include "hw/isa.h"
139#include "hw/baum.h"
140#include "hw/bt.h"
9dd986cc 141#include "hw/watchdog.h"
b6f6e3d3 142#include "hw/smbios.h"
e37630ca 143#include "hw/xen.h"
5ef4efa4 144#include "bt-host.h"
511d2b14
BS		 145#include "net.h"
146#include "monitor.h"
147#include "console.h"
148#include "sysemu.h"
149#include "gdbstub.h"
150#include "qemu-timer.h"
151#include "qemu-char.h"
152#include "cache-utils.h"
153#include "block.h"
a718acec 154#include "dma.h"
511d2b14
BS		 155#include "audio/audio.h"
156#include "migration.h"
157#include "kvm.h"
158#include "balloon.h"
d3f24367 159#include "qemu-option.h"
511d2b14 160
0824d6fc 161#include "disas.h"
fc01f7e7 162
8a7ddc38 163#include "exec-all.h"
0824d6fc 164
511d2b14
BS		 165#include "qemu_socket.h"
166
167#if defined(CONFIG_SLIRP)
168#include "libslirp.h"
169#endif
170
0824d6fc 171//#define DEBUG_UNUSED_IOPORT
fd872598 172//#define DEBUG_IOPORT
9dc63a1e
BS		 173//#define DEBUG_NET
174//#define DEBUG_SLIRP
330d0414 175
d12d51d5
AL		 176
177#ifdef DEBUG_IOPORT
93fcfe39 178# define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
d12d51d5
AL		 179#else
180# define LOG_IOPORT(...) do { } while (0)
181#endif
182
1bfe856e 183#define DEFAULT_RAM_SIZE 128
313aa567 184
0d92ed30
PB		 185/* Max number of USB devices that can be specified on the commandline. */
186#define MAX_USB_CMDLINE 8
187
dc72ac14
AZ		 188/* Max number of bluetooth switches on the commandline. */
189#define MAX_BT_CMDLINE 10
190
7dea1da4
FB		 191/* XXX: use a two level table to limit memory usage */
192#define MAX_IOPORTS 65536
0824d6fc 193
80cabfad 194const char *bios_dir = CONFIG_QEMU_SHAREDIR;
1192dad8 195const char *bios_name = NULL;
dbed7e40
BS		 196static void *ioport_opaque[MAX_IOPORTS];
197static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
198static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
e4bcb14c 199/* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
faea38e7 200 to store the VM snapshots */
e4bcb14c
TS		 201DriveInfo drives_table[MAX_DRIVES+1];
202int nb_drives;
cb5a7aa8 203enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
3023f332 204static DisplayState *display_state;
993fbfdb 205DisplayType display_type = DT_DEFAULT;
3d11d0eb 206const char* keyboard_layout = NULL;
313aa567 207int64_t ticks_per_sec;
00f82b8a 208ram_addr_t ram_size;
c4b1fcc0 209int nb_nics;
7c9d8e07 210NICInfo nd_table[MAX_NICS];
8a7ddc38 211int vm_running;
c0f4ce77 212static int autostart;
f6503059
AZ		 213static int rtc_utc = 1;
214static int rtc_date_offset = -1; /* -1 means no change */
1bfe856e 215int cirrus_vga_enabled = 1;
c2b3b41a 216int std_vga_enabled = 0;
d34cab9f 217int vmsvga_enabled = 0;
94909d9f 218int xenfb_enabled = 0;
d827220b
FB		 219#ifdef TARGET_SPARC
220int graphic_width = 1024;
221int graphic_height = 768;
eee0b836 222int graphic_depth = 8;
d827220b 223#else
1bfe856e
FB		 224int graphic_width = 800;
225int graphic_height = 600;
e9b137c2 226int graphic_depth = 15;
eee0b836 227#endif
dbed7e40 228static int full_screen = 0;
634a21f6 229#ifdef CONFIG_SDL
dbed7e40 230static int no_frame = 0;
634a21f6 231#endif
667accab 232int no_quit = 0;
8d11df9e 233CharDriverState *serial_hds[MAX_SERIAL_PORTS];
6508fe59 234CharDriverState *parallel_hds[MAX_PARALLEL_PORTS];
9ede2fde 235CharDriverState *virtcon_hds[MAX_VIRTIO_CONSOLES];
a09db21f
FB		 236#ifdef TARGET_I386
237int win2k_install_hack = 0;
73822ec8 238int rtc_td_hack = 0;
a09db21f 239#endif
bb36d470 240int usb_enabled = 0;
1b530a6d 241int singlestep = 0;
6a00d601 242int smp_cpus = 1;
73fc9742 243const char *vnc_display;
6515b203 244int acpi_enabled = 1;
16b29ae1 245int no_hpet = 0;
52ca8d6a 246int fd_bootchk = 1;
d1beab82 247int no_reboot = 0;
b2f76161 248int no_shutdown = 0;
9467cd46 249int cursor_hide = 1;
a171fe39 250int graphic_rotate = 0;
b9e82a59 251#ifndef _WIN32
71e3ceb8 252int daemonize = 0;
b9e82a59 253#endif
9dd986cc
RJ		 254WatchdogTimerModel *watchdog = NULL;
255int watchdog_action = WDT_RESET;
9ae02555
TS		 256const char *option_rom[MAX_OPTION_ROMS];
257int nb_option_roms;
8e71621f 258int semihosting_enabled = 0;
2b8f2d41
AZ		 259#ifdef TARGET_ARM
260int old_param = 0;
261#endif
c35734b2 262const char *qemu_name;
3780e197 263int alt_grab = 0;
95efd11c 264#if defined(TARGET_SPARC) || defined(TARGET_PPC)
66508601
BS		 265unsigned int nb_prom_envs = 0;
266const char *prom_envs[MAX_PROM_ENVS];
267#endif
ec691c80
AL		 268int nb_drives_opt;
269struct drive_opt drives_opt[MAX_DRIVES];
0824d6fc 270
268a362c
AL		 271int nb_numa_nodes;
272uint64_t node_mem[MAX_NODES];
273uint64_t node_cpumask[MAX_NODES];
274
ee5605e5
AZ		 275static CPUState *cur_cpu;
276static CPUState *next_cpu;
43b96858 277static int timer_alarm_pending = 1;
bf20dc07 278/* Conversion factor from emulated instructions to virtual clock ticks. */
2e70f6ef 279static int icount_time_shift;
bf20dc07 280/* Arbitrarily pick 1MIPS as the minimum allowable speed. */
2e70f6ef
PB		 281#define MAX_ICOUNT_SHIFT 10
282/* Compensate for varying guest execution speed. */
283static int64_t qemu_icount_bias;
dbed7e40
BS		 284static QEMUTimer *icount_rt_timer;
285static QEMUTimer *icount_vm_timer;
9043b62d 286static QEMUTimer *nographic_timer;
ee5605e5 287
8fcb1b90
BS		 288uint8_t qemu_uuid[16];
289
0824d6fc 290/***********************************************************/
26aa7d72
FB		 291/* x86 ISA bus support */
292
293target_phys_addr_t isa_mem_base = 0;
3de388f6 294PicState2 *isa_pic;
0824d6fc 295
477e3edf
AL		 296static IOPortReadFunc default_ioport_readb, default_ioport_readw, default_ioport_readl;
297static IOPortWriteFunc default_ioport_writeb, default_ioport_writew, default_ioport_writel;
298
299static uint32_t ioport_read(int index, uint32_t address)
300{
301 static IOPortReadFunc *default_func[3] = {
302 default_ioport_readb,
303 default_ioport_readw,
304 default_ioport_readl
305 };
306 IOPortReadFunc *func = ioport_read_table[index][address];
307 if (!func)
308 func = default_func[index];
309 return func(ioport_opaque[address], address);
310}
311
312static void ioport_write(int index, uint32_t address, uint32_t data)
313{
314 static IOPortWriteFunc *default_func[3] = {
315 default_ioport_writeb,
316 default_ioport_writew,
317 default_ioport_writel
318 };
319 IOPortWriteFunc *func = ioport_write_table[index][address];
320 if (!func)
321 func = default_func[index];
322 func(ioport_opaque[address], address, data);
323}
324
9596ebb7 325static uint32_t default_ioport_readb(void *opaque, uint32_t address)
0824d6fc
FB		 326{
327#ifdef DEBUG_UNUSED_IOPORT
1196be37 328 fprintf(stderr, "unused inb: port=0x%04x\n", address);
0824d6fc 329#endif
fc01f7e7 330 return 0xff;
0824d6fc
FB		 331}
332
9596ebb7 333static void default_ioport_writeb(void *opaque, uint32_t address, uint32_t data)
0824d6fc
FB		 334{
335#ifdef DEBUG_UNUSED_IOPORT
1196be37 336 fprintf(stderr, "unused outb: port=0x%04x data=0x%02x\n", address, data);
0824d6fc
FB		 337#endif
338}
339
340/* default is to make two byte accesses */
9596ebb7 341static uint32_t default_ioport_readw(void *opaque, uint32_t address)
0824d6fc
FB		 342{
343 uint32_t data;
477e3edf 344 data = ioport_read(0, address);
db45c29a 345 address = (address + 1) & (MAX_IOPORTS - 1);
477e3edf 346 data |= ioport_read(0, address) << 8;
0824d6fc
FB		 347 return data;
348}
349
9596ebb7 350static void default_ioport_writew(void *opaque, uint32_t address, uint32_t data)
0824d6fc 351{
477e3edf 352 ioport_write(0, address, data & 0xff);
db45c29a 353 address = (address + 1) & (MAX_IOPORTS - 1);
477e3edf 354 ioport_write(0, address, (data >> 8) & 0xff);
0824d6fc
FB		 355}
356
9596ebb7 357static uint32_t default_ioport_readl(void *opaque, uint32_t address)
0824d6fc 358{
fc01f7e7 359#ifdef DEBUG_UNUSED_IOPORT
1196be37 360 fprintf(stderr, "unused inl: port=0x%04x\n", address);
fc01f7e7
FB		 361#endif
362 return 0xffffffff;
0824d6fc
FB		 363}
364
9596ebb7 365static void default_ioport_writel(void *opaque, uint32_t address, uint32_t data)
0824d6fc 366{
fc01f7e7 367#ifdef DEBUG_UNUSED_IOPORT
1196be37 368 fprintf(stderr, "unused outl: port=0x%04x data=0x%02x\n", address, data);
fc01f7e7 369#endif
0824d6fc
FB		 370}
371
fc01f7e7 372/* size is the word size in byte */
5fafdf24 373int register_ioport_read(int start, int length, int size,
c4b1fcc0 374 IOPortReadFunc *func, void *opaque)
f1510b2c 375{
fc01f7e7 376 int i, bsize;
f1510b2c 377
c4b1fcc0 378 if (size == 1) {
fc01f7e7 379 bsize = 0;
c4b1fcc0 380 } else if (size == 2) {
fc01f7e7 381 bsize = 1;
c4b1fcc0 382 } else if (size == 4) {
fc01f7e7 383 bsize = 2;
c4b1fcc0 384 } else {
88fdf56f 385 hw_error("register_ioport_read: invalid size");
fc01f7e7 386 return -1;
c4b1fcc0
FB		 387 }
388 for(i = start; i < start + length; i += size) {
fc01f7e7 389 ioport_read_table[bsize][i] = func;
c4b1fcc0 390 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
88fdf56f 391 hw_error("register_ioport_read: invalid opaque");
c4b1fcc0
FB		 392 ioport_opaque[i] = opaque;
393 }
f1510b2c
FB		 394 return 0;
395}
396
fc01f7e7 397/* size is the word size in byte */
5fafdf24 398int register_ioport_write(int start, int length, int size,
c4b1fcc0 399 IOPortWriteFunc *func, void *opaque)
f1510b2c 400{
fc01f7e7 401 int i, bsize;
f1510b2c 402
c4b1fcc0 403 if (size == 1) {
fc01f7e7 404 bsize = 0;
c4b1fcc0 405 } else if (size == 2) {
fc01f7e7 406 bsize = 1;
c4b1fcc0 407 } else if (size == 4) {
fc01f7e7 408 bsize = 2;
c4b1fcc0 409 } else {
88fdf56f 410 hw_error("register_ioport_write: invalid size");
fc01f7e7 411 return -1;
c4b1fcc0
FB		 412 }
413 for(i = start; i < start + length; i += size) {
fc01f7e7 414 ioport_write_table[bsize][i] = func;
88fdf56f
AZ		 415 if (ioport_opaque[i] != NULL && ioport_opaque[i] != opaque)
416 hw_error("register_ioport_write: invalid opaque");
c4b1fcc0
FB		 417 ioport_opaque[i] = opaque;
418 }
f1510b2c
FB		 419 return 0;
420}
421
69b91039
FB		 422void isa_unassign_ioport(int start, int length)
423{
424 int i;
425
426 for(i = start; i < start + length; i++) {
427 ioport_read_table[0][i] = default_ioport_readb;
428 ioport_read_table[1][i] = default_ioport_readw;
429 ioport_read_table[2][i] = default_ioport_readl;
430
431 ioport_write_table[0][i] = default_ioport_writeb;
432 ioport_write_table[1][i] = default_ioport_writew;
433 ioport_write_table[2][i] = default_ioport_writel;
a7607f7e
AL		 434
435 ioport_opaque[i] = NULL;
69b91039
FB		 436 }
437}
438
20f32282
FB		 439/***********************************************************/
440
c45886db 441void cpu_outb(CPUState *env, int addr, int val)
0824d6fc 442{
d12d51d5 443 LOG_IOPORT("outb: %04x %02x\n", addr, val);
477e3edf 444 ioport_write(0, addr, val);
640f42e4 445#ifdef CONFIG_KQEMU
89bfc105
FB		 446 if (env)
447 env->last_io_time = cpu_get_time_fast();
448#endif
0824d6fc
FB		 449}
450
c45886db 451void cpu_outw(CPUState *env, int addr, int val)
0824d6fc 452{
d12d51d5 453 LOG_IOPORT("outw: %04x %04x\n", addr, val);
477e3edf 454 ioport_write(1, addr, val);
640f42e4 455#ifdef CONFIG_KQEMU
89bfc105
FB		 456 if (env)
457 env->last_io_time = cpu_get_time_fast();
458#endif
0824d6fc
FB		 459}
460
c45886db 461void cpu_outl(CPUState *env, int addr, int val)
0824d6fc 462{
d12d51d5 463 LOG_IOPORT("outl: %04x %08x\n", addr, val);
477e3edf 464 ioport_write(2, addr, val);
640f42e4 465#ifdef CONFIG_KQEMU
89bfc105
FB		 466 if (env)
467 env->last_io_time = cpu_get_time_fast();
468#endif
0824d6fc
FB		 469}
470
c45886db 471int cpu_inb(CPUState *env, int addr)
0824d6fc 472{
fd872598 473 int val;
477e3edf 474 val = ioport_read(0, addr);
d12d51d5 475 LOG_IOPORT("inb : %04x %02x\n", addr, val);
640f42e4 476#ifdef CONFIG_KQEMU
89bfc105
FB		 477 if (env)
478 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 479#endif
480 return val;
0824d6fc
FB		 481}
482
c45886db 483int cpu_inw(CPUState *env, int addr)
0824d6fc 484{
fd872598 485 int val;
477e3edf 486 val = ioport_read(1, addr);
d12d51d5 487 LOG_IOPORT("inw : %04x %04x\n", addr, val);
640f42e4 488#ifdef CONFIG_KQEMU
89bfc105
FB		 489 if (env)
490 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 491#endif
492 return val;
0824d6fc
FB		 493}
494
c45886db 495int cpu_inl(CPUState *env, int addr)
0824d6fc 496{
fd872598 497 int val;
477e3edf 498 val = ioport_read(2, addr);
d12d51d5 499 LOG_IOPORT("inl : %04x %08x\n", addr, val);
640f42e4 500#ifdef CONFIG_KQEMU
89bfc105
FB		 501 if (env)
502 env->last_io_time = cpu_get_time_fast();
fd872598
FB		 503#endif
504 return val;
0824d6fc
FB		 505}
506
507/***********************************************************/
0824d6fc
FB		 508void hw_error(const char *fmt, ...)
509{
510 va_list ap;
6a00d601 511 CPUState *env;
0824d6fc
FB		 512
513 va_start(ap, fmt);
514 fprintf(stderr, "qemu: hardware error: ");
515 vfprintf(stderr, fmt, ap);
516 fprintf(stderr, "\n");
6a00d601
FB		 517 for(env = first_cpu; env != NULL; env = env->next_cpu) {
518 fprintf(stderr, "CPU #%d:\n", env->cpu_index);
0824d6fc 519#ifdef TARGET_I386
6a00d601 520 cpu_dump_state(env, stderr, fprintf, X86_DUMP_FPU);
c45886db 521#else
6a00d601 522 cpu_dump_state(env, stderr, fprintf, 0);
0824d6fc 523#endif
6a00d601 524 }
0824d6fc
FB		 525 va_end(ap);
526 abort();
527}
df751fa8
AL		 528
529/***************/
530/* ballooning */
531
532static QEMUBalloonEvent *qemu_balloon_event;
533void *qemu_balloon_event_opaque;
534
535void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
536{
537 qemu_balloon_event = func;
538 qemu_balloon_event_opaque = opaque;
539}
540
541void qemu_balloon(ram_addr_t target)
542{
543 if (qemu_balloon_event)
544 qemu_balloon_event(qemu_balloon_event_opaque, target);
545}
546
547ram_addr_t qemu_balloon_status(void)
548{
549 if (qemu_balloon_event)
550 return qemu_balloon_event(qemu_balloon_event_opaque, 0);
551 return 0;
552}
0824d6fc 553
63066f4f
FB		 554/***********************************************************/
555/* keyboard/mouse */
556
557static QEMUPutKBDEvent *qemu_put_kbd_event;
558static void *qemu_put_kbd_event_opaque;
455204eb
TS		 559static QEMUPutMouseEntry *qemu_put_mouse_event_head;
560static QEMUPutMouseEntry *qemu_put_mouse_event_current;
63066f4f
FB		 561
562void qemu_add_kbd_event_handler(QEMUPutKBDEvent *func, void *opaque)
563{
564 qemu_put_kbd_event_opaque = opaque;
565 qemu_put_kbd_event = func;
566}
567
455204eb
TS		 568QEMUPutMouseEntry *qemu_add_mouse_event_handler(QEMUPutMouseEvent *func,
569 void *opaque, int absolute,
570 const char *name)
63066f4f 571{
455204eb
TS		 572 QEMUPutMouseEntry *s, *cursor;
573
574 s = qemu_mallocz(sizeof(QEMUPutMouseEntry));
455204eb
TS		 575
576 s->qemu_put_mouse_event = func;
577 s->qemu_put_mouse_event_opaque = opaque;
578 s->qemu_put_mouse_event_absolute = absolute;
579 s->qemu_put_mouse_event_name = qemu_strdup(name);
580 s->next = NULL;
581
582 if (!qemu_put_mouse_event_head) {
583 qemu_put_mouse_event_head = qemu_put_mouse_event_current = s;
584 return s;
585 }
586
587 cursor = qemu_put_mouse_event_head;
588 while (cursor->next != NULL)
589 cursor = cursor->next;
590
591 cursor->next = s;
592 qemu_put_mouse_event_current = s;
593
594 return s;
595}
596
597void qemu_remove_mouse_event_handler(QEMUPutMouseEntry *entry)
598{
599 QEMUPutMouseEntry *prev = NULL, *cursor;
600
601 if (!qemu_put_mouse_event_head || entry == NULL)
602 return;
603
604 cursor = qemu_put_mouse_event_head;
605 while (cursor != NULL && cursor != entry) {
606 prev = cursor;
607 cursor = cursor->next;
608 }
609
610 if (cursor == NULL) // does not exist or list empty
611 return;
612 else if (prev == NULL) { // entry is head
613 qemu_put_mouse_event_head = cursor->next;
614 if (qemu_put_mouse_event_current == entry)
615 qemu_put_mouse_event_current = cursor->next;
616 qemu_free(entry->qemu_put_mouse_event_name);
617 qemu_free(entry);
618 return;
619 }
620
621 prev->next = entry->next;
622
623 if (qemu_put_mouse_event_current == entry)
624 qemu_put_mouse_event_current = prev;
625
626 qemu_free(entry->qemu_put_mouse_event_name);
627 qemu_free(entry);
63066f4f
FB		 628}
629
630void kbd_put_keycode(int keycode)
631{
632 if (qemu_put_kbd_event) {
633 qemu_put_kbd_event(qemu_put_kbd_event_opaque, keycode);
634 }
635}
636
637void kbd_mouse_event(int dx, int dy, int dz, int buttons_state)
638{
455204eb
TS		 639 QEMUPutMouseEvent *mouse_event;
640 void *mouse_event_opaque;
a171fe39 641 int width;
455204eb
TS		 642
643 if (!qemu_put_mouse_event_current) {
644 return;
645 }
646
647 mouse_event =
648 qemu_put_mouse_event_current->qemu_put_mouse_event;
649 mouse_event_opaque =
650 qemu_put_mouse_event_current->qemu_put_mouse_event_opaque;
651
652 if (mouse_event) {
a171fe39
AZ		 653 if (graphic_rotate) {
654 if (qemu_put_mouse_event_current->qemu_put_mouse_event_absolute)
655 width = 0x7fff;
656 else
b94ed577 657 width = graphic_width - 1;
a171fe39
AZ		 658 mouse_event(mouse_event_opaque,
659 width - dy, dx, dz, buttons_state);
660 } else
661 mouse_event(mouse_event_opaque,
662 dx, dy, dz, buttons_state);
63066f4f
FB		 663 }
664}
665
09b26c5e
FB		 666int kbd_mouse_is_absolute(void)
667{
455204eb
TS		 668 if (!qemu_put_mouse_event_current)
669 return 0;
670
671 return qemu_put_mouse_event_current->qemu_put_mouse_event_absolute;
672}
673
376253ec 674void do_info_mice(Monitor *mon)
455204eb
TS		 675{
676 QEMUPutMouseEntry *cursor;
677 int index = 0;
678
679 if (!qemu_put_mouse_event_head) {
376253ec 680 monitor_printf(mon, "No mouse devices connected\n");
455204eb
TS		 681 return;
682 }
683
376253ec 684 monitor_printf(mon, "Mouse devices available:\n");
455204eb
TS		 685 cursor = qemu_put_mouse_event_head;
686 while (cursor != NULL) {
376253ec
AL		 687 monitor_printf(mon, "%c Mouse #%d: %s\n",
688 (cursor == qemu_put_mouse_event_current ? '*' : ' '),
689 index, cursor->qemu_put_mouse_event_name);
455204eb
TS		 690 index++;
691 cursor = cursor->next;
692 }
693}
694
376253ec 695void do_mouse_set(Monitor *mon, int index)
455204eb
TS		 696{
697 QEMUPutMouseEntry *cursor;
698 int i = 0;
699
700 if (!qemu_put_mouse_event_head) {
376253ec 701 monitor_printf(mon, "No mouse devices connected\n");
455204eb
TS		 702 return;
703 }
704
705 cursor = qemu_put_mouse_event_head;
706 while (cursor != NULL && index != i) {
707 i++;
708 cursor = cursor->next;
709 }
710
711 if (cursor != NULL)
712 qemu_put_mouse_event_current = cursor;
713 else
376253ec 714 monitor_printf(mon, "Mouse at given index not found\n");
09b26c5e
FB		 715}
716
1dce7c3c
FB		 717/* compute with 96 bit intermediate result: (a*b)/c */
718uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
0824d6fc 719{
1dce7c3c
FB		 720 union {
721 uint64_t ll;
722 struct {
723#ifdef WORDS_BIGENDIAN
724 uint32_t high, low;
725#else
726 uint32_t low, high;
3b46e624 727#endif
1dce7c3c
FB		 728 } l;
729 } u, res;
730 uint64_t rl, rh;
0824d6fc 731
1dce7c3c
FB		 732 u.ll = a;
733 rl = (uint64_t)u.l.low * (uint64_t)b;
734 rh = (uint64_t)u.l.high * (uint64_t)b;
735 rh += (rl >> 32);
736 res.l.high = rh / c;
737 res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
738 return res.ll;
34865134
FB		 739}
740
1dce7c3c
FB		 741/***********************************************************/
742/* real time host monotonic timer */
34865134 743
1dce7c3c 744#define QEMU_TIMER_BASE 1000000000LL
34865134 745
1dce7c3c 746#ifdef WIN32
0824d6fc 747
1dce7c3c 748static int64_t clock_freq;
1115dde7 749
1dce7c3c 750static void init_get_clock(void)
1115dde7 751{
a8e5ac33
FB		 752 LARGE_INTEGER freq;
753 int ret;
1dce7c3c
FB		 754 ret = QueryPerformanceFrequency(&freq);
755 if (ret == 0) {
756 fprintf(stderr, "Could not calibrate ticks\n");
757 exit(1);
758 }
759 clock_freq = freq.QuadPart;
1115dde7
FB		 760}
761
1dce7c3c 762static int64_t get_clock(void)
b8076a74 763{
1dce7c3c
FB		 764 LARGE_INTEGER ti;
765 QueryPerformanceCounter(&ti);
766 return muldiv64(ti.QuadPart, QEMU_TIMER_BASE, clock_freq);
b8076a74
FB		 767}
768
1dce7c3c 769#else
90cb9493 770
1dce7c3c
FB		 771static int use_rt_clock;
772
773static void init_get_clock(void)
90cb9493 774{
1dce7c3c 775 use_rt_clock = 0;
c5e97233
BS		 776#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
777 || defined(__DragonFly__)
1dce7c3c
FB		 778 {
779 struct timespec ts;
780 if (clock_gettime(CLOCK_MONOTONIC, &ts) == 0) {
781 use_rt_clock = 1;
782 }
783 }
784#endif
90cb9493
FB		 785}
786
1dce7c3c 787static int64_t get_clock(void)
fdbb4691 788{
c5e97233
BS		 789#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
790 || defined(__DragonFly__)
1dce7c3c
FB		 791 if (use_rt_clock) {
792 struct timespec ts;
793 clock_gettime(CLOCK_MONOTONIC, &ts);
794 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
5fafdf24 795 } else
fdbb4691 796#endif
1dce7c3c
FB		 797 {
798 /* XXX: using gettimeofday leads to problems if the date
799 changes, so it should be avoided. */
800 struct timeval tv;
801 gettimeofday(&tv, NULL);
802 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
803 }
fdbb4691 804}
34865134
FB		 805#endif
806
2e70f6ef
PB		 807/* Return the virtual CPU time, based on the instruction counter. */
808static int64_t cpu_get_icount(void)
809{
810 int64_t icount;
811 CPUState *env = cpu_single_env;;
812 icount = qemu_icount;
813 if (env) {
814 if (!can_do_io(env))
815 fprintf(stderr, "Bad clock read\n");
816 icount -= (env->icount_decr.u16.low + env->icount_extra);
817 }
818 return qemu_icount_bias + (icount << icount_time_shift);
819}
820
1dce7c3c
FB		 821/***********************************************************/
822/* guest cycle counter */
823
eade0f19 824static int64_t cpu_ticks_prev;
34865134 825static int64_t cpu_ticks_offset;
1dce7c3c 826static int64_t cpu_clock_offset;
8a7ddc38 827static int cpu_ticks_enabled;
34865134 828
1dce7c3c
FB		 829/* return the host CPU cycle counter and handle stop/restart */
830int64_t cpu_get_ticks(void)
34865134 831{
2e70f6ef
PB		 832 if (use_icount) {
833 return cpu_get_icount();
834 }
8a7ddc38
FB		 835 if (!cpu_ticks_enabled) {
836 return cpu_ticks_offset;
837 } else {
eade0f19
FB		 838 int64_t ticks;
839 ticks = cpu_get_real_ticks();
840 if (cpu_ticks_prev > ticks) {
841 /* Note: non increasing ticks may happen if the host uses
842 software suspend */
843 cpu_ticks_offset += cpu_ticks_prev - ticks;
844 }
845 cpu_ticks_prev = ticks;
846 return ticks + cpu_ticks_offset;
8a7ddc38 847 }
34865134
FB		 848}
849
1dce7c3c
FB		 850/* return the host CPU monotonic timer and handle stop/restart */
851static int64_t cpu_get_clock(void)
852{
853 int64_t ti;
854 if (!cpu_ticks_enabled) {
855 return cpu_clock_offset;
856 } else {
857 ti = get_clock();
858 return ti + cpu_clock_offset;
859 }
860}
861
34865134
FB		 862/* enable cpu_get_ticks() */
863void cpu_enable_ticks(void)
864{
8a7ddc38
FB		 865 if (!cpu_ticks_enabled) {
866 cpu_ticks_offset -= cpu_get_real_ticks();
1dce7c3c 867 cpu_clock_offset -= get_clock();
8a7ddc38
FB		 868 cpu_ticks_enabled = 1;
869 }
34865134
FB		 870}
871
872/* disable cpu_get_ticks() : the clock is stopped. You must not call
873 cpu_get_ticks() after that. */
874void cpu_disable_ticks(void)
875{
8a7ddc38
FB		 876 if (cpu_ticks_enabled) {
877 cpu_ticks_offset = cpu_get_ticks();
1dce7c3c 878 cpu_clock_offset = cpu_get_clock();
8a7ddc38
FB		 879 cpu_ticks_enabled = 0;
880 }
34865134
FB		 881}
882
1dce7c3c
FB		 883/***********************************************************/
884/* timers */
5fafdf24 885
8a7ddc38
FB		 886#define QEMU_TIMER_REALTIME 0
887#define QEMU_TIMER_VIRTUAL 1
888
889struct QEMUClock {
890 int type;
891 /* XXX: add frequency */
892};
893
894struct QEMUTimer {
895 QEMUClock *clock;
896 int64_t expire_time;
897 QEMUTimerCB *cb;
898 void *opaque;
899 struct QEMUTimer *next;
900};
901
c8994013
TS		 902struct qemu_alarm_timer {
903 char const *name;
efe75411 904 unsigned int flags;
c8994013
TS		 905
906 int (*start)(struct qemu_alarm_timer *t);
907 void (*stop)(struct qemu_alarm_timer *t);
efe75411 908 void (*rearm)(struct qemu_alarm_timer *t);
c8994013
TS		 909 void *priv;
910};
911
efe75411 912#define ALARM_FLAG_DYNTICKS 0x1
d5d08334 913#define ALARM_FLAG_EXPIRED 0x2
efe75411
TS		 914
915static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
916{
e332340a 917 return t && (t->flags & ALARM_FLAG_DYNTICKS);
efe75411
TS		 918}
919
920static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
921{
922 if (!alarm_has_dynticks(t))
923 return;
924
925 t->rearm(t);
926}
927
928/* TODO: MIN_TIMER_REARM_US should be optimized */
929#define MIN_TIMER_REARM_US 250
930
c8994013 931static struct qemu_alarm_timer *alarm_timer;
8a7ddc38 932
40c3bac3 933#ifdef _WIN32
c8994013
TS		 934
935struct qemu_alarm_win32 {
936 MMRESULT timerId;
c8994013 937 unsigned int period;
ef28c4b0 938} alarm_win32_data = {0, -1};
c8994013
TS		 939
940static int win32_start_timer(struct qemu_alarm_timer *t);
941static void win32_stop_timer(struct qemu_alarm_timer *t);
efe75411 942static void win32_rearm_timer(struct qemu_alarm_timer *t);
c8994013 943
40c3bac3 944#else
c8994013
TS		 945
946static int unix_start_timer(struct qemu_alarm_timer *t);
947static void unix_stop_timer(struct qemu_alarm_timer *t);
948
231c6586
TS		 949#ifdef __linux__
950
efe75411
TS		 951static int dynticks_start_timer(struct qemu_alarm_timer *t);
952static void dynticks_stop_timer(struct qemu_alarm_timer *t);
953static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
954
c40ec5a9
TS		 955static int hpet_start_timer(struct qemu_alarm_timer *t);
956static void hpet_stop_timer(struct qemu_alarm_timer *t);
957
c8994013
TS		 958static int rtc_start_timer(struct qemu_alarm_timer *t);
959static void rtc_stop_timer(struct qemu_alarm_timer *t);
960
efe75411 961#endif /* __linux__ */
8a7ddc38 962
c8994013
TS		 963#endif /* _WIN32 */
964
2e70f6ef 965/* Correlation between real and virtual time is always going to be
bf20dc07 966 fairly approximate, so ignore small variation.
2e70f6ef
PB		 967 When the guest is idle real and virtual time will be aligned in
968 the IO wait loop. */
969#define ICOUNT_WOBBLE (QEMU_TIMER_BASE / 10)
970
971static void icount_adjust(void)
972{
973 int64_t cur_time;
974 int64_t cur_icount;
975 int64_t delta;
976 static int64_t last_delta;
977 /* If the VM is not running, then do nothing. */
978 if (!vm_running)
979 return;
980
981 cur_time = cpu_get_clock();
982 cur_icount = qemu_get_clock(vm_clock);
983 delta = cur_icount - cur_time;
984 /* FIXME: This is a very crude algorithm, somewhat prone to oscillation. */
985 if (delta > 0
986 && last_delta + ICOUNT_WOBBLE < delta * 2
987 && icount_time_shift > 0) {
988 /* The guest is getting too far ahead. Slow time down. */
989 icount_time_shift--;
990 }
991 if (delta < 0
992 && last_delta - ICOUNT_WOBBLE > delta * 2
993 && icount_time_shift < MAX_ICOUNT_SHIFT) {
994 /* The guest is getting too far behind. Speed time up. */
995 icount_time_shift++;
996 }
997 last_delta = delta;
998 qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
999}
1000
1001static void icount_adjust_rt(void * opaque)
1002{
1003 qemu_mod_timer(icount_rt_timer,
1004 qemu_get_clock(rt_clock) + 1000);
1005 icount_adjust();
1006}
1007
1008static void icount_adjust_vm(void * opaque)
1009{
1010 qemu_mod_timer(icount_vm_timer,
1011 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1012 icount_adjust();
1013}
1014
1015static void init_icount_adjust(void)
1016{
1017 /* Have both realtime and virtual time triggers for speed adjustment.
1018 The realtime trigger catches emulated time passing too slowly,
1019 the virtual time trigger catches emulated time passing too fast.
1020 Realtime triggers occur even when idle, so use them less frequently
1021 than VM triggers. */
1022 icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL);
1023 qemu_mod_timer(icount_rt_timer,
1024 qemu_get_clock(rt_clock) + 1000);
1025 icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
1026 qemu_mod_timer(icount_vm_timer,
1027 qemu_get_clock(vm_clock) + QEMU_TIMER_BASE / 10);
1028}
1029
c8994013 1030static struct qemu_alarm_timer alarm_timers[] = {
efe75411 1031#ifndef _WIN32
231c6586 1032#ifdef __linux__
efe75411
TS		 1033 {"dynticks", ALARM_FLAG_DYNTICKS, dynticks_start_timer,
1034 dynticks_stop_timer, dynticks_rearm_timer, NULL},
c40ec5a9 1035 /* HPET - if available - is preferred */
efe75411 1036 {"hpet", 0, hpet_start_timer, hpet_stop_timer, NULL, NULL},
c40ec5a9 1037 /* ...otherwise try RTC */
efe75411 1038 {"rtc", 0, rtc_start_timer, rtc_stop_timer, NULL, NULL},
c8994013 1039#endif
efe75411 1040 {"unix", 0, unix_start_timer, unix_stop_timer, NULL, NULL},
c8994013 1041#else
efe75411
TS		 1042 {"dynticks", ALARM_FLAG_DYNTICKS, win32_start_timer,
1043 win32_stop_timer, win32_rearm_timer, &alarm_win32_data},
1044 {"win32", 0, win32_start_timer,
1045 win32_stop_timer, NULL, &alarm_win32_data},
c8994013
TS		 1046#endif
1047 {NULL, }
1048};
1049
3f47aa8c 1050static void show_available_alarms(void)
f3dcfada
TS		 1051{
1052 int i;
1053
1054 printf("Available alarm timers, in order of precedence:\n");
1055 for (i = 0; alarm_timers[i].name; i++)
1056 printf("%s\n", alarm_timers[i].name);
1057}
1058
1059static void configure_alarms(char const *opt)
1060{
1061 int i;
1062 int cur = 0;
b1503cda 1063 int count = ARRAY_SIZE(alarm_timers) - 1;
f3dcfada
TS		 1064 char *arg;
1065 char *name;
2e70f6ef 1066 struct qemu_alarm_timer tmp;
f3dcfada 1067
3adda04c 1068 if (!strcmp(opt, "?")) {
f3dcfada
TS		 1069 show_available_alarms();
1070 exit(0);
1071 }
1072
1073 arg = strdup(opt);
1074
1075 /* Reorder the array */
1076 name = strtok(arg, ",");
1077 while (name) {
e2b577e5 1078 for (i = 0; i < count && alarm_timers[i].name; i++) {
f3dcfada
TS		 1079 if (!strcmp(alarm_timers[i].name, name))
1080 break;
1081 }
1082
1083 if (i == count) {
1084 fprintf(stderr, "Unknown clock %s\n", name);
1085 goto next;
1086 }
1087
1088 if (i < cur)
1089 /* Ignore */
1090 goto next;
1091
1092 /* Swap */
1093 tmp = alarm_timers[i];
1094 alarm_timers[i] = alarm_timers[cur];
1095 alarm_timers[cur] = tmp;
1096
1097 cur++;
1098next:
1099 name = strtok(NULL, ",");
1100 }
1101
1102 free(arg);
1103
1104 if (cur) {
2e70f6ef 1105 /* Disable remaining timers */
f3dcfada
TS		 1106 for (i = cur; i < count; i++)
1107 alarm_timers[i].name = NULL;
3adda04c
AJ		 1108 } else {
1109 show_available_alarms();
1110 exit(1);
f3dcfada 1111 }
f3dcfada
TS		 1112}
1113
c8994013
TS		 1114QEMUClock *rt_clock;
1115QEMUClock *vm_clock;
1116
1117static QEMUTimer *active_timers[2];
1118
9596ebb7 1119static QEMUClock *qemu_new_clock(int type)
8a7ddc38
FB		 1120{
1121 QEMUClock *clock;
1122 clock = qemu_mallocz(sizeof(QEMUClock));
8a7ddc38
FB		 1123 clock->type = type;
1124 return clock;
1125}
1126
1127QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque)
1128{
1129 QEMUTimer *ts;
1130
1131 ts = qemu_mallocz(sizeof(QEMUTimer));
1132 ts->clock = clock;
1133 ts->cb = cb;
1134 ts->opaque = opaque;
1135 return ts;
1136}
1137
1138void qemu_free_timer(QEMUTimer *ts)
1139{
1140 qemu_free(ts);
1141}
1142
1143/* stop a timer, but do not dealloc it */
1144void qemu_del_timer(QEMUTimer *ts)
1145{
1146 QEMUTimer **pt, *t;
1147
1148 /* NOTE: this code must be signal safe because
1149 qemu_timer_expired() can be called from a signal. */
1150 pt = &active_timers[ts->clock->type];
1151 for(;;) {
1152 t = *pt;
1153 if (!t)
1154 break;
1155 if (t == ts) {
1156 *pt = t->next;
1157 break;
1158 }
1159 pt = &t->next;
1160 }
1161}
1162
1163/* modify the current timer so that it will be fired when current_time
1164 >= expire_time. The corresponding callback will be called. */
1165void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
1166{
1167 QEMUTimer **pt, *t;
1168
1169 qemu_del_timer(ts);
1170
1171 /* add the timer in the sorted list */
1172 /* NOTE: this code must be signal safe because
1173 qemu_timer_expired() can be called from a signal. */
1174 pt = &active_timers[ts->clock->type];
1175 for(;;) {
1176 t = *pt;
1177 if (!t)
1178 break;
5fafdf24 1179 if (t->expire_time > expire_time)
8a7ddc38
FB		 1180 break;
1181 pt = &t->next;
1182 }
1183 ts->expire_time = expire_time;
1184 ts->next = *pt;
1185 *pt = ts;
d5d08334
AZ		 1186
1187 /* Rearm if necessary */
2e70f6ef
PB		 1188 if (pt == &active_timers[ts->clock->type]) {
1189 if ((alarm_timer->flags & ALARM_FLAG_EXPIRED) == 0) {
1190 qemu_rearm_alarm_timer(alarm_timer);
1191 }
1192 /* Interrupt execution to force deadline recalculation. */
d9f75a4e
AL		 1193 if (use_icount)
1194 qemu_notify_event();
2e70f6ef 1195 }
8a7ddc38
FB		 1196}
1197
1198int qemu_timer_pending(QEMUTimer *ts)
1199{
1200 QEMUTimer *t;
1201 for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
1202 if (t == ts)
1203 return 1;
1204 }
1205 return 0;
1206}
1207
1208static inline int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
1209{
1210 if (!timer_head)
1211 return 0;
1212 return (timer_head->expire_time <= current_time);
1213}
1214
1215static void qemu_run_timers(QEMUTimer **ptimer_head, int64_t current_time)
1216{
1217 QEMUTimer *ts;
3b46e624 1218
8a7ddc38
FB		 1219 for(;;) {
1220 ts = *ptimer_head;
e95c8d51 1221 if (!ts || ts->expire_time > current_time)
8a7ddc38
FB		 1222 break;
1223 /* remove timer from the list before calling the callback */
1224 *ptimer_head = ts->next;
1225 ts->next = NULL;
3b46e624 1226
8a7ddc38
FB		 1227 /* run the callback (the timer list can be modified) */
1228 ts->cb(ts->opaque);
1229 }
1230}
1231
1232int64_t qemu_get_clock(QEMUClock *clock)
1233{
1234 switch(clock->type) {
1235 case QEMU_TIMER_REALTIME:
1dce7c3c 1236 return get_clock() / 1000000;
8a7ddc38
FB		 1237 default:
1238 case QEMU_TIMER_VIRTUAL:
2e70f6ef
PB		 1239 if (use_icount) {
1240 return cpu_get_icount();
1241 } else {
1242 return cpu_get_clock();
1243 }
8a7ddc38
FB		 1244 }
1245}
1246
1dce7c3c
FB		 1247static void init_timers(void)
1248{
1249 init_get_clock();
1250 ticks_per_sec = QEMU_TIMER_BASE;
1251 rt_clock = qemu_new_clock(QEMU_TIMER_REALTIME);
1252 vm_clock = qemu_new_clock(QEMU_TIMER_VIRTUAL);
1253}
1254
8a7ddc38
FB		 1255/* save a timer */
1256void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
1257{
1258 uint64_t expire_time;
1259
1260 if (qemu_timer_pending(ts)) {
1261 expire_time = ts->expire_time;
1262 } else {
1263 expire_time = -1;
1264 }
1265 qemu_put_be64(f, expire_time);
1266}
1267
1268void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
1269{
1270 uint64_t expire_time;
1271
1272 expire_time = qemu_get_be64(f);
1273 if (expire_time != -1) {
1274 qemu_mod_timer(ts, expire_time);
1275 } else {
1276 qemu_del_timer(ts);
1277 }
1278}
1279
1280static void timer_save(QEMUFile *f, void *opaque)
1281{
1282 if (cpu_ticks_enabled) {
1283 hw_error("cannot save state if virtual timers are running");
1284 }
bee8d684
TS		 1285 qemu_put_be64(f, cpu_ticks_offset);
1286 qemu_put_be64(f, ticks_per_sec);
1287 qemu_put_be64(f, cpu_clock_offset);
8a7ddc38
FB		 1288}
1289
1290static int timer_load(QEMUFile *f, void *opaque, int version_id)
1291{
c88676f8 1292 if (version_id != 1 && version_id != 2)
8a7ddc38
FB		 1293 return -EINVAL;
1294 if (cpu_ticks_enabled) {
1295 return -EINVAL;
1296 }
bee8d684
TS		 1297 cpu_ticks_offset=qemu_get_be64(f);
1298 ticks_per_sec=qemu_get_be64(f);
c88676f8 1299 if (version_id == 2) {
bee8d684 1300 cpu_clock_offset=qemu_get_be64(f);
c88676f8 1301 }
8a7ddc38
FB		 1302 return 0;
1303}
1304
50317c7f
AL		 1305static void qemu_event_increment(void);
1306
67b915a5 1307#ifdef _WIN32
b9e82a59
BS		 1308static void CALLBACK host_alarm_handler(UINT uTimerID, UINT uMsg,
1309 DWORD_PTR dwUser, DWORD_PTR dw1,
1310 DWORD_PTR dw2)
67b915a5 1311#else
8a7ddc38 1312static void host_alarm_handler(int host_signum)
67b915a5 1313#endif
8a7ddc38 1314{
02ba45c5
FB		 1315#if 0
1316#define DISP_FREQ 1000
1317 {
1318 static int64_t delta_min = INT64_MAX;
1319 static int64_t delta_max, delta_cum, last_clock, delta, ti;
1320 static int count;
1321 ti = qemu_get_clock(vm_clock);
1322 if (last_clock != 0) {
1323 delta = ti - last_clock;
1324 if (delta < delta_min)
1325 delta_min = delta;
1326 if (delta > delta_max)
1327 delta_max = delta;
1328 delta_cum += delta;
1329 if (++count == DISP_FREQ) {
26a76461 1330 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
02ba45c5
FB		 1331 muldiv64(delta_min, 1000000, ticks_per_sec),
1332 muldiv64(delta_max, 1000000, ticks_per_sec),
1333 muldiv64(delta_cum, 1000000 / DISP_FREQ, ticks_per_sec),
1334 (double)ticks_per_sec / ((double)delta_cum / DISP_FREQ));
1335 count = 0;
1336 delta_min = INT64_MAX;
1337 delta_max = 0;
1338 delta_cum = 0;
1339 }
1340 }
1341 last_clock = ti;
1342 }
1343#endif
efe75411 1344 if (alarm_has_dynticks(alarm_timer) ||
2e70f6ef
PB		 1345 (!use_icount &&
1346 qemu_timer_expired(active_timers[QEMU_TIMER_VIRTUAL],
1347 qemu_get_clock(vm_clock))) ||
8a7ddc38
FB		 1348 qemu_timer_expired(active_timers[QEMU_TIMER_REALTIME],
1349 qemu_get_clock(rt_clock))) {
50317c7f 1350 qemu_event_increment();
e332340a 1351 if (alarm_timer) alarm_timer->flags |= ALARM_FLAG_EXPIRED;
d5d08334 1352
d6dc3d42
AL		 1353#ifndef CONFIG_IOTHREAD
1354 if (next_cpu) {
4f8eb8da 1355 /* stop the currently executing cpu because a timer occured */
d6dc3d42 1356 cpu_exit(next_cpu);
640f42e4 1357#ifdef CONFIG_KQEMU
d6dc3d42
AL		 1358 if (next_cpu->kqemu_enabled) {
1359 kqemu_cpu_interrupt(next_cpu);
4f8eb8da 1360 }
ee5605e5 1361#endif
4f8eb8da 1362 }
d6dc3d42 1363#endif
43b96858 1364 timer_alarm_pending = 1;
d9f75a4e 1365 qemu_notify_event();
8a7ddc38
FB		 1366 }
1367}
1368
2e70f6ef 1369static int64_t qemu_next_deadline(void)
efe75411 1370{
2e70f6ef 1371 int64_t delta;
efe75411
TS		 1372
1373 if (active_timers[QEMU_TIMER_VIRTUAL]) {
2e70f6ef
PB		 1374 delta = active_timers[QEMU_TIMER_VIRTUAL]->expire_time -
1375 qemu_get_clock(vm_clock);
1376 } else {
1377 /* To avoid problems with overflow limit this to 2^32. */
1378 delta = INT32_MAX;
efe75411
TS		 1379 }
1380
2e70f6ef
PB		 1381 if (delta < 0)
1382 delta = 0;
efe75411 1383
2e70f6ef
PB		 1384 return delta;
1385}
1386
8632fb9a 1387#if defined(__linux__) || defined(_WIN32)
2e70f6ef
PB		 1388static uint64_t qemu_next_deadline_dyntick(void)
1389{
1390 int64_t delta;
1391 int64_t rtdelta;
1392
1393 if (use_icount)
1394 delta = INT32_MAX;
1395 else
1396 delta = (qemu_next_deadline() + 999) / 1000;
1397
1398 if (active_timers[QEMU_TIMER_REALTIME]) {
1399 rtdelta = (active_timers[QEMU_TIMER_REALTIME]->expire_time -
1400 qemu_get_clock(rt_clock))*1000;
1401 if (rtdelta < delta)
1402 delta = rtdelta;
1403 }
1404
1405 if (delta < MIN_TIMER_REARM_US)
1406 delta = MIN_TIMER_REARM_US;
1407
1408 return delta;
efe75411 1409}
8632fb9a 1410#endif
efe75411 1411
fd872598
FB		 1412#ifndef _WIN32
1413
7183b4b4
AL		 1414/* Sets a specific flag */
1415static int fcntl_setfl(int fd, int flag)
1416{
1417 int flags;
1418
1419 flags = fcntl(fd, F_GETFL);
1420 if (flags == -1)
1421 return -errno;
1422
1423 if (fcntl(fd, F_SETFL, flags | flag) == -1)
1424 return -errno;
1425
1426 return 0;
1427}
1428
829309c7
FB		 1429#if defined(__linux__)
1430
fd872598
FB		 1431#define RTC_FREQ 1024
1432
de9a95f0 1433static void enable_sigio_timer(int fd)
c8994013
TS		 1434{
1435 struct sigaction act;
1436
1437 /* timer signal */
1438 sigfillset(&act.sa_mask);
1439 act.sa_flags = 0;
c8994013
TS		 1440 act.sa_handler = host_alarm_handler;
1441
1442 sigaction(SIGIO, &act, NULL);
7183b4b4 1443 fcntl_setfl(fd, O_ASYNC);
c8994013
TS		 1444 fcntl(fd, F_SETOWN, getpid());
1445}
829309c7 1446
c40ec5a9
TS		 1447static int hpet_start_timer(struct qemu_alarm_timer *t)
1448{
1449 struct hpet_info info;
1450 int r, fd;
1451
1452 fd = open("/dev/hpet", O_RDONLY);
1453 if (fd < 0)
1454 return -1;
1455
1456 /* Set frequency */
1457 r = ioctl(fd, HPET_IRQFREQ, RTC_FREQ);
1458 if (r < 0) {
1459 fprintf(stderr, "Could not configure '/dev/hpet' to have a 1024Hz timer. This is not a fatal\n"
1460 "error, but for better emulation accuracy type:\n"
1461 "'echo 1024 > /proc/sys/dev/hpet/max-user-freq' as root.\n");
1462 goto fail;
1463 }
1464
1465 /* Check capabilities */
1466 r = ioctl(fd, HPET_INFO, &info);
1467 if (r < 0)
1468 goto fail;
1469
1470 /* Enable periodic mode */
1471 r = ioctl(fd, HPET_EPI, 0);
1472 if (info.hi_flags && (r < 0))
1473 goto fail;
1474
1475 /* Enable interrupt */
1476 r = ioctl(fd, HPET_IE_ON, 0);
1477 if (r < 0)
1478 goto fail;
1479
1480 enable_sigio_timer(fd);
fcdc2129 1481 t->priv = (void *)(long)fd;
c40ec5a9
TS		 1482
1483 return 0;
1484fail:
1485 close(fd);
1486 return -1;
1487}
1488
1489static void hpet_stop_timer(struct qemu_alarm_timer *t)
1490{
fcdc2129 1491 int fd = (long)t->priv;
c40ec5a9
TS		 1492
1493 close(fd);
1494}
1495
c8994013 1496static int rtc_start_timer(struct qemu_alarm_timer *t)
fd872598 1497{
c8994013 1498 int rtc_fd;
b5a23ad4 1499 unsigned long current_rtc_freq = 0;
c8994013 1500
aeb30be6 1501 TFR(rtc_fd = open("/dev/rtc", O_RDONLY));
fd872598
FB		 1502 if (rtc_fd < 0)
1503 return -1;
b5a23ad4
AZ		 1504 ioctl(rtc_fd, RTC_IRQP_READ, &current_rtc_freq);
1505 if (current_rtc_freq != RTC_FREQ &&
1506 ioctl(rtc_fd, RTC_IRQP_SET, RTC_FREQ) < 0) {
fd872598
FB		 1507 fprintf(stderr, "Could not configure '/dev/rtc' to have a 1024 Hz timer. This is not a fatal\n"
1508 "error, but for better emulation accuracy either use a 2.6 host Linux kernel or\n"
1509 "type 'echo 1024 > /proc/sys/dev/rtc/max-user-freq' as root.\n");
1510 goto fail;
1511 }
1512 if (ioctl(rtc_fd, RTC_PIE_ON, 0) < 0) {
1513 fail:
1514 close(rtc_fd);
1515 return -1;
1516 }
c8994013
TS		 1517
1518 enable_sigio_timer(rtc_fd);
1519
fcdc2129 1520 t->priv = (void *)(long)rtc_fd;
c8994013 1521
fd872598
FB		 1522 return 0;
1523}
1524
c8994013 1525static void rtc_stop_timer(struct qemu_alarm_timer *t)
829309c7 1526{
fcdc2129 1527 int rtc_fd = (long)t->priv;
c8994013
TS		 1528
1529 close(rtc_fd);
829309c7
FB		 1530}
1531
efe75411
TS		 1532static int dynticks_start_timer(struct qemu_alarm_timer *t)
1533{
1534 struct sigevent ev;
1535 timer_t host_timer;
1536 struct sigaction act;
1537
1538 sigfillset(&act.sa_mask);
1539 act.sa_flags = 0;
efe75411
TS		 1540 act.sa_handler = host_alarm_handler;
1541
1542 sigaction(SIGALRM, &act, NULL);
1543
9ed415b2
JCD		 1544 /*
1545 * Initialize ev struct to 0 to avoid valgrind complaining
1546 * about uninitialized data in timer_create call
1547 */
1548 memset(&ev, 0, sizeof(ev));
efe75411
TS		 1549 ev.sigev_value.sival_int = 0;
1550 ev.sigev_notify = SIGEV_SIGNAL;
1551 ev.sigev_signo = SIGALRM;
1552
1553 if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
1554 perror("timer_create");
1555
1556 /* disable dynticks */
1557 fprintf(stderr, "Dynamic Ticks disabled\n");
1558
1559 return -1;
1560 }
1561
0399bfe0 1562 t->priv = (void *)(long)host_timer;
efe75411
TS		 1563
1564 return 0;
1565}
1566
1567static void dynticks_stop_timer(struct qemu_alarm_timer *t)
1568{
0399bfe0 1569 timer_t host_timer = (timer_t)(long)t->priv;
efe75411
TS		 1570
1571 timer_delete(host_timer);
1572}
1573
1574static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
1575{
0399bfe0 1576 timer_t host_timer = (timer_t)(long)t->priv;
efe75411
TS		 1577 struct itimerspec timeout;
1578 int64_t nearest_delta_us = INT64_MAX;
1579 int64_t current_us;
1580
1581 if (!active_timers[QEMU_TIMER_REALTIME] &&
1582 !active_timers[QEMU_TIMER_VIRTUAL])
d5d08334 1583 return;
efe75411 1584
2e70f6ef 1585 nearest_delta_us = qemu_next_deadline_dyntick();
efe75411
TS		 1586
1587 /* check whether a timer is already running */
1588 if (timer_gettime(host_timer, &timeout)) {
1589 perror("gettime");
1590 fprintf(stderr, "Internal timer error: aborting\n");
1591 exit(1);
1592 }
1593 current_us = timeout.it_value.tv_sec * 1000000 + timeout.it_value.tv_nsec/1000;
1594 if (current_us && current_us <= nearest_delta_us)
1595 return;
1596
1597 timeout.it_interval.tv_sec = 0;
1598 timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1599 timeout.it_value.tv_sec = nearest_delta_us / 1000000;
1600 timeout.it_value.tv_nsec = (nearest_delta_us % 1000000) * 1000;
1601 if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
1602 perror("settime");
1603 fprintf(stderr, "Internal timer error: aborting\n");
1604 exit(1);
1605 }
1606}
1607
70744b3a 1608#endif /* defined(__linux__) */
231c6586 1609
c8994013
TS		 1610static int unix_start_timer(struct qemu_alarm_timer *t)
1611{
1612 struct sigaction act;
1613 struct itimerval itv;
1614 int err;
1615
1616 /* timer signal */
1617 sigfillset(&act.sa_mask);
1618 act.sa_flags = 0;
c8994013
TS		 1619 act.sa_handler = host_alarm_handler;
1620
1621 sigaction(SIGALRM, &act, NULL);
1622
1623 itv.it_interval.tv_sec = 0;
1624 /* for i386 kernel 2.6 to get 1 ms */
1625 itv.it_interval.tv_usec = 999;
1626 itv.it_value.tv_sec = 0;
1627 itv.it_value.tv_usec = 10 * 1000;
1628
1629 err = setitimer(ITIMER_REAL, &itv, NULL);
1630 if (err)
1631 return -1;
1632
1633 return 0;
1634}
1635
1636static void unix_stop_timer(struct qemu_alarm_timer *t)
1637{
1638 struct itimerval itv;
1639
1640 memset(&itv, 0, sizeof(itv));
1641 setitimer(ITIMER_REAL, &itv, NULL);
1642}
1643
829309c7 1644#endif /* !defined(_WIN32) */
fd872598 1645
f49e58dc 1646
c8994013
TS		 1647#ifdef _WIN32
1648
1649static int win32_start_timer(struct qemu_alarm_timer *t)
1650{
1651 TIMECAPS tc;
1652 struct qemu_alarm_win32 *data = t->priv;
efe75411 1653 UINT flags;
c8994013 1654
c8994013
TS		 1655 memset(&tc, 0, sizeof(tc));
1656 timeGetDevCaps(&tc, sizeof(tc));
1657
1658 if (data->period < tc.wPeriodMin)
1659 data->period = tc.wPeriodMin;
1660
1661 timeBeginPeriod(data->period);
1662
efe75411
TS		 1663 flags = TIME_CALLBACK_FUNCTION;
1664 if (alarm_has_dynticks(t))
1665 flags |= TIME_ONESHOT;
1666 else
1667 flags |= TIME_PERIODIC;
1668
c8994013
TS		 1669 data->timerId = timeSetEvent(1, // interval (ms)
1670 data->period, // resolution
1671 host_alarm_handler, // function
1672 (DWORD)t, // parameter
efe75411 1673 flags);
c8994013
TS		 1674
1675 if (!data->timerId) {
1676 perror("Failed to initialize win32 alarm timer");
c8994013 1677 timeEndPeriod(data->period);
c8994013
TS		 1678 return -1;
1679 }
1680
c8994013
TS		 1681 return 0;
1682}
1683
1684static void win32_stop_timer(struct qemu_alarm_timer *t)
1685{
1686 struct qemu_alarm_win32 *data = t->priv;
1687
1688 timeKillEvent(data->timerId);
1689 timeEndPeriod(data->period);
c8994013
TS		 1690}
1691
efe75411
TS		 1692static void win32_rearm_timer(struct qemu_alarm_timer *t)
1693{
1694 struct qemu_alarm_win32 *data = t->priv;
1695 uint64_t nearest_delta_us;
1696
1697 if (!active_timers[QEMU_TIMER_REALTIME] &&
1698 !active_timers[QEMU_TIMER_VIRTUAL])
d5d08334 1699 return;
efe75411 1700
2e70f6ef 1701 nearest_delta_us = qemu_next_deadline_dyntick();
efe75411
TS		 1702 nearest_delta_us /= 1000;
1703
1704 timeKillEvent(data->timerId);
1705
1706 data->timerId = timeSetEvent(1,
1707 data->period,
1708 host_alarm_handler,
1709 (DWORD)t,
1710 TIME_ONESHOT | TIME_PERIODIC);
1711
1712 if (!data->timerId) {
1713 perror("Failed to re-arm win32 alarm timer");
1714
1715 timeEndPeriod(data->period);
efe75411
TS		 1716 exit(1);
1717 }
1718}
1719
c8994013
TS		 1720#endif /* _WIN32 */
1721
7183b4b4 1722static int init_timer_alarm(void)
8a7ddc38 1723{
223f0d72 1724 struct qemu_alarm_timer *t = NULL;
c8994013 1725 int i, err = -1;
f49e58dc 1726
c8994013
TS		 1727 for (i = 0; alarm_timers[i].name; i++) {
1728 t = &alarm_timers[i];
1729
c8994013
TS		 1730 err = t->start(t);
1731 if (!err)
1732 break;
67b915a5 1733 }
fd872598 1734
c8994013 1735 if (err) {
7183b4b4
AL		 1736 err = -ENOENT;
1737 goto fail;
67b915a5 1738 }
c8994013
TS		 1739
1740 alarm_timer = t;
7183b4b4 1741
6abfbd79 1742 return 0;
7183b4b4
AL		 1743
1744fail:
7183b4b4 1745 return err;
8a7ddc38
FB		 1746}
1747
9596ebb7 1748static void quit_timers(void)
40c3bac3 1749{
c8994013
TS		 1750 alarm_timer->stop(alarm_timer);
1751 alarm_timer = NULL;
40c3bac3
FB		 1752}
1753
f6503059
AZ		 1754/***********************************************************/
1755/* host time/date access */
1756void qemu_get_timedate(struct tm *tm, int offset)
1757{
1758 time_t ti;
1759 struct tm *ret;
1760
1761 time(&ti);
1762 ti += offset;
1763 if (rtc_date_offset == -1) {
1764 if (rtc_utc)
1765 ret = gmtime(&ti);
1766 else
1767 ret = localtime(&ti);
1768 } else {
1769 ti -= rtc_date_offset;
1770 ret = gmtime(&ti);
1771 }
1772
1773 memcpy(tm, ret, sizeof(struct tm));
1774}
1775
1776int qemu_timedate_diff(struct tm *tm)
1777{
1778 time_t seconds;
1779
1780 if (rtc_date_offset == -1)
1781 if (rtc_utc)
1782 seconds = mktimegm(tm);
1783 else
1784 seconds = mktime(tm);
1785 else
1786 seconds = mktimegm(tm) + rtc_date_offset;
1787
1788 return seconds - time(NULL);
1789}
1790
fd1dff4b 1791#ifdef _WIN32
fd1dff4b
FB		 1792static void socket_cleanup(void)
1793{
1794 WSACleanup();
1795}
82c643ff 1796
fd1dff4b
FB		 1797static int socket_init(void)
1798{
1799 WSADATA Data;
1800 int ret, err;
1801
1802 ret = WSAStartup(MAKEWORD(2,2), &Data);
1803 if (ret != 0) {
1804 err = WSAGetLastError();
1805 fprintf(stderr, "WSAStartup: %d\n", err);
1806 return -1;
1807 }
1808 atexit(socket_cleanup);
1809 return 0;
1810}
64b7b733
AJ		 1811#endif
1812
63a01ef8
AL		 1813int get_param_value(char *buf, int buf_size,
1814 const char *tag, const char *str)
7c9d8e07
FB		 1815{
1816 const char *p;
7c9d8e07
FB		 1817 char option[128];
1818
1819 p = str;
1820 for(;;) {
268a362c 1821 p = get_opt_name(option, sizeof(option), p, '=');
7c9d8e07
FB		 1822 if (*p != '=')
1823 break;
1824 p++;
1825 if (!strcmp(tag, option)) {
609497ab 1826 (void)get_opt_value(buf, buf_size, p);
e4bcb14c 1827 return strlen(buf);
7c9d8e07 1828 } else {
609497ab 1829 p = get_opt_value(NULL, 0, p);
7c9d8e07
FB		 1830 }
1831 if (*p != ',')
1832 break;
1833 p++;
1834 }
1835 return 0;
1836}
1837
ffad4116 1838int check_params(const char * const *params, const char *str)
e4bcb14c 1839{
ffad4116 1840 int name_buf_size = 1;
e4bcb14c 1841 const char *p;
ffad4116
JK		 1842 char *name_buf;
1843 int i, len;
1844 int ret = 0;
1845
1846 for (i = 0; params[i] != NULL; i++) {
1847 len = strlen(params[i]) + 1;
1848 if (len > name_buf_size) {
1849 name_buf_size = len;
1850 }
1851 }
1852 name_buf = qemu_malloc(name_buf_size);
e4bcb14c
TS		 1853
1854 p = str;
10300216 1855 while (*p != '\0') {
ffad4116
JK		 1856 p = get_opt_name(name_buf, name_buf_size, p, '=');
1857 if (*p != '=') {
1858 ret = -1;
1859 break;
1860 }
e4bcb14c
TS		 1861 p++;
1862 for(i = 0; params[i] != NULL; i++)
ffad4116 1863 if (!strcmp(params[i], name_buf))
e4bcb14c 1864 break;
ffad4116
JK		 1865 if (params[i] == NULL) {
1866 ret = -1;
1867 break;
1868 }
609497ab 1869 p = get_opt_value(NULL, 0, p);
e4bcb14c
TS		 1870 if (*p != ',')
1871 break;
1872 p++;
1873 }
ffad4116
JK		 1874
1875 qemu_free(name_buf);
1876 return ret;
e4bcb14c
TS		 1877}
1878
1ae26a18
AZ		 1879/***********************************************************/
1880/* Bluetooth support */
1881static int nb_hcis;
1882static int cur_hci;
1883static struct HCIInfo *hci_table[MAX_NICS];
dc72ac14 1884
1ae26a18
AZ		 1885static struct bt_vlan_s {
1886 struct bt_scatternet_s net;
1887 int id;
1888 struct bt_vlan_s *next;
1889} *first_bt_vlan;
1890
1891/* find or alloc a new bluetooth "VLAN" */
674bb261 1892static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1ae26a18
AZ		 1893{
1894 struct bt_vlan_s **pvlan, *vlan;
1895 for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1896 if (vlan->id == id)
1897 return &vlan->net;
1898 }
1899 vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1900 vlan->id = id;
1901 pvlan = &first_bt_vlan;
1902 while (*pvlan != NULL)
1903 pvlan = &(*pvlan)->next;
1904 *pvlan = vlan;
1905 return &vlan->net;
1906}
1907
1908static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1909{
1910}
1911
1912static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1913{
1914 return -ENOTSUP;
1915}
1916
1917static struct HCIInfo null_hci = {
1918 .cmd_send = null_hci_send,
1919 .sco_send = null_hci_send,
1920 .acl_send = null_hci_send,
1921 .bdaddr_set = null_hci_addr_set,
1922};
1923
1924struct HCIInfo *qemu_next_hci(void)
1925{
1926 if (cur_hci == nb_hcis)
1927 return &null_hci;
1928
1929 return hci_table[cur_hci++];
1930}
1931
dc72ac14
AZ		 1932static struct HCIInfo *hci_init(const char *str)
1933{
1934 char *endp;
1935 struct bt_scatternet_s *vlan = 0;
1936
1937 if (!strcmp(str, "null"))
1938 /* null */
1939 return &null_hci;
1940 else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1941 /* host[:hciN] */
1942 return bt_host_hci(str[4] ? str + 5 : "hci0");
1943 else if (!strncmp(str, "hci", 3)) {
1944 /* hci[,vlan=n] */
1945 if (str[3]) {
1946 if (!strncmp(str + 3, ",vlan=", 6)) {
1947 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1948 if (*endp)
1949 vlan = 0;
1950 }
1951 } else
1952 vlan = qemu_find_bt_vlan(0);
1953 if (vlan)
1954 return bt_new_hci(vlan);
1955 }
1956
1957 fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
1958
1959 return 0;
1960}
1961
1962static int bt_hci_parse(const char *str)
1963{
1964 struct HCIInfo *hci;
1965 bdaddr_t bdaddr;
1966
1967 if (nb_hcis >= MAX_NICS) {
1968 fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
1969 return -1;
1970 }
1971
1972 hci = hci_init(str);
1973 if (!hci)
1974 return -1;
1975
1976 bdaddr.b[0] = 0x52;
1977 bdaddr.b[1] = 0x54;
1978 bdaddr.b[2] = 0x00;
1979 bdaddr.b[3] = 0x12;
1980 bdaddr.b[4] = 0x34;
1981 bdaddr.b[5] = 0x56 + nb_hcis;
1982 hci->bdaddr_set(hci, bdaddr.b);
1983
1984 hci_table[nb_hcis++] = hci;
1985
1986 return 0;
1987}
1988
1989static void bt_vhci_add(int vlan_id)
1990{
1991 struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1992
1993 if (!vlan->slave)
1994 fprintf(stderr, "qemu: warning: adding a VHCI to "
1995 "an empty scatternet %i\n", vlan_id);
1996
1997 bt_vhci_init(bt_new_hci(vlan));
1998}
1999
2000static struct bt_device_s *bt_device_add(const char *opt)
2001{
2002 struct bt_scatternet_s *vlan;
2003 int vlan_id = 0;
2004 char *endp = strstr(opt, ",vlan=");
2005 int len = (endp ? endp - opt : strlen(opt)) + 1;
2006 char devname[10];
2007
2008 pstrcpy(devname, MIN(sizeof(devname), len), opt);
2009
2010 if (endp) {
2011 vlan_id = strtol(endp + 6, &endp, 0);
2012 if (*endp) {
2013 fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2014 return 0;
2015 }
2016 }
2017
2018 vlan = qemu_find_bt_vlan(vlan_id);
2019
2020 if (!vlan->slave)
2021 fprintf(stderr, "qemu: warning: adding a slave device to "
2022 "an empty scatternet %i\n", vlan_id);
2023
2024 if (!strcmp(devname, "keyboard"))
2025 return bt_keyboard_init(vlan);
2026
2027 fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2028 return 0;
2029}
2030
2031static int bt_parse(const char *opt)
2032{
2033 const char *endp, *p;
2034 int vlan;
2035
2036 if (strstart(opt, "hci", &endp)) {
2037 if (!*endp || *endp == ',') {
2038 if (*endp)
2039 if (!strstart(endp, ",vlan=", 0))
2040 opt = endp + 1;
2041
2042 return bt_hci_parse(opt);
2043 }
2044 } else if (strstart(opt, "vhci", &endp)) {
2045 if (!*endp || *endp == ',') {
2046 if (*endp) {
2047 if (strstart(endp, ",vlan=", &p)) {
2048 vlan = strtol(p, (char **) &endp, 0);
2049 if (*endp) {
2050 fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2051 return 1;
2052 }
2053 } else {
2054 fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2055 return 1;
2056 }
2057 } else
2058 vlan = 0;
2059
2060 bt_vhci_add(vlan);
2061 return 0;
2062 }
2063 } else if (strstart(opt, "device:", &endp))
2064 return !bt_device_add(endp);
2065
2066 fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2067 return 1;
2068}
2069
1ae26a18
AZ		 2070/***********************************************************/
2071/* QEMU Block devices */
2072
609497ab 2073#define HD_ALIAS "index=%d,media=disk"
e4bcb14c 2074#define CDROM_ALIAS "index=2,media=cdrom"
e4bcb14c 2075#define FD_ALIAS "index=%d,if=floppy"
609497ab
AZ		 2076#define PFLASH_ALIAS "if=pflash"
2077#define MTD_ALIAS "if=mtd"
9d413d1d 2078#define SD_ALIAS "index=0,if=sd"
e4bcb14c 2079
7d5aca9e
AL		 2080static int drive_opt_get_free_idx(void)
2081{
2082 int index;
2083
2084 for (index = 0; index < MAX_DRIVES; index++)
2085 if (!drives_opt[index].used) {
2086 drives_opt[index].used = 1;
2087 return index;
2088 }
2089
2090 return -1;
2091}
2092
2093static int drive_get_free_idx(void)
2094{
2095 int index;
2096
2097 for (index = 0; index < MAX_DRIVES; index++)
2098 if (!drives_table[index].used) {
2099 drives_table[index].used = 1;
2100 return index;
2101 }
2102
2103 return -1;
2104}
2105
4d73cd3b 2106int drive_add(const char *file, const char *fmt, ...)
e4bcb14c
TS		 2107{
2108 va_list ap;
7d5aca9e 2109 int index = drive_opt_get_free_idx();
e4bcb14c 2110
7d5aca9e 2111 if (nb_drives_opt >= MAX_DRIVES || index == -1) {
e4bcb14c 2112 fprintf(stderr, "qemu: too many drives\n");
4d73cd3b 2113 return -1;
e4bcb14c
TS		 2114 }
2115
7d5aca9e 2116 drives_opt[index].file = file;
e4bcb14c 2117 va_start(ap, fmt);
7d5aca9e 2118 vsnprintf(drives_opt[index].opt,
609497ab 2119 sizeof(drives_opt[0].opt), fmt, ap);
e4bcb14c
TS		 2120 va_end(ap);
2121
7d5aca9e
AL		 2122 nb_drives_opt++;
2123 return index;
e4bcb14c
TS		 2124}
2125
b01b1111
AL		 2126void drive_remove(int index)
2127{
2128 drives_opt[index].used = 0;
2129 nb_drives_opt--;
2130}
2131
f60d39bc 2132int drive_get_index(BlockInterfaceType type, int bus, int unit)
e4bcb14c
TS		 2133{
2134 int index;
2135
2136 /* seek interface, bus and unit */
2137
7d5aca9e 2138 for (index = 0; index < MAX_DRIVES; index++)
f60d39bc 2139 if (drives_table[index].type == type &&
e4bcb14c 2140 drives_table[index].bus == bus &&
7d5aca9e
AL		 2141 drives_table[index].unit == unit &&
2142 drives_table[index].used)
e4bcb14c
TS		 2143 return index;
2144
2145 return -1;
2146}
2147
f60d39bc 2148int drive_get_max_bus(BlockInterfaceType type)
e4bcb14c
TS		 2149{
2150 int max_bus;
2151 int index;
2152
2153 max_bus = -1;
2154 for (index = 0; index < nb_drives; index++) {
f60d39bc 2155 if(drives_table[index].type == type &&
e4bcb14c
TS		 2156 drives_table[index].bus > max_bus)
2157 max_bus = drives_table[index].bus;
2158 }
2159 return max_bus;
2160}
2161
fa879c64
AL		 2162const char *drive_get_serial(BlockDriverState *bdrv)
2163{
2164 int index;
2165
2166 for (index = 0; index < nb_drives; index++)
2167 if (drives_table[index].bdrv == bdrv)
2168 return drives_table[index].serial;
2169
2170 return "\0";
2171}
2172
428c5705
AL		 2173BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2174{
2175 int index;
2176
2177 for (index = 0; index < nb_drives; index++)
2178 if (drives_table[index].bdrv == bdrv)
2179 return drives_table[index].onerror;
2180
cdad4bd8 2181 return BLOCK_ERR_STOP_ENOSPC;
428c5705
AL		 2182}
2183
a1620fac
AJ		 2184static void bdrv_format_print(void *opaque, const char *name)
2185{
2186 fprintf(stderr, " %s", name);
2187}
2188
b01b1111
AL		 2189void drive_uninit(BlockDriverState *bdrv)
2190{
2191 int i;
2192
2193 for (i = 0; i < MAX_DRIVES; i++)
2194 if (drives_table[i].bdrv == bdrv) {
2195 drives_table[i].bdrv = NULL;
2196 drives_table[i].used = 0;
2197 drive_remove(drives_table[i].drive_opt_idx);
2198 nb_drives--;
2199 break;
2200 }
2201}
2202
4d73cd3b 2203int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
e4bcb14c
TS		 2204{
2205 char buf[128];
2206 char file[1024];
c8522bdf 2207 char devname[128];
fa879c64 2208 char serial[21];
c8522bdf 2209 const char *mediastr = "";
f60d39bc 2210 BlockInterfaceType type;
e4bcb14c
TS		 2211 enum { MEDIA_DISK, MEDIA_CDROM } media;
2212 int bus_id, unit_id;
2213 int cyls, heads, secs, translation;
2214 BlockDriverState *bdrv;
1e72d3b7 2215 BlockDriver *drv = NULL;
4d73cd3b 2216 QEMUMachine *machine = opaque;
e4bcb14c
TS		 2217 int max_devs;
2218 int index;
33f00271 2219 int cache;
428c5705 2220 int bdrv_flags, onerror;
7d5aca9e 2221 int drives_table_idx;
609497ab 2222 char *str = arg->opt;
7ccfb2eb
BS		 2223 static const char * const params[] = { "bus", "unit", "if", "index",
2224 "cyls", "heads", "secs", "trans",
2225 "media", "snapshot", "file",
428c5705
AL		 2226 "cache", "format", "serial", "werror",
2227 NULL };
e4bcb14c 2228
ffad4116 2229 if (check_params(params, str) < 0) {
ff993638 2230 fprintf(stderr, "qemu: unknown parameter '%s' in '%s'\n",
e4bcb14c
TS		 2231 buf, str);
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
b0a46a33
JK		 3235 if (cpu_physical_sync_dirty_bitmap(0, last_ram_offset) != 0) {
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 }
29203dcf
AL		 3662 if (kvm_enabled())
3663 kvm_sync_vcpus();
bb0c6722
FB		 3664}
3665
3666void qemu_system_reset_request(void)
3667{
d1beab82
FB		 3668 if (no_reboot) {
3669 shutdown_requested = 1;
3670 } else {
3671 reset_requested = 1;
3672 }
d9f75a4e 3673 qemu_notify_event();
bb0c6722
FB		 3674}
3675
3676void qemu_system_shutdown_request(void)
3677{
3678 shutdown_requested = 1;
d9f75a4e 3679 qemu_notify_event();
bb0c6722
FB		 3680}
3681
3475187d
FB		 3682void qemu_system_powerdown_request(void)
3683{
3684 powerdown_requested = 1;
d9f75a4e
AL		 3685 qemu_notify_event();
3686}
3687
d6dc3d42
AL		 3688#ifdef CONFIG_IOTHREAD
3689static void qemu_system_vmstop_request(int reason)
d9f75a4e 3690{
d6dc3d42
AL		 3691 vmstop_requested = reason;
3692 qemu_notify_event();
bb0c6722 3693}
d6dc3d42 3694#endif
bb0c6722 3695
50317c7f
AL		 3696#ifndef _WIN32
3697static int io_thread_fd = -1;
3698
3699static void qemu_event_increment(void)
3fcf7b6b 3700{
50317c7f
AL		 3701 static const char byte = 0;
3702
3703 if (io_thread_fd == -1)
3704 return;
3705
3706 write(io_thread_fd, &byte, sizeof(byte));
3707}
3708
3709static void qemu_event_read(void *opaque)
3710{
3711 int fd = (unsigned long)opaque;
3712 ssize_t len;
3713
3714 /* Drain the notify pipe */
3715 do {
3716 char buffer[512];
3717 len = read(fd, buffer, sizeof(buffer));
3718 } while ((len == -1 && errno == EINTR) || len > 0);
3719}
3720
3721static int qemu_event_init(void)
3722{
3723 int err;
3724 int fds[2];
3725
3726 err = pipe(fds);
3727 if (err == -1)
3728 return -errno;
3729
3730 err = fcntl_setfl(fds[0], O_NONBLOCK);
3731 if (err < 0)
3732 goto fail;
3733
3734 err = fcntl_setfl(fds[1], O_NONBLOCK);
3735 if (err < 0)
3736 goto fail;
3737
3738 qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3739 (void *)(unsigned long)fds[0]);
3740
3741 io_thread_fd = fds[1];
a7e21219
JK		 3742 return 0;
3743
50317c7f
AL		 3744fail:
3745 close(fds[0]);
3746 close(fds[1]);
3747 return err;
3748}
3749#else
3750HANDLE qemu_event_handle;
3751
3752static void dummy_event_handler(void *opaque)
3753{
3754}
3755
3756static int qemu_event_init(void)
3757{
3758 qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3759 if (!qemu_event_handle) {
3760 perror("Failed CreateEvent");
3761 return -1;
3762 }
3763 qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3fcf7b6b
AL		 3764 return 0;
3765}
3766
50317c7f
AL		 3767static void qemu_event_increment(void)
3768{
3769 SetEvent(qemu_event_handle);
3770}
3771#endif
3772
d6dc3d42
AL		 3773static int cpu_can_run(CPUState *env)
3774{
3775 if (env->stop)
3776 return 0;
3777 if (env->stopped)
3778 return 0;
3779 return 1;
3780}
3781
3782#ifndef CONFIG_IOTHREAD
50317c7f
AL		 3783static int qemu_init_main_loop(void)
3784{
3785 return qemu_event_init();
3786}
3787
0bf46a40
AL		 3788void qemu_init_vcpu(void *_env)
3789{
3790 CPUState *env = _env;
3791
3792 if (kvm_enabled())
3793 kvm_init_vcpu(env);
3794 return;
3795}
3796
8edac960
AL		 3797int qemu_cpu_self(void *env)
3798{
3799 return 1;
3800}
3801
d6dc3d42
AL		 3802static void resume_all_vcpus(void)
3803{
3804}
3805
3806static void pause_all_vcpus(void)
3807{
3808}
3809
8edac960
AL		 3810void qemu_cpu_kick(void *env)
3811{
3812 return;
3813}
3814
d6dc3d42
AL		 3815void qemu_notify_event(void)
3816{
3817 CPUState *env = cpu_single_env;
3818
3819 if (env) {
3820 cpu_exit(env);
3821#ifdef USE_KQEMU
3822 if (env->kqemu_enabled)
3823 kqemu_cpu_interrupt(env);
3824#endif
3825 }
3826}
3827
4870852c
AL		 3828#define qemu_mutex_lock_iothread() do { } while (0)
3829#define qemu_mutex_unlock_iothread() do { } while (0)
3830
6e29f5da
AL		 3831void vm_stop(int reason)
3832{
3833 do_vm_stop(reason);
3834}
3835
d6dc3d42
AL		 3836#else /* CONFIG_IOTHREAD */
3837
3838#include "qemu-thread.h"
3839
3840QemuMutex qemu_global_mutex;
3841static QemuMutex qemu_fair_mutex;
3842
3843static QemuThread io_thread;
3844
3845static QemuThread *tcg_cpu_thread;
3846static QemuCond *tcg_halt_cond;
3847
3848static int qemu_system_ready;
3849/* cpu creation */
3850static QemuCond qemu_cpu_cond;
3851/* system init */
3852static QemuCond qemu_system_cond;
3853static QemuCond qemu_pause_cond;
3854
3855static void block_io_signals(void);
3856static void unblock_io_signals(void);
3857static int tcg_has_work(void);
3858
3859static int qemu_init_main_loop(void)
3860{
3861 int ret;
3862
3863 ret = qemu_event_init();
3864 if (ret)
3865 return ret;
3866
3867 qemu_cond_init(&qemu_pause_cond);
3868 qemu_mutex_init(&qemu_fair_mutex);
3869 qemu_mutex_init(&qemu_global_mutex);
3870 qemu_mutex_lock(&qemu_global_mutex);
3871
3872 unblock_io_signals();
3873 qemu_thread_self(&io_thread);
3874
3875 return 0;
3876}
3877
3878static void qemu_wait_io_event(CPUState *env)
3879{
3880 while (!tcg_has_work())
3881 qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3882
3883 qemu_mutex_unlock(&qemu_global_mutex);
3884
3885 /*
3886 * Users of qemu_global_mutex can be starved, having no chance
3887 * to acquire it since this path will get to it first.
3888 * So use another lock to provide fairness.
3889 */
3890 qemu_mutex_lock(&qemu_fair_mutex);
3891 qemu_mutex_unlock(&qemu_fair_mutex);
3892
3893 qemu_mutex_lock(&qemu_global_mutex);
3894 if (env->stop) {
3895 env->stop = 0;
3896 env->stopped = 1;
3897 qemu_cond_signal(&qemu_pause_cond);
3898 }
3899}
3900
3901static int qemu_cpu_exec(CPUState *env);
3902
3903static void *kvm_cpu_thread_fn(void *arg)
3904{
3905 CPUState *env = arg;
3906
3907 block_io_signals();
3908 qemu_thread_self(env->thread);
3909
3910 /* signal CPU creation */
3911 qemu_mutex_lock(&qemu_global_mutex);
3912 env->created = 1;
3913 qemu_cond_signal(&qemu_cpu_cond);
3914
3915 /* and wait for machine initialization */
3916 while (!qemu_system_ready)
3917 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3918
3919 while (1) {
3920 if (cpu_can_run(env))
3921 qemu_cpu_exec(env);
3922 qemu_wait_io_event(env);
3923 }
3924
3925 return NULL;
3926}
3927
3928static void tcg_cpu_exec(void);
3929
3930static void *tcg_cpu_thread_fn(void *arg)
3931{
3932 CPUState *env = arg;
3933
3934 block_io_signals();
3935 qemu_thread_self(env->thread);
3936
3937 /* signal CPU creation */
3938 qemu_mutex_lock(&qemu_global_mutex);
3939 for (env = first_cpu; env != NULL; env = env->next_cpu)
3940 env->created = 1;
3941 qemu_cond_signal(&qemu_cpu_cond);
3942
3943 /* and wait for machine initialization */
3944 while (!qemu_system_ready)
3945 qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3946
3947 while (1) {
3948 tcg_cpu_exec();
3949 qemu_wait_io_event(cur_cpu);
3950 }
3951
3952 return NULL;
3953}
3954
3955void qemu_cpu_kick(void *_env)
3956{
3957 CPUState *env = _env;
3958 qemu_cond_broadcast(env->halt_cond);
3959 if (kvm_enabled())
3960 qemu_thread_signal(env->thread, SIGUSR1);
3961}
3962
3963int qemu_cpu_self(void *env)
3964{
3965 return (cpu_single_env != NULL);
3966}
3967
3968static void cpu_signal(int sig)
3969{
3970 if (cpu_single_env)
3971 cpu_exit(cpu_single_env);
3972}
3973
3974static void block_io_signals(void)
3975{
3976 sigset_t set;
3977 struct sigaction sigact;
3978
3979 sigemptyset(&set);
3980 sigaddset(&set, SIGUSR2);
3981 sigaddset(&set, SIGIO);
3982 sigaddset(&set, SIGALRM);
3983 pthread_sigmask(SIG_BLOCK, &set, NULL);
3984
3985 sigemptyset(&set);
3986 sigaddset(&set, SIGUSR1);
3987 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3988
3989 memset(&sigact, 0, sizeof(sigact));
3990 sigact.sa_handler = cpu_signal;
3991 sigaction(SIGUSR1, &sigact, NULL);
3992}
3993
3994static void unblock_io_signals(void)
3995{
3996 sigset_t set;
3997
3998 sigemptyset(&set);
3999 sigaddset(&set, SIGUSR2);
4000 sigaddset(&set, SIGIO);
4001 sigaddset(&set, SIGALRM);
4002 pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4003
4004 sigemptyset(&set);
4005 sigaddset(&set, SIGUSR1);
4006 pthread_sigmask(SIG_BLOCK, &set, NULL);
4007}
4008
4009static void qemu_signal_lock(unsigned int msecs)
4010{
4011 qemu_mutex_lock(&qemu_fair_mutex);
4012
4013 while (qemu_mutex_trylock(&qemu_global_mutex)) {
4014 qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
4015 if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
4016 break;
4017 }
4018 qemu_mutex_unlock(&qemu_fair_mutex);
4019}
4020
4021static void qemu_mutex_lock_iothread(void)
4022{
4023 if (kvm_enabled()) {
4024 qemu_mutex_lock(&qemu_fair_mutex);
4025 qemu_mutex_lock(&qemu_global_mutex);
4026 qemu_mutex_unlock(&qemu_fair_mutex);
4027 } else
4028 qemu_signal_lock(100);
4029}
4030
4031static void qemu_mutex_unlock_iothread(void)
4032{
4033 qemu_mutex_unlock(&qemu_global_mutex);
4034}
4035
4036static int all_vcpus_paused(void)
4037{
4038 CPUState *penv = first_cpu;
4039
4040 while (penv) {
4041 if (!penv->stopped)
4042 return 0;
4043 penv = (CPUState *)penv->next_cpu;
4044 }
4045
4046 return 1;
4047}
4048
4049static void pause_all_vcpus(void)
4050{
4051 CPUState *penv = first_cpu;
4052
4053 while (penv) {
4054 penv->stop = 1;
4055 qemu_thread_signal(penv->thread, SIGUSR1);
4056 qemu_cpu_kick(penv);
4057 penv = (CPUState *)penv->next_cpu;
4058 }
4059
4060 while (!all_vcpus_paused()) {
4061 qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
4062 penv = first_cpu;
4063 while (penv) {
4064 qemu_thread_signal(penv->thread, SIGUSR1);
4065 penv = (CPUState *)penv->next_cpu;
4066 }
4067 }
4068}
4069
4070static void resume_all_vcpus(void)
4071{
4072 CPUState *penv = first_cpu;
4073
4074 while (penv) {
4075 penv->stop = 0;
4076 penv->stopped = 0;
4077 qemu_thread_signal(penv->thread, SIGUSR1);
4078 qemu_cpu_kick(penv);
4079 penv = (CPUState *)penv->next_cpu;
4080 }
4081}
4082
4083static void tcg_init_vcpu(void *_env)
4084{
4085 CPUState *env = _env;
4086 /* share a single thread for all cpus with TCG */
4087 if (!tcg_cpu_thread) {
4088 env->thread = qemu_mallocz(sizeof(QemuThread));
4089 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4090 qemu_cond_init(env->halt_cond);
4091 qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
4092 while (env->created == 0)
4093 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4094 tcg_cpu_thread = env->thread;
4095 tcg_halt_cond = env->halt_cond;
4096 } else {
4097 env->thread = tcg_cpu_thread;
4098 env->halt_cond = tcg_halt_cond;
4099 }
4100}
4101
4102static void kvm_start_vcpu(CPUState *env)
4103{
4104 kvm_init_vcpu(env);
4105 env->thread = qemu_mallocz(sizeof(QemuThread));
4106 env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4107 qemu_cond_init(env->halt_cond);
4108 qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
4109 while (env->created == 0)
4110 qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4111}
4112
4113void qemu_init_vcpu(void *_env)
4114{
4115 CPUState *env = _env;
4116
4117 if (kvm_enabled())
4118 kvm_start_vcpu(env);
4119 else
4120 tcg_init_vcpu(env);
4121}
4122
4123void qemu_notify_event(void)
4124{
4125 qemu_event_increment();
4126}
4127
4128void vm_stop(int reason)
4129{
4130 QemuThread me;
4131 qemu_thread_self(&me);
4132
4133 if (!qemu_thread_equal(&me, &io_thread)) {
4134 qemu_system_vmstop_request(reason);
4135 /*
4136 * FIXME: should not return to device code in case
4137 * vm_stop() has been requested.
4138 */
4139 if (cpu_single_env) {
4140 cpu_exit(cpu_single_env);
4141 cpu_single_env->stop = 1;
4142 }
4143 return;
4144 }
4145 do_vm_stop(reason);
4146}
4147
4148#endif
4149
4150
877cf882 4151#ifdef _WIN32
69d6451c 4152static void host_main_loop_wait(int *timeout)
56f3a5d0
AL		 4153{
4154 int ret, ret2, i;
f331110f
FB		 4155 PollingEntry *pe;
4156
c4b1fcc0 4157
f331110f
FB		 4158 /* XXX: need to suppress polling by better using win32 events */
4159 ret = 0;
4160 for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
4161 ret |= pe->func(pe->opaque);
4162 }
e6b1e558 4163 if (ret == 0) {
a18e524a
FB		 4164 int err;
4165 WaitObjects *w = &wait_objects;
3b46e624 4166
56f3a5d0 4167 ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
a18e524a
FB		 4168 if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
4169 if (w->func[ret - WAIT_OBJECT_0])
4170 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3b46e624 4171
5fafdf24 4172 /* Check for additional signaled events */
e6b1e558 4173 for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3b46e624 4174
e6b1e558
TS		 4175 /* Check if event is signaled */
4176 ret2 = WaitForSingleObject(w->events[i], 0);
4177 if(ret2 == WAIT_OBJECT_0) {
4178 if (w->func[i])
4179 w->func[i](w->opaque[i]);
4180 } else if (ret2 == WAIT_TIMEOUT) {
4181 } else {
4182 err = GetLastError();
4183 fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3b46e624
TS		 4184 }
4185 }
a18e524a
FB		 4186 } else if (ret == WAIT_TIMEOUT) {
4187 } else {
4188 err = GetLastError();
e6b1e558 4189 fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
a18e524a 4190 }
f331110f 4191 }
56f3a5d0
AL		 4192
4193 *timeout = 0;
4194}
4195#else
69d6451c 4196static void host_main_loop_wait(int *timeout)
56f3a5d0
AL		 4197{
4198}
fd1dff4b 4199#endif
56f3a5d0
AL		 4200
4201void main_loop_wait(int timeout)
4202{
4203 IOHandlerRecord *ioh;
4204 fd_set rfds, wfds, xfds;
4205 int ret, nfds;
4206 struct timeval tv;
4207
4208 qemu_bh_update_timeout(&timeout);
4209
4210 host_main_loop_wait(&timeout);
4211
fd1dff4b
FB		 4212 /* poll any events */
4213 /* XXX: separate device handlers from system ones */
6abfbd79 4214 nfds = -1;
fd1dff4b
FB		 4215 FD_ZERO(&rfds);
4216 FD_ZERO(&wfds);
e035649e 4217 FD_ZERO(&xfds);
fd1dff4b 4218 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
cafffd40
TS		 4219 if (ioh->deleted)
4220 continue;
fd1dff4b
FB		 4221 if (ioh->fd_read &&
4222 (!ioh->fd_read_poll ||
4223 ioh->fd_read_poll(ioh->opaque) != 0)) {
4224 FD_SET(ioh->fd, &rfds);
4225 if (ioh->fd > nfds)
4226 nfds = ioh->fd;
4227 }
4228 if (ioh->fd_write) {
4229 FD_SET(ioh->fd, &wfds);
4230 if (ioh->fd > nfds)
4231 nfds = ioh->fd;
4232 }
4233 }
3b46e624 4234
56f3a5d0
AL		 4235 tv.tv_sec = timeout / 1000;
4236 tv.tv_usec = (timeout % 1000) * 1000;
4237
e035649e 4238#if defined(CONFIG_SLIRP)
63a01ef8 4239 if (slirp_is_inited()) {
e035649e
FB		 4240 slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4241 }
4242#endif
4870852c 4243 qemu_mutex_unlock_iothread();
e035649e 4244 ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4870852c 4245 qemu_mutex_lock_iothread();
fd1dff4b 4246 if (ret > 0) {
cafffd40
TS		 4247 IOHandlerRecord **pioh;
4248
4249 for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
6ab43fdc 4250 if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
fd1dff4b 4251 ioh->fd_read(ioh->opaque);
7c9d8e07 4252 }
6ab43fdc 4253 if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
fd1dff4b 4254 ioh->fd_write(ioh->opaque);
c4b1fcc0 4255 }
b4608c04 4256 }
cafffd40
TS		 4257
4258 /* remove deleted IO handlers */
4259 pioh = &first_io_handler;
4260 while (*pioh) {
4261 ioh = *pioh;
4262 if (ioh->deleted) {
4263 *pioh = ioh->next;
4264 qemu_free(ioh);
5fafdf24 4265 } else
cafffd40
TS		 4266 pioh = &ioh->next;
4267 }
fd1dff4b 4268 }
c20709aa 4269#if defined(CONFIG_SLIRP)
63a01ef8 4270 if (slirp_is_inited()) {
e035649e
FB		 4271 if (ret < 0) {
4272 FD_ZERO(&rfds);
4273 FD_ZERO(&wfds);
4274 FD_ZERO(&xfds);
c20709aa 4275 }
e035649e 4276 slirp_select_poll(&rfds, &wfds, &xfds);
fd1dff4b 4277 }
e035649e 4278#endif
b4608c04 4279
50317c7f
AL		 4280 /* rearm timer, if not periodic */
4281 if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
4282 alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
4283 qemu_rearm_alarm_timer(alarm_timer);
4284 }
4285
357c692c 4286 /* vm time timers */
d6dc3d42
AL		 4287 if (vm_running) {
4288 if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
4289 qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4290 qemu_get_clock(vm_clock));
4291 }
357c692c
AL		 4292
4293 /* real time timers */
4294 qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4295 qemu_get_clock(rt_clock));
4296
423f0742
PB		 4297 /* Check bottom-halves last in case any of the earlier events triggered
4298 them. */
4299 qemu_bh_poll();
3b46e624 4300
5905b2e5
FB		 4301}
4302
43b96858 4303static int qemu_cpu_exec(CPUState *env)
5905b2e5 4304{
43b96858 4305 int ret;
89bfc105
FB		 4306#ifdef CONFIG_PROFILER
4307 int64_t ti;
4308#endif
5905b2e5 4309
89bfc105 4310#ifdef CONFIG_PROFILER
43b96858 4311 ti = profile_getclock();
89bfc105 4312#endif
43b96858
AL		 4313 if (use_icount) {
4314 int64_t count;
4315 int decr;
4316 qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
4317 env->icount_decr.u16.low = 0;
4318 env->icount_extra = 0;
4319 count = qemu_next_deadline();
4320 count = (count + (1 << icount_time_shift) - 1)
4321 >> icount_time_shift;
4322 qemu_icount += count;
4323 decr = (count > 0xffff) ? 0xffff : count;
4324 count -= decr;
4325 env->icount_decr.u16.low = decr;
4326 env->icount_extra = count;
4327 }
4328 ret = cpu_exec(env);
89bfc105 4329#ifdef CONFIG_PROFILER
43b96858 4330 qemu_time += profile_getclock() - ti;
89bfc105 4331#endif
43b96858
AL		 4332 if (use_icount) {
4333 /* Fold pending instructions back into the
4334 instruction counter, and clear the interrupt flag. */
4335 qemu_icount -= (env->icount_decr.u16.low
4336 + env->icount_extra);
4337 env->icount_decr.u32 = 0;
4338 env->icount_extra = 0;
4339 }
4340 return ret;
4341}
4342
e6e35b1e
AL		 4343static void tcg_cpu_exec(void)
4344{
d6dc3d42 4345 int ret = 0;
e6e35b1e
AL		 4346
4347 if (next_cpu == NULL)
4348 next_cpu = first_cpu;
4349 for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4350 CPUState *env = cur_cpu = next_cpu;
4351
4352 if (!vm_running)
4353 break;
4354 if (timer_alarm_pending) {
4355 timer_alarm_pending = 0;
4356 break;
4357 }
d6dc3d42
AL		 4358 if (cpu_can_run(env))
4359 ret = qemu_cpu_exec(env);
e6e35b1e
AL		 4360 if (ret == EXCP_DEBUG) {
4361 gdb_set_stop_cpu(env);
4362 debug_requested = 1;
4363 break;
4364 }
4365 }
4366}
4367
43b96858
AL		 4368static int cpu_has_work(CPUState *env)
4369{
d6dc3d42
AL		 4370 if (env->stop)
4371 return 1;
4372 if (env->stopped)
4373 return 0;
43b96858
AL		 4374 if (!env->halted)
4375 return 1;
4376 if (qemu_cpu_has_work(env))
4377 return 1;
4378 return 0;
4379}
4380
4381static int tcg_has_work(void)
4382{
4383 CPUState *env;
4384
4385 for (env = first_cpu; env != NULL; env = env->next_cpu)
4386 if (cpu_has_work(env))
4387 return 1;
4388 return 0;
4389}
4390
4391static int qemu_calculate_timeout(void)
4392{
4393 int timeout;
4394
4395 if (!vm_running)
4396 timeout = 5000;
4397 else if (tcg_has_work())
4398 timeout = 0;
4399 else if (!use_icount)
4400 timeout = 5000;
4401 else {
4402 /* XXX: use timeout computed from timers */
4403 int64_t add;
4404 int64_t delta;
4405 /* Advance virtual time to the next event. */
4406 if (use_icount == 1) {
4407 /* When not using an adaptive execution frequency
4408 we tend to get badly out of sync with real time,
4409 so just delay for a reasonable amount of time. */
4410 delta = 0;
4411 } else {
4412 delta = cpu_get_icount() - cpu_get_clock();
4413 }
4414 if (delta > 0) {
4415 /* If virtual time is ahead of real time then just
4416 wait for IO. */
4417 timeout = (delta / 1000000) + 1;
4418 } else {
4419 /* Wait for either IO to occur or the next
4420 timer event. */
4421 add = qemu_next_deadline();
4422 /* We advance the timer before checking for IO.
4423 Limit the amount we advance so that early IO
4424 activity won't get the guest too far ahead. */
4425 if (add > 10000000)
4426 add = 10000000;
4427 delta += add;
4428 add = (add + (1 << icount_time_shift) - 1)
4429 >> icount_time_shift;
4430 qemu_icount += add;
4431 timeout = delta / 1000000;
4432 if (timeout < 0)
4433 timeout = 0;
4434 }
4435 }
4436
4437 return timeout;
4438}
4439
4440static int vm_can_run(void)
4441{
4442 if (powerdown_requested)
4443 return 0;
4444 if (reset_requested)
4445 return 0;
4446 if (shutdown_requested)
4447 return 0;
e568902a
AL		 4448 if (debug_requested)
4449 return 0;
43b96858
AL		 4450 return 1;
4451}
4452
4453static void main_loop(void)
4454{
6e29f5da 4455 int r;
e6e35b1e 4456
d6dc3d42
AL		 4457#ifdef CONFIG_IOTHREAD
4458 qemu_system_ready = 1;
4459 qemu_cond_broadcast(&qemu_system_cond);
4460#endif
4461
6e29f5da 4462 for (;;) {
43b96858 4463 do {
e6e35b1e
AL		 4464#ifdef CONFIG_PROFILER
4465 int64_t ti;
4466#endif
d6dc3d42 4467#ifndef CONFIG_IOTHREAD
e6e35b1e 4468 tcg_cpu_exec();
d6dc3d42 4469#endif
89bfc105 4470#ifdef CONFIG_PROFILER
43b96858 4471 ti = profile_getclock();
89bfc105 4472#endif
d6dc3d42
AL		 4473#ifdef CONFIG_IOTHREAD
4474 main_loop_wait(1000);
4475#else
43b96858 4476 main_loop_wait(qemu_calculate_timeout());
d6dc3d42 4477#endif
89bfc105 4478#ifdef CONFIG_PROFILER
43b96858 4479 dev_time += profile_getclock() - ti;
89bfc105 4480#endif
e568902a 4481 } while (vm_can_run());
43b96858 4482
e568902a
AL		 4483 if (qemu_debug_requested())
4484 vm_stop(EXCP_DEBUG);
43b96858
AL		 4485 if (qemu_shutdown_requested()) {
4486 if (no_shutdown) {
4487 vm_stop(0);
4488 no_shutdown = 0;
4489 } else
4490 break;
4491 }
d6dc3d42
AL		 4492 if (qemu_reset_requested()) {
4493 pause_all_vcpus();
43b96858 4494 qemu_system_reset();
d6dc3d42
AL		 4495 resume_all_vcpus();
4496 }
43b96858
AL		 4497 if (qemu_powerdown_requested())
4498 qemu_system_powerdown();
6e29f5da
AL		 4499 if ((r = qemu_vmstop_requested()))
4500 vm_stop(r);
b4608c04 4501 }
d6dc3d42 4502 pause_all_vcpus();
b4608c04
FB		 4503}
4504
9bd7e6d9
PB		 4505static void version(void)
4506{
4a19f1ec 4507 printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
9bd7e6d9
PB		 4508}
4509
15f82208 4510static void help(int exitcode)
0824d6fc 4511{
9bd7e6d9
PB		 4512 version();
4513 printf("usage: %s [options] [disk_image]\n"
0824d6fc 4514 "\n"
a20dd508 4515 "'disk_image' is a raw hard image image for IDE hard disk 0\n"
fc01f7e7 4516 "\n"
5824d651
BS		 4517#define DEF(option, opt_arg, opt_enum, opt_help) \
4518 opt_help
4519#define DEFHEADING(text) stringify(text) "\n"
4520#include "qemu-options.h"
4521#undef DEF
4522#undef DEFHEADING
4523#undef GEN_DOCS
0824d6fc 4524 "\n"
82c643ff 4525 "During emulation, the following keys are useful:\n"
032a8c9e
FB		 4526 "ctrl-alt-f toggle full screen\n"
4527 "ctrl-alt-n switch to virtual console 'n'\n"
4528 "ctrl-alt toggle mouse and keyboard grab\n"
82c643ff
FB		 4529 "\n"
4530 "When using -nographic, press 'ctrl-a h' to get some help.\n"
4531 ,
0db63474 4532 "qemu",
a00bad7e 4533 DEFAULT_RAM_SIZE,
7c9d8e07 4534#ifndef _WIN32
a00bad7e 4535 DEFAULT_NETWORK_SCRIPT,
b46a8906 4536 DEFAULT_NETWORK_DOWN_SCRIPT,
7c9d8e07 4537#endif
6e44ba7f 4538 DEFAULT_GDBSTUB_PORT,
bce61846 4539 "/tmp/qemu.log");
15f82208 4540 exit(exitcode);
0824d6fc
FB		 4541}
4542
cd6f1169
FB		 4543#define HAS_ARG 0x0001
4544
4545enum {
5824d651
BS		 4546#define DEF(option, opt_arg, opt_enum, opt_help) \
4547 opt_enum,
4548#define DEFHEADING(text)
4549#include "qemu-options.h"
4550#undef DEF
4551#undef DEFHEADING
4552#undef GEN_DOCS
cd6f1169
FB		 4553};
4554
4555typedef struct QEMUOption {
4556 const char *name;
4557 int flags;
4558 int index;
4559} QEMUOption;
4560
dbed7e40 4561static const QEMUOption qemu_options[] = {
cd6f1169 4562 { "h", 0, QEMU_OPTION_h },
5824d651
BS		 4563#define DEF(option, opt_arg, opt_enum, opt_help) \
4564 { option, opt_arg, opt_enum },
4565#define DEFHEADING(text)
4566#include "qemu-options.h"
4567#undef DEF
4568#undef DEFHEADING
4569#undef GEN_DOCS
cd6f1169 4570 { NULL },
fc01f7e7
FB		 4571};
4572
1d14ffa9 4573#ifdef HAS_AUDIO
6a36d84e 4574struct soundhw soundhw[] = {
b00052e4 4575#ifdef HAS_AUDIO_CHOICE
4ce7ff6e 4576#if defined(TARGET_I386) || defined(TARGET_MIPS)
fd06c375
FB		 4577 {
4578 "pcspk",
4579 "PC speaker",
4580 0,
4581 1,
4582 { .init_isa = pcspk_audio_init }
4583 },
4584#endif
4c9b53e3 4585
4586#ifdef CONFIG_SB16
6a36d84e
FB		 4587 {
4588 "sb16",
4589 "Creative Sound Blaster 16",
4590 0,
4591 1,
4592 { .init_isa = SB16_init }
4593 },
4c9b53e3 4594#endif
6a36d84e 4595
cc53d26d 4596#ifdef CONFIG_CS4231A
4597 {
4598 "cs4231a",
4599 "CS4231A",
4600 0,
4601 1,
4602 { .init_isa = cs4231a_init }
4603 },
4604#endif
4605
1d14ffa9 4606#ifdef CONFIG_ADLIB
6a36d84e
FB		 4607 {
4608 "adlib",
1d14ffa9 4609#ifdef HAS_YMF262
6a36d84e 4610 "Yamaha YMF262 (OPL3)",
1d14ffa9 4611#else
6a36d84e 4612 "Yamaha YM3812 (OPL2)",
1d14ffa9 4613#endif
6a36d84e
FB		 4614 0,
4615 1,
4616 { .init_isa = Adlib_init }
4617 },
1d14ffa9 4618#endif
6a36d84e 4619
1d14ffa9 4620#ifdef CONFIG_GUS
6a36d84e
FB		 4621 {
4622 "gus",
4623 "Gravis Ultrasound GF1",
4624 0,
4625 1,
4626 { .init_isa = GUS_init }
4627 },
1d14ffa9 4628#endif
6a36d84e 4629
4c9b53e3 4630#ifdef CONFIG_AC97
e5c9a13e
AZ		 4631 {
4632 "ac97",
4633 "Intel 82801AA AC97 Audio",
4634 0,
4635 0,
4636 { .init_pci = ac97_init }
4637 },
4c9b53e3 4638#endif
e5c9a13e 4639
4c9b53e3 4640#ifdef CONFIG_ES1370
6a36d84e
FB		 4641 {
4642 "es1370",
4643 "ENSONIQ AudioPCI ES1370",
4644 0,
4645 0,
4646 { .init_pci = es1370_init }
4647 },
b00052e4 4648#endif
6a36d84e 4649
4c9b53e3 4650#endif /* HAS_AUDIO_CHOICE */
4651
6a36d84e
FB		 4652 { NULL, NULL, 0, 0, { NULL } }
4653};
4654
4655static void select_soundhw (const char *optarg)
4656{
4657 struct soundhw *c;
4658
4659 if (*optarg == '?') {
4660 show_valid_cards:
4661
4662 printf ("Valid sound card names (comma separated):\n");
4663 for (c = soundhw; c->name; ++c) {
4664 printf ("%-11s %s\n", c->name, c->descr);
4665 }
4666 printf ("\n-soundhw all will enable all of the above\n");
1d14ffa9
FB		 4667 exit (*optarg != '?');
4668 }
4669 else {
6a36d84e 4670 size_t l;
1d14ffa9
FB		 4671 const char *p;
4672 char *e;
4673 int bad_card = 0;
4674
6a36d84e
FB		 4675 if (!strcmp (optarg, "all")) {
4676 for (c = soundhw; c->name; ++c) {
4677 c->enabled = 1;
4678 }
4679 return;
4680 }
1d14ffa9 4681
6a36d84e 4682 p = optarg;
1d14ffa9
FB		 4683 while (*p) {
4684 e = strchr (p, ',');
4685 l = !e ? strlen (p) : (size_t) (e - p);
6a36d84e
FB		 4686
4687 for (c = soundhw; c->name; ++c) {
4688 if (!strncmp (c->name, p, l)) {
4689 c->enabled = 1;
1d14ffa9
FB		 4690 break;
4691 }
4692 }
6a36d84e
FB		 4693
4694 if (!c->name) {
1d14ffa9
FB		 4695 if (l > 80) {
4696 fprintf (stderr,
4697 "Unknown sound card name (too big to show)\n");
4698 }
4699 else {
4700 fprintf (stderr, "Unknown sound card name `%.*s'\n",
4701 (int) l, p);
4702 }
4703 bad_card = 1;
4704 }
4705 p += l + (e != NULL);
4706 }
4707
4708 if (bad_card)
4709 goto show_valid_cards;
4710 }
4711}
4712#endif
4713
3893c124 4714static void select_vgahw (const char *p)
4715{
4716 const char *opts;
4717
28b85ed8
AL		 4718 cirrus_vga_enabled = 0;
4719 std_vga_enabled = 0;
4720 vmsvga_enabled = 0;
94909d9f 4721 xenfb_enabled = 0;
3893c124 4722 if (strstart(p, "std", &opts)) {
c2b3b41a 4723 std_vga_enabled = 1;
3893c124 4724 } else if (strstart(p, "cirrus", &opts)) {
4725 cirrus_vga_enabled = 1;
3893c124 4726 } else if (strstart(p, "vmware", &opts)) {
3893c124 4727 vmsvga_enabled = 1;
94909d9f
AL		 4728 } else if (strstart(p, "xenfb", &opts)) {
4729 xenfb_enabled = 1;
28b85ed8 4730 } else if (!strstart(p, "none", &opts)) {
3893c124 4731 invalid_vga:
4732 fprintf(stderr, "Unknown vga type: %s\n", p);
4733 exit(1);
4734 }
cb5a7aa8 4735 while (*opts) {
4736 const char *nextopt;
4737
4738 if (strstart(opts, ",retrace=", &nextopt)) {
4739 opts = nextopt;
4740 if (strstart(opts, "dumb", &nextopt))
4741 vga_retrace_method = VGA_RETRACE_DUMB;
4742 else if (strstart(opts, "precise", &nextopt))
4743 vga_retrace_method = VGA_RETRACE_PRECISE;
4744 else goto invalid_vga;
4745 } else goto invalid_vga;
4746 opts = nextopt;
4747 }
3893c124 4748}
4749
3587d7e6
FB		 4750#ifdef _WIN32
4751static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4752{
4753 exit(STATUS_CONTROL_C_EXIT);
4754 return TRUE;
4755}
4756#endif
4757
c4be29ff 4758int qemu_uuid_parse(const char *str, uint8_t *uuid)
8fcb1b90
BS		 4759{
4760 int ret;
4761
4762 if(strlen(str) != 36)
4763 return -1;
4764
4765 ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4766 &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4767 &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4768
4769 if(ret != 16)
4770 return -1;
4771
b6f6e3d3
AL		 4772#ifdef TARGET_I386
4773 smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4774#endif
4775
8fcb1b90
BS		 4776 return 0;
4777}
4778
7c9d8e07 4779#define MAX_NET_CLIENTS 32
c20709aa 4780
5b08fc10
AL		 4781#ifndef _WIN32
4782
4783static void termsig_handler(int signal)
4784{
4785 qemu_system_shutdown_request();
4786}
4787
6f9e3801 4788static void termsig_setup(void)
5b08fc10
AL		 4789{
4790 struct sigaction act;
4791
4792 memset(&act, 0, sizeof(act));
4793 act.sa_handler = termsig_handler;
4794 sigaction(SIGINT, &act, NULL);
4795 sigaction(SIGHUP, &act, NULL);
4796 sigaction(SIGTERM, &act, NULL);
4797}
4798
4799#endif
4800
902b3d5c 4801int main(int argc, char **argv, char **envp)
0824d6fc 4802{
59030a8c 4803 const char *gdbstub_dev = NULL;
28c5af54 4804 uint32_t boot_devices_bitmap = 0;
e4bcb14c 4805 int i;
28c5af54 4806 int snapshot, linux_boot, net_boot;
7f7f9873 4807 const char *initrd_filename;
a20dd508 4808 const char *kernel_filename, *kernel_cmdline;
28c5af54 4809 const char *boot_devices = "";
3023f332 4810 DisplayState *ds;
7d957bd8 4811 DisplayChangeListener *dcl;
46d4767d 4812 int cyls, heads, secs, translation;
fd5f393a 4813 const char *net_clients[MAX_NET_CLIENTS];
7c9d8e07 4814 int nb_net_clients;
dc72ac14
AZ		 4815 const char *bt_opts[MAX_BT_CMDLINE];
4816 int nb_bt_opts;
e4bcb14c 4817 int hda_index;
cd6f1169
FB		 4818 int optind;
4819 const char *r, *optarg;
4c621805 4820 CharDriverState *monitor_hd = NULL;
fd5f393a
PB		 4821 const char *monitor_device;
4822 const char *serial_devices[MAX_SERIAL_PORTS];
8d11df9e 4823 int serial_device_index;
fd5f393a 4824 const char *parallel_devices[MAX_PARALLEL_PORTS];
6508fe59 4825 int parallel_device_index;
9ede2fde
AL		 4826 const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4827 int virtio_console_index;
d63d307f 4828 const char *loadvm = NULL;
cc1daa40 4829 QEMUMachine *machine;
94fc95cd 4830 const char *cpu_model;
fd5f393a 4831 const char *usb_devices[MAX_USB_CMDLINE];
a594cfbf 4832 int usb_devices_index;
b9e82a59 4833#ifndef _WIN32
71e3ceb8 4834 int fds[2];
b9e82a59 4835#endif
26a5f13b 4836 int tb_size;
93815bc2 4837 const char *pid_file = NULL;
5bb7910a 4838 const char *incoming = NULL;
b9e82a59 4839#ifndef _WIN32
54042bcf
AL		 4840 int fd = 0;
4841 struct passwd *pwd = NULL;
0858532e
AL		 4842 const char *chroot_dir = NULL;
4843 const char *run_as = NULL;
b9e82a59 4844#endif
268a362c 4845 CPUState *env;
993fbfdb 4846 int show_vnc_port = 0;
0bd48850 4847
902b3d5c 4848 qemu_cache_utils_init(envp);
4849
0bd48850 4850 LIST_INIT (&vm_change_state_head);
be995c27
FB		 4851#ifndef _WIN32
4852 {
4853 struct sigaction act;
4854 sigfillset(&act.sa_mask);
4855 act.sa_flags = 0;
4856 act.sa_handler = SIG_IGN;
4857 sigaction(SIGPIPE, &act, NULL);
4858 }
3587d7e6
FB		 4859#else
4860 SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
a8e5ac33
FB		 4861 /* Note: cpu_interrupt() is currently not SMP safe, so we force
4862 QEMU to run on a single CPU */
4863 {
4864 HANDLE h;
4865 DWORD mask, smask;
4866 int i;
4867 h = GetCurrentProcess();
4868 if (GetProcessAffinityMask(h, &mask, &smask)) {
4869 for(i = 0; i < 32; i++) {
4870 if (mask & (1 << i))
4871 break;
4872 }
4873 if (i != 32) {
4874 mask = 1 << i;
4875 SetProcessAffinityMask(h, mask);
4876 }
4877 }
4878 }
67b915a5 4879#endif
be995c27 4880
f80f9ec9 4881 module_call_init(MODULE_INIT_MACHINE);
0c257437 4882 machine = find_default_machine();
94fc95cd 4883 cpu_model = NULL;
fc01f7e7 4884 initrd_filename = NULL;
4fc5d071 4885 ram_size = 0;
33e3963e 4886 snapshot = 0;
a20dd508
FB		 4887 kernel_filename = NULL;
4888 kernel_cmdline = "";
c4b1fcc0 4889 cyls = heads = secs = 0;
46d4767d 4890 translation = BIOS_ATA_TRANSLATION_AUTO;
d47d13b9 4891 monitor_device = "vc:80Cx24C";
c4b1fcc0 4892
c75a823c 4893 serial_devices[0] = "vc:80Cx24C";
8d11df9e 4894 for(i = 1; i < MAX_SERIAL_PORTS; i++)
fd5f393a 4895 serial_devices[i] = NULL;
8d11df9e 4896 serial_device_index = 0;
3b46e624 4897
8290edda 4898 parallel_devices[0] = "vc:80Cx24C";
6508fe59 4899 for(i = 1; i < MAX_PARALLEL_PORTS; i++)
fd5f393a 4900 parallel_devices[i] = NULL;
6508fe59 4901 parallel_device_index = 0;
3b46e624 4902
1b8fc811 4903 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
9ede2fde
AL		 4904 virtio_consoles[i] = NULL;
4905 virtio_console_index = 0;
4906
268a362c
AL		 4907 for (i = 0; i < MAX_NODES; i++) {
4908 node_mem[i] = 0;
4909 node_cpumask[i] = 0;
4910 }
4911
a594cfbf 4912 usb_devices_index = 0;
3b46e624 4913
7c9d8e07 4914 nb_net_clients = 0;
dc72ac14 4915 nb_bt_opts = 0;
e4bcb14c
TS		 4916 nb_drives = 0;
4917 nb_drives_opt = 0;
268a362c 4918 nb_numa_nodes = 0;
e4bcb14c 4919 hda_index = -1;
7c9d8e07
FB		 4920
4921 nb_nics = 0;
3b46e624 4922
26a5f13b 4923 tb_size = 0;
41bd639b
BS		 4924 autostart= 1;
4925
9dd986cc
RJ		 4926 register_watchdogs();
4927
cd6f1169 4928 optind = 1;
0824d6fc 4929 for(;;) {
cd6f1169 4930 if (optind >= argc)
0824d6fc 4931 break;
cd6f1169
FB		 4932 r = argv[optind];
4933 if (r[0] != '-') {
609497ab 4934 hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
cd6f1169
FB		 4935 } else {
4936 const QEMUOption *popt;
4937
4938 optind++;
dff5efc8
PB		 4939 /* Treat --foo the same as -foo. */
4940 if (r[1] == '-')
4941 r++;
cd6f1169
FB		 4942 popt = qemu_options;
4943 for(;;) {
4944 if (!popt->name) {
5fafdf24 4945 fprintf(stderr, "%s: invalid option -- '%s'\n",
cd6f1169
FB		 4946 argv[0], r);
4947 exit(1);
4948 }
4949 if (!strcmp(popt->name, r + 1))
4950 break;
4951 popt++;
4952 }
4953 if (popt->flags & HAS_ARG) {
4954 if (optind >= argc) {
4955 fprintf(stderr, "%s: option '%s' requires an argument\n",
4956 argv[0], r);
4957 exit(1);
4958 }
4959 optarg = argv[optind++];
4960 } else {
4961 optarg = NULL;
4962 }
4963
4964 switch(popt->index) {
cc1daa40
FB		 4965 case QEMU_OPTION_M:
4966 machine = find_machine(optarg);
4967 if (!machine) {
4968 QEMUMachine *m;
4969 printf("Supported machines are:\n");
4970 for(m = first_machine; m != NULL; m = m->next) {
4971 printf("%-10s %s%s\n",
5fafdf24 4972 m->name, m->desc,
0c257437 4973 m->is_default ? " (default)" : "");
cc1daa40 4974 }
15f82208 4975 exit(*optarg != '?');
cc1daa40
FB		 4976 }
4977 break;
94fc95cd
JM		 4978 case QEMU_OPTION_cpu:
4979 /* hw initialization will check this */
15f82208 4980 if (*optarg == '?') {
c732abe2
JM		 4981/* XXX: implement xxx_cpu_list for targets that still miss it */
4982#if defined(cpu_list)
4983 cpu_list(stdout, &fprintf);
94fc95cd 4984#endif
15f82208 4985 exit(0);
94fc95cd
JM		 4986 } else {
4987 cpu_model = optarg;
4988 }
4989 break;
cd6f1169 4990 case QEMU_OPTION_initrd:
fc01f7e7
FB		 4991 initrd_filename = optarg;
4992 break;
cd6f1169 4993 case QEMU_OPTION_hda:
e4bcb14c 4994 if (cyls == 0)
609497ab 4995 hda_index = drive_add(optarg, HD_ALIAS, 0);
e4bcb14c 4996 else
609497ab 4997 hda_index = drive_add(optarg, HD_ALIAS
e4bcb14c 4998 ",cyls=%d,heads=%d,secs=%d%s",
609497ab 4999 0, cyls, heads, secs,
e4bcb14c
TS		 5000 translation == BIOS_ATA_TRANSLATION_LBA ?
5001 ",trans=lba" :
5002 translation == BIOS_ATA_TRANSLATION_NONE ?
5003 ",trans=none" : "");
5004 break;
cd6f1169 5005 case QEMU_OPTION_hdb:
cc1daa40
FB		 5006 case QEMU_OPTION_hdc:
5007 case QEMU_OPTION_hdd:
609497ab 5008 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
fc01f7e7 5009 break;
e4bcb14c 5010 case QEMU_OPTION_drive:
609497ab 5011 drive_add(NULL, "%s", optarg);
e4bcb14c 5012 break;
3e3d5815 5013 case QEMU_OPTION_mtdblock:
609497ab 5014 drive_add(optarg, MTD_ALIAS);
3e3d5815 5015 break;
a1bb27b1 5016 case QEMU_OPTION_sd:
609497ab 5017 drive_add(optarg, SD_ALIAS);
a1bb27b1 5018 break;
86f55663 5019 case QEMU_OPTION_pflash:
609497ab 5020 drive_add(optarg, PFLASH_ALIAS);
86f55663 5021 break;
cd6f1169 5022 case QEMU_OPTION_snapshot:
33e3963e
FB		 5023 snapshot = 1;
5024 break;
cd6f1169 5025 case QEMU_OPTION_hdachs:
330d0414 5026 {
330d0414
FB		 5027 const char *p;
5028 p = optarg;
5029 cyls = strtol(p, (char **)&p, 0);
46d4767d
FB		 5030 if (cyls < 1 || cyls > 16383)
5031 goto chs_fail;
330d0414
FB		 5032 if (*p != ',')
5033 goto chs_fail;
5034 p++;
5035 heads = strtol(p, (char **)&p, 0);
46d4767d
FB		 5036 if (heads < 1 || heads > 16)
5037 goto chs_fail;
330d0414
FB		 5038 if (*p != ',')
5039 goto chs_fail;
5040 p++;
5041 secs = strtol(p, (char **)&p, 0);
46d4767d
FB		 5042 if (secs < 1 || secs > 63)
5043 goto chs_fail;
5044 if (*p == ',') {
5045 p++;
5046 if (!strcmp(p, "none"))
5047 translation = BIOS_ATA_TRANSLATION_NONE;
5048 else if (!strcmp(p, "lba"))
5049 translation = BIOS_ATA_TRANSLATION_LBA;
5050 else if (!strcmp(p, "auto"))
5051 translation = BIOS_ATA_TRANSLATION_AUTO;
5052 else
5053 goto chs_fail;
5054 } else if (*p != '\0') {
c4b1fcc0 5055 chs_fail:
46d4767d
FB		 5056 fprintf(stderr, "qemu: invalid physical CHS format\n");
5057 exit(1);
c4b1fcc0 5058 }
e4bcb14c 5059 if (hda_index != -1)
609497ab
AZ		 5060 snprintf(drives_opt[hda_index].opt,
5061 sizeof(drives_opt[hda_index].opt),
5062 HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
5063 0, cyls, heads, secs,
e4bcb14c
TS		 5064 translation == BIOS_ATA_TRANSLATION_LBA ?
5065 ",trans=lba" :
5066 translation == BIOS_ATA_TRANSLATION_NONE ?
5067 ",trans=none" : "");
330d0414
FB		 5068 }
5069 break;
268a362c
AL		 5070 case QEMU_OPTION_numa:
5071 if (nb_numa_nodes >= MAX_NODES) {
5072 fprintf(stderr, "qemu: too many NUMA nodes\n");
5073 exit(1);
5074 }
5075 numa_add(optarg);
5076 break;
cd6f1169 5077 case QEMU_OPTION_nographic:
993fbfdb 5078 display_type = DT_NOGRAPHIC;
a20dd508 5079 break;
4d3b6f6e
AZ		 5080#ifdef CONFIG_CURSES
5081 case QEMU_OPTION_curses:
993fbfdb 5082 display_type = DT_CURSES;
4d3b6f6e
AZ		 5083 break;
5084#endif
a171fe39
AZ		 5085 case QEMU_OPTION_portrait:
5086 graphic_rotate = 1;
5087 break;
cd6f1169 5088 case QEMU_OPTION_kernel:
a20dd508
FB		 5089 kernel_filename = optarg;
5090 break;
cd6f1169 5091 case QEMU_OPTION_append:
a20dd508 5092 kernel_cmdline = optarg;
313aa567 5093 break;
cd6f1169 5094 case QEMU_OPTION_cdrom:
609497ab 5095 drive_add(optarg, CDROM_ALIAS);
36b486bb 5096 break;
cd6f1169 5097 case QEMU_OPTION_boot:
28c5af54
JM		 5098 boot_devices = optarg;
5099 /* We just do some generic consistency checks */
5100 {
5101 /* Could easily be extended to 64 devices if needed */
60fe76f3 5102 const char *p;
28c5af54
JM		 5103
5104 boot_devices_bitmap = 0;
5105 for (p = boot_devices; *p != '\0'; p++) {
5106 /* Allowed boot devices are:
5107 * a b : floppy disk drives
5108 * c ... f : IDE disk drives
5109 * g ... m : machine implementation dependant drives
5110 * n ... p : network devices
5111 * It's up to each machine implementation to check
5112 * if the given boot devices match the actual hardware
5113 * implementation and firmware features.
5114 */
5115 if (*p < 'a' || *p > 'q') {
5116 fprintf(stderr, "Invalid boot device '%c'\n", *p);
5117 exit(1);
5118 }
5119 if (boot_devices_bitmap & (1 << (*p - 'a'))) {
5120 fprintf(stderr,
5121 "Boot device '%c' was given twice\n",*p);
5122 exit(1);
5123 }
5124 boot_devices_bitmap |= 1 << (*p - 'a');
5125 }
36b486bb
FB		 5126 }
5127 break;
cd6f1169 5128 case QEMU_OPTION_fda:
cd6f1169 5129 case QEMU_OPTION_fdb:
609497ab 5130 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
c45886db 5131 break;
52ca8d6a
FB		 5132#ifdef TARGET_I386
5133 case QEMU_OPTION_no_fd_bootchk:
5134 fd_bootchk = 0;
5135 break;
5136#endif
7c9d8e07
FB		 5137 case QEMU_OPTION_net:
5138 if (nb_net_clients >= MAX_NET_CLIENTS) {
5139 fprintf(stderr, "qemu: too many network clients\n");
c4b1fcc0
FB		 5140 exit(1);
5141 }
fd5f393a 5142 net_clients[nb_net_clients] = optarg;
7c9d8e07 5143 nb_net_clients++;
702c651c 5144 break;
c7f74643
FB		 5145#ifdef CONFIG_SLIRP
5146 case QEMU_OPTION_tftp:
c7f74643 5147 tftp_prefix = optarg;
9bf05444 5148 break;
47d5d01a
TS		 5149 case QEMU_OPTION_bootp:
5150 bootp_filename = optarg;
5151 break;
c94c8d64 5152#ifndef _WIN32
9d728e8c
FB		 5153 case QEMU_OPTION_smb:
5154 net_slirp_smb(optarg);
5155 break;
c94c8d64 5156#endif
9bf05444 5157 case QEMU_OPTION_redir:
d4ebe193 5158 net_slirp_redir(NULL, optarg);
9bf05444 5159 break;
c7f74643 5160#endif
dc72ac14
AZ		 5161 case QEMU_OPTION_bt:
5162 if (nb_bt_opts >= MAX_BT_CMDLINE) {
5163 fprintf(stderr, "qemu: too many bluetooth options\n");
5164 exit(1);
5165 }
5166 bt_opts[nb_bt_opts++] = optarg;
5167 break;
1d14ffa9 5168#ifdef HAS_AUDIO
1d14ffa9
FB		 5169 case QEMU_OPTION_audio_help:
5170 AUD_help ();
5171 exit (0);
5172 break;
5173 case QEMU_OPTION_soundhw:
5174 select_soundhw (optarg);
5175 break;
5176#endif
cd6f1169 5177 case QEMU_OPTION_h:
15f82208 5178 help(0);
cd6f1169 5179 break;
9bd7e6d9
PB		 5180 case QEMU_OPTION_version:
5181 version();
5182 exit(0);
5183 break;
00f82b8a
AJ		 5184 case QEMU_OPTION_m: {
5185 uint64_t value;
5186 char *ptr;
5187
5188 value = strtoul(optarg, &ptr, 10);
5189 switch (*ptr) {
5190 case 0: case 'M': case 'm':
5191 value <<= 20;
5192 break;
5193 case 'G': case 'g':
5194 value <<= 30;
5195 break;
5196 default:
5197 fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
cd6f1169
FB		 5198 exit(1);
5199 }
00f82b8a
AJ		 5200
5201 /* On 32-bit hosts, QEMU is limited by virtual address space */
5202 if (value > (2047 << 20)
640f42e4 5203#ifndef CONFIG_KQEMU
00f82b8a
AJ		 5204 && HOST_LONG_BITS == 32
5205#endif
5206 ) {
5207 fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5208 exit(1);
5209 }
5210 if (value != (uint64_t)(ram_addr_t)value) {
5211 fprintf(stderr, "qemu: ram size too large\n");
5212 exit(1);
5213 }
5214 ram_size = value;
cd6f1169 5215 break;
00f82b8a 5216 }
cd6f1169
FB		 5217 case QEMU_OPTION_d:
5218 {
5219 int mask;
c7cd6a37 5220 const CPULogItem *item;
3b46e624 5221
cd6f1169
FB		 5222 mask = cpu_str_to_log_mask(optarg);
5223 if (!mask) {
5224 printf("Log items (comma separated):\n");
f193c797
FB		 5225 for(item = cpu_log_items; item->mask != 0; item++) {
5226 printf("%-10s %s\n", item->name, item->help);
5227 }
5228 exit(1);
cd6f1169
FB		 5229 }
5230 cpu_set_log(mask);
f193c797 5231 }
cd6f1169 5232 break;
cd6f1169 5233 case QEMU_OPTION_s:
59030a8c 5234 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
cd6f1169 5235 break;
59030a8c
AL		 5236 case QEMU_OPTION_gdb:
5237 gdbstub_dev = optarg;
cd6f1169 5238 break;
cd6f1169
FB		 5239 case QEMU_OPTION_L:
5240 bios_dir = optarg;
5241 break;
1192dad8
JM		 5242 case QEMU_OPTION_bios:
5243 bios_name = optarg;
5244 break;
1b530a6d
AJ		 5245 case QEMU_OPTION_singlestep:
5246 singlestep = 1;
5247 break;
cd6f1169 5248 case QEMU_OPTION_S:
3c07f8e8 5249 autostart = 0;
cd6f1169 5250 break;
5824d651 5251#ifndef _WIN32
3d11d0eb
FB		 5252 case QEMU_OPTION_k:
5253 keyboard_layout = optarg;
5254 break;
5824d651 5255#endif
ee22c2f7
FB		 5256 case QEMU_OPTION_localtime:
5257 rtc_utc = 0;
5258 break;
3893c124 5259 case QEMU_OPTION_vga:
5260 select_vgahw (optarg);
1bfe856e 5261 break;
5824d651 5262#if defined(TARGET_PPC) || defined(TARGET_SPARC)
e9b137c2
FB		 5263 case QEMU_OPTION_g:
5264 {
5265 const char *p;
5266 int w, h, depth;
5267 p = optarg;
5268 w = strtol(p, (char **)&p, 10);
5269 if (w <= 0) {
5270 graphic_error:
5271 fprintf(stderr, "qemu: invalid resolution or depth\n");
5272 exit(1);
5273 }
5274 if (*p != 'x')
5275 goto graphic_error;
5276 p++;
5277 h = strtol(p, (char **)&p, 10);
5278 if (h <= 0)
5279 goto graphic_error;
5280 if (*p == 'x') {
5281 p++;
5282 depth = strtol(p, (char **)&p, 10);
5fafdf24 5283 if (depth != 8 && depth != 15 && depth != 16 &&
e9b137c2
FB		 5284 depth != 24 && depth != 32)
5285 goto graphic_error;
5286 } else if (*p == '\0') {
5287 depth = graphic_depth;
5288 } else {
5289 goto graphic_error;
5290 }
3b46e624 5291
e9b137c2
FB		 5292 graphic_width = w;
5293 graphic_height = h;
5294 graphic_depth = depth;
5295 }
5296 break;
5824d651 5297#endif
20d8a3ed
TS		 5298 case QEMU_OPTION_echr:
5299 {
5300 char *r;
5301 term_escape_char = strtol(optarg, &r, 0);
5302 if (r == optarg)
5303 printf("Bad argument to echr\n");
5304 break;
5305 }
82c643ff 5306 case QEMU_OPTION_monitor:
fd5f393a 5307 monitor_device = optarg;
82c643ff
FB		 5308 break;
5309 case QEMU_OPTION_serial:
8d11df9e
FB		 5310 if (serial_device_index >= MAX_SERIAL_PORTS) {
5311 fprintf(stderr, "qemu: too many serial ports\n");
5312 exit(1);
5313 }
fd5f393a 5314 serial_devices[serial_device_index] = optarg;
8d11df9e 5315 serial_device_index++;
82c643ff 5316 break;
9dd986cc
RJ		 5317 case QEMU_OPTION_watchdog:
5318 i = select_watchdog(optarg);
5319 if (i > 0)
5320 exit (i == 1 ? 1 : 0);
5321 break;
5322 case QEMU_OPTION_watchdog_action:
5323 if (select_watchdog_action(optarg) == -1) {
5324 fprintf(stderr, "Unknown -watchdog-action parameter\n");
5325 exit(1);
5326 }
5327 break;
51ecf136
AL		 5328 case QEMU_OPTION_virtiocon:
5329 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5330 fprintf(stderr, "qemu: too many virtio consoles\n");
5331 exit(1);
5332 }
5333 virtio_consoles[virtio_console_index] = optarg;
5334 virtio_console_index++;
5335 break;
6508fe59
FB		 5336 case QEMU_OPTION_parallel:
5337 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5338 fprintf(stderr, "qemu: too many parallel ports\n");
5339 exit(1);
5340 }
fd5f393a 5341 parallel_devices[parallel_device_index] = optarg;
6508fe59
FB		 5342 parallel_device_index++;
5343 break;
d63d307f
FB		 5344 case QEMU_OPTION_loadvm:
5345 loadvm = optarg;
5346 break;
5347 case QEMU_OPTION_full_screen:
5348 full_screen = 1;
5349 break;
667accab 5350#ifdef CONFIG_SDL
43523e93
TS		 5351 case QEMU_OPTION_no_frame:
5352 no_frame = 1;
5353 break;
3780e197
TS		 5354 case QEMU_OPTION_alt_grab:
5355 alt_grab = 1;
5356 break;
667accab
TS		 5357 case QEMU_OPTION_no_quit:
5358 no_quit = 1;
5359 break;
7d957bd8 5360 case QEMU_OPTION_sdl:
993fbfdb 5361 display_type = DT_SDL;
7d957bd8 5362 break;
667accab 5363#endif
f7cce898 5364 case QEMU_OPTION_pidfile:
93815bc2 5365 pid_file = optarg;
f7cce898 5366 break;
a09db21f
FB		 5367#ifdef TARGET_I386
5368 case QEMU_OPTION_win2k_hack:
5369 win2k_install_hack = 1;
5370 break;
73822ec8
AL		 5371 case QEMU_OPTION_rtc_td_hack:
5372 rtc_td_hack = 1;
5373 break;
8a92ea2f
AL		 5374 case QEMU_OPTION_acpitable:
5375 if(acpi_table_add(optarg) < 0) {
5376 fprintf(stderr, "Wrong acpi table provided\n");
5377 exit(1);
5378 }
5379 break;
b6f6e3d3
AL		 5380 case QEMU_OPTION_smbios:
5381 if(smbios_entry_add(optarg) < 0) {
5382 fprintf(stderr, "Wrong smbios provided\n");
5383 exit(1);
5384 }
5385 break;
a09db21f 5386#endif
640f42e4 5387#ifdef CONFIG_KQEMU
d993e026
FB		 5388 case QEMU_OPTION_no_kqemu:
5389 kqemu_allowed = 0;
5390 break;
89bfc105
FB		 5391 case QEMU_OPTION_kernel_kqemu:
5392 kqemu_allowed = 2;
5393 break;
7ba1e619
AL		 5394#endif
5395#ifdef CONFIG_KVM
5396 case QEMU_OPTION_enable_kvm:
5397 kvm_allowed = 1;
640f42e4 5398#ifdef CONFIG_KQEMU
7ba1e619
AL		 5399 kqemu_allowed = 0;
5400#endif
5401 break;
d993e026 5402#endif
bb36d470
FB		 5403 case QEMU_OPTION_usb:
5404 usb_enabled = 1;
5405 break;
a594cfbf
FB		 5406 case QEMU_OPTION_usbdevice:
5407 usb_enabled = 1;
0d92ed30 5408 if (usb_devices_index >= MAX_USB_CMDLINE) {
a594cfbf
FB		 5409 fprintf(stderr, "Too many USB devices\n");
5410 exit(1);
5411 }
fd5f393a 5412 usb_devices[usb_devices_index] = optarg;
a594cfbf
FB		 5413 usb_devices_index++;
5414 break;
6a00d601
FB		 5415 case QEMU_OPTION_smp:
5416 smp_cpus = atoi(optarg);
b2097003 5417 if (smp_cpus < 1) {
6a00d601
FB		 5418 fprintf(stderr, "Invalid number of CPUs\n");
5419 exit(1);
5420 }
5421 break;
24236869 5422 case QEMU_OPTION_vnc:
993fbfdb 5423 display_type = DT_VNC;
73fc9742 5424 vnc_display = optarg;
24236869 5425 break;
5824d651 5426#ifdef TARGET_I386
6515b203
FB		 5427 case QEMU_OPTION_no_acpi:
5428 acpi_enabled = 0;
5429 break;
16b29ae1
AL		 5430 case QEMU_OPTION_no_hpet:
5431 no_hpet = 1;
5432 break;
5824d651 5433#endif
d1beab82
FB		 5434 case QEMU_OPTION_no_reboot:
5435 no_reboot = 1;
5436 break;
b2f76161
AJ		 5437 case QEMU_OPTION_no_shutdown:
5438 no_shutdown = 1;
5439 break;
9467cd46
AZ		 5440 case QEMU_OPTION_show_cursor:
5441 cursor_hide = 0;
5442 break;
8fcb1b90
BS		 5443 case QEMU_OPTION_uuid:
5444 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5445 fprintf(stderr, "Fail to parse UUID string."
5446 " Wrong format.\n");
5447 exit(1);
5448 }
5449 break;
5824d651 5450#ifndef _WIN32
71e3ceb8
TS		 5451 case QEMU_OPTION_daemonize:
5452 daemonize = 1;
5453 break;
5824d651 5454#endif
9ae02555
TS		 5455 case QEMU_OPTION_option_rom:
5456 if (nb_option_roms >= MAX_OPTION_ROMS) {
5457 fprintf(stderr, "Too many option ROMs\n");
5458 exit(1);
5459 }
5460 option_rom[nb_option_roms] = optarg;
5461 nb_option_roms++;
5462 break;
5824d651 5463#if defined(TARGET_ARM) || defined(TARGET_M68K)
8e71621f
PB		 5464 case QEMU_OPTION_semihosting:
5465 semihosting_enabled = 1;
5466 break;
5824d651 5467#endif
c35734b2
TS		 5468 case QEMU_OPTION_name:
5469 qemu_name = optarg;
5470 break;
95efd11c 5471#if defined(TARGET_SPARC) || defined(TARGET_PPC)
66508601
BS		 5472 case QEMU_OPTION_prom_env:
5473 if (nb_prom_envs >= MAX_PROM_ENVS) {
5474 fprintf(stderr, "Too many prom variables\n");
5475 exit(1);
5476 }
5477 prom_envs[nb_prom_envs] = optarg;
5478 nb_prom_envs++;
5479 break;
2b8f2d41
AZ		 5480#endif
5481#ifdef TARGET_ARM
5482 case QEMU_OPTION_old_param:
5483 old_param = 1;
05ebd537 5484 break;
66508601 5485#endif
f3dcfada
TS		 5486 case QEMU_OPTION_clock:
5487 configure_alarms(optarg);
5488 break;
7e0af5d0
FB		 5489 case QEMU_OPTION_startdate:
5490 {
5491 struct tm tm;
f6503059 5492 time_t rtc_start_date;
7e0af5d0 5493 if (!strcmp(optarg, "now")) {
f6503059 5494 rtc_date_offset = -1;
7e0af5d0
FB		 5495 } else {
5496 if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5497 &tm.tm_year,
5498 &tm.tm_mon,
5499 &tm.tm_mday,
5500 &tm.tm_hour,
5501 &tm.tm_min,
5502 &tm.tm_sec) == 6) {
5503 /* OK */
5504 } else if (sscanf(optarg, "%d-%d-%d",
5505 &tm.tm_year,
5506 &tm.tm_mon,
5507 &tm.tm_mday) == 3) {
5508 tm.tm_hour = 0;
5509 tm.tm_min = 0;
5510 tm.tm_sec = 0;
5511 } else {
5512 goto date_fail;
5513 }
5514 tm.tm_year -= 1900;
5515 tm.tm_mon--;
3c6b2088 5516 rtc_start_date = mktimegm(&tm);
7e0af5d0
FB		 5517 if (rtc_start_date == -1) {
5518 date_fail:
5519 fprintf(stderr, "Invalid date format. Valid format are:\n"
5520 "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5521 exit(1);
5522 }
f6503059 5523 rtc_date_offset = time(NULL) - rtc_start_date;
7e0af5d0
FB		 5524 }
5525 }
5526 break;
26a5f13b
FB		 5527 case QEMU_OPTION_tb_size:
5528 tb_size = strtol(optarg, NULL, 0);
5529 if (tb_size < 0)
5530 tb_size = 0;
5531 break;
2e70f6ef
PB		 5532 case QEMU_OPTION_icount:
5533 use_icount = 1;
5534 if (strcmp(optarg, "auto") == 0) {
5535 icount_time_shift = -1;
5536 } else {
5537 icount_time_shift = strtol(optarg, NULL, 0);
5538 }
5539 break;
5bb7910a
AL		 5540 case QEMU_OPTION_incoming:
5541 incoming = optarg;
5542 break;
5824d651 5543#ifndef _WIN32
0858532e
AL		 5544 case QEMU_OPTION_chroot:
5545 chroot_dir = optarg;
5546 break;
5547 case QEMU_OPTION_runas:
5548 run_as = optarg;
5549 break;
e37630ca
AL		 5550#endif
5551#ifdef CONFIG_XEN
5552 case QEMU_OPTION_xen_domid:
5553 xen_domid = atoi(optarg);
5554 break;
5555 case QEMU_OPTION_xen_create:
5556 xen_mode = XEN_CREATE;
5557 break;
5558 case QEMU_OPTION_xen_attach:
5559 xen_mode = XEN_ATTACH;
5560 break;
5824d651 5561#endif
cd6f1169 5562 }
0824d6fc
FB		 5563 }
5564 }
330d0414 5565
640f42e4 5566#if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
7ba1e619
AL		 5567 if (kvm_allowed && kqemu_allowed) {
5568 fprintf(stderr,
5569 "You can not enable both KVM and kqemu at the same time\n");
5570 exit(1);
5571 }
5572#endif
5573
3d878caa 5574 machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
b2097003
AL		 5575 if (smp_cpus > machine->max_cpus) {
5576 fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5577 "supported by machine `%s' (%d)\n", smp_cpus, machine->name,
5578 machine->max_cpus);
5579 exit(1);
5580 }
5581
993fbfdb 5582 if (display_type == DT_NOGRAPHIC) {
bc0129d9
AL		 5583 if (serial_device_index == 0)
5584 serial_devices[0] = "stdio";
5585 if (parallel_device_index == 0)
5586 parallel_devices[0] = "null";
5587 if (strncmp(monitor_device, "vc", 2) == 0)
5588 monitor_device = "stdio";
5589 }
5590
71e3ceb8 5591#ifndef _WIN32
71e3ceb8
TS		 5592 if (daemonize) {
5593 pid_t pid;
5594
5595 if (pipe(fds) == -1)
5596 exit(1);
5597
5598 pid = fork();
5599 if (pid > 0) {
5600 uint8_t status;
5601 ssize_t len;
5602
5603 close(fds[1]);
5604
5605 again:
93815bc2
TS		 5606 len = read(fds[0], &status, 1);
5607 if (len == -1 && (errno == EINTR))
5608 goto again;
5609
5610 if (len != 1)
5611 exit(1);
5612 else if (status == 1) {
5613 fprintf(stderr, "Could not acquire pidfile\n");
5614 exit(1);
5615 } else
5616 exit(0);
71e3ceb8 5617 } else if (pid < 0)
93815bc2 5618 exit(1);
71e3ceb8
TS		 5619
5620 setsid();
5621
5622 pid = fork();
5623 if (pid > 0)
5624 exit(0);
5625 else if (pid < 0)
5626 exit(1);
5627
5628 umask(027);
71e3ceb8
TS		 5629
5630 signal(SIGTSTP, SIG_IGN);
5631 signal(SIGTTOU, SIG_IGN);
5632 signal(SIGTTIN, SIG_IGN);
5633 }
71e3ceb8 5634
aa26bb2d 5635 if (pid_file && qemu_create_pidfile(pid_file) != 0) {
93815bc2
TS		 5636 if (daemonize) {
5637 uint8_t status = 1;
5638 write(fds[1], &status, 1);
5639 } else
5640 fprintf(stderr, "Could not acquire pid file\n");
5641 exit(1);
5642 }
b9e82a59 5643#endif
93815bc2 5644
640f42e4 5645#ifdef CONFIG_KQEMU
ff3fbb30
FB		 5646 if (smp_cpus > 1)
5647 kqemu_allowed = 0;
5648#endif
3fcf7b6b
AL		 5649 if (qemu_init_main_loop()) {
5650 fprintf(stderr, "qemu_init_main_loop failed\n");
5651 exit(1);
5652 }
a20dd508 5653 linux_boot = (kernel_filename != NULL);
7317b8ca 5654 net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
6c41b272 5655
f8d39c01
TS		 5656 if (!linux_boot && *kernel_cmdline != '\0') {
5657 fprintf(stderr, "-append only allowed with -kernel option\n");
5658 exit(1);
5659 }
5660
5661 if (!linux_boot && initrd_filename != NULL) {
5662 fprintf(stderr, "-initrd only allowed with -kernel option\n");
5663 exit(1);
5664 }
5665
96d30e48 5666 /* boot to floppy or the default cd if no hard disk defined yet */
28c5af54 5667 if (!boot_devices[0]) {
e4bcb14c 5668 boot_devices = "cad";
96d30e48 5669 }
b118d61e 5670 setvbuf(stdout, NULL, _IOLBF, 0);
3b46e624 5671
634fce96 5672 init_timers();
7183b4b4
AL		 5673 if (init_timer_alarm() < 0) {
5674 fprintf(stderr, "could not initialize alarm timer\n");
5675 exit(1);
5676 }
2e70f6ef
PB		 5677 if (use_icount && icount_time_shift < 0) {
5678 use_icount = 2;
5679 /* 125MIPS seems a reasonable initial guess at the guest speed.
5680 It will be corrected fairly quickly anyway. */
5681 icount_time_shift = 3;
5682 init_icount_adjust();
5683 }
634fce96 5684
fd1dff4b
FB		 5685#ifdef _WIN32
5686 socket_init();
5687#endif
5688
7c9d8e07
FB		 5689 /* init network clients */
5690 if (nb_net_clients == 0) {
5691 /* if no clients, we use a default config */
f441b28b
AL		 5692 net_clients[nb_net_clients++] = "nic";
5693#ifdef CONFIG_SLIRP
5694 net_clients[nb_net_clients++] = "user";
5695#endif
c20709aa
FB		 5696 }
5697
7c9d8e07 5698 for(i = 0;i < nb_net_clients; i++) {
9ad97e65 5699 if (net_client_parse(net_clients[i]) < 0)
7c9d8e07 5700 exit(1);
702c651c 5701 }
63a01ef8 5702 net_client_check();
f1510b2c 5703
eec85c2a 5704#ifdef TARGET_I386
ed494d87 5705 /* XXX: this should be moved in the PC machine instantiation code */
28c5af54
JM		 5706 if (net_boot != 0) {
5707 int netroms = 0;
5708 for (i = 0; i < nb_nics && i < 4; i++) {
eec85c2a
TS		 5709 const char *model = nd_table[i].model;
5710 char buf[1024];
28c5af54
JM		 5711 if (net_boot & (1 << i)) {
5712 if (model == NULL)
5713 model = "ne2k_pci";
5714 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5715 if (get_image_size(buf) > 0) {
5716 if (nb_option_roms >= MAX_OPTION_ROMS) {
5717 fprintf(stderr, "Too many option ROMs\n");
5718 exit(1);
5719 }
5720 option_rom[nb_option_roms] = strdup(buf);
5721 nb_option_roms++;
5722 netroms++;
5723 }
5724 }
eec85c2a 5725 }
28c5af54 5726 if (netroms == 0) {
eec85c2a
TS		 5727 fprintf(stderr, "No valid PXE rom found for network device\n");
5728 exit(1);
5729 }
eec85c2a
TS		 5730 }
5731#endif
5732
dc72ac14
AZ		 5733 /* init the bluetooth world */
5734 for (i = 0; i < nb_bt_opts; i++)
5735 if (bt_parse(bt_opts[i]))
5736 exit(1);
5737
0824d6fc 5738 /* init the memory */
94a6b54f
PB		 5739 if (ram_size == 0)
5740 ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
9ae02555 5741
640f42e4 5742#ifdef CONFIG_KQEMU
94a6b54f
PB		 5743 /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5744 guest ram allocation. It needs to go away. */
5745 if (kqemu_allowed) {
4cfce484 5746 kqemu_phys_ram_size = ram_size + 8 * 1024 * 1024 + 4 * 1024 * 1024;
94a6b54f
PB		 5747 kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size);
5748 if (!kqemu_phys_ram_base) {
5749 fprintf(stderr, "Could not allocate physical memory\n");
5750 exit(1);
5751 }
0824d6fc 5752 }
94a6b54f 5753#endif
0824d6fc 5754
26a5f13b
FB		 5755 /* init the dynamic translator */
5756 cpu_exec_init_all(tb_size * 1024 * 1024);
5757
5905b2e5 5758 bdrv_init();
6512a2a7 5759 dma_helper_init();
c4b1fcc0 5760
e4bcb14c 5761 /* we always create the cdrom drive, even if no disk is there */
c4b1fcc0 5762
e4bcb14c 5763 if (nb_drives_opt < MAX_DRIVES)
609497ab 5764 drive_add(NULL, CDROM_ALIAS);
c4b1fcc0 5765
9d413d1d 5766 /* we always create at least one floppy */
33e3963e 5767
e4bcb14c 5768 if (nb_drives_opt < MAX_DRIVES)
609497ab 5769 drive_add(NULL, FD_ALIAS, 0);
86f55663 5770
9d413d1d
AZ		 5771 /* we always create one sd slot, even if no card is in it */
5772
5773 if (nb_drives_opt < MAX_DRIVES)
609497ab 5774 drive_add(NULL, SD_ALIAS);
9d413d1d 5775
e4bcb14c
TS		 5776 /* open the virtual block devices */
5777
5778 for(i = 0; i < nb_drives_opt; i++)
609497ab 5779 if (drive_init(&drives_opt[i], snapshot, machine) == -1)
e4bcb14c 5780 exit(1);
3e3d5815 5781
c88676f8 5782 register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
475e4277 5783 register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
8a7ddc38 5784
3023f332
AL		 5785#ifndef _WIN32
5786 /* must be after terminal init, SDL library changes signal handlers */
5787 termsig_setup();
5788#endif
5789
5790 /* Maintain compatibility with multiple stdio monitors */
5791 if (!strcmp(monitor_device,"stdio")) {
5792 for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5793 const char *devname = serial_devices[i];
5794 if (devname && !strcmp(devname,"mon:stdio")) {
5795 monitor_device = NULL;
5796 break;
5797 } else if (devname && !strcmp(devname,"stdio")) {
5798 monitor_device = NULL;
5799 serial_devices[i] = "mon:stdio";
5800 break;
5801 }
5802 }
5803 }
5804
268a362c
AL		 5805 if (nb_numa_nodes > 0) {
5806 int i;
5807
5808 if (nb_numa_nodes > smp_cpus) {
5809 nb_numa_nodes = smp_cpus;
5810 }
5811
5812 /* If no memory size if given for any node, assume the default case
5813 * and distribute the available memory equally across all nodes
5814 */
5815 for (i = 0; i < nb_numa_nodes; i++) {
5816 if (node_mem[i] != 0)
5817 break;
5818 }
5819 if (i == nb_numa_nodes) {
5820 uint64_t usedmem = 0;
5821
5822 /* On Linux, the each node's border has to be 8MB aligned,
5823 * the final node gets the rest.
5824 */
5825 for (i = 0; i < nb_numa_nodes - 1; i++) {
5826 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5827 usedmem += node_mem[i];
5828 }
5829 node_mem[i] = ram_size - usedmem;
5830 }
5831
5832 for (i = 0; i < nb_numa_nodes; i++) {
5833 if (node_cpumask[i] != 0)
5834 break;
5835 }
5836 /* assigning the VCPUs round-robin is easier to implement, guest OSes
5837 * must cope with this anyway, because there are BIOSes out there in
5838 * real machines which also use this scheme.
5839 */
5840 if (i == nb_numa_nodes) {
5841 for (i = 0; i < smp_cpus; i++) {
5842 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5843 }
5844 }
5845 }
5846
3023f332
AL		 5847 if (kvm_enabled()) {
5848 int ret;
5849
5850 ret = kvm_init(smp_cpus);
5851 if (ret < 0) {
5852 fprintf(stderr, "failed to initialize KVM\n");
5853 exit(1);
5854 }
5855 }
5856
4c621805 5857 if (monitor_device) {
ceecf1d1 5858 monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
4c621805
AL		 5859 if (!monitor_hd) {
5860 fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5861 exit(1);
5862 }
5863 }
5864
2796dae0
AL		 5865 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5866 const char *devname = serial_devices[i];
5867 if (devname && strcmp(devname, "none")) {
5868 char label[32];
5869 snprintf(label, sizeof(label), "serial%d", i);
ceecf1d1 5870 serial_hds[i] = qemu_chr_open(label, devname, NULL);
2796dae0
AL		 5871 if (!serial_hds[i]) {
5872 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5873 devname);
5874 exit(1);
5875 }
5876 }
5877 }
5878
5879 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5880 const char *devname = parallel_devices[i];
5881 if (devname && strcmp(devname, "none")) {
5882 char label[32];
5883 snprintf(label, sizeof(label), "parallel%d", i);
ceecf1d1 5884 parallel_hds[i] = qemu_chr_open(label, devname, NULL);
2796dae0
AL		 5885 if (!parallel_hds[i]) {
5886 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5887 devname);
5888 exit(1);
5889 }
5890 }
5891 }
5892
5893 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5894 const char *devname = virtio_consoles[i];
5895 if (devname && strcmp(devname, "none")) {
5896 char label[32];
5897 snprintf(label, sizeof(label), "virtcon%d", i);
ceecf1d1 5898 virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
2796dae0
AL		 5899 if (!virtcon_hds[i]) {
5900 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5901 devname);
5902 exit(1);
5903 }
5904 }
5905 }
5906
aae9460e
PB		 5907 module_call_init(MODULE_INIT_DEVICE);
5908
fbe1b595 5909 machine->init(ram_size, boot_devices,
3023f332
AL		 5910 kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5911
268a362c
AL		 5912
5913 for (env = first_cpu; env != NULL; env = env->next_cpu) {
5914 for (i = 0; i < nb_numa_nodes; i++) {
5915 if (node_cpumask[i] & (1 << env->cpu_index)) {
5916 env->numa_node = i;
5917 }
5918 }
5919 }
5920
6f338c34
AL		 5921 current_machine = machine;
5922
3023f332
AL		 5923 /* Set KVM's vcpu state to qemu's initial CPUState. */
5924 if (kvm_enabled()) {
5925 int ret;
5926
5927 ret = kvm_sync_vcpus();
5928 if (ret < 0) {
5929 fprintf(stderr, "failed to initialize vcpus\n");
5930 exit(1);
5931 }
5932 }
5933
5934 /* init USB devices */
5935 if (usb_enabled) {
5936 for(i = 0; i < usb_devices_index; i++) {
c0f4ce77 5937 if (usb_device_add(usb_devices[i], 0) < 0) {
3023f332
AL		 5938 fprintf(stderr, "Warning: could not add USB device %s\n",
5939 usb_devices[i]);
5940 }
5941 }
5942 }
5943
8f391ab4
AL		 5944 if (!display_state)
5945 dumb_display_init();
3023f332
AL		 5946 /* just use the first displaystate for the moment */
5947 ds = display_state;
993fbfdb
AL		 5948
5949 if (display_type == DT_DEFAULT) {
5950#if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5951 display_type = DT_SDL;
5952#else
5953 display_type = DT_VNC;
5954 vnc_display = "localhost:0,to=99";
5955 show_vnc_port = 1;
5956#endif
5957 }
5958
5959
5960 switch (display_type) {
5961 case DT_NOGRAPHIC:
5962 break;
4d3b6f6e 5963#if defined(CONFIG_CURSES)
993fbfdb
AL		 5964 case DT_CURSES:
5965 curses_display_init(ds, full_screen);
5966 break;
4d3b6f6e 5967#endif
5b0753e0 5968#if defined(CONFIG_SDL)
993fbfdb
AL		 5969 case DT_SDL:
5970 sdl_display_init(ds, full_screen, no_frame);
5971 break;
5b0753e0 5972#elif defined(CONFIG_COCOA)
993fbfdb
AL		 5973 case DT_SDL:
5974 cocoa_display_init(ds, full_screen);
5975 break;
313aa567 5976#endif
993fbfdb
AL		 5977 case DT_VNC:
5978 vnc_display_init(ds);
5979 if (vnc_display_open(ds, vnc_display) < 0)
5980 exit(1);
f92f8afe 5981
993fbfdb
AL		 5982 if (show_vnc_port) {
5983 printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
f92f8afe 5984 }
993fbfdb
AL		 5985 break;
5986 default:
5987 break;
313aa567 5988 }
7d957bd8 5989 dpy_resize(ds);
5b08fc10 5990
3023f332
AL		 5991 dcl = ds->listeners;
5992 while (dcl != NULL) {
5993 if (dcl->dpy_refresh != NULL) {
5994 ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5995 qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
20d8a3ed 5996 }
3023f332 5997 dcl = dcl->next;
20d8a3ed 5998 }
3023f332 5999
993fbfdb 6000 if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
9043b62d
BS		 6001 nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6002 qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6003 }
6004
2796dae0 6005 text_consoles_set_display(display_state);
2970a6c9 6006 qemu_chr_initial_reset();
2796dae0 6007
4c621805 6008 if (monitor_device && monitor_hd)
cde76ee1 6009 monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
82c643ff 6010
8d11df9e 6011 for(i = 0; i < MAX_SERIAL_PORTS; i++) {
c03b0f0f 6012 const char *devname = serial_devices[i];
fd5f393a 6013 if (devname && strcmp(devname, "none")) {
5ccfae10
AL		 6014 char label[32];
6015 snprintf(label, sizeof(label), "serial%d", i);
af3a9031 6016 if (strstart(devname, "vc", 0))
7ba1260a 6017 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
8d11df9e 6018 }
82c643ff 6019 }
82c643ff 6020
6508fe59 6021 for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
c03b0f0f 6022 const char *devname = parallel_devices[i];
fd5f393a 6023 if (devname && strcmp(devname, "none")) {
5ccfae10
AL		 6024 char label[32];
6025 snprintf(label, sizeof(label), "parallel%d", i);
af3a9031 6026 if (strstart(devname, "vc", 0))
7ba1260a 6027 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6508fe59
FB		 6028 }
6029 }
6030
9ede2fde
AL		 6031 for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6032 const char *devname = virtio_consoles[i];
2796dae0 6033 if (virtcon_hds[i] && devname) {
9ede2fde
AL		 6034 char label[32];
6035 snprintf(label, sizeof(label), "virtcon%d", i);
9ede2fde
AL		 6036 if (strstart(devname, "vc", 0))
6037 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
6038 }
6039 }
6040
59030a8c
AL		 6041 if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6042 fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6043 gdbstub_dev);
6044 exit(1);
45669e00 6045 }
45669e00 6046
d63d307f 6047 if (loadvm)
376253ec 6048 do_loadvm(cur_mon, loadvm);
d63d307f 6049
5bb7910a
AL		 6050 if (incoming) {
6051 autostart = 0; /* fixme how to deal with -daemonize */
6052 qemu_start_incoming_migration(incoming);
6053 }
6054
c0f4ce77
AL		 6055 if (autostart)
6056 vm_start();
ffd843bc 6057
b9e82a59 6058#ifndef _WIN32
71e3ceb8
TS		 6059 if (daemonize) {
6060 uint8_t status = 0;
6061 ssize_t len;
71e3ceb8
TS		 6062
6063 again1:
6064 len = write(fds[1], &status, 1);
6065 if (len == -1 && (errno == EINTR))
6066 goto again1;
6067
6068 if (len != 1)
6069 exit(1);
6070
bd54b863 6071 chdir("/");
aeb30be6 6072 TFR(fd = open("/dev/null", O_RDWR));
71e3ceb8
TS		 6073 if (fd == -1)
6074 exit(1);
0858532e 6075 }
71e3ceb8 6076
0858532e
AL		 6077 if (run_as) {
6078 pwd = getpwnam(run_as);
6079 if (!pwd) {
6080 fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6081 exit(1);
6082 }
6083 }
6084
6085 if (chroot_dir) {
6086 if (chroot(chroot_dir) < 0) {
6087 fprintf(stderr, "chroot failed\n");
6088 exit(1);
6089 }
6090 chdir("/");
6091 }
6092
6093 if (run_as) {
6094 if (setgid(pwd->pw_gid) < 0) {
6095 fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6096 exit(1);
6097 }
6098 if (setuid(pwd->pw_uid) < 0) {
6099 fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6100 exit(1);
6101 }
6102 if (setuid(0) != -1) {
6103 fprintf(stderr, "Dropping privileges failed\n");
6104 exit(1);
6105 }
6106 }
0858532e
AL		 6107
6108 if (daemonize) {
6109 dup2(fd, 0);
6110 dup2(fd, 1);
6111 dup2(fd, 2);
71e3ceb8 6112
0858532e 6113 close(fd);
71e3ceb8 6114 }
b9e82a59 6115#endif
71e3ceb8 6116
8a7ddc38 6117 main_loop();
40c3bac3 6118 quit_timers();
63a01ef8 6119 net_cleanup();
b46a8906 6120
0824d6fc
FB		 6121 return 0;
6122}
QEMU mirror