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