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 <libgen.h>
  37 #include <pwd.h>
  38 #include <sys/times.h>
  39 #include <sys/wait.h>
  40 #include <termios.h>
  41 #include <sys/mman.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/resource.h>
  44 #include <sys/socket.h>
  45 #include <netinet/in.h>
  46 #include <net/if.h>
  47 #if defined(__NetBSD__)
  48 #include <net/if_tap.h>
  49 #endif
  50 #ifdef __linux__
  51 #include <linux/if_tun.h>
  52 #endif
  53 #include <arpa/inet.h>
  54 #include <dirent.h>
  55 #include <netdb.h>
  56 #include <sys/select.h>
  57 #ifdef HOST_BSD
  58 #include <sys/stat.h>
  59 #if defined(__FreeBSD__) || defined(__DragonFly__)
  60 #include <libutil.h>
  61 #else
  62 #include <util.h>
  63 #endif
  64 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
  65 #include <freebsd/stdlib.h>
  66 #else
  67 #ifdef __linux__
  68 #include <pty.h>
  69 #include <malloc.h>
  70 #include <linux/rtc.h>
  71
  72 /* For the benefit of older linux systems which don't supply it,
  73    we use a local copy of hpet.h. */
  74 /* #include <linux/hpet.h> */
  75 #include "hpet.h"
  76
  77 #include <linux/ppdev.h>
  78 #include <linux/parport.h>
  79 #endif
  80 #ifdef __sun__
  81 #include <sys/stat.h>
  82 #include <sys/ethernet.h>
  83 #include <sys/sockio.h>
  84 #include <netinet/arp.h>
  85 #include <netinet/in.h>
  86 #include <netinet/in_systm.h>
  87 #include <netinet/ip.h>
  88 #include <netinet/ip_icmp.h> // must come after ip.h
  89 #include <netinet/udp.h>
  90 #include <netinet/tcp.h>
  91 #include <net/if.h>
  92 #include <syslog.h>
  93 #include <stropts.h>
  94 #endif
  95 #endif
  96 #endif
  97
  98 #if defined(__OpenBSD__)
  99 #include <util.h>
 100 #endif
 101
 102 #if defined(CONFIG_VDE)
 103 #include <libvdeplug.h>
 104 #endif
 105
 106 #ifdef _WIN32
 107 #include <windows.h>
 108 #include <malloc.h>
 109 #include <sys/timeb.h>
 110 #include <mmsystem.h>
 111 #define getopt_long_only getopt_long
 112 #define memalign(align, size) malloc(size)
 113 #endif
 114
 115 #ifdef CONFIG_SDL
 116 #ifdef __APPLE__
 117 #include <SDL/SDL.h>
 118 int qemu_main(int argc, char **argv, char **envp);
 119 int main(int argc, char **argv)
 120 {
 121     qemu_main(argc, argv, NULL);
 122 }
 123 #undef main
 124 #define main qemu_main
 125 #endif
 126 #endif /* CONFIG_SDL */
 127
 128 #ifdef CONFIG_COCOA
 129 #undef main
 130 #define main qemu_main
 131 #endif /* CONFIG_COCOA */
 132
 133 #include "hw/hw.h"
 134 #include "hw/boards.h"
 135 #include "hw/usb.h"
 136 #include "hw/pcmcia.h"
 137 #include "hw/pc.h"
 138 #include "hw/audiodev.h"
 139 #include "hw/isa.h"
 140 #include "hw/baum.h"
 141 #include "hw/bt.h"
 142 #include "hw/watchdog.h"
 143 #include "hw/smbios.h"
 144 #include "hw/xen.h"
 145 #include "bt-host.h"
 146 #include "net.h"
 147 #include "monitor.h"
 148 #include "console.h"
 149 #include "sysemu.h"
 150 #include "gdbstub.h"
 151 #include "qemu-timer.h"
 152 #include "qemu-char.h"
 153 #include "cache-utils.h"
 154 #include "block.h"
 155 #include "dma.h"
 156 #include "audio/audio.h"
 157 #include "migration.h"
 158 #include "kvm.h"
 159 #include "balloon.h"
 160 #include "qemu-option.h"
 161
 162 #include "disas.h"
 163
 164 #include "exec-all.h"
 165
 166 #include "qemu_socket.h"
 167
 168 #if defined(CONFIG_SLIRP)
 169 #include "libslirp.h"
 170 #endif
 171
 172 //#define DEBUG_UNUSED_IOPORT
 173 //#define DEBUG_IOPORT
 174 //#define DEBUG_NET
 175 //#define DEBUG_SLIRP
 176
 177
 178 #ifdef DEBUG_IOPORT
 179 #  define LOG_IOPORT(...) qemu_log_mask(CPU_LOG_IOPORT, ## __VA_ARGS__)
 180 #else
 181 #  define LOG_IOPORT(...) do { } while (0)
 182 #endif
 183
 184 #define DEFAULT_RAM_SIZE 128
 185
 186 /* Max number of USB devices that can be specified on the commandline.  */
 187 #define MAX_USB_CMDLINE 8
 188
 189 /* Max number of bluetooth switches on the commandline.  */
 190 #define MAX_BT_CMDLINE 10
 191
 192 /* XXX: use a two level table to limit memory usage */
 193 #define MAX_IOPORTS 65536
 194
 195 static const char *data_dir;
 196 const char *bios_name = NULL;
 197 static void *ioport_opaque[MAX_IOPORTS];
 198 static IOPortReadFunc *ioport_read_table[3][MAX_IOPORTS];
 199 static IOPortWriteFunc *ioport_write_table[3][MAX_IOPORTS];
 200 /* Note: drives_table[MAX_DRIVES] is a dummy block driver if none available
 201    to store the VM snapshots */
 202 DriveInfo drives_table[MAX_DRIVES+1];
 203 int nb_drives;
 204 enum vga_retrace_method vga_retrace_method = VGA_RETRACE_DUMB;
 205 static DisplayState *display_state;
 206 DisplayType display_type = DT_DEFAULT;
 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 int get_param_value(char *buf, int buf_size,
1815                     const char *tag, const char *str)
1816 {
1817     const char *p;
1818     char option[128];
1819
1820     p = str;
1821     for(;;) {
1822         p = get_opt_name(option, sizeof(option), p, '=');
1823         if (*p != '=')
1824             break;
1825         p++;
1826         if (!strcmp(tag, option)) {
1827             (void)get_opt_value(buf, buf_size, p);
1828             return strlen(buf);
1829         } else {
1830             p = get_opt_value(NULL, 0, p);
1831         }
1832         if (*p != ',')
1833             break;
1834         p++;
1835     }
1836     return 0;
1837 }
1838
1839 int check_params(const char * const *params, const char *str)
1840 {
1841     int name_buf_size = 1;
1842     const char *p;
1843     char *name_buf;
1844     int i, len;
1845     int ret = 0;
1846
1847     for (i = 0; params[i] != NULL; i++) {
1848         len = strlen(params[i]) + 1;
1849         if (len > name_buf_size) {
1850             name_buf_size = len;
1851         }
1852     }
1853     name_buf = qemu_malloc(name_buf_size);
1854
1855     p = str;
1856     while (*p != '\0') {
1857         p = get_opt_name(name_buf, name_buf_size, p, '=');
1858         if (*p != '=') {
1859             ret = -1;
1860             break;
1861         }
1862         p++;
1863         for(i = 0; params[i] != NULL; i++)
1864             if (!strcmp(params[i], name_buf))
1865                 break;
1866         if (params[i] == NULL) {
1867             ret = -1;
1868             break;
1869         }
1870         p = get_opt_value(NULL, 0, p);
1871         if (*p != ',')
1872             break;
1873         p++;
1874     }
1875
1876     qemu_free(name_buf);
1877     return ret;
1878 }
1879
1880 /***********************************************************/
1881 /* Bluetooth support */
1882 static int nb_hcis;
1883 static int cur_hci;
1884 static struct HCIInfo *hci_table[MAX_NICS];
1885
1886 static struct bt_vlan_s {
1887     struct bt_scatternet_s net;
1888     int id;
1889     struct bt_vlan_s *next;
1890 } *first_bt_vlan;
1891
1892 /* find or alloc a new bluetooth "VLAN" */
1893 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1894 {
1895     struct bt_vlan_s **pvlan, *vlan;
1896     for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1897         if (vlan->id == id)
1898             return &vlan->net;
1899     }
1900     vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1901     vlan->id = id;
1902     pvlan = &first_bt_vlan;
1903     while (*pvlan != NULL)
1904         pvlan = &(*pvlan)->next;
1905     *pvlan = vlan;
1906     return &vlan->net;
1907 }
1908
1909 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1910 {
1911 }
1912
1913 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1914 {
1915     return -ENOTSUP;
1916 }
1917
1918 static struct HCIInfo null_hci = {
1919     .cmd_send = null_hci_send,
1920     .sco_send = null_hci_send,
1921     .acl_send = null_hci_send,
1922     .bdaddr_set = null_hci_addr_set,
1923 };
1924
1925 struct HCIInfo *qemu_next_hci(void)
1926 {
1927     if (cur_hci == nb_hcis)
1928         return &null_hci;
1929
1930     return hci_table[cur_hci++];
1931 }
1932
1933 static struct HCIInfo *hci_init(const char *str)
1934 {
1935     char *endp;
1936     struct bt_scatternet_s *vlan = 0;
1937
1938     if (!strcmp(str, "null"))
1939         /* null */
1940         return &null_hci;
1941     else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1942         /* host[:hciN] */
1943         return bt_host_hci(str[4] ? str + 5 : "hci0");
1944     else if (!strncmp(str, "hci", 3)) {
1945         /* hci[,vlan=n] */
1946         if (str[3]) {
1947             if (!strncmp(str + 3, ",vlan=", 6)) {
1948                 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1949                 if (*endp)
1950                     vlan = 0;
1951             }
1952         } else
1953             vlan = qemu_find_bt_vlan(0);
1954         if (vlan)
1955            return bt_new_hci(vlan);
1956     }
1957
1958     fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
1959
1960     return 0;
1961 }
1962
1963 static int bt_hci_parse(const char *str)
1964 {
1965     struct HCIInfo *hci;
1966     bdaddr_t bdaddr;
1967
1968     if (nb_hcis >= MAX_NICS) {
1969         fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
1970         return -1;
1971     }
1972
1973     hci = hci_init(str);
1974     if (!hci)
1975         return -1;
1976
1977     bdaddr.b[0] = 0x52;
1978     bdaddr.b[1] = 0x54;
1979     bdaddr.b[2] = 0x00;
1980     bdaddr.b[3] = 0x12;
1981     bdaddr.b[4] = 0x34;
1982     bdaddr.b[5] = 0x56 + nb_hcis;
1983     hci->bdaddr_set(hci, bdaddr.b);
1984
1985     hci_table[nb_hcis++] = hci;
1986
1987     return 0;
1988 }
1989
1990 static void bt_vhci_add(int vlan_id)
1991 {
1992     struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1993
1994     if (!vlan->slave)
1995         fprintf(stderr, "qemu: warning: adding a VHCI to "
1996                         "an empty scatternet %i\n", vlan_id);
1997
1998     bt_vhci_init(bt_new_hci(vlan));
1999 }
2000
2001 static struct bt_device_s *bt_device_add(const char *opt)
2002 {
2003     struct bt_scatternet_s *vlan;
2004     int vlan_id = 0;
2005     char *endp = strstr(opt, ",vlan=");
2006     int len = (endp ? endp - opt : strlen(opt)) + 1;
2007     char devname[10];
2008
2009     pstrcpy(devname, MIN(sizeof(devname), len), opt);
2010
2011     if (endp) {
2012         vlan_id = strtol(endp + 6, &endp, 0);
2013         if (*endp) {
2014             fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
2015             return 0;
2016         }
2017     }
2018
2019     vlan = qemu_find_bt_vlan(vlan_id);
2020
2021     if (!vlan->slave)
2022         fprintf(stderr, "qemu: warning: adding a slave device to "
2023                         "an empty scatternet %i\n", vlan_id);
2024
2025     if (!strcmp(devname, "keyboard"))
2026         return bt_keyboard_init(vlan);
2027
2028     fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
2029     return 0;
2030 }
2031
2032 static int bt_parse(const char *opt)
2033 {
2034     const char *endp, *p;
2035     int vlan;
2036
2037     if (strstart(opt, "hci", &endp)) {
2038         if (!*endp || *endp == ',') {
2039             if (*endp)
2040                 if (!strstart(endp, ",vlan=", 0))
2041                     opt = endp + 1;
2042
2043             return bt_hci_parse(opt);
2044        }
2045     } else if (strstart(opt, "vhci", &endp)) {
2046         if (!*endp || *endp == ',') {
2047             if (*endp) {
2048                 if (strstart(endp, ",vlan=", &p)) {
2049                     vlan = strtol(p, (char **) &endp, 0);
2050                     if (*endp) {
2051                         fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
2052                         return 1;
2053                     }
2054                 } else {
2055                     fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
2056                     return 1;
2057                 }
2058             } else
2059                 vlan = 0;
2060
2061             bt_vhci_add(vlan);
2062             return 0;
2063         }
2064     } else if (strstart(opt, "device:", &endp))
2065         return !bt_device_add(endp);
2066
2067     fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
2068     return 1;
2069 }
2070
2071 /***********************************************************/
2072 /* QEMU Block devices */
2073
2074 #define HD_ALIAS "index=%d,media=disk"
2075 #define CDROM_ALIAS "index=2,media=cdrom"
2076 #define FD_ALIAS "index=%d,if=floppy"
2077 #define PFLASH_ALIAS "if=pflash"
2078 #define MTD_ALIAS "if=mtd"
2079 #define SD_ALIAS "index=0,if=sd"
2080
2081 static int drive_opt_get_free_idx(void)
2082 {
2083     int index;
2084
2085     for (index = 0; index < MAX_DRIVES; index++)
2086         if (!drives_opt[index].used) {
2087             drives_opt[index].used = 1;
2088             return index;
2089         }
2090
2091     return -1;
2092 }
2093
2094 static int drive_get_free_idx(void)
2095 {
2096     int index;
2097
2098     for (index = 0; index < MAX_DRIVES; index++)
2099         if (!drives_table[index].used) {
2100             drives_table[index].used = 1;
2101             return index;
2102         }
2103
2104     return -1;
2105 }
2106
2107 int drive_add(const char *file, const char *fmt, ...)
2108 {
2109     va_list ap;
2110     int index = drive_opt_get_free_idx();
2111
2112     if (nb_drives_opt >= MAX_DRIVES || index == -1) {
2113         fprintf(stderr, "qemu: too many drives\n");
2114         return -1;
2115     }
2116
2117     drives_opt[index].file = file;
2118     va_start(ap, fmt);
2119     vsnprintf(drives_opt[index].opt,
2120               sizeof(drives_opt[0].opt), fmt, ap);
2121     va_end(ap);
2122
2123     nb_drives_opt++;
2124     return index;
2125 }
2126
2127 void drive_remove(int index)
2128 {
2129     drives_opt[index].used = 0;
2130     nb_drives_opt--;
2131 }
2132
2133 int drive_get_index(BlockInterfaceType type, int bus, int unit)
2134 {
2135     int index;
2136
2137     /* seek interface, bus and unit */
2138
2139     for (index = 0; index < MAX_DRIVES; index++)
2140         if (drives_table[index].type == type &&
2141             drives_table[index].bus == bus &&
2142             drives_table[index].unit == unit &&
2143             drives_table[index].used)
2144         return index;
2145
2146     return -1;
2147 }
2148
2149 int drive_get_max_bus(BlockInterfaceType type)
2150 {
2151     int max_bus;
2152     int index;
2153
2154     max_bus = -1;
2155     for (index = 0; index < nb_drives; index++) {
2156         if(drives_table[index].type == type &&
2157            drives_table[index].bus > max_bus)
2158             max_bus = drives_table[index].bus;
2159     }
2160     return max_bus;
2161 }
2162
2163 const char *drive_get_serial(BlockDriverState *bdrv)
2164 {
2165     int index;
2166
2167     for (index = 0; index < nb_drives; index++)
2168         if (drives_table[index].bdrv == bdrv)
2169             return drives_table[index].serial;
2170
2171     return "\0";
2172 }
2173
2174 BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
2175 {
2176     int index;
2177
2178     for (index = 0; index < nb_drives; index++)
2179         if (drives_table[index].bdrv == bdrv)
2180             return drives_table[index].onerror;
2181
2182     return BLOCK_ERR_STOP_ENOSPC;
2183 }
2184
2185 static void bdrv_format_print(void *opaque, const char *name)
2186 {
2187     fprintf(stderr, " %s", name);
2188 }
2189
2190 void drive_uninit(BlockDriverState *bdrv)
2191 {
2192     int i;
2193
2194     for (i = 0; i < MAX_DRIVES; i++)
2195         if (drives_table[i].bdrv == bdrv) {
2196             drives_table[i].bdrv = NULL;
2197             drives_table[i].used = 0;
2198             drive_remove(drives_table[i].drive_opt_idx);
2199             nb_drives--;
2200             break;
2201         }
2202 }
2203
2204 int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
2205 {
2206     char buf[128];
2207     char file[1024];
2208     char devname[128];
2209     char serial[21];
2210     const char *mediastr = "";
2211     BlockInterfaceType type;
2212     enum { MEDIA_DISK, MEDIA_CDROM } media;
2213     int bus_id, unit_id;
2214     int cyls, heads, secs, translation;
2215     BlockDriverState *bdrv;
2216     BlockDriver *drv = NULL;
2217     QEMUMachine *machine = opaque;
2218     int max_devs;
2219     int index;
2220     int cache;
2221     int bdrv_flags, onerror;
2222     int drives_table_idx;
2223     char *str = arg->opt;
2224     static const char * const params[] = { "bus", "unit", "if", "index",
2225                                            "cyls", "heads", "secs", "trans",
2226                                            "media", "snapshot", "file",
2227                                            "cache", "format", "serial", "werror",
2228                                            NULL };
2229
2230     if (check_params(params, str) < 0) {
2231          fprintf(stderr, "qemu: unknown parameter in '%s'\n", str);
2232          return -1;
2233     }
2234
2235     file[0] = 0;
2236     cyls = heads = secs = 0;
2237     bus_id = 0;
2238     unit_id = -1;
2239     translation = BIOS_ATA_TRANSLATION_AUTO;
2240     index = -1;
2241     cache = 3;
2242
2243     if (machine->use_scsi) {
2244         type = IF_SCSI;
2245         max_devs = MAX_SCSI_DEVS;
2246         pstrcpy(devname, sizeof(devname), "scsi");
2247     } else {
2248         type = IF_IDE;
2249         max_devs = MAX_IDE_DEVS;
2250         pstrcpy(devname, sizeof(devname), "ide");
2251     }
2252     media = MEDIA_DISK;
2253
2254     /* extract parameters */
2255
2256     if (get_param_value(buf, sizeof(buf), "bus", str)) {
2257         bus_id = strtol(buf, NULL, 0);
2258         if (bus_id < 0) {
2259             fprintf(stderr, "qemu: '%s' invalid bus id\n", str);
2260             return -1;
2261         }
2262     }
2263
2264     if (get_param_value(buf, sizeof(buf), "unit", str)) {
2265         unit_id = strtol(buf, NULL, 0);
2266         if (unit_id < 0) {
2267             fprintf(stderr, "qemu: '%s' invalid unit id\n", str);
2268             return -1;
2269         }
2270     }
2271
2272     if (get_param_value(buf, sizeof(buf), "if", str)) {
2273         pstrcpy(devname, sizeof(devname), buf);
2274         if (!strcmp(buf, "ide")) {
2275             type = IF_IDE;
2276             max_devs = MAX_IDE_DEVS;
2277         } else if (!strcmp(buf, "scsi")) {
2278             type = IF_SCSI;
2279             max_devs = MAX_SCSI_DEVS;
2280         } else if (!strcmp(buf, "floppy")) {
2281             type = IF_FLOPPY;
2282             max_devs = 0;
2283         } else if (!strcmp(buf, "pflash")) {
2284             type = IF_PFLASH;
2285             max_devs = 0;
2286         } else if (!strcmp(buf, "mtd")) {
2287             type = IF_MTD;
2288             max_devs = 0;
2289         } else if (!strcmp(buf, "sd")) {
2290             type = IF_SD;
2291             max_devs = 0;
2292         } else if (!strcmp(buf, "virtio")) {
2293             type = IF_VIRTIO;
2294             max_devs = 0;
2295         } else if (!strcmp(buf, "xen")) {
2296             type = IF_XEN;
2297             max_devs = 0;
2298         } else {
2299             fprintf(stderr, "qemu: '%s' unsupported bus type '%s'\n", str, buf);
2300             return -1;
2301         }
2302     }
2303
2304     if (get_param_value(buf, sizeof(buf), "index", str)) {
2305         index = strtol(buf, NULL, 0);
2306         if (index < 0) {
2307             fprintf(stderr, "qemu: '%s' invalid index\n", str);
2308             return -1;
2309         }
2310     }
2311
2312     if (get_param_value(buf, sizeof(buf), "cyls", str)) {
2313         cyls = strtol(buf, NULL, 0);
2314     }
2315
2316     if (get_param_value(buf, sizeof(buf), "heads", str)) {
2317         heads = strtol(buf, NULL, 0);
2318     }
2319
2320     if (get_param_value(buf, sizeof(buf), "secs", str)) {
2321         secs = strtol(buf, NULL, 0);
2322     }
2323
2324     if (cyls || heads || secs) {
2325         if (cyls < 1 || cyls > 16383) {
2326             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", str);
2327             return -1;
2328         }
2329         if (heads < 1 || heads > 16) {
2330             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", str);
2331             return -1;
2332         }
2333         if (secs < 1 || secs > 63) {
2334             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", str);
2335             return -1;
2336         }
2337     }
2338
2339     if (get_param_value(buf, sizeof(buf), "trans", str)) {
2340         if (!cyls) {
2341             fprintf(stderr,
2342                     "qemu: '%s' trans must be used with cyls,heads and secs\n",
2343                     str);
2344             return -1;
2345         }
2346         if (!strcmp(buf, "none"))
2347             translation = BIOS_ATA_TRANSLATION_NONE;
2348         else if (!strcmp(buf, "lba"))
2349             translation = BIOS_ATA_TRANSLATION_LBA;
2350         else if (!strcmp(buf, "auto"))
2351             translation = BIOS_ATA_TRANSLATION_AUTO;
2352         else {
2353             fprintf(stderr, "qemu: '%s' invalid translation type\n", str);
2354             return -1;
2355         }
2356     }
2357
2358     if (get_param_value(buf, sizeof(buf), "media", str)) {
2359         if (!strcmp(buf, "disk")) {
2360             media = MEDIA_DISK;
2361         } else if (!strcmp(buf, "cdrom")) {
2362             if (cyls || secs || heads) {
2363                 fprintf(stderr,
2364                         "qemu: '%s' invalid physical CHS format\n", str);
2365                 return -1;
2366             }
2367             media = MEDIA_CDROM;
2368         } else {
2369             fprintf(stderr, "qemu: '%s' invalid media\n", str);
2370             return -1;
2371         }
2372     }
2373
2374     if (get_param_value(buf, sizeof(buf), "snapshot", str)) {
2375         if (!strcmp(buf, "on"))
2376             snapshot = 1;
2377         else if (!strcmp(buf, "off"))
2378             snapshot = 0;
2379         else {
2380             fprintf(stderr, "qemu: '%s' invalid snapshot option\n", str);
2381             return -1;
2382         }
2383     }
2384
2385     if (get_param_value(buf, sizeof(buf), "cache", str)) {
2386         if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2387             cache = 0;
2388         else if (!strcmp(buf, "writethrough"))
2389             cache = 1;
2390         else if (!strcmp(buf, "writeback"))
2391             cache = 2;
2392         else {
2393            fprintf(stderr, "qemu: invalid cache option\n");
2394            return -1;
2395         }
2396     }
2397
2398     if (get_param_value(buf, sizeof(buf), "format", str)) {
2399        if (strcmp(buf, "?") == 0) {
2400             fprintf(stderr, "qemu: Supported formats:");
2401             bdrv_iterate_format(bdrv_format_print, NULL);
2402             fprintf(stderr, "\n");
2403             return -1;
2404         }
2405         drv = bdrv_find_format(buf);
2406         if (!drv) {
2407             fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2408             return -1;
2409         }
2410     }
2411
2412     if (arg->file == NULL)
2413         get_param_value(file, sizeof(file), "file", str);
2414     else
2415         pstrcpy(file, sizeof(file), arg->file);
2416
2417     if (!get_param_value(serial, sizeof(serial), "serial", str))
2418             memset(serial, 0,  sizeof(serial));
2419
2420     onerror = BLOCK_ERR_STOP_ENOSPC;
2421     if (get_param_value(buf, sizeof(serial), "werror", str)) {
2422         if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2423             fprintf(stderr, "werror is no supported by this format\n");
2424             return -1;
2425         }
2426         if (!strcmp(buf, "ignore"))
2427             onerror = BLOCK_ERR_IGNORE;
2428         else if (!strcmp(buf, "enospc"))
2429             onerror = BLOCK_ERR_STOP_ENOSPC;
2430         else if (!strcmp(buf, "stop"))
2431             onerror = BLOCK_ERR_STOP_ANY;
2432         else if (!strcmp(buf, "report"))
2433             onerror = BLOCK_ERR_REPORT;
2434         else {
2435             fprintf(stderr, "qemu: '%s' invalid write error action\n", buf);
2436             return -1;
2437         }
2438     }
2439
2440     /* compute bus and unit according index */
2441
2442     if (index != -1) {
2443         if (bus_id != 0 || unit_id != -1) {
2444             fprintf(stderr,
2445                     "qemu: '%s' index cannot be used with bus and unit\n", str);
2446             return -1;
2447         }
2448         if (max_devs == 0)
2449         {
2450             unit_id = index;
2451             bus_id = 0;
2452         } else {
2453             unit_id = index % max_devs;
2454             bus_id = index / max_devs;
2455         }
2456     }
2457
2458     /* if user doesn't specify a unit_id,
2459      * try to find the first free
2460      */
2461
2462     if (unit_id == -1) {
2463        unit_id = 0;
2464        while (drive_get_index(type, bus_id, unit_id) != -1) {
2465            unit_id++;
2466            if (max_devs && unit_id >= max_devs) {
2467                unit_id -= max_devs;
2468                bus_id++;
2469            }
2470        }
2471     }
2472
2473     /* check unit id */
2474
2475     if (max_devs && unit_id >= max_devs) {
2476         fprintf(stderr, "qemu: '%s' unit %d too big (max is %d)\n",
2477                         str, unit_id, max_devs - 1);
2478         return -1;
2479     }
2480
2481     /*
2482      * ignore multiple definitions
2483      */
2484
2485     if (drive_get_index(type, bus_id, unit_id) != -1)
2486         return -2;
2487
2488     /* init */
2489
2490     if (type == IF_IDE || type == IF_SCSI)
2491         mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2492     if (max_devs)
2493         snprintf(buf, sizeof(buf), "%s%i%s%i",
2494                  devname, bus_id, mediastr, unit_id);
2495     else
2496         snprintf(buf, sizeof(buf), "%s%s%i",
2497                  devname, mediastr, unit_id);
2498     bdrv = bdrv_new(buf);
2499     drives_table_idx = drive_get_free_idx();
2500     drives_table[drives_table_idx].bdrv = bdrv;
2501     drives_table[drives_table_idx].type = type;
2502     drives_table[drives_table_idx].bus = bus_id;
2503     drives_table[drives_table_idx].unit = unit_id;
2504     drives_table[drives_table_idx].onerror = onerror;
2505     drives_table[drives_table_idx].drive_opt_idx = arg - drives_opt;
2506     strncpy(drives_table[drives_table_idx].serial, serial, sizeof(serial));
2507     nb_drives++;
2508
2509     switch(type) {
2510     case IF_IDE:
2511     case IF_SCSI:
2512     case IF_XEN:
2513         switch(media) {
2514         case MEDIA_DISK:
2515             if (cyls != 0) {
2516                 bdrv_set_geometry_hint(bdrv, cyls, heads, secs);
2517                 bdrv_set_translation_hint(bdrv, translation);
2518             }
2519             break;
2520         case MEDIA_CDROM:
2521             bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
2522             break;
2523         }
2524         break;
2525     case IF_SD:
2526         /* FIXME: This isn't really a floppy, but it's a reasonable
2527            approximation.  */
2528     case IF_FLOPPY:
2529         bdrv_set_type_hint(bdrv, BDRV_TYPE_FLOPPY);
2530         break;
2531     case IF_PFLASH:
2532     case IF_MTD:
2533     case IF_VIRTIO:
2534         break;
2535     case IF_COUNT:
2536         abort();
2537     }
2538     if (!file[0])
2539         return -2;
2540     bdrv_flags = 0;
2541     if (snapshot) {
2542         bdrv_flags |= BDRV_O_SNAPSHOT;
2543         cache = 2; /* always use write-back with snapshot */
2544     }
2545     if (cache == 0) /* no caching */
2546         bdrv_flags |= BDRV_O_NOCACHE;
2547     else if (cache == 2) /* write-back */
2548         bdrv_flags |= BDRV_O_CACHE_WB;
2549     else if (cache == 3) /* not specified */
2550         bdrv_flags |= BDRV_O_CACHE_DEF;
2551     if (bdrv_open2(bdrv, file, bdrv_flags, drv) < 0) {
2552         fprintf(stderr, "qemu: could not open disk image %s\n",
2553                         file);
2554         return -1;
2555     }
2556     if (bdrv_key_required(bdrv))
2557         autostart = 0;
2558     return drives_table_idx;
2559 }
2560
2561 static void numa_add(const char *optarg)
2562 {
2563     char option[128];
2564     char *endptr;
2565     unsigned long long value, endvalue;
2566     int nodenr;
2567
2568     optarg = get_opt_name(option, 128, optarg, ',') + 1;
2569     if (!strcmp(option, "node")) {
2570         if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2571             nodenr = nb_numa_nodes;
2572         } else {
2573             nodenr = strtoull(option, NULL, 10);
2574         }
2575
2576         if (get_param_value(option, 128, "mem", optarg) == 0) {
2577             node_mem[nodenr] = 0;
2578         } else {
2579             value = strtoull(option, &endptr, 0);
2580             switch (*endptr) {
2581             case 0: case 'M': case 'm':
2582                 value <<= 20;
2583                 break;
2584             case 'G': case 'g':
2585                 value <<= 30;
2586                 break;
2587             }
2588             node_mem[nodenr] = value;
2589         }
2590         if (get_param_value(option, 128, "cpus", optarg) == 0) {
2591             node_cpumask[nodenr] = 0;
2592         } else {
2593             value = strtoull(option, &endptr, 10);
2594             if (value >= 64) {
2595                 value = 63;
2596                 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2597             } else {
2598                 if (*endptr == '-') {
2599                     endvalue = strtoull(endptr+1, &endptr, 10);
2600                     if (endvalue >= 63) {
2601                         endvalue = 62;
2602                         fprintf(stderr,
2603                             "only 63 CPUs in NUMA mode supported.\n");
2604                     }
2605                     value = (1 << (endvalue + 1)) - (1 << value);
2606                 } else {
2607                     value = 1 << value;
2608                 }
2609             }
2610             node_cpumask[nodenr] = value;
2611         }
2612         nb_numa_nodes++;
2613     }
2614     return;
2615 }
2616
2617 /***********************************************************/
2618 /* USB devices */
2619
2620 static USBPort *used_usb_ports;
2621 static USBPort *free_usb_ports;
2622
2623 /* ??? Maybe change this to register a hub to keep track of the topology.  */
2624 void qemu_register_usb_port(USBPort *port, void *opaque, int index,
2625                             usb_attachfn attach)
2626 {
2627     port->opaque = opaque;
2628     port->index = index;
2629     port->attach = attach;
2630     port->next = free_usb_ports;
2631     free_usb_ports = port;
2632 }
2633
2634 int usb_device_add_dev(USBDevice *dev)
2635 {
2636     USBPort *port;
2637
2638     /* Find a USB port to add the device to.  */
2639     port = free_usb_ports;
2640     if (!port->next) {
2641         USBDevice *hub;
2642
2643         /* Create a new hub and chain it on.  */
2644         free_usb_ports = NULL;
2645         port->next = used_usb_ports;
2646         used_usb_ports = port;
2647
2648         hub = usb_hub_init(VM_USB_HUB_SIZE);
2649         usb_attach(port, hub);
2650         port = free_usb_ports;
2651     }
2652
2653     free_usb_ports = port->next;
2654     port->next = used_usb_ports;
2655     used_usb_ports = port;
2656     usb_attach(port, dev);
2657     return 0;
2658 }
2659
2660 static void usb_msd_password_cb(void *opaque, int err)
2661 {
2662     USBDevice *dev = opaque;
2663
2664     if (!err)
2665         usb_device_add_dev(dev);
2666     else
2667         dev->handle_destroy(dev);
2668 }
2669
2670 static int usb_device_add(const char *devname, int is_hotplug)
2671 {
2672     const char *p;
2673     USBDevice *dev;
2674
2675     if (!free_usb_ports)
2676         return -1;
2677
2678     if (strstart(devname, "host:", &p)) {
2679         dev = usb_host_device_open(p);
2680     } else if (!strcmp(devname, "mouse")) {
2681         dev = usb_mouse_init();
2682     } else if (!strcmp(devname, "tablet")) {
2683         dev = usb_tablet_init();
2684     } else if (!strcmp(devname, "keyboard")) {
2685         dev = usb_keyboard_init();
2686     } else if (strstart(devname, "disk:", &p)) {
2687         BlockDriverState *bs;
2688
2689         dev = usb_msd_init(p);
2690         if (!dev)
2691             return -1;
2692         bs = usb_msd_get_bdrv(dev);
2693         if (bdrv_key_required(bs)) {
2694             autostart = 0;
2695             if (is_hotplug) {
2696                 monitor_read_bdrv_key_start(cur_mon, bs, usb_msd_password_cb,
2697                                             dev);
2698                 return 0;
2699             }
2700         }
2701     } else if (!strcmp(devname, "wacom-tablet")) {
2702         dev = usb_wacom_init();
2703     } else if (strstart(devname, "serial:", &p)) {
2704         dev = usb_serial_init(p);
2705 #ifdef CONFIG_BRLAPI
2706     } else if (!strcmp(devname, "braille")) {
2707         dev = usb_baum_init();
2708 #endif
2709     } else if (strstart(devname, "net:", &p)) {
2710         int nic = nb_nics;
2711
2712         if (net_client_init("nic", p) < 0)
2713             return -1;
2714         nd_table[nic].model = "usb";
2715         dev = usb_net_init(&nd_table[nic]);
2716     } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2717         dev = usb_bt_init(devname[2] ? hci_init(p) :
2718                         bt_new_hci(qemu_find_bt_vlan(0)));
2719     } else {
2720         return -1;
2721     }
2722     if (!dev)
2723         return -1;
2724
2725     return usb_device_add_dev(dev);
2726 }
2727
2728 int usb_device_del_addr(int bus_num, int addr)
2729 {
2730     USBPort *port;
2731     USBPort **lastp;
2732     USBDevice *dev;
2733
2734     if (!used_usb_ports)
2735         return -1;
2736
2737     if (bus_num != 0)
2738         return -1;
2739
2740     lastp = &used_usb_ports;
2741     port = used_usb_ports;
2742     while (port && port->dev->addr != addr) {
2743         lastp = &port->next;
2744         port = port->next;
2745     }
2746
2747     if (!port)
2748         return -1;
2749
2750     dev = port->dev;
2751     *lastp = port->next;
2752     usb_attach(port, NULL);
2753     dev->handle_destroy(dev);
2754     port->next = free_usb_ports;
2755     free_usb_ports = port;
2756     return 0;
2757 }
2758
2759 static int usb_device_del(const char *devname)
2760 {
2761     int bus_num, addr;
2762     const char *p;
2763
2764     if (strstart(devname, "host:", &p))
2765         return usb_host_device_close(p);
2766
2767     if (!used_usb_ports)
2768         return -1;
2769
2770     p = strchr(devname, '.');
2771     if (!p)
2772         return -1;
2773     bus_num = strtoul(devname, NULL, 0);
2774     addr = strtoul(p + 1, NULL, 0);
2775
2776     return usb_device_del_addr(bus_num, addr);
2777 }
2778
2779 void do_usb_add(Monitor *mon, const char *devname)
2780 {
2781     usb_device_add(devname, 1);
2782 }
2783
2784 void do_usb_del(Monitor *mon, const char *devname)
2785 {
2786     usb_device_del(devname);
2787 }
2788
2789 void usb_info(Monitor *mon)
2790 {
2791     USBDevice *dev;
2792     USBPort *port;
2793     const char *speed_str;
2794
2795     if (!usb_enabled) {
2796         monitor_printf(mon, "USB support not enabled\n");
2797         return;
2798     }
2799
2800     for (port = used_usb_ports; port; port = port->next) {
2801         dev = port->dev;
2802         if (!dev)
2803             continue;
2804         switch(dev->speed) {
2805         case USB_SPEED_LOW:
2806             speed_str = "1.5";
2807             break;
2808         case USB_SPEED_FULL:
2809             speed_str = "12";
2810             break;
2811         case USB_SPEED_HIGH:
2812             speed_str = "480";
2813             break;
2814         default:
2815             speed_str = "?";
2816             break;
2817         }
2818         monitor_printf(mon, "  Device %d.%d, Speed %s Mb/s, Product %s\n",
2819                        0, dev->addr, speed_str, dev->devname);
2820     }
2821 }
2822
2823 /***********************************************************/
2824 /* PCMCIA/Cardbus */
2825
2826 static struct pcmcia_socket_entry_s {
2827     PCMCIASocket *socket;
2828     struct pcmcia_socket_entry_s *next;
2829 } *pcmcia_sockets = 0;
2830
2831 void pcmcia_socket_register(PCMCIASocket *socket)
2832 {
2833     struct pcmcia_socket_entry_s *entry;
2834
2835     entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2836     entry->socket = socket;
2837     entry->next = pcmcia_sockets;
2838     pcmcia_sockets = entry;
2839 }
2840
2841 void pcmcia_socket_unregister(PCMCIASocket *socket)
2842 {
2843     struct pcmcia_socket_entry_s *entry, **ptr;
2844
2845     ptr = &pcmcia_sockets;
2846     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2847         if (entry->socket == socket) {
2848             *ptr = entry->next;
2849             qemu_free(entry);
2850         }
2851 }
2852
2853 void pcmcia_info(Monitor *mon)
2854 {
2855     struct pcmcia_socket_entry_s *iter;
2856
2857     if (!pcmcia_sockets)
2858         monitor_printf(mon, "No PCMCIA sockets\n");
2859
2860     for (iter = pcmcia_sockets; iter; iter = iter->next)
2861         monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2862                        iter->socket->attached ? iter->socket->card_string :
2863                        "Empty");
2864 }
2865
2866 /***********************************************************/
2867 /* register display */
2868
2869 struct DisplayAllocator default_allocator = {
2870     defaultallocator_create_displaysurface,
2871     defaultallocator_resize_displaysurface,
2872     defaultallocator_free_displaysurface
2873 };
2874
2875 void register_displaystate(DisplayState *ds)
2876 {
2877     DisplayState **s;
2878     s = &display_state;
2879     while (*s != NULL)
2880         s = &(*s)->next;
2881     ds->next = NULL;
2882     *s = ds;
2883 }
2884
2885 DisplayState *get_displaystate(void)
2886 {
2887     return display_state;
2888 }
2889
2890 DisplayAllocator *register_displayallocator(DisplayState *ds, DisplayAllocator *da)
2891 {
2892     if(ds->allocator ==  &default_allocator) ds->allocator = da;
2893     return ds->allocator;
2894 }
2895
2896 /* dumb display */
2897
2898 static void dumb_display_init(void)
2899 {
2900     DisplayState *ds = qemu_mallocz(sizeof(DisplayState));
2901     ds->allocator = &default_allocator;
2902     ds->surface = qemu_create_displaysurface(ds, 640, 480);
2903     register_displaystate(ds);
2904 }
2905
2906 /***********************************************************/
2907 /* I/O handling */
2908
2909 typedef struct IOHandlerRecord {
2910     int fd;
2911     IOCanRWHandler *fd_read_poll;
2912     IOHandler *fd_read;
2913     IOHandler *fd_write;
2914     int deleted;
2915     void *opaque;
2916     /* temporary data */
2917     struct pollfd *ufd;
2918     struct IOHandlerRecord *next;
2919 } IOHandlerRecord;
2920
2921 static IOHandlerRecord *first_io_handler;
2922
2923 /* XXX: fd_read_poll should be suppressed, but an API change is
2924    necessary in the character devices to suppress fd_can_read(). */
2925 int qemu_set_fd_handler2(int fd,
2926                          IOCanRWHandler *fd_read_poll,
2927                          IOHandler *fd_read,
2928                          IOHandler *fd_write,
2929                          void *opaque)
2930 {
2931     IOHandlerRecord **pioh, *ioh;
2932
2933     if (!fd_read && !fd_write) {
2934         pioh = &first_io_handler;
2935         for(;;) {
2936             ioh = *pioh;
2937             if (ioh == NULL)
2938                 break;
2939             if (ioh->fd == fd) {
2940                 ioh->deleted = 1;
2941                 break;
2942             }
2943             pioh = &ioh->next;
2944         }
2945     } else {
2946         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2947             if (ioh->fd == fd)
2948                 goto found;
2949         }
2950         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2951         ioh->next = first_io_handler;
2952         first_io_handler = ioh;
2953     found:
2954         ioh->fd = fd;
2955         ioh->fd_read_poll = fd_read_poll;
2956         ioh->fd_read = fd_read;
2957         ioh->fd_write = fd_write;
2958         ioh->opaque = opaque;
2959         ioh->deleted = 0;
2960     }
2961     return 0;
2962 }
2963
2964 int qemu_set_fd_handler(int fd,
2965                         IOHandler *fd_read,
2966                         IOHandler *fd_write,
2967                         void *opaque)
2968 {
2969     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2970 }
2971
2972 #ifdef _WIN32
2973 /***********************************************************/
2974 /* Polling handling */
2975
2976 typedef struct PollingEntry {
2977     PollingFunc *func;
2978     void *opaque;
2979     struct PollingEntry *next;
2980 } PollingEntry;
2981
2982 static PollingEntry *first_polling_entry;
2983
2984 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2985 {
2986     PollingEntry **ppe, *pe;
2987     pe = qemu_mallocz(sizeof(PollingEntry));
2988     pe->func = func;
2989     pe->opaque = opaque;
2990     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2991     *ppe = pe;
2992     return 0;
2993 }
2994
2995 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2996 {
2997     PollingEntry **ppe, *pe;
2998     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2999         pe = *ppe;
3000         if (pe->func == func && pe->opaque == opaque) {
3001             *ppe = pe->next;
3002             qemu_free(pe);
3003             break;
3004         }
3005     }
3006 }
3007
3008 /***********************************************************/
3009 /* Wait objects support */
3010 typedef struct WaitObjects {
3011     int num;
3012     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
3013     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
3014     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
3015 } WaitObjects;
3016
3017 static WaitObjects wait_objects = {0};
3018
3019 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3020 {
3021     WaitObjects *w = &wait_objects;
3022
3023     if (w->num >= MAXIMUM_WAIT_OBJECTS)
3024         return -1;
3025     w->events[w->num] = handle;
3026     w->func[w->num] = func;
3027     w->opaque[w->num] = opaque;
3028     w->num++;
3029     return 0;
3030 }
3031
3032 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
3033 {
3034     int i, found;
3035     WaitObjects *w = &wait_objects;
3036
3037     found = 0;
3038     for (i = 0; i < w->num; i++) {
3039         if (w->events[i] == handle)
3040             found = 1;
3041         if (found) {
3042             w->events[i] = w->events[i + 1];
3043             w->func[i] = w->func[i + 1];
3044             w->opaque[i] = w->opaque[i + 1];
3045         }
3046     }
3047     if (found)
3048         w->num--;
3049 }
3050 #endif
3051
3052 /***********************************************************/
3053 /* ram save/restore */
3054
3055 static int ram_get_page(QEMUFile *f, uint8_t *buf, int len)
3056 {
3057     int v;
3058
3059     v = qemu_get_byte(f);
3060     switch(v) {
3061     case 0:
3062         if (qemu_get_buffer(f, buf, len) != len)
3063             return -EIO;
3064         break;
3065     case 1:
3066         v = qemu_get_byte(f);
3067         memset(buf, v, len);
3068         break;
3069     default:
3070         return -EINVAL;
3071     }
3072
3073     if (qemu_file_has_error(f))
3074         return -EIO;
3075
3076     return 0;
3077 }
3078
3079 static int ram_load_v1(QEMUFile *f, void *opaque)
3080 {
3081     int ret;
3082     ram_addr_t i;
3083
3084     if (qemu_get_be32(f) != last_ram_offset)
3085         return -EINVAL;
3086     for(i = 0; i < last_ram_offset; i+= TARGET_PAGE_SIZE) {
3087         ret = ram_get_page(f, qemu_get_ram_ptr(i), TARGET_PAGE_SIZE);
3088         if (ret)
3089             return ret;
3090     }
3091     return 0;
3092 }
3093
3094 #define BDRV_HASH_BLOCK_SIZE 1024
3095 #define IOBUF_SIZE 4096
3096 #define RAM_CBLOCK_MAGIC 0xfabe
3097
3098 typedef struct RamDecompressState {
3099     z_stream zstream;
3100     QEMUFile *f;
3101     uint8_t buf[IOBUF_SIZE];
3102 } RamDecompressState;
3103
3104 static int ram_decompress_open(RamDecompressState *s, QEMUFile *f)
3105 {
3106     int ret;
3107     memset(s, 0, sizeof(*s));
3108     s->f = f;
3109     ret = inflateInit(&s->zstream);
3110     if (ret != Z_OK)
3111         return -1;
3112     return 0;
3113 }
3114
3115 static int ram_decompress_buf(RamDecompressState *s, uint8_t *buf, int len)
3116 {
3117     int ret, clen;
3118
3119     s->zstream.avail_out = len;
3120     s->zstream.next_out = buf;
3121     while (s->zstream.avail_out > 0) {
3122         if (s->zstream.avail_in == 0) {
3123             if (qemu_get_be16(s->f) != RAM_CBLOCK_MAGIC)
3124                 return -1;
3125             clen = qemu_get_be16(s->f);
3126             if (clen > IOBUF_SIZE)
3127                 return -1;
3128             qemu_get_buffer(s->f, s->buf, clen);
3129             s->zstream.avail_in = clen;
3130             s->zstream.next_in = s->buf;
3131         }
3132         ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);
3133         if (ret != Z_OK && ret != Z_STREAM_END) {
3134             return -1;
3135         }
3136     }
3137     return 0;
3138 }
3139
3140 static void ram_decompress_close(RamDecompressState *s)
3141 {
3142     inflateEnd(&s->zstream);
3143 }
3144
3145 #define RAM_SAVE_FLAG_FULL      0x01
3146 #define RAM_SAVE_FLAG_COMPRESS  0x02
3147 #define RAM_SAVE_FLAG_MEM_SIZE  0x04
3148 #define RAM_SAVE_FLAG_PAGE      0x08
3149 #define RAM_SAVE_FLAG_EOS       0x10
3150
3151 static int is_dup_page(uint8_t *page, uint8_t ch)
3152 {
3153     uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
3154     uint32_t *array = (uint32_t *)page;
3155     int i;
3156
3157     for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
3158         if (array[i] != val)
3159             return 0;
3160     }
3161
3162     return 1;
3163 }
3164
3165 static int ram_save_block(QEMUFile *f)
3166 {
3167     static ram_addr_t current_addr = 0;
3168     ram_addr_t saved_addr = current_addr;
3169     ram_addr_t addr = 0;
3170     int found = 0;
3171
3172     while (addr < last_ram_offset) {
3173         if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
3174             uint8_t *p;
3175
3176             cpu_physical_memory_reset_dirty(current_addr,
3177                                             current_addr + TARGET_PAGE_SIZE,
3178                                             MIGRATION_DIRTY_FLAG);
3179
3180             p = qemu_get_ram_ptr(current_addr);
3181
3182             if (is_dup_page(p, *p)) {
3183                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
3184                 qemu_put_byte(f, *p);
3185             } else {
3186                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
3187                 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
3188             }
3189
3190             found = 1;
3191             break;
3192         }
3193         addr += TARGET_PAGE_SIZE;
3194         current_addr = (saved_addr + addr) % last_ram_offset;
3195     }
3196
3197     return found;
3198 }
3199
3200 static ram_addr_t ram_save_threshold = 10;
3201 static uint64_t bytes_transferred = 0;
3202
3203 static ram_addr_t ram_save_remaining(void)
3204 {
3205     ram_addr_t addr;
3206     ram_addr_t count = 0;
3207
3208     for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3209         if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3210             count++;
3211     }
3212
3213     return count;
3214 }
3215
3216 uint64_t ram_bytes_remaining(void)
3217 {
3218     return ram_save_remaining() * TARGET_PAGE_SIZE;
3219 }
3220
3221 uint64_t ram_bytes_transferred(void)
3222 {
3223     return bytes_transferred;
3224 }
3225
3226 uint64_t ram_bytes_total(void)
3227 {
3228     return last_ram_offset;
3229 }
3230
3231 static int ram_save_live(QEMUFile *f, int stage, void *opaque)
3232 {
3233     ram_addr_t addr;
3234
3235     if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
3236         qemu_file_set_error(f);
3237         return 0;
3238     }
3239
3240     if (stage == 1) {
3241         /* Make sure all dirty bits are set */
3242         for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
3243             if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
3244                 cpu_physical_memory_set_dirty(addr);
3245         }
3246
3247         /* Enable dirty memory tracking */
3248         cpu_physical_memory_set_dirty_tracking(1);
3249
3250         qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
3251     }
3252
3253     while (!qemu_file_rate_limit(f)) {
3254         int ret;
3255
3256         ret = ram_save_block(f);
3257         bytes_transferred += ret * TARGET_PAGE_SIZE;
3258         if (ret == 0) /* no more blocks */
3259             break;
3260     }
3261
3262     /* try transferring iterative blocks of memory */
3263
3264     if (stage == 3) {
3265
3266         /* flush all remaining blocks regardless of rate limiting */
3267         while (ram_save_block(f) != 0) {
3268             bytes_transferred += TARGET_PAGE_SIZE;
3269         }
3270         cpu_physical_memory_set_dirty_tracking(0);
3271     }
3272
3273     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
3274
3275     return (stage == 2) && (ram_save_remaining() < ram_save_threshold);
3276 }
3277
3278 static int ram_load_dead(QEMUFile *f, void *opaque)
3279 {
3280     RamDecompressState s1, *s = &s1;
3281     uint8_t buf[10];
3282     ram_addr_t i;
3283
3284     if (ram_decompress_open(s, f) < 0)
3285         return -EINVAL;
3286     for(i = 0; i < last_ram_offset; i+= BDRV_HASH_BLOCK_SIZE) {
3287         if (ram_decompress_buf(s, buf, 1) < 0) {
3288             fprintf(stderr, "Error while reading ram block header\n");
3289             goto error;
3290         }
3291         if (buf[0] == 0) {
3292             if (ram_decompress_buf(s, qemu_get_ram_ptr(i),
3293                                    BDRV_HASH_BLOCK_SIZE) < 0) {
3294                 fprintf(stderr, "Error while reading ram block address=0x%08" PRIx64, (uint64_t)i);
3295                 goto error;
3296             }
3297         } else {
3298         error:
3299             printf("Error block header\n");
3300             return -EINVAL;
3301         }
3302     }
3303     ram_decompress_close(s);
3304
3305     return 0;
3306 }
3307
3308 static int ram_load(QEMUFile *f, void *opaque, int version_id)
3309 {
3310     ram_addr_t addr;
3311     int flags;
3312
3313     if (version_id == 1)
3314         return ram_load_v1(f, opaque);
3315
3316     if (version_id == 2) {
3317         if (qemu_get_be32(f) != last_ram_offset)
3318             return -EINVAL;
3319         return ram_load_dead(f, opaque);
3320     }
3321
3322     if (version_id != 3)
3323         return -EINVAL;
3324
3325     do {
3326         addr = qemu_get_be64(f);
3327
3328         flags = addr & ~TARGET_PAGE_MASK;
3329         addr &= TARGET_PAGE_MASK;
3330
3331         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3332             if (addr != last_ram_offset)
3333                 return -EINVAL;
3334         }
3335
3336         if (flags & RAM_SAVE_FLAG_FULL) {
3337             if (ram_load_dead(f, opaque) < 0)
3338                 return -EINVAL;
3339         }
3340
3341         if (flags & RAM_SAVE_FLAG_COMPRESS) {
3342             uint8_t ch = qemu_get_byte(f);
3343             memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3344         } else if (flags & RAM_SAVE_FLAG_PAGE)
3345             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3346     } while (!(flags & RAM_SAVE_FLAG_EOS));
3347
3348     return 0;
3349 }
3350
3351 void qemu_service_io(void)
3352 {
3353     qemu_notify_event();
3354 }
3355
3356 /***********************************************************/
3357 /* bottom halves (can be seen as timers which expire ASAP) */
3358
3359 struct QEMUBH {
3360     QEMUBHFunc *cb;
3361     void *opaque;
3362     int scheduled;
3363     int idle;
3364     int deleted;
3365     QEMUBH *next;
3366 };
3367
3368 static QEMUBH *first_bh = NULL;
3369
3370 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
3371 {
3372     QEMUBH *bh;
3373     bh = qemu_mallocz(sizeof(QEMUBH));
3374     bh->cb = cb;
3375     bh->opaque = opaque;
3376     bh->next = first_bh;
3377     first_bh = bh;
3378     return bh;
3379 }
3380
3381 int qemu_bh_poll(void)
3382 {
3383     QEMUBH *bh, **bhp;
3384     int ret;
3385
3386     ret = 0;
3387     for (bh = first_bh; bh; bh = bh->next) {
3388         if (!bh->deleted && bh->scheduled) {
3389             bh->scheduled = 0;
3390             if (!bh->idle)
3391                 ret = 1;
3392             bh->idle = 0;
3393             bh->cb(bh->opaque);
3394         }
3395     }
3396
3397     /* remove deleted bhs */
3398     bhp = &first_bh;
3399     while (*bhp) {
3400         bh = *bhp;
3401         if (bh->deleted) {
3402             *bhp = bh->next;
3403             qemu_free(bh);
3404         } else
3405             bhp = &bh->next;
3406     }
3407
3408     return ret;
3409 }
3410
3411 void qemu_bh_schedule_idle(QEMUBH *bh)
3412 {
3413     if (bh->scheduled)
3414         return;
3415     bh->scheduled = 1;
3416     bh->idle = 1;
3417 }
3418
3419 void qemu_bh_schedule(QEMUBH *bh)
3420 {
3421     if (bh->scheduled)
3422         return;
3423     bh->scheduled = 1;
3424     bh->idle = 0;
3425     /* stop the currently executing CPU to execute the BH ASAP */
3426     qemu_notify_event();
3427 }
3428
3429 void qemu_bh_cancel(QEMUBH *bh)
3430 {
3431     bh->scheduled = 0;
3432 }
3433
3434 void qemu_bh_delete(QEMUBH *bh)
3435 {
3436     bh->scheduled = 0;
3437     bh->deleted = 1;
3438 }
3439
3440 static void qemu_bh_update_timeout(int *timeout)
3441 {
3442     QEMUBH *bh;
3443
3444     for (bh = first_bh; bh; bh = bh->next) {
3445         if (!bh->deleted && bh->scheduled) {
3446             if (bh->idle) {
3447                 /* idle bottom halves will be polled at least
3448                  * every 10ms */
3449                 *timeout = MIN(10, *timeout);
3450             } else {
3451                 /* non-idle bottom halves will be executed
3452                  * immediately */
3453                 *timeout = 0;
3454                 break;
3455             }
3456         }
3457     }
3458 }
3459
3460 /***********************************************************/
3461 /* machine registration */
3462
3463 static QEMUMachine *first_machine = NULL;
3464 QEMUMachine *current_machine = NULL;
3465
3466 int qemu_register_machine(QEMUMachine *m)
3467 {
3468     QEMUMachine **pm;
3469     pm = &first_machine;
3470     while (*pm != NULL)
3471         pm = &(*pm)->next;
3472     m->next = NULL;
3473     *pm = m;
3474     return 0;
3475 }
3476
3477 static QEMUMachine *find_machine(const char *name)
3478 {
3479     QEMUMachine *m;
3480
3481     for(m = first_machine; m != NULL; m = m->next) {
3482         if (!strcmp(m->name, name))
3483             return m;
3484     }
3485     return NULL;
3486 }
3487
3488 static QEMUMachine *find_default_machine(void)
3489 {
3490     QEMUMachine *m;
3491
3492     for(m = first_machine; m != NULL; m = m->next) {
3493         if (m->is_default) {
3494             return m;
3495         }
3496     }
3497     return NULL;
3498 }
3499
3500 /***********************************************************/
3501 /* main execution loop */
3502
3503 static void gui_update(void *opaque)
3504 {
3505     uint64_t interval = GUI_REFRESH_INTERVAL;
3506     DisplayState *ds = opaque;
3507     DisplayChangeListener *dcl = ds->listeners;
3508
3509     dpy_refresh(ds);
3510
3511     while (dcl != NULL) {
3512         if (dcl->gui_timer_interval &&
3513             dcl->gui_timer_interval < interval)
3514             interval = dcl->gui_timer_interval;
3515         dcl = dcl->next;
3516     }
3517     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3518 }
3519
3520 static void nographic_update(void *opaque)
3521 {
3522     uint64_t interval = GUI_REFRESH_INTERVAL;
3523
3524     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3525 }
3526
3527 struct vm_change_state_entry {
3528     VMChangeStateHandler *cb;
3529     void *opaque;
3530     LIST_ENTRY (vm_change_state_entry) entries;
3531 };
3532
3533 static LIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3534
3535 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3536                                                      void *opaque)
3537 {
3538     VMChangeStateEntry *e;
3539
3540     e = qemu_mallocz(sizeof (*e));
3541
3542     e->cb = cb;
3543     e->opaque = opaque;
3544     LIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3545     return e;
3546 }
3547
3548 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3549 {
3550     LIST_REMOVE (e, entries);
3551     qemu_free (e);
3552 }
3553
3554 static void vm_state_notify(int running, int reason)
3555 {
3556     VMChangeStateEntry *e;
3557
3558     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3559         e->cb(e->opaque, running, reason);
3560     }
3561 }
3562
3563 static void resume_all_vcpus(void);
3564 static void pause_all_vcpus(void);
3565
3566 void vm_start(void)
3567 {
3568     if (!vm_running) {
3569         cpu_enable_ticks();
3570         vm_running = 1;
3571         vm_state_notify(1, 0);
3572         qemu_rearm_alarm_timer(alarm_timer);
3573         resume_all_vcpus();
3574     }
3575 }
3576
3577 /* reset/shutdown handler */
3578
3579 typedef struct QEMUResetEntry {
3580     QEMUResetHandler *func;
3581     void *opaque;
3582     int order;
3583     struct QEMUResetEntry *next;
3584 } QEMUResetEntry;
3585
3586 static QEMUResetEntry *first_reset_entry;
3587 static int reset_requested;
3588 static int shutdown_requested;
3589 static int powerdown_requested;
3590 static int debug_requested;
3591 static int vmstop_requested;
3592
3593 int qemu_shutdown_requested(void)
3594 {
3595     int r = shutdown_requested;
3596     shutdown_requested = 0;
3597     return r;
3598 }
3599
3600 int qemu_reset_requested(void)
3601 {
3602     int r = reset_requested;
3603     reset_requested = 0;
3604     return r;
3605 }
3606
3607 int qemu_powerdown_requested(void)
3608 {
3609     int r = powerdown_requested;
3610     powerdown_requested = 0;
3611     return r;
3612 }
3613
3614 static int qemu_debug_requested(void)
3615 {
3616     int r = debug_requested;
3617     debug_requested = 0;
3618     return r;
3619 }
3620
3621 static int qemu_vmstop_requested(void)
3622 {
3623     int r = vmstop_requested;
3624     vmstop_requested = 0;
3625     return r;
3626 }
3627
3628 static void do_vm_stop(int reason)
3629 {
3630     if (vm_running) {
3631         cpu_disable_ticks();
3632         vm_running = 0;
3633         pause_all_vcpus();
3634         vm_state_notify(0, reason);
3635     }
3636 }
3637
3638 void qemu_register_reset(QEMUResetHandler *func, int order, void *opaque)
3639 {
3640     QEMUResetEntry **pre, *re;
3641
3642     pre = &first_reset_entry;
3643     while (*pre != NULL && (*pre)->order >= order) {
3644         pre = &(*pre)->next;
3645     }
3646     re = qemu_mallocz(sizeof(QEMUResetEntry));
3647     re->func = func;
3648     re->opaque = opaque;
3649     re->order = order;
3650     re->next = NULL;
3651     *pre = re;
3652 }
3653
3654 void qemu_system_reset(void)
3655 {
3656     QEMUResetEntry *re;
3657
3658     /* reset all devices */
3659     for(re = first_reset_entry; re != NULL; re = re->next) {
3660         re->func(re->opaque);
3661     }
3662 }
3663
3664 void qemu_system_reset_request(void)
3665 {
3666     if (no_reboot) {
3667         shutdown_requested = 1;
3668     } else {
3669         reset_requested = 1;
3670     }
3671     qemu_notify_event();
3672 }
3673
3674 void qemu_system_shutdown_request(void)
3675 {
3676     shutdown_requested = 1;
3677     qemu_notify_event();
3678 }
3679
3680 void qemu_system_powerdown_request(void)
3681 {
3682     powerdown_requested = 1;
3683     qemu_notify_event();
3684 }
3685
3686 #ifdef CONFIG_IOTHREAD
3687 static void qemu_system_vmstop_request(int reason)
3688 {
3689     vmstop_requested = reason;
3690     qemu_notify_event();
3691 }
3692 #endif
3693
3694 #ifndef _WIN32
3695 static int io_thread_fd = -1;
3696
3697 static void qemu_event_increment(void)
3698 {
3699     static const char byte = 0;
3700
3701     if (io_thread_fd == -1)
3702         return;
3703
3704     write(io_thread_fd, &byte, sizeof(byte));
3705 }
3706
3707 static void qemu_event_read(void *opaque)
3708 {
3709     int fd = (unsigned long)opaque;
3710     ssize_t len;
3711
3712     /* Drain the notify pipe */
3713     do {
3714         char buffer[512];
3715         len = read(fd, buffer, sizeof(buffer));
3716     } while ((len == -1 && errno == EINTR) || len > 0);
3717 }
3718
3719 static int qemu_event_init(void)
3720 {
3721     int err;
3722     int fds[2];
3723
3724     err = pipe(fds);
3725     if (err == -1)
3726         return -errno;
3727
3728     err = fcntl_setfl(fds[0], O_NONBLOCK);
3729     if (err < 0)
3730         goto fail;
3731
3732     err = fcntl_setfl(fds[1], O_NONBLOCK);
3733     if (err < 0)
3734         goto fail;
3735
3736     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3737                          (void *)(unsigned long)fds[0]);
3738
3739     io_thread_fd = fds[1];
3740     return 0;
3741
3742 fail:
3743     close(fds[0]);
3744     close(fds[1]);
3745     return err;
3746 }
3747 #else
3748 HANDLE qemu_event_handle;
3749
3750 static void dummy_event_handler(void *opaque)
3751 {
3752 }
3753
3754 static int qemu_event_init(void)
3755 {
3756     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3757     if (!qemu_event_handle) {
3758         perror("Failed CreateEvent");
3759         return -1;
3760     }
3761     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3762     return 0;
3763 }
3764
3765 static void qemu_event_increment(void)
3766 {
3767     SetEvent(qemu_event_handle);
3768 }
3769 #endif
3770
3771 static int cpu_can_run(CPUState *env)
3772 {
3773     if (env->stop)
3774         return 0;
3775     if (env->stopped)
3776         return 0;
3777     return 1;
3778 }
3779
3780 #ifndef CONFIG_IOTHREAD
3781 static int qemu_init_main_loop(void)
3782 {
3783     return qemu_event_init();
3784 }
3785
3786 void qemu_init_vcpu(void *_env)
3787 {
3788     CPUState *env = _env;
3789
3790     if (kvm_enabled())
3791         kvm_init_vcpu(env);
3792     return;
3793 }
3794
3795 int qemu_cpu_self(void *env)
3796 {
3797     return 1;
3798 }
3799
3800 static void resume_all_vcpus(void)
3801 {
3802 }
3803
3804 static void pause_all_vcpus(void)
3805 {
3806 }
3807
3808 void qemu_cpu_kick(void *env)
3809 {
3810     return;
3811 }
3812
3813 void qemu_notify_event(void)
3814 {
3815     CPUState *env = cpu_single_env;
3816
3817     if (env) {
3818         cpu_exit(env);
3819 #ifdef USE_KQEMU
3820         if (env->kqemu_enabled)
3821             kqemu_cpu_interrupt(env);
3822 #endif
3823      }
3824 }
3825
3826 #define qemu_mutex_lock_iothread() do { } while (0)
3827 #define qemu_mutex_unlock_iothread() do { } while (0)
3828
3829 void vm_stop(int reason)
3830 {
3831     do_vm_stop(reason);
3832 }
3833
3834 #else /* CONFIG_IOTHREAD */
3835
3836 #include "qemu-thread.h"
3837
3838 QemuMutex qemu_global_mutex;
3839 static QemuMutex qemu_fair_mutex;
3840
3841 static QemuThread io_thread;
3842
3843 static QemuThread *tcg_cpu_thread;
3844 static QemuCond *tcg_halt_cond;
3845
3846 static int qemu_system_ready;
3847 /* cpu creation */
3848 static QemuCond qemu_cpu_cond;
3849 /* system init */
3850 static QemuCond qemu_system_cond;
3851 static QemuCond qemu_pause_cond;
3852
3853 static void block_io_signals(void);
3854 static void unblock_io_signals(void);
3855 static int tcg_has_work(void);
3856
3857 static int qemu_init_main_loop(void)
3858 {
3859     int ret;
3860
3861     ret = qemu_event_init();
3862     if (ret)
3863         return ret;
3864
3865     qemu_cond_init(&qemu_pause_cond);
3866     qemu_mutex_init(&qemu_fair_mutex);
3867     qemu_mutex_init(&qemu_global_mutex);
3868     qemu_mutex_lock(&qemu_global_mutex);
3869
3870     unblock_io_signals();
3871     qemu_thread_self(&io_thread);
3872
3873     return 0;
3874 }
3875
3876 static void qemu_wait_io_event(CPUState *env)
3877 {
3878     while (!tcg_has_work())
3879         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3880
3881     qemu_mutex_unlock(&qemu_global_mutex);
3882
3883     /*
3884      * Users of qemu_global_mutex can be starved, having no chance
3885      * to acquire it since this path will get to it first.
3886      * So use another lock to provide fairness.
3887      */
3888     qemu_mutex_lock(&qemu_fair_mutex);
3889     qemu_mutex_unlock(&qemu_fair_mutex);
3890
3891     qemu_mutex_lock(&qemu_global_mutex);
3892     if (env->stop) {
3893         env->stop = 0;
3894         env->stopped = 1;
3895         qemu_cond_signal(&qemu_pause_cond);
3896     }
3897 }
3898
3899 static int qemu_cpu_exec(CPUState *env);
3900
3901 static void *kvm_cpu_thread_fn(void *arg)
3902 {
3903     CPUState *env = arg;
3904
3905     block_io_signals();
3906     qemu_thread_self(env->thread);
3907
3908     /* signal CPU creation */
3909     qemu_mutex_lock(&qemu_global_mutex);
3910     env->created = 1;
3911     qemu_cond_signal(&qemu_cpu_cond);
3912
3913     /* and wait for machine initialization */
3914     while (!qemu_system_ready)
3915         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3916
3917     while (1) {
3918         if (cpu_can_run(env))
3919             qemu_cpu_exec(env);
3920         qemu_wait_io_event(env);
3921     }
3922
3923     return NULL;
3924 }
3925
3926 static void tcg_cpu_exec(void);
3927
3928 static void *tcg_cpu_thread_fn(void *arg)
3929 {
3930     CPUState *env = arg;
3931
3932     block_io_signals();
3933     qemu_thread_self(env->thread);
3934
3935     /* signal CPU creation */
3936     qemu_mutex_lock(&qemu_global_mutex);
3937     for (env = first_cpu; env != NULL; env = env->next_cpu)
3938         env->created = 1;
3939     qemu_cond_signal(&qemu_cpu_cond);
3940
3941     /* and wait for machine initialization */
3942     while (!qemu_system_ready)
3943         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3944
3945     while (1) {
3946         tcg_cpu_exec();
3947         qemu_wait_io_event(cur_cpu);
3948     }
3949
3950     return NULL;
3951 }
3952
3953 void qemu_cpu_kick(void *_env)
3954 {
3955     CPUState *env = _env;
3956     qemu_cond_broadcast(env->halt_cond);
3957     if (kvm_enabled())
3958         qemu_thread_signal(env->thread, SIGUSR1);
3959 }
3960
3961 int qemu_cpu_self(void *env)
3962 {
3963     return (cpu_single_env != NULL);
3964 }
3965
3966 static void cpu_signal(int sig)
3967 {
3968     if (cpu_single_env)
3969         cpu_exit(cpu_single_env);
3970 }
3971
3972 static void block_io_signals(void)
3973 {
3974     sigset_t set;
3975     struct sigaction sigact;
3976
3977     sigemptyset(&set);
3978     sigaddset(&set, SIGUSR2);
3979     sigaddset(&set, SIGIO);
3980     sigaddset(&set, SIGALRM);
3981     pthread_sigmask(SIG_BLOCK, &set, NULL);
3982
3983     sigemptyset(&set);
3984     sigaddset(&set, SIGUSR1);
3985     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3986
3987     memset(&sigact, 0, sizeof(sigact));
3988     sigact.sa_handler = cpu_signal;
3989     sigaction(SIGUSR1, &sigact, NULL);
3990 }
3991
3992 static void unblock_io_signals(void)
3993 {
3994     sigset_t set;
3995
3996     sigemptyset(&set);
3997     sigaddset(&set, SIGUSR2);
3998     sigaddset(&set, SIGIO);
3999     sigaddset(&set, SIGALRM);
4000     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
4001
4002     sigemptyset(&set);
4003     sigaddset(&set, SIGUSR1);
4004     pthread_sigmask(SIG_BLOCK, &set, NULL);
4005 }
4006
4007 static void qemu_signal_lock(unsigned int msecs)
4008 {
4009     qemu_mutex_lock(&qemu_fair_mutex);
4010
4011     while (qemu_mutex_trylock(&qemu_global_mutex)) {
4012         qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
4013         if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
4014             break;
4015     }
4016     qemu_mutex_unlock(&qemu_fair_mutex);
4017 }
4018
4019 static void qemu_mutex_lock_iothread(void)
4020 {
4021     if (kvm_enabled()) {
4022         qemu_mutex_lock(&qemu_fair_mutex);
4023         qemu_mutex_lock(&qemu_global_mutex);
4024         qemu_mutex_unlock(&qemu_fair_mutex);
4025     } else
4026         qemu_signal_lock(100);
4027 }
4028
4029 static void qemu_mutex_unlock_iothread(void)
4030 {
4031     qemu_mutex_unlock(&qemu_global_mutex);
4032 }
4033
4034 static int all_vcpus_paused(void)
4035 {
4036     CPUState *penv = first_cpu;
4037
4038     while (penv) {
4039         if (!penv->stopped)
4040             return 0;
4041         penv = (CPUState *)penv->next_cpu;
4042     }
4043
4044     return 1;
4045 }
4046
4047 static void pause_all_vcpus(void)
4048 {
4049     CPUState *penv = first_cpu;
4050
4051     while (penv) {
4052         penv->stop = 1;
4053         qemu_thread_signal(penv->thread, SIGUSR1);
4054         qemu_cpu_kick(penv);
4055         penv = (CPUState *)penv->next_cpu;
4056     }
4057
4058     while (!all_vcpus_paused()) {
4059         qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
4060         penv = first_cpu;
4061         while (penv) {
4062             qemu_thread_signal(penv->thread, SIGUSR1);
4063             penv = (CPUState *)penv->next_cpu;
4064         }
4065     }
4066 }
4067
4068 static void resume_all_vcpus(void)
4069 {
4070     CPUState *penv = first_cpu;
4071
4072     while (penv) {
4073         penv->stop = 0;
4074         penv->stopped = 0;
4075         qemu_thread_signal(penv->thread, SIGUSR1);
4076         qemu_cpu_kick(penv);
4077         penv = (CPUState *)penv->next_cpu;
4078     }
4079 }
4080
4081 static void tcg_init_vcpu(void *_env)
4082 {
4083     CPUState *env = _env;
4084     /* share a single thread for all cpus with TCG */
4085     if (!tcg_cpu_thread) {
4086         env->thread = qemu_mallocz(sizeof(QemuThread));
4087         env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4088         qemu_cond_init(env->halt_cond);
4089         qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
4090         while (env->created == 0)
4091             qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4092         tcg_cpu_thread = env->thread;
4093         tcg_halt_cond = env->halt_cond;
4094     } else {
4095         env->thread = tcg_cpu_thread;
4096         env->halt_cond = tcg_halt_cond;
4097     }
4098 }
4099
4100 static void kvm_start_vcpu(CPUState *env)
4101 {
4102     kvm_init_vcpu(env);
4103     env->thread = qemu_mallocz(sizeof(QemuThread));
4104     env->halt_cond = qemu_mallocz(sizeof(QemuCond));
4105     qemu_cond_init(env->halt_cond);
4106     qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
4107     while (env->created == 0)
4108         qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
4109 }
4110
4111 void qemu_init_vcpu(void *_env)
4112 {
4113     CPUState *env = _env;
4114
4115     if (kvm_enabled())
4116         kvm_start_vcpu(env);
4117     else
4118         tcg_init_vcpu(env);
4119 }
4120
4121 void qemu_notify_event(void)
4122 {
4123     qemu_event_increment();
4124 }
4125
4126 void vm_stop(int reason)
4127 {
4128     QemuThread me;
4129     qemu_thread_self(&me);
4130
4131     if (!qemu_thread_equal(&me, &io_thread)) {
4132         qemu_system_vmstop_request(reason);
4133         /*
4134          * FIXME: should not return to device code in case
4135          * vm_stop() has been requested.
4136          */
4137         if (cpu_single_env) {
4138             cpu_exit(cpu_single_env);
4139             cpu_single_env->stop = 1;
4140         }
4141         return;
4142     }
4143     do_vm_stop(reason);
4144 }
4145
4146 #endif
4147
4148
4149 #ifdef _WIN32
4150 static void host_main_loop_wait(int *timeout)
4151 {
4152     int ret, ret2, i;
4153     PollingEntry *pe;
4154
4155
4156     /* XXX: need to suppress polling by better using win32 events */
4157     ret = 0;
4158     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
4159         ret |= pe->func(pe->opaque);
4160     }
4161     if (ret == 0) {
4162         int err;
4163         WaitObjects *w = &wait_objects;
4164
4165         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
4166         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
4167             if (w->func[ret - WAIT_OBJECT_0])
4168                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
4169
4170             /* Check for additional signaled events */
4171             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
4172
4173                 /* Check if event is signaled */
4174                 ret2 = WaitForSingleObject(w->events[i], 0);
4175                 if(ret2 == WAIT_OBJECT_0) {
4176                     if (w->func[i])
4177                         w->func[i](w->opaque[i]);
4178                 } else if (ret2 == WAIT_TIMEOUT) {
4179                 } else {
4180                     err = GetLastError();
4181                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
4182                 }
4183             }
4184         } else if (ret == WAIT_TIMEOUT) {
4185         } else {
4186             err = GetLastError();
4187             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
4188         }
4189     }
4190
4191     *timeout = 0;
4192 }
4193 #else
4194 static void host_main_loop_wait(int *timeout)
4195 {
4196 }
4197 #endif
4198
4199 void main_loop_wait(int timeout)
4200 {
4201     IOHandlerRecord *ioh;
4202     fd_set rfds, wfds, xfds;
4203     int ret, nfds;
4204     struct timeval tv;
4205
4206     qemu_bh_update_timeout(&timeout);
4207
4208     host_main_loop_wait(&timeout);
4209
4210     /* poll any events */
4211     /* XXX: separate device handlers from system ones */
4212     nfds = -1;
4213     FD_ZERO(&rfds);
4214     FD_ZERO(&wfds);
4215     FD_ZERO(&xfds);
4216     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4217         if (ioh->deleted)
4218             continue;
4219         if (ioh->fd_read &&
4220             (!ioh->fd_read_poll ||
4221              ioh->fd_read_poll(ioh->opaque) != 0)) {
4222             FD_SET(ioh->fd, &rfds);
4223             if (ioh->fd > nfds)
4224                 nfds = ioh->fd;
4225         }
4226         if (ioh->fd_write) {
4227             FD_SET(ioh->fd, &wfds);
4228             if (ioh->fd > nfds)
4229                 nfds = ioh->fd;
4230         }
4231     }
4232
4233     tv.tv_sec = timeout / 1000;
4234     tv.tv_usec = (timeout % 1000) * 1000;
4235
4236 #if defined(CONFIG_SLIRP)
4237     if (slirp_is_inited()) {
4238         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
4239     }
4240 #endif
4241     qemu_mutex_unlock_iothread();
4242     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
4243     qemu_mutex_lock_iothread();
4244     if (ret > 0) {
4245         IOHandlerRecord **pioh;
4246
4247         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
4248             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
4249                 ioh->fd_read(ioh->opaque);
4250             }
4251             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
4252                 ioh->fd_write(ioh->opaque);
4253             }
4254         }
4255
4256         /* remove deleted IO handlers */
4257         pioh = &first_io_handler;
4258         while (*pioh) {
4259             ioh = *pioh;
4260             if (ioh->deleted) {
4261                 *pioh = ioh->next;
4262                 qemu_free(ioh);
4263             } else
4264                 pioh = &ioh->next;
4265         }
4266     }
4267 #if defined(CONFIG_SLIRP)
4268     if (slirp_is_inited()) {
4269         if (ret < 0) {
4270             FD_ZERO(&rfds);
4271             FD_ZERO(&wfds);
4272             FD_ZERO(&xfds);
4273         }
4274         slirp_select_poll(&rfds, &wfds, &xfds);
4275     }
4276 #endif
4277
4278     /* rearm timer, if not periodic */
4279     if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
4280         alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
4281         qemu_rearm_alarm_timer(alarm_timer);
4282     }
4283
4284     /* vm time timers */
4285     if (vm_running) {
4286         if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
4287             qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
4288                 qemu_get_clock(vm_clock));
4289     }
4290
4291     /* real time timers */
4292     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
4293                     qemu_get_clock(rt_clock));
4294
4295     /* Check bottom-halves last in case any of the earlier events triggered
4296        them.  */
4297     qemu_bh_poll();
4298
4299 }
4300
4301 static int qemu_cpu_exec(CPUState *env)
4302 {
4303     int ret;
4304 #ifdef CONFIG_PROFILER
4305     int64_t ti;
4306 #endif
4307
4308 #ifdef CONFIG_PROFILER
4309     ti = profile_getclock();
4310 #endif
4311     if (use_icount) {
4312         int64_t count;
4313         int decr;
4314         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
4315         env->icount_decr.u16.low = 0;
4316         env->icount_extra = 0;
4317         count = qemu_next_deadline();
4318         count = (count + (1 << icount_time_shift) - 1)
4319                 >> icount_time_shift;
4320         qemu_icount += count;
4321         decr = (count > 0xffff) ? 0xffff : count;
4322         count -= decr;
4323         env->icount_decr.u16.low = decr;
4324         env->icount_extra = count;
4325     }
4326     ret = cpu_exec(env);
4327 #ifdef CONFIG_PROFILER
4328     qemu_time += profile_getclock() - ti;
4329 #endif
4330     if (use_icount) {
4331         /* Fold pending instructions back into the
4332            instruction counter, and clear the interrupt flag.  */
4333         qemu_icount -= (env->icount_decr.u16.low
4334                         + env->icount_extra);
4335         env->icount_decr.u32 = 0;
4336         env->icount_extra = 0;
4337     }
4338     return ret;
4339 }
4340
4341 static void tcg_cpu_exec(void)
4342 {
4343     int ret = 0;
4344
4345     if (next_cpu == NULL)
4346         next_cpu = first_cpu;
4347     for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4348         CPUState *env = cur_cpu = next_cpu;
4349
4350         if (!vm_running)
4351             break;
4352         if (timer_alarm_pending) {
4353             timer_alarm_pending = 0;
4354             break;
4355         }
4356         if (cpu_can_run(env))
4357             ret = qemu_cpu_exec(env);
4358         if (ret == EXCP_DEBUG) {
4359             gdb_set_stop_cpu(env);
4360             debug_requested = 1;
4361             break;
4362         }
4363     }
4364 }
4365
4366 static int cpu_has_work(CPUState *env)
4367 {
4368     if (env->stop)
4369         return 1;
4370     if (env->stopped)
4371         return 0;
4372     if (!env->halted)
4373         return 1;
4374     if (qemu_cpu_has_work(env))
4375         return 1;
4376     return 0;
4377 }
4378
4379 static int tcg_has_work(void)
4380 {
4381     CPUState *env;
4382
4383     for (env = first_cpu; env != NULL; env = env->next_cpu)
4384         if (cpu_has_work(env))
4385             return 1;
4386     return 0;
4387 }
4388
4389 static int qemu_calculate_timeout(void)
4390 {
4391     int timeout;
4392
4393     if (!vm_running)
4394         timeout = 5000;
4395     else if (tcg_has_work())
4396         timeout = 0;
4397     else if (!use_icount)
4398         timeout = 5000;
4399     else {
4400      /* XXX: use timeout computed from timers */
4401         int64_t add;
4402         int64_t delta;
4403         /* Advance virtual time to the next event.  */
4404         if (use_icount == 1) {
4405             /* When not using an adaptive execution frequency
4406                we tend to get badly out of sync with real time,
4407                so just delay for a reasonable amount of time.  */
4408             delta = 0;
4409         } else {
4410             delta = cpu_get_icount() - cpu_get_clock();
4411         }
4412         if (delta > 0) {
4413             /* If virtual time is ahead of real time then just
4414                wait for IO.  */
4415             timeout = (delta / 1000000) + 1;
4416         } else {
4417             /* Wait for either IO to occur or the next
4418                timer event.  */
4419             add = qemu_next_deadline();
4420             /* We advance the timer before checking for IO.
4421                Limit the amount we advance so that early IO
4422                activity won't get the guest too far ahead.  */
4423             if (add > 10000000)
4424                 add = 10000000;
4425             delta += add;
4426             add = (add + (1 << icount_time_shift) - 1)
4427                   >> icount_time_shift;
4428             qemu_icount += add;
4429             timeout = delta / 1000000;
4430             if (timeout < 0)
4431                 timeout = 0;
4432         }
4433     }
4434
4435     return timeout;
4436 }
4437
4438 static int vm_can_run(void)
4439 {
4440     if (powerdown_requested)
4441         return 0;
4442     if (reset_requested)
4443         return 0;
4444     if (shutdown_requested)
4445         return 0;
4446     if (debug_requested)
4447         return 0;
4448     return 1;
4449 }
4450
4451 static void main_loop(void)
4452 {
4453     int r;
4454
4455 #ifdef CONFIG_IOTHREAD
4456     qemu_system_ready = 1;
4457     qemu_cond_broadcast(&qemu_system_cond);
4458 #endif
4459
4460     for (;;) {
4461         do {
4462 #ifdef CONFIG_PROFILER
4463             int64_t ti;
4464 #endif
4465 #ifndef CONFIG_IOTHREAD
4466             tcg_cpu_exec();
4467 #endif
4468 #ifdef CONFIG_PROFILER
4469             ti = profile_getclock();
4470 #endif
4471 #ifdef CONFIG_IOTHREAD
4472             main_loop_wait(1000);
4473 #else
4474             main_loop_wait(qemu_calculate_timeout());
4475 #endif
4476 #ifdef CONFIG_PROFILER
4477             dev_time += profile_getclock() - ti;
4478 #endif
4479         } while (vm_can_run());
4480
4481         if (qemu_debug_requested())
4482             vm_stop(EXCP_DEBUG);
4483         if (qemu_shutdown_requested()) {
4484             if (no_shutdown) {
4485                 vm_stop(0);
4486                 no_shutdown = 0;
4487             } else
4488                 break;
4489         }
4490         if (qemu_reset_requested()) {
4491             pause_all_vcpus();
4492             qemu_system_reset();
4493             resume_all_vcpus();
4494         }
4495         if (qemu_powerdown_requested())
4496             qemu_system_powerdown();
4497         if ((r = qemu_vmstop_requested()))
4498             vm_stop(r);
4499     }
4500     pause_all_vcpus();
4501 }
4502
4503 static void version(void)
4504 {
4505     printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4506 }
4507
4508 static void help(int exitcode)
4509 {
4510     version();
4511     printf("usage: %s [options] [disk_image]\n"
4512            "\n"
4513            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4514            "\n"
4515 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4516            opt_help
4517 #define DEFHEADING(text) stringify(text) "\n"
4518 #include "qemu-options.h"
4519 #undef DEF
4520 #undef DEFHEADING
4521 #undef GEN_DOCS
4522            "\n"
4523            "During emulation, the following keys are useful:\n"
4524            "ctrl-alt-f      toggle full screen\n"
4525            "ctrl-alt-n      switch to virtual console 'n'\n"
4526            "ctrl-alt        toggle mouse and keyboard grab\n"
4527            "\n"
4528            "When using -nographic, press 'ctrl-a h' to get some help.\n"
4529            ,
4530            "qemu",
4531            DEFAULT_RAM_SIZE,
4532 #ifndef _WIN32
4533            DEFAULT_NETWORK_SCRIPT,
4534            DEFAULT_NETWORK_DOWN_SCRIPT,
4535 #endif
4536            DEFAULT_GDBSTUB_PORT,
4537            "/tmp/qemu.log");
4538     exit(exitcode);
4539 }
4540
4541 #define HAS_ARG 0x0001
4542
4543 enum {
4544 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4545     opt_enum,
4546 #define DEFHEADING(text)
4547 #include "qemu-options.h"
4548 #undef DEF
4549 #undef DEFHEADING
4550 #undef GEN_DOCS
4551 };
4552
4553 typedef struct QEMUOption {
4554     const char *name;
4555     int flags;
4556     int index;
4557 } QEMUOption;
4558
4559 static const QEMUOption qemu_options[] = {
4560     { "h", 0, QEMU_OPTION_h },
4561 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4562     { option, opt_arg, opt_enum },
4563 #define DEFHEADING(text)
4564 #include "qemu-options.h"
4565 #undef DEF
4566 #undef DEFHEADING
4567 #undef GEN_DOCS
4568     { NULL },
4569 };
4570
4571 #ifdef HAS_AUDIO
4572 struct soundhw soundhw[] = {
4573 #ifdef HAS_AUDIO_CHOICE
4574 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4575     {
4576         "pcspk",
4577         "PC speaker",
4578         0,
4579         1,
4580         { .init_isa = pcspk_audio_init }
4581     },
4582 #endif
4583
4584 #ifdef CONFIG_SB16
4585     {
4586         "sb16",
4587         "Creative Sound Blaster 16",
4588         0,
4589         1,
4590         { .init_isa = SB16_init }
4591     },
4592 #endif
4593
4594 #ifdef CONFIG_CS4231A
4595     {
4596         "cs4231a",
4597         "CS4231A",
4598         0,
4599         1,
4600         { .init_isa = cs4231a_init }
4601     },
4602 #endif
4603
4604 #ifdef CONFIG_ADLIB
4605     {
4606         "adlib",
4607 #ifdef HAS_YMF262
4608         "Yamaha YMF262 (OPL3)",
4609 #else
4610         "Yamaha YM3812 (OPL2)",
4611 #endif
4612         0,
4613         1,
4614         { .init_isa = Adlib_init }
4615     },
4616 #endif
4617
4618 #ifdef CONFIG_GUS
4619     {
4620         "gus",
4621         "Gravis Ultrasound GF1",
4622         0,
4623         1,
4624         { .init_isa = GUS_init }
4625     },
4626 #endif
4627
4628 #ifdef CONFIG_AC97
4629     {
4630         "ac97",
4631         "Intel 82801AA AC97 Audio",
4632         0,
4633         0,
4634         { .init_pci = ac97_init }
4635     },
4636 #endif
4637
4638 #ifdef CONFIG_ES1370
4639     {
4640         "es1370",
4641         "ENSONIQ AudioPCI ES1370",
4642         0,
4643         0,
4644         { .init_pci = es1370_init }
4645     },
4646 #endif
4647
4648 #endif /* HAS_AUDIO_CHOICE */
4649
4650     { NULL, NULL, 0, 0, { NULL } }
4651 };
4652
4653 static void select_soundhw (const char *optarg)
4654 {
4655     struct soundhw *c;
4656
4657     if (*optarg == '?') {
4658     show_valid_cards:
4659
4660         printf ("Valid sound card names (comma separated):\n");
4661         for (c = soundhw; c->name; ++c) {
4662             printf ("%-11s %s\n", c->name, c->descr);
4663         }
4664         printf ("\n-soundhw all will enable all of the above\n");
4665         exit (*optarg != '?');
4666     }
4667     else {
4668         size_t l;
4669         const char *p;
4670         char *e;
4671         int bad_card = 0;
4672
4673         if (!strcmp (optarg, "all")) {
4674             for (c = soundhw; c->name; ++c) {
4675                 c->enabled = 1;
4676             }
4677             return;
4678         }
4679
4680         p = optarg;
4681         while (*p) {
4682             e = strchr (p, ',');
4683             l = !e ? strlen (p) : (size_t) (e - p);
4684
4685             for (c = soundhw; c->name; ++c) {
4686                 if (!strncmp (c->name, p, l)) {
4687                     c->enabled = 1;
4688                     break;
4689                 }
4690             }
4691
4692             if (!c->name) {
4693                 if (l > 80) {
4694                     fprintf (stderr,
4695                              "Unknown sound card name (too big to show)\n");
4696                 }
4697                 else {
4698                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4699                              (int) l, p);
4700                 }
4701                 bad_card = 1;
4702             }
4703             p += l + (e != NULL);
4704         }
4705
4706         if (bad_card)
4707             goto show_valid_cards;
4708     }
4709 }
4710 #endif
4711
4712 static void select_vgahw (const char *p)
4713 {
4714     const char *opts;
4715
4716     cirrus_vga_enabled = 0;
4717     std_vga_enabled = 0;
4718     vmsvga_enabled = 0;
4719     xenfb_enabled = 0;
4720     if (strstart(p, "std", &opts)) {
4721         std_vga_enabled = 1;
4722     } else if (strstart(p, "cirrus", &opts)) {
4723         cirrus_vga_enabled = 1;
4724     } else if (strstart(p, "vmware", &opts)) {
4725         vmsvga_enabled = 1;
4726     } else if (strstart(p, "xenfb", &opts)) {
4727         xenfb_enabled = 1;
4728     } else if (!strstart(p, "none", &opts)) {
4729     invalid_vga:
4730         fprintf(stderr, "Unknown vga type: %s\n", p);
4731         exit(1);
4732     }
4733     while (*opts) {
4734         const char *nextopt;
4735
4736         if (strstart(opts, ",retrace=", &nextopt)) {
4737             opts = nextopt;
4738             if (strstart(opts, "dumb", &nextopt))
4739                 vga_retrace_method = VGA_RETRACE_DUMB;
4740             else if (strstart(opts, "precise", &nextopt))
4741                 vga_retrace_method = VGA_RETRACE_PRECISE;
4742             else goto invalid_vga;
4743         } else goto invalid_vga;
4744         opts = nextopt;
4745     }
4746 }
4747
4748 #ifdef _WIN32
4749 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4750 {
4751     exit(STATUS_CONTROL_C_EXIT);
4752     return TRUE;
4753 }
4754 #endif
4755
4756 int qemu_uuid_parse(const char *str, uint8_t *uuid)
4757 {
4758     int ret;
4759
4760     if(strlen(str) != 36)
4761         return -1;
4762
4763     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4764             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4765             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4766
4767     if(ret != 16)
4768         return -1;
4769
4770 #ifdef TARGET_I386
4771     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4772 #endif
4773
4774     return 0;
4775 }
4776
4777 #define MAX_NET_CLIENTS 32
4778
4779 #ifndef _WIN32
4780
4781 static void termsig_handler(int signal)
4782 {
4783     qemu_system_shutdown_request();
4784 }
4785
4786 static void termsig_setup(void)
4787 {
4788     struct sigaction act;
4789
4790     memset(&act, 0, sizeof(act));
4791     act.sa_handler = termsig_handler;
4792     sigaction(SIGINT,  &act, NULL);
4793     sigaction(SIGHUP,  &act, NULL);
4794     sigaction(SIGTERM, &act, NULL);
4795 }
4796
4797 #endif
4798
4799 #ifdef _WIN32
4800 /* Look for support files in the same directory as the executable.  */
4801 static char *find_datadir(const char *argv0)
4802 {
4803     char *p;
4804     char buf[MAX_PATH];
4805     DWORD len;
4806
4807     len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4808     if (len == 0) {
4809         return NULL;
4810     }
4811
4812     buf[len] = 0;
4813     p = buf + len - 1;
4814     while (p != buf && *p != '\\')
4815         p--;
4816     *p = 0;
4817     if (access(buf, R_OK) == 0) {
4818         return qemu_strdup(buf);
4819     }
4820     return NULL;
4821 }
4822 #else /* !_WIN32 */
4823
4824 /* Find a likely location for support files using the location of the binary.
4825    For installed binaries this will be "$bindir/../share/qemu".  When
4826    running from the build tree this will be "$bindir/../pc-bios".  */
4827 #define SHARE_SUFFIX "/share/qemu"
4828 #define BUILD_SUFFIX "/pc-bios"
4829 static char *find_datadir(const char *argv0)
4830 {
4831     char *dir;
4832     char *p = NULL;
4833     char *res;
4834 #ifdef PATH_MAX
4835     char buf[PATH_MAX];
4836 #endif
4837     size_t max_len;
4838
4839 #if defined(__linux__)
4840     {
4841         int len;
4842         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4843         if (len > 0) {
4844             buf[len] = 0;
4845             p = buf;
4846         }
4847     }
4848 #elif defined(__FreeBSD__)
4849     {
4850         int len;
4851         len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4852         if (len > 0) {
4853             buf[len] = 0;
4854             p = buf;
4855         }
4856     }
4857 #endif
4858     /* If we don't have any way of figuring out the actual executable
4859        location then try argv[0].  */
4860     if (!p) {
4861 #ifdef PATH_MAX
4862         p = buf;
4863 #endif
4864         p = realpath(argv0, p);
4865         if (!p) {
4866             return NULL;
4867         }
4868     }
4869     dir = dirname(p);
4870     dir = dirname(dir);
4871
4872     max_len = strlen(dir) +
4873         MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4874     res = qemu_mallocz(max_len);
4875     snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4876     if (access(res, R_OK)) {
4877         snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4878         if (access(res, R_OK)) {
4879             qemu_free(res);
4880             res = NULL;
4881         }
4882     }
4883 #ifndef PATH_MAX
4884     free(p);
4885 #endif
4886     return res;
4887 }
4888 #undef SHARE_SUFFIX
4889 #undef BUILD_SUFFIX
4890 #endif
4891
4892 char *qemu_find_file(int type, const char *name)
4893 {
4894     int len;
4895     const char *subdir;
4896     char *buf;
4897
4898     /* If name contains path separators then try it as a straight path.  */
4899     if ((strchr(name, '/') || strchr(name, '\\'))
4900         && access(name, R_OK) == 0) {
4901         return strdup(name);
4902     }
4903     switch (type) {
4904     case QEMU_FILE_TYPE_BIOS:
4905         subdir = "";
4906         break;
4907     case QEMU_FILE_TYPE_KEYMAP:
4908         subdir = "keymaps/";
4909         break;
4910     default:
4911         abort();
4912     }
4913     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4914     buf = qemu_mallocz(len);
4915     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4916     if (access(buf, R_OK)) {
4917         qemu_free(buf);
4918         return NULL;
4919     }
4920     return buf;
4921 }
4922
4923 int main(int argc, char **argv, char **envp)
4924 {
4925     const char *gdbstub_dev = NULL;
4926     uint32_t boot_devices_bitmap = 0;
4927     int i;
4928     int snapshot, linux_boot, net_boot;
4929     const char *initrd_filename;
4930     const char *kernel_filename, *kernel_cmdline;
4931     const char *boot_devices = "";
4932     DisplayState *ds;
4933     DisplayChangeListener *dcl;
4934     int cyls, heads, secs, translation;
4935     const char *net_clients[MAX_NET_CLIENTS];
4936     int nb_net_clients;
4937     const char *bt_opts[MAX_BT_CMDLINE];
4938     int nb_bt_opts;
4939     int hda_index;
4940     int optind;
4941     const char *r, *optarg;
4942     CharDriverState *monitor_hd = NULL;
4943     const char *monitor_device;
4944     const char *serial_devices[MAX_SERIAL_PORTS];
4945     int serial_device_index;
4946     const char *parallel_devices[MAX_PARALLEL_PORTS];
4947     int parallel_device_index;
4948     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4949     int virtio_console_index;
4950     const char *loadvm = NULL;
4951     QEMUMachine *machine;
4952     const char *cpu_model;
4953     const char *usb_devices[MAX_USB_CMDLINE];
4954     int usb_devices_index;
4955 #ifndef _WIN32
4956     int fds[2];
4957 #endif
4958     int tb_size;
4959     const char *pid_file = NULL;
4960     const char *incoming = NULL;
4961 #ifndef _WIN32
4962     int fd = 0;
4963     struct passwd *pwd = NULL;
4964     const char *chroot_dir = NULL;
4965     const char *run_as = NULL;
4966 #endif
4967     CPUState *env;
4968     int show_vnc_port = 0;
4969
4970     qemu_cache_utils_init(envp);
4971
4972     LIST_INIT (&vm_change_state_head);
4973 #ifndef _WIN32
4974     {
4975         struct sigaction act;
4976         sigfillset(&act.sa_mask);
4977         act.sa_flags = 0;
4978         act.sa_handler = SIG_IGN;
4979         sigaction(SIGPIPE, &act, NULL);
4980     }
4981 #else
4982     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4983     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4984        QEMU to run on a single CPU */
4985     {
4986         HANDLE h;
4987         DWORD mask, smask;
4988         int i;
4989         h = GetCurrentProcess();
4990         if (GetProcessAffinityMask(h, &mask, &smask)) {
4991             for(i = 0; i < 32; i++) {
4992                 if (mask & (1 << i))
4993                     break;
4994             }
4995             if (i != 32) {
4996                 mask = 1 << i;
4997                 SetProcessAffinityMask(h, mask);
4998             }
4999         }
5000     }
5001 #endif
5002
5003     module_call_init(MODULE_INIT_MACHINE);
5004     machine = find_default_machine();
5005     cpu_model = NULL;
5006     initrd_filename = NULL;
5007     ram_size = 0;
5008     snapshot = 0;
5009     kernel_filename = NULL;
5010     kernel_cmdline = "";
5011     cyls = heads = secs = 0;
5012     translation = BIOS_ATA_TRANSLATION_AUTO;
5013     monitor_device = "vc:80Cx24C";
5014
5015     serial_devices[0] = "vc:80Cx24C";
5016     for(i = 1; i < MAX_SERIAL_PORTS; i++)
5017         serial_devices[i] = NULL;
5018     serial_device_index = 0;
5019
5020     parallel_devices[0] = "vc:80Cx24C";
5021     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
5022         parallel_devices[i] = NULL;
5023     parallel_device_index = 0;
5024
5025     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
5026         virtio_consoles[i] = NULL;
5027     virtio_console_index = 0;
5028
5029     for (i = 0; i < MAX_NODES; i++) {
5030         node_mem[i] = 0;
5031         node_cpumask[i] = 0;
5032     }
5033
5034     usb_devices_index = 0;
5035
5036     nb_net_clients = 0;
5037     nb_bt_opts = 0;
5038     nb_drives = 0;
5039     nb_drives_opt = 0;
5040     nb_numa_nodes = 0;
5041     hda_index = -1;
5042
5043     nb_nics = 0;
5044
5045     tb_size = 0;
5046     autostart= 1;
5047
5048     register_watchdogs();
5049
5050     optind = 1;
5051     for(;;) {
5052         if (optind >= argc)
5053             break;
5054         r = argv[optind];
5055         if (r[0] != '-') {
5056             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
5057         } else {
5058             const QEMUOption *popt;
5059
5060             optind++;
5061             /* Treat --foo the same as -foo.  */
5062             if (r[1] == '-')
5063                 r++;
5064             popt = qemu_options;
5065             for(;;) {
5066                 if (!popt->name) {
5067                     fprintf(stderr, "%s: invalid option -- '%s'\n",
5068                             argv[0], r);
5069                     exit(1);
5070                 }
5071                 if (!strcmp(popt->name, r + 1))
5072                     break;
5073                 popt++;
5074             }
5075             if (popt->flags & HAS_ARG) {
5076                 if (optind >= argc) {
5077                     fprintf(stderr, "%s: option '%s' requires an argument\n",
5078                             argv[0], r);
5079                     exit(1);
5080                 }
5081                 optarg = argv[optind++];
5082             } else {
5083                 optarg = NULL;
5084             }
5085
5086             switch(popt->index) {
5087             case QEMU_OPTION_M:
5088                 machine = find_machine(optarg);
5089                 if (!machine) {
5090                     QEMUMachine *m;
5091                     printf("Supported machines are:\n");
5092                     for(m = first_machine; m != NULL; m = m->next) {
5093                         printf("%-10s %s%s\n",
5094                                m->name, m->desc,
5095                                m->is_default ? " (default)" : "");
5096                     }
5097                     exit(*optarg != '?');
5098                 }
5099                 break;
5100             case QEMU_OPTION_cpu:
5101                 /* hw initialization will check this */
5102                 if (*optarg == '?') {
5103 /* XXX: implement xxx_cpu_list for targets that still miss it */
5104 #if defined(cpu_list)
5105                     cpu_list(stdout, &fprintf);
5106 #endif
5107                     exit(0);
5108                 } else {
5109                     cpu_model = optarg;
5110                 }
5111                 break;
5112             case QEMU_OPTION_initrd:
5113                 initrd_filename = optarg;
5114                 break;
5115             case QEMU_OPTION_hda:
5116                 if (cyls == 0)
5117                     hda_index = drive_add(optarg, HD_ALIAS, 0);
5118                 else
5119                     hda_index = drive_add(optarg, HD_ALIAS
5120                              ",cyls=%d,heads=%d,secs=%d%s",
5121                              0, cyls, heads, secs,
5122                              translation == BIOS_ATA_TRANSLATION_LBA ?
5123                                  ",trans=lba" :
5124                              translation == BIOS_ATA_TRANSLATION_NONE ?
5125                                  ",trans=none" : "");
5126                  break;
5127             case QEMU_OPTION_hdb:
5128             case QEMU_OPTION_hdc:
5129             case QEMU_OPTION_hdd:
5130                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
5131                 break;
5132             case QEMU_OPTION_drive:
5133                 drive_add(NULL, "%s", optarg);
5134                 break;
5135             case QEMU_OPTION_mtdblock:
5136                 drive_add(optarg, MTD_ALIAS);
5137                 break;
5138             case QEMU_OPTION_sd:
5139                 drive_add(optarg, SD_ALIAS);
5140                 break;
5141             case QEMU_OPTION_pflash:
5142                 drive_add(optarg, PFLASH_ALIAS);
5143                 break;
5144             case QEMU_OPTION_snapshot:
5145                 snapshot = 1;
5146                 break;
5147             case QEMU_OPTION_hdachs:
5148                 {
5149                     const char *p;
5150                     p = optarg;
5151                     cyls = strtol(p, (char **)&p, 0);
5152                     if (cyls < 1 || cyls > 16383)
5153                         goto chs_fail;
5154                     if (*p != ',')
5155                         goto chs_fail;
5156                     p++;
5157                     heads = strtol(p, (char **)&p, 0);
5158                     if (heads < 1 || heads > 16)
5159                         goto chs_fail;
5160                     if (*p != ',')
5161                         goto chs_fail;
5162                     p++;
5163                     secs = strtol(p, (char **)&p, 0);
5164                     if (secs < 1 || secs > 63)
5165                         goto chs_fail;
5166                     if (*p == ',') {
5167                         p++;
5168                         if (!strcmp(p, "none"))
5169                             translation = BIOS_ATA_TRANSLATION_NONE;
5170                         else if (!strcmp(p, "lba"))
5171                             translation = BIOS_ATA_TRANSLATION_LBA;
5172                         else if (!strcmp(p, "auto"))
5173                             translation = BIOS_ATA_TRANSLATION_AUTO;
5174                         else
5175                             goto chs_fail;
5176                     } else if (*p != '\0') {
5177                     chs_fail:
5178                         fprintf(stderr, "qemu: invalid physical CHS format\n");
5179                         exit(1);
5180                     }
5181                     if (hda_index != -1)
5182                         snprintf(drives_opt[hda_index].opt,
5183                                  sizeof(drives_opt[hda_index].opt),
5184                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
5185                                  0, cyls, heads, secs,
5186                                  translation == BIOS_ATA_TRANSLATION_LBA ?
5187                                     ",trans=lba" :
5188                                  translation == BIOS_ATA_TRANSLATION_NONE ?
5189                                      ",trans=none" : "");
5190                 }
5191                 break;
5192             case QEMU_OPTION_numa:
5193                 if (nb_numa_nodes >= MAX_NODES) {
5194                     fprintf(stderr, "qemu: too many NUMA nodes\n");
5195                     exit(1);
5196                 }
5197                 numa_add(optarg);
5198                 break;
5199             case QEMU_OPTION_nographic:
5200                 display_type = DT_NOGRAPHIC;
5201                 break;
5202 #ifdef CONFIG_CURSES
5203             case QEMU_OPTION_curses:
5204                 display_type = DT_CURSES;
5205                 break;
5206 #endif
5207             case QEMU_OPTION_portrait:
5208                 graphic_rotate = 1;
5209                 break;
5210             case QEMU_OPTION_kernel:
5211                 kernel_filename = optarg;
5212                 break;
5213             case QEMU_OPTION_append:
5214                 kernel_cmdline = optarg;
5215                 break;
5216             case QEMU_OPTION_cdrom:
5217                 drive_add(optarg, CDROM_ALIAS);
5218                 break;
5219             case QEMU_OPTION_boot:
5220                 boot_devices = optarg;
5221                 /* We just do some generic consistency checks */
5222                 {
5223                     /* Could easily be extended to 64 devices if needed */
5224                     const char *p;
5225
5226                     boot_devices_bitmap = 0;
5227                     for (p = boot_devices; *p != '\0'; p++) {
5228                         /* Allowed boot devices are:
5229                          * a b     : floppy disk drives
5230                          * c ... f : IDE disk drives
5231                          * g ... m : machine implementation dependant drives
5232                          * n ... p : network devices
5233                          * It's up to each machine implementation to check
5234                          * if the given boot devices match the actual hardware
5235                          * implementation and firmware features.
5236                          */
5237                         if (*p < 'a' || *p > 'q') {
5238                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
5239                             exit(1);
5240                         }
5241                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
5242                             fprintf(stderr,
5243                                     "Boot device '%c' was given twice\n",*p);
5244                             exit(1);
5245                         }
5246                         boot_devices_bitmap |= 1 << (*p - 'a');
5247                     }
5248                 }
5249                 break;
5250             case QEMU_OPTION_fda:
5251             case QEMU_OPTION_fdb:
5252                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5253                 break;
5254 #ifdef TARGET_I386
5255             case QEMU_OPTION_no_fd_bootchk:
5256                 fd_bootchk = 0;
5257                 break;
5258 #endif
5259             case QEMU_OPTION_net:
5260                 if (nb_net_clients >= MAX_NET_CLIENTS) {
5261                     fprintf(stderr, "qemu: too many network clients\n");
5262                     exit(1);
5263                 }
5264                 net_clients[nb_net_clients] = optarg;
5265                 nb_net_clients++;
5266                 break;
5267 #ifdef CONFIG_SLIRP
5268             case QEMU_OPTION_tftp:
5269                 tftp_prefix = optarg;
5270                 break;
5271             case QEMU_OPTION_bootp:
5272                 bootp_filename = optarg;
5273                 break;
5274 #ifndef _WIN32
5275             case QEMU_OPTION_smb:
5276                 net_slirp_smb(optarg);
5277                 break;
5278 #endif
5279             case QEMU_OPTION_redir:
5280                 net_slirp_redir(NULL, optarg, NULL);
5281                 break;
5282 #endif
5283             case QEMU_OPTION_bt:
5284                 if (nb_bt_opts >= MAX_BT_CMDLINE) {
5285                     fprintf(stderr, "qemu: too many bluetooth options\n");
5286                     exit(1);
5287                 }
5288                 bt_opts[nb_bt_opts++] = optarg;
5289                 break;
5290 #ifdef HAS_AUDIO
5291             case QEMU_OPTION_audio_help:
5292                 AUD_help ();
5293                 exit (0);
5294                 break;
5295             case QEMU_OPTION_soundhw:
5296                 select_soundhw (optarg);
5297                 break;
5298 #endif
5299             case QEMU_OPTION_h:
5300                 help(0);
5301                 break;
5302             case QEMU_OPTION_version:
5303                 version();
5304                 exit(0);
5305                 break;
5306             case QEMU_OPTION_m: {
5307                 uint64_t value;
5308                 char *ptr;
5309
5310                 value = strtoul(optarg, &ptr, 10);
5311                 switch (*ptr) {
5312                 case 0: case 'M': case 'm':
5313                     value <<= 20;
5314                     break;
5315                 case 'G': case 'g':
5316                     value <<= 30;
5317                     break;
5318                 default:
5319                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5320                     exit(1);
5321                 }
5322
5323                 /* On 32-bit hosts, QEMU is limited by virtual address space */
5324                 if (value > (2047 << 20)
5325 #ifndef CONFIG_KQEMU
5326                     && HOST_LONG_BITS == 32
5327 #endif
5328                     ) {
5329                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5330                     exit(1);
5331                 }
5332                 if (value != (uint64_t)(ram_addr_t)value) {
5333                     fprintf(stderr, "qemu: ram size too large\n");
5334                     exit(1);
5335                 }
5336                 ram_size = value;
5337                 break;
5338             }
5339             case QEMU_OPTION_d:
5340                 {
5341                     int mask;
5342                     const CPULogItem *item;
5343
5344                     mask = cpu_str_to_log_mask(optarg);
5345                     if (!mask) {
5346                         printf("Log items (comma separated):\n");
5347                     for(item = cpu_log_items; item->mask != 0; item++) {
5348                         printf("%-10s %s\n", item->name, item->help);
5349                     }
5350                     exit(1);
5351                     }
5352                     cpu_set_log(mask);
5353                 }
5354                 break;
5355             case QEMU_OPTION_s:
5356                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5357                 break;
5358             case QEMU_OPTION_gdb:
5359                 gdbstub_dev = optarg;
5360                 break;
5361             case QEMU_OPTION_L:
5362                 data_dir = optarg;
5363                 break;
5364             case QEMU_OPTION_bios:
5365                 bios_name = optarg;
5366                 break;
5367             case QEMU_OPTION_singlestep:
5368                 singlestep = 1;
5369                 break;
5370             case QEMU_OPTION_S:
5371                 autostart = 0;
5372                 break;
5373 #ifndef _WIN32
5374             case QEMU_OPTION_k:
5375                 keyboard_layout = optarg;
5376                 break;
5377 #endif
5378             case QEMU_OPTION_localtime:
5379                 rtc_utc = 0;
5380                 break;
5381             case QEMU_OPTION_vga:
5382                 select_vgahw (optarg);
5383                 break;
5384 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5385             case QEMU_OPTION_g:
5386                 {
5387                     const char *p;
5388                     int w, h, depth;
5389                     p = optarg;
5390                     w = strtol(p, (char **)&p, 10);
5391                     if (w <= 0) {
5392                     graphic_error:
5393                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5394                         exit(1);
5395                     }
5396                     if (*p != 'x')
5397                         goto graphic_error;
5398                     p++;
5399                     h = strtol(p, (char **)&p, 10);
5400                     if (h <= 0)
5401                         goto graphic_error;
5402                     if (*p == 'x') {
5403                         p++;
5404                         depth = strtol(p, (char **)&p, 10);
5405                         if (depth != 8 && depth != 15 && depth != 16 &&
5406                             depth != 24 && depth != 32)
5407                             goto graphic_error;
5408                     } else if (*p == '\0') {
5409                         depth = graphic_depth;
5410                     } else {
5411                         goto graphic_error;
5412                     }
5413
5414                     graphic_width = w;
5415                     graphic_height = h;
5416                     graphic_depth = depth;
5417                 }
5418                 break;
5419 #endif
5420             case QEMU_OPTION_echr:
5421                 {
5422                     char *r;
5423                     term_escape_char = strtol(optarg, &r, 0);
5424                     if (r == optarg)
5425                         printf("Bad argument to echr\n");
5426                     break;
5427                 }
5428             case QEMU_OPTION_monitor:
5429                 monitor_device = optarg;
5430                 break;
5431             case QEMU_OPTION_serial:
5432                 if (serial_device_index >= MAX_SERIAL_PORTS) {
5433                     fprintf(stderr, "qemu: too many serial ports\n");
5434                     exit(1);
5435                 }
5436                 serial_devices[serial_device_index] = optarg;
5437                 serial_device_index++;
5438                 break;
5439             case QEMU_OPTION_watchdog:
5440                 i = select_watchdog(optarg);
5441                 if (i > 0)
5442                     exit (i == 1 ? 1 : 0);
5443                 break;
5444             case QEMU_OPTION_watchdog_action:
5445                 if (select_watchdog_action(optarg) == -1) {
5446                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
5447                     exit(1);
5448                 }
5449                 break;
5450             case QEMU_OPTION_virtiocon:
5451                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5452                     fprintf(stderr, "qemu: too many virtio consoles\n");
5453                     exit(1);
5454                 }
5455                 virtio_consoles[virtio_console_index] = optarg;
5456                 virtio_console_index++;
5457                 break;
5458             case QEMU_OPTION_parallel:
5459                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5460                     fprintf(stderr, "qemu: too many parallel ports\n");
5461                     exit(1);
5462                 }
5463                 parallel_devices[parallel_device_index] = optarg;
5464                 parallel_device_index++;
5465                 break;
5466             case QEMU_OPTION_loadvm:
5467                 loadvm = optarg;
5468                 break;
5469             case QEMU_OPTION_full_screen:
5470                 full_screen = 1;
5471                 break;
5472 #ifdef CONFIG_SDL
5473             case QEMU_OPTION_no_frame:
5474                 no_frame = 1;
5475                 break;
5476             case QEMU_OPTION_alt_grab:
5477                 alt_grab = 1;
5478                 break;
5479             case QEMU_OPTION_no_quit:
5480                 no_quit = 1;
5481                 break;
5482             case QEMU_OPTION_sdl:
5483                 display_type = DT_SDL;
5484                 break;
5485 #endif
5486             case QEMU_OPTION_pidfile:
5487                 pid_file = optarg;
5488                 break;
5489 #ifdef TARGET_I386
5490             case QEMU_OPTION_win2k_hack:
5491                 win2k_install_hack = 1;
5492                 break;
5493             case QEMU_OPTION_rtc_td_hack:
5494                 rtc_td_hack = 1;
5495                 break;
5496             case QEMU_OPTION_acpitable:
5497                 if(acpi_table_add(optarg) < 0) {
5498                     fprintf(stderr, "Wrong acpi table provided\n");
5499                     exit(1);
5500                 }
5501                 break;
5502             case QEMU_OPTION_smbios:
5503                 if(smbios_entry_add(optarg) < 0) {
5504                     fprintf(stderr, "Wrong smbios provided\n");
5505                     exit(1);
5506                 }
5507                 break;
5508 #endif
5509 #ifdef CONFIG_KQEMU
5510             case QEMU_OPTION_no_kqemu:
5511                 kqemu_allowed = 0;
5512                 break;
5513             case QEMU_OPTION_kernel_kqemu:
5514                 kqemu_allowed = 2;
5515                 break;
5516 #endif
5517 #ifdef CONFIG_KVM
5518             case QEMU_OPTION_enable_kvm:
5519                 kvm_allowed = 1;
5520 #ifdef CONFIG_KQEMU
5521                 kqemu_allowed = 0;
5522 #endif
5523                 break;
5524 #endif
5525             case QEMU_OPTION_usb:
5526                 usb_enabled = 1;
5527                 break;
5528             case QEMU_OPTION_usbdevice:
5529                 usb_enabled = 1;
5530                 if (usb_devices_index >= MAX_USB_CMDLINE) {
5531                     fprintf(stderr, "Too many USB devices\n");
5532                     exit(1);
5533                 }
5534                 usb_devices[usb_devices_index] = optarg;
5535                 usb_devices_index++;
5536                 break;
5537             case QEMU_OPTION_smp:
5538                 smp_cpus = atoi(optarg);
5539                 if (smp_cpus < 1) {
5540                     fprintf(stderr, "Invalid number of CPUs\n");
5541                     exit(1);
5542                 }
5543                 break;
5544             case QEMU_OPTION_vnc:
5545                 display_type = DT_VNC;
5546                 vnc_display = optarg;
5547                 break;
5548 #ifdef TARGET_I386
5549             case QEMU_OPTION_no_acpi:
5550                 acpi_enabled = 0;
5551                 break;
5552             case QEMU_OPTION_no_hpet:
5553                 no_hpet = 1;
5554                 break;
5555 #endif
5556             case QEMU_OPTION_no_reboot:
5557                 no_reboot = 1;
5558                 break;
5559             case QEMU_OPTION_no_shutdown:
5560                 no_shutdown = 1;
5561                 break;
5562             case QEMU_OPTION_show_cursor:
5563                 cursor_hide = 0;
5564                 break;
5565             case QEMU_OPTION_uuid:
5566                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5567                     fprintf(stderr, "Fail to parse UUID string."
5568                             " Wrong format.\n");
5569                     exit(1);
5570                 }
5571                 break;
5572 #ifndef _WIN32
5573             case QEMU_OPTION_daemonize:
5574                 daemonize = 1;
5575                 break;
5576 #endif
5577             case QEMU_OPTION_option_rom:
5578                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5579                     fprintf(stderr, "Too many option ROMs\n");
5580                     exit(1);
5581                 }
5582                 option_rom[nb_option_roms] = optarg;
5583                 nb_option_roms++;
5584                 break;
5585 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5586             case QEMU_OPTION_semihosting:
5587                 semihosting_enabled = 1;
5588                 break;
5589 #endif
5590             case QEMU_OPTION_name:
5591                 qemu_name = optarg;
5592                 break;
5593 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5594             case QEMU_OPTION_prom_env:
5595                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5596                     fprintf(stderr, "Too many prom variables\n");
5597                     exit(1);
5598                 }
5599                 prom_envs[nb_prom_envs] = optarg;
5600                 nb_prom_envs++;
5601                 break;
5602 #endif
5603 #ifdef TARGET_ARM
5604             case QEMU_OPTION_old_param:
5605                 old_param = 1;
5606                 break;
5607 #endif
5608             case QEMU_OPTION_clock:
5609                 configure_alarms(optarg);
5610                 break;
5611             case QEMU_OPTION_startdate:
5612                 {
5613                     struct tm tm;
5614                     time_t rtc_start_date;
5615                     if (!strcmp(optarg, "now")) {
5616                         rtc_date_offset = -1;
5617                     } else {
5618                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5619                                &tm.tm_year,
5620                                &tm.tm_mon,
5621                                &tm.tm_mday,
5622                                &tm.tm_hour,
5623                                &tm.tm_min,
5624                                &tm.tm_sec) == 6) {
5625                             /* OK */
5626                         } else if (sscanf(optarg, "%d-%d-%d",
5627                                           &tm.tm_year,
5628                                           &tm.tm_mon,
5629                                           &tm.tm_mday) == 3) {
5630                             tm.tm_hour = 0;
5631                             tm.tm_min = 0;
5632                             tm.tm_sec = 0;
5633                         } else {
5634                             goto date_fail;
5635                         }
5636                         tm.tm_year -= 1900;
5637                         tm.tm_mon--;
5638                         rtc_start_date = mktimegm(&tm);
5639                         if (rtc_start_date == -1) {
5640                         date_fail:
5641                             fprintf(stderr, "Invalid date format. Valid format are:\n"
5642                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5643                             exit(1);
5644                         }
5645                         rtc_date_offset = time(NULL) - rtc_start_date;
5646                     }
5647                 }
5648                 break;
5649             case QEMU_OPTION_tb_size:
5650                 tb_size = strtol(optarg, NULL, 0);
5651                 if (tb_size < 0)
5652                     tb_size = 0;
5653                 break;
5654             case QEMU_OPTION_icount:
5655                 use_icount = 1;
5656                 if (strcmp(optarg, "auto") == 0) {
5657                     icount_time_shift = -1;
5658                 } else {
5659                     icount_time_shift = strtol(optarg, NULL, 0);
5660                 }
5661                 break;
5662             case QEMU_OPTION_incoming:
5663                 incoming = optarg;
5664                 break;
5665 #ifndef _WIN32
5666             case QEMU_OPTION_chroot:
5667                 chroot_dir = optarg;
5668                 break;
5669             case QEMU_OPTION_runas:
5670                 run_as = optarg;
5671                 break;
5672 #endif
5673 #ifdef CONFIG_XEN
5674             case QEMU_OPTION_xen_domid:
5675                 xen_domid = atoi(optarg);
5676                 break;
5677             case QEMU_OPTION_xen_create:
5678                 xen_mode = XEN_CREATE;
5679                 break;
5680             case QEMU_OPTION_xen_attach:
5681                 xen_mode = XEN_ATTACH;
5682                 break;
5683 #endif
5684             }
5685         }
5686     }
5687
5688     /* If no data_dir is specified then try to find it relative to the
5689        executable path.  */
5690     if (!data_dir) {
5691         data_dir = find_datadir(argv[0]);
5692     }
5693     /* If all else fails use the install patch specified when building.  */
5694     if (!data_dir) {
5695         data_dir = CONFIG_QEMU_SHAREDIR;
5696     }
5697
5698 #if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
5699     if (kvm_allowed && kqemu_allowed) {
5700         fprintf(stderr,
5701                 "You can not enable both KVM and kqemu at the same time\n");
5702         exit(1);
5703     }
5704 #endif
5705
5706     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5707     if (smp_cpus > machine->max_cpus) {
5708         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5709                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5710                 machine->max_cpus);
5711         exit(1);
5712     }
5713
5714     if (display_type == DT_NOGRAPHIC) {
5715        if (serial_device_index == 0)
5716            serial_devices[0] = "stdio";
5717        if (parallel_device_index == 0)
5718            parallel_devices[0] = "null";
5719        if (strncmp(monitor_device, "vc", 2) == 0)
5720            monitor_device = "stdio";
5721     }
5722
5723 #ifndef _WIN32
5724     if (daemonize) {
5725         pid_t pid;
5726
5727         if (pipe(fds) == -1)
5728             exit(1);
5729
5730         pid = fork();
5731         if (pid > 0) {
5732             uint8_t status;
5733             ssize_t len;
5734
5735             close(fds[1]);
5736
5737         again:
5738             len = read(fds[0], &status, 1);
5739             if (len == -1 && (errno == EINTR))
5740                 goto again;
5741
5742             if (len != 1)
5743                 exit(1);
5744             else if (status == 1) {
5745                 fprintf(stderr, "Could not acquire pidfile\n");
5746                 exit(1);
5747             } else
5748                 exit(0);
5749         } else if (pid < 0)
5750             exit(1);
5751
5752         setsid();
5753
5754         pid = fork();
5755         if (pid > 0)
5756             exit(0);
5757         else if (pid < 0)
5758             exit(1);
5759
5760         umask(027);
5761
5762         signal(SIGTSTP, SIG_IGN);
5763         signal(SIGTTOU, SIG_IGN);
5764         signal(SIGTTIN, SIG_IGN);
5765     }
5766
5767     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5768         if (daemonize) {
5769             uint8_t status = 1;
5770             write(fds[1], &status, 1);
5771         } else
5772             fprintf(stderr, "Could not acquire pid file\n");
5773         exit(1);
5774     }
5775 #endif
5776
5777 #ifdef CONFIG_KQEMU
5778     if (smp_cpus > 1)
5779         kqemu_allowed = 0;
5780 #endif
5781     if (qemu_init_main_loop()) {
5782         fprintf(stderr, "qemu_init_main_loop failed\n");
5783         exit(1);
5784     }
5785     linux_boot = (kernel_filename != NULL);
5786     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5787
5788     if (!linux_boot && *kernel_cmdline != '\0') {
5789         fprintf(stderr, "-append only allowed with -kernel option\n");
5790         exit(1);
5791     }
5792
5793     if (!linux_boot && initrd_filename != NULL) {
5794         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5795         exit(1);
5796     }
5797
5798     /* boot to floppy or the default cd if no hard disk defined yet */
5799     if (!boot_devices[0]) {
5800         boot_devices = "cad";
5801     }
5802     setvbuf(stdout, NULL, _IOLBF, 0);
5803
5804     init_timers();
5805     if (init_timer_alarm() < 0) {
5806         fprintf(stderr, "could not initialize alarm timer\n");
5807         exit(1);
5808     }
5809     if (use_icount && icount_time_shift < 0) {
5810         use_icount = 2;
5811         /* 125MIPS seems a reasonable initial guess at the guest speed.
5812            It will be corrected fairly quickly anyway.  */
5813         icount_time_shift = 3;
5814         init_icount_adjust();
5815     }
5816
5817 #ifdef _WIN32
5818     socket_init();
5819 #endif
5820
5821     /* init network clients */
5822     if (nb_net_clients == 0) {
5823         /* if no clients, we use a default config */
5824         net_clients[nb_net_clients++] = "nic";
5825 #ifdef CONFIG_SLIRP
5826         net_clients[nb_net_clients++] = "user";
5827 #endif
5828     }
5829
5830     for(i = 0;i < nb_net_clients; i++) {
5831         if (net_client_parse(net_clients[i]) < 0)
5832             exit(1);
5833     }
5834     net_client_check();
5835
5836 #ifdef TARGET_I386
5837     /* XXX: this should be moved in the PC machine instantiation code */
5838     if (net_boot != 0) {
5839         int netroms = 0;
5840         for (i = 0; i < nb_nics && i < 4; i++) {
5841             const char *model = nd_table[i].model;
5842             char buf[1024];
5843             char *filename;
5844             if (net_boot & (1 << i)) {
5845                 if (model == NULL)
5846                     model = "ne2k_pci";
5847                 snprintf(buf, sizeof(buf), "pxe-%s.bin", model);
5848                 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, buf);
5849                 if (filename && get_image_size(filename) > 0) {
5850                     if (nb_option_roms >= MAX_OPTION_ROMS) {
5851                         fprintf(stderr, "Too many option ROMs\n");
5852                         exit(1);
5853                     }
5854                     option_rom[nb_option_roms] = qemu_strdup(buf);
5855                     nb_option_roms++;
5856                     netroms++;
5857                 }
5858                 if (filename) {
5859                     qemu_free(filename);
5860                 }
5861             }
5862         }
5863         if (netroms == 0) {
5864             fprintf(stderr, "No valid PXE rom found for network device\n");
5865             exit(1);
5866         }
5867     }
5868 #endif
5869
5870     /* init the bluetooth world */
5871     for (i = 0; i < nb_bt_opts; i++)
5872         if (bt_parse(bt_opts[i]))
5873             exit(1);
5874
5875     /* init the memory */
5876     if (ram_size == 0)
5877         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5878
5879 #ifdef CONFIG_KQEMU
5880     /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5881        guest ram allocation.  It needs to go away.  */
5882     if (kqemu_allowed) {
5883         kqemu_phys_ram_size = ram_size + 8 * 1024 * 1024 + 4 * 1024 * 1024;
5884         kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size);
5885         if (!kqemu_phys_ram_base) {
5886             fprintf(stderr, "Could not allocate physical memory\n");
5887             exit(1);
5888         }
5889     }
5890 #endif
5891
5892     /* init the dynamic translator */
5893     cpu_exec_init_all(tb_size * 1024 * 1024);
5894
5895     bdrv_init();
5896
5897     /* we always create the cdrom drive, even if no disk is there */
5898
5899     if (nb_drives_opt < MAX_DRIVES)
5900         drive_add(NULL, CDROM_ALIAS);
5901
5902     /* we always create at least one floppy */
5903
5904     if (nb_drives_opt < MAX_DRIVES)
5905         drive_add(NULL, FD_ALIAS, 0);
5906
5907     /* we always create one sd slot, even if no card is in it */
5908
5909     if (nb_drives_opt < MAX_DRIVES)
5910         drive_add(NULL, SD_ALIAS);
5911
5912     /* open the virtual block devices */
5913
5914     for(i = 0; i < nb_drives_opt; i++)
5915         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5916             exit(1);
5917
5918     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5919     register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5920
5921 #ifndef _WIN32
5922     /* must be after terminal init, SDL library changes signal handlers */
5923     termsig_setup();
5924 #endif
5925
5926     /* Maintain compatibility with multiple stdio monitors */
5927     if (!strcmp(monitor_device,"stdio")) {
5928         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5929             const char *devname = serial_devices[i];
5930             if (devname && !strcmp(devname,"mon:stdio")) {
5931                 monitor_device = NULL;
5932                 break;
5933             } else if (devname && !strcmp(devname,"stdio")) {
5934                 monitor_device = NULL;
5935                 serial_devices[i] = "mon:stdio";
5936                 break;
5937             }
5938         }
5939     }
5940
5941     if (nb_numa_nodes > 0) {
5942         int i;
5943
5944         if (nb_numa_nodes > smp_cpus) {
5945             nb_numa_nodes = smp_cpus;
5946         }
5947
5948         /* If no memory size if given for any node, assume the default case
5949          * and distribute the available memory equally across all nodes
5950          */
5951         for (i = 0; i < nb_numa_nodes; i++) {
5952             if (node_mem[i] != 0)
5953                 break;
5954         }
5955         if (i == nb_numa_nodes) {
5956             uint64_t usedmem = 0;
5957
5958             /* On Linux, the each node's border has to be 8MB aligned,
5959              * the final node gets the rest.
5960              */
5961             for (i = 0; i < nb_numa_nodes - 1; i++) {
5962                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5963                 usedmem += node_mem[i];
5964             }
5965             node_mem[i] = ram_size - usedmem;
5966         }
5967
5968         for (i = 0; i < nb_numa_nodes; i++) {
5969             if (node_cpumask[i] != 0)
5970                 break;
5971         }
5972         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5973          * must cope with this anyway, because there are BIOSes out there in
5974          * real machines which also use this scheme.
5975          */
5976         if (i == nb_numa_nodes) {
5977             for (i = 0; i < smp_cpus; i++) {
5978                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5979             }
5980         }
5981     }
5982
5983     if (kvm_enabled()) {
5984         int ret;
5985
5986         ret = kvm_init(smp_cpus);
5987         if (ret < 0) {
5988             fprintf(stderr, "failed to initialize KVM\n");
5989             exit(1);
5990         }
5991     }
5992
5993     if (monitor_device) {
5994         monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5995         if (!monitor_hd) {
5996             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5997             exit(1);
5998         }
5999     }
6000
6001     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6002         const char *devname = serial_devices[i];
6003         if (devname && strcmp(devname, "none")) {
6004             char label[32];
6005             snprintf(label, sizeof(label), "serial%d", i);
6006             serial_hds[i] = qemu_chr_open(label, devname, NULL);
6007             if (!serial_hds[i]) {
6008                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
6009                         devname);
6010                 exit(1);
6011             }
6012         }
6013     }
6014
6015     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6016         const char *devname = parallel_devices[i];
6017         if (devname && strcmp(devname, "none")) {
6018             char label[32];
6019             snprintf(label, sizeof(label), "parallel%d", i);
6020             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
6021             if (!parallel_hds[i]) {
6022                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
6023                         devname);
6024                 exit(1);
6025             }
6026         }
6027     }
6028
6029     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6030         const char *devname = virtio_consoles[i];
6031         if (devname && strcmp(devname, "none")) {
6032             char label[32];
6033             snprintf(label, sizeof(label), "virtcon%d", i);
6034             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
6035             if (!virtcon_hds[i]) {
6036                 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
6037                         devname);
6038                 exit(1);
6039             }
6040         }
6041     }
6042
6043     module_call_init(MODULE_INIT_DEVICE);
6044
6045     machine->init(ram_size, boot_devices,
6046                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
6047
6048
6049     for (env = first_cpu; env != NULL; env = env->next_cpu) {
6050         for (i = 0; i < nb_numa_nodes; i++) {
6051             if (node_cpumask[i] & (1 << env->cpu_index)) {
6052                 env->numa_node = i;
6053             }
6054         }
6055     }
6056
6057     current_machine = machine;
6058
6059     /* Set KVM's vcpu state to qemu's initial CPUState. */
6060     if (kvm_enabled()) {
6061         int ret;
6062
6063         ret = kvm_sync_vcpus();
6064         if (ret < 0) {
6065             fprintf(stderr, "failed to initialize vcpus\n");
6066             exit(1);
6067         }
6068     }
6069
6070     /* init USB devices */
6071     if (usb_enabled) {
6072         for(i = 0; i < usb_devices_index; i++) {
6073             if (usb_device_add(usb_devices[i], 0) < 0) {
6074                 fprintf(stderr, "Warning: could not add USB device %s\n",
6075                         usb_devices[i]);
6076             }
6077         }
6078     }
6079
6080     if (!display_state)
6081         dumb_display_init();
6082     /* just use the first displaystate for the moment */
6083     ds = display_state;
6084
6085     if (display_type == DT_DEFAULT) {
6086 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
6087         display_type = DT_SDL;
6088 #else
6089         display_type = DT_VNC;
6090         vnc_display = "localhost:0,to=99";
6091         show_vnc_port = 1;
6092 #endif
6093     }
6094
6095
6096     switch (display_type) {
6097     case DT_NOGRAPHIC:
6098         break;
6099 #if defined(CONFIG_CURSES)
6100     case DT_CURSES:
6101         curses_display_init(ds, full_screen);
6102         break;
6103 #endif
6104 #if defined(CONFIG_SDL)
6105     case DT_SDL:
6106         sdl_display_init(ds, full_screen, no_frame);
6107         break;
6108 #elif defined(CONFIG_COCOA)
6109     case DT_SDL:
6110         cocoa_display_init(ds, full_screen);
6111         break;
6112 #endif
6113     case DT_VNC:
6114         vnc_display_init(ds);
6115         if (vnc_display_open(ds, vnc_display) < 0)
6116             exit(1);
6117
6118         if (show_vnc_port) {
6119             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
6120         }
6121         break;
6122     default:
6123         break;
6124     }
6125     dpy_resize(ds);
6126
6127     dcl = ds->listeners;
6128     while (dcl != NULL) {
6129         if (dcl->dpy_refresh != NULL) {
6130             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
6131             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
6132         }
6133         dcl = dcl->next;
6134     }
6135
6136     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
6137         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6138         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6139     }
6140
6141     text_consoles_set_display(display_state);
6142     qemu_chr_initial_reset();
6143
6144     if (monitor_device && monitor_hd)
6145         monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
6146
6147     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6148         const char *devname = serial_devices[i];
6149         if (devname && strcmp(devname, "none")) {
6150             char label[32];
6151             snprintf(label, sizeof(label), "serial%d", i);
6152             if (strstart(devname, "vc", 0))
6153                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6154         }
6155     }
6156
6157     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6158         const char *devname = parallel_devices[i];
6159         if (devname && strcmp(devname, "none")) {
6160             char label[32];
6161             snprintf(label, sizeof(label), "parallel%d", i);
6162             if (strstart(devname, "vc", 0))
6163                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6164         }
6165     }
6166
6167     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6168         const char *devname = virtio_consoles[i];
6169         if (virtcon_hds[i] && devname) {
6170             char label[32];
6171             snprintf(label, sizeof(label), "virtcon%d", i);
6172             if (strstart(devname, "vc", 0))
6173                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
6174         }
6175     }
6176
6177     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6178         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6179                 gdbstub_dev);
6180         exit(1);
6181     }
6182
6183     if (loadvm)
6184         do_loadvm(cur_mon, loadvm);
6185
6186     if (incoming) {
6187         autostart = 0; /* fixme how to deal with -daemonize */
6188         qemu_start_incoming_migration(incoming);
6189     }
6190
6191     if (autostart)
6192         vm_start();
6193
6194 #ifndef _WIN32
6195     if (daemonize) {
6196         uint8_t status = 0;
6197         ssize_t len;
6198
6199     again1:
6200         len = write(fds[1], &status, 1);
6201         if (len == -1 && (errno == EINTR))
6202             goto again1;
6203
6204         if (len != 1)
6205             exit(1);
6206
6207         chdir("/");
6208         TFR(fd = open("/dev/null", O_RDWR));
6209         if (fd == -1)
6210             exit(1);
6211     }
6212
6213     if (run_as) {
6214         pwd = getpwnam(run_as);
6215         if (!pwd) {
6216             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6217             exit(1);
6218         }
6219     }
6220
6221     if (chroot_dir) {
6222         if (chroot(chroot_dir) < 0) {
6223             fprintf(stderr, "chroot failed\n");
6224             exit(1);
6225         }
6226         chdir("/");
6227     }
6228
6229     if (run_as) {
6230         if (setgid(pwd->pw_gid) < 0) {
6231             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6232             exit(1);
6233         }
6234         if (setuid(pwd->pw_uid) < 0) {
6235             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6236             exit(1);
6237         }
6238         if (setuid(0) != -1) {
6239             fprintf(stderr, "Dropping privileges failed\n");
6240             exit(1);
6241         }
6242     }
6243
6244     if (daemonize) {
6245         dup2(fd, 0);
6246         dup2(fd, 1);
6247         dup2(fd, 2);
6248
6249         close(fd);
6250     }
6251 #endif
6252
6253     main_loop();
6254     quit_timers();
6255     net_cleanup();
6256
6257     return 0;
6258 }