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