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