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