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

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