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 (!vm_running)
3880             break;
3881         if (timer_alarm_pending) {
3882             timer_alarm_pending = 0;
3883             break;
3884         }
3885         if (cpu_can_run(env))
3886             ret = qemu_cpu_exec(env);
3887         if (ret == EXCP_DEBUG) {
3888             gdb_set_stop_cpu(env);
3889             debug_requested = 1;
3890             break;
3891         }
3892     }
3893 }
3894
3895 static int cpu_has_work(CPUState *env)
3896 {
3897     if (env->stop)
3898         return 1;
3899     if (env->stopped)
3900         return 0;
3901     if (!env->halted)
3902         return 1;
3903     if (qemu_cpu_has_work(env))
3904         return 1;
3905     return 0;
3906 }
3907
3908 static int tcg_has_work(void)
3909 {
3910     CPUState *env;
3911
3912     for (env = first_cpu; env != NULL; env = env->next_cpu)
3913         if (cpu_has_work(env))
3914             return 1;
3915     return 0;
3916 }
3917
3918 static int qemu_calculate_timeout(void)
3919 {
3920 #ifndef CONFIG_IOTHREAD
3921     int timeout;
3922
3923     if (!vm_running)
3924         timeout = 5000;
3925     else if (tcg_has_work())
3926         timeout = 0;
3927     else if (!use_icount)
3928         timeout = 5000;
3929     else {
3930      /* XXX: use timeout computed from timers */
3931         int64_t add;
3932         int64_t delta;
3933         /* Advance virtual time to the next event.  */
3934         if (use_icount == 1) {
3935             /* When not using an adaptive execution frequency
3936                we tend to get badly out of sync with real time,
3937                so just delay for a reasonable amount of time.  */
3938             delta = 0;
3939         } else {
3940             delta = cpu_get_icount() - cpu_get_clock();
3941         }
3942         if (delta > 0) {
3943             /* If virtual time is ahead of real time then just
3944                wait for IO.  */
3945             timeout = (delta / 1000000) + 1;
3946         } else {
3947             /* Wait for either IO to occur or the next
3948                timer event.  */
3949             add = qemu_next_deadline();
3950             /* We advance the timer before checking for IO.
3951                Limit the amount we advance so that early IO
3952                activity won't get the guest too far ahead.  */
3953             if (add > 10000000)
3954                 add = 10000000;
3955             delta += add;
3956             add = (add + (1 << icount_time_shift) - 1)
3957                   >> icount_time_shift;
3958             qemu_icount += add;
3959             timeout = delta / 1000000;
3960             if (timeout < 0)
3961                 timeout = 0;
3962         }
3963     }
3964
3965     return timeout;
3966 #else /* CONFIG_IOTHREAD */
3967     return 1000;
3968 #endif
3969 }
3970
3971 static int vm_can_run(void)
3972 {
3973     if (powerdown_requested)
3974         return 0;
3975     if (reset_requested)
3976         return 0;
3977     if (shutdown_requested)
3978         return 0;
3979     if (debug_requested)
3980         return 0;
3981     return 1;
3982 }
3983
3984 qemu_irq qemu_system_powerdown;
3985
3986 static void main_loop(void)
3987 {
3988     int r;
3989
3990 #ifdef CONFIG_IOTHREAD
3991     qemu_system_ready = 1;
3992     qemu_cond_broadcast(&qemu_system_cond);
3993 #endif
3994
3995     for (;;) {
3996         do {
3997 #ifdef CONFIG_PROFILER
3998             int64_t ti;
3999 #endif
4000 #ifndef CONFIG_IOTHREAD
4001             tcg_cpu_exec();
4002 #endif
4003 #ifdef CONFIG_PROFILER
4004             ti = profile_getclock();
4005 #endif
4006             main_loop_wait(qemu_calculate_timeout());
4007 #ifdef CONFIG_PROFILER
4008             dev_time += profile_getclock() - ti;
4009 #endif
4010         } while (vm_can_run());
4011
4012         if (qemu_debug_requested()) {
4013             monitor_protocol_event(QEVENT_DEBUG, NULL);
4014             vm_stop(EXCP_DEBUG);
4015         }
4016         if (qemu_shutdown_requested()) {
4017             monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
4018             if (no_shutdown) {
4019                 vm_stop(0);
4020                 no_shutdown = 0;
4021             } else
4022                 break;
4023         }
4024         if (qemu_reset_requested()) {
4025             monitor_protocol_event(QEVENT_RESET, NULL);
4026             pause_all_vcpus();
4027             qemu_system_reset();
4028             resume_all_vcpus();
4029         }
4030         if (qemu_powerdown_requested()) {
4031             monitor_protocol_event(QEVENT_POWERDOWN, NULL);
4032             qemu_irq_raise(qemu_system_powerdown);
4033         }
4034         if ((r = qemu_vmstop_requested())) {
4035             monitor_protocol_event(QEVENT_STOP, NULL);
4036             vm_stop(r);
4037         }
4038     }
4039     pause_all_vcpus();
4040 }
4041
4042 static void version(void)
4043 {
4044     printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4045 }
4046
4047 static void help(int exitcode)
4048 {
4049     const char *options_help =
4050 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4051            opt_help
4052 #define DEFHEADING(text) stringify(text) "\n"
4053 #include "qemu-options.h"
4054 #undef DEF
4055 #undef DEFHEADING
4056 #undef GEN_DOCS
4057         ;
4058     version();
4059     printf("usage: %s [options] [disk_image]\n"
4060            "\n"
4061            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4062            "\n"
4063            "%s\n"
4064            "During emulation, the following keys are useful:\n"
4065            "ctrl-alt-f      toggle full screen\n"
4066            "ctrl-alt-n      switch to virtual console 'n'\n"
4067            "ctrl-alt        toggle mouse and keyboard grab\n"
4068            "\n"
4069            "When using -nographic, press 'ctrl-a h' to get some help.\n",
4070            "qemu",
4071            options_help);
4072     exit(exitcode);
4073 }
4074
4075 #define HAS_ARG 0x0001
4076
4077 enum {
4078 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4079     opt_enum,
4080 #define DEFHEADING(text)
4081 #include "qemu-options.h"
4082 #undef DEF
4083 #undef DEFHEADING
4084 #undef GEN_DOCS
4085 };
4086
4087 typedef struct QEMUOption {
4088     const char *name;
4089     int flags;
4090     int index;
4091 } QEMUOption;
4092
4093 static const QEMUOption qemu_options[] = {
4094     { "h", 0, QEMU_OPTION_h },
4095 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4096     { option, opt_arg, opt_enum },
4097 #define DEFHEADING(text)
4098 #include "qemu-options.h"
4099 #undef DEF
4100 #undef DEFHEADING
4101 #undef GEN_DOCS
4102     { NULL },
4103 };
4104
4105 #ifdef HAS_AUDIO
4106 struct soundhw soundhw[] = {
4107 #ifdef HAS_AUDIO_CHOICE
4108 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4109     {
4110         "pcspk",
4111         "PC speaker",
4112         0,
4113         1,
4114         { .init_isa = pcspk_audio_init }
4115     },
4116 #endif
4117
4118 #ifdef CONFIG_SB16
4119     {
4120         "sb16",
4121         "Creative Sound Blaster 16",
4122         0,
4123         1,
4124         { .init_isa = SB16_init }
4125     },
4126 #endif
4127
4128 #ifdef CONFIG_CS4231A
4129     {
4130         "cs4231a",
4131         "CS4231A",
4132         0,
4133         1,
4134         { .init_isa = cs4231a_init }
4135     },
4136 #endif
4137
4138 #ifdef CONFIG_ADLIB
4139     {
4140         "adlib",
4141 #ifdef HAS_YMF262
4142         "Yamaha YMF262 (OPL3)",
4143 #else
4144         "Yamaha YM3812 (OPL2)",
4145 #endif
4146         0,
4147         1,
4148         { .init_isa = Adlib_init }
4149     },
4150 #endif
4151
4152 #ifdef CONFIG_GUS
4153     {
4154         "gus",
4155         "Gravis Ultrasound GF1",
4156         0,
4157         1,
4158         { .init_isa = GUS_init }
4159     },
4160 #endif
4161
4162 #ifdef CONFIG_AC97
4163     {
4164         "ac97",
4165         "Intel 82801AA AC97 Audio",
4166         0,
4167         0,
4168         { .init_pci = ac97_init }
4169     },
4170 #endif
4171
4172 #ifdef CONFIG_ES1370
4173     {
4174         "es1370",
4175         "ENSONIQ AudioPCI ES1370",
4176         0,
4177         0,
4178         { .init_pci = es1370_init }
4179     },
4180 #endif
4181
4182 #endif /* HAS_AUDIO_CHOICE */
4183
4184     { NULL, NULL, 0, 0, { NULL } }
4185 };
4186
4187 static void select_soundhw (const char *optarg)
4188 {
4189     struct soundhw *c;
4190
4191     if (*optarg == '?') {
4192     show_valid_cards:
4193
4194         printf ("Valid sound card names (comma separated):\n");
4195         for (c = soundhw; c->name; ++c) {
4196             printf ("%-11s %s\n", c->name, c->descr);
4197         }
4198         printf ("\n-soundhw all will enable all of the above\n");
4199         exit (*optarg != '?');
4200     }
4201     else {
4202         size_t l;
4203         const char *p;
4204         char *e;
4205         int bad_card = 0;
4206
4207         if (!strcmp (optarg, "all")) {
4208             for (c = soundhw; c->name; ++c) {
4209                 c->enabled = 1;
4210             }
4211             return;
4212         }
4213
4214         p = optarg;
4215         while (*p) {
4216             e = strchr (p, ',');
4217             l = !e ? strlen (p) : (size_t) (e - p);
4218
4219             for (c = soundhw; c->name; ++c) {
4220                 if (!strncmp (c->name, p, l) && !c->name[l]) {
4221                     c->enabled = 1;
4222                     break;
4223                 }
4224             }
4225
4226             if (!c->name) {
4227                 if (l > 80) {
4228                     fprintf (stderr,
4229                              "Unknown sound card name (too big to show)\n");
4230                 }
4231                 else {
4232                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4233                              (int) l, p);
4234                 }
4235                 bad_card = 1;
4236             }
4237             p += l + (e != NULL);
4238         }
4239
4240         if (bad_card)
4241             goto show_valid_cards;
4242     }
4243 }
4244 #endif
4245
4246 static void select_vgahw (const char *p)
4247 {
4248     const char *opts;
4249
4250     default_vga = 0;
4251     vga_interface_type = VGA_NONE;
4252     if (strstart(p, "std", &opts)) {
4253         vga_interface_type = VGA_STD;
4254     } else if (strstart(p, "cirrus", &opts)) {
4255         vga_interface_type = VGA_CIRRUS;
4256     } else if (strstart(p, "vmware", &opts)) {
4257         vga_interface_type = VGA_VMWARE;
4258     } else if (strstart(p, "xenfb", &opts)) {
4259         vga_interface_type = VGA_XENFB;
4260     } else if (!strstart(p, "none", &opts)) {
4261     invalid_vga:
4262         fprintf(stderr, "Unknown vga type: %s\n", p);
4263         exit(1);
4264     }
4265     while (*opts) {
4266         const char *nextopt;
4267
4268         if (strstart(opts, ",retrace=", &nextopt)) {
4269             opts = nextopt;
4270             if (strstart(opts, "dumb", &nextopt))
4271                 vga_retrace_method = VGA_RETRACE_DUMB;
4272             else if (strstart(opts, "precise", &nextopt))
4273                 vga_retrace_method = VGA_RETRACE_PRECISE;
4274             else goto invalid_vga;
4275         } else goto invalid_vga;
4276         opts = nextopt;
4277     }
4278 }
4279
4280 #ifdef TARGET_I386
4281 static int balloon_parse(const char *arg)
4282 {
4283     QemuOpts *opts;
4284
4285     if (strcmp(arg, "none") == 0) {
4286         return 0;
4287     }
4288
4289     if (!strncmp(arg, "virtio", 6)) {
4290         if (arg[6] == ',') {
4291             /* have params -> parse them */
4292             opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
4293             if (!opts)
4294                 return  -1;
4295         } else {
4296             /* create empty opts */
4297             opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4298         }
4299         qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4300         return 0;
4301     }
4302
4303     return -1;
4304 }
4305 #endif
4306
4307 #ifdef _WIN32
4308 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4309 {
4310     exit(STATUS_CONTROL_C_EXIT);
4311     return TRUE;
4312 }
4313 #endif
4314
4315 int qemu_uuid_parse(const char *str, uint8_t *uuid)
4316 {
4317     int ret;
4318
4319     if(strlen(str) != 36)
4320         return -1;
4321
4322     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4323             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4324             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4325
4326     if(ret != 16)
4327         return -1;
4328
4329 #ifdef TARGET_I386
4330     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4331 #endif
4332
4333     return 0;
4334 }
4335
4336 #ifndef _WIN32
4337
4338 static void termsig_handler(int signal)
4339 {
4340     qemu_system_shutdown_request();
4341 }
4342
4343 static void sigchld_handler(int signal)
4344 {
4345     waitpid(-1, NULL, WNOHANG);
4346 }
4347
4348 static void sighandler_setup(void)
4349 {
4350     struct sigaction act;
4351
4352     memset(&act, 0, sizeof(act));
4353     act.sa_handler = termsig_handler;
4354     sigaction(SIGINT,  &act, NULL);
4355     sigaction(SIGHUP,  &act, NULL);
4356     sigaction(SIGTERM, &act, NULL);
4357
4358     act.sa_handler = sigchld_handler;
4359     act.sa_flags = SA_NOCLDSTOP;
4360     sigaction(SIGCHLD, &act, NULL);
4361 }
4362
4363 #endif
4364
4365 #ifdef _WIN32
4366 /* Look for support files in the same directory as the executable.  */
4367 static char *find_datadir(const char *argv0)
4368 {
4369     char *p;
4370     char buf[MAX_PATH];
4371     DWORD len;
4372
4373     len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4374     if (len == 0) {
4375         return NULL;
4376     }
4377
4378     buf[len] = 0;
4379     p = buf + len - 1;
4380     while (p != buf && *p != '\\')
4381         p--;
4382     *p = 0;
4383     if (access(buf, R_OK) == 0) {
4384         return qemu_strdup(buf);
4385     }
4386     return NULL;
4387 }
4388 #else /* !_WIN32 */
4389
4390 /* Find a likely location for support files using the location of the binary.
4391    For installed binaries this will be "$bindir/../share/qemu".  When
4392    running from the build tree this will be "$bindir/../pc-bios".  */
4393 #define SHARE_SUFFIX "/share/qemu"
4394 #define BUILD_SUFFIX "/pc-bios"
4395 static char *find_datadir(const char *argv0)
4396 {
4397     char *dir;
4398     char *p = NULL;
4399     char *res;
4400     char buf[PATH_MAX];
4401     size_t max_len;
4402
4403 #if defined(__linux__)
4404     {
4405         int len;
4406         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4407         if (len > 0) {
4408             buf[len] = 0;
4409             p = buf;
4410         }
4411     }
4412 #elif defined(__FreeBSD__)
4413     {
4414         int len;
4415         len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4416         if (len > 0) {
4417             buf[len] = 0;
4418             p = buf;
4419         }
4420     }
4421 #endif
4422     /* If we don't have any way of figuring out the actual executable
4423        location then try argv[0].  */
4424     if (!p) {
4425         p = realpath(argv0, buf);
4426         if (!p) {
4427             return NULL;
4428         }
4429     }
4430     dir = dirname(p);
4431     dir = dirname(dir);
4432
4433     max_len = strlen(dir) +
4434         MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4435     res = qemu_mallocz(max_len);
4436     snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4437     if (access(res, R_OK)) {
4438         snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4439         if (access(res, R_OK)) {
4440             qemu_free(res);
4441             res = NULL;
4442         }
4443     }
4444
4445     return res;
4446 }
4447 #undef SHARE_SUFFIX
4448 #undef BUILD_SUFFIX
4449 #endif
4450
4451 char *qemu_find_file(int type, const char *name)
4452 {
4453     int len;
4454     const char *subdir;
4455     char *buf;
4456
4457     /* If name contains path separators then try it as a straight path.  */
4458     if ((strchr(name, '/') || strchr(name, '\\'))
4459         && access(name, R_OK) == 0) {
4460         return qemu_strdup(name);
4461     }
4462     switch (type) {
4463     case QEMU_FILE_TYPE_BIOS:
4464         subdir = "";
4465         break;
4466     case QEMU_FILE_TYPE_KEYMAP:
4467         subdir = "keymaps/";
4468         break;
4469     default:
4470         abort();
4471     }
4472     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4473     buf = qemu_mallocz(len);
4474     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4475     if (access(buf, R_OK)) {
4476         qemu_free(buf);
4477         return NULL;
4478     }
4479     return buf;
4480 }
4481
4482 static int device_help_func(QemuOpts *opts, void *opaque)
4483 {
4484     return qdev_device_help(opts);
4485 }
4486
4487 static int device_init_func(QemuOpts *opts, void *opaque)
4488 {
4489     DeviceState *dev;
4490
4491     dev = qdev_device_add(opts);
4492     if (!dev)
4493         return -1;
4494     return 0;
4495 }
4496
4497 static int chardev_init_func(QemuOpts *opts, void *opaque)
4498 {
4499     CharDriverState *chr;
4500
4501     chr = qemu_chr_open_opts(opts, NULL);
4502     if (!chr)
4503         return -1;
4504     return 0;
4505 }
4506
4507 static int mon_init_func(QemuOpts *opts, void *opaque)
4508 {
4509     CharDriverState *chr;
4510     const char *chardev;
4511     const char *mode;
4512     int flags;
4513
4514     mode = qemu_opt_get(opts, "mode");
4515     if (mode == NULL) {
4516         mode = "readline";
4517     }
4518     if (strcmp(mode, "readline") == 0) {
4519         flags = MONITOR_USE_READLINE;
4520     } else if (strcmp(mode, "control") == 0) {
4521         flags = MONITOR_USE_CONTROL;
4522     } else {
4523         fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
4524         exit(1);
4525     }
4526
4527     if (qemu_opt_get_bool(opts, "default", 0))
4528         flags |= MONITOR_IS_DEFAULT;
4529
4530     chardev = qemu_opt_get(opts, "chardev");
4531     chr = qemu_chr_find(chardev);
4532     if (chr == NULL) {
4533         fprintf(stderr, "chardev \"%s\" not found\n", chardev);
4534         exit(1);
4535     }
4536
4537     monitor_init(chr, flags);
4538     return 0;
4539 }
4540
4541 static void monitor_parse(const char *optarg, const char *mode)
4542 {
4543     static int monitor_device_index = 0;
4544     QemuOpts *opts;
4545     const char *p;
4546     char label[32];
4547     int def = 0;
4548
4549     if (strstart(optarg, "chardev:", &p)) {
4550         snprintf(label, sizeof(label), "%s", p);
4551     } else {
4552         if (monitor_device_index) {
4553             snprintf(label, sizeof(label), "monitor%d",
4554                      monitor_device_index);
4555         } else {
4556             snprintf(label, sizeof(label), "monitor");
4557             def = 1;
4558         }
4559         opts = qemu_chr_parse_compat(label, optarg);
4560         if (!opts) {
4561             fprintf(stderr, "parse error: %s\n", optarg);
4562             exit(1);
4563         }
4564     }
4565
4566     opts = qemu_opts_create(&qemu_mon_opts, label, 1);
4567     if (!opts) {
4568         fprintf(stderr, "duplicate chardev: %s\n", label);
4569         exit(1);
4570     }
4571     qemu_opt_set(opts, "mode", mode);
4572     qemu_opt_set(opts, "chardev", label);
4573     if (def)
4574         qemu_opt_set(opts, "default", "on");
4575     monitor_device_index++;
4576 }
4577
4578 struct device_config {
4579     enum {
4580         DEV_USB,       /* -usbdevice     */
4581         DEV_BT,        /* -bt            */
4582         DEV_SERIAL,    /* -serial        */
4583         DEV_PARALLEL,  /* -parallel      */
4584         DEV_VIRTCON,   /* -virtioconsole */
4585         DEV_DEBUGCON,  /* -debugcon */
4586     } type;
4587     const char *cmdline;
4588     QTAILQ_ENTRY(device_config) next;
4589 };
4590 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4591
4592 static void add_device_config(int type, const char *cmdline)
4593 {
4594     struct device_config *conf;
4595
4596     conf = qemu_mallocz(sizeof(*conf));
4597     conf->type = type;
4598     conf->cmdline = cmdline;
4599     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4600 }
4601
4602 static int foreach_device_config(int type, int (*func)(const char *cmdline))
4603 {
4604     struct device_config *conf;
4605     int rc;
4606
4607     QTAILQ_FOREACH(conf, &device_configs, next) {
4608         if (conf->type != type)
4609             continue;
4610         rc = func(conf->cmdline);
4611         if (0 != rc)
4612             return rc;
4613     }
4614     return 0;
4615 }
4616
4617 static int serial_parse(const char *devname)
4618 {
4619     static int index = 0;
4620     char label[32];
4621
4622     if (strcmp(devname, "none") == 0)
4623         return 0;
4624     if (index == MAX_SERIAL_PORTS) {
4625         fprintf(stderr, "qemu: too many serial ports\n");
4626         exit(1);
4627     }
4628     snprintf(label, sizeof(label), "serial%d", index);
4629     serial_hds[index] = qemu_chr_open(label, devname, NULL);
4630     if (!serial_hds[index]) {
4631         fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
4632                 devname, strerror(errno));
4633         return -1;
4634     }
4635     index++;
4636     return 0;
4637 }
4638
4639 static int parallel_parse(const char *devname)
4640 {
4641     static int index = 0;
4642     char label[32];
4643
4644     if (strcmp(devname, "none") == 0)
4645         return 0;
4646     if (index == MAX_PARALLEL_PORTS) {
4647         fprintf(stderr, "qemu: too many parallel ports\n");
4648         exit(1);
4649     }
4650     snprintf(label, sizeof(label), "parallel%d", index);
4651     parallel_hds[index] = qemu_chr_open(label, devname, NULL);
4652     if (!parallel_hds[index]) {
4653         fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
4654                 devname, strerror(errno));
4655         return -1;
4656     }
4657     index++;
4658     return 0;
4659 }
4660
4661 static int virtcon_parse(const char *devname)
4662 {
4663     static int index = 0;
4664     char label[32];
4665     QemuOpts *bus_opts, *dev_opts;
4666
4667     if (strcmp(devname, "none") == 0)
4668         return 0;
4669     if (index == MAX_VIRTIO_CONSOLES) {
4670         fprintf(stderr, "qemu: too many virtio consoles\n");
4671         exit(1);
4672     }
4673
4674     bus_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4675     qemu_opt_set(bus_opts, "driver", "virtio-serial");
4676
4677     dev_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4678     qemu_opt_set(dev_opts, "driver", "virtconsole");
4679
4680     snprintf(label, sizeof(label), "virtcon%d", index);
4681     virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
4682     if (!virtcon_hds[index]) {
4683         fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
4684                 devname, strerror(errno));
4685         return -1;
4686     }
4687     qemu_opt_set(dev_opts, "chardev", label);
4688
4689     index++;
4690     return 0;
4691 }
4692
4693 static int debugcon_parse(const char *devname)
4694 {
4695     QemuOpts *opts;
4696
4697     if (!qemu_chr_open("debugcon", devname, NULL)) {
4698         exit(1);
4699     }
4700     opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
4701     if (!opts) {
4702         fprintf(stderr, "qemu: already have a debugcon device\n");
4703         exit(1);
4704     }
4705     qemu_opt_set(opts, "driver", "isa-debugcon");
4706     qemu_opt_set(opts, "chardev", "debugcon");
4707     return 0;
4708 }
4709
4710 static const QEMUOption *lookup_opt(int argc, char **argv,
4711                                     const char **poptarg, int *poptind)
4712 {
4713     const QEMUOption *popt;
4714     int optind = *poptind;
4715     char *r = argv[optind];
4716     const char *optarg;
4717
4718     optind++;
4719     /* Treat --foo the same as -foo.  */
4720     if (r[1] == '-')
4721         r++;
4722     popt = qemu_options;
4723     for(;;) {
4724         if (!popt->name) {
4725             fprintf(stderr, "%s: invalid option -- '%s'\n",
4726                     argv[0], r);
4727             exit(1);
4728         }
4729         if (!strcmp(popt->name, r + 1))
4730             break;
4731         popt++;
4732     }
4733     if (popt->flags & HAS_ARG) {
4734         if (optind >= argc) {
4735             fprintf(stderr, "%s: option '%s' requires an argument\n",
4736                     argv[0], r);
4737             exit(1);
4738         }
4739         optarg = argv[optind++];
4740     } else {
4741         optarg = NULL;
4742     }
4743
4744     *poptarg = optarg;
4745     *poptind = optind;
4746
4747     return popt;
4748 }
4749
4750 int main(int argc, char **argv, char **envp)
4751 {
4752     const char *gdbstub_dev = NULL;
4753     uint32_t boot_devices_bitmap = 0;
4754     int i;
4755     int snapshot, linux_boot, net_boot;
4756     const char *initrd_filename;
4757     const char *kernel_filename, *kernel_cmdline;
4758     char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4759     DisplayState *ds;
4760     DisplayChangeListener *dcl;
4761     int cyls, heads, secs, translation;
4762     QemuOpts *hda_opts = NULL, *opts;
4763     int optind;
4764     const char *optarg;
4765     const char *loadvm = NULL;
4766     QEMUMachine *machine;
4767     const char *cpu_model;
4768 #ifndef _WIN32
4769     int fds[2];
4770 #endif
4771     int tb_size;
4772     const char *pid_file = NULL;
4773     const char *incoming = NULL;
4774 #ifndef _WIN32
4775     int fd = 0;
4776     struct passwd *pwd = NULL;
4777     const char *chroot_dir = NULL;
4778     const char *run_as = NULL;
4779 #endif
4780     CPUState *env;
4781     int show_vnc_port = 0;
4782     int defconfig = 1;
4783
4784     init_clocks();
4785
4786     qemu_errors_to_file(stderr);
4787     qemu_cache_utils_init(envp);
4788
4789     QLIST_INIT (&vm_change_state_head);
4790 #ifndef _WIN32
4791     {
4792         struct sigaction act;
4793         sigfillset(&act.sa_mask);
4794         act.sa_flags = 0;
4795         act.sa_handler = SIG_IGN;
4796         sigaction(SIGPIPE, &act, NULL);
4797     }
4798 #else
4799     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4800     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4801        QEMU to run on a single CPU */
4802     {
4803         HANDLE h;
4804         DWORD mask, smask;
4805         int i;
4806         h = GetCurrentProcess();
4807         if (GetProcessAffinityMask(h, &mask, &smask)) {
4808             for(i = 0; i < 32; i++) {
4809                 if (mask & (1 << i))
4810                     break;
4811             }
4812             if (i != 32) {
4813                 mask = 1 << i;
4814                 SetProcessAffinityMask(h, mask);
4815             }
4816         }
4817     }
4818 #endif
4819
4820     module_call_init(MODULE_INIT_MACHINE);
4821     machine = find_default_machine();
4822     cpu_model = NULL;
4823     initrd_filename = NULL;
4824     ram_size = 0;
4825     snapshot = 0;
4826     kernel_filename = NULL;
4827     kernel_cmdline = "";
4828     cyls = heads = secs = 0;
4829     translation = BIOS_ATA_TRANSLATION_AUTO;
4830
4831     for (i = 0; i < MAX_NODES; i++) {
4832         node_mem[i] = 0;
4833         node_cpumask[i] = 0;
4834     }
4835
4836     nb_numa_nodes = 0;
4837     nb_nics = 0;
4838
4839     tb_size = 0;
4840     autostart= 1;
4841
4842     /* first pass of option parsing */
4843     optind = 1;
4844     while (optind < argc) {
4845         if (argv[optind][0] != '-') {
4846             /* disk image */
4847             optind++;
4848             continue;
4849         } else {
4850             const QEMUOption *popt;
4851
4852             popt = lookup_opt(argc, argv, &optarg, &optind);
4853             switch (popt->index) {
4854             case QEMU_OPTION_nodefconfig:
4855                 defconfig=0;
4856                 break;
4857             }
4858         }
4859     }
4860
4861     if (defconfig) {
4862         FILE *fp;
4863         fp = fopen(CONFIG_QEMU_CONFDIR "/qemu.conf", "r");
4864         if (fp) {
4865             if (qemu_config_parse(fp) != 0) {
4866                 exit(1);
4867             }
4868             fclose(fp);
4869         }
4870
4871         fp = fopen(CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", "r");
4872         if (fp) {
4873             if (qemu_config_parse(fp) != 0) {
4874                 exit(1);
4875             }
4876             fclose(fp);
4877         }
4878     }
4879
4880     /* second pass of option parsing */
4881     optind = 1;
4882     for(;;) {
4883         if (optind >= argc)
4884             break;
4885         if (argv[optind][0] != '-') {
4886             hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4887         } else {
4888             const QEMUOption *popt;
4889
4890             popt = lookup_opt(argc, argv, &optarg, &optind);
4891             switch(popt->index) {
4892             case QEMU_OPTION_M:
4893                 machine = find_machine(optarg);
4894                 if (!machine) {
4895                     QEMUMachine *m;
4896                     printf("Supported machines are:\n");
4897                     for(m = first_machine; m != NULL; m = m->next) {
4898                         if (m->alias)
4899                             printf("%-10s %s (alias of %s)\n",
4900                                    m->alias, m->desc, m->name);
4901                         printf("%-10s %s%s\n",
4902                                m->name, m->desc,
4903                                m->is_default ? " (default)" : "");
4904                     }
4905                     exit(*optarg != '?');
4906                 }
4907                 break;
4908             case QEMU_OPTION_cpu:
4909                 /* hw initialization will check this */
4910                 if (*optarg == '?') {
4911 /* XXX: implement xxx_cpu_list for targets that still miss it */
4912 #if defined(cpu_list)
4913                     cpu_list(stdout, &fprintf);
4914 #endif
4915                     exit(0);
4916                 } else {
4917                     cpu_model = optarg;
4918                 }
4919                 break;
4920             case QEMU_OPTION_initrd:
4921                 initrd_filename = optarg;
4922                 break;
4923             case QEMU_OPTION_hda:
4924                 if (cyls == 0)
4925                     hda_opts = drive_add(optarg, HD_ALIAS, 0);
4926                 else
4927                     hda_opts = drive_add(optarg, HD_ALIAS
4928                              ",cyls=%d,heads=%d,secs=%d%s",
4929                              0, cyls, heads, secs,
4930                              translation == BIOS_ATA_TRANSLATION_LBA ?
4931                                  ",trans=lba" :
4932                              translation == BIOS_ATA_TRANSLATION_NONE ?
4933                                  ",trans=none" : "");
4934                  break;
4935             case QEMU_OPTION_hdb:
4936             case QEMU_OPTION_hdc:
4937             case QEMU_OPTION_hdd:
4938                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4939                 break;
4940             case QEMU_OPTION_drive:
4941                 drive_add(NULL, "%s", optarg);
4942                 break;
4943             case QEMU_OPTION_set:
4944                 if (qemu_set_option(optarg) != 0)
4945                     exit(1);
4946                 break;
4947             case QEMU_OPTION_global:
4948                 if (qemu_global_option(optarg) != 0)
4949                     exit(1);
4950                 break;
4951             case QEMU_OPTION_mtdblock:
4952                 drive_add(optarg, MTD_ALIAS);
4953                 break;
4954             case QEMU_OPTION_sd:
4955                 drive_add(optarg, SD_ALIAS);
4956                 break;
4957             case QEMU_OPTION_pflash:
4958                 drive_add(optarg, PFLASH_ALIAS);
4959                 break;
4960             case QEMU_OPTION_snapshot:
4961                 snapshot = 1;
4962                 break;
4963             case QEMU_OPTION_hdachs:
4964                 {
4965                     const char *p;
4966                     p = optarg;
4967                     cyls = strtol(p, (char **)&p, 0);
4968                     if (cyls < 1 || cyls > 16383)
4969                         goto chs_fail;
4970                     if (*p != ',')
4971                         goto chs_fail;
4972                     p++;
4973                     heads = strtol(p, (char **)&p, 0);
4974                     if (heads < 1 || heads > 16)
4975                         goto chs_fail;
4976                     if (*p != ',')
4977                         goto chs_fail;
4978                     p++;
4979                     secs = strtol(p, (char **)&p, 0);
4980                     if (secs < 1 || secs > 63)
4981                         goto chs_fail;
4982                     if (*p == ',') {
4983                         p++;
4984                         if (!strcmp(p, "none"))
4985                             translation = BIOS_ATA_TRANSLATION_NONE;
4986                         else if (!strcmp(p, "lba"))
4987                             translation = BIOS_ATA_TRANSLATION_LBA;
4988                         else if (!strcmp(p, "auto"))
4989                             translation = BIOS_ATA_TRANSLATION_AUTO;
4990                         else
4991                             goto chs_fail;
4992                     } else if (*p != '\0') {
4993                     chs_fail:
4994                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4995                         exit(1);
4996                     }
4997                     if (hda_opts != NULL) {
4998                         char num[16];
4999                         snprintf(num, sizeof(num), "%d", cyls);
5000                         qemu_opt_set(hda_opts, "cyls", num);
5001                         snprintf(num, sizeof(num), "%d", heads);
5002                         qemu_opt_set(hda_opts, "heads", num);
5003                         snprintf(num, sizeof(num), "%d", secs);
5004                         qemu_opt_set(hda_opts, "secs", num);
5005                         if (translation == BIOS_ATA_TRANSLATION_LBA)
5006                             qemu_opt_set(hda_opts, "trans", "lba");
5007                         if (translation == BIOS_ATA_TRANSLATION_NONE)
5008                             qemu_opt_set(hda_opts, "trans", "none");
5009                     }
5010                 }
5011                 break;
5012             case QEMU_OPTION_numa:
5013                 if (nb_numa_nodes >= MAX_NODES) {
5014                     fprintf(stderr, "qemu: too many NUMA nodes\n");
5015                     exit(1);
5016                 }
5017                 numa_add(optarg);
5018                 break;
5019             case QEMU_OPTION_nographic:
5020                 display_type = DT_NOGRAPHIC;
5021                 break;
5022 #ifdef CONFIG_CURSES
5023             case QEMU_OPTION_curses:
5024                 display_type = DT_CURSES;
5025                 break;
5026 #endif
5027             case QEMU_OPTION_portrait:
5028                 graphic_rotate = 1;
5029                 break;
5030             case QEMU_OPTION_kernel:
5031                 kernel_filename = optarg;
5032                 break;
5033             case QEMU_OPTION_append:
5034                 kernel_cmdline = optarg;
5035                 break;
5036             case QEMU_OPTION_cdrom:
5037                 drive_add(optarg, CDROM_ALIAS);
5038                 break;
5039             case QEMU_OPTION_boot:
5040                 {
5041                     static const char * const params[] = {
5042                         "order", "once", "menu", NULL
5043                     };
5044                     char buf[sizeof(boot_devices)];
5045                     char *standard_boot_devices;
5046                     int legacy = 0;
5047
5048                     if (!strchr(optarg, '=')) {
5049                         legacy = 1;
5050                         pstrcpy(buf, sizeof(buf), optarg);
5051                     } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
5052                         fprintf(stderr,
5053                                 "qemu: unknown boot parameter '%s' in '%s'\n",
5054                                 buf, optarg);
5055                         exit(1);
5056                     }
5057
5058                     if (legacy ||
5059                         get_param_value(buf, sizeof(buf), "order", optarg)) {
5060                         boot_devices_bitmap = parse_bootdevices(buf);
5061                         pstrcpy(boot_devices, sizeof(boot_devices), buf);
5062                     }
5063                     if (!legacy) {
5064                         if (get_param_value(buf, sizeof(buf),
5065                                             "once", optarg)) {
5066                             boot_devices_bitmap |= parse_bootdevices(buf);
5067                             standard_boot_devices = qemu_strdup(boot_devices);
5068                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
5069                             qemu_register_reset(restore_boot_devices,
5070                                                 standard_boot_devices);
5071                         }
5072                         if (get_param_value(buf, sizeof(buf),
5073                                             "menu", optarg)) {
5074                             if (!strcmp(buf, "on")) {
5075                                 boot_menu = 1;
5076                             } else if (!strcmp(buf, "off")) {
5077                                 boot_menu = 0;
5078                             } else {
5079                                 fprintf(stderr,
5080                                         "qemu: invalid option value '%s'\n",
5081                                         buf);
5082                                 exit(1);
5083                             }
5084                         }
5085                     }
5086                 }
5087                 break;
5088             case QEMU_OPTION_fda:
5089             case QEMU_OPTION_fdb:
5090                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5091                 break;
5092 #ifdef TARGET_I386
5093             case QEMU_OPTION_no_fd_bootchk:
5094                 fd_bootchk = 0;
5095                 break;
5096 #endif
5097             case QEMU_OPTION_netdev:
5098                 if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
5099                     exit(1);
5100                 }
5101                 break;
5102             case QEMU_OPTION_net:
5103                 if (net_client_parse(&qemu_net_opts, optarg) == -1) {
5104                     exit(1);
5105                 }
5106                 break;
5107 #ifdef CONFIG_SLIRP
5108             case QEMU_OPTION_tftp:
5109                 legacy_tftp_prefix = optarg;
5110                 break;
5111             case QEMU_OPTION_bootp:
5112                 legacy_bootp_filename = optarg;
5113                 break;
5114 #ifndef _WIN32
5115             case QEMU_OPTION_smb:
5116                 if (net_slirp_smb(optarg) < 0)
5117                     exit(1);
5118                 break;
5119 #endif
5120             case QEMU_OPTION_redir:
5121                 if (net_slirp_redir(optarg) < 0)
5122                     exit(1);
5123                 break;
5124 #endif
5125             case QEMU_OPTION_bt:
5126                 add_device_config(DEV_BT, optarg);
5127                 break;
5128 #ifdef HAS_AUDIO
5129             case QEMU_OPTION_audio_help:
5130                 AUD_help ();
5131                 exit (0);
5132                 break;
5133             case QEMU_OPTION_soundhw:
5134                 select_soundhw (optarg);
5135                 break;
5136 #endif
5137             case QEMU_OPTION_h:
5138                 help(0);
5139                 break;
5140             case QEMU_OPTION_version:
5141                 version();
5142                 exit(0);
5143                 break;
5144             case QEMU_OPTION_m: {
5145                 uint64_t value;
5146                 char *ptr;
5147
5148                 value = strtoul(optarg, &ptr, 10);
5149                 switch (*ptr) {
5150                 case 0: case 'M': case 'm':
5151                     value <<= 20;
5152                     break;
5153                 case 'G': case 'g':
5154                     value <<= 30;
5155                     break;
5156                 default:
5157                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5158                     exit(1);
5159                 }
5160
5161                 /* On 32-bit hosts, QEMU is limited by virtual address space */
5162                 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5163                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5164                     exit(1);
5165                 }
5166                 if (value != (uint64_t)(ram_addr_t)value) {
5167                     fprintf(stderr, "qemu: ram size too large\n");
5168                     exit(1);
5169                 }
5170                 ram_size = value;
5171                 break;
5172             }
5173             case QEMU_OPTION_d:
5174                 {
5175                     int mask;
5176                     const CPULogItem *item;
5177
5178                     mask = cpu_str_to_log_mask(optarg);
5179                     if (!mask) {
5180                         printf("Log items (comma separated):\n");
5181                     for(item = cpu_log_items; item->mask != 0; item++) {
5182                         printf("%-10s %s\n", item->name, item->help);
5183                     }
5184                     exit(1);
5185                     }
5186                     cpu_set_log(mask);
5187                 }
5188                 break;
5189             case QEMU_OPTION_s:
5190                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5191                 break;
5192             case QEMU_OPTION_gdb:
5193                 gdbstub_dev = optarg;
5194                 break;
5195             case QEMU_OPTION_L:
5196                 data_dir = optarg;
5197                 break;
5198             case QEMU_OPTION_bios:
5199                 bios_name = optarg;
5200                 break;
5201             case QEMU_OPTION_singlestep:
5202                 singlestep = 1;
5203                 break;
5204             case QEMU_OPTION_S:
5205                 autostart = 0;
5206                 break;
5207             case QEMU_OPTION_k:
5208                 keyboard_layout = optarg;
5209                 break;
5210             case QEMU_OPTION_localtime:
5211                 rtc_utc = 0;
5212                 break;
5213             case QEMU_OPTION_vga:
5214                 select_vgahw (optarg);
5215                 break;
5216 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5217             case QEMU_OPTION_g:
5218                 {
5219                     const char *p;
5220                     int w, h, depth;
5221                     p = optarg;
5222                     w = strtol(p, (char **)&p, 10);
5223                     if (w <= 0) {
5224                     graphic_error:
5225                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5226                         exit(1);
5227                     }
5228                     if (*p != 'x')
5229                         goto graphic_error;
5230                     p++;
5231                     h = strtol(p, (char **)&p, 10);
5232                     if (h <= 0)
5233                         goto graphic_error;
5234                     if (*p == 'x') {
5235                         p++;
5236                         depth = strtol(p, (char **)&p, 10);
5237                         if (depth != 8 && depth != 15 && depth != 16 &&
5238                             depth != 24 && depth != 32)
5239                             goto graphic_error;
5240                     } else if (*p == '\0') {
5241                         depth = graphic_depth;
5242                     } else {
5243                         goto graphic_error;
5244                     }
5245
5246                     graphic_width = w;
5247                     graphic_height = h;
5248                     graphic_depth = depth;
5249                 }
5250                 break;
5251 #endif
5252             case QEMU_OPTION_echr:
5253                 {
5254                     char *r;
5255                     term_escape_char = strtol(optarg, &r, 0);
5256                     if (r == optarg)
5257                         printf("Bad argument to echr\n");
5258                     break;
5259                 }
5260             case QEMU_OPTION_monitor:
5261                 monitor_parse(optarg, "readline");
5262                 default_monitor = 0;
5263                 break;
5264             case QEMU_OPTION_qmp:
5265                 monitor_parse(optarg, "control");
5266                 default_monitor = 0;
5267                 break;
5268             case QEMU_OPTION_mon:
5269                 opts = qemu_opts_parse(&qemu_mon_opts, optarg, "chardev");
5270                 if (!opts) {
5271                     fprintf(stderr, "parse error: %s\n", optarg);
5272                     exit(1);
5273                 }
5274                 default_monitor = 0;
5275                 break;
5276             case QEMU_OPTION_chardev:
5277                 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend");
5278                 if (!opts) {
5279                     fprintf(stderr, "parse error: %s\n", optarg);
5280                     exit(1);
5281                 }
5282                 break;
5283             case QEMU_OPTION_serial:
5284                 add_device_config(DEV_SERIAL, optarg);
5285                 default_serial = 0;
5286                 break;
5287             case QEMU_OPTION_watchdog:
5288                 if (watchdog) {
5289                     fprintf(stderr,
5290                             "qemu: only one watchdog option may be given\n");
5291                     return 1;
5292                 }
5293                 watchdog = optarg;
5294                 break;
5295             case QEMU_OPTION_watchdog_action:
5296                 if (select_watchdog_action(optarg) == -1) {
5297                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
5298                     exit(1);
5299                 }
5300                 break;
5301             case QEMU_OPTION_virtiocon:
5302                 add_device_config(DEV_VIRTCON, optarg);
5303                 default_virtcon = 0;
5304                 break;
5305             case QEMU_OPTION_parallel:
5306                 add_device_config(DEV_PARALLEL, optarg);
5307                 default_parallel = 0;
5308                 break;
5309             case QEMU_OPTION_debugcon:
5310                 add_device_config(DEV_DEBUGCON, optarg);
5311                 break;
5312             case QEMU_OPTION_loadvm:
5313                 loadvm = optarg;
5314                 break;
5315             case QEMU_OPTION_full_screen:
5316                 full_screen = 1;
5317                 break;
5318 #ifdef CONFIG_SDL
5319             case QEMU_OPTION_no_frame:
5320                 no_frame = 1;
5321                 break;
5322             case QEMU_OPTION_alt_grab:
5323                 alt_grab = 1;
5324                 break;
5325             case QEMU_OPTION_ctrl_grab:
5326                 ctrl_grab = 1;
5327                 break;
5328             case QEMU_OPTION_no_quit:
5329                 no_quit = 1;
5330                 break;
5331             case QEMU_OPTION_sdl:
5332                 display_type = DT_SDL;
5333                 break;
5334 #endif
5335             case QEMU_OPTION_pidfile:
5336                 pid_file = optarg;
5337                 break;
5338 #ifdef TARGET_I386
5339             case QEMU_OPTION_win2k_hack:
5340                 win2k_install_hack = 1;
5341                 break;
5342             case QEMU_OPTION_rtc_td_hack:
5343                 rtc_td_hack = 1;
5344                 break;
5345             case QEMU_OPTION_acpitable:
5346                 if(acpi_table_add(optarg) < 0) {
5347                     fprintf(stderr, "Wrong acpi table provided\n");
5348                     exit(1);
5349                 }
5350                 break;
5351             case QEMU_OPTION_smbios:
5352                 if(smbios_entry_add(optarg) < 0) {
5353                     fprintf(stderr, "Wrong smbios provided\n");
5354                     exit(1);
5355                 }
5356                 break;
5357 #endif
5358 #ifdef CONFIG_KVM
5359             case QEMU_OPTION_enable_kvm:
5360                 kvm_allowed = 1;
5361                 break;
5362 #endif
5363             case QEMU_OPTION_usb:
5364                 usb_enabled = 1;
5365                 break;
5366             case QEMU_OPTION_usbdevice:
5367                 usb_enabled = 1;
5368                 add_device_config(DEV_USB, optarg);
5369                 break;
5370             case QEMU_OPTION_device:
5371                 if (!qemu_opts_parse(&qemu_device_opts, optarg, "driver")) {
5372                     exit(1);
5373                 }
5374                 break;
5375             case QEMU_OPTION_smp:
5376                 smp_parse(optarg);
5377                 if (smp_cpus < 1) {
5378                     fprintf(stderr, "Invalid number of CPUs\n");
5379                     exit(1);
5380                 }
5381                 if (max_cpus < smp_cpus) {
5382                     fprintf(stderr, "maxcpus must be equal to or greater than "
5383                             "smp\n");
5384                     exit(1);
5385                 }
5386                 if (max_cpus > 255) {
5387                     fprintf(stderr, "Unsupported number of maxcpus\n");
5388                     exit(1);
5389                 }
5390                 break;
5391             case QEMU_OPTION_vnc:
5392                 display_type = DT_VNC;
5393                 vnc_display = optarg;
5394                 break;
5395 #ifdef TARGET_I386
5396             case QEMU_OPTION_no_acpi:
5397                 acpi_enabled = 0;
5398                 break;
5399             case QEMU_OPTION_no_hpet:
5400                 no_hpet = 1;
5401                 break;
5402             case QEMU_OPTION_balloon:
5403                 if (balloon_parse(optarg) < 0) {
5404                     fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5405                     exit(1);
5406                 }
5407                 break;
5408 #endif
5409             case QEMU_OPTION_no_reboot:
5410                 no_reboot = 1;
5411                 break;
5412             case QEMU_OPTION_no_shutdown:
5413                 no_shutdown = 1;
5414                 break;
5415             case QEMU_OPTION_show_cursor:
5416                 cursor_hide = 0;
5417                 break;
5418             case QEMU_OPTION_uuid:
5419                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5420                     fprintf(stderr, "Fail to parse UUID string."
5421                             " Wrong format.\n");
5422                     exit(1);
5423                 }
5424                 break;
5425 #ifndef _WIN32
5426             case QEMU_OPTION_daemonize:
5427                 daemonize = 1;
5428                 break;
5429 #endif
5430             case QEMU_OPTION_option_rom:
5431                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5432                     fprintf(stderr, "Too many option ROMs\n");
5433                     exit(1);
5434                 }
5435                 option_rom[nb_option_roms] = optarg;
5436                 nb_option_roms++;
5437                 break;
5438 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5439             case QEMU_OPTION_semihosting:
5440                 semihosting_enabled = 1;
5441                 break;
5442 #endif
5443             case QEMU_OPTION_name:
5444                 qemu_name = qemu_strdup(optarg);
5445                  {
5446                      char *p = strchr(qemu_name, ',');
5447                      if (p != NULL) {
5448                         *p++ = 0;
5449                         if (strncmp(p, "process=", 8)) {
5450                             fprintf(stderr, "Unknown subargument %s to -name", p);
5451                             exit(1);
5452                         }
5453                         p += 8;
5454                         set_proc_name(p);
5455                      }
5456                  }
5457                 break;
5458 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5459             case QEMU_OPTION_prom_env:
5460                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5461                     fprintf(stderr, "Too many prom variables\n");
5462                     exit(1);
5463                 }
5464                 prom_envs[nb_prom_envs] = optarg;
5465                 nb_prom_envs++;
5466                 break;
5467 #endif
5468 #ifdef TARGET_ARM
5469             case QEMU_OPTION_old_param:
5470                 old_param = 1;
5471                 break;
5472 #endif
5473             case QEMU_OPTION_clock:
5474                 configure_alarms(optarg);
5475                 break;
5476             case QEMU_OPTION_startdate:
5477                 configure_rtc_date_offset(optarg, 1);
5478                 break;
5479             case QEMU_OPTION_rtc:
5480                 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
5481                 if (!opts) {
5482                     fprintf(stderr, "parse error: %s\n", optarg);
5483                     exit(1);
5484                 }
5485                 configure_rtc(opts);
5486                 break;
5487             case QEMU_OPTION_tb_size:
5488                 tb_size = strtol(optarg, NULL, 0);
5489                 if (tb_size < 0)
5490                     tb_size = 0;
5491                 break;
5492             case QEMU_OPTION_icount:
5493                 use_icount = 1;
5494                 if (strcmp(optarg, "auto") == 0) {
5495                     icount_time_shift = -1;
5496                 } else {
5497                     icount_time_shift = strtol(optarg, NULL, 0);
5498                 }
5499                 break;
5500             case QEMU_OPTION_incoming:
5501                 incoming = optarg;
5502                 break;
5503             case QEMU_OPTION_nodefaults:
5504                 default_serial = 0;
5505                 default_parallel = 0;
5506                 default_virtcon = 0;
5507                 default_monitor = 0;
5508                 default_vga = 0;
5509                 default_net = 0;
5510                 default_floppy = 0;
5511                 default_cdrom = 0;
5512                 default_sdcard = 0;
5513                 break;
5514 #ifndef _WIN32
5515             case QEMU_OPTION_chroot:
5516                 chroot_dir = optarg;
5517                 break;
5518             case QEMU_OPTION_runas:
5519                 run_as = optarg;
5520                 break;
5521 #endif
5522 #ifdef CONFIG_XEN
5523             case QEMU_OPTION_xen_domid:
5524                 xen_domid = atoi(optarg);
5525                 break;
5526             case QEMU_OPTION_xen_create:
5527                 xen_mode = XEN_CREATE;
5528                 break;
5529             case QEMU_OPTION_xen_attach:
5530                 xen_mode = XEN_ATTACH;
5531                 break;
5532 #endif
5533             case QEMU_OPTION_readconfig:
5534                 {
5535                     FILE *fp;
5536                     fp = fopen(optarg, "r");
5537                     if (fp == NULL) {
5538                         fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5539                         exit(1);
5540                     }
5541                     if (qemu_config_parse(fp) != 0) {
5542                         exit(1);
5543                     }
5544                     fclose(fp);
5545                     break;
5546                 }
5547             case QEMU_OPTION_writeconfig:
5548                 {
5549                     FILE *fp;
5550                     if (strcmp(optarg, "-") == 0) {
5551                         fp = stdout;
5552                     } else {
5553                         fp = fopen(optarg, "w");
5554                         if (fp == NULL) {
5555                             fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5556                             exit(1);
5557                         }
5558                     }
5559                     qemu_config_write(fp);
5560                     fclose(fp);
5561                     break;
5562                 }
5563             }
5564         }
5565     }
5566
5567     /* If no data_dir is specified then try to find it relative to the
5568        executable path.  */
5569     if (!data_dir) {
5570         data_dir = find_datadir(argv[0]);
5571     }
5572     /* If all else fails use the install patch specified when building.  */
5573     if (!data_dir) {
5574         data_dir = CONFIG_QEMU_SHAREDIR;
5575     }
5576
5577     /*
5578      * Default to max_cpus = smp_cpus, in case the user doesn't
5579      * specify a max_cpus value.
5580      */
5581     if (!max_cpus)
5582         max_cpus = smp_cpus;
5583
5584     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5585     if (smp_cpus > machine->max_cpus) {
5586         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5587                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5588                 machine->max_cpus);
5589         exit(1);
5590     }
5591
5592     qemu_opts_foreach(&qemu_device_opts, default_driver_check, NULL, 0);
5593     qemu_opts_foreach(&qemu_global_opts, default_driver_check, NULL, 0);
5594
5595     if (machine->no_serial) {
5596         default_serial = 0;
5597     }
5598     if (machine->no_parallel) {
5599         default_parallel = 0;
5600     }
5601     if (!machine->use_virtcon) {
5602         default_virtcon = 0;
5603     }
5604     if (machine->no_vga) {
5605         default_vga = 0;
5606     }
5607     if (machine->no_floppy) {
5608         default_floppy = 0;
5609     }
5610     if (machine->no_cdrom) {
5611         default_cdrom = 0;
5612     }
5613     if (machine->no_sdcard) {
5614         default_sdcard = 0;
5615     }
5616
5617     if (display_type == DT_NOGRAPHIC) {
5618         if (default_parallel)
5619             add_device_config(DEV_PARALLEL, "null");
5620         if (default_serial && default_monitor) {
5621             add_device_config(DEV_SERIAL, "mon:stdio");
5622         } else if (default_virtcon && default_monitor) {
5623             add_device_config(DEV_VIRTCON, "mon:stdio");
5624         } else {
5625             if (default_serial)
5626                 add_device_config(DEV_SERIAL, "stdio");
5627             if (default_virtcon)
5628                 add_device_config(DEV_VIRTCON, "stdio");
5629             if (default_monitor)
5630                 monitor_parse("stdio", "readline");
5631         }
5632     } else {
5633         if (default_serial)
5634             add_device_config(DEV_SERIAL, "vc:80Cx24C");
5635         if (default_parallel)
5636             add_device_config(DEV_PARALLEL, "vc:80Cx24C");
5637         if (default_monitor)
5638             monitor_parse("vc:80Cx24C", "readline");
5639         if (default_virtcon)
5640             add_device_config(DEV_VIRTCON, "vc:80Cx24C");
5641     }
5642     if (default_vga)
5643         vga_interface_type = VGA_CIRRUS;
5644
5645     if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0)
5646         exit(1);
5647
5648 #ifndef _WIN32
5649     if (daemonize) {
5650         pid_t pid;
5651
5652         if (pipe(fds) == -1)
5653             exit(1);
5654
5655         pid = fork();
5656         if (pid > 0) {
5657             uint8_t status;
5658             ssize_t len;
5659
5660             close(fds[1]);
5661
5662         again:
5663             len = read(fds[0], &status, 1);
5664             if (len == -1 && (errno == EINTR))
5665                 goto again;
5666
5667             if (len != 1)
5668                 exit(1);
5669             else if (status == 1) {
5670                 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
5671                 exit(1);
5672             } else
5673                 exit(0);
5674         } else if (pid < 0)
5675             exit(1);
5676
5677         close(fds[0]);
5678         qemu_set_cloexec(fds[1]);
5679
5680         setsid();
5681
5682         pid = fork();
5683         if (pid > 0)
5684             exit(0);
5685         else if (pid < 0)
5686             exit(1);
5687
5688         umask(027);
5689
5690         signal(SIGTSTP, SIG_IGN);
5691         signal(SIGTTOU, SIG_IGN);
5692         signal(SIGTTIN, SIG_IGN);
5693     }
5694 #endif
5695
5696     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5697 #ifndef _WIN32
5698         if (daemonize) {
5699             uint8_t status = 1;
5700             if (write(fds[1], &status, 1) != 1) {
5701                 perror("daemonize. Writing to pipe\n");
5702             }
5703         } else
5704 #endif
5705             fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
5706         exit(1);
5707     }
5708
5709     if (kvm_enabled()) {
5710         int ret;
5711
5712         ret = kvm_init(smp_cpus);
5713         if (ret < 0) {
5714             fprintf(stderr, "failed to initialize KVM\n");
5715             exit(1);
5716         }
5717     }
5718
5719     if (qemu_init_main_loop()) {
5720         fprintf(stderr, "qemu_init_main_loop failed\n");
5721         exit(1);
5722     }
5723     linux_boot = (kernel_filename != NULL);
5724
5725     if (!linux_boot && *kernel_cmdline != '\0') {
5726         fprintf(stderr, "-append only allowed with -kernel option\n");
5727         exit(1);
5728     }
5729
5730     if (!linux_boot && initrd_filename != NULL) {
5731         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5732         exit(1);
5733     }
5734
5735 #ifndef _WIN32
5736     /* Win32 doesn't support line-buffering and requires size >= 2 */
5737     setvbuf(stdout, NULL, _IOLBF, 0);
5738 #endif
5739
5740     if (init_timer_alarm() < 0) {
5741         fprintf(stderr, "could not initialize alarm timer\n");
5742         exit(1);
5743     }
5744     if (use_icount && icount_time_shift < 0) {
5745         use_icount = 2;
5746         /* 125MIPS seems a reasonable initial guess at the guest speed.
5747            It will be corrected fairly quickly anyway.  */
5748         icount_time_shift = 3;
5749         init_icount_adjust();
5750     }
5751
5752 #ifdef _WIN32
5753     socket_init();
5754 #endif
5755
5756     if (net_init_clients() < 0) {
5757         exit(1);
5758     }
5759
5760     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5761     net_set_boot_mask(net_boot);
5762
5763     /* init the bluetooth world */
5764     if (foreach_device_config(DEV_BT, bt_parse))
5765         exit(1);
5766
5767     /* init the memory */
5768     if (ram_size == 0)
5769         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5770
5771     /* init the dynamic translator */
5772     cpu_exec_init_all(tb_size * 1024 * 1024);
5773
5774     bdrv_init_with_whitelist();
5775
5776     blk_mig_init();
5777
5778     if (default_cdrom) {
5779         /* we always create the cdrom drive, even if no disk is there */
5780         drive_add(NULL, CDROM_ALIAS);
5781     }
5782
5783     if (default_floppy) {
5784         /* we always create at least one floppy */
5785         drive_add(NULL, FD_ALIAS, 0);
5786     }
5787
5788     if (default_sdcard) {
5789         /* we always create one sd slot, even if no card is in it */
5790         drive_add(NULL, SD_ALIAS);
5791     }
5792
5793     /* open the virtual block devices */
5794     if (snapshot)
5795         qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5796     if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5797         exit(1);
5798
5799     vmstate_register(0, &vmstate_timers ,&timers_state);
5800     register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
5801                          ram_load, NULL);
5802
5803     if (nb_numa_nodes > 0) {
5804         int i;
5805
5806         if (nb_numa_nodes > smp_cpus) {
5807             nb_numa_nodes = smp_cpus;
5808         }
5809
5810         /* If no memory size if given for any node, assume the default case
5811          * and distribute the available memory equally across all nodes
5812          */
5813         for (i = 0; i < nb_numa_nodes; i++) {
5814             if (node_mem[i] != 0)
5815                 break;
5816         }
5817         if (i == nb_numa_nodes) {
5818             uint64_t usedmem = 0;
5819
5820             /* On Linux, the each node's border has to be 8MB aligned,
5821              * the final node gets the rest.
5822              */
5823             for (i = 0; i < nb_numa_nodes - 1; i++) {
5824                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5825                 usedmem += node_mem[i];
5826             }
5827             node_mem[i] = ram_size - usedmem;
5828         }
5829
5830         for (i = 0; i < nb_numa_nodes; i++) {
5831             if (node_cpumask[i] != 0)
5832                 break;
5833         }
5834         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5835          * must cope with this anyway, because there are BIOSes out there in
5836          * real machines which also use this scheme.
5837          */
5838         if (i == nb_numa_nodes) {
5839             for (i = 0; i < smp_cpus; i++) {
5840                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5841             }
5842         }
5843     }
5844
5845     if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
5846         exit(1);
5847     if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
5848         exit(1);
5849     if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
5850         exit(1);
5851     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
5852         exit(1);
5853
5854     module_call_init(MODULE_INIT_DEVICE);
5855
5856     if (qemu_opts_foreach(&qemu_device_opts, device_help_func, NULL, 0) != 0)
5857         exit(0);
5858
5859     if (watchdog) {
5860         i = select_watchdog(watchdog);
5861         if (i > 0)
5862             exit (i == 1 ? 1 : 0);
5863     }
5864
5865     if (machine->compat_props) {
5866         qdev_prop_register_global_list(machine->compat_props);
5867     }
5868     qemu_add_globals();
5869
5870     machine->init(ram_size, boot_devices,
5871                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5872
5873
5874 #ifndef _WIN32
5875     /* must be after terminal init, SDL library changes signal handlers */
5876     sighandler_setup();
5877 #endif
5878
5879     for (env = first_cpu; env != NULL; env = env->next_cpu) {
5880         for (i = 0; i < nb_numa_nodes; i++) {
5881             if (node_cpumask[i] & (1 << env->cpu_index)) {
5882                 env->numa_node = i;
5883             }
5884         }
5885     }
5886
5887     current_machine = machine;
5888
5889     /* init USB devices */
5890     if (usb_enabled) {
5891         if (foreach_device_config(DEV_USB, usb_parse) < 0)
5892             exit(1);
5893     }
5894
5895     /* init generic devices */
5896     if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5897         exit(1);
5898
5899     if (!display_state)
5900         dumb_display_init();
5901     /* just use the first displaystate for the moment */
5902     ds = display_state;
5903
5904     if (display_type == DT_DEFAULT) {
5905 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5906         display_type = DT_SDL;
5907 #else
5908         display_type = DT_VNC;
5909         vnc_display = "localhost:0,to=99";
5910         show_vnc_port = 1;
5911 #endif
5912     }
5913
5914
5915     switch (display_type) {
5916     case DT_NOGRAPHIC:
5917         break;
5918 #if defined(CONFIG_CURSES)
5919     case DT_CURSES:
5920         curses_display_init(ds, full_screen);
5921         break;
5922 #endif
5923 #if defined(CONFIG_SDL)
5924     case DT_SDL:
5925         sdl_display_init(ds, full_screen, no_frame);
5926         break;
5927 #elif defined(CONFIG_COCOA)
5928     case DT_SDL:
5929         cocoa_display_init(ds, full_screen);
5930         break;
5931 #endif
5932     case DT_VNC:
5933         vnc_display_init(ds);
5934         if (vnc_display_open(ds, vnc_display) < 0)
5935             exit(1);
5936
5937         if (show_vnc_port) {
5938             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
5939         }
5940         break;
5941     default:
5942         break;
5943     }
5944     dpy_resize(ds);
5945
5946     dcl = ds->listeners;
5947     while (dcl != NULL) {
5948         if (dcl->dpy_refresh != NULL) {
5949             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5950             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5951         }
5952         dcl = dcl->next;
5953     }
5954
5955     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
5956         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5957         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5958     }
5959
5960     text_consoles_set_display(display_state);
5961
5962     if (qemu_opts_foreach(&qemu_mon_opts, mon_init_func, NULL, 1) != 0)
5963         exit(1);
5964
5965     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5966         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5967                 gdbstub_dev);
5968         exit(1);
5969     }
5970
5971     qdev_machine_creation_done();
5972
5973     if (rom_load_all() != 0) {
5974         fprintf(stderr, "rom loading failed\n");
5975         exit(1);
5976     }
5977
5978     qemu_system_reset();
5979     if (loadvm) {
5980         if (load_vmstate(cur_mon, loadvm) < 0) {
5981             autostart = 0;
5982         }
5983     }
5984
5985     if (incoming) {
5986         qemu_start_incoming_migration(incoming);
5987     } else if (autostart) {
5988         vm_start();
5989     }
5990
5991 #ifndef _WIN32
5992     if (daemonize) {
5993         uint8_t status = 0;
5994         ssize_t len;
5995
5996     again1:
5997         len = write(fds[1], &status, 1);
5998         if (len == -1 && (errno == EINTR))
5999             goto again1;
6000
6001         if (len != 1)
6002             exit(1);
6003
6004         if (chdir("/")) {
6005             perror("not able to chdir to /");
6006             exit(1);
6007         }
6008         TFR(fd = qemu_open("/dev/null", O_RDWR));
6009         if (fd == -1)
6010             exit(1);
6011     }
6012
6013     if (run_as) {
6014         pwd = getpwnam(run_as);
6015         if (!pwd) {
6016             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6017             exit(1);
6018         }
6019     }
6020
6021     if (chroot_dir) {
6022         if (chroot(chroot_dir) < 0) {
6023             fprintf(stderr, "chroot failed\n");
6024             exit(1);
6025         }
6026         if (chdir("/")) {
6027             perror("not able to chdir to /");
6028             exit(1);
6029         }
6030     }
6031
6032     if (run_as) {
6033         if (setgid(pwd->pw_gid) < 0) {
6034             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6035             exit(1);
6036         }
6037         if (setuid(pwd->pw_uid) < 0) {
6038             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6039             exit(1);
6040         }
6041         if (setuid(0) != -1) {
6042             fprintf(stderr, "Dropping privileges failed\n");
6043             exit(1);
6044         }
6045     }
6046
6047     if (daemonize) {
6048         dup2(fd, 0);
6049         dup2(fd, 1);
6050         dup2(fd, 2);
6051
6052         close(fd);
6053     }
6054 #endif
6055
6056     main_loop();
6057     quit_timers();
6058     net_cleanup();
6059
6060     return 0;
6061 }