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(NULL, "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 #ifndef CONFIG_IOTHREAD
4382     int timeout;
4383
4384     if (!vm_running)
4385         timeout = 5000;
4386     else if (tcg_has_work())
4387         timeout = 0;
4388     else if (!use_icount)
4389         timeout = 5000;
4390     else {
4391      /* XXX: use timeout computed from timers */
4392         int64_t add;
4393         int64_t delta;
4394         /* Advance virtual time to the next event.  */
4395         if (use_icount == 1) {
4396             /* When not using an adaptive execution frequency
4397                we tend to get badly out of sync with real time,
4398                so just delay for a reasonable amount of time.  */
4399             delta = 0;
4400         } else {
4401             delta = cpu_get_icount() - cpu_get_clock();
4402         }
4403         if (delta > 0) {
4404             /* If virtual time is ahead of real time then just
4405                wait for IO.  */
4406             timeout = (delta / 1000000) + 1;
4407         } else {
4408             /* Wait for either IO to occur or the next
4409                timer event.  */
4410             add = qemu_next_deadline();
4411             /* We advance the timer before checking for IO.
4412                Limit the amount we advance so that early IO
4413                activity won't get the guest too far ahead.  */
4414             if (add > 10000000)
4415                 add = 10000000;
4416             delta += add;
4417             add = (add + (1 << icount_time_shift) - 1)
4418                   >> icount_time_shift;
4419             qemu_icount += add;
4420             timeout = delta / 1000000;
4421             if (timeout < 0)
4422                 timeout = 0;
4423         }
4424     }
4425
4426     return timeout;
4427 #else /* CONFIG_IOTHREAD */
4428     return 1000;
4429 #endif
4430 }
4431
4432 static int vm_can_run(void)
4433 {
4434     if (powerdown_requested)
4435         return 0;
4436     if (reset_requested)
4437         return 0;
4438     if (shutdown_requested)
4439         return 0;
4440     if (debug_requested)
4441         return 0;
4442     return 1;
4443 }
4444
4445 static void main_loop(void)
4446 {
4447     int r;
4448
4449 #ifdef CONFIG_IOTHREAD
4450     qemu_system_ready = 1;
4451     qemu_cond_broadcast(&qemu_system_cond);
4452 #endif
4453
4454     for (;;) {
4455         do {
4456 #ifdef CONFIG_PROFILER
4457             int64_t ti;
4458 #endif
4459 #ifndef CONFIG_IOTHREAD
4460             tcg_cpu_exec();
4461 #endif
4462 #ifdef CONFIG_PROFILER
4463             ti = profile_getclock();
4464 #endif
4465             main_loop_wait(qemu_calculate_timeout());
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 NULL;
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     size_t max_len;
4837
4838 #if defined(__linux__)
4839     {
4840         int len;
4841         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4842         if (len > 0) {
4843             buf[len] = 0;
4844             p = buf;
4845         }
4846     }
4847 #elif defined(__FreeBSD__)
4848     {
4849         int len;
4850         len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4851         if (len > 0) {
4852             buf[len] = 0;
4853             p = buf;
4854         }
4855     }
4856 #endif
4857     /* If we don't have any way of figuring out the actual executable
4858        location then try argv[0].  */
4859     if (!p) {
4860 #ifdef PATH_MAX
4861         p = buf;
4862 #endif
4863         p = realpath(argv0, p);
4864         if (!p) {
4865             return NULL;
4866         }
4867     }
4868     dir = dirname(p);
4869     dir = dirname(dir);
4870
4871     max_len = strlen(dir) +
4872         MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4873     res = qemu_mallocz(max_len);
4874     snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4875     if (access(res, R_OK)) {
4876         snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4877         if (access(res, R_OK)) {
4878             qemu_free(res);
4879             res = NULL;
4880         }
4881     }
4882 #ifndef PATH_MAX
4883     free(p);
4884 #endif
4885     return res;
4886 }
4887 #undef SHARE_SUFFIX
4888 #undef BUILD_SUFFIX
4889 #endif
4890
4891 char *qemu_find_file(int type, const char *name)
4892 {
4893     int len;
4894     const char *subdir;
4895     char *buf;
4896
4897     /* If name contains path separators then try it as a straight path.  */
4898     if ((strchr(name, '/') || strchr(name, '\\'))
4899         && access(name, R_OK) == 0) {
4900         return strdup(name);
4901     }
4902     switch (type) {
4903     case QEMU_FILE_TYPE_BIOS:
4904         subdir = "";
4905         break;
4906     case QEMU_FILE_TYPE_KEYMAP:
4907         subdir = "keymaps/";
4908         break;
4909     default:
4910         abort();
4911     }
4912     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4913     buf = qemu_mallocz(len);
4914     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4915     if (access(buf, R_OK)) {
4916         qemu_free(buf);
4917         return NULL;
4918     }
4919     return buf;
4920 }
4921
4922 int main(int argc, char **argv, char **envp)
4923 {
4924     const char *gdbstub_dev = NULL;
4925     uint32_t boot_devices_bitmap = 0;
4926     int i;
4927     int snapshot, linux_boot, net_boot;
4928     const char *initrd_filename;
4929     const char *kernel_filename, *kernel_cmdline;
4930     const char *boot_devices = "";
4931     DisplayState *ds;
4932     DisplayChangeListener *dcl;
4933     int cyls, heads, secs, translation;
4934     const char *net_clients[MAX_NET_CLIENTS];
4935     int nb_net_clients;
4936     const char *bt_opts[MAX_BT_CMDLINE];
4937     int nb_bt_opts;
4938     int hda_index;
4939     int optind;
4940     const char *r, *optarg;
4941     CharDriverState *monitor_hd = NULL;
4942     const char *monitor_device;
4943     const char *serial_devices[MAX_SERIAL_PORTS];
4944     int serial_device_index;
4945     const char *parallel_devices[MAX_PARALLEL_PORTS];
4946     int parallel_device_index;
4947     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4948     int virtio_console_index;
4949     const char *loadvm = NULL;
4950     QEMUMachine *machine;
4951     const char *cpu_model;
4952     const char *usb_devices[MAX_USB_CMDLINE];
4953     int usb_devices_index;
4954 #ifndef _WIN32
4955     int fds[2];
4956 #endif
4957     int tb_size;
4958     const char *pid_file = NULL;
4959     const char *incoming = NULL;
4960 #ifndef _WIN32
4961     int fd = 0;
4962     struct passwd *pwd = NULL;
4963     const char *chroot_dir = NULL;
4964     const char *run_as = NULL;
4965 #endif
4966     CPUState *env;
4967     int show_vnc_port = 0;
4968
4969     qemu_cache_utils_init(envp);
4970
4971     LIST_INIT (&vm_change_state_head);
4972 #ifndef _WIN32
4973     {
4974         struct sigaction act;
4975         sigfillset(&act.sa_mask);
4976         act.sa_flags = 0;
4977         act.sa_handler = SIG_IGN;
4978         sigaction(SIGPIPE, &act, NULL);
4979     }
4980 #else
4981     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4982     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4983        QEMU to run on a single CPU */
4984     {
4985         HANDLE h;
4986         DWORD mask, smask;
4987         int i;
4988         h = GetCurrentProcess();
4989         if (GetProcessAffinityMask(h, &mask, &smask)) {
4990             for(i = 0; i < 32; i++) {
4991                 if (mask & (1 << i))
4992                     break;
4993             }
4994             if (i != 32) {
4995                 mask = 1 << i;
4996                 SetProcessAffinityMask(h, mask);
4997             }
4998         }
4999     }
5000 #endif
5001
5002     module_call_init(MODULE_INIT_MACHINE);
5003     machine = find_default_machine();
5004     cpu_model = NULL;
5005     initrd_filename = NULL;
5006     ram_size = 0;
5007     snapshot = 0;
5008     kernel_filename = NULL;
5009     kernel_cmdline = "";
5010     cyls = heads = secs = 0;
5011     translation = BIOS_ATA_TRANSLATION_AUTO;
5012     monitor_device = "vc:80Cx24C";
5013
5014     serial_devices[0] = "vc:80Cx24C";
5015     for(i = 1; i < MAX_SERIAL_PORTS; i++)
5016         serial_devices[i] = NULL;
5017     serial_device_index = 0;
5018
5019     parallel_devices[0] = "vc:80Cx24C";
5020     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
5021         parallel_devices[i] = NULL;
5022     parallel_device_index = 0;
5023
5024     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
5025         virtio_consoles[i] = NULL;
5026     virtio_console_index = 0;
5027
5028     for (i = 0; i < MAX_NODES; i++) {
5029         node_mem[i] = 0;
5030         node_cpumask[i] = 0;
5031     }
5032
5033     usb_devices_index = 0;
5034
5035     nb_net_clients = 0;
5036     nb_bt_opts = 0;
5037     nb_drives = 0;
5038     nb_drives_opt = 0;
5039     nb_numa_nodes = 0;
5040     hda_index = -1;
5041
5042     nb_nics = 0;
5043
5044     tb_size = 0;
5045     autostart= 1;
5046
5047     register_watchdogs();
5048
5049     optind = 1;
5050     for(;;) {
5051         if (optind >= argc)
5052             break;
5053         r = argv[optind];
5054         if (r[0] != '-') {
5055             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
5056         } else {
5057             const QEMUOption *popt;
5058
5059             optind++;
5060             /* Treat --foo the same as -foo.  */
5061             if (r[1] == '-')
5062                 r++;
5063             popt = qemu_options;
5064             for(;;) {
5065                 if (!popt->name) {
5066                     fprintf(stderr, "%s: invalid option -- '%s'\n",
5067                             argv[0], r);
5068                     exit(1);
5069                 }
5070                 if (!strcmp(popt->name, r + 1))
5071                     break;
5072                 popt++;
5073             }
5074             if (popt->flags & HAS_ARG) {
5075                 if (optind >= argc) {
5076                     fprintf(stderr, "%s: option '%s' requires an argument\n",
5077                             argv[0], r);
5078                     exit(1);
5079                 }
5080                 optarg = argv[optind++];
5081             } else {
5082                 optarg = NULL;
5083             }
5084
5085             switch(popt->index) {
5086             case QEMU_OPTION_M:
5087                 machine = find_machine(optarg);
5088                 if (!machine) {
5089                     QEMUMachine *m;
5090                     printf("Supported machines are:\n");
5091                     for(m = first_machine; m != NULL; m = m->next) {
5092                         printf("%-10s %s%s\n",
5093                                m->name, m->desc,
5094                                m->is_default ? " (default)" : "");
5095                     }
5096                     exit(*optarg != '?');
5097                 }
5098                 break;
5099             case QEMU_OPTION_cpu:
5100                 /* hw initialization will check this */
5101                 if (*optarg == '?') {
5102 /* XXX: implement xxx_cpu_list for targets that still miss it */
5103 #if defined(cpu_list)
5104                     cpu_list(stdout, &fprintf);
5105 #endif
5106                     exit(0);
5107                 } else {
5108                     cpu_model = optarg;
5109                 }
5110                 break;
5111             case QEMU_OPTION_initrd:
5112                 initrd_filename = optarg;
5113                 break;
5114             case QEMU_OPTION_hda:
5115                 if (cyls == 0)
5116                     hda_index = drive_add(optarg, HD_ALIAS, 0);
5117                 else
5118                     hda_index = drive_add(optarg, HD_ALIAS
5119                              ",cyls=%d,heads=%d,secs=%d%s",
5120                              0, cyls, heads, secs,
5121                              translation == BIOS_ATA_TRANSLATION_LBA ?
5122                                  ",trans=lba" :
5123                              translation == BIOS_ATA_TRANSLATION_NONE ?
5124                                  ",trans=none" : "");
5125                  break;
5126             case QEMU_OPTION_hdb:
5127             case QEMU_OPTION_hdc:
5128             case QEMU_OPTION_hdd:
5129                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
5130                 break;
5131             case QEMU_OPTION_drive:
5132                 drive_add(NULL, "%s", optarg);
5133                 break;
5134             case QEMU_OPTION_mtdblock:
5135                 drive_add(optarg, MTD_ALIAS);
5136                 break;
5137             case QEMU_OPTION_sd:
5138                 drive_add(optarg, SD_ALIAS);
5139                 break;
5140             case QEMU_OPTION_pflash:
5141                 drive_add(optarg, PFLASH_ALIAS);
5142                 break;
5143             case QEMU_OPTION_snapshot:
5144                 snapshot = 1;
5145                 break;
5146             case QEMU_OPTION_hdachs:
5147                 {
5148                     const char *p;
5149                     p = optarg;
5150                     cyls = strtol(p, (char **)&p, 0);
5151                     if (cyls < 1 || cyls > 16383)
5152                         goto chs_fail;
5153                     if (*p != ',')
5154                         goto chs_fail;
5155                     p++;
5156                     heads = strtol(p, (char **)&p, 0);
5157                     if (heads < 1 || heads > 16)
5158                         goto chs_fail;
5159                     if (*p != ',')
5160                         goto chs_fail;
5161                     p++;
5162                     secs = strtol(p, (char **)&p, 0);
5163                     if (secs < 1 || secs > 63)
5164                         goto chs_fail;
5165                     if (*p == ',') {
5166                         p++;
5167                         if (!strcmp(p, "none"))
5168                             translation = BIOS_ATA_TRANSLATION_NONE;
5169                         else if (!strcmp(p, "lba"))
5170                             translation = BIOS_ATA_TRANSLATION_LBA;
5171                         else if (!strcmp(p, "auto"))
5172                             translation = BIOS_ATA_TRANSLATION_AUTO;
5173                         else
5174                             goto chs_fail;
5175                     } else if (*p != '\0') {
5176                     chs_fail:
5177                         fprintf(stderr, "qemu: invalid physical CHS format\n");
5178                         exit(1);
5179                     }
5180                     if (hda_index != -1)
5181                         snprintf(drives_opt[hda_index].opt,
5182                                  sizeof(drives_opt[hda_index].opt),
5183                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
5184                                  0, cyls, heads, secs,
5185                                  translation == BIOS_ATA_TRANSLATION_LBA ?
5186                                     ",trans=lba" :
5187                                  translation == BIOS_ATA_TRANSLATION_NONE ?
5188                                      ",trans=none" : "");
5189                 }
5190                 break;
5191             case QEMU_OPTION_numa:
5192                 if (nb_numa_nodes >= MAX_NODES) {
5193                     fprintf(stderr, "qemu: too many NUMA nodes\n");
5194                     exit(1);
5195                 }
5196                 numa_add(optarg);
5197                 break;
5198             case QEMU_OPTION_nographic:
5199                 display_type = DT_NOGRAPHIC;
5200                 break;
5201 #ifdef CONFIG_CURSES
5202             case QEMU_OPTION_curses:
5203                 display_type = DT_CURSES;
5204                 break;
5205 #endif
5206             case QEMU_OPTION_portrait:
5207                 graphic_rotate = 1;
5208                 break;
5209             case QEMU_OPTION_kernel:
5210                 kernel_filename = optarg;
5211                 break;
5212             case QEMU_OPTION_append:
5213                 kernel_cmdline = optarg;
5214                 break;
5215             case QEMU_OPTION_cdrom:
5216                 drive_add(optarg, CDROM_ALIAS);
5217                 break;
5218             case QEMU_OPTION_boot:
5219                 boot_devices = optarg;
5220                 /* We just do some generic consistency checks */
5221                 {
5222                     /* Could easily be extended to 64 devices if needed */
5223                     const char *p;
5224
5225                     boot_devices_bitmap = 0;
5226                     for (p = boot_devices; *p != '\0'; p++) {
5227                         /* Allowed boot devices are:
5228                          * a b     : floppy disk drives
5229                          * c ... f : IDE disk drives
5230                          * g ... m : machine implementation dependant drives
5231                          * n ... p : network devices
5232                          * It's up to each machine implementation to check
5233                          * if the given boot devices match the actual hardware
5234                          * implementation and firmware features.
5235                          */
5236                         if (*p < 'a' || *p > 'q') {
5237                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
5238                             exit(1);
5239                         }
5240                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
5241                             fprintf(stderr,
5242                                     "Boot device '%c' was given twice\n",*p);
5243                             exit(1);
5244                         }
5245                         boot_devices_bitmap |= 1 << (*p - 'a');
5246                     }
5247                 }
5248                 break;
5249             case QEMU_OPTION_fda:
5250             case QEMU_OPTION_fdb:
5251                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5252                 break;
5253 #ifdef TARGET_I386
5254             case QEMU_OPTION_no_fd_bootchk:
5255                 fd_bootchk = 0;
5256                 break;
5257 #endif
5258             case QEMU_OPTION_net:
5259                 if (nb_net_clients >= MAX_NET_CLIENTS) {
5260                     fprintf(stderr, "qemu: too many network clients\n");
5261                     exit(1);
5262                 }
5263                 net_clients[nb_net_clients] = optarg;
5264                 nb_net_clients++;
5265                 break;
5266 #ifdef CONFIG_SLIRP
5267             case QEMU_OPTION_tftp:
5268                 tftp_prefix = optarg;
5269                 break;
5270             case QEMU_OPTION_bootp:
5271                 bootp_filename = optarg;
5272                 break;
5273 #ifndef _WIN32
5274             case QEMU_OPTION_smb:
5275                 net_slirp_smb(optarg);
5276                 break;
5277 #endif
5278             case QEMU_OPTION_redir:
5279                 net_slirp_redir(NULL, optarg, NULL);
5280                 break;
5281 #endif
5282             case QEMU_OPTION_bt:
5283                 if (nb_bt_opts >= MAX_BT_CMDLINE) {
5284                     fprintf(stderr, "qemu: too many bluetooth options\n");
5285                     exit(1);
5286                 }
5287                 bt_opts[nb_bt_opts++] = optarg;
5288                 break;
5289 #ifdef HAS_AUDIO
5290             case QEMU_OPTION_audio_help:
5291                 AUD_help ();
5292                 exit (0);
5293                 break;
5294             case QEMU_OPTION_soundhw:
5295                 select_soundhw (optarg);
5296                 break;
5297 #endif
5298             case QEMU_OPTION_h:
5299                 help(0);
5300                 break;
5301             case QEMU_OPTION_version:
5302                 version();
5303                 exit(0);
5304                 break;
5305             case QEMU_OPTION_m: {
5306                 uint64_t value;
5307                 char *ptr;
5308
5309                 value = strtoul(optarg, &ptr, 10);
5310                 switch (*ptr) {
5311                 case 0: case 'M': case 'm':
5312                     value <<= 20;
5313                     break;
5314                 case 'G': case 'g':
5315                     value <<= 30;
5316                     break;
5317                 default:
5318                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5319                     exit(1);
5320                 }
5321
5322                 /* On 32-bit hosts, QEMU is limited by virtual address space */
5323                 if (value > (2047 << 20)
5324 #ifndef CONFIG_KQEMU
5325                     && HOST_LONG_BITS == 32
5326 #endif
5327                     ) {
5328                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5329                     exit(1);
5330                 }
5331                 if (value != (uint64_t)(ram_addr_t)value) {
5332                     fprintf(stderr, "qemu: ram size too large\n");
5333                     exit(1);
5334                 }
5335                 ram_size = value;
5336                 break;
5337             }
5338             case QEMU_OPTION_d:
5339                 {
5340                     int mask;
5341                     const CPULogItem *item;
5342
5343                     mask = cpu_str_to_log_mask(optarg);
5344                     if (!mask) {
5345                         printf("Log items (comma separated):\n");
5346                     for(item = cpu_log_items; item->mask != 0; item++) {
5347                         printf("%-10s %s\n", item->name, item->help);
5348                     }
5349                     exit(1);
5350                     }
5351                     cpu_set_log(mask);
5352                 }
5353                 break;
5354             case QEMU_OPTION_s:
5355                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5356                 break;
5357             case QEMU_OPTION_gdb:
5358                 gdbstub_dev = optarg;
5359                 break;
5360             case QEMU_OPTION_L:
5361                 data_dir = optarg;
5362                 break;
5363             case QEMU_OPTION_bios:
5364                 bios_name = optarg;
5365                 break;
5366             case QEMU_OPTION_singlestep:
5367                 singlestep = 1;
5368                 break;
5369             case QEMU_OPTION_S:
5370                 autostart = 0;
5371                 break;
5372 #ifndef _WIN32
5373             case QEMU_OPTION_k:
5374                 keyboard_layout = optarg;
5375                 break;
5376 #endif
5377             case QEMU_OPTION_localtime:
5378                 rtc_utc = 0;
5379                 break;
5380             case QEMU_OPTION_vga:
5381                 select_vgahw (optarg);
5382                 break;
5383 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5384             case QEMU_OPTION_g:
5385                 {
5386                     const char *p;
5387                     int w, h, depth;
5388                     p = optarg;
5389                     w = strtol(p, (char **)&p, 10);
5390                     if (w <= 0) {
5391                     graphic_error:
5392                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5393                         exit(1);
5394                     }
5395                     if (*p != 'x')
5396                         goto graphic_error;
5397                     p++;
5398                     h = strtol(p, (char **)&p, 10);
5399                     if (h <= 0)
5400                         goto graphic_error;
5401                     if (*p == 'x') {
5402                         p++;
5403                         depth = strtol(p, (char **)&p, 10);
5404                         if (depth != 8 && depth != 15 && depth != 16 &&
5405                             depth != 24 && depth != 32)
5406                             goto graphic_error;
5407                     } else if (*p == '\0') {
5408                         depth = graphic_depth;
5409                     } else {
5410                         goto graphic_error;
5411                     }
5412
5413                     graphic_width = w;
5414                     graphic_height = h;
5415                     graphic_depth = depth;
5416                 }
5417                 break;
5418 #endif
5419             case QEMU_OPTION_echr:
5420                 {
5421                     char *r;
5422                     term_escape_char = strtol(optarg, &r, 0);
5423                     if (r == optarg)
5424                         printf("Bad argument to echr\n");
5425                     break;
5426                 }
5427             case QEMU_OPTION_monitor:
5428                 monitor_device = optarg;
5429                 break;
5430             case QEMU_OPTION_serial:
5431                 if (serial_device_index >= MAX_SERIAL_PORTS) {
5432                     fprintf(stderr, "qemu: too many serial ports\n");
5433                     exit(1);
5434                 }
5435                 serial_devices[serial_device_index] = optarg;
5436                 serial_device_index++;
5437                 break;
5438             case QEMU_OPTION_watchdog:
5439                 i = select_watchdog(optarg);
5440                 if (i > 0)
5441                     exit (i == 1 ? 1 : 0);
5442                 break;
5443             case QEMU_OPTION_watchdog_action:
5444                 if (select_watchdog_action(optarg) == -1) {
5445                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
5446                     exit(1);
5447                 }
5448                 break;
5449             case QEMU_OPTION_virtiocon:
5450                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5451                     fprintf(stderr, "qemu: too many virtio consoles\n");
5452                     exit(1);
5453                 }
5454                 virtio_consoles[virtio_console_index] = optarg;
5455                 virtio_console_index++;
5456                 break;
5457             case QEMU_OPTION_parallel:
5458                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5459                     fprintf(stderr, "qemu: too many parallel ports\n");
5460                     exit(1);
5461                 }
5462                 parallel_devices[parallel_device_index] = optarg;
5463                 parallel_device_index++;
5464                 break;
5465             case QEMU_OPTION_loadvm:
5466                 loadvm = optarg;
5467                 break;
5468             case QEMU_OPTION_full_screen:
5469                 full_screen = 1;
5470                 break;
5471 #ifdef CONFIG_SDL
5472             case QEMU_OPTION_no_frame:
5473                 no_frame = 1;
5474                 break;
5475             case QEMU_OPTION_alt_grab:
5476                 alt_grab = 1;
5477                 break;
5478             case QEMU_OPTION_no_quit:
5479                 no_quit = 1;
5480                 break;
5481             case QEMU_OPTION_sdl:
5482                 display_type = DT_SDL;
5483                 break;
5484 #endif
5485             case QEMU_OPTION_pidfile:
5486                 pid_file = optarg;
5487                 break;
5488 #ifdef TARGET_I386
5489             case QEMU_OPTION_win2k_hack:
5490                 win2k_install_hack = 1;
5491                 break;
5492             case QEMU_OPTION_rtc_td_hack:
5493                 rtc_td_hack = 1;
5494                 break;
5495             case QEMU_OPTION_acpitable:
5496                 if(acpi_table_add(optarg) < 0) {
5497                     fprintf(stderr, "Wrong acpi table provided\n");
5498                     exit(1);
5499                 }
5500                 break;
5501             case QEMU_OPTION_smbios:
5502                 if(smbios_entry_add(optarg) < 0) {
5503                     fprintf(stderr, "Wrong smbios provided\n");
5504                     exit(1);
5505                 }
5506                 break;
5507 #endif
5508 #ifdef CONFIG_KQEMU
5509             case QEMU_OPTION_no_kqemu:
5510                 kqemu_allowed = 0;
5511                 break;
5512             case QEMU_OPTION_kernel_kqemu:
5513                 kqemu_allowed = 2;
5514                 break;
5515 #endif
5516 #ifdef CONFIG_KVM
5517             case QEMU_OPTION_enable_kvm:
5518                 kvm_allowed = 1;
5519 #ifdef CONFIG_KQEMU
5520                 kqemu_allowed = 0;
5521 #endif
5522                 break;
5523 #endif
5524             case QEMU_OPTION_usb:
5525                 usb_enabled = 1;
5526                 break;
5527             case QEMU_OPTION_usbdevice:
5528                 usb_enabled = 1;
5529                 if (usb_devices_index >= MAX_USB_CMDLINE) {
5530                     fprintf(stderr, "Too many USB devices\n");
5531                     exit(1);
5532                 }
5533                 usb_devices[usb_devices_index] = optarg;
5534                 usb_devices_index++;
5535                 break;
5536             case QEMU_OPTION_smp:
5537                 smp_cpus = atoi(optarg);
5538                 if (smp_cpus < 1) {
5539                     fprintf(stderr, "Invalid number of CPUs\n");
5540                     exit(1);
5541                 }
5542                 break;
5543             case QEMU_OPTION_vnc:
5544                 display_type = DT_VNC;
5545                 vnc_display = optarg;
5546                 break;
5547 #ifdef TARGET_I386
5548             case QEMU_OPTION_no_acpi:
5549                 acpi_enabled = 0;
5550                 break;
5551             case QEMU_OPTION_no_hpet:
5552                 no_hpet = 1;
5553                 break;
5554 #endif
5555             case QEMU_OPTION_no_reboot:
5556                 no_reboot = 1;
5557                 break;
5558             case QEMU_OPTION_no_shutdown:
5559                 no_shutdown = 1;
5560                 break;
5561             case QEMU_OPTION_show_cursor:
5562                 cursor_hide = 0;
5563                 break;
5564             case QEMU_OPTION_uuid:
5565                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5566                     fprintf(stderr, "Fail to parse UUID string."
5567                             " Wrong format.\n");
5568                     exit(1);
5569                 }
5570                 break;
5571 #ifndef _WIN32
5572             case QEMU_OPTION_daemonize:
5573                 daemonize = 1;
5574                 break;
5575 #endif
5576             case QEMU_OPTION_option_rom:
5577                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5578                     fprintf(stderr, "Too many option ROMs\n");
5579                     exit(1);
5580                 }
5581                 option_rom[nb_option_roms] = optarg;
5582                 nb_option_roms++;
5583                 break;
5584 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5585             case QEMU_OPTION_semihosting:
5586                 semihosting_enabled = 1;
5587                 break;
5588 #endif
5589             case QEMU_OPTION_name:
5590                 qemu_name = optarg;
5591                 break;
5592 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5593             case QEMU_OPTION_prom_env:
5594                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5595                     fprintf(stderr, "Too many prom variables\n");
5596                     exit(1);
5597                 }
5598                 prom_envs[nb_prom_envs] = optarg;
5599                 nb_prom_envs++;
5600                 break;
5601 #endif
5602 #ifdef TARGET_ARM
5603             case QEMU_OPTION_old_param:
5604                 old_param = 1;
5605                 break;
5606 #endif
5607             case QEMU_OPTION_clock:
5608                 configure_alarms(optarg);
5609                 break;
5610             case QEMU_OPTION_startdate:
5611                 {
5612                     struct tm tm;
5613                     time_t rtc_start_date;
5614                     if (!strcmp(optarg, "now")) {
5615                         rtc_date_offset = -1;
5616                     } else {
5617                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5618                                &tm.tm_year,
5619                                &tm.tm_mon,
5620                                &tm.tm_mday,
5621                                &tm.tm_hour,
5622                                &tm.tm_min,
5623                                &tm.tm_sec) == 6) {
5624                             /* OK */
5625                         } else if (sscanf(optarg, "%d-%d-%d",
5626                                           &tm.tm_year,
5627                                           &tm.tm_mon,
5628                                           &tm.tm_mday) == 3) {
5629                             tm.tm_hour = 0;
5630                             tm.tm_min = 0;
5631                             tm.tm_sec = 0;
5632                         } else {
5633                             goto date_fail;
5634                         }
5635                         tm.tm_year -= 1900;
5636                         tm.tm_mon--;
5637                         rtc_start_date = mktimegm(&tm);
5638                         if (rtc_start_date == -1) {
5639                         date_fail:
5640                             fprintf(stderr, "Invalid date format. Valid format are:\n"
5641                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5642                             exit(1);
5643                         }
5644                         rtc_date_offset = time(NULL) - rtc_start_date;
5645                     }
5646                 }
5647                 break;
5648             case QEMU_OPTION_tb_size:
5649                 tb_size = strtol(optarg, NULL, 0);
5650                 if (tb_size < 0)
5651                     tb_size = 0;
5652                 break;
5653             case QEMU_OPTION_icount:
5654                 use_icount = 1;
5655                 if (strcmp(optarg, "auto") == 0) {
5656                     icount_time_shift = -1;
5657                 } else {
5658                     icount_time_shift = strtol(optarg, NULL, 0);
5659                 }
5660                 break;
5661             case QEMU_OPTION_incoming:
5662                 incoming = optarg;
5663                 break;
5664 #ifndef _WIN32
5665             case QEMU_OPTION_chroot:
5666                 chroot_dir = optarg;
5667                 break;
5668             case QEMU_OPTION_runas:
5669                 run_as = optarg;
5670                 break;
5671 #endif
5672 #ifdef CONFIG_XEN
5673             case QEMU_OPTION_xen_domid:
5674                 xen_domid = atoi(optarg);
5675                 break;
5676             case QEMU_OPTION_xen_create:
5677                 xen_mode = XEN_CREATE;
5678                 break;
5679             case QEMU_OPTION_xen_attach:
5680                 xen_mode = XEN_ATTACH;
5681                 break;
5682 #endif
5683             }
5684         }
5685     }
5686
5687     /* If no data_dir is specified then try to find it relative to the
5688        executable path.  */
5689     if (!data_dir) {
5690         data_dir = find_datadir(argv[0]);
5691     }
5692     /* If all else fails use the install patch specified when building.  */
5693     if (!data_dir) {
5694         data_dir = CONFIG_QEMU_SHAREDIR;
5695     }
5696
5697 #if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
5698     if (kvm_allowed && kqemu_allowed) {
5699         fprintf(stderr,
5700                 "You can not enable both KVM and kqemu at the same time\n");
5701         exit(1);
5702     }
5703 #endif
5704
5705     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5706     if (smp_cpus > machine->max_cpus) {
5707         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5708                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5709                 machine->max_cpus);
5710         exit(1);
5711     }
5712
5713     if (display_type == DT_NOGRAPHIC) {
5714        if (serial_device_index == 0)
5715            serial_devices[0] = "stdio";
5716        if (parallel_device_index == 0)
5717            parallel_devices[0] = "null";
5718        if (strncmp(monitor_device, "vc", 2) == 0)
5719            monitor_device = "stdio";
5720     }
5721
5722 #ifndef _WIN32
5723     if (daemonize) {
5724         pid_t pid;
5725
5726         if (pipe(fds) == -1)
5727             exit(1);
5728
5729         pid = fork();
5730         if (pid > 0) {
5731             uint8_t status;
5732             ssize_t len;
5733
5734             close(fds[1]);
5735
5736         again:
5737             len = read(fds[0], &status, 1);
5738             if (len == -1 && (errno == EINTR))
5739                 goto again;
5740
5741             if (len != 1)
5742                 exit(1);
5743             else if (status == 1) {
5744                 fprintf(stderr, "Could not acquire pidfile\n");
5745                 exit(1);
5746             } else
5747                 exit(0);
5748         } else if (pid < 0)
5749             exit(1);
5750
5751         setsid();
5752
5753         pid = fork();
5754         if (pid > 0)
5755             exit(0);
5756         else if (pid < 0)
5757             exit(1);
5758
5759         umask(027);
5760
5761         signal(SIGTSTP, SIG_IGN);
5762         signal(SIGTTOU, SIG_IGN);
5763         signal(SIGTTIN, SIG_IGN);
5764     }
5765
5766     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5767         if (daemonize) {
5768             uint8_t status = 1;
5769             write(fds[1], &status, 1);
5770         } else
5771             fprintf(stderr, "Could not acquire pid file\n");
5772         exit(1);
5773     }
5774 #endif
5775
5776 #ifdef CONFIG_KQEMU
5777     if (smp_cpus > 1)
5778         kqemu_allowed = 0;
5779 #endif
5780     if (qemu_init_main_loop()) {
5781         fprintf(stderr, "qemu_init_main_loop failed\n");
5782         exit(1);
5783     }
5784     linux_boot = (kernel_filename != NULL);
5785     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5786
5787     if (!linux_boot && *kernel_cmdline != '\0') {
5788         fprintf(stderr, "-append only allowed with -kernel option\n");
5789         exit(1);
5790     }
5791
5792     if (!linux_boot && initrd_filename != NULL) {
5793         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5794         exit(1);
5795     }
5796
5797     /* boot to floppy or the default cd if no hard disk defined yet */
5798     if (!boot_devices[0]) {
5799         boot_devices = "cad";
5800     }
5801     setvbuf(stdout, NULL, _IOLBF, 0);
5802
5803     init_timers();
5804     if (init_timer_alarm() < 0) {
5805         fprintf(stderr, "could not initialize alarm timer\n");
5806         exit(1);
5807     }
5808     if (use_icount && icount_time_shift < 0) {
5809         use_icount = 2;
5810         /* 125MIPS seems a reasonable initial guess at the guest speed.
5811            It will be corrected fairly quickly anyway.  */
5812         icount_time_shift = 3;
5813         init_icount_adjust();
5814     }
5815
5816 #ifdef _WIN32
5817     socket_init();
5818 #endif
5819
5820     /* init network clients */
5821     if (nb_net_clients == 0) {
5822         /* if no clients, we use a default config */
5823         net_clients[nb_net_clients++] = "nic";
5824 #ifdef CONFIG_SLIRP
5825         net_clients[nb_net_clients++] = "user";
5826 #endif
5827     }
5828
5829     for(i = 0;i < nb_net_clients; i++) {
5830         if (net_client_parse(net_clients[i]) < 0)
5831             exit(1);
5832     }
5833     net_client_check();
5834
5835 #ifdef TARGET_I386
5836     /* XXX: this should be moved in the PC machine instantiation code */
5837     if (net_boot != 0) {
5838         int netroms = 0;
5839         for (i = 0; i < nb_nics && i < 4; i++) {
5840             const char *model = nd_table[i].model;
5841             char buf[1024];
5842             char *filename;
5843             if (net_boot & (1 << i)) {
5844                 if (model == NULL)
5845                     model = "ne2k_pci";
5846                 snprintf(buf, sizeof(buf), "pxe-%s.bin", model);
5847                 filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, buf);
5848                 if (filename && get_image_size(filename) > 0) {
5849                     if (nb_option_roms >= MAX_OPTION_ROMS) {
5850                         fprintf(stderr, "Too many option ROMs\n");
5851                         exit(1);
5852                     }
5853                     option_rom[nb_option_roms] = qemu_strdup(buf);
5854                     nb_option_roms++;
5855                     netroms++;
5856                 }
5857                 if (filename) {
5858                     qemu_free(filename);
5859                 }
5860             }
5861         }
5862         if (netroms == 0) {
5863             fprintf(stderr, "No valid PXE rom found for network device\n");
5864             exit(1);
5865         }
5866     }
5867 #endif
5868
5869     /* init the bluetooth world */
5870     for (i = 0; i < nb_bt_opts; i++)
5871         if (bt_parse(bt_opts[i]))
5872             exit(1);
5873
5874     /* init the memory */
5875     if (ram_size == 0)
5876         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5877
5878 #ifdef CONFIG_KQEMU
5879     /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5880        guest ram allocation.  It needs to go away.  */
5881     if (kqemu_allowed) {
5882         kqemu_phys_ram_size = ram_size + 8 * 1024 * 1024 + 4 * 1024 * 1024;
5883         kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size);
5884         if (!kqemu_phys_ram_base) {
5885             fprintf(stderr, "Could not allocate physical memory\n");
5886             exit(1);
5887         }
5888     }
5889 #endif
5890
5891     /* init the dynamic translator */
5892     cpu_exec_init_all(tb_size * 1024 * 1024);
5893
5894     bdrv_init();
5895
5896     /* we always create the cdrom drive, even if no disk is there */
5897
5898     if (nb_drives_opt < MAX_DRIVES)
5899         drive_add(NULL, CDROM_ALIAS);
5900
5901     /* we always create at least one floppy */
5902
5903     if (nb_drives_opt < MAX_DRIVES)
5904         drive_add(NULL, FD_ALIAS, 0);
5905
5906     /* we always create one sd slot, even if no card is in it */
5907
5908     if (nb_drives_opt < MAX_DRIVES)
5909         drive_add(NULL, SD_ALIAS);
5910
5911     /* open the virtual block devices */
5912
5913     for(i = 0; i < nb_drives_opt; i++)
5914         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5915             exit(1);
5916
5917     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5918     register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5919
5920 #ifndef _WIN32
5921     /* must be after terminal init, SDL library changes signal handlers */
5922     sighandler_setup();
5923 #endif
5924
5925     /* Maintain compatibility with multiple stdio monitors */
5926     if (!strcmp(monitor_device,"stdio")) {
5927         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5928             const char *devname = serial_devices[i];
5929             if (devname && !strcmp(devname,"mon:stdio")) {
5930                 monitor_device = NULL;
5931                 break;
5932             } else if (devname && !strcmp(devname,"stdio")) {
5933                 monitor_device = NULL;
5934                 serial_devices[i] = "mon:stdio";
5935                 break;
5936             }
5937         }
5938     }
5939
5940     if (nb_numa_nodes > 0) {
5941         int i;
5942
5943         if (nb_numa_nodes > smp_cpus) {
5944             nb_numa_nodes = smp_cpus;
5945         }
5946
5947         /* If no memory size if given for any node, assume the default case
5948          * and distribute the available memory equally across all nodes
5949          */
5950         for (i = 0; i < nb_numa_nodes; i++) {
5951             if (node_mem[i] != 0)
5952                 break;
5953         }
5954         if (i == nb_numa_nodes) {
5955             uint64_t usedmem = 0;
5956
5957             /* On Linux, the each node's border has to be 8MB aligned,
5958              * the final node gets the rest.
5959              */
5960             for (i = 0; i < nb_numa_nodes - 1; i++) {
5961                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5962                 usedmem += node_mem[i];
5963             }
5964             node_mem[i] = ram_size - usedmem;
5965         }
5966
5967         for (i = 0; i < nb_numa_nodes; i++) {
5968             if (node_cpumask[i] != 0)
5969                 break;
5970         }
5971         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5972          * must cope with this anyway, because there are BIOSes out there in
5973          * real machines which also use this scheme.
5974          */
5975         if (i == nb_numa_nodes) {
5976             for (i = 0; i < smp_cpus; i++) {
5977                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5978             }
5979         }
5980     }
5981
5982     if (kvm_enabled()) {
5983         int ret;
5984
5985         ret = kvm_init(smp_cpus);
5986         if (ret < 0) {
5987             fprintf(stderr, "failed to initialize KVM\n");
5988             exit(1);
5989         }
5990     }
5991
5992     if (monitor_device) {
5993         monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5994         if (!monitor_hd) {
5995             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5996             exit(1);
5997         }
5998     }
5999
6000     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6001         const char *devname = serial_devices[i];
6002         if (devname && strcmp(devname, "none")) {
6003             char label[32];
6004             snprintf(label, sizeof(label), "serial%d", i);
6005             serial_hds[i] = qemu_chr_open(label, devname, NULL);
6006             if (!serial_hds[i]) {
6007                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
6008                         devname);
6009                 exit(1);
6010             }
6011         }
6012     }
6013
6014     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6015         const char *devname = parallel_devices[i];
6016         if (devname && strcmp(devname, "none")) {
6017             char label[32];
6018             snprintf(label, sizeof(label), "parallel%d", i);
6019             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
6020             if (!parallel_hds[i]) {
6021                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
6022                         devname);
6023                 exit(1);
6024             }
6025         }
6026     }
6027
6028     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6029         const char *devname = virtio_consoles[i];
6030         if (devname && strcmp(devname, "none")) {
6031             char label[32];
6032             snprintf(label, sizeof(label), "virtcon%d", i);
6033             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
6034             if (!virtcon_hds[i]) {
6035                 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
6036                         devname);
6037                 exit(1);
6038             }
6039         }
6040     }
6041
6042     module_call_init(MODULE_INIT_DEVICE);
6043
6044     machine->init(ram_size, boot_devices,
6045                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
6046
6047
6048     for (env = first_cpu; env != NULL; env = env->next_cpu) {
6049         for (i = 0; i < nb_numa_nodes; i++) {
6050             if (node_cpumask[i] & (1 << env->cpu_index)) {
6051                 env->numa_node = i;
6052             }
6053         }
6054     }
6055
6056     current_machine = machine;
6057
6058     /* Set KVM's vcpu state to qemu's initial CPUState. */
6059     if (kvm_enabled()) {
6060         int ret;
6061
6062         ret = kvm_sync_vcpus();
6063         if (ret < 0) {
6064             fprintf(stderr, "failed to initialize vcpus\n");
6065             exit(1);
6066         }
6067     }
6068
6069     /* init USB devices */
6070     if (usb_enabled) {
6071         for(i = 0; i < usb_devices_index; i++) {
6072             if (usb_device_add(usb_devices[i], 0) < 0) {
6073                 fprintf(stderr, "Warning: could not add USB device %s\n",
6074                         usb_devices[i]);
6075             }
6076         }
6077     }
6078
6079     if (!display_state)
6080         dumb_display_init();
6081     /* just use the first displaystate for the moment */
6082     ds = display_state;
6083
6084     if (display_type == DT_DEFAULT) {
6085 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
6086         display_type = DT_SDL;
6087 #else
6088         display_type = DT_VNC;
6089         vnc_display = "localhost:0,to=99";
6090         show_vnc_port = 1;
6091 #endif
6092     }
6093
6094
6095     switch (display_type) {
6096     case DT_NOGRAPHIC:
6097         break;
6098 #if defined(CONFIG_CURSES)
6099     case DT_CURSES:
6100         curses_display_init(ds, full_screen);
6101         break;
6102 #endif
6103 #if defined(CONFIG_SDL)
6104     case DT_SDL:
6105         sdl_display_init(ds, full_screen, no_frame);
6106         break;
6107 #elif defined(CONFIG_COCOA)
6108     case DT_SDL:
6109         cocoa_display_init(ds, full_screen);
6110         break;
6111 #endif
6112     case DT_VNC:
6113         vnc_display_init(ds);
6114         if (vnc_display_open(ds, vnc_display) < 0)
6115             exit(1);
6116
6117         if (show_vnc_port) {
6118             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
6119         }
6120         break;
6121     default:
6122         break;
6123     }
6124     dpy_resize(ds);
6125
6126     dcl = ds->listeners;
6127     while (dcl != NULL) {
6128         if (dcl->dpy_refresh != NULL) {
6129             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
6130             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
6131         }
6132         dcl = dcl->next;
6133     }
6134
6135     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
6136         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6137         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6138     }
6139
6140     text_consoles_set_display(display_state);
6141     qemu_chr_initial_reset();
6142
6143     if (monitor_device && monitor_hd)
6144         monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
6145
6146     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
6147         const char *devname = serial_devices[i];
6148         if (devname && strcmp(devname, "none")) {
6149             char label[32];
6150             snprintf(label, sizeof(label), "serial%d", i);
6151             if (strstart(devname, "vc", 0))
6152                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
6153         }
6154     }
6155
6156     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
6157         const char *devname = parallel_devices[i];
6158         if (devname && strcmp(devname, "none")) {
6159             char label[32];
6160             snprintf(label, sizeof(label), "parallel%d", i);
6161             if (strstart(devname, "vc", 0))
6162                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
6163         }
6164     }
6165
6166     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
6167         const char *devname = virtio_consoles[i];
6168         if (virtcon_hds[i] && devname) {
6169             char label[32];
6170             snprintf(label, sizeof(label), "virtcon%d", i);
6171             if (strstart(devname, "vc", 0))
6172                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
6173         }
6174     }
6175
6176     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6177         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6178                 gdbstub_dev);
6179         exit(1);
6180     }
6181
6182     if (loadvm)
6183         do_loadvm(cur_mon, loadvm);
6184
6185     if (incoming) {
6186         autostart = 0; /* fixme how to deal with -daemonize */
6187         qemu_start_incoming_migration(incoming);
6188     }
6189
6190     if (autostart)
6191         vm_start();
6192
6193 #ifndef _WIN32
6194     if (daemonize) {
6195         uint8_t status = 0;
6196         ssize_t len;
6197
6198     again1:
6199         len = write(fds[1], &status, 1);
6200         if (len == -1 && (errno == EINTR))
6201             goto again1;
6202
6203         if (len != 1)
6204             exit(1);
6205
6206         chdir("/");
6207         TFR(fd = open("/dev/null", O_RDWR));
6208         if (fd == -1)
6209             exit(1);
6210     }
6211
6212     if (run_as) {
6213         pwd = getpwnam(run_as);
6214         if (!pwd) {
6215             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6216             exit(1);
6217         }
6218     }
6219
6220     if (chroot_dir) {
6221         if (chroot(chroot_dir) < 0) {
6222             fprintf(stderr, "chroot failed\n");
6223             exit(1);
6224         }
6225         chdir("/");
6226     }
6227
6228     if (run_as) {
6229         if (setgid(pwd->pw_gid) < 0) {
6230             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6231             exit(1);
6232         }
6233         if (setuid(pwd->pw_uid) < 0) {
6234             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6235             exit(1);
6236         }
6237         if (setuid(0) != -1) {
6238             fprintf(stderr, "Dropping privileges failed\n");
6239             exit(1);
6240         }
6241     }
6242
6243     if (daemonize) {
6244         dup2(fd, 0);
6245         dup2(fd, 1);
6246         dup2(fd, 2);
6247
6248         close(fd);
6249     }
6250 #endif
6251
6252     main_loop();
6253     quit_timers();
6254     net_cleanup();
6255
6256     return 0;
6257 }