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

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