vl.c

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