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 void register_displaystate(DisplayState *ds)
2878 {
2879     DisplayState **s;
2880     s = &display_state;
2881     while (*s != NULL)
2882         s = &(*s)->next;
2883     ds->next = NULL;
2884     *s = ds;
2885 }
2886
2887 DisplayState *get_displaystate(void)
2888 {
2889     return display_state;
2890 }
2891
2892 /* dumb display */
2893
2894 static void dumb_display_init(void)
2895 {
2896     DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2897     ds->surface = qemu_create_displaysurface(640, 480, 32, 640 * 4);
2898     register_displaystate(ds);
2899 }
2900
2901 /***********************************************************/
2902 /* I/O handling */
2903
2904 #define MAX_IO_HANDLERS 64
2905
2906 typedef struct IOHandlerRecord {
2907     int fd;
2908     IOCanRWHandler *fd_read_poll;
2909     IOHandler *fd_read;
2910     IOHandler *fd_write;
2911     int deleted;
2912     void *opaque;
2913     /* temporary data */
2914     struct pollfd *ufd;
2915     struct IOHandlerRecord *next;
2916 } IOHandlerRecord;
2917
2918 static IOHandlerRecord *first_io_handler;
2919
2920 /* XXX: fd_read_poll should be suppressed, but an API change is
2921    necessary in the character devices to suppress fd_can_read(). */
2922 int qemu_set_fd_handler2(int fd,
2923                          IOCanRWHandler *fd_read_poll,
2924                          IOHandler *fd_read,
2925                          IOHandler *fd_write,
2926                          void *opaque)
2927 {
2928     IOHandlerRecord **pioh, *ioh;
2929
2930     if (!fd_read && !fd_write) {
2931         pioh = &first_io_handler;
2932         for(;;) {
2933             ioh = *pioh;
2934             if (ioh == NULL)
2935                 break;
2936             if (ioh->fd == fd) {
2937                 ioh->deleted = 1;
2938                 break;
2939             }
2940             pioh = &ioh->next;
2941         }
2942     } else {
2943         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2944             if (ioh->fd == fd)
2945                 goto found;
2946         }
2947         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2948         ioh->next = first_io_handler;
2949         first_io_handler = ioh;
2950     found:
2951         ioh->fd = fd;
2952         ioh->fd_read_poll = fd_read_poll;
2953         ioh->fd_read = fd_read;
2954         ioh->fd_write = fd_write;
2955         ioh->opaque = opaque;
2956         ioh->deleted = 0;
2957     }
2958     return 0;
2959 }
2960
2961 int qemu_set_fd_handler(int fd,
2962                         IOHandler *fd_read,
2963                         IOHandler *fd_write,
2964                         void *opaque)
2965 {
2966     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2967 }
2968
2969 #ifdef _WIN32
2970 /***********************************************************/
2971 /* Polling handling */
2972
2973 typedef struct PollingEntry {
2974     PollingFunc *func;
2975     void *opaque;
2976     struct PollingEntry *next;
2977 } PollingEntry;
2978
2979 static PollingEntry *first_polling_entry;
2980
2981 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2982 {
2983     PollingEntry **ppe, *pe;
2984     pe = qemu_mallocz(sizeof(PollingEntry));
2985     pe->func = func;
2986     pe->opaque = opaque;
2987     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2988     *ppe = pe;
2989     return 0;
2990 }
2991
2992 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2993 {
2994     PollingEntry **ppe, *pe;
2995     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2996         pe = *ppe;
2997         if (pe->func == func && pe->opaque == opaque) {
2998             *ppe = pe->next;
2999             qemu_free(pe);
3000             break;
3001         }
3002     }
3003 }
3004
3005 /***********************************************************/
3006 /* Wait objects support */
3007 typedef struct WaitObjects {
3008     int num;
3009     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3010     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3011     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3012 } WaitObjects;
3013
3014 static WaitObjects wait_objects = {0};
3015
3016 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3017 {
3018     WaitObjects *w = &wait_objects;
3019
3020     if (w->num >= MAXIMUM_WAIT_OBJECTS)
3021         return -1;
3022     w->events[w->num] = handle;
3023     w->func[w->num] = func;
3024     w->opaque[w->num] = opaque;
3025     w->num++;
3026     return 0;
3027 }
3028
3029 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3030 {
3031     int i, found;
3032     WaitObjects *w = &wait_objects;
3033
3034     found = 0;
3035     for (i = 0; i < w->num; i++) {
3036         if (w->events[i] == handle)
3037             found = 1;
3038         if (found) {
3039             w->events[i] = w->events[i + 1];
3040             w->func[i] = w->func[i + 1];
3041             w->opaque[i] = w->opaque[i + 1];
3042         }
3043     }
3044     if (found)
3045         w->num--;
3046 }
3047 #endif
3048
3049 /***********************************************************/
3050 /* ram save/restore */
3051
3052 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3053 {
3054     int v;
3055
3056     v = qemu_get_byte(f);
3057     switch(v) {
3058     case 0:
3059         if (qemu_get_buffer(f, buf, len) != len)
3060             return -EIO;
3061         break;
3062     case 1:
3063         v = qemu_get_byte(f);
3064         memset(buf, v, len);
3065         break;
3066     default:
3067         return -EINVAL;
3068     }
3069
3070     if (qemu_file_has_error(f))
3071         return -EIO;
3072
3073     return 0;
3074 }
3075
3076 static int ram_load_v1(QEMUFile *f, void *opaque)
3077 {
3078     int ret;
3079     ram_addr_t i;
3080
3081     if (qemu_get_be32(f) != phys_ram_size)
3082         return -EINVAL;
3083     for(i = 0; i < phys_ram_size; i+= TARGET_PAGE_SIZE) {
3084         ret = ram_get_page(f, phys_ram_base + i, TARGET_PAGE_SIZE);
3085         if (ret)
3086             return ret;
3087     }
3088     return 0;
3089 }
3090
3091 #define BDRV_HASH_BLOCK_SIZE 1024
3092 #define IOBUF_SIZE 4096
3093 #define RAM_CBLOCK_MAGIC 0xfabe
3094
3095 typedef struct RamDecompressState {
3096     z_stream zstream;
3097     QEMUFile *f;
3098     uint8_t buf[IOBUF_SIZE];
3099 } RamDecompressState;
3100
3101 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3102 {
3103     int ret;
3104     memset(s, 0, sizeof(*s));
3105     s->f = f;
3106     ret = inflateInit(&s->zstream);
3107     if (ret != Z_OK)
3108         return -1;
3109     return 0;
3110 }
3111
3112 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3113 {
3114     int ret, clen;
3115
3116     s->zstream.avail_out = len;
3117     s->zstream.next_out = buf;
3118     while (s->zstream.avail_out > 0) {
3119         if (s->zstream.avail_in == 0) {
3120             if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3121                 return -1;
3122             clen = qemu_get_be16(s->f);
3123             if (clen > IOBUF_SIZE)
3124                 return -1;
3125             qemu_get_buffer(s->f, s->buf, clen);
3126             s->zstream.avail_in = clen;
3127             s->zstream.next_in = s->buf;
3128         }
3129         ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3130         if (ret != Z_OK && ret != Z_STREAM_END) {
3131             return -1;
3132         }
3133     }
3134     return 0;
3135 }
3136
3137 static void ram_decompress_close(RamDecompressState *s)
3138 {
3139     inflateEnd(&s->zstream);
3140 }
3141
3142 #define RAM_SAVE_FLAG_FULL      0x01
3143 #define RAM_SAVE_FLAG_COMPRESS  0x02
3144 #define RAM_SAVE_FLAG_MEM_SIZE  0x04
3145 #define RAM_SAVE_FLAG_PAGE      0x08
3146 #define RAM_SAVE_FLAG_EOS       0x10
3147
3148 static int is_dup_page(uint8_t *page, uint8_t ch)
3149 {
3150     uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3151     uint32_t *array = (uint32_t *)page;
3152     int i;
3153
3154     for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3155         if (array[i] != val)
3156             return 0;
3157     }
3158
3159     return 1;
3160 }
3161
3162 static int ram_save_block(QEMUFile *f)
3163 {
3164     static ram_addr_t current_addr = 0;
3165     ram_addr_t saved_addr = current_addr;
3166     ram_addr_t addr = 0;
3167     int found = 0;
3168
3169     while (addr < phys_ram_size) {
3170         if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3171             uint8_t ch;
3172
3173             cpu_physical_memory_reset_dirty(current_addr,
3174                                             current_addr + TARGET_PAGE_SIZE,
3175                                             MIGRATION_DIRTY_FLAG);
3176
3177             ch = *(phys_ram_base + current_addr);
3178
3179             if (is_dup_page(phys_ram_base + current_addr, ch)) {
3180                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3181                 qemu_put_byte(f, ch);
3182             } else {
3183                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3184                 qemu_put_buffer(f, phys_ram_base + current_addr, TARGET_PAGE_SIZE);
3185             }
3186
3187             found = 1;
3188             break;
3189         }
3190         addr += TARGET_PAGE_SIZE;
3191         current_addr = (saved_addr + addr) % phys_ram_size;
3192     }
3193
3194     return found;
3195 }
3196
3197 static ram_addr_t ram_save_threshold = 10;
3198
3199 static ram_addr_t ram_save_remaining(void)
3200 {
3201     ram_addr_t addr;
3202     ram_addr_t count = 0;
3203
3204     for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3205         if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3206             count++;
3207     }
3208
3209     return count;
3210 }
3211
3212 static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3213 {
3214     ram_addr_t addr;
3215
3216     if (stage == 1) {
3217         /* Make sure all dirty bits are set */
3218         for (addr = 0; addr < phys_ram_size; addr += TARGET_PAGE_SIZE) {
3219             if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3220                 cpu_physical_memory_set_dirty(addr);
3221         }
3222
3223         /* Enable dirty memory tracking */
3224         cpu_physical_memory_set_dirty_tracking(1);
3225
3226         qemu_put_be64(f, phys_ram_size | RAM_SAVE_FLAG_MEM_SIZE);
3227     }
3228
3229     while (!qemu_file_rate_limit(f)) {
3230         int ret;
3231
3232         ret = ram_save_block(f);
3233         if (ret == 0) /* no more blocks */
3234             break;
3235     }
3236
3237     /* try transferring iterative blocks of memory */
3238
3239     if (stage == 3) {
3240         cpu_physical_memory_set_dirty_tracking(0);
3241
3242         /* flush all remaining blocks regardless of rate limiting */
3243         while (ram_save_block(f) != 0);
3244     }
3245
3246     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3247
3248     return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3249 }
3250
3251 static int ram_load_dead(QEMUFile *f, void *opaque)
3252 {
3253     RamDecompressState s1, *s = &s1;
3254     uint8_t buf[10];
3255     ram_addr_t i;
3256
3257     if (ram_decompress_open(s, f) < 0)
3258         return -EINVAL;
3259     for(i = 0; i < phys_ram_size; i+= BDRV_HASH_BLOCK_SIZE) {
3260         if (ram_decompress_buf(s, buf, 1) < 0) {
3261             fprintf(stderr, "Error while reading ram block header\n");
3262             goto error;
3263         }
3264         if (buf[0] == 0) {
3265             if (ram_decompress_buf(s, phys_ram_base + i, BDRV_HASH_BLOCK_SIZE) < 0) {
3266                 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3267                 goto error;
3268             }
3269         } else {
3270         error:
3271             printf("Error block header\n");
3272             return -EINVAL;
3273         }
3274     }
3275     ram_decompress_close(s);
3276
3277     return 0;
3278 }
3279
3280 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3281 {
3282     ram_addr_t addr;
3283     int flags;
3284
3285     if (version_id == 1)
3286         return ram_load_v1(f, opaque);
3287
3288     if (version_id == 2) {
3289         if (qemu_get_be32(f) != phys_ram_size)
3290             return -EINVAL;
3291         return ram_load_dead(f, opaque);
3292     }
3293
3294     if (version_id != 3)
3295         return -EINVAL;
3296
3297     do {
3298         addr = qemu_get_be64(f);
3299
3300         flags = addr & ~TARGET_PAGE_MASK;
3301         addr &= TARGET_PAGE_MASK;
3302
3303         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3304             if (addr != phys_ram_size)
3305                 return -EINVAL;
3306         }
3307
3308         if (flags & RAM_SAVE_FLAG_FULL) {
3309             if (ram_load_dead(f, opaque) < 0)
3310                 return -EINVAL;
3311         }
3312
3313         if (flags & RAM_SAVE_FLAG_COMPRESS) {
3314             uint8_t ch = qemu_get_byte(f);
3315             memset(phys_ram_base + addr, ch, TARGET_PAGE_SIZE);
3316         } else if (flags & RAM_SAVE_FLAG_PAGE)
3317             qemu_get_buffer(f, phys_ram_base + addr, TARGET_PAGE_SIZE);
3318     } while (!(flags & RAM_SAVE_FLAG_EOS));
3319
3320     return 0;
3321 }
3322
3323 void qemu_service_io(void)
3324 {
3325     CPUState *env = cpu_single_env;
3326     if (env) {
3327         cpu_exit(env);
3328 #ifdef USE_KQEMU
3329         if (env->kqemu_enabled) {
3330             kqemu_cpu_interrupt(env);
3331         }
3332 #endif
3333     }
3334 }
3335
3336 /***********************************************************/
3337 /* bottom halves (can be seen as timers which expire ASAP) */
3338
3339 struct QEMUBH {
3340     QEMUBHFunc *cb;
3341     void *opaque;
3342     int scheduled;
3343     int idle;
3344     int deleted;
3345     QEMUBH *next;
3346 };
3347
3348 static QEMUBH *first_bh = NULL;
3349
3350 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3351 {
3352     QEMUBH *bh;
3353     bh = qemu_mallocz(sizeof(QEMUBH));
3354     bh->cb = cb;
3355     bh->opaque = opaque;
3356     bh->next = first_bh;
3357     first_bh = bh;
3358     return bh;
3359 }
3360
3361 int qemu_bh_poll(void)
3362 {
3363     QEMUBH *bh, **bhp;
3364     int ret;
3365
3366     ret = 0;
3367     for (bh = first_bh; bh; bh = bh->next) {
3368         if (!bh->deleted && bh->scheduled) {
3369             bh->scheduled = 0;
3370             if (!bh->idle)
3371                 ret = 1;
3372             bh->idle = 0;
3373             bh->cb(bh->opaque);
3374         }
3375     }
3376
3377     /* remove deleted bhs */
3378     bhp = &first_bh;
3379     while (*bhp) {
3380         bh = *bhp;
3381         if (bh->deleted) {
3382             *bhp = bh->next;
3383             qemu_free(bh);
3384         } else
3385             bhp = &bh->next;
3386     }
3387
3388     return ret;
3389 }
3390
3391 void qemu_bh_schedule_idle(QEMUBH *bh)
3392 {
3393     if (bh->scheduled)
3394         return;
3395     bh->scheduled = 1;
3396     bh->idle = 1;
3397 }
3398
3399 void qemu_bh_schedule(QEMUBH *bh)
3400 {
3401     CPUState *env = cpu_single_env;
3402     if (bh->scheduled)
3403         return;
3404     bh->scheduled = 1;
3405     bh->idle = 0;
3406     /* stop the currently executing CPU to execute the BH ASAP */
3407     if (env) {
3408         cpu_exit(env);
3409     }
3410 }
3411
3412 void qemu_bh_cancel(QEMUBH *bh)
3413 {
3414     bh->scheduled = 0;
3415 }
3416
3417 void qemu_bh_delete(QEMUBH *bh)
3418 {
3419     bh->scheduled = 0;
3420     bh->deleted = 1;
3421 }
3422
3423 static void qemu_bh_update_timeout(int *timeout)
3424 {
3425     QEMUBH *bh;
3426
3427     for (bh = first_bh; bh; bh = bh->next) {
3428         if (!bh->deleted && bh->scheduled) {
3429             if (bh->idle) {
3430                 /* idle bottom halves will be polled at least
3431                  * every 10ms */
3432                 *timeout = MIN(10, *timeout);
3433             } else {
3434                 /* non-idle bottom halves will be executed
3435                  * immediately */
3436                 *timeout = 0;
3437                 break;
3438             }
3439         }
3440     }
3441 }
3442
3443 /***********************************************************/
3444 /* machine registration */
3445
3446 static QEMUMachine *first_machine = NULL;
3447 QEMUMachine *current_machine = NULL;
3448
3449 int qemu_register_machine(QEMUMachine *m)
3450 {
3451     QEMUMachine **pm;
3452     pm = &first_machine;
3453     while (*pm != NULL)
3454         pm = &(*pm)->next;
3455     m->next = NULL;
3456     *pm = m;
3457     return 0;
3458 }
3459
3460 static QEMUMachine *find_machine(const char *name)
3461 {
3462     QEMUMachine *m;
3463
3464     for(m = first_machine; m != NULL; m = m->next) {
3465         if (!strcmp(m->name, name))
3466             return m;
3467     }
3468     return NULL;
3469 }
3470
3471 /***********************************************************/
3472 /* main execution loop */
3473
3474 static void gui_update(void *opaque)
3475 {
3476     uint64_t interval = GUI_REFRESH_INTERVAL;
3477     DisplayState *ds = opaque;
3478     DisplayChangeListener *dcl = ds->listeners;
3479
3480     dpy_refresh(ds);
3481
3482     while (dcl != NULL) {
3483         if (dcl->gui_timer_interval &&
3484             dcl->gui_timer_interval < interval)
3485             interval = dcl->gui_timer_interval;
3486         dcl = dcl->next;
3487     }
3488     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3489 }
3490
3491 static void nographic_update(void *opaque)
3492 {
3493     uint64_t interval = GUI_REFRESH_INTERVAL;
3494
3495     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3496 }
3497
3498 struct vm_change_state_entry {
3499     VMChangeStateHandler *cb;
3500     void *opaque;
3501     LIST_ENTRY (vm_change_state_entry) entries;
3502 };
3503
3504 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3505
3506 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3507                                                      void *opaque)
3508 {
3509     VMChangeStateEntry *e;
3510
3511     e = qemu_mallocz(sizeof (*e));
3512
3513     e->cb = cb;
3514     e->opaque = opaque;
3515     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3516     return e;
3517 }
3518
3519 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3520 {
3521     LIST_REMOVE (e, entries);
3522     qemu_free (e);
3523 }
3524
3525 static void vm_state_notify(int running, int reason)
3526 {
3527     VMChangeStateEntry *e;
3528
3529     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3530         e->cb(e->opaque, running, reason);
3531     }
3532 }
3533
3534 void vm_start(void)
3535 {
3536     if (!vm_running) {
3537         cpu_enable_ticks();
3538         vm_running = 1;
3539         vm_state_notify(1, 0);
3540         qemu_rearm_alarm_timer(alarm_timer);
3541     }
3542 }
3543
3544 void vm_stop(int reason)
3545 {
3546     if (vm_running) {
3547         cpu_disable_ticks();
3548         vm_running = 0;
3549         vm_state_notify(0, reason);
3550     }
3551 }
3552
3553 /* reset/shutdown handler */
3554
3555 typedef struct QEMUResetEntry {
3556     QEMUResetHandler *func;
3557     void *opaque;
3558     struct QEMUResetEntry *next;
3559 } QEMUResetEntry;
3560
3561 static QEMUResetEntry *first_reset_entry;
3562 static int reset_requested;
3563 static int shutdown_requested;
3564 static int powerdown_requested;
3565
3566 int qemu_shutdown_requested(void)
3567 {
3568     int r = shutdown_requested;
3569     shutdown_requested = 0;
3570     return r;
3571 }
3572
3573 int qemu_reset_requested(void)
3574 {
3575     int r = reset_requested;
3576     reset_requested = 0;
3577     return r;
3578 }
3579
3580 int qemu_powerdown_requested(void)
3581 {
3582     int r = powerdown_requested;
3583     powerdown_requested = 0;
3584     return r;
3585 }
3586
3587 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3588 {
3589     QEMUResetEntry **pre, *re;
3590
3591     pre = &first_reset_entry;
3592     while (*pre != NULL)
3593         pre = &(*pre)->next;
3594     re = qemu_mallocz(sizeof(QEMUResetEntry));
3595     re->func = func;
3596     re->opaque = opaque;
3597     re->next = NULL;
3598     *pre = re;
3599 }
3600
3601 void qemu_system_reset(void)
3602 {
3603     QEMUResetEntry *re;
3604
3605     /* reset all devices */
3606     for(re = first_reset_entry; re != NULL; re = re->next) {
3607         re->func(re->opaque);
3608     }
3609 }
3610
3611 void qemu_system_reset_request(void)
3612 {
3613     if (no_reboot) {
3614         shutdown_requested = 1;
3615     } else {
3616         reset_requested = 1;
3617     }
3618     if (cpu_single_env)
3619         cpu_exit(cpu_single_env);
3620 }
3621
3622 void qemu_system_shutdown_request(void)
3623 {
3624     shutdown_requested = 1;
3625     if (cpu_single_env)
3626         cpu_exit(cpu_single_env);
3627 }
3628
3629 void qemu_system_powerdown_request(void)
3630 {
3631     powerdown_requested = 1;
3632     if (cpu_single_env)
3633         cpu_exit(cpu_single_env);
3634 }
3635
3636 #ifdef _WIN32
3637 static void host_main_loop_wait(int *timeout)
3638 {
3639     int ret, ret2, i;
3640     PollingEntry *pe;
3641
3642
3643     /* XXX: need to suppress polling by better using win32 events */
3644     ret = 0;
3645     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3646         ret |= pe->func(pe->opaque);
3647     }
3648     if (ret == 0) {
3649         int err;
3650         WaitObjects *w = &wait_objects;
3651
3652         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3653         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3654             if (w->func[ret - WAIT_OBJECT_0])
3655                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3656
3657             /* Check for additional signaled events */
3658             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3659
3660                 /* Check if event is signaled */
3661                 ret2 = WaitForSingleObject(w->events[i], 0);
3662                 if(ret2 == WAIT_OBJECT_0) {
3663                     if (w->func[i])
3664                         w->func[i](w->opaque[i]);
3665                 } else if (ret2 == WAIT_TIMEOUT) {
3666                 } else {
3667                     err = GetLastError();
3668                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3669                 }
3670             }
3671         } else if (ret == WAIT_TIMEOUT) {
3672         } else {
3673             err = GetLastError();
3674             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3675         }
3676     }
3677
3678     *timeout = 0;
3679 }
3680 #else
3681 static void host_main_loop_wait(int *timeout)
3682 {
3683 }
3684 #endif
3685
3686 void main_loop_wait(int timeout)
3687 {
3688     IOHandlerRecord *ioh;
3689     fd_set rfds, wfds, xfds;
3690     int ret, nfds;
3691     struct timeval tv;
3692
3693     qemu_bh_update_timeout(&timeout);
3694
3695     host_main_loop_wait(&timeout);
3696
3697     /* poll any events */
3698     /* XXX: separate device handlers from system ones */
3699     nfds = -1;
3700     FD_ZERO(&rfds);
3701     FD_ZERO(&wfds);
3702     FD_ZERO(&xfds);
3703     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3704         if (ioh->deleted)
3705             continue;
3706         if (ioh->fd_read &&
3707             (!ioh->fd_read_poll ||
3708              ioh->fd_read_poll(ioh->opaque) != 0)) {
3709             FD_SET(ioh->fd, &rfds);
3710             if (ioh->fd > nfds)
3711                 nfds = ioh->fd;
3712         }
3713         if (ioh->fd_write) {
3714             FD_SET(ioh->fd, &wfds);
3715             if (ioh->fd > nfds)
3716                 nfds = ioh->fd;
3717         }
3718     }
3719
3720     tv.tv_sec = timeout / 1000;
3721     tv.tv_usec = (timeout % 1000) * 1000;
3722
3723 #if defined(CONFIG_SLIRP)
3724     if (slirp_is_inited()) {
3725         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3726     }
3727 #endif
3728     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3729     if (ret > 0) {
3730         IOHandlerRecord **pioh;
3731
3732         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3733             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3734                 ioh->fd_read(ioh->opaque);
3735             }
3736             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3737                 ioh->fd_write(ioh->opaque);
3738             }
3739         }
3740
3741         /* remove deleted IO handlers */
3742         pioh = &first_io_handler;
3743         while (*pioh) {
3744             ioh = *pioh;
3745             if (ioh->deleted) {
3746                 *pioh = ioh->next;
3747                 qemu_free(ioh);
3748             } else
3749                 pioh = &ioh->next;
3750         }
3751     }
3752 #if defined(CONFIG_SLIRP)
3753     if (slirp_is_inited()) {
3754         if (ret < 0) {
3755             FD_ZERO(&rfds);
3756             FD_ZERO(&wfds);
3757             FD_ZERO(&xfds);
3758         }
3759         slirp_select_poll(&rfds, &wfds, &xfds);
3760     }
3761 #endif
3762
3763     /* vm time timers */
3764     if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3765         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3766                         qemu_get_clock(vm_clock));
3767
3768     /* real time timers */
3769     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3770                     qemu_get_clock(rt_clock));
3771
3772     /* Check bottom-halves last in case any of the earlier events triggered
3773        them.  */
3774     qemu_bh_poll();
3775
3776 }
3777
3778 static int main_loop(void)
3779 {
3780     int ret, timeout;
3781 #ifdef CONFIG_PROFILER
3782     int64_t ti;
3783 #endif
3784     CPUState *env;
3785
3786     cur_cpu = first_cpu;
3787     next_cpu = cur_cpu->next_cpu ?: first_cpu;
3788     for(;;) {
3789         if (vm_running) {
3790
3791             for(;;) {
3792                 /* get next cpu */
3793                 env = next_cpu;
3794 #ifdef CONFIG_PROFILER
3795                 ti = profile_getclock();
3796 #endif
3797                 if (use_icount) {
3798                     int64_t count;
3799                     int decr;
3800                     qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3801                     env->icount_decr.u16.low = 0;
3802                     env->icount_extra = 0;
3803                     count = qemu_next_deadline();
3804                     count = (count + (1 << icount_time_shift) - 1)
3805                             >> icount_time_shift;
3806                     qemu_icount += count;
3807                     decr = (count > 0xffff) ? 0xffff : count;
3808                     count -= decr;
3809                     env->icount_decr.u16.low = decr;
3810                     env->icount_extra = count;
3811                 }
3812                 ret = cpu_exec(env);
3813 #ifdef CONFIG_PROFILER
3814                 qemu_time += profile_getclock() - ti;
3815 #endif
3816                 if (use_icount) {
3817                     /* Fold pending instructions back into the
3818                        instruction counter, and clear the interrupt flag.  */
3819                     qemu_icount -= (env->icount_decr.u16.low
3820                                     + env->icount_extra);
3821                     env->icount_decr.u32 = 0;
3822                     env->icount_extra = 0;
3823                 }
3824                 next_cpu = env->next_cpu ?: first_cpu;
3825                 if (event_pending && likely(ret != EXCP_DEBUG)) {
3826                     ret = EXCP_INTERRUPT;
3827                     event_pending = 0;
3828                     break;
3829                 }
3830                 if (ret == EXCP_HLT) {
3831                     /* Give the next CPU a chance to run.  */
3832                     cur_cpu = env;
3833                     continue;
3834                 }
3835                 if (ret != EXCP_HALTED)
3836                     break;
3837                 /* all CPUs are halted ? */
3838                 if (env == cur_cpu)
3839                     break;
3840             }
3841             cur_cpu = env;
3842
3843             if (shutdown_requested) {
3844                 ret = EXCP_INTERRUPT;
3845                 if (no_shutdown) {
3846                     vm_stop(0);
3847                     no_shutdown = 0;
3848                 }
3849                 else
3850                     break;
3851             }
3852             if (reset_requested) {
3853                 reset_requested = 0;
3854                 qemu_system_reset();
3855                 ret = EXCP_INTERRUPT;
3856             }
3857             if (powerdown_requested) {
3858                 powerdown_requested = 0;
3859                 qemu_system_powerdown();
3860                 ret = EXCP_INTERRUPT;
3861             }
3862             if (unlikely(ret == EXCP_DEBUG)) {
3863                 gdb_set_stop_cpu(cur_cpu);
3864                 vm_stop(EXCP_DEBUG);
3865             }
3866             /* If all cpus are halted then wait until the next IRQ */
3867             /* XXX: use timeout computed from timers */
3868             if (ret == EXCP_HALTED) {
3869                 if (use_icount) {
3870                     int64_t add;
3871                     int64_t delta;
3872                     /* Advance virtual time to the next event.  */
3873                     if (use_icount == 1) {
3874                         /* When not using an adaptive execution frequency
3875                            we tend to get badly out of sync with real time,
3876                            so just delay for a reasonable amount of time.  */
3877                         delta = 0;
3878                     } else {
3879                         delta = cpu_get_icount() - cpu_get_clock();
3880                     }
3881                     if (delta > 0) {
3882                         /* If virtual time is ahead of real time then just
3883                            wait for IO.  */
3884                         timeout = (delta / 1000000) + 1;
3885                     } else {
3886                         /* Wait for either IO to occur or the next
3887                            timer event.  */
3888                         add = qemu_next_deadline();
3889                         /* We advance the timer before checking for IO.
3890                            Limit the amount we advance so that early IO
3891                            activity won't get the guest too far ahead.  */
3892                         if (add > 10000000)
3893                             add = 10000000;
3894                         delta += add;
3895                         add = (add + (1 << icount_time_shift) - 1)
3896                               >> icount_time_shift;
3897                         qemu_icount += add;
3898                         timeout = delta / 1000000;
3899                         if (timeout < 0)
3900                             timeout = 0;
3901                     }
3902                 } else {
3903                     timeout = 5000;
3904                 }
3905             } else {
3906                 timeout = 0;
3907             }
3908         } else {
3909             if (shutdown_requested) {
3910                 ret = EXCP_INTERRUPT;
3911                 break;
3912             }
3913             timeout = 5000;
3914         }
3915 #ifdef CONFIG_PROFILER
3916         ti = profile_getclock();
3917 #endif
3918         main_loop_wait(timeout);
3919 #ifdef CONFIG_PROFILER
3920         dev_time += profile_getclock() - ti;
3921 #endif
3922     }
3923     cpu_disable_ticks();
3924     return ret;
3925 }
3926
3927 static void help(int exitcode)
3928 {
3929     /* Please keep in synch with QEMU_OPTION_ enums, qemu_options[]
3930        and qemu-doc.texi */
3931     printf("QEMU PC emulator version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
3932            "usage: %s [options] [disk_image]\n"
3933            "\n"
3934            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
3935            "\n"
3936            "Standard options:\n"
3937            "-h or -help     display this help and exit\n"
3938            "-M machine      select emulated machine (-M ? for list)\n"
3939            "-cpu cpu        select CPU (-cpu ? for list)\n"
3940            "-smp n          set the number of CPUs to 'n' [default=1]\n"
3941            "-fda/-fdb file  use 'file' as floppy disk 0/1 image\n"
3942            "-hda/-hdb file  use 'file' as IDE hard disk 0/1 image\n"
3943            "-hdc/-hdd file  use 'file' as IDE hard disk 2/3 image\n"
3944            "-cdrom file     use 'file' as IDE cdrom image (cdrom is ide1 master)\n"
3945            "-drive [file=file][,if=type][,bus=n][,unit=m][,media=d][,index=i]\n"
3946            "       [,cyls=c,heads=h,secs=s[,trans=t]][,snapshot=on|off]\n"
3947            "       [,cache=writethrough|writeback|none][,format=f][,serial=s]\n"
3948            "                use 'file' as a drive image\n"
3949            "-mtdblock file  use 'file' as on-board Flash memory image\n"
3950            "-sd file        use 'file' as SecureDigital card image\n"
3951            "-pflash file    use 'file' as a parallel flash image\n"
3952            "-boot [a|c|d|n] boot on floppy (a), hard disk (c), CD-ROM (d), or network (n)\n"
3953            "-snapshot       write to temporary files instead of disk image files\n"
3954            "-m megs         set virtual RAM size to megs MB [default=%d]\n"
3955 #ifndef _WIN32
3956            "-k language     use keyboard layout (for example \"fr\" for French)\n"
3957 #endif
3958 #ifdef HAS_AUDIO
3959            "-audio-help     print list of audio drivers and their options\n"
3960            "-soundhw c1,... enable audio support\n"
3961            "                and only specified sound cards (comma separated list)\n"
3962            "                use -soundhw ? to get the list of supported cards\n"
3963            "                use -soundhw all to enable all of them\n"
3964 #endif
3965            "-usb            enable the USB driver (will be the default soon)\n"
3966            "-usbdevice name add the host or guest USB device 'name'\n"
3967            "-name string    set the name of the guest\n"
3968            "-uuid %%08x-%%04x-%%04x-%%04x-%%012x\n"
3969            "                specify machine UUID\n"
3970            "\n"
3971            "Display options:\n"
3972            "-nographic      disable graphical output and redirect serial I/Os to console\n"
3973 #ifdef CONFIG_CURSES
3974            "-curses         use a curses/ncurses interface instead of SDL\n"
3975 #endif
3976 #ifdef CONFIG_SDL
3977            "-no-frame       open SDL window without a frame and window decorations\n"
3978            "-alt-grab       use Ctrl-Alt-Shift to grab mouse (instead of Ctrl-Alt)\n"
3979            "-no-quit        disable SDL window close capability\n"
3980            "-sdl            enable SDL\n"
3981 #endif
3982            "-portrait       rotate graphical output 90 deg left (only PXA LCD)\n"
3983            "-vga [std|cirrus|vmware|none]\n"
3984            "                select video card type\n"
3985            "-full-screen    start in full screen\n"
3986 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
3987            "-g WxH[xDEPTH]  Set the initial graphical resolution and depth\n"
3988 #endif
3989            "-vnc display    start a VNC server on display\n"
3990            "\n"
3991            "Network options:\n"
3992            "-net nic[,vlan=n][,macaddr=addr][,model=type][,name=str]\n"
3993            "                create a new Network Interface Card and connect it to VLAN 'n'\n"
3994 #ifdef CONFIG_SLIRP
3995            "-net user[,vlan=n][,name=str][,hostname=host]\n"
3996            "                connect the user mode network stack to VLAN 'n' and send\n"
3997            "                hostname 'host' to DHCP clients\n"
3998 #endif
3999 #ifdef _WIN32
4000            "-net tap[,vlan=n][,name=str],ifname=name\n"
4001            "                connect the host TAP network interface to VLAN 'n'\n"
4002 #else
4003            "-net tap[,vlan=n][,name=str][,fd=h][,ifname=name][,script=file][,downscript=dfile]\n"
4004            "                connect the host TAP network interface to VLAN 'n' and use the\n"
4005            "                network scripts 'file' (default=%s)\n"
4006            "                and 'dfile' (default=%s);\n"
4007            "                use '[down]script=no' to disable script execution;\n"
4008            "                use 'fd=h' to connect to an already opened TAP interface\n"
4009 #endif
4010            "-net socket[,vlan=n][,name=str][,fd=h][,listen=[host]:port][,connect=host:port]\n"
4011            "                connect the vlan 'n' to another VLAN using a socket connection\n"
4012            "-net socket[,vlan=n][,name=str][,fd=h][,mcast=maddr:port]\n"
4013            "                connect the vlan 'n' to multicast maddr and port\n"
4014 #ifdef CONFIG_VDE
4015            "-net vde[,vlan=n][,name=str][,sock=socketpath][,port=n][,group=groupname][,mode=octalmode]\n"
4016            "                connect the vlan 'n' to port 'n' of a vde switch running\n"
4017            "                on host and listening for incoming connections on 'socketpath'.\n"
4018            "                Use group 'groupname' and mode 'octalmode' to change default\n"
4019            "                ownership and permissions for communication port.\n"
4020 #endif
4021            "-net none       use it alone to have zero network devices; if no -net option\n"
4022            "                is provided, the default is '-net nic -net user'\n"
4023 #ifdef CONFIG_SLIRP
4024            "-tftp dir       allow tftp access to files in dir [-net user]\n"
4025            "-bootp file     advertise file in BOOTP replies\n"
4026 #ifndef _WIN32
4027            "-smb dir        allow SMB access to files in 'dir' [-net user]\n"
4028 #endif
4029            "-redir [tcp|udp]:host-port:[guest-host]:guest-port\n"
4030            "                redirect TCP or UDP connections from host to guest [-net user]\n"
4031 #endif
4032            "\n"
4033            "-bt hci,null    dumb bluetooth HCI - doesn't respond to commands\n"
4034            "-bt hci,host[:id]\n"
4035            "                use host's HCI with the given name\n"
4036            "-bt hci[,vlan=n]\n"
4037            "                emulate a standard HCI in virtual scatternet 'n'\n"
4038            "-bt vhci[,vlan=n]\n"
4039            "                add host computer to virtual scatternet 'n' using VHCI\n"
4040            "-bt device:dev[,vlan=n]\n"
4041            "                emulate a bluetooth device 'dev' in scatternet 'n'\n"
4042            "\n"
4043 #ifdef TARGET_I386
4044            "\n"
4045            "i386 target only:\n"
4046            "-win2k-hack     use it when installing Windows 2000 to avoid a disk full bug\n"
4047            "-rtc-td-hack    use it to fix time drift in Windows ACPI HAL\n"
4048            "-no-fd-bootchk  disable boot signature checking for floppy disks\n"
4049            "-no-acpi        disable ACPI\n"
4050            "-no-hpet        disable HPET\n"
4051            "-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"
4052            "                ACPI table description\n"
4053 #endif
4054            "Linux boot specific:\n"
4055            "-kernel bzImage use 'bzImage' as kernel image\n"
4056            "-append cmdline use 'cmdline' as kernel command line\n"
4057            "-initrd file    use 'file' as initial ram disk\n"
4058            "\n"
4059            "Debug/Expert options:\n"
4060            "-serial dev     redirect the serial port to char device 'dev'\n"
4061            "-parallel dev   redirect the parallel port to char device 'dev'\n"
4062            "-monitor dev    redirect the monitor to char device 'dev'\n"
4063            "-pidfile file   write PID to 'file'\n"
4064            "-S              freeze CPU at startup (use 'c' to start execution)\n"
4065            "-s              wait gdb connection to port\n"
4066            "-p port         set gdb connection port [default=%s]\n"
4067            "-d item1,...    output log to %s (use -d ? for a list of log items)\n"
4068            "-hdachs c,h,s[,t]\n"
4069            "                force hard disk 0 physical geometry and the optional BIOS\n"
4070            "                translation (t=none or lba) (usually qemu can guess them)\n"
4071            "-L path         set the directory for the BIOS, VGA BIOS and keymaps\n"
4072            "-bios file      set the filename for the BIOS\n"
4073 #ifdef USE_KQEMU
4074            "-kernel-kqemu   enable KQEMU full virtualization (default is user mode only)\n"
4075            "-no-kqemu       disable KQEMU kernel module usage\n"
4076 #endif
4077 #ifdef CONFIG_KVM
4078            "-enable-kvm     enable KVM full virtualization support\n"
4079 #endif
4080            "-no-reboot      exit instead of rebooting\n"
4081            "-no-shutdown    stop before shutdown\n"
4082            "-loadvm [tag|id]\n"
4083            "                start right away with a saved state (loadvm in monitor)\n"
4084 #ifndef _WIN32
4085            "-daemonize      daemonize QEMU after initializing\n"
4086 #endif
4087            "-option-rom rom load a file, rom, into the option ROM space\n"
4088 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4089            "-prom-env variable=value\n"
4090            "                set OpenBIOS nvram variables\n"
4091 #endif
4092            "-clock          force the use of the given methods for timer alarm.\n"
4093            "                To see what timers are available use -clock ?\n"
4094            "-localtime      set the real time clock to local time [default=utc]\n"
4095            "-startdate      select initial date of the clock\n"
4096            "-icount [N|auto]\n"
4097            "                enable virtual instruction counter with 2^N clock ticks per instruction\n"
4098            "-echr chr       set terminal escape character instead of ctrl-a\n"
4099            "-virtioconsole c\n"
4100            "                set virtio console\n"
4101            "-show-cursor    show cursor\n"
4102 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4103            "-semihosting    semihosting mode\n"
4104 #endif
4105 #if defined(TARGET_ARM)
4106            "-old-param      old param mode\n"
4107 #endif
4108            "-tb-size n      set TB size\n"
4109            "-incoming p     prepare for incoming migration, listen on port p\n"
4110 #ifndef _WIN32
4111            "-chroot dir     Chroot to dir just before starting the VM.\n"
4112            "-runas user     Change to user id user just before starting the VM.\n"
4113 #endif
4114            "\n"
4115            "During emulation, the following keys are useful:\n"
4116            "ctrl-alt-f      toggle full screen\n"
4117            "ctrl-alt-n      switch to virtual console 'n'\n"
4118            "ctrl-alt        toggle mouse and keyboard grab\n"
4119            "\n"
4120            "When using -nographic, press 'ctrl-a h' to get some help.\n"
4121            ,
4122            "qemu",
4123            DEFAULT_RAM_SIZE,
4124 #ifndef _WIN32
4125            DEFAULT_NETWORK_SCRIPT,
4126            DEFAULT_NETWORK_DOWN_SCRIPT,
4127 #endif
4128            DEFAULT_GDBSTUB_PORT,
4129            "/tmp/qemu.log");
4130     exit(exitcode);
4131 }
4132
4133 #define HAS_ARG 0x0001
4134
4135 enum {
4136     /* Please keep in synch with help, qemu_options[] and
4137        qemu-doc.texi */
4138     /* Standard options: */
4139     QEMU_OPTION_h,
4140     QEMU_OPTION_M,
4141     QEMU_OPTION_cpu,
4142     QEMU_OPTION_smp,
4143     QEMU_OPTION_fda,
4144     QEMU_OPTION_fdb,
4145     QEMU_OPTION_hda,
4146     QEMU_OPTION_hdb,
4147     QEMU_OPTION_hdc,
4148     QEMU_OPTION_hdd,
4149     QEMU_OPTION_cdrom,
4150     QEMU_OPTION_drive,
4151     QEMU_OPTION_mtdblock,
4152     QEMU_OPTION_sd,
4153     QEMU_OPTION_pflash,
4154     QEMU_OPTION_boot,
4155     QEMU_OPTION_snapshot,
4156     QEMU_OPTION_m,
4157     QEMU_OPTION_k,
4158     QEMU_OPTION_audio_help,
4159     QEMU_OPTION_soundhw,
4160     QEMU_OPTION_usb,
4161     QEMU_OPTION_usbdevice,
4162     QEMU_OPTION_name,
4163     QEMU_OPTION_uuid,
4164
4165     /* Display options: */
4166     QEMU_OPTION_nographic,
4167     QEMU_OPTION_curses,
4168     QEMU_OPTION_no_frame,
4169     QEMU_OPTION_alt_grab,
4170     QEMU_OPTION_no_quit,
4171     QEMU_OPTION_sdl,
4172     QEMU_OPTION_portrait,
4173     QEMU_OPTION_vga,
4174     QEMU_OPTION_full_screen,
4175     QEMU_OPTION_g,
4176     QEMU_OPTION_vnc,
4177
4178     /* Network options: */
4179     QEMU_OPTION_net,
4180     QEMU_OPTION_tftp,
4181     QEMU_OPTION_bootp,
4182     QEMU_OPTION_smb,
4183     QEMU_OPTION_redir,
4184     QEMU_OPTION_bt,
4185
4186     /* i386 target only: */
4187     QEMU_OPTION_win2k_hack,
4188     QEMU_OPTION_rtc_td_hack,
4189     QEMU_OPTION_no_fd_bootchk,
4190     QEMU_OPTION_no_acpi,
4191     QEMU_OPTION_no_hpet,
4192     QEMU_OPTION_acpitable,
4193
4194     /* Linux boot specific: */
4195     QEMU_OPTION_kernel,
4196     QEMU_OPTION_append,
4197     QEMU_OPTION_initrd,
4198
4199     /* Debug/Expert options: */
4200     QEMU_OPTION_serial,
4201     QEMU_OPTION_parallel,
4202     QEMU_OPTION_monitor,
4203     QEMU_OPTION_pidfile,
4204     QEMU_OPTION_S,
4205     QEMU_OPTION_s,
4206     QEMU_OPTION_p,
4207     QEMU_OPTION_d,
4208     QEMU_OPTION_hdachs,
4209     QEMU_OPTION_L,
4210     QEMU_OPTION_bios,
4211     QEMU_OPTION_kernel_kqemu,
4212     QEMU_OPTION_no_kqemu,
4213     QEMU_OPTION_enable_kvm,
4214     QEMU_OPTION_no_reboot,
4215     QEMU_OPTION_no_shutdown,
4216     QEMU_OPTION_loadvm,
4217     QEMU_OPTION_daemonize,
4218     QEMU_OPTION_option_rom,
4219     QEMU_OPTION_prom_env,
4220     QEMU_OPTION_clock,
4221     QEMU_OPTION_localtime,
4222     QEMU_OPTION_startdate,
4223     QEMU_OPTION_icount,
4224     QEMU_OPTION_echr,
4225     QEMU_OPTION_virtiocon,
4226     QEMU_OPTION_show_cursor,
4227     QEMU_OPTION_semihosting,
4228     QEMU_OPTION_old_param,
4229     QEMU_OPTION_tb_size,
4230     QEMU_OPTION_incoming,
4231     QEMU_OPTION_chroot,
4232     QEMU_OPTION_runas,
4233 };
4234
4235 typedef struct QEMUOption {
4236     const char *name;
4237     int flags;
4238     int index;
4239 } QEMUOption;
4240
4241 static const QEMUOption qemu_options[] = {
4242     /* Please keep in synch with help, QEMU_OPTION_ enums, and
4243        qemu-doc.texi */
4244     /* Standard options: */
4245     { "h", 0, QEMU_OPTION_h },
4246     { "help", 0, QEMU_OPTION_h },
4247     { "M", HAS_ARG, QEMU_OPTION_M },
4248     { "cpu", HAS_ARG, QEMU_OPTION_cpu },
4249     { "smp", HAS_ARG, QEMU_OPTION_smp },
4250     { "fda", HAS_ARG, QEMU_OPTION_fda },
4251     { "fdb", HAS_ARG, QEMU_OPTION_fdb },
4252     { "hda", HAS_ARG, QEMU_OPTION_hda },
4253     { "hdb", HAS_ARG, QEMU_OPTION_hdb },
4254     { "hdc", HAS_ARG, QEMU_OPTION_hdc },
4255     { "hdd", HAS_ARG, QEMU_OPTION_hdd },
4256     { "cdrom", HAS_ARG, QEMU_OPTION_cdrom },
4257     { "drive", HAS_ARG, QEMU_OPTION_drive },
4258     { "mtdblock", HAS_ARG, QEMU_OPTION_mtdblock },
4259     { "sd", HAS_ARG, QEMU_OPTION_sd },
4260     { "pflash", HAS_ARG, QEMU_OPTION_pflash },
4261     { "boot", HAS_ARG, QEMU_OPTION_boot },
4262     { "snapshot", 0, QEMU_OPTION_snapshot },
4263     { "m", HAS_ARG, QEMU_OPTION_m },
4264 #ifndef _WIN32
4265     { "k", HAS_ARG, QEMU_OPTION_k },
4266 #endif
4267 #ifdef HAS_AUDIO
4268     { "audio-help", 0, QEMU_OPTION_audio_help },
4269     { "soundhw", HAS_ARG, QEMU_OPTION_soundhw },
4270 #endif
4271     { "usb", 0, QEMU_OPTION_usb },
4272     { "usbdevice", HAS_ARG, QEMU_OPTION_usbdevice },
4273     { "name", HAS_ARG, QEMU_OPTION_name },
4274     { "uuid", HAS_ARG, QEMU_OPTION_uuid },
4275
4276     /* Display options: */
4277     { "nographic", 0, QEMU_OPTION_nographic },
4278 #ifdef CONFIG_CURSES
4279     { "curses", 0, QEMU_OPTION_curses },
4280 #endif
4281 #ifdef CONFIG_SDL
4282     { "no-frame", 0, QEMU_OPTION_no_frame },
4283     { "alt-grab", 0, QEMU_OPTION_alt_grab },
4284     { "no-quit", 0, QEMU_OPTION_no_quit },
4285     { "sdl", 0, QEMU_OPTION_sdl },
4286 #endif
4287     { "portrait", 0, QEMU_OPTION_portrait },
4288     { "vga", HAS_ARG, QEMU_OPTION_vga },
4289     { "full-screen", 0, QEMU_OPTION_full_screen },
4290 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4291     { "g", 1, QEMU_OPTION_g },
4292 #endif
4293     { "vnc", HAS_ARG, QEMU_OPTION_vnc },
4294
4295     /* Network options: */
4296     { "net", HAS_ARG, QEMU_OPTION_net},
4297 #ifdef CONFIG_SLIRP
4298     { "tftp", HAS_ARG, QEMU_OPTION_tftp },
4299     { "bootp", HAS_ARG, QEMU_OPTION_bootp },
4300 #ifndef _WIN32
4301     { "smb", HAS_ARG, QEMU_OPTION_smb },
4302 #endif
4303     { "redir", HAS_ARG, QEMU_OPTION_redir },
4304 #endif
4305     { "bt", HAS_ARG, QEMU_OPTION_bt },
4306 #ifdef TARGET_I386
4307     /* i386 target only: */
4308     { "win2k-hack", 0, QEMU_OPTION_win2k_hack },
4309     { "rtc-td-hack", 0, QEMU_OPTION_rtc_td_hack },
4310     { "no-fd-bootchk", 0, QEMU_OPTION_no_fd_bootchk },
4311     { "no-acpi", 0, QEMU_OPTION_no_acpi },
4312     { "no-hpet", 0, QEMU_OPTION_no_hpet },
4313     { "acpitable", HAS_ARG, QEMU_OPTION_acpitable },
4314 #endif
4315
4316     /* Linux boot specific: */
4317     { "kernel", HAS_ARG, QEMU_OPTION_kernel },
4318     { "append", HAS_ARG, QEMU_OPTION_append },
4319     { "initrd", HAS_ARG, QEMU_OPTION_initrd },
4320
4321     /* Debug/Expert options: */
4322     { "serial", HAS_ARG, QEMU_OPTION_serial },
4323     { "parallel", HAS_ARG, QEMU_OPTION_parallel },
4324     { "monitor", HAS_ARG, QEMU_OPTION_monitor },
4325     { "pidfile", HAS_ARG, QEMU_OPTION_pidfile },
4326     { "S", 0, QEMU_OPTION_S },
4327     { "s", 0, QEMU_OPTION_s },
4328     { "p", HAS_ARG, QEMU_OPTION_p },
4329     { "d", HAS_ARG, QEMU_OPTION_d },
4330     { "hdachs", HAS_ARG, QEMU_OPTION_hdachs },
4331     { "L", HAS_ARG, QEMU_OPTION_L },
4332     { "bios", HAS_ARG, QEMU_OPTION_bios },
4333 #ifdef USE_KQEMU
4334     { "kernel-kqemu", 0, QEMU_OPTION_kernel_kqemu },
4335     { "no-kqemu", 0, QEMU_OPTION_no_kqemu },
4336 #endif
4337 #ifdef CONFIG_KVM
4338     { "enable-kvm", 0, QEMU_OPTION_enable_kvm },
4339 #endif
4340     { "no-reboot", 0, QEMU_OPTION_no_reboot },
4341     { "no-shutdown", 0, QEMU_OPTION_no_shutdown },
4342     { "loadvm", HAS_ARG, QEMU_OPTION_loadvm },
4343     { "daemonize", 0, QEMU_OPTION_daemonize },
4344     { "option-rom", HAS_ARG, QEMU_OPTION_option_rom },
4345 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
4346     { "prom-env", HAS_ARG, QEMU_OPTION_prom_env },
4347 #endif
4348     { "clock", HAS_ARG, QEMU_OPTION_clock },
4349     { "localtime", 0, QEMU_OPTION_localtime },
4350     { "startdate", HAS_ARG, QEMU_OPTION_startdate },
4351     { "icount", HAS_ARG, QEMU_OPTION_icount },
4352     { "echr", HAS_ARG, QEMU_OPTION_echr },
4353     { "virtioconsole", HAS_ARG, QEMU_OPTION_virtiocon },
4354     { "show-cursor", 0, QEMU_OPTION_show_cursor },
4355 #if defined(TARGET_ARM) || defined(TARGET_M68K)
4356     { "semihosting", 0, QEMU_OPTION_semihosting },
4357 #endif
4358 #if defined(TARGET_ARM)
4359     { "old-param", 0, QEMU_OPTION_old_param },
4360 #endif
4361     { "tb-size", HAS_ARG, QEMU_OPTION_tb_size },
4362     { "incoming", HAS_ARG, QEMU_OPTION_incoming },
4363     { "chroot", HAS_ARG, QEMU_OPTION_chroot },
4364     { "runas", HAS_ARG, QEMU_OPTION_runas },
4365     { NULL },
4366 };
4367
4368 #ifdef HAS_AUDIO
4369 struct soundhw soundhw[] = {
4370 #ifdef HAS_AUDIO_CHOICE
4371 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4372     {
4373         "pcspk",
4374         "PC speaker",
4375         0,
4376         1,
4377         { .init_isa = pcspk_audio_init }
4378     },
4379 #endif
4380
4381 #ifdef CONFIG_SB16
4382     {
4383         "sb16",
4384         "Creative Sound Blaster 16",
4385         0,
4386         1,
4387         { .init_isa = SB16_init }
4388     },
4389 #endif
4390
4391 #ifdef CONFIG_CS4231A
4392     {
4393         "cs4231a",
4394         "CS4231A",
4395         0,
4396         1,
4397         { .init_isa = cs4231a_init }
4398     },
4399 #endif
4400
4401 #ifdef CONFIG_ADLIB
4402     {
4403         "adlib",
4404 #ifdef HAS_YMF262
4405         "Yamaha YMF262 (OPL3)",
4406 #else
4407         "Yamaha YM3812 (OPL2)",
4408 #endif
4409         0,
4410         1,
4411         { .init_isa = Adlib_init }
4412     },
4413 #endif
4414
4415 #ifdef CONFIG_GUS
4416     {
4417         "gus",
4418         "Gravis Ultrasound GF1",
4419         0,
4420         1,
4421         { .init_isa = GUS_init }
4422     },
4423 #endif
4424
4425 #ifdef CONFIG_AC97
4426     {
4427         "ac97",
4428         "Intel 82801AA AC97 Audio",
4429         0,
4430         0,
4431         { .init_pci = ac97_init }
4432     },
4433 #endif
4434
4435 #ifdef CONFIG_ES1370
4436     {
4437         "es1370",
4438         "ENSONIQ AudioPCI ES1370",
4439         0,
4440         0,
4441         { .init_pci = es1370_init }
4442     },
4443 #endif
4444
4445 #endif /* HAS_AUDIO_CHOICE */
4446
4447     { NULL, NULL, 0, 0, { NULL } }
4448 };
4449
4450 static void select_soundhw (const char *optarg)
4451 {
4452     struct soundhw *c;
4453
4454     if (*optarg == '?') {
4455     show_valid_cards:
4456
4457         printf ("Valid sound card names (comma separated):\n");
4458         for (c = soundhw; c->name; ++c) {
4459             printf ("%-11s %s\n", c->name, c->descr);
4460         }
4461         printf ("\n-soundhw all will enable all of the above\n");
4462         exit (*optarg != '?');
4463     }
4464     else {
4465         size_t l;
4466         const char *p;
4467         char *e;
4468         int bad_card = 0;
4469
4470         if (!strcmp (optarg, "all")) {
4471             for (c = soundhw; c->name; ++c) {
4472                 c->enabled = 1;
4473             }
4474             return;
4475         }
4476
4477         p = optarg;
4478         while (*p) {
4479             e = strchr (p, ',');
4480             l = !e ? strlen (p) : (size_t) (e - p);
4481
4482             for (c = soundhw; c->name; ++c) {
4483                 if (!strncmp (c->name, p, l)) {
4484                     c->enabled = 1;
4485                     break;
4486                 }
4487             }
4488
4489             if (!c->name) {
4490                 if (l > 80) {
4491                     fprintf (stderr,
4492                              "Unknown sound card name (too big to show)\n");
4493                 }
4494                 else {
4495                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4496                              (int) l, p);
4497                 }
4498                 bad_card = 1;
4499             }
4500             p += l + (e != NULL);
4501         }
4502
4503         if (bad_card)
4504             goto show_valid_cards;
4505     }
4506 }
4507 #endif
4508
4509 static void select_vgahw (const char *p)
4510 {
4511     const char *opts;
4512
4513     if (strstart(p, "std", &opts)) {
4514         std_vga_enabled = 1;
4515         cirrus_vga_enabled = 0;
4516         vmsvga_enabled = 0;
4517     } else if (strstart(p, "cirrus", &opts)) {
4518         cirrus_vga_enabled = 1;
4519         std_vga_enabled = 0;
4520         vmsvga_enabled = 0;
4521     } else if (strstart(p, "vmware", &opts)) {
4522         cirrus_vga_enabled = 0;
4523         std_vga_enabled = 0;
4524         vmsvga_enabled = 1;
4525     } else if (strstart(p, "none", &opts)) {
4526         cirrus_vga_enabled = 0;
4527         std_vga_enabled = 0;
4528         vmsvga_enabled = 0;
4529     } else {
4530     invalid_vga:
4531         fprintf(stderr, "Unknown vga type: %s\n", p);
4532         exit(1);
4533     }
4534     while (*opts) {
4535         const char *nextopt;
4536
4537         if (strstart(opts, ",retrace=", &nextopt)) {
4538             opts = nextopt;
4539             if (strstart(opts, "dumb", &nextopt))
4540                 vga_retrace_method = VGA_RETRACE_DUMB;
4541             else if (strstart(opts, "precise", &nextopt))
4542                 vga_retrace_method = VGA_RETRACE_PRECISE;
4543             else goto invalid_vga;
4544         } else goto invalid_vga;
4545         opts = nextopt;
4546     }
4547 }
4548
4549 #ifdef _WIN32
4550 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4551 {
4552     exit(STATUS_CONTROL_C_EXIT);
4553     return TRUE;
4554 }
4555 #endif
4556
4557 static int qemu_uuid_parse(const char *str, uint8_t *uuid)
4558 {
4559     int ret;
4560
4561     if(strlen(str) != 36)
4562         return -1;
4563
4564     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4565             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4566             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4567
4568     if(ret != 16)
4569         return -1;
4570
4571     return 0;
4572 }
4573
4574 #define MAX_NET_CLIENTS 32
4575
4576 #ifndef _WIN32
4577
4578 static void termsig_handler(int signal)
4579 {
4580     qemu_system_shutdown_request();
4581 }
4582
4583 static void termsig_setup(void)
4584 {
4585     struct sigaction act;
4586
4587     memset(&act, 0, sizeof(act));
4588     act.sa_handler = termsig_handler;
4589     sigaction(SIGINT,  &act, NULL);
4590     sigaction(SIGHUP,  &act, NULL);
4591     sigaction(SIGTERM, &act, NULL);
4592 }
4593
4594 #endif
4595
4596 int main(int argc, char **argv, char **envp)
4597 {
4598 #ifdef CONFIG_GDBSTUB
4599     int use_gdbstub;
4600     const char *gdbstub_port;
4601 #endif
4602     uint32_t boot_devices_bitmap = 0;
4603     int i;
4604     int snapshot, linux_boot, net_boot;
4605     const char *initrd_filename;
4606     const char *kernel_filename, *kernel_cmdline;
4607     const char *boot_devices = "";
4608     DisplayState *ds;
4609     DisplayChangeListener *dcl;
4610     int cyls, heads, secs, translation;
4611     const char *net_clients[MAX_NET_CLIENTS];
4612     int nb_net_clients;
4613     const char *bt_opts[MAX_BT_CMDLINE];
4614     int nb_bt_opts;
4615     int hda_index;
4616     int optind;
4617     const char *r, *optarg;
4618     CharDriverState *monitor_hd = NULL;
4619     const char *monitor_device;
4620     const char *serial_devices[MAX_SERIAL_PORTS];
4621     int serial_device_index;
4622     const char *parallel_devices[MAX_PARALLEL_PORTS];
4623     int parallel_device_index;
4624     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4625     int virtio_console_index;
4626     const char *loadvm = NULL;
4627     QEMUMachine *machine;
4628     const char *cpu_model;
4629     const char *usb_devices[MAX_USB_CMDLINE];
4630     int usb_devices_index;
4631     int fds[2];
4632     int tb_size;
4633     const char *pid_file = NULL;
4634     const char *incoming = NULL;
4635     int fd = 0;
4636     struct passwd *pwd = NULL;
4637     const char *chroot_dir = NULL;
4638     const char *run_as = NULL;
4639
4640     qemu_cache_utils_init(envp);
4641
4642     LIST_INIT (&vm_change_state_head);
4643 #ifndef _WIN32
4644     {
4645         struct sigaction act;
4646         sigfillset(&act.sa_mask);
4647         act.sa_flags = 0;
4648         act.sa_handler = SIG_IGN;
4649         sigaction(SIGPIPE, &act, NULL);
4650     }
4651 #else
4652     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4653     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4654        QEMU to run on a single CPU */
4655     {
4656         HANDLE h;
4657         DWORD mask, smask;
4658         int i;
4659         h = GetCurrentProcess();
4660         if (GetProcessAffinityMask(h, &mask, &smask)) {
4661             for(i = 0; i < 32; i++) {
4662                 if (mask & (1 << i))
4663                     break;
4664             }
4665             if (i != 32) {
4666                 mask = 1 << i;
4667                 SetProcessAffinityMask(h, mask);
4668             }
4669         }
4670     }
4671 #endif
4672
4673     register_machines();
4674     machine = first_machine;
4675     cpu_model = NULL;
4676     initrd_filename = NULL;
4677     ram_size = 0;
4678     vga_ram_size = VGA_RAM_SIZE;
4679 #ifdef CONFIG_GDBSTUB
4680     use_gdbstub = 0;
4681     gdbstub_port = DEFAULT_GDBSTUB_PORT;
4682 #endif
4683     snapshot = 0;
4684     nographic = 0;
4685     curses = 0;
4686     kernel_filename = NULL;
4687     kernel_cmdline = "";
4688     cyls = heads = secs = 0;
4689     translation = BIOS_ATA_TRANSLATION_AUTO;
4690     monitor_device = "vc:80Cx24C";
4691
4692     serial_devices[0] = "vc:80Cx24C";
4693     for(i = 1; i < MAX_SERIAL_PORTS; i++)
4694         serial_devices[i] = NULL;
4695     serial_device_index = 0;
4696
4697     parallel_devices[0] = "vc:80Cx24C";
4698     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4699         parallel_devices[i] = NULL;
4700     parallel_device_index = 0;
4701
4702     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4703         virtio_consoles[i] = NULL;
4704     virtio_console_index = 0;
4705
4706     usb_devices_index = 0;
4707
4708     nb_net_clients = 0;
4709     nb_bt_opts = 0;
4710     nb_drives = 0;
4711     nb_drives_opt = 0;
4712     hda_index = -1;
4713
4714     nb_nics = 0;
4715
4716     tb_size = 0;
4717     autostart= 1;
4718
4719     optind = 1;
4720     for(;;) {
4721         if (optind >= argc)
4722             break;
4723         r = argv[optind];
4724         if (r[0] != '-') {
4725             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4726         } else {
4727             const QEMUOption *popt;
4728
4729             optind++;
4730             /* Treat --foo the same as -foo.  */
4731             if (r[1] == '-')
4732                 r++;
4733             popt = qemu_options;
4734             for(;;) {
4735                 if (!popt->name) {
4736                     fprintf(stderr, "%s: invalid option -- '%s'\n",
4737                             argv[0], r);
4738                     exit(1);
4739                 }
4740                 if (!strcmp(popt->name, r + 1))
4741                     break;
4742                 popt++;
4743             }
4744             if (popt->flags & HAS_ARG) {
4745                 if (optind >= argc) {
4746                     fprintf(stderr, "%s: option '%s' requires an argument\n",
4747                             argv[0], r);
4748                     exit(1);
4749                 }
4750                 optarg = argv[optind++];
4751             } else {
4752                 optarg = NULL;
4753             }
4754
4755             switch(popt->index) {
4756             case QEMU_OPTION_M:
4757                 machine = find_machine(optarg);
4758                 if (!machine) {
4759                     QEMUMachine *m;
4760                     printf("Supported machines are:\n");
4761                     for(m = first_machine; m != NULL; m = m->next) {
4762                         printf("%-10s %s%s\n",
4763                                m->name, m->desc,
4764                                m == first_machine ? " (default)" : "");
4765                     }
4766                     exit(*optarg != '?');
4767                 }
4768                 break;
4769             case QEMU_OPTION_cpu:
4770                 /* hw initialization will check this */
4771                 if (*optarg == '?') {
4772 /* XXX: implement xxx_cpu_list for targets that still miss it */
4773 #if defined(cpu_list)
4774                     cpu_list(stdout, &fprintf);
4775 #endif
4776                     exit(0);
4777                 } else {
4778                     cpu_model = optarg;
4779                 }
4780                 break;
4781             case QEMU_OPTION_initrd:
4782                 initrd_filename = optarg;
4783                 break;
4784             case QEMU_OPTION_hda:
4785                 if (cyls == 0)
4786                     hda_index = drive_add(optarg, HD_ALIAS, 0);
4787                 else
4788                     hda_index = drive_add(optarg, HD_ALIAS
4789                              ",cyls=%d,heads=%d,secs=%d%s",
4790                              0, cyls, heads, secs,
4791                              translation == BIOS_ATA_TRANSLATION_LBA ?
4792                                  ",trans=lba" :
4793                              translation == BIOS_ATA_TRANSLATION_NONE ?
4794                                  ",trans=none" : "");
4795                  break;
4796             case QEMU_OPTION_hdb:
4797             case QEMU_OPTION_hdc:
4798             case QEMU_OPTION_hdd:
4799                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4800                 break;
4801             case QEMU_OPTION_drive:
4802                 drive_add(NULL, "%s", optarg);
4803                 break;
4804             case QEMU_OPTION_mtdblock:
4805                 drive_add(optarg, MTD_ALIAS);
4806                 break;
4807             case QEMU_OPTION_sd:
4808                 drive_add(optarg, SD_ALIAS);
4809                 break;
4810             case QEMU_OPTION_pflash:
4811                 drive_add(optarg, PFLASH_ALIAS);
4812                 break;
4813             case QEMU_OPTION_snapshot:
4814                 snapshot = 1;
4815                 break;
4816             case QEMU_OPTION_hdachs:
4817                 {
4818                     const char *p;
4819                     p = optarg;
4820                     cyls = strtol(p, (char **)&p, 0);
4821                     if (cyls < 1 || cyls > 16383)
4822                         goto chs_fail;
4823                     if (*p != ',')
4824                         goto chs_fail;
4825                     p++;
4826                     heads = strtol(p, (char **)&p, 0);
4827                     if (heads < 1 || heads > 16)
4828                         goto chs_fail;
4829                     if (*p != ',')
4830                         goto chs_fail;
4831                     p++;
4832                     secs = strtol(p, (char **)&p, 0);
4833                     if (secs < 1 || secs > 63)
4834                         goto chs_fail;
4835                     if (*p == ',') {
4836                         p++;
4837                         if (!strcmp(p, "none"))
4838                             translation = BIOS_ATA_TRANSLATION_NONE;
4839                         else if (!strcmp(p, "lba"))
4840                             translation = BIOS_ATA_TRANSLATION_LBA;
4841                         else if (!strcmp(p, "auto"))
4842                             translation = BIOS_ATA_TRANSLATION_AUTO;
4843                         else
4844                             goto chs_fail;
4845                     } else if (*p != '\0') {
4846                     chs_fail:
4847                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4848                         exit(1);
4849                     }
4850                     if (hda_index != -1)
4851                         snprintf(drives_opt[hda_index].opt,
4852                                  sizeof(drives_opt[hda_index].opt),
4853                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4854                                  0, cyls, heads, secs,
4855                                  translation == BIOS_ATA_TRANSLATION_LBA ?
4856                                     ",trans=lba" :
4857                                  translation == BIOS_ATA_TRANSLATION_NONE ?
4858                                      ",trans=none" : "");
4859                 }
4860                 break;
4861             case QEMU_OPTION_nographic:
4862                 nographic = 1;
4863                 break;
4864 #ifdef CONFIG_CURSES
4865             case QEMU_OPTION_curses:
4866                 curses = 1;
4867                 break;
4868 #endif
4869             case QEMU_OPTION_portrait:
4870                 graphic_rotate = 1;
4871                 break;
4872             case QEMU_OPTION_kernel:
4873                 kernel_filename = optarg;
4874                 break;
4875             case QEMU_OPTION_append:
4876                 kernel_cmdline = optarg;
4877                 break;
4878             case QEMU_OPTION_cdrom:
4879                 drive_add(optarg, CDROM_ALIAS);
4880                 break;
4881             case QEMU_OPTION_boot:
4882                 boot_devices = optarg;
4883                 /* We just do some generic consistency checks */
4884                 {
4885                     /* Could easily be extended to 64 devices if needed */
4886                     const char *p;
4887
4888                     boot_devices_bitmap = 0;
4889                     for (p = boot_devices; *p != '\0'; p++) {
4890                         /* Allowed boot devices are:
4891                          * a b     : floppy disk drives
4892                          * c ... f : IDE disk drives
4893                          * g ... m : machine implementation dependant drives
4894                          * n ... p : network devices
4895                          * It's up to each machine implementation to check
4896                          * if the given boot devices match the actual hardware
4897                          * implementation and firmware features.
4898                          */
4899                         if (*p < 'a' || *p > 'q') {
4900                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
4901                             exit(1);
4902                         }
4903                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4904                             fprintf(stderr,
4905                                     "Boot device '%c' was given twice\n",*p);
4906                             exit(1);
4907                         }
4908                         boot_devices_bitmap |= 1 << (*p - 'a');
4909                     }
4910                 }
4911                 break;
4912             case QEMU_OPTION_fda:
4913             case QEMU_OPTION_fdb:
4914                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4915                 break;
4916 #ifdef TARGET_I386
4917             case QEMU_OPTION_no_fd_bootchk:
4918                 fd_bootchk = 0;
4919                 break;
4920 #endif
4921             case QEMU_OPTION_net:
4922                 if (nb_net_clients >= MAX_NET_CLIENTS) {
4923                     fprintf(stderr, "qemu: too many network clients\n");
4924                     exit(1);
4925                 }
4926                 net_clients[nb_net_clients] = optarg;
4927                 nb_net_clients++;
4928                 break;
4929 #ifdef CONFIG_SLIRP
4930             case QEMU_OPTION_tftp:
4931                 tftp_prefix = optarg;
4932                 break;
4933             case QEMU_OPTION_bootp:
4934                 bootp_filename = optarg;
4935                 break;
4936 #ifndef _WIN32
4937             case QEMU_OPTION_smb:
4938                 net_slirp_smb(optarg);
4939                 break;
4940 #endif
4941             case QEMU_OPTION_redir:
4942                 net_slirp_redir(optarg);
4943                 break;
4944 #endif
4945             case QEMU_OPTION_bt:
4946                 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4947                     fprintf(stderr, "qemu: too many bluetooth options\n");
4948                     exit(1);
4949                 }
4950                 bt_opts[nb_bt_opts++] = optarg;
4951                 break;
4952 #ifdef HAS_AUDIO
4953             case QEMU_OPTION_audio_help:
4954                 AUD_help ();
4955                 exit (0);
4956                 break;
4957             case QEMU_OPTION_soundhw:
4958                 select_soundhw (optarg);
4959                 break;
4960 #endif
4961             case QEMU_OPTION_h:
4962                 help(0);
4963                 break;
4964             case QEMU_OPTION_m: {
4965                 uint64_t value;
4966                 char *ptr;
4967
4968                 value = strtoul(optarg, &ptr, 10);
4969                 switch (*ptr) {
4970                 case 0: case 'M': case 'm':
4971                     value <<= 20;
4972                     break;
4973                 case 'G': case 'g':
4974                     value <<= 30;
4975                     break;
4976                 default:
4977                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4978                     exit(1);
4979                 }
4980
4981                 /* On 32-bit hosts, QEMU is limited by virtual address space */
4982                 if (value > (2047 << 20)
4983 #ifndef USE_KQEMU
4984                     && HOST_LONG_BITS == 32
4985 #endif
4986                     ) {
4987                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4988                     exit(1);
4989                 }
4990                 if (value != (uint64_t)(ram_addr_t)value) {
4991                     fprintf(stderr, "qemu: ram size too large\n");
4992                     exit(1);
4993                 }
4994                 ram_size = value;
4995                 break;
4996             }
4997             case QEMU_OPTION_d:
4998                 {
4999                     int mask;
5000                     const CPULogItem *item;
5001
5002                     mask = cpu_str_to_log_mask(optarg);
5003                     if (!mask) {
5004                         printf("Log items (comma separated):\n");
5005                     for(item = cpu_log_items; item->mask != 0; item++) {
5006                         printf("%-10s %s\n", item->name, item->help);
5007                     }
5008                     exit(1);
5009                     }
5010                     cpu_set_log(mask);
5011                 }
5012                 break;
5013 #ifdef CONFIG_GDBSTUB
5014             case QEMU_OPTION_s:
5015                 use_gdbstub = 1;
5016                 break;
5017             case QEMU_OPTION_p:
5018                 gdbstub_port = optarg;
5019                 break;
5020 #endif
5021             case QEMU_OPTION_L:
5022                 bios_dir = optarg;
5023                 break;
5024             case QEMU_OPTION_bios:
5025                 bios_name = optarg;
5026                 break;
5027             case QEMU_OPTION_S:
5028                 autostart = 0;
5029                 break;
5030             case QEMU_OPTION_k:
5031                 keyboard_layout = optarg;
5032                 break;
5033             case QEMU_OPTION_localtime:
5034                 rtc_utc = 0;
5035                 break;
5036             case QEMU_OPTION_vga:
5037                 select_vgahw (optarg);
5038                 break;
5039             case QEMU_OPTION_g:
5040                 {
5041                     const char *p;
5042                     int w, h, depth;
5043                     p = optarg;
5044                     w = strtol(p, (char **)&p, 10);
5045                     if (w <= 0) {
5046                     graphic_error:
5047                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5048                         exit(1);
5049                     }
5050                     if (*p != 'x')
5051                         goto graphic_error;
5052                     p++;
5053                     h = strtol(p, (char **)&p, 10);
5054                     if (h <= 0)
5055                         goto graphic_error;
5056                     if (*p == 'x') {
5057                         p++;
5058                         depth = strtol(p, (char **)&p, 10);
5059                         if (depth != 8 && depth != 15 && depth != 16 &&
5060                             depth != 24 && depth != 32)
5061                             goto graphic_error;
5062                     } else if (*p == '\0') {
5063                         depth = graphic_depth;
5064                     } else {
5065                         goto graphic_error;
5066                     }
5067
5068                     graphic_width = w;
5069                     graphic_height = h;
5070                     graphic_depth = depth;
5071                 }
5072                 break;
5073             case QEMU_OPTION_echr:
5074                 {
5075                     char *r;
5076                     term_escape_char = strtol(optarg, &r, 0);
5077                     if (r == optarg)
5078                         printf("Bad argument to echr\n");
5079                     break;
5080                 }
5081             case QEMU_OPTION_monitor:
5082                 monitor_device = optarg;
5083                 break;
5084             case QEMU_OPTION_serial:
5085                 if (serial_device_index >= MAX_SERIAL_PORTS) {
5086                     fprintf(stderr, "qemu: too many serial ports\n");
5087                     exit(1);
5088                 }
5089                 serial_devices[serial_device_index] = optarg;
5090                 serial_device_index++;
5091                 break;
5092             case QEMU_OPTION_virtiocon:
5093                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5094                     fprintf(stderr, "qemu: too many virtio consoles\n");
5095                     exit(1);
5096                 }
5097                 virtio_consoles[virtio_console_index] = optarg;
5098                 virtio_console_index++;
5099                 break;
5100             case QEMU_OPTION_parallel:
5101                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5102                     fprintf(stderr, "qemu: too many parallel ports\n");
5103                     exit(1);
5104                 }
5105                 parallel_devices[parallel_device_index] = optarg;
5106                 parallel_device_index++;
5107                 break;
5108             case QEMU_OPTION_loadvm:
5109                 loadvm = optarg;
5110                 break;
5111             case QEMU_OPTION_full_screen:
5112                 full_screen = 1;
5113                 break;
5114 #ifdef CONFIG_SDL
5115             case QEMU_OPTION_no_frame:
5116                 no_frame = 1;
5117                 break;
5118             case QEMU_OPTION_alt_grab:
5119                 alt_grab = 1;
5120                 break;
5121             case QEMU_OPTION_no_quit:
5122                 no_quit = 1;
5123                 break;
5124             case QEMU_OPTION_sdl:
5125                 sdl = 1;
5126                 break;
5127 #endif
5128             case QEMU_OPTION_pidfile:
5129                 pid_file = optarg;
5130                 break;
5131 #ifdef TARGET_I386
5132             case QEMU_OPTION_win2k_hack:
5133                 win2k_install_hack = 1;
5134                 break;
5135             case QEMU_OPTION_rtc_td_hack:
5136                 rtc_td_hack = 1;
5137                 break;
5138             case QEMU_OPTION_acpitable:
5139                 if(acpi_table_add(optarg) < 0) {
5140                     fprintf(stderr, "Wrong acpi table provided\n");
5141                     exit(1);
5142                 }
5143                 break;
5144 #endif
5145 #ifdef USE_KQEMU
5146             case QEMU_OPTION_no_kqemu:
5147                 kqemu_allowed = 0;
5148                 break;
5149             case QEMU_OPTION_kernel_kqemu:
5150                 kqemu_allowed = 2;
5151                 break;
5152 #endif
5153 #ifdef CONFIG_KVM
5154             case QEMU_OPTION_enable_kvm:
5155                 kvm_allowed = 1;
5156 #ifdef USE_KQEMU
5157                 kqemu_allowed = 0;
5158 #endif
5159                 break;
5160 #endif
5161             case QEMU_OPTION_usb:
5162                 usb_enabled = 1;
5163                 break;
5164             case QEMU_OPTION_usbdevice:
5165                 usb_enabled = 1;
5166                 if (usb_devices_index >= MAX_USB_CMDLINE) {
5167                     fprintf(stderr, "Too many USB devices\n");
5168                     exit(1);
5169                 }
5170                 usb_devices[usb_devices_index] = optarg;
5171                 usb_devices_index++;
5172                 break;
5173             case QEMU_OPTION_smp:
5174                 smp_cpus = atoi(optarg);
5175                 if (smp_cpus < 1) {
5176                     fprintf(stderr, "Invalid number of CPUs\n");
5177                     exit(1);
5178                 }
5179                 break;
5180             case QEMU_OPTION_vnc:
5181                 vnc_display = optarg;
5182                 break;
5183             case QEMU_OPTION_no_acpi:
5184                 acpi_enabled = 0;
5185                 break;
5186             case QEMU_OPTION_no_hpet:
5187                 no_hpet = 1;
5188                 break;
5189             case QEMU_OPTION_no_reboot:
5190                 no_reboot = 1;
5191                 break;
5192             case QEMU_OPTION_no_shutdown:
5193                 no_shutdown = 1;
5194                 break;
5195             case QEMU_OPTION_show_cursor:
5196                 cursor_hide = 0;
5197                 break;
5198             case QEMU_OPTION_uuid:
5199                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5200                     fprintf(stderr, "Fail to parse UUID string."
5201                             " Wrong format.\n");
5202                     exit(1);
5203                 }
5204                 break;
5205             case QEMU_OPTION_daemonize:
5206                 daemonize = 1;
5207                 break;
5208             case QEMU_OPTION_option_rom:
5209                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5210                     fprintf(stderr, "Too many option ROMs\n");
5211                     exit(1);
5212                 }
5213                 option_rom[nb_option_roms] = optarg;
5214                 nb_option_roms++;
5215                 break;
5216             case QEMU_OPTION_semihosting:
5217                 semihosting_enabled = 1;
5218                 break;
5219             case QEMU_OPTION_name:
5220                 qemu_name = optarg;
5221                 break;
5222 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5223             case QEMU_OPTION_prom_env:
5224                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5225                     fprintf(stderr, "Too many prom variables\n");
5226                     exit(1);
5227                 }
5228                 prom_envs[nb_prom_envs] = optarg;
5229                 nb_prom_envs++;
5230                 break;
5231 #endif
5232 #ifdef TARGET_ARM
5233             case QEMU_OPTION_old_param:
5234                 old_param = 1;
5235                 break;
5236 #endif
5237             case QEMU_OPTION_clock:
5238                 configure_alarms(optarg);
5239                 break;
5240             case QEMU_OPTION_startdate:
5241                 {
5242                     struct tm tm;
5243                     time_t rtc_start_date;
5244                     if (!strcmp(optarg, "now")) {
5245                         rtc_date_offset = -1;
5246                     } else {
5247                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5248                                &tm.tm_year,
5249                                &tm.tm_mon,
5250                                &tm.tm_mday,
5251                                &tm.tm_hour,
5252                                &tm.tm_min,
5253                                &tm.tm_sec) == 6) {
5254                             /* OK */
5255                         } else if (sscanf(optarg, "%d-%d-%d",
5256                                           &tm.tm_year,
5257                                           &tm.tm_mon,
5258                                           &tm.tm_mday) == 3) {
5259                             tm.tm_hour = 0;
5260                             tm.tm_min = 0;
5261                             tm.tm_sec = 0;
5262                         } else {
5263                             goto date_fail;
5264                         }
5265                         tm.tm_year -= 1900;
5266                         tm.tm_mon--;
5267                         rtc_start_date = mktimegm(&tm);
5268                         if (rtc_start_date == -1) {
5269                         date_fail:
5270                             fprintf(stderr, "Invalid date format. Valid format are:\n"
5271                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5272                             exit(1);
5273                         }
5274                         rtc_date_offset = time(NULL) - rtc_start_date;
5275                     }
5276                 }
5277                 break;
5278             case QEMU_OPTION_tb_size:
5279                 tb_size = strtol(optarg, NULL, 0);
5280                 if (tb_size < 0)
5281                     tb_size = 0;
5282                 break;
5283             case QEMU_OPTION_icount:
5284                 use_icount = 1;
5285                 if (strcmp(optarg, "auto") == 0) {
5286                     icount_time_shift = -1;
5287                 } else {
5288                     icount_time_shift = strtol(optarg, NULL, 0);
5289                 }
5290                 break;
5291             case QEMU_OPTION_incoming:
5292                 incoming = optarg;
5293                 break;
5294             case QEMU_OPTION_chroot:
5295                 chroot_dir = optarg;
5296                 break;
5297             case QEMU_OPTION_runas:
5298                 run_as = optarg;
5299                 break;
5300             }
5301         }
5302     }
5303
5304 #if defined(CONFIG_KVM) && defined(USE_KQEMU)
5305     if (kvm_allowed && kqemu_allowed) {
5306         fprintf(stderr,
5307                 "You can not enable both KVM and kqemu at the same time\n");
5308         exit(1);
5309     }
5310 #endif
5311
5312     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5313     if (smp_cpus > machine->max_cpus) {
5314         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5315                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5316                 machine->max_cpus);
5317         exit(1);
5318     }
5319
5320     if (nographic) {
5321        if (serial_device_index == 0)
5322            serial_devices[0] = "stdio";
5323        if (parallel_device_index == 0)
5324            parallel_devices[0] = "null";
5325        if (strncmp(monitor_device, "vc", 2) == 0)
5326            monitor_device = "stdio";
5327     }
5328
5329 #ifndef _WIN32
5330     if (daemonize) {
5331         pid_t pid;
5332
5333         if (pipe(fds) == -1)
5334             exit(1);
5335
5336         pid = fork();
5337         if (pid > 0) {
5338             uint8_t status;
5339             ssize_t len;
5340
5341             close(fds[1]);
5342
5343         again:
5344             len = read(fds[0], &status, 1);
5345             if (len == -1 && (errno == EINTR))
5346                 goto again;
5347
5348             if (len != 1)
5349                 exit(1);
5350             else if (status == 1) {
5351                 fprintf(stderr, "Could not acquire pidfile\n");
5352                 exit(1);
5353             } else
5354                 exit(0);
5355         } else if (pid < 0)
5356             exit(1);
5357
5358         setsid();
5359
5360         pid = fork();
5361         if (pid > 0)
5362             exit(0);
5363         else if (pid < 0)
5364             exit(1);
5365
5366         umask(027);
5367
5368         signal(SIGTSTP, SIG_IGN);
5369         signal(SIGTTOU, SIG_IGN);
5370         signal(SIGTTIN, SIG_IGN);
5371     }
5372 #endif
5373
5374     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5375         if (daemonize) {
5376             uint8_t status = 1;
5377             write(fds[1], &status, 1);
5378         } else
5379             fprintf(stderr, "Could not acquire pid file\n");
5380         exit(1);
5381     }
5382
5383 #ifdef USE_KQEMU
5384     if (smp_cpus > 1)
5385         kqemu_allowed = 0;
5386 #endif
5387     linux_boot = (kernel_filename != NULL);
5388     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5389
5390     if (!linux_boot && net_boot == 0 &&
5391         !machine->nodisk_ok && nb_drives_opt == 0)
5392         help(1);
5393
5394     if (!linux_boot && *kernel_cmdline != '\0') {
5395         fprintf(stderr, "-append only allowed with -kernel option\n");
5396         exit(1);
5397     }
5398
5399     if (!linux_boot && initrd_filename != NULL) {
5400         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5401         exit(1);
5402     }
5403
5404     /* boot to floppy or the default cd if no hard disk defined yet */
5405     if (!boot_devices[0]) {
5406         boot_devices = "cad";
5407     }
5408     setvbuf(stdout, NULL, _IOLBF, 0);
5409
5410     init_timers();
5411     if (init_timer_alarm() < 0) {
5412         fprintf(stderr, "could not initialize alarm timer\n");
5413         exit(1);
5414     }
5415     if (use_icount && icount_time_shift < 0) {
5416         use_icount = 2;
5417         /* 125MIPS seems a reasonable initial guess at the guest speed.
5418            It will be corrected fairly quickly anyway.  */
5419         icount_time_shift = 3;
5420         init_icount_adjust();
5421     }
5422
5423 #ifdef _WIN32
5424     socket_init();
5425 #endif
5426
5427     /* init network clients */
5428     if (nb_net_clients == 0) {
5429         /* if no clients, we use a default config */
5430         net_clients[nb_net_clients++] = "nic";
5431 #ifdef CONFIG_SLIRP
5432         net_clients[nb_net_clients++] = "user";
5433 #endif
5434     }
5435
5436     for(i = 0;i < nb_net_clients; i++) {
5437         if (net_client_parse(net_clients[i]) < 0)
5438             exit(1);
5439     }
5440     net_client_check();
5441
5442 #ifdef TARGET_I386
5443     /* XXX: this should be moved in the PC machine instantiation code */
5444     if (net_boot != 0) {
5445         int netroms = 0;
5446         for (i = 0; i < nb_nics && i < 4; i++) {
5447             const char *model = nd_table[i].model;
5448             char buf[1024];
5449             if (net_boot & (1 << i)) {
5450                 if (model == NULL)
5451                     model = "ne2k_pci";
5452                 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5453                 if (get_image_size(buf) > 0) {
5454                     if (nb_option_roms >= MAX_OPTION_ROMS) {
5455                         fprintf(stderr, "Too many option ROMs\n");
5456                         exit(1);
5457                     }
5458                     option_rom[nb_option_roms] = strdup(buf);
5459                     nb_option_roms++;
5460                     netroms++;
5461                 }
5462             }
5463         }
5464         if (netroms == 0) {
5465             fprintf(stderr, "No valid PXE rom found for network device\n");
5466             exit(1);
5467         }
5468     }
5469 #endif
5470
5471     /* init the bluetooth world */
5472     for (i = 0; i < nb_bt_opts; i++)
5473         if (bt_parse(bt_opts[i]))
5474             exit(1);
5475
5476     /* init the memory */
5477     phys_ram_size = machine->ram_require & ~RAMSIZE_FIXED;
5478
5479     if (machine->ram_require & RAMSIZE_FIXED) {
5480         if (ram_size > 0) {
5481             if (ram_size < phys_ram_size) {
5482                 fprintf(stderr, "Machine `%s' requires %llu bytes of memory\n",
5483                                 machine->name, (unsigned long long) phys_ram_size);
5484                 exit(-1);
5485             }
5486
5487             phys_ram_size = ram_size;
5488         } else
5489             ram_size = phys_ram_size;
5490     } else {
5491         if (ram_size == 0)
5492             ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5493
5494         phys_ram_size += ram_size;
5495     }
5496
5497     phys_ram_base = qemu_vmalloc(phys_ram_size);
5498     if (!phys_ram_base) {
5499         fprintf(stderr, "Could not allocate physical memory\n");
5500         exit(1);
5501     }
5502
5503     /* init the dynamic translator */
5504     cpu_exec_init_all(tb_size * 1024 * 1024);
5505
5506     bdrv_init();
5507
5508     /* we always create the cdrom drive, even if no disk is there */
5509
5510     if (nb_drives_opt < MAX_DRIVES)
5511         drive_add(NULL, CDROM_ALIAS);
5512
5513     /* we always create at least one floppy */
5514
5515     if (nb_drives_opt < MAX_DRIVES)
5516         drive_add(NULL, FD_ALIAS, 0);
5517
5518     /* we always create one sd slot, even if no card is in it */
5519
5520     if (nb_drives_opt < MAX_DRIVES)
5521         drive_add(NULL, SD_ALIAS);
5522
5523     /* open the virtual block devices */
5524
5525     for(i = 0; i < nb_drives_opt; i++)
5526         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5527             exit(1);
5528
5529     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5530     register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5531
5532 #ifndef _WIN32
5533     /* must be after terminal init, SDL library changes signal handlers */
5534     termsig_setup();
5535 #endif
5536
5537     /* Maintain compatibility with multiple stdio monitors */
5538     if (!strcmp(monitor_device,"stdio")) {
5539         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5540             const char *devname = serial_devices[i];
5541             if (devname && !strcmp(devname,"mon:stdio")) {
5542                 monitor_device = NULL;
5543                 break;
5544             } else if (devname && !strcmp(devname,"stdio")) {
5545                 monitor_device = NULL;
5546                 serial_devices[i] = "mon:stdio";
5547                 break;
5548             }
5549         }
5550     }
5551
5552     if (kvm_enabled()) {
5553         int ret;
5554
5555         ret = kvm_init(smp_cpus);
5556         if (ret < 0) {
5557             fprintf(stderr, "failed to initialize KVM\n");
5558             exit(1);
5559         }
5560     }
5561
5562     if (monitor_device) {
5563         monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5564         if (!monitor_hd) {
5565             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5566             exit(1);
5567         }
5568     }
5569
5570     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5571         const char *devname = serial_devices[i];
5572         if (devname && strcmp(devname, "none")) {
5573             char label[32];
5574             snprintf(label, sizeof(label), "serial%d", i);
5575             serial_hds[i] = qemu_chr_open(label, devname, NULL);
5576             if (!serial_hds[i]) {
5577                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5578                         devname);
5579                 exit(1);
5580             }
5581         }
5582     }
5583
5584     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5585         const char *devname = parallel_devices[i];
5586         if (devname && strcmp(devname, "none")) {
5587             char label[32];
5588             snprintf(label, sizeof(label), "parallel%d", i);
5589             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5590             if (!parallel_hds[i]) {
5591                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5592                         devname);
5593                 exit(1);
5594             }
5595         }
5596     }
5597
5598     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5599         const char *devname = virtio_consoles[i];
5600         if (devname && strcmp(devname, "none")) {
5601             char label[32];
5602             snprintf(label, sizeof(label), "virtcon%d", i);
5603             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5604             if (!virtcon_hds[i]) {
5605                 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5606                         devname);
5607                 exit(1);
5608             }
5609         }
5610     }
5611
5612     machine->init(ram_size, vga_ram_size, boot_devices,
5613                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5614
5615     current_machine = machine;
5616
5617     /* Set KVM's vcpu state to qemu's initial CPUState. */
5618     if (kvm_enabled()) {
5619         int ret;
5620
5621         ret = kvm_sync_vcpus();
5622         if (ret < 0) {
5623             fprintf(stderr, "failed to initialize vcpus\n");
5624             exit(1);
5625         }
5626     }
5627
5628     /* init USB devices */
5629     if (usb_enabled) {
5630         for(i = 0; i < usb_devices_index; i++) {
5631             if (usb_device_add(usb_devices[i], 0) < 0) {
5632                 fprintf(stderr, "Warning: could not add USB device %s\n",
5633                         usb_devices[i]);
5634             }
5635         }
5636     }
5637
5638     if (!display_state)
5639         dumb_display_init();
5640     /* just use the first displaystate for the moment */
5641     ds = display_state;
5642     /* terminal init */
5643     if (nographic) {
5644         if (curses) {
5645             fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5646             exit(1);
5647         }
5648     } else {
5649 #if defined(CONFIG_CURSES)
5650             if (curses) {
5651                 /* At the moment curses cannot be used with other displays */
5652                 curses_display_init(ds, full_screen);
5653             } else
5654 #endif
5655             {
5656                 if (vnc_display != NULL) {
5657                     vnc_display_init(ds);
5658                     if (vnc_display_open(ds, vnc_display) < 0)
5659                         exit(1);
5660                 }
5661 #if defined(CONFIG_SDL)
5662                 if (sdl || !vnc_display)
5663                     sdl_display_init(ds, full_screen, no_frame);
5664 #elif defined(CONFIG_COCOA)
5665                 if (sdl || !vnc_display)
5666                     cocoa_display_init(ds, full_screen);
5667 #endif
5668             }
5669     }
5670     dpy_resize(ds);
5671
5672     dcl = ds->listeners;
5673     while (dcl != NULL) {
5674         if (dcl->dpy_refresh != NULL) {
5675             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5676             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5677         }
5678         dcl = dcl->next;
5679     }
5680
5681     if (nographic || (vnc_display && !sdl)) {
5682         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5683         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5684     }
5685
5686     text_consoles_set_display(display_state);
5687     qemu_chr_initial_reset();
5688
5689     if (monitor_device && monitor_hd)
5690         monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
5691
5692     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5693         const char *devname = serial_devices[i];
5694         if (devname && strcmp(devname, "none")) {
5695             char label[32];
5696             snprintf(label, sizeof(label), "serial%d", i);
5697             if (strstart(devname, "vc", 0))
5698                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5699         }
5700     }
5701
5702     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5703         const char *devname = parallel_devices[i];
5704         if (devname && strcmp(devname, "none")) {
5705             char label[32];
5706             snprintf(label, sizeof(label), "parallel%d", i);
5707             if (strstart(devname, "vc", 0))
5708                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5709         }
5710     }
5711
5712     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5713         const char *devname = virtio_consoles[i];
5714         if (virtcon_hds[i] && devname) {
5715             char label[32];
5716             snprintf(label, sizeof(label), "virtcon%d", i);
5717             if (strstart(devname, "vc", 0))
5718                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5719         }
5720     }
5721
5722 #ifdef CONFIG_GDBSTUB
5723     if (use_gdbstub) {
5724         /* XXX: use standard host:port notation and modify options
5725            accordingly. */
5726         if (gdbserver_start(gdbstub_port) < 0) {
5727             fprintf(stderr, "qemu: could not open gdbstub device on port '%s'\n",
5728                     gdbstub_port);
5729             exit(1);
5730         }
5731     }
5732 #endif
5733
5734     if (loadvm)
5735         do_loadvm(cur_mon, loadvm);
5736
5737     if (incoming) {
5738         autostart = 0; /* fixme how to deal with -daemonize */
5739         qemu_start_incoming_migration(incoming);
5740     }
5741
5742     if (autostart)
5743         vm_start();
5744
5745     if (daemonize) {
5746         uint8_t status = 0;
5747         ssize_t len;
5748
5749     again1:
5750         len = write(fds[1], &status, 1);
5751         if (len == -1 && (errno == EINTR))
5752             goto again1;
5753
5754         if (len != 1)
5755             exit(1);
5756
5757         chdir("/");
5758         TFR(fd = open("/dev/null", O_RDWR));
5759         if (fd == -1)
5760             exit(1);
5761     }
5762
5763 #ifndef _WIN32
5764     if (run_as) {
5765         pwd = getpwnam(run_as);
5766         if (!pwd) {
5767             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5768             exit(1);
5769         }
5770     }
5771
5772     if (chroot_dir) {
5773         if (chroot(chroot_dir) < 0) {
5774             fprintf(stderr, "chroot failed\n");
5775             exit(1);
5776         }
5777         chdir("/");
5778     }
5779
5780     if (run_as) {
5781         if (setgid(pwd->pw_gid) < 0) {
5782             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5783             exit(1);
5784         }
5785         if (setuid(pwd->pw_uid) < 0) {
5786             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5787             exit(1);
5788         }
5789         if (setuid(0) != -1) {
5790             fprintf(stderr, "Dropping privileges failed\n");
5791             exit(1);
5792         }
5793     }
5794 #endif
5795
5796     if (daemonize) {
5797         dup2(fd, 0);
5798         dup2(fd, 1);
5799         dup2(fd, 2);
5800
5801         close(fd);
5802     }
5803
5804     main_loop();
5805     quit_timers();
5806     net_cleanup();
5807
5808     return 0;
5809 }