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

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