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