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