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

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <signal.h>
  27 #include <time.h>
  28 #include <errno.h>
  29 #include <sys/time.h>
  30 #include <zlib.h>
  31
  32 /* Needed early for HOST_BSD etc. */
  33 #include "config-host.h"
  34
  35 #ifndef _WIN32
  36 #include <pwd.h>
  37 #include <sys/times.h>
  38 #include <sys/wait.h>
  39 #include <termios.h>
  40 #include <sys/mman.h>
  41 #include <sys/ioctl.h>
  42 #include <sys/resource.h>
  43 #include <sys/socket.h>
  44 #include <netinet/in.h>
  45 #include <net/if.h>
  46 #if defined(__NetBSD__)
  47 #include <net/if_tap.h>
  48 #endif
  49 #ifdef __linux__
  50 #include <linux/if_tun.h>
  51 #endif
  52 #include <arpa/inet.h>
  53 #include <dirent.h>
  54 #include <netdb.h>
  55 #include <sys/select.h>
  56 #ifdef HOST_BSD
  57 #include <sys/stat.h>
  58 #if defined(__FreeBSD__) || defined(__DragonFly__)
  59 #include <libutil.h>
  60 #else
  61 #include <util.h>
  62 #endif
  63 #elif defined (__GLIBC__) && defined (__FreeBSD_kernel__)
  64 #include <freebsd/stdlib.h>
  65 #else
  66 #ifdef __linux__
  67 #include <pty.h>
  68 #include <malloc.h>
  69 #include <linux/rtc.h>
  70
  71 /* For the benefit of older linux systems which don't supply it,
  72    we use a local copy of hpet.h. */
  73 /* #include <linux/hpet.h> */
  74 #include "hpet.h"
  75
  76 #include <linux/ppdev.h>
  77 #include <linux/parport.h>
  78 #endif
  79 #ifdef __sun__
  80 #include <sys/stat.h>
  81 #include <sys/ethernet.h>
  82 #include <sys/sockio.h>
  83 #include <netinet/arp.h>
  84 #include <netinet/in.h>
  85 #include <netinet/in_systm.h>
  86 #include <netinet/ip.h>
  87 #include <netinet/ip_icmp.h> // must come after ip.h
  88 #include <netinet/udp.h>
  89 #include <netinet/tcp.h>
  90 #include <net/if.h>
  91 #include <syslog.h>
  92 #include <stropts.h>
  93 #endif
  94 #endif
  95 #endif
  96
  97 #if defined(__OpenBSD__)
  98 #include <util.h>
  99 #endif
 100
 101 #if defined(CONFIG_VDE)
 102 #include <libvdeplug.h>
 103 #endif
 104
 105 #ifdef _WIN32
 106 #include <windows.h>
 107 #include <malloc.h>
 108 #include <sys/timeb.h>
 109 #include <mmsystem.h>
 110 #define getopt_long_only getopt_long
 111 #define memalign(align, size) malloc(size)
 112 #endif
 113
 114 #ifdef CONFIG_SDL
 115 #ifdef __APPLE__
 116 #include <SDL/SDL.h>
 117 int qemu_main(int argc, char **argv, char **envp);
 118 int main(int argc, char **argv)
 119 {
 120     qemu_main(argc, argv, NULL);
 121 }
 122 #undef main
 123 #define main qemu_main
 124 #endif
 125 #endif /* CONFIG_SDL */
 126
 127 #ifdef CONFIG_COCOA
 128 #undef main
 129 #define main qemu_main
 130 #endif /* CONFIG_COCOA */
 131
 132 #include "hw/hw.h"
 133 #include "hw/boards.h"
 134 #include "hw/usb.h"
 135 #include "hw/pcmcia.h"
 136 #include "hw/pc.h"
 137 #include "hw/audiodev.h"
 138 #include "hw/isa.h"
 139 #include "hw/baum.h"
 140 #include "hw/bt.h"
 141 #include "hw/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
3572 int qemu_shutdown_requested(void)
3573 {
3574     int r = shutdown_requested;
3575     shutdown_requested = 0;
3576     return r;
3577 }
3578
3579 int qemu_reset_requested(void)
3580 {
3581     int r = reset_requested;
3582     reset_requested = 0;
3583     return r;
3584 }
3585
3586 int qemu_powerdown_requested(void)
3587 {
3588     int r = powerdown_requested;
3589     powerdown_requested = 0;
3590     return r;
3591 }
3592
3593 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3594 {
3595     QEMUResetEntry **pre, *re;
3596
3597     pre = &first_reset_entry;
3598     while (*pre != NULL)
3599         pre = &(*pre)->next;
3600     re = qemu_mallocz(sizeof(QEMUResetEntry));
3601     re->func = func;
3602     re->opaque = opaque;
3603     re->next = NULL;
3604     *pre = re;
3605 }
3606
3607 void qemu_system_reset(void)
3608 {
3609     QEMUResetEntry *re;
3610
3611     /* reset all devices */
3612     for(re = first_reset_entry; re != NULL; re = re->next) {
3613         re->func(re->opaque);
3614     }
3615     if (kvm_enabled())
3616         kvm_sync_vcpus();
3617 }
3618
3619 void qemu_system_reset_request(void)
3620 {
3621     if (no_reboot) {
3622         shutdown_requested = 1;
3623     } else {
3624         reset_requested = 1;
3625     }
3626     qemu_notify_event();
3627 }
3628
3629 void qemu_system_shutdown_request(void)
3630 {
3631     shutdown_requested = 1;
3632     qemu_notify_event();
3633 }
3634
3635 void qemu_system_powerdown_request(void)
3636 {
3637     powerdown_requested = 1;
3638     qemu_notify_event();
3639 }
3640
3641 void qemu_notify_event(void)
3642 {
3643     CPUState *env = cpu_single_env;
3644
3645     if (env) {
3646         cpu_exit(env);
3647 #ifdef USE_KQEMU
3648         if (env->kqemu_enabled)
3649             kqemu_cpu_interrupt(env);
3650 #endif
3651      }
3652 }
3653
3654 #ifndef _WIN32
3655 static int io_thread_fd = -1;
3656
3657 static void qemu_event_increment(void)
3658 {
3659     static const char byte = 0;
3660
3661     if (io_thread_fd == -1)
3662         return;
3663
3664     write(io_thread_fd, &byte, sizeof(byte));
3665 }
3666
3667 static void qemu_event_read(void *opaque)
3668 {
3669     int fd = (unsigned long)opaque;
3670     ssize_t len;
3671
3672     /* Drain the notify pipe */
3673     do {
3674         char buffer[512];
3675         len = read(fd, buffer, sizeof(buffer));
3676     } while ((len == -1 && errno == EINTR) || len > 0);
3677 }
3678
3679 static int qemu_event_init(void)
3680 {
3681     int err;
3682     int fds[2];
3683
3684     err = pipe(fds);
3685     if (err == -1)
3686         return -errno;
3687
3688     err = fcntl_setfl(fds[0], O_NONBLOCK);
3689     if (err < 0)
3690         goto fail;
3691
3692     err = fcntl_setfl(fds[1], O_NONBLOCK);
3693     if (err < 0)
3694         goto fail;
3695
3696     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3697                          (void *)(unsigned long)fds[0]);
3698
3699     io_thread_fd = fds[1];
3700 fail:
3701     close(fds[0]);
3702     close(fds[1]);
3703     return err;
3704 }
3705 #else
3706 HANDLE qemu_event_handle;
3707
3708 static void dummy_event_handler(void *opaque)
3709 {
3710 }
3711
3712 static int qemu_event_init(void)
3713 {
3714     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3715     if (!qemu_event_handle) {
3716         perror("Failed CreateEvent");
3717         return -1;
3718     }
3719     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3720     return 0;
3721 }
3722
3723 static void qemu_event_increment(void)
3724 {
3725     SetEvent(qemu_event_handle);
3726 }
3727 #endif
3728
3729 static int qemu_init_main_loop(void)
3730 {
3731     return qemu_event_init();
3732 }
3733
3734 void qemu_init_vcpu(void *_env)
3735 {
3736     CPUState *env = _env;
3737
3738     if (kvm_enabled())
3739         kvm_init_vcpu(env);
3740     return;
3741 }
3742
3743 int qemu_cpu_self(void *env)
3744 {
3745     return 1;
3746 }
3747
3748 void qemu_cpu_kick(void *env)
3749 {
3750     return;
3751 }
3752
3753 #define qemu_mutex_lock_iothread() do { } while (0)
3754 #define qemu_mutex_unlock_iothread() do { } while (0)
3755
3756 #ifdef _WIN32
3757 static void host_main_loop_wait(int *timeout)
3758 {
3759     int ret, ret2, i;
3760     PollingEntry *pe;
3761
3762
3763     /* XXX: need to suppress polling by better using win32 events */
3764     ret = 0;
3765     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3766         ret |= pe->func(pe->opaque);
3767     }
3768     if (ret == 0) {
3769         int err;
3770         WaitObjects *w = &wait_objects;
3771
3772         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3773         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3774             if (w->func[ret - WAIT_OBJECT_0])
3775                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3776
3777             /* Check for additional signaled events */
3778             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3779
3780                 /* Check if event is signaled */
3781                 ret2 = WaitForSingleObject(w->events[i], 0);
3782                 if(ret2 == WAIT_OBJECT_0) {
3783                     if (w->func[i])
3784                         w->func[i](w->opaque[i]);
3785                 } else if (ret2 == WAIT_TIMEOUT) {
3786                 } else {
3787                     err = GetLastError();
3788                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3789                 }
3790             }
3791         } else if (ret == WAIT_TIMEOUT) {
3792         } else {
3793             err = GetLastError();
3794             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3795         }
3796     }
3797
3798     *timeout = 0;
3799 }
3800 #else
3801 static void host_main_loop_wait(int *timeout)
3802 {
3803 }
3804 #endif
3805
3806 void main_loop_wait(int timeout)
3807 {
3808     IOHandlerRecord *ioh;
3809     fd_set rfds, wfds, xfds;
3810     int ret, nfds;
3811     struct timeval tv;
3812
3813     qemu_bh_update_timeout(&timeout);
3814
3815     host_main_loop_wait(&timeout);
3816
3817     /* poll any events */
3818     /* XXX: separate device handlers from system ones */
3819     nfds = -1;
3820     FD_ZERO(&rfds);
3821     FD_ZERO(&wfds);
3822     FD_ZERO(&xfds);
3823     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3824         if (ioh->deleted)
3825             continue;
3826         if (ioh->fd_read &&
3827             (!ioh->fd_read_poll ||
3828              ioh->fd_read_poll(ioh->opaque) != 0)) {
3829             FD_SET(ioh->fd, &rfds);
3830             if (ioh->fd > nfds)
3831                 nfds = ioh->fd;
3832         }
3833         if (ioh->fd_write) {
3834             FD_SET(ioh->fd, &wfds);
3835             if (ioh->fd > nfds)
3836                 nfds = ioh->fd;
3837         }
3838     }
3839
3840     tv.tv_sec = timeout / 1000;
3841     tv.tv_usec = (timeout % 1000) * 1000;
3842
3843 #if defined(CONFIG_SLIRP)
3844     if (slirp_is_inited()) {
3845         slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3846     }
3847 #endif
3848     qemu_mutex_unlock_iothread();
3849     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3850     qemu_mutex_lock_iothread();
3851     if (ret > 0) {
3852         IOHandlerRecord **pioh;
3853
3854         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3855             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3856                 ioh->fd_read(ioh->opaque);
3857             }
3858             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3859                 ioh->fd_write(ioh->opaque);
3860             }
3861         }
3862
3863         /* remove deleted IO handlers */
3864         pioh = &first_io_handler;
3865         while (*pioh) {
3866             ioh = *pioh;
3867             if (ioh->deleted) {
3868                 *pioh = ioh->next;
3869                 qemu_free(ioh);
3870             } else
3871                 pioh = &ioh->next;
3872         }
3873     }
3874 #if defined(CONFIG_SLIRP)
3875     if (slirp_is_inited()) {
3876         if (ret < 0) {
3877             FD_ZERO(&rfds);
3878             FD_ZERO(&wfds);
3879             FD_ZERO(&xfds);
3880         }
3881         slirp_select_poll(&rfds, &wfds, &xfds);
3882     }
3883 #endif
3884
3885     /* rearm timer, if not periodic */
3886     if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
3887         alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
3888         qemu_rearm_alarm_timer(alarm_timer);
3889     }
3890
3891     /* vm time timers */
3892     if (vm_running && likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3893         qemu_run_timers(&active_timers[QEMU_TIMER_VIRTUAL],
3894                         qemu_get_clock(vm_clock));
3895
3896     /* real time timers */
3897     qemu_run_timers(&active_timers[QEMU_TIMER_REALTIME],
3898                     qemu_get_clock(rt_clock));
3899
3900     /* Check bottom-halves last in case any of the earlier events triggered
3901        them.  */
3902     qemu_bh_poll();
3903
3904 }
3905
3906 static int qemu_cpu_exec(CPUState *env)
3907 {
3908     int ret;
3909 #ifdef CONFIG_PROFILER
3910     int64_t ti;
3911 #endif
3912
3913 #ifdef CONFIG_PROFILER
3914     ti = profile_getclock();
3915 #endif
3916     if (use_icount) {
3917         int64_t count;
3918         int decr;
3919         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3920         env->icount_decr.u16.low = 0;
3921         env->icount_extra = 0;
3922         count = qemu_next_deadline();
3923         count = (count + (1 << icount_time_shift) - 1)
3924                 >> icount_time_shift;
3925         qemu_icount += count;
3926         decr = (count > 0xffff) ? 0xffff : count;
3927         count -= decr;
3928         env->icount_decr.u16.low = decr;
3929         env->icount_extra = count;
3930     }
3931     ret = cpu_exec(env);
3932 #ifdef CONFIG_PROFILER
3933     qemu_time += profile_getclock() - ti;
3934 #endif
3935     if (use_icount) {
3936         /* Fold pending instructions back into the
3937            instruction counter, and clear the interrupt flag.  */
3938         qemu_icount -= (env->icount_decr.u16.low
3939                         + env->icount_extra);
3940         env->icount_decr.u32 = 0;
3941         env->icount_extra = 0;
3942     }
3943     return ret;
3944 }
3945
3946 static int cpu_has_work(CPUState *env)
3947 {
3948     if (!env->halted)
3949         return 1;
3950     if (qemu_cpu_has_work(env))
3951         return 1;
3952     return 0;
3953 }
3954
3955 static int tcg_has_work(void)
3956 {
3957     CPUState *env;
3958
3959     for (env = first_cpu; env != NULL; env = env->next_cpu)
3960         if (cpu_has_work(env))
3961             return 1;
3962     return 0;
3963 }
3964
3965 static int qemu_calculate_timeout(void)
3966 {
3967     int timeout;
3968
3969     if (!vm_running)
3970         timeout = 5000;
3971     else if (tcg_has_work())
3972         timeout = 0;
3973     else if (!use_icount)
3974         timeout = 5000;
3975     else {
3976      /* XXX: use timeout computed from timers */
3977         int64_t add;
3978         int64_t delta;
3979         /* Advance virtual time to the next event.  */
3980         if (use_icount == 1) {
3981             /* When not using an adaptive execution frequency
3982                we tend to get badly out of sync with real time,
3983                so just delay for a reasonable amount of time.  */
3984             delta = 0;
3985         } else {
3986             delta = cpu_get_icount() - cpu_get_clock();
3987         }
3988         if (delta > 0) {
3989             /* If virtual time is ahead of real time then just
3990                wait for IO.  */
3991             timeout = (delta / 1000000) + 1;
3992         } else {
3993             /* Wait for either IO to occur or the next
3994                timer event.  */
3995             add = qemu_next_deadline();
3996             /* We advance the timer before checking for IO.
3997                Limit the amount we advance so that early IO
3998                activity won't get the guest too far ahead.  */
3999             if (add > 10000000)
4000                 add = 10000000;
4001             delta += add;
4002             add = (add + (1 << icount_time_shift) - 1)
4003                   >> icount_time_shift;
4004             qemu_icount += add;
4005             timeout = delta / 1000000;
4006             if (timeout < 0)
4007                 timeout = 0;
4008         }
4009     }
4010
4011     return timeout;
4012 }
4013
4014 static int vm_can_run(void)
4015 {
4016     if (powerdown_requested)
4017         return 0;
4018     if (reset_requested)
4019         return 0;
4020     if (shutdown_requested)
4021         return 0;
4022     return 1;
4023 }
4024
4025 static void main_loop(void)
4026 {
4027     int ret = 0;
4028 #ifdef CONFIG_PROFILER
4029     int64_t ti;
4030 #endif
4031
4032     for (;;) {
4033         do {
4034             if (next_cpu == NULL)
4035                 next_cpu = first_cpu;
4036             for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
4037                 CPUState *env = cur_cpu = next_cpu;
4038
4039                 if (!vm_running)
4040                     break;
4041                 if (timer_alarm_pending) {
4042                     timer_alarm_pending = 0;
4043                     break;
4044                 }
4045                 ret = qemu_cpu_exec(env);
4046                 if (ret == EXCP_DEBUG) {
4047                     gdb_set_stop_cpu(env);
4048                     break;
4049                 }
4050             }
4051 #ifdef CONFIG_PROFILER
4052             ti = profile_getclock();
4053 #endif
4054             main_loop_wait(qemu_calculate_timeout());
4055 #ifdef CONFIG_PROFILER
4056             dev_time += profile_getclock() - ti;
4057 #endif
4058         } while (ret != EXCP_DEBUG && vm_can_run());
4059
4060         if (ret == EXCP_DEBUG)
4061             vm_stop(EXCP_DEBUG);
4062
4063         if (qemu_shutdown_requested()) {
4064             if (no_shutdown) {
4065                 vm_stop(0);
4066                 no_shutdown = 0;
4067             } else
4068                 break;
4069         }
4070         if (qemu_reset_requested())
4071             qemu_system_reset();
4072         if (qemu_powerdown_requested())
4073             qemu_system_powerdown();
4074     }
4075 }
4076
4077 static void version(void)
4078 {
4079     printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4080 }
4081
4082 static void help(int exitcode)
4083 {
4084     version();
4085     printf("usage: %s [options] [disk_image]\n"
4086            "\n"
4087            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4088            "\n"
4089 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4090            opt_help
4091 #define DEFHEADING(text) stringify(text) "\n"
4092 #include "qemu-options.h"
4093 #undef DEF
4094 #undef DEFHEADING
4095 #undef GEN_DOCS
4096            "\n"
4097            "During emulation, the following keys are useful:\n"
4098            "ctrl-alt-f      toggle full screen\n"
4099            "ctrl-alt-n      switch to virtual console 'n'\n"
4100            "ctrl-alt        toggle mouse and keyboard grab\n"
4101            "\n"
4102            "When using -nographic, press 'ctrl-a h' to get some help.\n"
4103            ,
4104            "qemu",
4105            DEFAULT_RAM_SIZE,
4106 #ifndef _WIN32
4107            DEFAULT_NETWORK_SCRIPT,
4108            DEFAULT_NETWORK_DOWN_SCRIPT,
4109 #endif
4110            DEFAULT_GDBSTUB_PORT,
4111            "/tmp/qemu.log");
4112     exit(exitcode);
4113 }
4114
4115 #define HAS_ARG 0x0001
4116
4117 enum {
4118 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4119     opt_enum,
4120 #define DEFHEADING(text)
4121 #include "qemu-options.h"
4122 #undef DEF
4123 #undef DEFHEADING
4124 #undef GEN_DOCS
4125 };
4126
4127 typedef struct QEMUOption {
4128     const char *name;
4129     int flags;
4130     int index;
4131 } QEMUOption;
4132
4133 static const QEMUOption qemu_options[] = {
4134     { "h", 0, QEMU_OPTION_h },
4135 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4136     { option, opt_arg, opt_enum },
4137 #define DEFHEADING(text)
4138 #include "qemu-options.h"
4139 #undef DEF
4140 #undef DEFHEADING
4141 #undef GEN_DOCS
4142     { NULL },
4143 };
4144
4145 #ifdef HAS_AUDIO
4146 struct soundhw soundhw[] = {
4147 #ifdef HAS_AUDIO_CHOICE
4148 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4149     {
4150         "pcspk",
4151         "PC speaker",
4152         0,
4153         1,
4154         { .init_isa = pcspk_audio_init }
4155     },
4156 #endif
4157
4158 #ifdef CONFIG_SB16
4159     {
4160         "sb16",
4161         "Creative Sound Blaster 16",
4162         0,
4163         1,
4164         { .init_isa = SB16_init }
4165     },
4166 #endif
4167
4168 #ifdef CONFIG_CS4231A
4169     {
4170         "cs4231a",
4171         "CS4231A",
4172         0,
4173         1,
4174         { .init_isa = cs4231a_init }
4175     },
4176 #endif
4177
4178 #ifdef CONFIG_ADLIB
4179     {
4180         "adlib",
4181 #ifdef HAS_YMF262
4182         "Yamaha YMF262 (OPL3)",
4183 #else
4184         "Yamaha YM3812 (OPL2)",
4185 #endif
4186         0,
4187         1,
4188         { .init_isa = Adlib_init }
4189     },
4190 #endif
4191
4192 #ifdef CONFIG_GUS
4193     {
4194         "gus",
4195         "Gravis Ultrasound GF1",
4196         0,
4197         1,
4198         { .init_isa = GUS_init }
4199     },
4200 #endif
4201
4202 #ifdef CONFIG_AC97
4203     {
4204         "ac97",
4205         "Intel 82801AA AC97 Audio",
4206         0,
4207         0,
4208         { .init_pci = ac97_init }
4209     },
4210 #endif
4211
4212 #ifdef CONFIG_ES1370
4213     {
4214         "es1370",
4215         "ENSONIQ AudioPCI ES1370",
4216         0,
4217         0,
4218         { .init_pci = es1370_init }
4219     },
4220 #endif
4221
4222 #endif /* HAS_AUDIO_CHOICE */
4223
4224     { NULL, NULL, 0, 0, { NULL } }
4225 };
4226
4227 static void select_soundhw (const char *optarg)
4228 {
4229     struct soundhw *c;
4230
4231     if (*optarg == '?') {
4232     show_valid_cards:
4233
4234         printf ("Valid sound card names (comma separated):\n");
4235         for (c = soundhw; c->name; ++c) {
4236             printf ("%-11s %s\n", c->name, c->descr);
4237         }
4238         printf ("\n-soundhw all will enable all of the above\n");
4239         exit (*optarg != '?');
4240     }
4241     else {
4242         size_t l;
4243         const char *p;
4244         char *e;
4245         int bad_card = 0;
4246
4247         if (!strcmp (optarg, "all")) {
4248             for (c = soundhw; c->name; ++c) {
4249                 c->enabled = 1;
4250             }
4251             return;
4252         }
4253
4254         p = optarg;
4255         while (*p) {
4256             e = strchr (p, ',');
4257             l = !e ? strlen (p) : (size_t) (e - p);
4258
4259             for (c = soundhw; c->name; ++c) {
4260                 if (!strncmp (c->name, p, l)) {
4261                     c->enabled = 1;
4262                     break;
4263                 }
4264             }
4265
4266             if (!c->name) {
4267                 if (l > 80) {
4268                     fprintf (stderr,
4269                              "Unknown sound card name (too big to show)\n");
4270                 }
4271                 else {
4272                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4273                              (int) l, p);
4274                 }
4275                 bad_card = 1;
4276             }
4277             p += l + (e != NULL);
4278         }
4279
4280         if (bad_card)
4281             goto show_valid_cards;
4282     }
4283 }
4284 #endif
4285
4286 static void select_vgahw (const char *p)
4287 {
4288     const char *opts;
4289
4290     cirrus_vga_enabled = 0;
4291     std_vga_enabled = 0;
4292     vmsvga_enabled = 0;
4293     xenfb_enabled = 0;
4294     if (strstart(p, "std", &opts)) {
4295         std_vga_enabled = 1;
4296     } else if (strstart(p, "cirrus", &opts)) {
4297         cirrus_vga_enabled = 1;
4298     } else if (strstart(p, "vmware", &opts)) {
4299         vmsvga_enabled = 1;
4300     } else if (strstart(p, "xenfb", &opts)) {
4301         xenfb_enabled = 1;
4302     } else if (!strstart(p, "none", &opts)) {
4303     invalid_vga:
4304         fprintf(stderr, "Unknown vga type: %s\n", p);
4305         exit(1);
4306     }
4307     while (*opts) {
4308         const char *nextopt;
4309
4310         if (strstart(opts, ",retrace=", &nextopt)) {
4311             opts = nextopt;
4312             if (strstart(opts, "dumb", &nextopt))
4313                 vga_retrace_method = VGA_RETRACE_DUMB;
4314             else if (strstart(opts, "precise", &nextopt))
4315                 vga_retrace_method = VGA_RETRACE_PRECISE;
4316             else goto invalid_vga;
4317         } else goto invalid_vga;
4318         opts = nextopt;
4319     }
4320 }
4321
4322 #ifdef _WIN32
4323 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4324 {
4325     exit(STATUS_CONTROL_C_EXIT);
4326     return TRUE;
4327 }
4328 #endif
4329
4330 int qemu_uuid_parse(const char *str, uint8_t *uuid)
4331 {
4332     int ret;
4333
4334     if(strlen(str) != 36)
4335         return -1;
4336
4337     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4338             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4339             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4340
4341     if(ret != 16)
4342         return -1;
4343
4344 #ifdef TARGET_I386
4345     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4346 #endif
4347
4348     return 0;
4349 }
4350
4351 #define MAX_NET_CLIENTS 32
4352
4353 #ifndef _WIN32
4354
4355 static void termsig_handler(int signal)
4356 {
4357     qemu_system_shutdown_request();
4358 }
4359
4360 static void termsig_setup(void)
4361 {
4362     struct sigaction act;
4363
4364     memset(&act, 0, sizeof(act));
4365     act.sa_handler = termsig_handler;
4366     sigaction(SIGINT,  &act, NULL);
4367     sigaction(SIGHUP,  &act, NULL);
4368     sigaction(SIGTERM, &act, NULL);
4369 }
4370
4371 #endif
4372
4373 int main(int argc, char **argv, char **envp)
4374 {
4375 #ifdef CONFIG_GDBSTUB
4376     const char *gdbstub_dev = NULL;
4377 #endif
4378     uint32_t boot_devices_bitmap = 0;
4379     int i;
4380     int snapshot, linux_boot, net_boot;
4381     const char *initrd_filename;
4382     const char *kernel_filename, *kernel_cmdline;
4383     const char *boot_devices = "";
4384     DisplayState *ds;
4385     DisplayChangeListener *dcl;
4386     int cyls, heads, secs, translation;
4387     const char *net_clients[MAX_NET_CLIENTS];
4388     int nb_net_clients;
4389     const char *bt_opts[MAX_BT_CMDLINE];
4390     int nb_bt_opts;
4391     int hda_index;
4392     int optind;
4393     const char *r, *optarg;
4394     CharDriverState *monitor_hd = NULL;
4395     const char *monitor_device;
4396     const char *serial_devices[MAX_SERIAL_PORTS];
4397     int serial_device_index;
4398     const char *parallel_devices[MAX_PARALLEL_PORTS];
4399     int parallel_device_index;
4400     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4401     int virtio_console_index;
4402     const char *loadvm = NULL;
4403     QEMUMachine *machine;
4404     const char *cpu_model;
4405     const char *usb_devices[MAX_USB_CMDLINE];
4406     int usb_devices_index;
4407 #ifndef _WIN32
4408     int fds[2];
4409 #endif
4410     int tb_size;
4411     const char *pid_file = NULL;
4412     const char *incoming = NULL;
4413 #ifndef _WIN32
4414     int fd = 0;
4415     struct passwd *pwd = NULL;
4416     const char *chroot_dir = NULL;
4417     const char *run_as = NULL;
4418 #endif
4419     CPUState *env;
4420
4421     qemu_cache_utils_init(envp);
4422
4423     LIST_INIT (&vm_change_state_head);
4424 #ifndef _WIN32
4425     {
4426         struct sigaction act;
4427         sigfillset(&act.sa_mask);
4428         act.sa_flags = 0;
4429         act.sa_handler = SIG_IGN;
4430         sigaction(SIGPIPE, &act, NULL);
4431     }
4432 #else
4433     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4434     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4435        QEMU to run on a single CPU */
4436     {
4437         HANDLE h;
4438         DWORD mask, smask;
4439         int i;
4440         h = GetCurrentProcess();
4441         if (GetProcessAffinityMask(h, &mask, &smask)) {
4442             for(i = 0; i < 32; i++) {
4443                 if (mask & (1 << i))
4444                     break;
4445             }
4446             if (i != 32) {
4447                 mask = 1 << i;
4448                 SetProcessAffinityMask(h, mask);
4449             }
4450         }
4451     }
4452 #endif
4453
4454     register_machines();
4455     machine = first_machine;
4456     cpu_model = NULL;
4457     initrd_filename = NULL;
4458     ram_size = 0;
4459     vga_ram_size = VGA_RAM_SIZE;
4460     snapshot = 0;
4461     nographic = 0;
4462     curses = 0;
4463     kernel_filename = NULL;
4464     kernel_cmdline = "";
4465     cyls = heads = secs = 0;
4466     translation = BIOS_ATA_TRANSLATION_AUTO;
4467     monitor_device = "vc:80Cx24C";
4468
4469     serial_devices[0] = "vc:80Cx24C";
4470     for(i = 1; i < MAX_SERIAL_PORTS; i++)
4471         serial_devices[i] = NULL;
4472     serial_device_index = 0;
4473
4474     parallel_devices[0] = "vc:80Cx24C";
4475     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4476         parallel_devices[i] = NULL;
4477     parallel_device_index = 0;
4478
4479     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4480         virtio_consoles[i] = NULL;
4481     virtio_console_index = 0;
4482
4483     for (i = 0; i < MAX_NODES; i++) {
4484         node_mem[i] = 0;
4485         node_cpumask[i] = 0;
4486     }
4487
4488     usb_devices_index = 0;
4489
4490     nb_net_clients = 0;
4491     nb_bt_opts = 0;
4492     nb_drives = 0;
4493     nb_drives_opt = 0;
4494     nb_numa_nodes = 0;
4495     hda_index = -1;
4496
4497     nb_nics = 0;
4498
4499     tb_size = 0;
4500     autostart= 1;
4501
4502     optind = 1;
4503     for(;;) {
4504         if (optind >= argc)
4505             break;
4506         r = argv[optind];
4507         if (r[0] != '-') {
4508             hda_index = drive_add(argv[optind++], HD_ALIAS, 0);
4509         } else {
4510             const QEMUOption *popt;
4511
4512             optind++;
4513             /* Treat --foo the same as -foo.  */
4514             if (r[1] == '-')
4515                 r++;
4516             popt = qemu_options;
4517             for(;;) {
4518                 if (!popt->name) {
4519                     fprintf(stderr, "%s: invalid option -- '%s'\n",
4520                             argv[0], r);
4521                     exit(1);
4522                 }
4523                 if (!strcmp(popt->name, r + 1))
4524                     break;
4525                 popt++;
4526             }
4527             if (popt->flags & HAS_ARG) {
4528                 if (optind >= argc) {
4529                     fprintf(stderr, "%s: option '%s' requires an argument\n",
4530                             argv[0], r);
4531                     exit(1);
4532                 }
4533                 optarg = argv[optind++];
4534             } else {
4535                 optarg = NULL;
4536             }
4537
4538             switch(popt->index) {
4539             case QEMU_OPTION_M:
4540                 machine = find_machine(optarg);
4541                 if (!machine) {
4542                     QEMUMachine *m;
4543                     printf("Supported machines are:\n");
4544                     for(m = first_machine; m != NULL; m = m->next) {
4545                         printf("%-10s %s%s\n",
4546                                m->name, m->desc,
4547                                m == first_machine ? " (default)" : "");
4548                     }
4549                     exit(*optarg != '?');
4550                 }
4551                 break;
4552             case QEMU_OPTION_cpu:
4553                 /* hw initialization will check this */
4554                 if (*optarg == '?') {
4555 /* XXX: implement xxx_cpu_list for targets that still miss it */
4556 #if defined(cpu_list)
4557                     cpu_list(stdout, &fprintf);
4558 #endif
4559                     exit(0);
4560                 } else {
4561                     cpu_model = optarg;
4562                 }
4563                 break;
4564             case QEMU_OPTION_initrd:
4565                 initrd_filename = optarg;
4566                 break;
4567             case QEMU_OPTION_hda:
4568                 if (cyls == 0)
4569                     hda_index = drive_add(optarg, HD_ALIAS, 0);
4570                 else
4571                     hda_index = drive_add(optarg, HD_ALIAS
4572                              ",cyls=%d,heads=%d,secs=%d%s",
4573                              0, cyls, heads, secs,
4574                              translation == BIOS_ATA_TRANSLATION_LBA ?
4575                                  ",trans=lba" :
4576                              translation == BIOS_ATA_TRANSLATION_NONE ?
4577                                  ",trans=none" : "");
4578                  break;
4579             case QEMU_OPTION_hdb:
4580             case QEMU_OPTION_hdc:
4581             case QEMU_OPTION_hdd:
4582                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4583                 break;
4584             case QEMU_OPTION_drive:
4585                 drive_add(NULL, "%s", optarg);
4586                 break;
4587             case QEMU_OPTION_mtdblock:
4588                 drive_add(optarg, MTD_ALIAS);
4589                 break;
4590             case QEMU_OPTION_sd:
4591                 drive_add(optarg, SD_ALIAS);
4592                 break;
4593             case QEMU_OPTION_pflash:
4594                 drive_add(optarg, PFLASH_ALIAS);
4595                 break;
4596             case QEMU_OPTION_snapshot:
4597                 snapshot = 1;
4598                 break;
4599             case QEMU_OPTION_hdachs:
4600                 {
4601                     const char *p;
4602                     p = optarg;
4603                     cyls = strtol(p, (char **)&p, 0);
4604                     if (cyls < 1 || cyls > 16383)
4605                         goto chs_fail;
4606                     if (*p != ',')
4607                         goto chs_fail;
4608                     p++;
4609                     heads = strtol(p, (char **)&p, 0);
4610                     if (heads < 1 || heads > 16)
4611                         goto chs_fail;
4612                     if (*p != ',')
4613                         goto chs_fail;
4614                     p++;
4615                     secs = strtol(p, (char **)&p, 0);
4616                     if (secs < 1 || secs > 63)
4617                         goto chs_fail;
4618                     if (*p == ',') {
4619                         p++;
4620                         if (!strcmp(p, "none"))
4621                             translation = BIOS_ATA_TRANSLATION_NONE;
4622                         else if (!strcmp(p, "lba"))
4623                             translation = BIOS_ATA_TRANSLATION_LBA;
4624                         else if (!strcmp(p, "auto"))
4625                             translation = BIOS_ATA_TRANSLATION_AUTO;
4626                         else
4627                             goto chs_fail;
4628                     } else if (*p != '\0') {
4629                     chs_fail:
4630                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4631                         exit(1);
4632                     }
4633                     if (hda_index != -1)
4634                         snprintf(drives_opt[hda_index].opt,
4635                                  sizeof(drives_opt[hda_index].opt),
4636                                  HD_ALIAS ",cyls=%d,heads=%d,secs=%d%s",
4637                                  0, cyls, heads, secs,
4638                                  translation == BIOS_ATA_TRANSLATION_LBA ?
4639                                     ",trans=lba" :
4640                                  translation == BIOS_ATA_TRANSLATION_NONE ?
4641                                      ",trans=none" : "");
4642                 }
4643                 break;
4644             case QEMU_OPTION_numa:
4645                 if (nb_numa_nodes >= MAX_NODES) {
4646                     fprintf(stderr, "qemu: too many NUMA nodes\n");
4647                     exit(1);
4648                 }
4649                 numa_add(optarg);
4650                 break;
4651             case QEMU_OPTION_nographic:
4652                 nographic = 1;
4653                 break;
4654 #ifdef CONFIG_CURSES
4655             case QEMU_OPTION_curses:
4656                 curses = 1;
4657                 break;
4658 #endif
4659             case QEMU_OPTION_portrait:
4660                 graphic_rotate = 1;
4661                 break;
4662             case QEMU_OPTION_kernel:
4663                 kernel_filename = optarg;
4664                 break;
4665             case QEMU_OPTION_append:
4666                 kernel_cmdline = optarg;
4667                 break;
4668             case QEMU_OPTION_cdrom:
4669                 drive_add(optarg, CDROM_ALIAS);
4670                 break;
4671             case QEMU_OPTION_boot:
4672                 boot_devices = optarg;
4673                 /* We just do some generic consistency checks */
4674                 {
4675                     /* Could easily be extended to 64 devices if needed */
4676                     const char *p;
4677
4678                     boot_devices_bitmap = 0;
4679                     for (p = boot_devices; *p != '\0'; p++) {
4680                         /* Allowed boot devices are:
4681                          * a b     : floppy disk drives
4682                          * c ... f : IDE disk drives
4683                          * g ... m : machine implementation dependant drives
4684                          * n ... p : network devices
4685                          * It's up to each machine implementation to check
4686                          * if the given boot devices match the actual hardware
4687                          * implementation and firmware features.
4688                          */
4689                         if (*p < 'a' || *p > 'q') {
4690                             fprintf(stderr, "Invalid boot device '%c'\n", *p);
4691                             exit(1);
4692                         }
4693                         if (boot_devices_bitmap & (1 << (*p - 'a'))) {
4694                             fprintf(stderr,
4695                                     "Boot device '%c' was given twice\n",*p);
4696                             exit(1);
4697                         }
4698                         boot_devices_bitmap |= 1 << (*p - 'a');
4699                     }
4700                 }
4701                 break;
4702             case QEMU_OPTION_fda:
4703             case QEMU_OPTION_fdb:
4704                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4705                 break;
4706 #ifdef TARGET_I386
4707             case QEMU_OPTION_no_fd_bootchk:
4708                 fd_bootchk = 0;
4709                 break;
4710 #endif
4711             case QEMU_OPTION_net:
4712                 if (nb_net_clients >= MAX_NET_CLIENTS) {
4713                     fprintf(stderr, "qemu: too many network clients\n");
4714                     exit(1);
4715                 }
4716                 net_clients[nb_net_clients] = optarg;
4717                 nb_net_clients++;
4718                 break;
4719 #ifdef CONFIG_SLIRP
4720             case QEMU_OPTION_tftp:
4721                 tftp_prefix = optarg;
4722                 break;
4723             case QEMU_OPTION_bootp:
4724                 bootp_filename = optarg;
4725                 break;
4726 #ifndef _WIN32
4727             case QEMU_OPTION_smb:
4728                 net_slirp_smb(optarg);
4729                 break;
4730 #endif
4731             case QEMU_OPTION_redir:
4732                 net_slirp_redir(NULL, optarg);
4733                 break;
4734 #endif
4735             case QEMU_OPTION_bt:
4736                 if (nb_bt_opts >= MAX_BT_CMDLINE) {
4737                     fprintf(stderr, "qemu: too many bluetooth options\n");
4738                     exit(1);
4739                 }
4740                 bt_opts[nb_bt_opts++] = optarg;
4741                 break;
4742 #ifdef HAS_AUDIO
4743             case QEMU_OPTION_audio_help:
4744                 AUD_help ();
4745                 exit (0);
4746                 break;
4747             case QEMU_OPTION_soundhw:
4748                 select_soundhw (optarg);
4749                 break;
4750 #endif
4751             case QEMU_OPTION_h:
4752                 help(0);
4753                 break;
4754             case QEMU_OPTION_version:
4755                 version();
4756                 exit(0);
4757                 break;
4758             case QEMU_OPTION_m: {
4759                 uint64_t value;
4760                 char *ptr;
4761
4762                 value = strtoul(optarg, &ptr, 10);
4763                 switch (*ptr) {
4764                 case 0: case 'M': case 'm':
4765                     value <<= 20;
4766                     break;
4767                 case 'G': case 'g':
4768                     value <<= 30;
4769                     break;
4770                 default:
4771                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
4772                     exit(1);
4773                 }
4774
4775                 /* On 32-bit hosts, QEMU is limited by virtual address space */
4776                 if (value > (2047 << 20)
4777 #ifndef CONFIG_KQEMU
4778                     && HOST_LONG_BITS == 32
4779 #endif
4780                     ) {
4781                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
4782                     exit(1);
4783                 }
4784                 if (value != (uint64_t)(ram_addr_t)value) {
4785                     fprintf(stderr, "qemu: ram size too large\n");
4786                     exit(1);
4787                 }
4788                 ram_size = value;
4789                 break;
4790             }
4791             case QEMU_OPTION_d:
4792                 {
4793                     int mask;
4794                     const CPULogItem *item;
4795
4796                     mask = cpu_str_to_log_mask(optarg);
4797                     if (!mask) {
4798                         printf("Log items (comma separated):\n");
4799                     for(item = cpu_log_items; item->mask != 0; item++) {
4800                         printf("%-10s %s\n", item->name, item->help);
4801                     }
4802                     exit(1);
4803                     }
4804                     cpu_set_log(mask);
4805                 }
4806                 break;
4807 #ifdef CONFIG_GDBSTUB
4808             case QEMU_OPTION_s:
4809                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
4810                 break;
4811             case QEMU_OPTION_gdb:
4812                 gdbstub_dev = optarg;
4813                 break;
4814 #endif
4815             case QEMU_OPTION_L:
4816                 bios_dir = optarg;
4817                 break;
4818             case QEMU_OPTION_bios:
4819                 bios_name = optarg;
4820                 break;
4821             case QEMU_OPTION_singlestep:
4822                 singlestep = 1;
4823                 break;
4824             case QEMU_OPTION_S:
4825                 autostart = 0;
4826                 break;
4827 #ifndef _WIN32
4828             case QEMU_OPTION_k:
4829                 keyboard_layout = optarg;
4830                 break;
4831 #endif
4832             case QEMU_OPTION_localtime:
4833                 rtc_utc = 0;
4834                 break;
4835             case QEMU_OPTION_vga:
4836                 select_vgahw (optarg);
4837                 break;
4838 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
4839             case QEMU_OPTION_g:
4840                 {
4841                     const char *p;
4842                     int w, h, depth;
4843                     p = optarg;
4844                     w = strtol(p, (char **)&p, 10);
4845                     if (w <= 0) {
4846                     graphic_error:
4847                         fprintf(stderr, "qemu: invalid resolution or depth\n");
4848                         exit(1);
4849                     }
4850                     if (*p != 'x')
4851                         goto graphic_error;
4852                     p++;
4853                     h = strtol(p, (char **)&p, 10);
4854                     if (h <= 0)
4855                         goto graphic_error;
4856                     if (*p == 'x') {
4857                         p++;
4858                         depth = strtol(p, (char **)&p, 10);
4859                         if (depth != 8 && depth != 15 && depth != 16 &&
4860                             depth != 24 && depth != 32)
4861                             goto graphic_error;
4862                     } else if (*p == '\0') {
4863                         depth = graphic_depth;
4864                     } else {
4865                         goto graphic_error;
4866                     }
4867
4868                     graphic_width = w;
4869                     graphic_height = h;
4870                     graphic_depth = depth;
4871                 }
4872                 break;
4873 #endif
4874             case QEMU_OPTION_echr:
4875                 {
4876                     char *r;
4877                     term_escape_char = strtol(optarg, &r, 0);
4878                     if (r == optarg)
4879                         printf("Bad argument to echr\n");
4880                     break;
4881                 }
4882             case QEMU_OPTION_monitor:
4883                 monitor_device = optarg;
4884                 break;
4885             case QEMU_OPTION_serial:
4886                 if (serial_device_index >= MAX_SERIAL_PORTS) {
4887                     fprintf(stderr, "qemu: too many serial ports\n");
4888                     exit(1);
4889                 }
4890                 serial_devices[serial_device_index] = optarg;
4891                 serial_device_index++;
4892                 break;
4893             case QEMU_OPTION_virtiocon:
4894                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
4895                     fprintf(stderr, "qemu: too many virtio consoles\n");
4896                     exit(1);
4897                 }
4898                 virtio_consoles[virtio_console_index] = optarg;
4899                 virtio_console_index++;
4900                 break;
4901             case QEMU_OPTION_parallel:
4902                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
4903                     fprintf(stderr, "qemu: too many parallel ports\n");
4904                     exit(1);
4905                 }
4906                 parallel_devices[parallel_device_index] = optarg;
4907                 parallel_device_index++;
4908                 break;
4909             case QEMU_OPTION_loadvm:
4910                 loadvm = optarg;
4911                 break;
4912             case QEMU_OPTION_full_screen:
4913                 full_screen = 1;
4914                 break;
4915 #ifdef CONFIG_SDL
4916             case QEMU_OPTION_no_frame:
4917                 no_frame = 1;
4918                 break;
4919             case QEMU_OPTION_alt_grab:
4920                 alt_grab = 1;
4921                 break;
4922             case QEMU_OPTION_no_quit:
4923                 no_quit = 1;
4924                 break;
4925             case QEMU_OPTION_sdl:
4926                 sdl = 1;
4927                 break;
4928 #endif
4929             case QEMU_OPTION_pidfile:
4930                 pid_file = optarg;
4931                 break;
4932 #ifdef TARGET_I386
4933             case QEMU_OPTION_win2k_hack:
4934                 win2k_install_hack = 1;
4935                 break;
4936             case QEMU_OPTION_rtc_td_hack:
4937                 rtc_td_hack = 1;
4938                 break;
4939             case QEMU_OPTION_acpitable:
4940                 if(acpi_table_add(optarg) < 0) {
4941                     fprintf(stderr, "Wrong acpi table provided\n");
4942                     exit(1);
4943                 }
4944                 break;
4945             case QEMU_OPTION_smbios:
4946                 if(smbios_entry_add(optarg) < 0) {
4947                     fprintf(stderr, "Wrong smbios provided\n");
4948                     exit(1);
4949                 }
4950                 break;
4951 #endif
4952 #ifdef CONFIG_KQEMU
4953             case QEMU_OPTION_no_kqemu:
4954                 kqemu_allowed = 0;
4955                 break;
4956             case QEMU_OPTION_kernel_kqemu:
4957                 kqemu_allowed = 2;
4958                 break;
4959 #endif
4960 #ifdef CONFIG_KVM
4961             case QEMU_OPTION_enable_kvm:
4962                 kvm_allowed = 1;
4963 #ifdef CONFIG_KQEMU
4964                 kqemu_allowed = 0;
4965 #endif
4966                 break;
4967 #endif
4968             case QEMU_OPTION_usb:
4969                 usb_enabled = 1;
4970                 break;
4971             case QEMU_OPTION_usbdevice:
4972                 usb_enabled = 1;
4973                 if (usb_devices_index >= MAX_USB_CMDLINE) {
4974                     fprintf(stderr, "Too many USB devices\n");
4975                     exit(1);
4976                 }
4977                 usb_devices[usb_devices_index] = optarg;
4978                 usb_devices_index++;
4979                 break;
4980             case QEMU_OPTION_smp:
4981                 smp_cpus = atoi(optarg);
4982                 if (smp_cpus < 1) {
4983                     fprintf(stderr, "Invalid number of CPUs\n");
4984                     exit(1);
4985                 }
4986                 break;
4987             case QEMU_OPTION_vnc:
4988                 vnc_display = optarg;
4989                 break;
4990 #ifdef TARGET_I386
4991             case QEMU_OPTION_no_acpi:
4992                 acpi_enabled = 0;
4993                 break;
4994             case QEMU_OPTION_no_hpet:
4995                 no_hpet = 1;
4996                 break;
4997 #endif
4998             case QEMU_OPTION_no_reboot:
4999                 no_reboot = 1;
5000                 break;
5001             case QEMU_OPTION_no_shutdown:
5002                 no_shutdown = 1;
5003                 break;
5004             case QEMU_OPTION_show_cursor:
5005                 cursor_hide = 0;
5006                 break;
5007             case QEMU_OPTION_uuid:
5008                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5009                     fprintf(stderr, "Fail to parse UUID string."
5010                             " Wrong format.\n");
5011                     exit(1);
5012                 }
5013                 break;
5014 #ifndef _WIN32
5015             case QEMU_OPTION_daemonize:
5016                 daemonize = 1;
5017                 break;
5018 #endif
5019             case QEMU_OPTION_option_rom:
5020                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5021                     fprintf(stderr, "Too many option ROMs\n");
5022                     exit(1);
5023                 }
5024                 option_rom[nb_option_roms] = optarg;
5025                 nb_option_roms++;
5026                 break;
5027 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5028             case QEMU_OPTION_semihosting:
5029                 semihosting_enabled = 1;
5030                 break;
5031 #endif
5032             case QEMU_OPTION_name:
5033                 qemu_name = optarg;
5034                 break;
5035 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5036             case QEMU_OPTION_prom_env:
5037                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5038                     fprintf(stderr, "Too many prom variables\n");
5039                     exit(1);
5040                 }
5041                 prom_envs[nb_prom_envs] = optarg;
5042                 nb_prom_envs++;
5043                 break;
5044 #endif
5045 #ifdef TARGET_ARM
5046             case QEMU_OPTION_old_param:
5047                 old_param = 1;
5048                 break;
5049 #endif
5050             case QEMU_OPTION_clock:
5051                 configure_alarms(optarg);
5052                 break;
5053             case QEMU_OPTION_startdate:
5054                 {
5055                     struct tm tm;
5056                     time_t rtc_start_date;
5057                     if (!strcmp(optarg, "now")) {
5058                         rtc_date_offset = -1;
5059                     } else {
5060                         if (sscanf(optarg, "%d-%d-%dT%d:%d:%d",
5061                                &tm.tm_year,
5062                                &tm.tm_mon,
5063                                &tm.tm_mday,
5064                                &tm.tm_hour,
5065                                &tm.tm_min,
5066                                &tm.tm_sec) == 6) {
5067                             /* OK */
5068                         } else if (sscanf(optarg, "%d-%d-%d",
5069                                           &tm.tm_year,
5070                                           &tm.tm_mon,
5071                                           &tm.tm_mday) == 3) {
5072                             tm.tm_hour = 0;
5073                             tm.tm_min = 0;
5074                             tm.tm_sec = 0;
5075                         } else {
5076                             goto date_fail;
5077                         }
5078                         tm.tm_year -= 1900;
5079                         tm.tm_mon--;
5080                         rtc_start_date = mktimegm(&tm);
5081                         if (rtc_start_date == -1) {
5082                         date_fail:
5083                             fprintf(stderr, "Invalid date format. Valid format are:\n"
5084                                     "'now' or '2006-06-17T16:01:21' or '2006-06-17'\n");
5085                             exit(1);
5086                         }
5087                         rtc_date_offset = time(NULL) - rtc_start_date;
5088                     }
5089                 }
5090                 break;
5091             case QEMU_OPTION_tb_size:
5092                 tb_size = strtol(optarg, NULL, 0);
5093                 if (tb_size < 0)
5094                     tb_size = 0;
5095                 break;
5096             case QEMU_OPTION_icount:
5097                 use_icount = 1;
5098                 if (strcmp(optarg, "auto") == 0) {
5099                     icount_time_shift = -1;
5100                 } else {
5101                     icount_time_shift = strtol(optarg, NULL, 0);
5102                 }
5103                 break;
5104             case QEMU_OPTION_incoming:
5105                 incoming = optarg;
5106                 break;
5107 #ifndef _WIN32
5108             case QEMU_OPTION_chroot:
5109                 chroot_dir = optarg;
5110                 break;
5111             case QEMU_OPTION_runas:
5112                 run_as = optarg;
5113                 break;
5114 #endif
5115 #ifdef CONFIG_XEN
5116             case QEMU_OPTION_xen_domid:
5117                 xen_domid = atoi(optarg);
5118                 break;
5119             case QEMU_OPTION_xen_create:
5120                 xen_mode = XEN_CREATE;
5121                 break;
5122             case QEMU_OPTION_xen_attach:
5123                 xen_mode = XEN_ATTACH;
5124                 break;
5125 #endif
5126             }
5127         }
5128     }
5129
5130 #if defined(CONFIG_KVM) && defined(CONFIG_KQEMU)
5131     if (kvm_allowed && kqemu_allowed) {
5132         fprintf(stderr,
5133                 "You can not enable both KVM and kqemu at the same time\n");
5134         exit(1);
5135     }
5136 #endif
5137
5138     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5139     if (smp_cpus > machine->max_cpus) {
5140         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5141                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5142                 machine->max_cpus);
5143         exit(1);
5144     }
5145
5146     if (nographic) {
5147        if (serial_device_index == 0)
5148            serial_devices[0] = "stdio";
5149        if (parallel_device_index == 0)
5150            parallel_devices[0] = "null";
5151        if (strncmp(monitor_device, "vc", 2) == 0)
5152            monitor_device = "stdio";
5153     }
5154
5155 #ifndef _WIN32
5156     if (daemonize) {
5157         pid_t pid;
5158
5159         if (pipe(fds) == -1)
5160             exit(1);
5161
5162         pid = fork();
5163         if (pid > 0) {
5164             uint8_t status;
5165             ssize_t len;
5166
5167             close(fds[1]);
5168
5169         again:
5170             len = read(fds[0], &status, 1);
5171             if (len == -1 && (errno == EINTR))
5172                 goto again;
5173
5174             if (len != 1)
5175                 exit(1);
5176             else if (status == 1) {
5177                 fprintf(stderr, "Could not acquire pidfile\n");
5178                 exit(1);
5179             } else
5180                 exit(0);
5181         } else if (pid < 0)
5182             exit(1);
5183
5184         setsid();
5185
5186         pid = fork();
5187         if (pid > 0)
5188             exit(0);
5189         else if (pid < 0)
5190             exit(1);
5191
5192         umask(027);
5193
5194         signal(SIGTSTP, SIG_IGN);
5195         signal(SIGTTOU, SIG_IGN);
5196         signal(SIGTTIN, SIG_IGN);
5197     }
5198
5199     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5200         if (daemonize) {
5201             uint8_t status = 1;
5202             write(fds[1], &status, 1);
5203         } else
5204             fprintf(stderr, "Could not acquire pid file\n");
5205         exit(1);
5206     }
5207 #endif
5208
5209 #ifdef CONFIG_KQEMU
5210     if (smp_cpus > 1)
5211         kqemu_allowed = 0;
5212 #endif
5213     if (qemu_init_main_loop()) {
5214         fprintf(stderr, "qemu_init_main_loop failed\n");
5215         exit(1);
5216     }
5217     linux_boot = (kernel_filename != NULL);
5218     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5219
5220     if (!linux_boot && *kernel_cmdline != '\0') {
5221         fprintf(stderr, "-append only allowed with -kernel option\n");
5222         exit(1);
5223     }
5224
5225     if (!linux_boot && initrd_filename != NULL) {
5226         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5227         exit(1);
5228     }
5229
5230     /* boot to floppy or the default cd if no hard disk defined yet */
5231     if (!boot_devices[0]) {
5232         boot_devices = "cad";
5233     }
5234     setvbuf(stdout, NULL, _IOLBF, 0);
5235
5236     init_timers();
5237     if (init_timer_alarm() < 0) {
5238         fprintf(stderr, "could not initialize alarm timer\n");
5239         exit(1);
5240     }
5241     if (use_icount && icount_time_shift < 0) {
5242         use_icount = 2;
5243         /* 125MIPS seems a reasonable initial guess at the guest speed.
5244            It will be corrected fairly quickly anyway.  */
5245         icount_time_shift = 3;
5246         init_icount_adjust();
5247     }
5248
5249 #ifdef _WIN32
5250     socket_init();
5251 #endif
5252
5253     /* init network clients */
5254     if (nb_net_clients == 0) {
5255         /* if no clients, we use a default config */
5256         net_clients[nb_net_clients++] = "nic";
5257 #ifdef CONFIG_SLIRP
5258         net_clients[nb_net_clients++] = "user";
5259 #endif
5260     }
5261
5262     for(i = 0;i < nb_net_clients; i++) {
5263         if (net_client_parse(net_clients[i]) < 0)
5264             exit(1);
5265     }
5266     net_client_check();
5267
5268 #ifdef TARGET_I386
5269     /* XXX: this should be moved in the PC machine instantiation code */
5270     if (net_boot != 0) {
5271         int netroms = 0;
5272         for (i = 0; i < nb_nics && i < 4; i++) {
5273             const char *model = nd_table[i].model;
5274             char buf[1024];
5275             if (net_boot & (1 << i)) {
5276                 if (model == NULL)
5277                     model = "ne2k_pci";
5278                 snprintf(buf, sizeof(buf), "%s/pxe-%s.bin", bios_dir, model);
5279                 if (get_image_size(buf) > 0) {
5280                     if (nb_option_roms >= MAX_OPTION_ROMS) {
5281                         fprintf(stderr, "Too many option ROMs\n");
5282                         exit(1);
5283                     }
5284                     option_rom[nb_option_roms] = strdup(buf);
5285                     nb_option_roms++;
5286                     netroms++;
5287                 }
5288             }
5289         }
5290         if (netroms == 0) {
5291             fprintf(stderr, "No valid PXE rom found for network device\n");
5292             exit(1);
5293         }
5294     }
5295 #endif
5296
5297     /* init the bluetooth world */
5298     for (i = 0; i < nb_bt_opts; i++)
5299         if (bt_parse(bt_opts[i]))
5300             exit(1);
5301
5302     /* init the memory */
5303     if (ram_size == 0)
5304         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5305
5306 #ifdef CONFIG_KQEMU
5307     /* FIXME: This is a nasty hack because kqemu can't cope with dynamic
5308        guest ram allocation.  It needs to go away.  */
5309     if (kqemu_allowed) {
5310         kqemu_phys_ram_size = ram_size + VGA_RAM_SIZE + 4 * 1024 * 1024;
5311         kqemu_phys_ram_base = qemu_vmalloc(kqemu_phys_ram_size);
5312         if (!kqemu_phys_ram_base) {
5313             fprintf(stderr, "Could not allocate physical memory\n");
5314             exit(1);
5315         }
5316     }
5317 #endif
5318
5319     /* init the dynamic translator */
5320     cpu_exec_init_all(tb_size * 1024 * 1024);
5321
5322     bdrv_init();
5323     dma_helper_init();
5324
5325     /* we always create the cdrom drive, even if no disk is there */
5326
5327     if (nb_drives_opt < MAX_DRIVES)
5328         drive_add(NULL, CDROM_ALIAS);
5329
5330     /* we always create at least one floppy */
5331
5332     if (nb_drives_opt < MAX_DRIVES)
5333         drive_add(NULL, FD_ALIAS, 0);
5334
5335     /* we always create one sd slot, even if no card is in it */
5336
5337     if (nb_drives_opt < MAX_DRIVES)
5338         drive_add(NULL, SD_ALIAS);
5339
5340     /* open the virtual block devices */
5341
5342     for(i = 0; i < nb_drives_opt; i++)
5343         if (drive_init(&drives_opt[i], snapshot, machine) == -1)
5344             exit(1);
5345
5346     register_savevm("timer", 0, 2, timer_save, timer_load, NULL);
5347     register_savevm_live("ram", 0, 3, ram_save_live, NULL, ram_load, NULL);
5348
5349 #ifndef _WIN32
5350     /* must be after terminal init, SDL library changes signal handlers */
5351     termsig_setup();
5352 #endif
5353
5354     /* Maintain compatibility with multiple stdio monitors */
5355     if (!strcmp(monitor_device,"stdio")) {
5356         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5357             const char *devname = serial_devices[i];
5358             if (devname && !strcmp(devname,"mon:stdio")) {
5359                 monitor_device = NULL;
5360                 break;
5361             } else if (devname && !strcmp(devname,"stdio")) {
5362                 monitor_device = NULL;
5363                 serial_devices[i] = "mon:stdio";
5364                 break;
5365             }
5366         }
5367     }
5368
5369     if (nb_numa_nodes > 0) {
5370         int i;
5371
5372         if (nb_numa_nodes > smp_cpus) {
5373             nb_numa_nodes = smp_cpus;
5374         }
5375
5376         /* If no memory size if given for any node, assume the default case
5377          * and distribute the available memory equally across all nodes
5378          */
5379         for (i = 0; i < nb_numa_nodes; i++) {
5380             if (node_mem[i] != 0)
5381                 break;
5382         }
5383         if (i == nb_numa_nodes) {
5384             uint64_t usedmem = 0;
5385
5386             /* On Linux, the each node's border has to be 8MB aligned,
5387              * the final node gets the rest.
5388              */
5389             for (i = 0; i < nb_numa_nodes - 1; i++) {
5390                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5391                 usedmem += node_mem[i];
5392             }
5393             node_mem[i] = ram_size - usedmem;
5394         }
5395
5396         for (i = 0; i < nb_numa_nodes; i++) {
5397             if (node_cpumask[i] != 0)
5398                 break;
5399         }
5400         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5401          * must cope with this anyway, because there are BIOSes out there in
5402          * real machines which also use this scheme.
5403          */
5404         if (i == nb_numa_nodes) {
5405             for (i = 0; i < smp_cpus; i++) {
5406                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5407             }
5408         }
5409     }
5410
5411     if (kvm_enabled()) {
5412         int ret;
5413
5414         ret = kvm_init(smp_cpus);
5415         if (ret < 0) {
5416             fprintf(stderr, "failed to initialize KVM\n");
5417             exit(1);
5418         }
5419     }
5420
5421     if (monitor_device) {
5422         monitor_hd = qemu_chr_open("monitor", monitor_device, NULL);
5423         if (!monitor_hd) {
5424             fprintf(stderr, "qemu: could not open monitor device '%s'\n", monitor_device);
5425             exit(1);
5426         }
5427     }
5428
5429     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5430         const char *devname = serial_devices[i];
5431         if (devname && strcmp(devname, "none")) {
5432             char label[32];
5433             snprintf(label, sizeof(label), "serial%d", i);
5434             serial_hds[i] = qemu_chr_open(label, devname, NULL);
5435             if (!serial_hds[i]) {
5436                 fprintf(stderr, "qemu: could not open serial device '%s'\n",
5437                         devname);
5438                 exit(1);
5439             }
5440         }
5441     }
5442
5443     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5444         const char *devname = parallel_devices[i];
5445         if (devname && strcmp(devname, "none")) {
5446             char label[32];
5447             snprintf(label, sizeof(label), "parallel%d", i);
5448             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5449             if (!parallel_hds[i]) {
5450                 fprintf(stderr, "qemu: could not open parallel device '%s'\n",
5451                         devname);
5452                 exit(1);
5453             }
5454         }
5455     }
5456
5457     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5458         const char *devname = virtio_consoles[i];
5459         if (devname && strcmp(devname, "none")) {
5460             char label[32];
5461             snprintf(label, sizeof(label), "virtcon%d", i);
5462             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5463             if (!virtcon_hds[i]) {
5464                 fprintf(stderr, "qemu: could not open virtio console '%s'\n",
5465                         devname);
5466                 exit(1);
5467             }
5468         }
5469     }
5470
5471     machine->init(ram_size, vga_ram_size, boot_devices,
5472                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5473
5474
5475     for (env = first_cpu; env != NULL; env = env->next_cpu) {
5476         for (i = 0; i < nb_numa_nodes; i++) {
5477             if (node_cpumask[i] & (1 << env->cpu_index)) {
5478                 env->numa_node = i;
5479             }
5480         }
5481     }
5482
5483     current_machine = machine;
5484
5485     /* Set KVM's vcpu state to qemu's initial CPUState. */
5486     if (kvm_enabled()) {
5487         int ret;
5488
5489         ret = kvm_sync_vcpus();
5490         if (ret < 0) {
5491             fprintf(stderr, "failed to initialize vcpus\n");
5492             exit(1);
5493         }
5494     }
5495
5496     /* init USB devices */
5497     if (usb_enabled) {
5498         for(i = 0; i < usb_devices_index; i++) {
5499             if (usb_device_add(usb_devices[i], 0) < 0) {
5500                 fprintf(stderr, "Warning: could not add USB device %s\n",
5501                         usb_devices[i]);
5502             }
5503         }
5504     }
5505
5506     if (!display_state)
5507         dumb_display_init();
5508     /* just use the first displaystate for the moment */
5509     ds = display_state;
5510     /* terminal init */
5511     if (nographic) {
5512         if (curses) {
5513             fprintf(stderr, "fatal: -nographic can't be used with -curses\n");
5514             exit(1);
5515         }
5516     } else {
5517 #if defined(CONFIG_CURSES)
5518             if (curses) {
5519                 /* At the moment curses cannot be used with other displays */
5520                 curses_display_init(ds, full_screen);
5521             } else
5522 #endif
5523             {
5524                 if (vnc_display != NULL) {
5525                     vnc_display_init(ds);
5526                     if (vnc_display_open(ds, vnc_display) < 0)
5527                         exit(1);
5528                 }
5529 #if defined(CONFIG_SDL)
5530                 if (sdl || !vnc_display)
5531                     sdl_display_init(ds, full_screen, no_frame);
5532 #elif defined(CONFIG_COCOA)
5533                 if (sdl || !vnc_display)
5534                     cocoa_display_init(ds, full_screen);
5535 #endif
5536             }
5537     }
5538     dpy_resize(ds);
5539
5540     dcl = ds->listeners;
5541     while (dcl != NULL) {
5542         if (dcl->dpy_refresh != NULL) {
5543             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5544             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5545         }
5546         dcl = dcl->next;
5547     }
5548
5549     if (nographic || (vnc_display && !sdl)) {
5550         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5551         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5552     }
5553
5554     text_consoles_set_display(display_state);
5555     qemu_chr_initial_reset();
5556
5557     if (monitor_device && monitor_hd)
5558         monitor_init(monitor_hd, MONITOR_USE_READLINE | MONITOR_IS_DEFAULT);
5559
5560     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5561         const char *devname = serial_devices[i];
5562         if (devname && strcmp(devname, "none")) {
5563             char label[32];
5564             snprintf(label, sizeof(label), "serial%d", i);
5565             if (strstart(devname, "vc", 0))
5566                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5567         }
5568     }
5569
5570     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5571         const char *devname = parallel_devices[i];
5572         if (devname && strcmp(devname, "none")) {
5573             char label[32];
5574             snprintf(label, sizeof(label), "parallel%d", i);
5575             if (strstart(devname, "vc", 0))
5576                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5577         }
5578     }
5579
5580     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5581         const char *devname = virtio_consoles[i];
5582         if (virtcon_hds[i] && devname) {
5583             char label[32];
5584             snprintf(label, sizeof(label), "virtcon%d", i);
5585             if (strstart(devname, "vc", 0))
5586                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5587         }
5588     }
5589
5590 #ifdef CONFIG_GDBSTUB
5591     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5592         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5593                 gdbstub_dev);
5594         exit(1);
5595     }
5596 #endif
5597
5598     if (loadvm)
5599         do_loadvm(cur_mon, loadvm);
5600
5601     if (incoming) {
5602         autostart = 0; /* fixme how to deal with -daemonize */
5603         qemu_start_incoming_migration(incoming);
5604     }
5605
5606     if (autostart)
5607         vm_start();
5608
5609 #ifndef _WIN32
5610     if (daemonize) {
5611         uint8_t status = 0;
5612         ssize_t len;
5613
5614     again1:
5615         len = write(fds[1], &status, 1);
5616         if (len == -1 && (errno == EINTR))
5617             goto again1;
5618
5619         if (len != 1)
5620             exit(1);
5621
5622         chdir("/");
5623         TFR(fd = open("/dev/null", O_RDWR));
5624         if (fd == -1)
5625             exit(1);
5626     }
5627
5628     if (run_as) {
5629         pwd = getpwnam(run_as);
5630         if (!pwd) {
5631             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5632             exit(1);
5633         }
5634     }
5635
5636     if (chroot_dir) {
5637         if (chroot(chroot_dir) < 0) {
5638             fprintf(stderr, "chroot failed\n");
5639             exit(1);
5640         }
5641         chdir("/");
5642     }
5643
5644     if (run_as) {
5645         if (setgid(pwd->pw_gid) < 0) {
5646             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5647             exit(1);
5648         }
5649         if (setuid(pwd->pw_uid) < 0) {
5650             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5651             exit(1);
5652         }
5653         if (setuid(0) != -1) {
5654             fprintf(stderr, "Dropping privileges failed\n");
5655             exit(1);
5656         }
5657     }
5658
5659     if (daemonize) {
5660         dup2(fd, 0);
5661         dup2(fd, 1);
5662         dup2(fd, 2);
5663
5664         close(fd);
5665     }
5666 #endif
5667
5668     main_loop();
5669     quit_timers();
5670     net_cleanup();
5671
5672     return 0;
5673 }