git.maemo.org Git - qemu/blob - vl.c

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