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