vl.c

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