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

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