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) != phys_ram_size)
3098         return -EINVAL;
3099     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3100         ret = ram_get_page(f, phys_ram_base + 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 < phys_ram_size) {
3186         if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3187             uint8_t ch;
3188
3189             cpu_physical_memory_reset_dirty(current_addr,
3190                                             current_addr + TARGET_PAGE_SIZE,
3191                                             MIGRATION_DIRTY_FLAG);
3192
3193             ch = *(phys_ram_base + current_addr);
3194
3195             if (is_dup_page(phys_ram_base + current_addr, ch)) {
3196                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3197                 qemu_put_byte(f, ch);
3198             } else {
3199                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3200                 qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
3201             }
3202
3203             found = 1;
3204             break;
3205         }
3206         addr += TARGET_PAGE_SIZE;
3207         current_addr = (saved_addr + addr) % phys_ram_size;
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 < phys_ram_size; 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 < phys_ram_size; 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, phys_ram_size | 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 < phys_ram_size; 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, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
3282                 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3283                 goto error;
3284             }
3285         } else {
3286         error:
3287             printf("Error block header\n");
3288             return -EINVAL;
3289         }
3290     }
3291     ram_decompress_close(s);
3292
3293     return 0;
3294 }
3295
3296 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3297 {
3298     ram_addr_t addr;
3299     int flags;
3300
3301     if (version_id == 1)
3302         return ram_load_v1(f, opaque);
3303
3304     if (version_id == 2) {
3305         if (qemu_get_be32(f) != phys_ram_size)
3306             return -EINVAL;
3307         return ram_load_dead(f, opaque);
3308     }
3309
3310     if (version_id != 3)
3311         return -EINVAL;
3312
3313     do {
3314         addr = qemu_get_be64(f);
3315
3316         flags = addr & ~TARGET_PAGE_MASK;
3317         addr &= TARGET_PAGE_MASK;
3318
3319         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3320             if (addr != phys_ram_size)
3321                 return -EINVAL;
3322         }
3323
3324         if (flags & RAM_SAVE_FLAG_FULL) {
3325             if (ram_load_dead(f, opaque) < 0)
3326                 return -EINVAL;
3327         }
3328
3329         if (flags & RAM_SAVE_FLAG_COMPRESS) {
3330             uint8_t ch = qemu_get_byte(f);
3331             memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3332         } else if (flags & RAM_SAVE_FLAG_PAGE)
3333             qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3334     } while (!(flags & RAM_SAVE_FLAG_EOS));
3335
3336     return 0;
3337 }
3338
3339 void qemu_service_io(void)
3340 {
3341     CPUState *env = cpu_single_env;
3342     if (env) {
3343         cpu_exit(env);
3344 #ifdef USE_KQEMU
3345         if (env->kqemu_enabled) {
3346             kqemu_cpu_interrupt(env);
3347         }
3348 #endif
3349     }
3350 }
3351
3352 /***********************************************************/
3353 /* bottom halves (can be seen as timers which expire ASAP) */
3354
3355 struct QEMUBH {
3356     QEMUBHFunc *cb;
3357     void *opaque;
3358     int scheduled;
3359     int idle;
3360     int deleted;
3361     QEMUBH *next;
3362 };
3363
3364 static QEMUBH *first_bh = NULL;
3365
3366 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3367 {
3368     QEMUBH *bh;
3369     bh = qemu_mallocz(sizeof(QEMUBH));
3370     bh->cb = cb;
3371     bh->opaque = opaque;
3372     bh->next = first_bh;
3373     first_bh = bh;
3374     return bh;
3375 }
3376
3377 int qemu_bh_poll(void)
3378 {
3379     QEMUBH *bh, **bhp;
3380     int ret;
3381
3382     ret = 0;
3383     for (bh = first_bh; bh; bh = bh->next) {
3384         if (!bh->deleted && bh->scheduled) {
3385             bh->scheduled = 0;
3386             if (!bh->idle)
3387                 ret = 1;
3388             bh->idle = 0;
3389             bh->cb(bh->opaque);
3390         }
3391     }
3392
3393     /* remove deleted bhs */
3394     bhp = &first_bh;
3395     while (*bhp) {
3396         bh = *bhp;
3397         if (bh->deleted) {
3398             *bhp = bh->next;
3399             qemu_free(bh);
3400         } else
3401             bhp = &bh->next;
3402     }
3403
3404     return ret;
3405 }
3406
3407 void qemu_bh_schedule_idle(QEMUBH *bh)
3408 {
3409     if (bh->scheduled)
3410         return;
3411     bh->scheduled = 1;
3412     bh->idle = 1;
3413 }
3414
3415 void qemu_bh_schedule(QEMUBH *bh)
3416 {
3417     CPUState *env = cpu_single_env;
3418     if (bh->scheduled)
3419         return;
3420     bh->scheduled = 1;
3421     bh->idle = 0;
3422     /* stop the currently executing CPU to execute the BH ASAP */
3423     if (env) {
3424         cpu_exit(env);
3425     }
3426 }
3427
3428 void qemu_bh_cancel(QEMUBH *bh)
3429 {
3430     bh->scheduled = 0;
3431 }
3432
3433 void qemu_bh_delete(QEMUBH *bh)
3434 {
3435     bh->scheduled = 0;
3436     bh->deleted = 1;
3437 }
3438
3439 static void qemu_bh_update_timeout(int *timeout)
3440 {
3441     QEMUBH *bh;
3442
3443     for (bh = first_bh; bh; bh = bh->next) {
3444         if (!bh->deleted && bh->scheduled) {
3445             if (bh->idle) {
3446                 /* idle bottom halves will be polled at least
3447                  * every 10ms */
3448                 *timeout = MIN(10, *timeout);
3449             } else {
3450                 /* non-idle bottom halves will be executed
3451                  * immediately */
3452                 *timeout = 0;
3453                 break;
3454             }
3455         }
3456     }
3457 }
3458
3459 /***********************************************************/
3460 /* machine registration */
3461
3462 static QEMUMachine *first_machine = NULL;
3463 QEMUMachine *current_machine = NULL;
3464
3465 int qemu_register_machine(QEMUMachine *m)
3466 {
3467     QEMUMachine **pm;
3468     pm = &first_machine;
3469     while (*pm != NULL)
3470         pm = &(*pm)->next;
3471     m->next = NULL;
3472     *pm = m;
3473     return 0;
3474 }
3475
3476 static QEMUMachine *find_machine(const char *name)
3477 {
3478     QEMUMachine *m;
3479
3480     for(m = first_machine; m != NULL; m = m->next) {
3481         if (!strcmp(m->name, name))
3482             return m;
3483     }
3484     return NULL;
3485 }
3486
3487 /***********************************************************/
3488 /* main execution loop */
3489
3490 static void gui_update(void *opaque)
3491 {
3492     uint64_t interval = GUI_REFRESH_INTERVAL;
3493     DisplayState *ds = opaque;
3494     DisplayChangeListener *dcl = ds->listeners;
3495
3496     dpy_refresh(ds);
3497
3498     while (dcl != NULL) {
3499         if (dcl->gui_timer_interval &&
3500             dcl->gui_timer_interval < interval)
3501             interval = dcl->gui_timer_interval;
3502         dcl = dcl->next;
3503     }
3504     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3505 }
3506
3507 static void nographic_update(void *opaque)
3508 {
3509     uint64_t interval = GUI_REFRESH_INTERVAL;
3510
3511     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3512 }
3513
3514 struct vm_change_state_entry {
3515     VMChangeStateHandler *cb;
3516     void *opaque;
3517     LIST_ENTRY (vm_change_state_entry) entries;
3518 };
3519
3520 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3521
3522 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3523                                                      void *opaque)
3524 {
3525     VMChangeStateEntry *e;
3526
3527     e = qemu_mallocz(sizeof (*e));
3528
3529     e->cb = cb;
3530     e->opaque = opaque;
3531     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3532     return e;
3533 }
3534
3535 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3536 {
3537     LIST_REMOVE (e, entries);
3538     qemu_free (e);
3539 }
3540
3541 static void vm_state_notify(int running, int reason)
3542 {
3543     VMChangeStateEntry *e;
3544
3545     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3546         e->cb(e->opaque, running, reason);
3547     }
3548 }
3549
3550 void vm_start(void)
3551 {
3552     if (!vm_running) {
3553         cpu_enable_ticks();
3554         vm_running = 1;
3555         vm_state_notify(1, 0);
3556         qemu_rearm_alarm_timer(alarm_timer);
3557     }
3558 }
3559
3560 void vm_stop(int reason)
3561 {
3562     if (vm_running) {
3563         cpu_disable_ticks();
3564         vm_running = 0;
3565         vm_state_notify(0, reason);
3566     }
3567 }
3568
3569 /* reset/shutdown handler */
3570
3571 typedef struct QEMUResetEntry {
3572     QEMUResetHandler *func;
3573     void *opaque;
3574     struct QEMUResetEntry *next;
3575 } QEMUResetEntry;
3576
3577 static QEMUResetEntry *first_reset_entry;
3578 static int reset_requested;
3579 static int shutdown_requested;
3580 static int powerdown_requested;
3581
3582 int qemu_shutdown_requested(void)
3583 {
3584     int r = shutdown_requested;
3585     shutdown_requested = 0;
3586     return r;
3587 }
3588
3589 int qemu_reset_requested(void)
3590 {
3591     int r = reset_requested;
3592     reset_requested = 0;
3593     return r;
3594 }
3595
3596 int qemu_powerdown_requested(void)
3597 {
3598     int r = powerdown_requested;
3599     powerdown_requested = 0;
3600     return r;
3601 }
3602
3603 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3604 {
3605     QEMUResetEntry **pre, *re;
3606
3607     pre = &first_reset_entry;
3608     while (*pre != NULL)
3609         pre = &(*pre)->next;
3610     re = qemu_mallocz(sizeof(QEMUResetEntry));
3611     re->func = func;
3612     re->opaque = opaque;
3613     re->next = NULL;
3614     *pre = re;
3615 }
3616
3617 void qemu_system_reset(void)
3618 {
3619     QEMUResetEntry *re;
3620
3621     /* reset all devices */
3622     for(re = first_reset_entry; re != NULL; re = re->next) {
3623         re->func(re->opaque);
3624     }
3625 }
3626
3627 void qemu_system_reset_request(void)
3628 {
3629     if (no_reboot) {
3630         shutdown_requested = 1;
3631     } else {
3632         reset_requested = 1;
3633     }
3634     if (cpu_single_env)
3635         cpu_exit(cpu_single_env);
3636 }
3637
3638 void qemu_system_shutdown_request(void)
3639 {
3640     shutdown_requested = 1;
3641     if (cpu_single_env)
3642         cpu_exit(cpu_single_env);
3643 }
3644
3645 void qemu_system_powerdown_request(void)
3646 {
3647     powerdown_requested = 1;
3648     if (cpu_single_env)
3649         cpu_exit(cpu_single_env);
3650 }
3651
3652 #ifdef _WIN32
3653 static void host_main_loop_wait(int *timeout)
3654 {
3655     int ret, ret2, i;
3656     PollingEntry *pe;
3657
3658
3659     /* XXX: need to suppress polling by better using win32 events */
3660     ret = 0;
3661     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3662         ret |= pe->func(pe->opaque);
3663     }
3664     if (ret == 0) {
3665         int err;
3666         WaitObjects *w = &wait_objects;
3667
3668         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3669         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3670             if (w->func[ret - WAIT_OBJECT_0])
3671                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3672
3673             /* Check for additional signaled events */
3674             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3675
3676                 /* Check if event is signaled */
3677                 ret2 = WaitForSingleObject(w->events[i], 0);
3678                 if(ret2 == WAIT_OBJECT_0) {
3679                     if (w->func[i])
3680                         w->func[i](w->opaque[i]);
3681                 } else if (ret2 == WAIT_TIMEOUT) {
3682                 } else {
3683                     err = GetLastError();
3684                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3685                 }
3686             }
3687         } else if (ret == WAIT_TIMEOUT) {
3688         } else {
3689             err = GetLastError();
3690             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3691         }
3692     }
3693
3694     *timeout = 0;
3695 }
3696 #else
3697 static void host_main_loop_wait(int *timeout)
3698 {
3699 }
3700 #endif
3701
3702 void main_loop_wait(int timeout)
3703 {
3704     IOHandlerRecord *ioh;
3705     fd_set rfds, wfds, xfds;
3706     int ret, nfds;
3707     struct timeval tv;
3708
3709     qemu_bh_update_timeout(&timeout);
3710
3711     host_main_loop_wait(&timeout);
3712
3713     /* poll any events */
3714     /* XXX: separate device handlers from system ones */
3715     nfds = -1;
3716     FD_ZERO(&rfds);
3717     FD_ZERO(&wfds);
3718     FD_ZERO(&xfds);
3719     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3720         if (ioh->deleted)
3721             continue;
3722         if (ioh->fd_read &&
3723             (!ioh->fd_read_poll ||
3724              ioh->fd_read_poll(ioh->opaque) != 0)) {
3725             FD_SET(ioh->fd, &rfds);
3726             if (ioh->fd > nfds)
3727                 nfds = ioh->fd;
3728         }
3729         if (ioh->fd_write) {
3730             FD_SET(ioh->fd, &wfds);
3731             if (ioh->fd > nfds)
3732                 nfds = ioh->fd;
3733         }
3734     }
3735
3736     tv.tv_sec = timeout / 1000;
3737     tv.tv_usec = (timeout % 1000) * 1000;
3738
3739 #if defined(CONFIG_SLIRP)
3740     if (slirp_is_inited()) {
3741         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3742     }
3743 #endif
3744     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3745     if (ret > 0) {
3746         IOHandlerRecord **pioh;
3747
3748         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3749             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3750                 ioh->fd_read(ioh->opaque);
3751             }
3752             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3753                 ioh->fd_write(ioh->opaque);
3754             }
3755         }
3756
3757         /* remove deleted IO handlers */
3758         pioh = &first_io_handler;
3759         while (*pioh) {
3760             ioh = *pioh;
3761             if (ioh->deleted) {
3762                 *pioh = ioh->next;
3763                 qemu_free(ioh);
3764             } else
3765                 pioh = &ioh->next;
3766         }
3767     }
3768 #if defined(CONFIG_SLIRP)
3769     if (slirp_is_inited()) {
3770         if (ret < 0) {
3771             FD_ZERO(&rfds);
3772             FD_ZERO(&wfds);
3773             FD_ZERO(&xfds);
3774         }
3775         slirp_select_poll(&rfds, &wfds, &xfds);
3776     }
3777 #endif
3778
3779     /* vm time timers */
3780     if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3781         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3782                         qemu_get_clock(vm_clock));
3783
3784     /* real time timers */
3785     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3786                     qemu_get_clock(rt_clock));
3787
3788     /* Check bottom-halves last in case any of the earlier events triggered
3789        them.  */
3790     qemu_bh_poll();
3791
3792 }
3793
3794 static int main_loop(void)
3795 {
3796     int ret, timeout;
3797 #ifdef CONFIG_PROFILER
3798     int64_t ti;
3799 #endif
3800     CPUState *env;
3801
3802     cur_cpu = first_cpu;
3803     next_cpu = cur_cpu->next_cpu ?: first_cpu;
3804     for(;;) {
3805         if (vm_running) {
3806
3807             for(;;) {
3808                 /* get next cpu */
3809                 env = next_cpu;
3810 #ifdef CONFIG_PROFILER
3811                 ti = profile_getclock();
3812 #endif
3813                 if (use_icount) {
3814                     int64_t count;
3815                     int decr;
3816                     qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3817                     env->icount_decr.u16.low = 0;
3818                     env->icount_extra = 0;
3819                     count = qemu_next_deadline();
3820                     count = (count + (1 << icount_time_shift) - 1)
3821                             >> icount_time_shift;
3822                     qemu_icount += count;
3823                     decr = (count > 0xffff) ? 0xffff : count;
3824                     count -= decr;
3825                     env->icount_decr.u16.low = decr;
3826                     env->icount_extra = count;
3827                 }
3828                 ret = cpu_exec(env);
3829 #ifdef CONFIG_PROFILER
3830                 qemu_time += profile_getclock() - ti;
3831 #endif
3832                 if (use_icount) {
3833                     /* Fold pending instructions back into the
3834                        instruction counter, and clear the interrupt flag.  */
3835                     qemu_icount -= (env->icount_decr.u16.low
3836                                     + env->icount_extra);
3837                     env->icount_decr.u32 = 0;
3838                     env->icount_extra = 0;
3839                 }
3840                 next_cpu = env->next_cpu ?: first_cpu;
3841                 if (event_pending && likely(ret != EXCP_DEBUG)) {
3842                     ret = EXCP_INTERRUPT;
3843                     event_pending = 0;
3844                     break;
3845                 }
3846                 if (ret == EXCP_HLT) {
3847                     /* Give the next CPU a chance to run.  */
3848                     cur_cpu = env;
3849                     continue;
3850                 }
3851                 if (ret != EXCP_HALTED)
3852                     break;
3853                 /* all CPUs are halted ? */
3854                 if (env == cur_cpu)
3855                     break;
3856             }
3857             cur_cpu = env;
3858
3859             if (shutdown_requested) {
3860                 ret = EXCP_INTERRUPT;
3861                 if (no_shutdown) {
3862                     vm_stop(0);
3863                     no_shutdown = 0;
3864                 }
3865                 else
3866                     break;
3867             }
3868             if (reset_requested) {
3869                 reset_requested = 0;
3870                 qemu_system_reset();
3871                 ret = EXCP_INTERRUPT;
3872             }
3873             if (powerdown_requested) {
3874                 powerdown_requested = 0;
3875                 qemu_system_powerdown();
3876                 ret = EXCP_INTERRUPT;
3877             }
3878             if (unlikely(ret == EXCP_DEBUG)) {
3879                 gdb_set_stop_cpu(cur_cpu);
3880                 vm_stop(EXCP_DEBUG);
3881             }
3882             /* If all cpus are halted then wait until the next IRQ */
3883             /* XXX: use timeout computed from timers */
3884             if (ret == EXCP_HALTED) {
3885                 if (use_icount) {
3886                     int64_t add;
3887                     int64_t delta;
3888                     /* Advance virtual time to the next event.  */
3889                     if (use_icount == 1) {
3890                         /* When not using an adaptive execution frequency
3891                            we tend to get badly out of sync with real time,
3892                            so just delay for a reasonable amount of time.  */
3893                         delta = 0;
3894                     } else {
3895                         delta = cpu_get_icount() - cpu_get_clock();
3896                     }
3897                     if (delta > 0) {
3898                         /* If virtual time is ahead of real time then just
3899                            wait for IO.  */
3900                         timeout = (delta / 1000000) + 1;
3901                     } else {
3902                         /* Wait for either IO to occur or the next
3903                            timer event.  */
3904                         add = qemu_next_deadline();
3905                         /* We advance the timer before checking for IO.
3906                            Limit the amount we advance so that early IO
3907                            activity won't get the guest too far ahead.  */
3908                         if (add > 10000000)
3909                             add = 10000000;
3910                         delta += add;
3911                         add = (add + (1 << icount_time_shift) - 1)
3912                               >> icount_time_shift;
3913                         qemu_icount += add;
3914                         timeout = delta / 1000000;
3915                         if (timeout < 0)
3916                             timeout = 0;
3917                     }
3918                 } else {
3919                     timeout = 5000;
3920                 }
3921             } else {
3922                 timeout = 0;
3923             }
3924         } else {
3925             if (shutdown_requested) {
3926                 ret = EXCP_INTERRUPT;
3927                 break;
3928             }
3929             timeout = 5000;
3930         }
3931 #ifdef CONFIG_PROFILER
3932         ti = profile_getclock();
3933 #endif
3934         main_loop_wait(timeout);
3935 #ifdef CONFIG_PROFILER
3936         dev_time += profile_getclock() - ti;
3937 #endif
3938     }
3939     cpu_disable_ticks();
3940     return ret;
3941 }
3942
3943 static void version(void)
3944 {
3945     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
3946 }
3947
3948 static void help(int exitcode)
3949 {
3950     version();
3951     printf("usage: %s [options] [disk_image]\n"
3952            "\n"
3953            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
3954            "\n"
3955 #define DEF(option, opt_arg, opt_enum, opt_help)        \
3956            opt_help
3957 #define DEFHEADING(text) stringify(text) "\n"
3958 #include "qemu-options.h"
3959 #undef DEF
3960 #undef DEFHEADING
3961 #undef GEN_DOCS
3962            "\n"
3963            "During emulation, the following keys are useful:\n"
3964            "ctrl-alt-f      toggle full screen\n"
3965            "ctrl-alt-n      switch to virtual console 'n'\n"
3966            "ctrl-alt        toggle mouse and keyboard grab\n"
3967            "\n"
3968            "When using -nographic, press 'ctrl-a h' to get some help.\n"
3969            ,
3970            "qemu",
3971            DEFAULT_RAM_SIZE,
3972 #ifndef _WIN32
3973            DEFAULT_NETWORK_SCRIPT,
3974            DEFAULT_NETWORK_DOWN_SCRIPT,
3975 #endif
3976            DEFAULT_GDBSTUB_PORT,
3977            "/tmp/qemu.log");
3978     exit(exitcode);
3979 }
3980
3981 #define HAS_ARG 0x0001
3982
3983 enum {
3984 #define DEF(option, opt_arg, opt_enum, opt_help)        \
3985     opt_enum,
3986 #define DEFHEADING(text)
3987 #include "qemu-options.h"
3988 #undef DEF
3989 #undef DEFHEADING
3990 #undef GEN_DOCS
3991 };
3992
3993 typedef struct QEMUOption {
3994     const char *name;
3995     int flags;
3996     int index;
3997 } QEMUOption;
3998
3999 static const QEMUOption qemu_options[] = {
4000     { "h", 0, QEMU_OPTION_h },
4001 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4002     { option, opt_arg, opt_enum },
4003 #define DEFHEADING(text)
4004 #include "qemu-options.h"
4005 #undef DEF
4006 #undef DEFHEADING
4007 #undef GEN_DOCS
4008     { NULL },
4009 };
4010
4011 #ifdef HAS_AUDIO
4012 struct soundhw soundhw[] = {
4013 #ifdef HAS_AUDIO_CHOICE
4014 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4015     {
4016         "pcspk",
4017         "PC speaker",
4018         0,
4019         1,
4020         { .init_isa = pcspk_audio_init }
4021     },
4022 #endif
4023
4024 #ifdef CONFIG_SB16
4025     {
4026         "sb16",
4027         "Creative Sound Blaster 16",
4028         0,
4029         1,
4030         { .init_isa = SB16_init }
4031     },
4032 #endif
4033
4034 #ifdef CONFIG_CS4231A
4035     {
4036         "cs4231a",
4037         "CS4231A",
4038         0,
4039         1,
4040         { .init_isa = cs4231a_init }
4041     },
4042 #endif
4043
4044 #ifdef CONFIG_ADLIB
4045     {
4046         "adlib",
4047 #ifdef HAS_YMF262
4048         "Yamaha YMF262 (OPL3)",
4049 #else
4050         "Yamaha YM3812 (OPL2)",
4051 #endif
4052         0,
4053         1,
4054         { .init_isa = Adlib_init }
4055     },
4056 #endif
4057
4058 #ifdef CONFIG_GUS
4059     {
4060         "gus",
4061         "Gravis Ultrasound GF1",
4062         0,
4063         1,
4064         { .init_isa = GUS_init }
4065     },
4066 #endif
4067
4068 #ifdef CONFIG_AC97
4069     {
4070         "ac97",
4071         "Intel 82801AA AC97 Audio",
4072         0,
4073         0,
4074         { .init_pci = ac97_init }
4075     },
4076 #endif
4077
4078 #ifdef CONFIG_ES1370
4079     {
4080         "es1370",
4081         "ENSONIQ AudioPCI ES1370",
4082         0,
4083         0,
4084         { .init_pci = es1370_init }
4085     },
4086 #endif
4087
4088 #endif /* HAS_AUDIO_CHOICE */
4089
4090     { NULL, NULL, 0, 0, { NULL } }
4091 };
4092
4093 static void select_soundhw (const char *optarg)
4094 {
4095     struct soundhw *c;
4096
4097     if (*optarg == '?') {
4098     show_valid_cards:
4099
4100         printf ("Valid sound card names (comma separated):\n");
4101         for (c = soundhw; c->name; ++c) {
4102             printf ("%-11s %s\n", c->name, c->descr);
4103         }
4104         printf ("\n-soundhw all will enable all of the above\n");
4105         exit (*optarg != '?');
4106     }
4107     else {
4108         size_t l;
4109         const char *p;
4110         char *e;
4111         int bad_card = 0;
4112
4113         if (!strcmp (optarg, "all")) {
4114             for (c = soundhw; c->name; ++c) {
4115                 c->enabled = 1;
4116             }
4117             return;
4118         }
4119
4120         p = optarg;
4121         while (*p) {
4122             e = strchr (p, ',');
4123             l = !e ? strlen (p) : (size_t) (e - p);
4124
4125             for (c = soundhw; c->name; ++c) {
4126                 if (!strncmp (c->name, p, l)) {
4127                     c->enabled = 1;
4128                     break;
4129                 }
4130             }
4131
4132             if (!c->name) {
4133                 if (l > 80) {
4134                     fprintf (stderr,
4135                              "Unknown sound card name (too big to show)\n");
4136                 }
4137                 else {
4138                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4139                              (int) l, p);
4140                 }
4141                 bad_card = 1;
4142             }
4143             p += l + (e != NULL);
4144         }
4145
4146         if (bad_card)
4147             goto show_valid_cards;
4148     }
4149 }
4150 #endif
4151
4152 static void select_vgahw (const char *p)
4153 {
4154     const char *opts;
4155
4156     if (strstart(p, "std", &opts)) {
4157         std_vga_enabled = 1;
4158         cirrus_vga_enabled = 0;
4159         vmsvga_enabled = 0;
4160     } else if (strstart(p, "cirrus", &opts)) {
4161         cirrus_vga_enabled = 1;
4162         std_vga_enabled = 0;
4163         vmsvga_enabled = 0;
4164     } else if (strstart(p, "vmware", &opts)) {
4165         cirrus_vga_enabled = 0;
4166         std_vga_enabled = 0;
4167         vmsvga_enabled = 1;
4168     } else if (strstart(p, "none", &opts)) {
4169         cirrus_vga_enabled = 0;
4170         std_vga_enabled = 0;
4171         vmsvga_enabled = 0;
4172     } else {
4173     invalid_vga:
4174         fprintf(stderr, "Unknown vga type: %s\n", p);
4175         exit(1);
4176     }
4177     while (*opts) {
4178         const char *nextopt;
4179
4180         if (strstart(opts, ",retrace=", &nextopt)) {
4181             opts = nextopt;
4182             if (strstart(opts, "dumb", &nextopt))
4183                 vga_retrace_method = VGA_RETRACE_DUMB;
4184             else if (strstart(opts, "precise", &nextopt))
4185                 vga_retrace_method = VGA_RETRACE_PRECISE;
4186             else goto invalid_vga;
4187         } else goto invalid_vga;
4188         opts = nextopt;
4189     }
4190 }
4191
4192 #ifdef _WIN32
4193 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4194 {
4195     exit(STATUS_CONTROL_C_EXIT);
4196     return TRUE;
4197 }
4198 #endif
4199
4200 static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4201 {
4202     int ret;
4203
4204     if(strlen(str) != 36)
4205         return -1;
4206
4207     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4208             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4209             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4210
4211     if(ret != 16)
4212         return -1;
4213
4214     return 0;
4215 }
4216
4217 #define MAX_NET_CLIENTS 32
4218
4219 #ifndef _WIN32
4220
4221 static void termsig_handler(int signal)
4222 {
4223     qemu_system_shutdown_request();
4224 }
4225
4226 static void termsig_setup(void)
4227 {
4228     struct sigaction act;
4229
4230     memset(&act, 0, sizeof(act));
4231     act.sa_handler = termsig_handler;
4232     sigaction(SIGINT,  &act, NULL);
4233     sigaction(SIGHUP,  &act, NULL);
4234     sigaction(SIGTERM, &act, NULL);
4235 }
4236
4237 #endif
4238
4239 int main(int argc, char **argv, char **envp)
4240 {
4241 #ifdef CONFIG_GDBSTUB
4242     const char *gdbstub_dev = NULL;
4243 #endif
4244     uint32_t boot_devices_bitmap = 0;
4245     int i;
4246     int snapshot, linux_boot, net_boot;
4247     const char *initrd_filename;
4248     const char *kernel_filename, *kernel_cmdline;
4249     const char *boot_devices = "";
4250     DisplayState *ds;
4251     DisplayChangeListener *dcl;
4252     int cyls, heads, secs, translation;
4253     const char *net_clients[MAX_NET_CLIENTS];
4254     int nb_net_clients;
4255     const char *bt_opts[MAX_BT_CMDLINE];
4256     int nb_bt_opts;
4257     int hda_index;
4258     int optind;
4259     const char *r, *optarg;
4260     CharDriverState *monitor_hd = NULL;
4261     const char *monitor_device;
4262     const char *serial_devices[MAX_SERIAL_PORTS];
4263     int serial_device_index;
4264     const char *parallel_devices[MAX_PARALLEL_PORTS];
4265     int parallel_device_index;
4266     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4267     int virtio_console_index;
4268     const char *loadvm = NULL;
4269     QEMUMachine *machine;
4270     const char *cpu_model;
4271     const char *usb_devices[MAX_USB_CMDLINE];
4272     int usb_devices_index;
4273 #ifndef _WIN32
4274     int fds[2];
4275 #endif
4276     int tb_size;
4277     const char *pid_file = NULL;
4278     const char *incoming = NULL;
4279 #ifndef _WIN32
4280     int fd = 0;
4281     struct passwd *pwd = NULL;
4282     const char *chroot_dir = NULL;
4283     const char *run_as = NULL;
4284 #endif
4285
4286     qemu_cache_utils_init(envp);
4287
4288     LIST_INIT (&vm_change_state_head);
4289 #ifndef _WIN32
4290     {
4291         struct sigaction act;
4292         sigfillset(&act.sa_mask);
4293         act.sa_flags = 0;
4294         act.sa_handler = SIG_IGN;
4295         sigaction(SIGPIPE, &act, NULL);
4296     }
4297 #else
4298     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4299     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4300        QEMU to run on a single CPU */
4301     {
4302         HANDLE h;
4303         DWORD mask, smask;
4304         int i;
4305         h = GetCurrentProcess();
4306         if (GetProcessAffinityMask(h, &mask, &smask)) {
4307             for(i = 0; i < 32; i++) {
4308                 if (mask & (1 << i))
4309                     break;
4310             }
4311             if (i != 32) {
4312                 mask = 1 << i;
4313                 SetProcessAffinityMask(h, mask);
4314             }
4315         }
4316     }
4317 #endif
4318
4319     register_machines();
4320     machine = first_machine;
4321     cpu_model = NULL;
4322     initrd_filename = NULL;
4323     ram_size = 0;
4324     vga_ram_size = VGA_RAM_SIZE;
4325     snapshot = 0;
4326     nographic = 0;
4327     curses = 0;
4328     kernel_filename = NULL;
4329     kernel_cmdline = "";
4330     cyls = heads = secs = 0;
4331     translation = BIOS_ATA_TRANSLATION_AUTO;
4332     monitor_device = "vc:80Cx24C";
4333
4334     serial_devices[0] = "vc:80Cx24C";
4335     for(i = 1; i < MAX_SERIAL_PORTS; i++)
4336         serial_devices[i] = NULL;
4337     serial_device_index = 0;
4338
4339     parallel_devices[0] = "vc:80Cx24C";
4340     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4341         parallel_devices[i] = NULL;
4342     parallel_device_index = 0;
4343
4344     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4345         virtio_consoles[i] = NULL;
4346     virtio_console_index = 0;
4347
4348     usb_devices_index = 0;
4349
4350     nb_net_clients = 0;
4351     nb_bt_opts = 0;
4352     nb_drives = 0;
4353     nb_drives_opt = 0;
4354     hda_index = -1;
4355
4356     nb_nics = 0;
4357
4358     tb_size = 0;
4359     autostart= 1;
4360
4361     optind = 1;
4362     for(;;) {
4363         if (optind >= argc)
4364             break;
4365         r = argv[optind];
4366         if (r[0] != '-') {
4367             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4368         } else {
4369             const QEMUOption *popt;
4370
4371             optind++;
4372             /* Treat --foo the same as -foo.  */
4373             if (r[1] == '-')
4374                 r++;
4375             popt = qemu_options;
4376             for(;;) {
4377                 if (!popt->name) {
4378                     fprintf(stderr, "%s: invalid option -- '%s'\n",
4379                             argv[0], r);
4380                     exit(1);
4381                 }
4382                 if (!strcmp(popt->name, r + 1))
4383                     break;
4384                 popt++;
4385             }
4386             if (popt->flags & HAS_ARG) {
4387                 if (optind >= argc) {
4388                     fprintf(stderr, "%s: option '%s' requires an argument\n",
4389                             argv[0], r);
4390                     exit(1);
4391                 }
4392                 optarg = argv[optind++];
4393             } else {
4394                 optarg = NULL;
4395             }
4396
4397             switch(popt->index) {
4398             case QEMU_OPTION_M:
4399                 machine = find_machine(optarg);
4400                 if (!machine) {
4401                     QEMUMachine *m;
4402                     printf("Supported machines are:\n");
4403                     for(m = first_machine; m != NULL; m = m->next) {
4404                         printf("%-10s %s%s\n",
4405                                m->name, m->desc,
4406                                m == first_machine ? " (default)" : "");
4407                     }
4408                     exit(*optarg != '?');
4409                 }
4410                 break;
4411             case QEMU_OPTION_cpu:
4412                 /* hw initialization will check this */
4413                 if (*optarg == '?') {
4414 /* XXX: implement xxx_cpu_list for targets that still miss it */
4415 #if defined(cpu_list)
4416                     cpu_list(stdout, &fprintf);
4417 #endif
4418                     exit(0);
4419                 } else {
4420                     cpu_model = optarg;
4421                 }
4422                 break;
4423             case QEMU_OPTION_initrd:
4424                 initrd_filename = optarg;
4425                 break;
4426             case QEMU_OPTION_hda:
4427                 if (cyls == 0)
4428                     hda_index = drive_add(optarg, HD_ALIAS, 0);
4429                 else
4430                     hda_index = drive_add(optarg, HD_ALIAS
4431                              ",cyls=%d,heads=%d,secs=%d%s",
4432                              0, cyls, heads, secs,
4433                              translation == BIOS_ATA_TRANSLATION_LBA ?
4434                                  ",trans=lba" :
4435                              translation == BIOS_ATA_TRANSLATION_NONE ?
4436                                  ",trans=none" : "");
4437                  break;
4438             case QEMU_OPTION_hdb:
4439             case QEMU_OPTION_hdc:
4440             case QEMU_OPTION_hdd:
4441                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4442                 break;
4443             case QEMU_OPTION_drive:
4444                 drive_add(NULL, "%s", optarg);
4445                 break;
4446             case QEMU_OPTION_mtdblock:
4447                 drive_add(optarg, MTD_ALIAS);
4448                 break;
4449             case QEMU_OPTION_sd:
4450                 drive_add(optarg, SD_ALIAS);
4451                 break;
4452             case QEMU_OPTION_pflash:
4453                 drive_add(optarg, PFLASH_ALIAS);
4454                 break;
4455             case QEMU_OPTION_snapshot:
4456                 snapshot = 1;
4457                 break;
4458             case QEMU_OPTION_hdachs:
4459                 {
4460                     const char *p;
4461                     p = optarg;
4462                     cyls = strtol(p, (char **)&p, 0);
4463                     if (cyls < 1 || cyls > 16383)
4464                         goto chs_fail;
4465                     if (*p != ',')
4466                         goto chs_fail;
4467                     p++;
4468                     heads = strtol(p, (char **)&p, 0);
4469                     if (heads < 1 || heads > 16)
4470                         goto chs_fail;
4471                     if (*p != ',')
4472                         goto chs_fail;
4473                     p++;
4474                     secs = strtol(p, (char **)&p, 0);
4475                     if (secs < 1 || secs > 63)
4476                         goto chs_fail;
4477                     if (*p == ',') {
4478                         p++;
4479                         if (!strcmp(p, "none"))
4480                             translation = BIOS_ATA_TRANSLATION_NONE;
4481                         else if (!strcmp(p, "lba"))
4482                             translation = BIOS_ATA_TRANSLATION_LBA;
4483                         else if (!strcmp(p, "auto"))
4484                             translation = BIOS_ATA_TRANSLATION_AUTO;
4485                         else
4486                             goto chs_fail;
4487                     } else if (*p != '\0') {
4488                     chs_fail:
4489                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4490                         exit(1);
4491                     }
4492                     if (hda_index != -1)
4493                         snprintf(drives_opt[hda_index].opt,
4494                                  sizeof(drives_opt[hda_index].opt),
4495                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4496                                  0, cyls, heads, secs,
4497                                  translation == BIOS_ATA_TRANSLATION_LBA ?
4498                                     ",trans=lba" :
4499                                  translation == BIOS_ATA_TRANSLATION_NONE ?
4500                                      ",trans=none" : "");
4501                 }
4502                 break;
4503             case QEMU_OPTION_nographic:
4504                 nographic = 1;
4505                 break;
4506 #ifdef CONFIG_CURSES
4507             case QEMU_OPTION_curses:
4508                 curses = 1;
4509                 break;
4510 #endif
4511             case QEMU_OPTION_portrait:
4512                 graphic_rotate = 1;
4513                 break;
4514             case QEMU_OPTION_kernel:
4515                 kernel_filename = optarg;
4516                 break;
4517             case QEMU_OPTION_append:
4518                 kernel_cmdline = optarg;
4519                 break;
4520             case QEMU_OPTION_cdrom:
4521                 drive_add(optarg, CDROM_ALIAS);
4522                 break;
4523             case QEMU_OPTION_boot:
4524                 boot_devices = optarg;
4525                 /* We just do some generic consistency checks */
4526                 {
4527                     /* Could easily be extended to 64 devices if needed */
4528                     const char *p;
4529
4530                     boot_devices_bitmap = 0;
4531                     for (p = boot_devices; *p != '\0'; p++) {
4532                         /* Allowed boot devices are:
4533                          * a b     : floppy disk drives
4534                          * c ... f : IDE disk drives
4535                          * g ... m : machine implementation dependant drives
4536                          * n ... p : network devices
4537                          * It's up to each machine implementation to check
4538                          * if the given boot devices match the actual hardware
4539                          * implementation and firmware features.
4540                          */
4541                         if (*p < 'a' || *p > 'q') {
4542                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
4543                             exit(1);
4544                         }
4545                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4546                             fprintf(stderr,
4547                                     "Boot device '%c' was given twice\n",*p);
4548                             exit(1);
4549                         }
4550                         boot_devices_bitmap |= 1 << (*p - 'a');
4551                     }
4552                 }
4553                 break;
4554             case QEMU_OPTION_fda:
4555             case QEMU_OPTION_fdb:
4556                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4557                 break;
4558 #ifdef TARGET_I386
4559             case QEMU_OPTION_no_fd_bootchk:
4560                 fd_bootchk = 0;
4561                 break;
4562 #endif
4563             case QEMU_OPTION_net:
4564                 if (nb_net_clients >= MAX_NET_CLIENTS) {
4565                     fprintf(stderr, "qemu: too many network clients\n");
4566                     exit(1);
4567                 }
4568                 net_clients[nb_net_clients] = optarg;
4569                 nb_net_clients++;
4570                 break;
4571 #ifdef CONFIG_SLIRP
4572             case QEMU_OPTION_tftp:
4573                 tftp_prefix = optarg;
4574                 break;
4575             case QEMU_OPTION_bootp:
4576                 bootp_filename = optarg;
4577                 break;
4578 #ifndef _WIN32
4579             case QEMU_OPTION_smb:
4580                 net_slirp_smb(optarg);
4581                 break;
4582 #endif
4583             case QEMU_OPTION_redir:
4584                 net_slirp_redir(optarg);
4585                 break;
4586 #endif
4587             case QEMU_OPTION_bt:
4588                 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4589                     fprintf(stderr, "qemu: too many bluetooth options\n");
4590                     exit(1);
4591                 }
4592                 bt_opts[nb_bt_opts++] = optarg;
4593                 break;
4594 #ifdef HAS_AUDIO
4595             case QEMU_OPTION_audio_help:
4596                 AUD_help ();
4597                 exit (0);
4598                 break;
4599             case QEMU_OPTION_soundhw:
4600                 select_soundhw (optarg);
4601                 break;
4602 #endif
4603             case QEMU_OPTION_h:
4604                 help(0);
4605                 break;
4606             case QEMU_OPTION_version:
4607                 version();
4608                 exit(0);
4609                 break;
4610             case QEMU_OPTION_m: {
4611                 uint64_t value;
4612                 char *ptr;
4613
4614                 value = strtoul(optarg, &ptr, 10);
4615                 switch (*ptr) {
4616                 case 0: case 'M': case 'm':
4617                     value <<= 20;
4618                     break;
4619                 case 'G': case 'g':
4620                     value <<= 30;
4621                     break;
4622                 default:
4623                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4624                     exit(1);
4625                 }
4626
4627                 /* On 32-bit hosts, QEMU is limited by virtual address space */
4628                 if (value > (2047 << 20)
4629 #ifndef USE_KQEMU
4630                     && HOST_LONG_BITS == 32
4631 #endif
4632                     ) {
4633                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4634                     exit(1);
4635                 }
4636                 if (value != (uint64_t)(ram_addr_t)value) {
4637                     fprintf(stderr, "qemu: ram size too large\n");
4638                     exit(1);
4639                 }
4640                 ram_size = value;
4641                 break;
4642             }
4643             case QEMU_OPTION_d:
4644                 {
4645                     int mask;
4646                     const CPULogItem *item;
4647
4648                     mask = cpu_str_to_log_mask(optarg);
4649                     if (!mask) {
4650                         printf("Log items (comma separated):\n");
4651                     for(item = cpu_log_items; item->mask != 0; item++) {
4652                         printf("%-10s %s\n", item->name, item->help);
4653                     }
4654                     exit(1);
4655                     }
4656                     cpu_set_log(mask);
4657                 }
4658                 break;
4659 #ifdef CONFIG_GDBSTUB
4660             case QEMU_OPTION_s:
4661                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
4662                 break;
4663             case QEMU_OPTION_gdb:
4664                 gdbstub_dev = optarg;
4665                 break;
4666 #endif
4667             case QEMU_OPTION_L:
4668                 bios_dir = optarg;
4669                 break;
4670             case QEMU_OPTION_bios:
4671                 bios_name = optarg;
4672                 break;
4673             case QEMU_OPTION_singlestep:
4674                 singlestep = 1;
4675                 break;
4676             case QEMU_OPTION_S:
4677                 autostart = 0;
4678                 break;
4679 #ifndef _WIN32
4680             case QEMU_OPTION_k:
4681                 keyboard_layout = optarg;
4682                 break;
4683 #endif
4684             case QEMU_OPTION_localtime:
4685                 rtc_utc = 0;
4686                 break;
4687             case QEMU_OPTION_vga:
4688                 select_vgahw (optarg);
4689                 break;
4690 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4691             case QEMU_OPTION_g:
4692                 {
4693                     const char *p;
4694                     int w, h, depth;
4695                     p = optarg;
4696                     w = strtol(p, (char **)&p, 10);
4697                     if (w <= 0) {
4698                     graphic_error:
4699                         fprintf(stderr, "qemu: invalid resolution or depth\n");
4700                         exit(1);
4701                     }
4702                     if (*p != 'x')
4703                         goto graphic_error;
4704                     p++;
4705                     h = strtol(p, (char **)&p, 10);
4706                     if (h <= 0)
4707                         goto graphic_error;
4708                     if (*p == 'x') {
4709                         p++;
4710                         depth = strtol(p, (char **)&p, 10);
4711                         if (depth != 8 && depth != 15 && depth != 16 &&
4712                             depth != 24 && depth != 32)
4713                             goto graphic_error;
4714                     } else if (*p == '\0') {
4715                         depth = graphic_depth;
4716                     } else {
4717                         goto graphic_error;
4718                     }
4719
4720                     graphic_width = w;
4721                     graphic_height = h;
4722                     graphic_depth = depth;
4723                 }
4724                 break;
4725 #endif
4726             case QEMU_OPTION_echr:
4727                 {
4728                     char *r;
4729                     term_escape_char = strtol(optarg, &r, 0);
4730                     if (r == optarg)
4731                         printf("Bad argument to echr\n");
4732                     break;
4733                 }
4734             case QEMU_OPTION_monitor:
4735                 monitor_device = optarg;
4736                 break;
4737             case QEMU_OPTION_serial:
4738                 if (serial_device_index >= MAX_SERIAL_PORTS) {
4739                     fprintf(stderr, "qemu: too many serial ports\n");
4740                     exit(1);
4741                 }
4742                 serial_devices[serial_device_index] = optarg;
4743                 serial_device_index++;
4744                 break;
4745             case QEMU_OPTION_virtiocon:
4746                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
4747                     fprintf(stderr, "qemu: too many virtio consoles\n");
4748                     exit(1);
4749                 }
4750                 virtio_consoles[virtio_console_index] = optarg;
4751                 virtio_console_index++;
4752                 break;
4753             case QEMU_OPTION_parallel:
4754                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4755                     fprintf(stderr, "qemu: too many parallel ports\n");
4756                     exit(1);
4757                 }
4758                 parallel_devices[parallel_device_index] = optarg;
4759                 parallel_device_index++;
4760                 break;
4761             case QEMU_OPTION_loadvm:
4762                 loadvm = optarg;
4763                 break;
4764             case QEMU_OPTION_full_screen:
4765                 full_screen = 1;
4766                 break;
4767 #ifdef CONFIG_SDL
4768             case QEMU_OPTION_no_frame:
4769                 no_frame = 1;
4770                 break;
4771             case QEMU_OPTION_alt_grab:
4772                 alt_grab = 1;
4773                 break;
4774             case QEMU_OPTION_no_quit:
4775                 no_quit = 1;
4776                 break;
4777             case QEMU_OPTION_sdl:
4778                 sdl = 1;
4779                 break;
4780 #endif
4781             case QEMU_OPTION_pidfile:
4782                 pid_file = optarg;
4783                 break;
4784 #ifdef TARGET_I386
4785             case QEMU_OPTION_win2k_hack:
4786                 win2k_install_hack = 1;
4787                 break;
4788             case QEMU_OPTION_rtc_td_hack:
4789                 rtc_td_hack = 1;
4790                 break;
4791             case QEMU_OPTION_acpitable:
4792                 if(acpi_table_add(optarg) < 0) {
4793                     fprintf(stderr, "Wrong acpi table provided\n");
4794                     exit(1);
4795                 }
4796                 break;
4797 #endif
4798 #ifdef USE_KQEMU
4799             case QEMU_OPTION_no_kqemu:
4800                 kqemu_allowed = 0;
4801                 break;
4802             case QEMU_OPTION_kernel_kqemu:
4803                 kqemu_allowed = 2;
4804                 break;
4805 #endif
4806 #ifdef CONFIG_KVM
4807             case QEMU_OPTION_enable_kvm:
4808                 kvm_allowed = 1;
4809 #ifdef USE_KQEMU
4810                 kqemu_allowed = 0;
4811 #endif
4812                 break;
4813 #endif
4814             case QEMU_OPTION_usb:
4815                 usb_enabled = 1;
4816                 break;
4817             case QEMU_OPTION_usbdevice:
4818                 usb_enabled = 1;
4819                 if (usb_devices_index >= MAX_USB_CMDLINE) {
4820                     fprintf(stderr, "Too many USB devices\n");
4821                     exit(1);
4822                 }
4823                 usb_devices[usb_devices_index] = optarg;
4824                 usb_devices_index++;
4825                 break;
4826             case QEMU_OPTION_smp:
4827                 smp_cpus = atoi(optarg);
4828                 if (smp_cpus < 1) {
4829                     fprintf(stderr, "Invalid number of CPUs\n");
4830                     exit(1);
4831                 }
4832                 break;
4833             case QEMU_OPTION_vnc:
4834                 vnc_display = optarg;
4835                 break;
4836 #ifdef TARGET_I386
4837             case QEMU_OPTION_no_acpi:
4838                 acpi_enabled = 0;
4839                 break;
4840             case QEMU_OPTION_no_hpet:
4841                 no_hpet = 1;
4842                 break;
4843 #endif
4844             case QEMU_OPTION_no_reboot:
4845                 no_reboot = 1;
4846                 break;
4847             case QEMU_OPTION_no_shutdown:
4848                 no_shutdown = 1;
4849                 break;
4850             case QEMU_OPTION_show_cursor:
4851                 cursor_hide = 0;
4852                 break;
4853             case QEMU_OPTION_uuid:
4854                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
4855                     fprintf(stderr, "Fail to parse UUID string."
4856                             " Wrong format.\n");
4857                     exit(1);
4858                 }
4859                 break;
4860 #ifndef _WIN32
4861             case QEMU_OPTION_daemonize:
4862                 daemonize = 1;
4863                 break;
4864 #endif
4865             case QEMU_OPTION_option_rom:
4866                 if (nb_option_roms >= MAX_OPTION_ROMS) {
4867                     fprintf(stderr, "Too many option ROMs\n");
4868                     exit(1);
4869                 }
4870                 option_rom[nb_option_roms] = optarg;
4871                 nb_option_roms++;
4872                 break;
4873 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4874             case QEMU_OPTION_semihosting:
4875                 semihosting_enabled = 1;
4876                 break;
4877 #endif
4878             case QEMU_OPTION_name:
4879                 qemu_name = optarg;
4880                 break;
4881 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4882             case QEMU_OPTION_prom_env:
4883                 if (nb_prom_envs >= MAX_PROM_ENVS) {
4884                     fprintf(stderr, "Too many prom variables\n");
4885                     exit(1);
4886                 }
4887                 prom_envs[nb_prom_envs] = optarg;
4888                 nb_prom_envs++;
4889                 break;
4890 #endif
4891 #ifdef TARGET_ARM
4892             case QEMU_OPTION_old_param:
4893                 old_param = 1;
4894                 break;
4895 #endif
4896             case QEMU_OPTION_clock:
4897                 configure_alarms(optarg);
4898                 break;
4899             case QEMU_OPTION_startdate:
4900                 {
4901                     struct tm tm;
4902                     time_t rtc_start_date;
4903                     if (!strcmp(optarg, "now")) {
4904                         rtc_date_offset = -1;
4905                     } else {
4906                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
4907                                &tm.tm_year,
4908                                &tm.tm_mon,
4909                                &tm.tm_mday,
4910                                &tm.tm_hour,
4911                                &tm.tm_min,
4912                                &tm.tm_sec) == 6) {
4913                             /* OK */
4914                         } else if (sscanf(optarg, "%d-%d-%d",
4915                                           &tm.tm_year,
4916                                           &tm.tm_mon,
4917                                           &tm.tm_mday) == 3) {
4918                             tm.tm_hour = 0;
4919                             tm.tm_min = 0;
4920                             tm.tm_sec = 0;
4921                         } else {
4922                             goto date_fail;
4923                         }
4924                         tm.tm_year -= 1900;
4925                         tm.tm_mon--;
4926                         rtc_start_date = mktimegm(&tm);
4927                         if (rtc_start_date == -1) {
4928                         date_fail:
4929                             fprintf(stderr, "Invalid date format. Valid format are:\n"
4930                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
4931                             exit(1);
4932                         }
4933                         rtc_date_offset = time(NULL) - rtc_start_date;
4934                     }
4935                 }
4936                 break;
4937             case QEMU_OPTION_tb_size:
4938                 tb_size = strtol(optarg, NULL, 0);
4939                 if (tb_size < 0)
4940                     tb_size = 0;
4941                 break;
4942             case QEMU_OPTION_icount:
4943                 use_icount = 1;
4944                 if (strcmp(optarg, "auto") == 0) {
4945                     icount_time_shift = -1;
4946                 } else {
4947                     icount_time_shift = strtol(optarg, NULL, 0);
4948                 }
4949                 break;
4950             case QEMU_OPTION_incoming:
4951                 incoming = optarg;
4952                 break;
4953 #ifndef _WIN32
4954             case QEMU_OPTION_chroot:
4955                 chroot_dir = optarg;
4956                 break;
4957             case QEMU_OPTION_runas:
4958                 run_as = optarg;
4959                 break;
4960 #endif
4961             }
4962         }
4963     }
4964
4965 #if defined(CONFIG_KVM) && defined(USE_KQEMU)
4966     if (kvm_allowed && kqemu_allowed) {
4967         fprintf(stderr,
4968                 "You can not enable both KVM and kqemu at the same time\n");
4969         exit(1);
4970     }
4971 #endif
4972
4973     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
4974     if (smp_cpus > machine->max_cpus) {
4975         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
4976                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
4977                 machine->max_cpus);
4978         exit(1);
4979     }
4980
4981     if (nographic) {
4982        if (serial_device_index == 0)
4983            serial_devices[0] = "stdio";
4984        if (parallel_device_index == 0)
4985            parallel_devices[0] = "null";
4986        if (strncmp(monitor_device, "vc", 2) == 0)
4987            monitor_device = "stdio";
4988     }
4989
4990 #ifndef _WIN32
4991     if (daemonize) {
4992         pid_t pid;
4993
4994         if (pipe(fds) == -1)
4995             exit(1);
4996
4997         pid = fork();
4998         if (pid > 0) {
4999             uint8_t status;
5000             ssize_t len;
5001
5002             close(fds[1]);
5003
5004         again:
5005             len = read(fds[0], &status, 1);
5006             if (len == -1 && (errno == EINTR))
5007                 goto again;
5008
5009             if (len != 1)
5010                 exit(1);
5011             else if (status == 1) {
5012                 fprintf(stderr, "Could not acquire pidfile\n");
5013                 exit(1);
5014             } else
5015                 exit(0);
5016         } else if (pid < 0)
5017             exit(1);
5018
5019         setsid();
5020
5021         pid = fork();
5022         if (pid > 0)
5023             exit(0);
5024         else if (pid < 0)
5025             exit(1);
5026
5027         umask(027);
5028
5029         signal(SIGTSTP, SIG_IGN);
5030         signal(SIGTTOU, SIG_IGN);
5031         signal(SIGTTIN, SIG_IGN);
5032     }
5033
5034     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5035         if (daemonize) {
5036             uint8_t status = 1;
5037             write(fds[1], &status, 1);
5038         } else
5039             fprintf(stderr, "Could not acquire pid file\n");
5040         exit(1);
5041     }
5042 #endif
5043
5044 #ifdef USE_KQEMU
5045     if (smp_cpus > 1)
5046         kqemu_allowed = 0;
5047 #endif
5048     linux_boot = (kernel_filename != NULL);
5049     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5050
5051     if (!linux_boot && *kernel_cmdline != '\0') {
5052         fprintf(stderr, "-append only allowed with -kernel option\n");
5053         exit(1);
5054     }
5055
5056     if (!linux_boot && initrd_filename != NULL) {
5057         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5058         exit(1);
5059     }
5060
5061     /* boot to floppy or the default cd if no hard disk defined yet */
5062     if (!boot_devices[0]) {
5063         boot_devices = "cad";
5064     }
5065     setvbuf(stdout, NULL, _IOLBF, 0);
5066
5067     init_timers();
5068     if (init_timer_alarm() < 0) {
5069         fprintf(stderr, "could not initialize alarm timer\n");
5070         exit(1);
5071     }
5072     if (use_icount && icount_time_shift < 0) {
5073         use_icount = 2;
5074         /* 125MIPS seems a reasonable initial guess at the guest speed.
5075            It will be corrected fairly quickly anyway.  */
5076         icount_time_shift = 3;
5077         init_icount_adjust();
5078     }
5079
5080 #ifdef _WIN32
5081     socket_init();
5082 #endif
5083
5084     /* init network clients */
5085     if (nb_net_clients == 0) {
5086         /* if no clients, we use a default config */
5087         net_clients[nb_net_clients++] = "nic";
5088 #ifdef CONFIG_SLIRP
5089         net_clients[nb_net_clients++] = "user";
5090 #endif
5091     }
5092
5093     for(i = 0;i < nb_net_clients; i++) {
5094         if (net_client_parse(net_clients[i]) < 0)
5095             exit(1);
5096     }
5097     net_client_check();
5098
5099 #ifdef TARGET_I386
5100     /* XXX: this should be moved in the PC machine instantiation code */
5101     if (net_boot != 0) {
5102         int netroms = 0;
5103         for (i = 0; i < nb_nics && i < 4; i++) {
5104             const char *model = nd_table[i].model;
5105             char buf[1024];
5106             if (net_boot & (1 << i)) {
5107                 if (model == NULL)
5108                     model = "ne2k_pci";
5109                 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5110                 if (get_image_size(buf) > 0) {
5111                     if (nb_option_roms >= MAX_OPTION_ROMS) {
5112                         fprintf(stderr, "Too many option ROMs\n");
5113                         exit(1);
5114                     }
5115                     option_rom[nb_option_roms] = strdup(buf);
5116                     nb_option_roms++;
5117                     netroms++;
5118                 }
5119             }
5120         }
5121         if (netroms == 0) {
5122             fprintf(stderr, "No valid PXE rom found for network device\n");
5123             exit(1);
5124         }
5125     }
5126 #endif
5127
5128     /* init the bluetooth world */
5129     for (i = 0; i < nb_bt_opts; i++)
5130         if (bt_parse(bt_opts[i]))
5131             exit(1);
5132
5133     /* init the memory */
5134     phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5135
5136     if (machine->ram_require & RAMSIZE_FIXED) {
5137         if (ram_size > 0) {
5138             if (ram_size < phys_ram_size) {
5139                 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5140                                 machine->name, (unsigned long long) phys_ram_size);
5141                 exit(-1);
5142             }
5143
5144             phys_ram_size = ram_size;
5145         } else
5146             ram_size = phys_ram_size;
5147     } else {
5148         if (ram_size == 0)
5149             ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5150
5151         phys_ram_size += ram_size;
5152     }
5153
5154     phys_ram_base = qemu_vmalloc(phys_ram_size);
5155     if (!phys_ram_base) {
5156         fprintf(stderr, "Could not allocate physical memory\n");
5157         exit(1);
5158     }
5159
5160     /* init the dynamic translator */
5161     cpu_exec_init_all(tb_size * 1024 * 1024);
5162
5163     bdrv_init();
5164     dma_helper_init();
5165
5166     /* we always create the cdrom drive, even if no disk is there */
5167
5168     if (nb_drives_opt < MAX_DRIVES)
5169         drive_add(NULL, CDROM_ALIAS);
5170
5171     /* we always create at least one floppy */
5172
5173     if (nb_drives_opt < MAX_DRIVES)
5174         drive_add(NULL, FD_ALIAS, 0);
5175
5176     /* we always create one sd slot, even if no card is in it */
5177
5178     if (nb_drives_opt < MAX_DRIVES)
5179         drive_add(NULL, SD_ALIAS);
5180
5181     /* open the virtual block devices */
5182
5183     for(i = 0; i < nb_drives_opt; i++)
5184         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5185             exit(1);
5186
5187     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5188     register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5189
5190 #ifndef _WIN32
5191     /* must be after terminal init, SDL library changes signal handlers */
5192     termsig_setup();
5193 #endif
5194
5195     /* Maintain compatibility with multiple stdio monitors */
5196     if (!strcmp(monitor_device,"stdio")) {
5197         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5198             const char *devname = serial_devices[i];
5199             if (devname && !strcmp(devname,"mon:stdio")) {
5200                 monitor_device = NULL;
5201                 break;
5202             } else if (devname && !strcmp(devname,"stdio")) {
5203                 monitor_device = NULL;
5204                 serial_devices[i] = "mon:stdio";
5205                 break;
5206             }
5207         }
5208     }
5209
5210     if (kvm_enabled()) {
5211         int ret;
5212
5213         ret = kvm_init(smp_cpus);
5214         if (ret < 0) {
5215             fprintf(stderr, "failed to initialize KVM\n");
5216             exit(1);
5217         }
5218     }
5219
5220     if (monitor_device) {
5221         monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5222         if (!monitor_hd) {
5223             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5224             exit(1);
5225         }
5226     }
5227
5228     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5229         const char *devname = serial_devices[i];
5230         if (devname && strcmp(devname, "none")) {
5231             char label[32];
5232             snprintf(label, sizeof(label), "serial%d", i);
5233             serial_hds[i] = qemu_chr_open(label, devname, NULL);
5234             if (!serial_hds[i]) {
5235                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5236                         devname);
5237                 exit(1);
5238             }
5239         }
5240     }
5241
5242     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5243         const char *devname = parallel_devices[i];
5244         if (devname && strcmp(devname, "none")) {
5245             char label[32];
5246             snprintf(label, sizeof(label), "parallel%d", i);
5247             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5248             if (!parallel_hds[i]) {
5249                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5250                         devname);
5251                 exit(1);
5252             }
5253         }
5254     }
5255
5256     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5257         const char *devname = virtio_consoles[i];
5258         if (devname && strcmp(devname, "none")) {
5259             char label[32];
5260             snprintf(label, sizeof(label), "virtcon%d", i);
5261             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5262             if (!virtcon_hds[i]) {
5263                 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5264                         devname);
5265                 exit(1);
5266             }
5267         }
5268     }
5269
5270     machine->init(ram_size, vga_ram_size, boot_devices,
5271                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5272
5273     current_machine = machine;
5274
5275     /* Set KVM's vcpu state to qemu's initial CPUState. */
5276     if (kvm_enabled()) {
5277         int ret;
5278
5279         ret = kvm_sync_vcpus();
5280         if (ret < 0) {
5281             fprintf(stderr, "failed to initialize vcpus\n");
5282             exit(1);
5283         }
5284     }
5285
5286     /* init USB devices */
5287     if (usb_enabled) {
5288         for(i = 0; i < usb_devices_index; i++) {
5289             if (usb_device_add(usb_devices[i], 0) < 0) {
5290                 fprintf(stderr, "Warning: could not add USB device %s\n",
5291                         usb_devices[i]);
5292             }
5293         }
5294     }
5295
5296     if (!display_state)
5297         dumb_display_init();
5298     /* just use the first displaystate for the moment */
5299     ds = display_state;
5300     /* terminal init */
5301     if (nographic) {
5302         if (curses) {
5303             fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5304             exit(1);
5305         }
5306     } else {
5307 #if defined(CONFIG_CURSES)
5308             if (curses) {
5309                 /* At the moment curses cannot be used with other displays */
5310                 curses_display_init(ds, full_screen);
5311             } else
5312 #endif
5313             {
5314                 if (vnc_display != NULL) {
5315                     vnc_display_init(ds);
5316                     if (vnc_display_open(ds, vnc_display) < 0)
5317                         exit(1);
5318                 }
5319 #if defined(CONFIG_SDL)
5320                 if (sdl || !vnc_display)
5321                     sdl_display_init(ds, full_screen, no_frame);
5322 #elif defined(CONFIG_COCOA)
5323                 if (sdl || !vnc_display)
5324                     cocoa_display_init(ds, full_screen);
5325 #endif
5326             }
5327     }
5328     dpy_resize(ds);
5329
5330     dcl = ds->listeners;
5331     while (dcl != NULL) {
5332         if (dcl->dpy_refresh != NULL) {
5333             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5334             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5335         }
5336         dcl = dcl->next;
5337     }
5338
5339     if (nographic || (vnc_display && !sdl)) {
5340         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5341         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5342     }
5343
5344     text_consoles_set_display(display_state);
5345     qemu_chr_initial_reset();
5346
5347     if (monitor_device && monitor_hd)
5348         monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
5349
5350     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5351         const char *devname = serial_devices[i];
5352         if (devname && strcmp(devname, "none")) {
5353             char label[32];
5354             snprintf(label, sizeof(label), "serial%d", i);
5355             if (strstart(devname, "vc", 0))
5356                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5357         }
5358     }
5359
5360     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5361         const char *devname = parallel_devices[i];
5362         if (devname && strcmp(devname, "none")) {
5363             char label[32];
5364             snprintf(label, sizeof(label), "parallel%d", i);
5365             if (strstart(devname, "vc", 0))
5366                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5367         }
5368     }
5369
5370     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5371         const char *devname = virtio_consoles[i];
5372         if (virtcon_hds[i] && devname) {
5373             char label[32];
5374             snprintf(label, sizeof(label), "virtcon%d", i);
5375             if (strstart(devname, "vc", 0))
5376                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5377         }
5378     }
5379
5380 #ifdef CONFIG_GDBSTUB
5381     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5382         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5383                 gdbstub_dev);
5384         exit(1);
5385     }
5386 #endif
5387
5388     if (loadvm)
5389         do_loadvm(cur_mon, loadvm);
5390
5391     if (incoming) {
5392         autostart = 0; /* fixme how to deal with -daemonize */
5393         qemu_start_incoming_migration(incoming);
5394     }
5395
5396     if (autostart)
5397         vm_start();
5398
5399 #ifndef _WIN32
5400     if (daemonize) {
5401         uint8_t status = 0;
5402         ssize_t len;
5403
5404     again1:
5405         len = write(fds[1], &status, 1);
5406         if (len == -1 && (errno == EINTR))
5407             goto again1;
5408
5409         if (len != 1)
5410             exit(1);
5411
5412         chdir("/");
5413         TFR(fd = open("/dev/null", O_RDWR));
5414         if (fd == -1)
5415             exit(1);
5416     }
5417
5418     if (run_as) {
5419         pwd = getpwnam(run_as);
5420         if (!pwd) {
5421             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5422             exit(1);
5423         }
5424     }
5425
5426     if (chroot_dir) {
5427         if (chroot(chroot_dir) < 0) {
5428             fprintf(stderr, "chroot failed\n");
5429             exit(1);
5430         }
5431         chdir("/");
5432     }
5433
5434     if (run_as) {
5435         if (setgid(pwd->pw_gid) < 0) {
5436             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5437             exit(1);
5438         }
5439         if (setuid(pwd->pw_uid) < 0) {
5440             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5441             exit(1);
5442         }
5443         if (setuid(0) != -1) {
5444             fprintf(stderr, "Dropping privileges failed\n");
5445             exit(1);
5446         }
5447     }
5448
5449     if (daemonize) {
5450         dup2(fd, 0);
5451         dup2(fd, 1);
5452         dup2(fd, 2);
5453
5454         close(fd);
5455     }
5456 #endif
5457
5458     main_loop();
5459     quit_timers();
5460     net_cleanup();
5461
5462     return 0;
5463 }