git.maemo.org Git - qemu/blob - vl.c

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