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