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