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 static void configure_rtc_date_offset(const char *startdate, int legacy)
1496 {
1497     time_t rtc_start_date;
1498     struct tm tm;
1499
1500     if (!strcmp(startdate, "now") && legacy) {
1501         rtc_date_offset = -1;
1502     } else {
1503         if (sscanf(startdate, "%d-%d-%dT%d:%d:%d",
1504                    &tm.tm_year,
1505                    &tm.tm_mon,
1506                    &tm.tm_mday,
1507                    &tm.tm_hour,
1508                    &tm.tm_min,
1509                    &tm.tm_sec) == 6) {
1510             /* OK */
1511         } else if (sscanf(startdate, "%d-%d-%d",
1512                           &tm.tm_year,
1513                           &tm.tm_mon,
1514                           &tm.tm_mday) == 3) {
1515             tm.tm_hour = 0;
1516             tm.tm_min = 0;
1517             tm.tm_sec = 0;
1518         } else {
1519             goto date_fail;
1520         }
1521         tm.tm_year -= 1900;
1522         tm.tm_mon--;
1523         rtc_start_date = mktimegm(&tm);
1524         if (rtc_start_date == -1) {
1525         date_fail:
1526             fprintf(stderr, "Invalid date format. Valid formats are:\n"
1527                             "'2006-06-17T16:01:21' or '2006-06-17'\n");
1528             exit(1);
1529         }
1530         rtc_date_offset = time(NULL) - rtc_start_date;
1531     }
1532 }
1533
1534 static void configure_rtc(QemuOpts *opts)
1535 {
1536     const char *value;
1537
1538     value = qemu_opt_get(opts, "base");
1539     if (value) {
1540         if (!strcmp(value, "utc")) {
1541             rtc_utc = 1;
1542         } else if (!strcmp(value, "localtime")) {
1543             rtc_utc = 0;
1544         } else {
1545             configure_rtc_date_offset(value, 0);
1546         }
1547     }
1548     value = qemu_opt_get(opts, "clock");
1549     if (value) {
1550         if (!strcmp(value, "host")) {
1551             rtc_clock = host_clock;
1552         } else if (!strcmp(value, "vm")) {
1553             rtc_clock = vm_clock;
1554         } else {
1555             fprintf(stderr, "qemu: invalid option value '%s'\n", value);
1556             exit(1);
1557         }
1558     }
1559 #ifdef CONFIG_TARGET_I386
1560     value = qemu_opt_get(opts, "driftfix");
1561     if (value) {
1562         if (!strcmp(buf, "slew")) {
1563             rtc_td_hack = 1;
1564         } else if (!strcmp(buf, "none")) {
1565             rtc_td_hack = 0;
1566         } else {
1567             fprintf(stderr, "qemu: invalid option value '%s'\n", value);
1568             exit(1);
1569         }
1570     }
1571 #endif
1572 }
1573
1574 #ifdef _WIN32
1575 static void socket_cleanup(void)
1576 {
1577     WSACleanup();
1578 }
1579
1580 static int socket_init(void)
1581 {
1582     WSADATA Data;
1583     int ret, err;
1584
1585     ret = WSAStartup(MAKEWORD(2,2), &Data);
1586     if (ret != 0) {
1587         err = WSAGetLastError();
1588         fprintf(stderr, "WSAStartup: %d\n", err);
1589         return -1;
1590     }
1591     atexit(socket_cleanup);
1592     return 0;
1593 }
1594 #endif
1595
1596 /***********************************************************/
1597 /* Bluetooth support */
1598 static int nb_hcis;
1599 static int cur_hci;
1600 static struct HCIInfo *hci_table[MAX_NICS];
1601
1602 static struct bt_vlan_s {
1603     struct bt_scatternet_s net;
1604     int id;
1605     struct bt_vlan_s *next;
1606 } *first_bt_vlan;
1607
1608 /* find or alloc a new bluetooth "VLAN" */
1609 static struct bt_scatternet_s *qemu_find_bt_vlan(int id)
1610 {
1611     struct bt_vlan_s **pvlan, *vlan;
1612     for (vlan = first_bt_vlan; vlan != NULL; vlan = vlan->next) {
1613         if (vlan->id == id)
1614             return &vlan->net;
1615     }
1616     vlan = qemu_mallocz(sizeof(struct bt_vlan_s));
1617     vlan->id = id;
1618     pvlan = &first_bt_vlan;
1619     while (*pvlan != NULL)
1620         pvlan = &(*pvlan)->next;
1621     *pvlan = vlan;
1622     return &vlan->net;
1623 }
1624
1625 static void null_hci_send(struct HCIInfo *hci, const uint8_t *data, int len)
1626 {
1627 }
1628
1629 static int null_hci_addr_set(struct HCIInfo *hci, const uint8_t *bd_addr)
1630 {
1631     return -ENOTSUP;
1632 }
1633
1634 static struct HCIInfo null_hci = {
1635     .cmd_send = null_hci_send,
1636     .sco_send = null_hci_send,
1637     .acl_send = null_hci_send,
1638     .bdaddr_set = null_hci_addr_set,
1639 };
1640
1641 struct HCIInfo *qemu_next_hci(void)
1642 {
1643     if (cur_hci == nb_hcis)
1644         return &null_hci;
1645
1646     return hci_table[cur_hci++];
1647 }
1648
1649 static struct HCIInfo *hci_init(const char *str)
1650 {
1651     char *endp;
1652     struct bt_scatternet_s *vlan = 0;
1653
1654     if (!strcmp(str, "null"))
1655         /* null */
1656         return &null_hci;
1657     else if (!strncmp(str, "host", 4) && (str[4] == '\0' || str[4] == ':'))
1658         /* host[:hciN] */
1659         return bt_host_hci(str[4] ? str + 5 : "hci0");
1660     else if (!strncmp(str, "hci", 3)) {
1661         /* hci[,vlan=n] */
1662         if (str[3]) {
1663             if (!strncmp(str + 3, ",vlan=", 6)) {
1664                 vlan = qemu_find_bt_vlan(strtol(str + 9, &endp, 0));
1665                 if (*endp)
1666                     vlan = 0;
1667             }
1668         } else
1669             vlan = qemu_find_bt_vlan(0);
1670         if (vlan)
1671            return bt_new_hci(vlan);
1672     }
1673
1674     fprintf(stderr, "qemu: Unknown bluetooth HCI `%s'.\n", str);
1675
1676     return 0;
1677 }
1678
1679 static int bt_hci_parse(const char *str)
1680 {
1681     struct HCIInfo *hci;
1682     bdaddr_t bdaddr;
1683
1684     if (nb_hcis >= MAX_NICS) {
1685         fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
1686         return -1;
1687     }
1688
1689     hci = hci_init(str);
1690     if (!hci)
1691         return -1;
1692
1693     bdaddr.b[0] = 0x52;
1694     bdaddr.b[1] = 0x54;
1695     bdaddr.b[2] = 0x00;
1696     bdaddr.b[3] = 0x12;
1697     bdaddr.b[4] = 0x34;
1698     bdaddr.b[5] = 0x56 + nb_hcis;
1699     hci->bdaddr_set(hci, bdaddr.b);
1700
1701     hci_table[nb_hcis++] = hci;
1702
1703     return 0;
1704 }
1705
1706 static void bt_vhci_add(int vlan_id)
1707 {
1708     struct bt_scatternet_s *vlan = qemu_find_bt_vlan(vlan_id);
1709
1710     if (!vlan->slave)
1711         fprintf(stderr, "qemu: warning: adding a VHCI to "
1712                         "an empty scatternet %i\n", vlan_id);
1713
1714     bt_vhci_init(bt_new_hci(vlan));
1715 }
1716
1717 static struct bt_device_s *bt_device_add(const char *opt)
1718 {
1719     struct bt_scatternet_s *vlan;
1720     int vlan_id = 0;
1721     char *endp = strstr(opt, ",vlan=");
1722     int len = (endp ? endp - opt : strlen(opt)) + 1;
1723     char devname[10];
1724
1725     pstrcpy(devname, MIN(sizeof(devname), len), opt);
1726
1727     if (endp) {
1728         vlan_id = strtol(endp + 6, &endp, 0);
1729         if (*endp) {
1730             fprintf(stderr, "qemu: unrecognised bluetooth vlan Id\n");
1731             return 0;
1732         }
1733     }
1734
1735     vlan = qemu_find_bt_vlan(vlan_id);
1736
1737     if (!vlan->slave)
1738         fprintf(stderr, "qemu: warning: adding a slave device to "
1739                         "an empty scatternet %i\n", vlan_id);
1740
1741     if (!strcmp(devname, "keyboard"))
1742         return bt_keyboard_init(vlan);
1743
1744     fprintf(stderr, "qemu: unsupported bluetooth device `%s'\n", devname);
1745     return 0;
1746 }
1747
1748 static int bt_parse(const char *opt)
1749 {
1750     const char *endp, *p;
1751     int vlan;
1752
1753     if (strstart(opt, "hci", &endp)) {
1754         if (!*endp || *endp == ',') {
1755             if (*endp)
1756                 if (!strstart(endp, ",vlan=", 0))
1757                     opt = endp + 1;
1758
1759             return bt_hci_parse(opt);
1760        }
1761     } else if (strstart(opt, "vhci", &endp)) {
1762         if (!*endp || *endp == ',') {
1763             if (*endp) {
1764                 if (strstart(endp, ",vlan=", &p)) {
1765                     vlan = strtol(p, (char **) &endp, 0);
1766                     if (*endp) {
1767                         fprintf(stderr, "qemu: bad scatternet '%s'\n", p);
1768                         return 1;
1769                     }
1770                 } else {
1771                     fprintf(stderr, "qemu: bad parameter '%s'\n", endp + 1);
1772                     return 1;
1773                 }
1774             } else
1775                 vlan = 0;
1776
1777             bt_vhci_add(vlan);
1778             return 0;
1779         }
1780     } else if (strstart(opt, "device:", &endp))
1781         return !bt_device_add(endp);
1782
1783     fprintf(stderr, "qemu: bad bluetooth parameter '%s'\n", opt);
1784     return 1;
1785 }
1786
1787 /***********************************************************/
1788 /* QEMU Block devices */
1789
1790 #define HD_ALIAS "index=%d,media=disk"
1791 #define CDROM_ALIAS "index=2,media=cdrom"
1792 #define FD_ALIAS "index=%d,if=floppy"
1793 #define PFLASH_ALIAS "if=pflash"
1794 #define MTD_ALIAS "if=mtd"
1795 #define SD_ALIAS "index=0,if=sd"
1796
1797 QemuOpts *drive_add(const char *file, const char *fmt, ...)
1798 {
1799     va_list ap;
1800     char optstr[1024];
1801     QemuOpts *opts;
1802
1803     va_start(ap, fmt);
1804     vsnprintf(optstr, sizeof(optstr), fmt, ap);
1805     va_end(ap);
1806
1807     opts = qemu_opts_parse(&qemu_drive_opts, optstr, NULL);
1808     if (!opts) {
1809         fprintf(stderr, "%s: huh? duplicate? (%s)\n",
1810                 __FUNCTION__, optstr);
1811         return NULL;
1812     }
1813     if (file)
1814         qemu_opt_set(opts, "file", file);
1815     return opts;
1816 }
1817
1818 DriveInfo *drive_get(BlockInterfaceType type, int bus, int unit)
1819 {
1820     DriveInfo *dinfo;
1821
1822     /* seek interface, bus and unit */
1823
1824     QTAILQ_FOREACH(dinfo, &drives, next) {
1825         if (dinfo->type == type &&
1826             dinfo->bus == bus &&
1827             dinfo->unit == unit)
1828             return dinfo;
1829     }
1830
1831     return NULL;
1832 }
1833
1834 DriveInfo *drive_get_by_id(const char *id)
1835 {
1836     DriveInfo *dinfo;
1837
1838     QTAILQ_FOREACH(dinfo, &drives, next) {
1839         if (strcmp(id, dinfo->id))
1840             continue;
1841         return dinfo;
1842     }
1843     return NULL;
1844 }
1845
1846 int drive_get_max_bus(BlockInterfaceType type)
1847 {
1848     int max_bus;
1849     DriveInfo *dinfo;
1850
1851     max_bus = -1;
1852     QTAILQ_FOREACH(dinfo, &drives, next) {
1853         if(dinfo->type == type &&
1854            dinfo->bus > max_bus)
1855             max_bus = dinfo->bus;
1856     }
1857     return max_bus;
1858 }
1859
1860 const char *drive_get_serial(BlockDriverState *bdrv)
1861 {
1862     DriveInfo *dinfo;
1863
1864     QTAILQ_FOREACH(dinfo, &drives, next) {
1865         if (dinfo->bdrv == bdrv)
1866             return dinfo->serial;
1867     }
1868
1869     return "\0";
1870 }
1871
1872 BlockInterfaceErrorAction drive_get_on_error(
1873     BlockDriverState *bdrv, int is_read)
1874 {
1875     DriveInfo *dinfo;
1876
1877     QTAILQ_FOREACH(dinfo, &drives, next) {
1878         if (dinfo->bdrv == bdrv)
1879             return is_read ? dinfo->on_read_error : dinfo->on_write_error;
1880     }
1881
1882     return is_read ? BLOCK_ERR_REPORT : BLOCK_ERR_STOP_ENOSPC;
1883 }
1884
1885 static void bdrv_format_print(void *opaque, const char *name)
1886 {
1887     fprintf(stderr, " %s", name);
1888 }
1889
1890 void drive_uninit(DriveInfo *dinfo)
1891 {
1892     qemu_opts_del(dinfo->opts);
1893     bdrv_delete(dinfo->bdrv);
1894     QTAILQ_REMOVE(&drives, dinfo, next);
1895     qemu_free(dinfo);
1896 }
1897
1898 static int parse_block_error_action(const char *buf, int is_read)
1899 {
1900     if (!strcmp(buf, "ignore")) {
1901         return BLOCK_ERR_IGNORE;
1902     } else if (!is_read && !strcmp(buf, "enospc")) {
1903         return BLOCK_ERR_STOP_ENOSPC;
1904     } else if (!strcmp(buf, "stop")) {
1905         return BLOCK_ERR_STOP_ANY;
1906     } else if (!strcmp(buf, "report")) {
1907         return BLOCK_ERR_REPORT;
1908     } else {
1909         fprintf(stderr, "qemu: '%s' invalid %s error action\n",
1910             buf, is_read ? "read" : "write");
1911         return -1;
1912     }
1913 }
1914
1915 DriveInfo *drive_init(QemuOpts *opts, void *opaque,
1916                       int *fatal_error)
1917 {
1918     const char *buf;
1919     const char *file = NULL;
1920     char devname[128];
1921     const char *serial;
1922     const char *mediastr = "";
1923     BlockInterfaceType type;
1924     enum { MEDIA_DISK, MEDIA_CDROM } media;
1925     int bus_id, unit_id;
1926     int cyls, heads, secs, translation;
1927     BlockDriver *drv = NULL;
1928     QEMUMachine *machine = opaque;
1929     int max_devs;
1930     int index;
1931     int cache;
1932     int aio = 0;
1933     int ro = 0;
1934     int bdrv_flags;
1935     int on_read_error, on_write_error;
1936     const char *devaddr;
1937     DriveInfo *dinfo;
1938     int snapshot = 0;
1939
1940     *fatal_error = 1;
1941
1942     translation = BIOS_ATA_TRANSLATION_AUTO;
1943     cache = 1;
1944
1945     if (machine && machine->use_scsi) {
1946         type = IF_SCSI;
1947         max_devs = MAX_SCSI_DEVS;
1948         pstrcpy(devname, sizeof(devname), "scsi");
1949     } else {
1950         type = IF_IDE;
1951         max_devs = MAX_IDE_DEVS;
1952         pstrcpy(devname, sizeof(devname), "ide");
1953     }
1954     media = MEDIA_DISK;
1955
1956     /* extract parameters */
1957     bus_id  = qemu_opt_get_number(opts, "bus", 0);
1958     unit_id = qemu_opt_get_number(opts, "unit", -1);
1959     index   = qemu_opt_get_number(opts, "index", -1);
1960
1961     cyls  = qemu_opt_get_number(opts, "cyls", 0);
1962     heads = qemu_opt_get_number(opts, "heads", 0);
1963     secs  = qemu_opt_get_number(opts, "secs", 0);
1964
1965     snapshot = qemu_opt_get_bool(opts, "snapshot", 0);
1966     ro = qemu_opt_get_bool(opts, "readonly", 0);
1967
1968     file = qemu_opt_get(opts, "file");
1969     serial = qemu_opt_get(opts, "serial");
1970
1971     if ((buf = qemu_opt_get(opts, "if")) != NULL) {
1972         pstrcpy(devname, sizeof(devname), buf);
1973         if (!strcmp(buf, "ide")) {
1974             type = IF_IDE;
1975             max_devs = MAX_IDE_DEVS;
1976         } else if (!strcmp(buf, "scsi")) {
1977             type = IF_SCSI;
1978             max_devs = MAX_SCSI_DEVS;
1979         } else if (!strcmp(buf, "floppy")) {
1980             type = IF_FLOPPY;
1981             max_devs = 0;
1982         } else if (!strcmp(buf, "pflash")) {
1983             type = IF_PFLASH;
1984             max_devs = 0;
1985         } else if (!strcmp(buf, "mtd")) {
1986             type = IF_MTD;
1987             max_devs = 0;
1988         } else if (!strcmp(buf, "sd")) {
1989             type = IF_SD;
1990             max_devs = 0;
1991         } else if (!strcmp(buf, "virtio")) {
1992             type = IF_VIRTIO;
1993             max_devs = 0;
1994         } else if (!strcmp(buf, "xen")) {
1995             type = IF_XEN;
1996             max_devs = 0;
1997         } else if (!strcmp(buf, "none")) {
1998             type = IF_NONE;
1999             max_devs = 0;
2000         } else {
2001             fprintf(stderr, "qemu: unsupported bus type '%s'\n", buf);
2002             return NULL;
2003         }
2004     }
2005
2006     if (cyls || heads || secs) {
2007         if (cyls < 1 || (type == IF_IDE && cyls > 16383)) {
2008             fprintf(stderr, "qemu: '%s' invalid physical cyls number\n", buf);
2009             return NULL;
2010         }
2011         if (heads < 1 || (type == IF_IDE && heads > 16)) {
2012             fprintf(stderr, "qemu: '%s' invalid physical heads number\n", buf);
2013             return NULL;
2014         }
2015         if (secs < 1 || (type == IF_IDE && secs > 63)) {
2016             fprintf(stderr, "qemu: '%s' invalid physical secs number\n", buf);
2017             return NULL;
2018         }
2019     }
2020
2021     if ((buf = qemu_opt_get(opts, "trans")) != NULL) {
2022         if (!cyls) {
2023             fprintf(stderr,
2024                     "qemu: '%s' trans must be used with cyls,heads and secs\n",
2025                     buf);
2026             return NULL;
2027         }
2028         if (!strcmp(buf, "none"))
2029             translation = BIOS_ATA_TRANSLATION_NONE;
2030         else if (!strcmp(buf, "lba"))
2031             translation = BIOS_ATA_TRANSLATION_LBA;
2032         else if (!strcmp(buf, "auto"))
2033             translation = BIOS_ATA_TRANSLATION_AUTO;
2034         else {
2035             fprintf(stderr, "qemu: '%s' invalid translation type\n", buf);
2036             return NULL;
2037         }
2038     }
2039
2040     if ((buf = qemu_opt_get(opts, "media")) != NULL) {
2041         if (!strcmp(buf, "disk")) {
2042             media = MEDIA_DISK;
2043         } else if (!strcmp(buf, "cdrom")) {
2044             if (cyls || secs || heads) {
2045                 fprintf(stderr,
2046                         "qemu: '%s' invalid physical CHS format\n", buf);
2047                 return NULL;
2048             }
2049             media = MEDIA_CDROM;
2050         } else {
2051             fprintf(stderr, "qemu: '%s' invalid media\n", buf);
2052             return NULL;
2053         }
2054     }
2055
2056     if ((buf = qemu_opt_get(opts, "cache")) != NULL) {
2057         if (!strcmp(buf, "off") || !strcmp(buf, "none"))
2058             cache = 0;
2059         else if (!strcmp(buf, "writethrough"))
2060             cache = 1;
2061         else if (!strcmp(buf, "writeback"))
2062             cache = 2;
2063         else {
2064            fprintf(stderr, "qemu: invalid cache option\n");
2065            return NULL;
2066         }
2067     }
2068
2069 #ifdef CONFIG_LINUX_AIO
2070     if ((buf = qemu_opt_get(opts, "aio")) != NULL) {
2071         if (!strcmp(buf, "threads"))
2072             aio = 0;
2073         else if (!strcmp(buf, "native"))
2074             aio = 1;
2075         else {
2076            fprintf(stderr, "qemu: invalid aio option\n");
2077            return NULL;
2078         }
2079     }
2080 #endif
2081
2082     if ((buf = qemu_opt_get(opts, "format")) != NULL) {
2083        if (strcmp(buf, "?") == 0) {
2084             fprintf(stderr, "qemu: Supported formats:");
2085             bdrv_iterate_format(bdrv_format_print, NULL);
2086             fprintf(stderr, "\n");
2087             return NULL;
2088         }
2089         drv = bdrv_find_whitelisted_format(buf);
2090         if (!drv) {
2091             fprintf(stderr, "qemu: '%s' invalid format\n", buf);
2092             return NULL;
2093         }
2094     }
2095
2096     on_write_error = BLOCK_ERR_STOP_ENOSPC;
2097     if ((buf = qemu_opt_get(opts, "werror")) != NULL) {
2098         if (type != IF_IDE && type != IF_SCSI && type != IF_VIRTIO) {
2099             fprintf(stderr, "werror is no supported by this format\n");
2100             return NULL;
2101         }
2102
2103         on_write_error = parse_block_error_action(buf, 0);
2104         if (on_write_error < 0) {
2105             return NULL;
2106         }
2107     }
2108
2109     on_read_error = BLOCK_ERR_REPORT;
2110     if ((buf = qemu_opt_get(opts, "rerror")) != NULL) {
2111         if (type != IF_IDE && type != IF_VIRTIO) {
2112             fprintf(stderr, "rerror is no supported by this format\n");
2113             return NULL;
2114         }
2115
2116         on_read_error = parse_block_error_action(buf, 1);
2117         if (on_read_error < 0) {
2118             return NULL;
2119         }
2120     }
2121
2122     if ((devaddr = qemu_opt_get(opts, "addr")) != NULL) {
2123         if (type != IF_VIRTIO) {
2124             fprintf(stderr, "addr is not supported\n");
2125             return NULL;
2126         }
2127     }
2128
2129     /* compute bus and unit according index */
2130
2131     if (index != -1) {
2132         if (bus_id != 0 || unit_id != -1) {
2133             fprintf(stderr,
2134                     "qemu: index cannot be used with bus and unit\n");
2135             return NULL;
2136         }
2137         if (max_devs == 0)
2138         {
2139             unit_id = index;
2140             bus_id = 0;
2141         } else {
2142             unit_id = index % max_devs;
2143             bus_id = index / max_devs;
2144         }
2145     }
2146
2147     /* if user doesn't specify a unit_id,
2148      * try to find the first free
2149      */
2150
2151     if (unit_id == -1) {
2152        unit_id = 0;
2153        while (drive_get(type, bus_id, unit_id) != NULL) {
2154            unit_id++;
2155            if (max_devs && unit_id >= max_devs) {
2156                unit_id -= max_devs;
2157                bus_id++;
2158            }
2159        }
2160     }
2161
2162     /* check unit id */
2163
2164     if (max_devs && unit_id >= max_devs) {
2165         fprintf(stderr, "qemu: unit %d too big (max is %d)\n",
2166                 unit_id, max_devs - 1);
2167         return NULL;
2168     }
2169
2170     /*
2171      * ignore multiple definitions
2172      */
2173
2174     if (drive_get(type, bus_id, unit_id) != NULL) {
2175         *fatal_error = 0;
2176         return NULL;
2177     }
2178
2179     /* init */
2180
2181     dinfo = qemu_mallocz(sizeof(*dinfo));
2182     if ((buf = qemu_opts_id(opts)) != NULL) {
2183         dinfo->id = qemu_strdup(buf);
2184     } else {
2185         /* no id supplied -> create one */
2186         dinfo->id = qemu_mallocz(32);
2187         if (type == IF_IDE || type == IF_SCSI)
2188             mediastr = (media == MEDIA_CDROM) ? "-cd" : "-hd";
2189         if (max_devs)
2190             snprintf(dinfo->id, 32, "%s%i%s%i",
2191                      devname, bus_id, mediastr, unit_id);
2192         else
2193             snprintf(dinfo->id, 32, "%s%s%i",
2194                      devname, mediastr, unit_id);
2195     }
2196     dinfo->bdrv = bdrv_new(dinfo->id);
2197     dinfo->devaddr = devaddr;
2198     dinfo->type = type;
2199     dinfo->bus = bus_id;
2200     dinfo->unit = unit_id;
2201     dinfo->on_read_error = on_read_error;
2202     dinfo->on_write_error = on_write_error;
2203     dinfo->opts = opts;
2204     if (serial)
2205         strncpy(dinfo->serial, serial, sizeof(serial));
2206     QTAILQ_INSERT_TAIL(&drives, dinfo, next);
2207
2208     switch(type) {
2209     case IF_IDE:
2210     case IF_SCSI:
2211     case IF_XEN:
2212     case IF_NONE:
2213         switch(media) {
2214         case MEDIA_DISK:
2215             if (cyls != 0) {
2216                 bdrv_set_geometry_hint(dinfo->bdrv, cyls, heads, secs);
2217                 bdrv_set_translation_hint(dinfo->bdrv, translation);
2218             }
2219             break;
2220         case MEDIA_CDROM:
2221             bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_CDROM);
2222             break;
2223         }
2224         break;
2225     case IF_SD:
2226         /* FIXME: This isn't really a floppy, but it's a reasonable
2227            approximation.  */
2228     case IF_FLOPPY:
2229         bdrv_set_type_hint(dinfo->bdrv, BDRV_TYPE_FLOPPY);
2230         break;
2231     case IF_PFLASH:
2232     case IF_MTD:
2233         break;
2234     case IF_VIRTIO:
2235         /* add virtio block device */
2236         opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
2237         qemu_opt_set(opts, "driver", "virtio-blk-pci");
2238         qemu_opt_set(opts, "drive", dinfo->id);
2239         if (devaddr)
2240             qemu_opt_set(opts, "addr", devaddr);
2241         break;
2242     case IF_COUNT:
2243         abort();
2244     }
2245     if (!file) {
2246         *fatal_error = 0;
2247         return NULL;
2248     }
2249     bdrv_flags = 0;
2250     if (snapshot) {
2251         bdrv_flags |= BDRV_O_SNAPSHOT;
2252         cache = 2; /* always use write-back with snapshot */
2253     }
2254     if (cache == 0) /* no caching */
2255         bdrv_flags |= BDRV_O_NOCACHE;
2256     else if (cache == 2) /* write-back */
2257         bdrv_flags |= BDRV_O_CACHE_WB;
2258
2259     if (aio == 1) {
2260         bdrv_flags |= BDRV_O_NATIVE_AIO;
2261     } else {
2262         bdrv_flags &= ~BDRV_O_NATIVE_AIO;
2263     }
2264
2265     if (ro == 1) {
2266         if (type != IF_SCSI && type != IF_VIRTIO && type != IF_FLOPPY) {
2267             fprintf(stderr, "qemu: readonly flag not supported for drive with this interface\n");
2268             return NULL;
2269         }
2270     }
2271     /*
2272      * cdrom is read-only. Set it now, after above interface checking
2273      * since readonly attribute not explicitly required, so no error.
2274      */
2275     if (media == MEDIA_CDROM) {
2276         ro = 1;
2277     }
2278     bdrv_flags |= ro ? 0 : BDRV_O_RDWR;
2279
2280     if (bdrv_open2(dinfo->bdrv, file, bdrv_flags, drv) < 0) {
2281         fprintf(stderr, "qemu: could not open disk image %s: %s\n",
2282                         file, strerror(errno));
2283         return NULL;
2284     }
2285
2286     if (bdrv_key_required(dinfo->bdrv))
2287         autostart = 0;
2288     *fatal_error = 0;
2289     return dinfo;
2290 }
2291
2292 static int drive_init_func(QemuOpts *opts, void *opaque)
2293 {
2294     QEMUMachine *machine = opaque;
2295     int fatal_error = 0;
2296
2297     if (drive_init(opts, machine, &fatal_error) == NULL) {
2298         if (fatal_error)
2299             return 1;
2300     }
2301     return 0;
2302 }
2303
2304 static int drive_enable_snapshot(QemuOpts *opts, void *opaque)
2305 {
2306     if (NULL == qemu_opt_get(opts, "snapshot")) {
2307         qemu_opt_set(opts, "snapshot", "on");
2308     }
2309     return 0;
2310 }
2311
2312 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
2313 {
2314     boot_set_handler = func;
2315     boot_set_opaque = opaque;
2316 }
2317
2318 int qemu_boot_set(const char *boot_devices)
2319 {
2320     if (!boot_set_handler) {
2321         return -EINVAL;
2322     }
2323     return boot_set_handler(boot_set_opaque, boot_devices);
2324 }
2325
2326 static int parse_bootdevices(char *devices)
2327 {
2328     /* We just do some generic consistency checks */
2329     const char *p;
2330     int bitmap = 0;
2331
2332     for (p = devices; *p != '\0'; p++) {
2333         /* Allowed boot devices are:
2334          * a-b: floppy disk drives
2335          * c-f: IDE disk drives
2336          * g-m: machine implementation dependant drives
2337          * n-p: network devices
2338          * It's up to each machine implementation to check if the given boot
2339          * devices match the actual hardware implementation and firmware
2340          * features.
2341          */
2342         if (*p < 'a' || *p > 'p') {
2343             fprintf(stderr, "Invalid boot device '%c'\n", *p);
2344             exit(1);
2345         }
2346         if (bitmap & (1 << (*p - 'a'))) {
2347             fprintf(stderr, "Boot device '%c' was given twice\n", *p);
2348             exit(1);
2349         }
2350         bitmap |= 1 << (*p - 'a');
2351     }
2352     return bitmap;
2353 }
2354
2355 static void restore_boot_devices(void *opaque)
2356 {
2357     char *standard_boot_devices = opaque;
2358
2359     qemu_boot_set(standard_boot_devices);
2360
2361     qemu_unregister_reset(restore_boot_devices, standard_boot_devices);
2362     qemu_free(standard_boot_devices);
2363 }
2364
2365 static void numa_add(const char *optarg)
2366 {
2367     char option[128];
2368     char *endptr;
2369     unsigned long long value, endvalue;
2370     int nodenr;
2371
2372     optarg = get_opt_name(option, 128, optarg, ',') + 1;
2373     if (!strcmp(option, "node")) {
2374         if (get_param_value(option, 128, "nodeid", optarg) == 0) {
2375             nodenr = nb_numa_nodes;
2376         } else {
2377             nodenr = strtoull(option, NULL, 10);
2378         }
2379
2380         if (get_param_value(option, 128, "mem", optarg) == 0) {
2381             node_mem[nodenr] = 0;
2382         } else {
2383             value = strtoull(option, &endptr, 0);
2384             switch (*endptr) {
2385             case 0: case 'M': case 'm':
2386                 value <<= 20;
2387                 break;
2388             case 'G': case 'g':
2389                 value <<= 30;
2390                 break;
2391             }
2392             node_mem[nodenr] = value;
2393         }
2394         if (get_param_value(option, 128, "cpus", optarg) == 0) {
2395             node_cpumask[nodenr] = 0;
2396         } else {
2397             value = strtoull(option, &endptr, 10);
2398             if (value >= 64) {
2399                 value = 63;
2400                 fprintf(stderr, "only 64 CPUs in NUMA mode supported.\n");
2401             } else {
2402                 if (*endptr == '-') {
2403                     endvalue = strtoull(endptr+1, &endptr, 10);
2404                     if (endvalue >= 63) {
2405                         endvalue = 62;
2406                         fprintf(stderr,
2407                             "only 63 CPUs in NUMA mode supported.\n");
2408                     }
2409                     value = (2ULL << endvalue) - (1ULL << value);
2410                 } else {
2411                     value = 1ULL << value;
2412                 }
2413             }
2414             node_cpumask[nodenr] = value;
2415         }
2416         nb_numa_nodes++;
2417     }
2418     return;
2419 }
2420
2421 static void smp_parse(const char *optarg)
2422 {
2423     int smp, sockets = 0, threads = 0, cores = 0;
2424     char *endptr;
2425     char option[128];
2426
2427     smp = strtoul(optarg, &endptr, 10);
2428     if (endptr != optarg) {
2429         if (*endptr == ',') {
2430             endptr++;
2431         }
2432     }
2433     if (get_param_value(option, 128, "sockets", endptr) != 0)
2434         sockets = strtoull(option, NULL, 10);
2435     if (get_param_value(option, 128, "cores", endptr) != 0)
2436         cores = strtoull(option, NULL, 10);
2437     if (get_param_value(option, 128, "threads", endptr) != 0)
2438         threads = strtoull(option, NULL, 10);
2439     if (get_param_value(option, 128, "maxcpus", endptr) != 0)
2440         max_cpus = strtoull(option, NULL, 10);
2441
2442     /* compute missing values, prefer sockets over cores over threads */
2443     if (smp == 0 || sockets == 0) {
2444         sockets = sockets > 0 ? sockets : 1;
2445         cores = cores > 0 ? cores : 1;
2446         threads = threads > 0 ? threads : 1;
2447         if (smp == 0) {
2448             smp = cores * threads * sockets;
2449         }
2450     } else {
2451         if (cores == 0) {
2452             threads = threads > 0 ? threads : 1;
2453             cores = smp / (sockets * threads);
2454         } else {
2455             if (sockets) {
2456                 threads = smp / (cores * sockets);
2457             }
2458         }
2459     }
2460     smp_cpus = smp;
2461     smp_cores = cores > 0 ? cores : 1;
2462     smp_threads = threads > 0 ? threads : 1;
2463     if (max_cpus == 0)
2464         max_cpus = smp_cpus;
2465 }
2466
2467 /***********************************************************/
2468 /* USB devices */
2469
2470 static int usb_device_add(const char *devname, int is_hotplug)
2471 {
2472     const char *p;
2473     USBDevice *dev = NULL;
2474
2475     if (!usb_enabled)
2476         return -1;
2477
2478     /* drivers with .usbdevice_name entry in USBDeviceInfo */
2479     dev = usbdevice_create(devname);
2480     if (dev)
2481         goto done;
2482
2483     /* the other ones */
2484     if (strstart(devname, "host:", &p)) {
2485         dev = usb_host_device_open(p);
2486     } else if (!strcmp(devname, "bt") || strstart(devname, "bt:", &p)) {
2487         dev = usb_bt_init(devname[2] ? hci_init(p) :
2488                         bt_new_hci(qemu_find_bt_vlan(0)));
2489     } else {
2490         return -1;
2491     }
2492     if (!dev)
2493         return -1;
2494
2495 done:
2496     return 0;
2497 }
2498
2499 static int usb_device_del(const char *devname)
2500 {
2501     int bus_num, addr;
2502     const char *p;
2503
2504     if (strstart(devname, "host:", &p))
2505         return usb_host_device_close(p);
2506
2507     if (!usb_enabled)
2508         return -1;
2509
2510     p = strchr(devname, '.');
2511     if (!p)
2512         return -1;
2513     bus_num = strtoul(devname, NULL, 0);
2514     addr = strtoul(p + 1, NULL, 0);
2515
2516     return usb_device_delete_addr(bus_num, addr);
2517 }
2518
2519 static int usb_parse(const char *cmdline)
2520 {
2521     int r;
2522     r = usb_device_add(cmdline, 0);
2523     if (r < 0) {
2524         fprintf(stderr, "qemu: could not add USB device '%s'\n", cmdline);
2525     }
2526     return r;
2527 }
2528
2529 void do_usb_add(Monitor *mon, const QDict *qdict)
2530 {
2531     const char *devname = qdict_get_str(qdict, "devname");
2532     if (usb_device_add(devname, 1) < 0) {
2533         qemu_error("could not add USB device '%s'\n", devname);
2534     }
2535 }
2536
2537 void do_usb_del(Monitor *mon, const QDict *qdict)
2538 {
2539     const char *devname = qdict_get_str(qdict, "devname");
2540     if (usb_device_del(devname) < 0) {
2541         qemu_error("could not delete USB device '%s'\n", devname);
2542     }
2543 }
2544
2545 /***********************************************************/
2546 /* PCMCIA/Cardbus */
2547
2548 static struct pcmcia_socket_entry_s {
2549     PCMCIASocket *socket;
2550     struct pcmcia_socket_entry_s *next;
2551 } *pcmcia_sockets = 0;
2552
2553 void pcmcia_socket_register(PCMCIASocket *socket)
2554 {
2555     struct pcmcia_socket_entry_s *entry;
2556
2557     entry = qemu_malloc(sizeof(struct pcmcia_socket_entry_s));
2558     entry->socket = socket;
2559     entry->next = pcmcia_sockets;
2560     pcmcia_sockets = entry;
2561 }
2562
2563 void pcmcia_socket_unregister(PCMCIASocket *socket)
2564 {
2565     struct pcmcia_socket_entry_s *entry, **ptr;
2566
2567     ptr = &pcmcia_sockets;
2568     for (entry = *ptr; entry; ptr = &entry->next, entry = *ptr)
2569         if (entry->socket == socket) {
2570             *ptr = entry->next;
2571             qemu_free(entry);
2572         }
2573 }
2574
2575 void pcmcia_info(Monitor *mon)
2576 {
2577     struct pcmcia_socket_entry_s *iter;
2578
2579     if (!pcmcia_sockets)
2580         monitor_printf(mon, "No PCMCIA sockets\n");
2581
2582     for (iter = pcmcia_sockets; iter; iter = iter->next)
2583         monitor_printf(mon, "%s: %s\n", iter->socket->slot_string,
2584                        iter->socket->attached ? iter->socket->card_string :
2585                        "Empty");
2586 }
2587
2588 /***********************************************************/
2589 /* I/O handling */
2590
2591 typedef struct IOHandlerRecord {
2592     int fd;
2593     IOCanRWHandler *fd_read_poll;
2594     IOHandler *fd_read;
2595     IOHandler *fd_write;
2596     int deleted;
2597     void *opaque;
2598     /* temporary data */
2599     struct pollfd *ufd;
2600     struct IOHandlerRecord *next;
2601 } IOHandlerRecord;
2602
2603 static IOHandlerRecord *first_io_handler;
2604
2605 /* XXX: fd_read_poll should be suppressed, but an API change is
2606    necessary in the character devices to suppress fd_can_read(). */
2607 int qemu_set_fd_handler2(int fd,
2608                          IOCanRWHandler *fd_read_poll,
2609                          IOHandler *fd_read,
2610                          IOHandler *fd_write,
2611                          void *opaque)
2612 {
2613     IOHandlerRecord **pioh, *ioh;
2614
2615     if (!fd_read && !fd_write) {
2616         pioh = &first_io_handler;
2617         for(;;) {
2618             ioh = *pioh;
2619             if (ioh == NULL)
2620                 break;
2621             if (ioh->fd == fd) {
2622                 ioh->deleted = 1;
2623                 break;
2624             }
2625             pioh = &ioh->next;
2626         }
2627     } else {
2628         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
2629             if (ioh->fd == fd)
2630                 goto found;
2631         }
2632         ioh = qemu_mallocz(sizeof(IOHandlerRecord));
2633         ioh->next = first_io_handler;
2634         first_io_handler = ioh;
2635     found:
2636         ioh->fd = fd;
2637         ioh->fd_read_poll = fd_read_poll;
2638         ioh->fd_read = fd_read;
2639         ioh->fd_write = fd_write;
2640         ioh->opaque = opaque;
2641         ioh->deleted = 0;
2642     }
2643     return 0;
2644 }
2645
2646 int qemu_set_fd_handler(int fd,
2647                         IOHandler *fd_read,
2648                         IOHandler *fd_write,
2649                         void *opaque)
2650 {
2651     return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
2652 }
2653
2654 #ifdef _WIN32
2655 /***********************************************************/
2656 /* Polling handling */
2657
2658 typedef struct PollingEntry {
2659     PollingFunc *func;
2660     void *opaque;
2661     struct PollingEntry *next;
2662 } PollingEntry;
2663
2664 static PollingEntry *first_polling_entry;
2665
2666 int qemu_add_polling_cb(PollingFunc *func, void *opaque)
2667 {
2668     PollingEntry **ppe, *pe;
2669     pe = qemu_mallocz(sizeof(PollingEntry));
2670     pe->func = func;
2671     pe->opaque = opaque;
2672     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next);
2673     *ppe = pe;
2674     return 0;
2675 }
2676
2677 void qemu_del_polling_cb(PollingFunc *func, void *opaque)
2678 {
2679     PollingEntry **ppe, *pe;
2680     for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) {
2681         pe = *ppe;
2682         if (pe->func == func && pe->opaque == opaque) {
2683             *ppe = pe->next;
2684             qemu_free(pe);
2685             break;
2686         }
2687     }
2688 }
2689
2690 /***********************************************************/
2691 /* Wait objects support */
2692 typedef struct WaitObjects {
2693     int num;
2694     HANDLE events[MAXIMUM_WAIT_OBJECTS + 1];
2695     WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1];
2696     void *opaque[MAXIMUM_WAIT_OBJECTS + 1];
2697 } WaitObjects;
2698
2699 static WaitObjects wait_objects = {0};
2700
2701 int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2702 {
2703     WaitObjects *w = &wait_objects;
2704
2705     if (w->num >= MAXIMUM_WAIT_OBJECTS)
2706         return -1;
2707     w->events[w->num] = handle;
2708     w->func[w->num] = func;
2709     w->opaque[w->num] = opaque;
2710     w->num++;
2711     return 0;
2712 }
2713
2714 void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque)
2715 {
2716     int i, found;
2717     WaitObjects *w = &wait_objects;
2718
2719     found = 0;
2720     for (i = 0; i < w->num; i++) {
2721         if (w->events[i] == handle)
2722             found = 1;
2723         if (found) {
2724             w->events[i] = w->events[i + 1];
2725             w->func[i] = w->func[i + 1];
2726             w->opaque[i] = w->opaque[i + 1];
2727         }
2728     }
2729     if (found)
2730         w->num--;
2731 }
2732 #endif
2733
2734 /***********************************************************/
2735 /* ram save/restore */
2736
2737 #define RAM_SAVE_FLAG_FULL      0x01 /* Obsolete, not used anymore */
2738 #define RAM_SAVE_FLAG_COMPRESS  0x02
2739 #define RAM_SAVE_FLAG_MEM_SIZE  0x04
2740 #define RAM_SAVE_FLAG_PAGE      0x08
2741 #define RAM_SAVE_FLAG_EOS       0x10
2742
2743 static int is_dup_page(uint8_t *page, uint8_t ch)
2744 {
2745     uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
2746     uint32_t *array = (uint32_t *)page;
2747     int i;
2748
2749     for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
2750         if (array[i] != val)
2751             return 0;
2752     }
2753
2754     return 1;
2755 }
2756
2757 static int ram_save_block(QEMUFile *f)
2758 {
2759     static ram_addr_t current_addr = 0;
2760     ram_addr_t saved_addr = current_addr;
2761     ram_addr_t addr = 0;
2762     int found = 0;
2763
2764     while (addr < last_ram_offset) {
2765         if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
2766             uint8_t *p;
2767
2768             cpu_physical_memory_reset_dirty(current_addr,
2769                                             current_addr + TARGET_PAGE_SIZE,
2770                                             MIGRATION_DIRTY_FLAG);
2771
2772             p = qemu_get_ram_ptr(current_addr);
2773
2774             if (is_dup_page(p, *p)) {
2775                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
2776                 qemu_put_byte(f, *p);
2777             } else {
2778                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
2779                 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
2780             }
2781
2782             found = 1;
2783             break;
2784         }
2785         addr += TARGET_PAGE_SIZE;
2786         current_addr = (saved_addr + addr) % last_ram_offset;
2787     }
2788
2789     return found;
2790 }
2791
2792 static uint64_t bytes_transferred;
2793
2794 static ram_addr_t ram_save_remaining(void)
2795 {
2796     ram_addr_t addr;
2797     ram_addr_t count = 0;
2798
2799     for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2800         if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2801             count++;
2802     }
2803
2804     return count;
2805 }
2806
2807 uint64_t ram_bytes_remaining(void)
2808 {
2809     return ram_save_remaining() * TARGET_PAGE_SIZE;
2810 }
2811
2812 uint64_t ram_bytes_transferred(void)
2813 {
2814     return bytes_transferred;
2815 }
2816
2817 uint64_t ram_bytes_total(void)
2818 {
2819     return last_ram_offset;
2820 }
2821
2822 static int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
2823 {
2824     ram_addr_t addr;
2825     uint64_t bytes_transferred_last;
2826     double bwidth = 0;
2827     uint64_t expected_time = 0;
2828
2829     if (stage < 0) {
2830         cpu_physical_memory_set_dirty_tracking(0);
2831         return 0;
2832     }
2833
2834     if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
2835         qemu_file_set_error(f);
2836         return 0;
2837     }
2838
2839     if (stage == 1) {
2840         bytes_transferred = 0;
2841
2842         /* Make sure all dirty bits are set */
2843         for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2844             if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2845                 cpu_physical_memory_set_dirty(addr);
2846         }
2847
2848         /* Enable dirty memory tracking */
2849         cpu_physical_memory_set_dirty_tracking(1);
2850
2851         qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
2852     }
2853
2854     bytes_transferred_last = bytes_transferred;
2855     bwidth = qemu_get_clock_ns(rt_clock);
2856
2857     while (!qemu_file_rate_limit(f)) {
2858         int ret;
2859
2860         ret = ram_save_block(f);
2861         bytes_transferred += ret * TARGET_PAGE_SIZE;
2862         if (ret == 0) /* no more blocks */
2863             break;
2864     }
2865
2866     bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
2867     bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
2868
2869     /* if we haven't transferred anything this round, force expected_time to a
2870      * a very high value, but without crashing */
2871     if (bwidth == 0)
2872         bwidth = 0.000001;
2873
2874     /* try transferring iterative blocks of memory */
2875     if (stage == 3) {
2876         /* flush all remaining blocks regardless of rate limiting */
2877         while (ram_save_block(f) != 0) {
2878             bytes_transferred += TARGET_PAGE_SIZE;
2879         }
2880         cpu_physical_memory_set_dirty_tracking(0);
2881     }
2882
2883     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
2884
2885     expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
2886
2887     return (stage == 2) && (expected_time <= migrate_max_downtime());
2888 }
2889
2890 static int ram_load(QEMUFile *f, void *opaque, int version_id)
2891 {
2892     ram_addr_t addr;
2893     int flags;
2894
2895     if (version_id != 3)
2896         return -EINVAL;
2897
2898     do {
2899         addr = qemu_get_be64(f);
2900
2901         flags = addr & ~TARGET_PAGE_MASK;
2902         addr &= TARGET_PAGE_MASK;
2903
2904         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
2905             if (addr != last_ram_offset)
2906                 return -EINVAL;
2907         }
2908
2909         if (flags & RAM_SAVE_FLAG_COMPRESS) {
2910             uint8_t ch = qemu_get_byte(f);
2911             memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
2912 #ifndef _WIN32
2913             if (ch == 0 &&
2914                 (!kvm_enabled() || kvm_has_sync_mmu())) {
2915                 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
2916             }
2917 #endif
2918         } else if (flags & RAM_SAVE_FLAG_PAGE) {
2919             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
2920         }
2921         if (qemu_file_has_error(f)) {
2922             return -EIO;
2923         }
2924     } while (!(flags & RAM_SAVE_FLAG_EOS));
2925
2926     return 0;
2927 }
2928
2929 void qemu_service_io(void)
2930 {
2931     qemu_notify_event();
2932 }
2933
2934 /***********************************************************/
2935 /* machine registration */
2936
2937 static QEMUMachine *first_machine = NULL;
2938 QEMUMachine *current_machine = NULL;
2939
2940 int qemu_register_machine(QEMUMachine *m)
2941 {
2942     QEMUMachine **pm;
2943     pm = &first_machine;
2944     while (*pm != NULL)
2945         pm = &(*pm)->next;
2946     m->next = NULL;
2947     *pm = m;
2948     return 0;
2949 }
2950
2951 static QEMUMachine *find_machine(const char *name)
2952 {
2953     QEMUMachine *m;
2954
2955     for(m = first_machine; m != NULL; m = m->next) {
2956         if (!strcmp(m->name, name))
2957             return m;
2958         if (m->alias && !strcmp(m->alias, name))
2959             return m;
2960     }
2961     return NULL;
2962 }
2963
2964 static QEMUMachine *find_default_machine(void)
2965 {
2966     QEMUMachine *m;
2967
2968     for(m = first_machine; m != NULL; m = m->next) {
2969         if (m->is_default) {
2970             return m;
2971         }
2972     }
2973     return NULL;
2974 }
2975
2976 /***********************************************************/
2977 /* main execution loop */
2978
2979 static void gui_update(void *opaque)
2980 {
2981     uint64_t interval = GUI_REFRESH_INTERVAL;
2982     DisplayState *ds = opaque;
2983     DisplayChangeListener *dcl = ds->listeners;
2984
2985     qemu_flush_coalesced_mmio_buffer();
2986     dpy_refresh(ds);
2987
2988     while (dcl != NULL) {
2989         if (dcl->gui_timer_interval &&
2990             dcl->gui_timer_interval < interval)
2991             interval = dcl->gui_timer_interval;
2992         dcl = dcl->next;
2993     }
2994     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
2995 }
2996
2997 static void nographic_update(void *opaque)
2998 {
2999     uint64_t interval = GUI_REFRESH_INTERVAL;
3000
3001     qemu_flush_coalesced_mmio_buffer();
3002     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3003 }
3004
3005 void cpu_synchronize_all_states(void)
3006 {
3007     CPUState *cpu;
3008
3009     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
3010         cpu_synchronize_state(cpu);
3011     }
3012 }
3013
3014 void cpu_synchronize_all_post_reset(void)
3015 {
3016     CPUState *cpu;
3017
3018     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
3019         cpu_synchronize_post_reset(cpu);
3020     }
3021 }
3022
3023 void cpu_synchronize_all_post_init(void)
3024 {
3025     CPUState *cpu;
3026
3027     for (cpu = first_cpu; cpu; cpu = cpu->next_cpu) {
3028         cpu_synchronize_post_init(cpu);
3029     }
3030 }
3031
3032 struct vm_change_state_entry {
3033     VMChangeStateHandler *cb;
3034     void *opaque;
3035     QLIST_ENTRY (vm_change_state_entry) entries;
3036 };
3037
3038 static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3039
3040 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3041                                                      void *opaque)
3042 {
3043     VMChangeStateEntry *e;
3044
3045     e = qemu_mallocz(sizeof (*e));
3046
3047     e->cb = cb;
3048     e->opaque = opaque;
3049     QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3050     return e;
3051 }
3052
3053 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3054 {
3055     QLIST_REMOVE (e, entries);
3056     qemu_free (e);
3057 }
3058
3059 static void vm_state_notify(int running, int reason)
3060 {
3061     VMChangeStateEntry *e;
3062
3063     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3064         e->cb(e->opaque, running, reason);
3065     }
3066 }
3067
3068 static void resume_all_vcpus(void);
3069 static void pause_all_vcpus(void);
3070
3071 void vm_start(void)
3072 {
3073     if (!vm_running) {
3074         cpu_enable_ticks();
3075         vm_running = 1;
3076         vm_state_notify(1, 0);
3077         qemu_rearm_alarm_timer(alarm_timer);
3078         resume_all_vcpus();
3079     }
3080 }
3081
3082 /* reset/shutdown handler */
3083
3084 typedef struct QEMUResetEntry {
3085     QTAILQ_ENTRY(QEMUResetEntry) entry;
3086     QEMUResetHandler *func;
3087     void *opaque;
3088 } QEMUResetEntry;
3089
3090 static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
3091     QTAILQ_HEAD_INITIALIZER(reset_handlers);
3092 static int reset_requested;
3093 static int shutdown_requested;
3094 static int powerdown_requested;
3095 static int debug_requested;
3096 static int vmstop_requested;
3097
3098 int qemu_shutdown_requested(void)
3099 {
3100     int r = shutdown_requested;
3101     shutdown_requested = 0;
3102     return r;
3103 }
3104
3105 int qemu_reset_requested(void)
3106 {
3107     int r = reset_requested;
3108     reset_requested = 0;
3109     return r;
3110 }
3111
3112 int qemu_powerdown_requested(void)
3113 {
3114     int r = powerdown_requested;
3115     powerdown_requested = 0;
3116     return r;
3117 }
3118
3119 static int qemu_debug_requested(void)
3120 {
3121     int r = debug_requested;
3122     debug_requested = 0;
3123     return r;
3124 }
3125
3126 static int qemu_vmstop_requested(void)
3127 {
3128     int r = vmstop_requested;
3129     vmstop_requested = 0;
3130     return r;
3131 }
3132
3133 static void do_vm_stop(int reason)
3134 {
3135     if (vm_running) {
3136         cpu_disable_ticks();
3137         vm_running = 0;
3138         pause_all_vcpus();
3139         vm_state_notify(0, reason);
3140         monitor_protocol_event(QEVENT_STOP, NULL);
3141     }
3142
3143     monitor_protocol_event(QEVENT_RESET, NULL);
3144 }
3145
3146 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3147 {
3148     QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
3149
3150     re->func = func;
3151     re->opaque = opaque;
3152     QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
3153 }
3154
3155 void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
3156 {
3157     QEMUResetEntry *re;
3158
3159     QTAILQ_FOREACH(re, &reset_handlers, entry) {
3160         if (re->func == func && re->opaque == opaque) {
3161             QTAILQ_REMOVE(&reset_handlers, re, entry);
3162             qemu_free(re);
3163             return;
3164         }
3165     }
3166 }
3167
3168 void qemu_system_reset(void)
3169 {
3170     QEMUResetEntry *re, *nre;
3171
3172     /* reset all devices */
3173     QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
3174         re->func(re->opaque);
3175     }
3176     cpu_synchronize_all_post_reset();
3177 }
3178
3179 void qemu_system_reset_request(void)
3180 {
3181     if (no_reboot) {
3182         shutdown_requested = 1;
3183     } else {
3184         reset_requested = 1;
3185     }
3186     qemu_notify_event();
3187 }
3188
3189 void qemu_system_shutdown_request(void)
3190 {
3191     shutdown_requested = 1;
3192     qemu_notify_event();
3193 }
3194
3195 void qemu_system_powerdown_request(void)
3196 {
3197     powerdown_requested = 1;
3198     qemu_notify_event();
3199 }
3200
3201 #ifdef CONFIG_IOTHREAD
3202 static void qemu_system_vmstop_request(int reason)
3203 {
3204     vmstop_requested = reason;
3205     qemu_notify_event();
3206 }
3207 #endif
3208
3209 #ifndef _WIN32
3210 static int io_thread_fd = -1;
3211
3212 static void qemu_event_increment(void)
3213 {
3214     /* Write 8 bytes to be compatible with eventfd.  */
3215     static uint64_t val = 1;
3216     ssize_t ret;
3217
3218     if (io_thread_fd == -1)
3219         return;
3220
3221     do {
3222         ret = write(io_thread_fd, &val, sizeof(val));
3223     } while (ret < 0 && errno == EINTR);
3224
3225     /* EAGAIN is fine, a read must be pending.  */
3226     if (ret < 0 && errno != EAGAIN) {
3227         fprintf(stderr, "qemu_event_increment: write() filed: %s\n",
3228                 strerror(errno));
3229         exit (1);
3230     }
3231 }
3232
3233 static void qemu_event_read(void *opaque)
3234 {
3235     int fd = (unsigned long)opaque;
3236     ssize_t len;
3237     char buffer[512];
3238
3239     /* Drain the notify pipe.  For eventfd, only 8 bytes will be read.  */
3240     do {
3241         len = read(fd, buffer, sizeof(buffer));
3242     } while ((len == -1 && errno == EINTR) || len == sizeof(buffer));
3243 }
3244
3245 static int qemu_event_init(void)
3246 {
3247     int err;
3248     int fds[2];
3249
3250     err = qemu_eventfd(fds);
3251     if (err == -1)
3252         return -errno;
3253
3254     err = fcntl_setfl(fds[0], O_NONBLOCK);
3255     if (err < 0)
3256         goto fail;
3257
3258     err = fcntl_setfl(fds[1], O_NONBLOCK);
3259     if (err < 0)
3260         goto fail;
3261
3262     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3263                          (void *)(unsigned long)fds[0]);
3264
3265     io_thread_fd = fds[1];
3266     return 0;
3267
3268 fail:
3269     close(fds[0]);
3270     close(fds[1]);
3271     return err;
3272 }
3273 #else
3274 HANDLE qemu_event_handle;
3275
3276 static void dummy_event_handler(void *opaque)
3277 {
3278 }
3279
3280 static int qemu_event_init(void)
3281 {
3282     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3283     if (!qemu_event_handle) {
3284         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
3285         return -1;
3286     }
3287     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3288     return 0;
3289 }
3290
3291 static void qemu_event_increment(void)
3292 {
3293     if (!SetEvent(qemu_event_handle)) {
3294         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
3295                 GetLastError());
3296         exit (1);
3297     }
3298 }
3299 #endif
3300
3301 static int cpu_can_run(CPUState *env)
3302 {
3303     if (env->stop)
3304         return 0;
3305     if (env->stopped)
3306         return 0;
3307     if (!vm_running)
3308         return 0;
3309     return 1;
3310 }
3311
3312 #ifndef CONFIG_IOTHREAD
3313 static int qemu_init_main_loop(void)
3314 {
3315     return qemu_event_init();
3316 }
3317
3318 void qemu_init_vcpu(void *_env)
3319 {
3320     CPUState *env = _env;
3321
3322     env->nr_cores = smp_cores;
3323     env->nr_threads = smp_threads;
3324     if (kvm_enabled())
3325         kvm_init_vcpu(env);
3326     return;
3327 }
3328
3329 int qemu_cpu_self(void *env)
3330 {
3331     return 1;
3332 }
3333
3334 static void resume_all_vcpus(void)
3335 {
3336 }
3337
3338 static void pause_all_vcpus(void)
3339 {
3340 }
3341
3342 void qemu_cpu_kick(void *env)
3343 {
3344     return;
3345 }
3346
3347 void qemu_notify_event(void)
3348 {
3349     CPUState *env = cpu_single_env;
3350
3351     if (env) {
3352         cpu_exit(env);
3353     }
3354 }
3355
3356 void qemu_mutex_lock_iothread(void) {}
3357 void qemu_mutex_unlock_iothread(void) {}
3358
3359 void vm_stop(int reason)
3360 {
3361     do_vm_stop(reason);
3362 }
3363
3364 #else /* CONFIG_IOTHREAD */
3365
3366 #include "qemu-thread.h"
3367
3368 QemuMutex qemu_global_mutex;
3369 static QemuMutex qemu_fair_mutex;
3370
3371 static QemuThread io_thread;
3372
3373 static QemuThread *tcg_cpu_thread;
3374 static QemuCond *tcg_halt_cond;
3375
3376 static int qemu_system_ready;
3377 /* cpu creation */
3378 static QemuCond qemu_cpu_cond;
3379 /* system init */
3380 static QemuCond qemu_system_cond;
3381 static QemuCond qemu_pause_cond;
3382
3383 static void tcg_block_io_signals(void);
3384 static void kvm_block_io_signals(CPUState *env);
3385 static void unblock_io_signals(void);
3386 static int tcg_has_work(void);
3387 static int cpu_has_work(CPUState *env);
3388
3389 static int qemu_init_main_loop(void)
3390 {
3391     int ret;
3392
3393     ret = qemu_event_init();
3394     if (ret)
3395         return ret;
3396
3397     qemu_cond_init(&qemu_pause_cond);
3398     qemu_mutex_init(&qemu_fair_mutex);
3399     qemu_mutex_init(&qemu_global_mutex);
3400     qemu_mutex_lock(&qemu_global_mutex);
3401
3402     unblock_io_signals();
3403     qemu_thread_self(&io_thread);
3404
3405     return 0;
3406 }
3407
3408 static void qemu_wait_io_event_common(CPUState *env)
3409 {
3410     if (env->stop) {
3411         env->stop = 0;
3412         env->stopped = 1;
3413         qemu_cond_signal(&qemu_pause_cond);
3414     }
3415 }
3416
3417 static void qemu_wait_io_event(CPUState *env)
3418 {
3419     while (!tcg_has_work())
3420         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3421
3422     qemu_mutex_unlock(&qemu_global_mutex);
3423
3424     /*
3425      * Users of qemu_global_mutex can be starved, having no chance
3426      * to acquire it since this path will get to it first.
3427      * So use another lock to provide fairness.
3428      */
3429     qemu_mutex_lock(&qemu_fair_mutex);
3430     qemu_mutex_unlock(&qemu_fair_mutex);
3431
3432     qemu_mutex_lock(&qemu_global_mutex);
3433     qemu_wait_io_event_common(env);
3434 }
3435
3436 static void qemu_kvm_eat_signal(CPUState *env, int timeout)
3437 {
3438     struct timespec ts;
3439     int r, e;
3440     siginfo_t siginfo;
3441     sigset_t waitset;
3442
3443     ts.tv_sec = timeout / 1000;
3444     ts.tv_nsec = (timeout % 1000) * 1000000;
3445
3446     sigemptyset(&waitset);
3447     sigaddset(&waitset, SIG_IPI);
3448
3449     qemu_mutex_unlock(&qemu_global_mutex);
3450     r = sigtimedwait(&waitset, &siginfo, &ts);
3451     e = errno;
3452     qemu_mutex_lock(&qemu_global_mutex);
3453
3454     if (r == -1 && !(e == EAGAIN || e == EINTR)) {
3455         fprintf(stderr, "sigtimedwait: %s\n", strerror(e));
3456         exit(1);
3457     }
3458 }
3459
3460 static void qemu_kvm_wait_io_event(CPUState *env)
3461 {
3462     while (!cpu_has_work(env))
3463         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3464
3465     qemu_kvm_eat_signal(env, 0);
3466     qemu_wait_io_event_common(env);
3467 }
3468
3469 static int qemu_cpu_exec(CPUState *env);
3470
3471 static void *kvm_cpu_thread_fn(void *arg)
3472 {
3473     CPUState *env = arg;
3474
3475     qemu_thread_self(env->thread);
3476     if (kvm_enabled())
3477         kvm_init_vcpu(env);
3478
3479     kvm_block_io_signals(env);
3480
3481     /* signal CPU creation */
3482     qemu_mutex_lock(&qemu_global_mutex);
3483     env->created = 1;
3484     qemu_cond_signal(&qemu_cpu_cond);
3485
3486     /* and wait for machine initialization */
3487     while (!qemu_system_ready)
3488         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3489
3490     while (1) {
3491         if (cpu_can_run(env))
3492             qemu_cpu_exec(env);
3493         qemu_kvm_wait_io_event(env);
3494     }
3495
3496     return NULL;
3497 }
3498
3499 static void tcg_cpu_exec(void);
3500
3501 static void *tcg_cpu_thread_fn(void *arg)
3502 {
3503     CPUState *env = arg;
3504
3505     tcg_block_io_signals();
3506     qemu_thread_self(env->thread);
3507
3508     /* signal CPU creation */
3509     qemu_mutex_lock(&qemu_global_mutex);
3510     for (env = first_cpu; env != NULL; env = env->next_cpu)
3511         env->created = 1;
3512     qemu_cond_signal(&qemu_cpu_cond);
3513
3514     /* and wait for machine initialization */
3515     while (!qemu_system_ready)
3516         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3517
3518     while (1) {
3519         tcg_cpu_exec();
3520         qemu_wait_io_event(cur_cpu);
3521     }
3522
3523     return NULL;
3524 }
3525
3526 void qemu_cpu_kick(void *_env)
3527 {
3528     CPUState *env = _env;
3529     qemu_cond_broadcast(env->halt_cond);
3530     if (kvm_enabled())
3531         qemu_thread_signal(env->thread, SIG_IPI);
3532 }
3533
3534 int qemu_cpu_self(void *_env)
3535 {
3536     CPUState *env = _env;
3537     QemuThread this;
3538
3539     qemu_thread_self(&this);
3540
3541     return qemu_thread_equal(&this, env->thread);
3542 }
3543
3544 static void cpu_signal(int sig)
3545 {
3546     if (cpu_single_env)
3547         cpu_exit(cpu_single_env);
3548 }
3549
3550 static void tcg_block_io_signals(void)
3551 {
3552     sigset_t set;
3553     struct sigaction sigact;
3554
3555     sigemptyset(&set);
3556     sigaddset(&set, SIGUSR2);
3557     sigaddset(&set, SIGIO);
3558     sigaddset(&set, SIGALRM);
3559     sigaddset(&set, SIGCHLD);
3560     pthread_sigmask(SIG_BLOCK, &set, NULL);
3561
3562     sigemptyset(&set);
3563     sigaddset(&set, SIG_IPI);
3564     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3565
3566     memset(&sigact, 0, sizeof(sigact));
3567     sigact.sa_handler = cpu_signal;
3568     sigaction(SIG_IPI, &sigact, NULL);
3569 }
3570
3571 static void dummy_signal(int sig)
3572 {
3573 }
3574
3575 static void kvm_block_io_signals(CPUState *env)
3576 {
3577     int r;
3578     sigset_t set;
3579     struct sigaction sigact;
3580
3581     sigemptyset(&set);
3582     sigaddset(&set, SIGUSR2);
3583     sigaddset(&set, SIGIO);
3584     sigaddset(&set, SIGALRM);
3585     sigaddset(&set, SIGCHLD);
3586     sigaddset(&set, SIG_IPI);
3587     pthread_sigmask(SIG_BLOCK, &set, NULL);
3588
3589     pthread_sigmask(SIG_BLOCK, NULL, &set);
3590     sigdelset(&set, SIG_IPI);
3591
3592     memset(&sigact, 0, sizeof(sigact));
3593     sigact.sa_handler = dummy_signal;
3594     sigaction(SIG_IPI, &sigact, NULL);
3595
3596     r = kvm_set_signal_mask(env, &set);
3597     if (r) {
3598         fprintf(stderr, "kvm_set_signal_mask: %s\n", strerror(r));
3599         exit(1);
3600     }
3601 }
3602
3603 static void unblock_io_signals(void)
3604 {
3605     sigset_t set;
3606
3607     sigemptyset(&set);
3608     sigaddset(&set, SIGUSR2);
3609     sigaddset(&set, SIGIO);
3610     sigaddset(&set, SIGALRM);
3611     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3612
3613     sigemptyset(&set);
3614     sigaddset(&set, SIG_IPI);
3615     pthread_sigmask(SIG_BLOCK, &set, NULL);
3616 }
3617
3618 static void qemu_signal_lock(unsigned int msecs)
3619 {
3620     qemu_mutex_lock(&qemu_fair_mutex);
3621
3622     while (qemu_mutex_trylock(&qemu_global_mutex)) {
3623         qemu_thread_signal(tcg_cpu_thread, SIG_IPI);
3624         if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
3625             break;
3626     }
3627     qemu_mutex_unlock(&qemu_fair_mutex);
3628 }
3629
3630 void qemu_mutex_lock_iothread(void)
3631 {
3632     if (kvm_enabled()) {
3633         qemu_mutex_lock(&qemu_fair_mutex);
3634         qemu_mutex_lock(&qemu_global_mutex);
3635         qemu_mutex_unlock(&qemu_fair_mutex);
3636     } else
3637         qemu_signal_lock(100);
3638 }
3639
3640 void qemu_mutex_unlock_iothread(void)
3641 {
3642     qemu_mutex_unlock(&qemu_global_mutex);
3643 }
3644
3645 static int all_vcpus_paused(void)
3646 {
3647     CPUState *penv = first_cpu;
3648
3649     while (penv) {
3650         if (!penv->stopped)
3651             return 0;
3652         penv = (CPUState *)penv->next_cpu;
3653     }
3654
3655     return 1;
3656 }
3657
3658 static void pause_all_vcpus(void)
3659 {
3660     CPUState *penv = first_cpu;
3661
3662     while (penv) {
3663         penv->stop = 1;
3664         qemu_thread_signal(penv->thread, SIG_IPI);
3665         qemu_cpu_kick(penv);
3666         penv = (CPUState *)penv->next_cpu;
3667     }
3668
3669     while (!all_vcpus_paused()) {
3670         qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
3671         penv = first_cpu;
3672         while (penv) {
3673             qemu_thread_signal(penv->thread, SIG_IPI);
3674             penv = (CPUState *)penv->next_cpu;
3675         }
3676     }
3677 }
3678
3679 static void resume_all_vcpus(void)
3680 {
3681     CPUState *penv = first_cpu;
3682
3683     while (penv) {
3684         penv->stop = 0;
3685         penv->stopped = 0;
3686         qemu_thread_signal(penv->thread, SIG_IPI);
3687         qemu_cpu_kick(penv);
3688         penv = (CPUState *)penv->next_cpu;
3689     }
3690 }
3691
3692 static void tcg_init_vcpu(void *_env)
3693 {
3694     CPUState *env = _env;
3695     /* share a single thread for all cpus with TCG */
3696     if (!tcg_cpu_thread) {
3697         env->thread = qemu_mallocz(sizeof(QemuThread));
3698         env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3699         qemu_cond_init(env->halt_cond);
3700         qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
3701         while (env->created == 0)
3702             qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3703         tcg_cpu_thread = env->thread;
3704         tcg_halt_cond = env->halt_cond;
3705     } else {
3706         env->thread = tcg_cpu_thread;
3707         env->halt_cond = tcg_halt_cond;
3708     }
3709 }
3710
3711 static void kvm_start_vcpu(CPUState *env)
3712 {
3713     env->thread = qemu_mallocz(sizeof(QemuThread));
3714     env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3715     qemu_cond_init(env->halt_cond);
3716     qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
3717     while (env->created == 0)
3718         qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3719 }
3720
3721 void qemu_init_vcpu(void *_env)
3722 {
3723     CPUState *env = _env;
3724
3725     env->nr_cores = smp_cores;
3726     env->nr_threads = smp_threads;
3727     if (kvm_enabled())
3728         kvm_start_vcpu(env);
3729     else
3730         tcg_init_vcpu(env);
3731 }
3732
3733 void qemu_notify_event(void)
3734 {
3735     qemu_event_increment();
3736 }
3737
3738 void vm_stop(int reason)
3739 {
3740     QemuThread me;
3741     qemu_thread_self(&me);
3742
3743     if (!qemu_thread_equal(&me, &io_thread)) {
3744         qemu_system_vmstop_request(reason);
3745         /*
3746          * FIXME: should not return to device code in case
3747          * vm_stop() has been requested.
3748          */
3749         if (cpu_single_env) {
3750             cpu_exit(cpu_single_env);
3751             cpu_single_env->stop = 1;
3752         }
3753         return;
3754     }
3755     do_vm_stop(reason);
3756 }
3757
3758 #endif
3759
3760
3761 #ifdef _WIN32
3762 static void host_main_loop_wait(int *timeout)
3763 {
3764     int ret, ret2, i;
3765     PollingEntry *pe;
3766
3767
3768     /* XXX: need to suppress polling by better using win32 events */
3769     ret = 0;
3770     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3771         ret |= pe->func(pe->opaque);
3772     }
3773     if (ret == 0) {
3774         int err;
3775         WaitObjects *w = &wait_objects;
3776
3777         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3778         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3779             if (w->func[ret - WAIT_OBJECT_0])
3780                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3781
3782             /* Check for additional signaled events */
3783             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3784
3785                 /* Check if event is signaled */
3786                 ret2 = WaitForSingleObject(w->events[i], 0);
3787                 if(ret2 == WAIT_OBJECT_0) {
3788                     if (w->func[i])
3789                         w->func[i](w->opaque[i]);
3790                 } else if (ret2 == WAIT_TIMEOUT) {
3791                 } else {
3792                     err = GetLastError();
3793                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3794                 }
3795             }
3796         } else if (ret == WAIT_TIMEOUT) {
3797         } else {
3798             err = GetLastError();
3799             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3800         }
3801     }
3802
3803     *timeout = 0;
3804 }
3805 #else
3806 static void host_main_loop_wait(int *timeout)
3807 {
3808 }
3809 #endif
3810
3811 void main_loop_wait(int timeout)
3812 {
3813     IOHandlerRecord *ioh;
3814     fd_set rfds, wfds, xfds;
3815     int ret, nfds;
3816     struct timeval tv;
3817
3818     qemu_bh_update_timeout(&timeout);
3819
3820     host_main_loop_wait(&timeout);
3821
3822     /* poll any events */
3823     /* XXX: separate device handlers from system ones */
3824     nfds = -1;
3825     FD_ZERO(&rfds);
3826     FD_ZERO(&wfds);
3827     FD_ZERO(&xfds);
3828     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3829         if (ioh->deleted)
3830             continue;
3831         if (ioh->fd_read &&
3832             (!ioh->fd_read_poll ||
3833              ioh->fd_read_poll(ioh->opaque) != 0)) {
3834             FD_SET(ioh->fd, &rfds);
3835             if (ioh->fd > nfds)
3836                 nfds = ioh->fd;
3837         }
3838         if (ioh->fd_write) {
3839             FD_SET(ioh->fd, &wfds);
3840             if (ioh->fd > nfds)
3841                 nfds = ioh->fd;
3842         }
3843     }
3844
3845     tv.tv_sec = timeout / 1000;
3846     tv.tv_usec = (timeout % 1000) * 1000;
3847
3848     slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3849
3850     qemu_mutex_unlock_iothread();
3851     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3852     qemu_mutex_lock_iothread();
3853     if (ret > 0) {
3854         IOHandlerRecord **pioh;
3855
3856         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3857             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3858                 ioh->fd_read(ioh->opaque);
3859             }
3860             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3861                 ioh->fd_write(ioh->opaque);
3862             }
3863         }
3864
3865         /* remove deleted IO handlers */
3866         pioh = &first_io_handler;
3867         while (*pioh) {
3868             ioh = *pioh;
3869             if (ioh->deleted) {
3870                 *pioh = ioh->next;
3871                 qemu_free(ioh);
3872             } else
3873                 pioh = &ioh->next;
3874         }
3875     }
3876
3877     slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
3878
3879     /* rearm timer, if not periodic */
3880     if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
3881         alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
3882         qemu_rearm_alarm_timer(alarm_timer);
3883     }
3884
3885     /* vm time timers */
3886     if (vm_running) {
3887         if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3888             qemu_run_timers(&active_timers[QEMU_CLOCK_VIRTUAL],
3889                             qemu_get_clock(vm_clock));
3890     }
3891
3892     /* real time timers */
3893     qemu_run_timers(&active_timers[QEMU_CLOCK_REALTIME],
3894                     qemu_get_clock(rt_clock));
3895
3896     qemu_run_timers(&active_timers[QEMU_CLOCK_HOST],
3897                     qemu_get_clock(host_clock));
3898
3899     /* Check bottom-halves last in case any of the earlier events triggered
3900        them.  */
3901     qemu_bh_poll();
3902
3903 }
3904
3905 static int qemu_cpu_exec(CPUState *env)
3906 {
3907     int ret;
3908 #ifdef CONFIG_PROFILER
3909     int64_t ti;
3910 #endif
3911
3912 #ifdef CONFIG_PROFILER
3913     ti = profile_getclock();
3914 #endif
3915     if (use_icount) {
3916         int64_t count;
3917         int decr;
3918         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3919         env->icount_decr.u16.low = 0;
3920         env->icount_extra = 0;
3921         count = qemu_next_deadline();
3922         count = (count + (1 << icount_time_shift) - 1)
3923                 >> icount_time_shift;
3924         qemu_icount += count;
3925         decr = (count > 0xffff) ? 0xffff : count;
3926         count -= decr;
3927         env->icount_decr.u16.low = decr;
3928         env->icount_extra = count;
3929     }
3930     ret = cpu_exec(env);
3931 #ifdef CONFIG_PROFILER
3932     qemu_time += profile_getclock() - ti;
3933 #endif
3934     if (use_icount) {
3935         /* Fold pending instructions back into the
3936            instruction counter, and clear the interrupt flag.  */
3937         qemu_icount -= (env->icount_decr.u16.low
3938                         + env->icount_extra);
3939         env->icount_decr.u32 = 0;
3940         env->icount_extra = 0;
3941     }
3942     return ret;
3943 }
3944
3945 static void tcg_cpu_exec(void)
3946 {
3947     int ret = 0;
3948
3949     if (next_cpu == NULL)
3950         next_cpu = first_cpu;
3951     for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
3952         CPUState *env = cur_cpu = next_cpu;
3953
3954         if (timer_alarm_pending) {
3955             timer_alarm_pending = 0;
3956             break;
3957         }
3958         if (cpu_can_run(env))
3959             ret = qemu_cpu_exec(env);
3960         else if (env->stop)
3961             break;
3962
3963         if (ret == EXCP_DEBUG) {
3964             gdb_set_stop_cpu(env);
3965             debug_requested = 1;
3966             break;
3967         }
3968     }
3969 }
3970
3971 static int cpu_has_work(CPUState *env)
3972 {
3973     if (env->stop)
3974         return 1;
3975     if (env->stopped)
3976         return 0;
3977     if (!env->halted)
3978         return 1;
3979     if (qemu_cpu_has_work(env))
3980         return 1;
3981     return 0;
3982 }
3983
3984 static int tcg_has_work(void)
3985 {
3986     CPUState *env;
3987
3988     for (env = first_cpu; env != NULL; env = env->next_cpu)
3989         if (cpu_has_work(env))
3990             return 1;
3991     return 0;
3992 }
3993
3994 static int qemu_calculate_timeout(void)
3995 {
3996 #ifndef CONFIG_IOTHREAD
3997     int timeout;
3998
3999     if (!vm_running)
4000         timeout = 5000;
4001     else if (tcg_has_work())
4002         timeout = 0;
4003     else if (!use_icount)
4004         timeout = 5000;
4005     else {
4006      /* XXX: use timeout computed from timers */
4007         int64_t add;
4008         int64_t delta;
4009         /* Advance virtual time to the next event.  */
4010         if (use_icount == 1) {
4011             /* When not using an adaptive execution frequency
4012                we tend to get badly out of sync with real time,
4013                so just delay for a reasonable amount of time.  */
4014             delta = 0;
4015         } else {
4016             delta = cpu_get_icount() - cpu_get_clock();
4017         }
4018         if (delta > 0) {
4019             /* If virtual time is ahead of real time then just
4020                wait for IO.  */
4021             timeout = (delta / 1000000) + 1;
4022         } else {
4023             /* Wait for either IO to occur or the next
4024                timer event.  */
4025             add = qemu_next_deadline();
4026             /* We advance the timer before checking for IO.
4027                Limit the amount we advance so that early IO
4028                activity won't get the guest too far ahead.  */
4029             if (add > 10000000)
4030                 add = 10000000;
4031             delta += add;
4032             add = (add + (1 << icount_time_shift) - 1)
4033                   >> icount_time_shift;
4034             qemu_icount += add;
4035             timeout = delta / 1000000;
4036             if (timeout < 0)
4037                 timeout = 0;
4038         }
4039     }
4040
4041     return timeout;
4042 #else /* CONFIG_IOTHREAD */
4043     return 1000;
4044 #endif
4045 }
4046
4047 static int vm_can_run(void)
4048 {
4049     if (powerdown_requested)
4050         return 0;
4051     if (reset_requested)
4052         return 0;
4053     if (shutdown_requested)
4054         return 0;
4055     if (debug_requested)
4056         return 0;
4057     return 1;
4058 }
4059
4060 qemu_irq qemu_system_powerdown;
4061
4062 static void main_loop(void)
4063 {
4064     int r;
4065
4066 #ifdef CONFIG_IOTHREAD
4067     qemu_system_ready = 1;
4068     qemu_cond_broadcast(&qemu_system_cond);
4069 #endif
4070
4071     for (;;) {
4072         do {
4073 #ifdef CONFIG_PROFILER
4074             int64_t ti;
4075 #endif
4076 #ifndef CONFIG_IOTHREAD
4077             tcg_cpu_exec();
4078 #endif
4079 #ifdef CONFIG_PROFILER
4080             ti = profile_getclock();
4081 #endif
4082             main_loop_wait(qemu_calculate_timeout());
4083 #ifdef CONFIG_PROFILER
4084             dev_time += profile_getclock() - ti;
4085 #endif
4086         } while (vm_can_run());
4087
4088         if (qemu_debug_requested()) {
4089             monitor_protocol_event(QEVENT_DEBUG, NULL);
4090             vm_stop(EXCP_DEBUG);
4091         }
4092         if (qemu_shutdown_requested()) {
4093             monitor_protocol_event(QEVENT_SHUTDOWN, NULL);
4094             if (no_shutdown) {
4095                 vm_stop(0);
4096                 no_shutdown = 0;
4097             } else
4098                 break;
4099         }
4100         if (qemu_reset_requested()) {
4101             pause_all_vcpus();
4102             qemu_system_reset();
4103             resume_all_vcpus();
4104         }
4105         if (qemu_powerdown_requested()) {
4106             monitor_protocol_event(QEVENT_POWERDOWN, NULL);
4107             qemu_irq_raise(qemu_system_powerdown);
4108         }
4109         if ((r = qemu_vmstop_requested())) {
4110             vm_stop(r);
4111         }
4112     }
4113     pause_all_vcpus();
4114 }
4115
4116 static void version(void)
4117 {
4118     printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4119 }
4120
4121 static void help(int exitcode)
4122 {
4123     const char *options_help =
4124 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4125            opt_help
4126 #define DEFHEADING(text) stringify(text) "\n"
4127 #include "qemu-options.h"
4128 #undef DEF
4129 #undef DEFHEADING
4130 #undef GEN_DOCS
4131         ;
4132     version();
4133     printf("usage: %s [options] [disk_image]\n"
4134            "\n"
4135            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4136            "\n"
4137            "%s\n"
4138            "During emulation, the following keys are useful:\n"
4139            "ctrl-alt-f      toggle full screen\n"
4140            "ctrl-alt-n      switch to virtual console 'n'\n"
4141            "ctrl-alt        toggle mouse and keyboard grab\n"
4142            "\n"
4143            "When using -nographic, press 'ctrl-a h' to get some help.\n",
4144            "qemu",
4145            options_help);
4146     exit(exitcode);
4147 }
4148
4149 #define HAS_ARG 0x0001
4150
4151 enum {
4152 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4153     opt_enum,
4154 #define DEFHEADING(text)
4155 #include "qemu-options.h"
4156 #undef DEF
4157 #undef DEFHEADING
4158 #undef GEN_DOCS
4159 };
4160
4161 typedef struct QEMUOption {
4162     const char *name;
4163     int flags;
4164     int index;
4165 } QEMUOption;
4166
4167 static const QEMUOption qemu_options[] = {
4168     { "h", 0, QEMU_OPTION_h },
4169 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4170     { option, opt_arg, opt_enum },
4171 #define DEFHEADING(text)
4172 #include "qemu-options.h"
4173 #undef DEF
4174 #undef DEFHEADING
4175 #undef GEN_DOCS
4176     { NULL },
4177 };
4178
4179 #ifdef HAS_AUDIO
4180 struct soundhw soundhw[] = {
4181 #ifdef HAS_AUDIO_CHOICE
4182 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4183     {
4184         "pcspk",
4185         "PC speaker",
4186         0,
4187         1,
4188         { .init_isa = pcspk_audio_init }
4189     },
4190 #endif
4191
4192 #ifdef CONFIG_SB16
4193     {
4194         "sb16",
4195         "Creative Sound Blaster 16",
4196         0,
4197         1,
4198         { .init_isa = SB16_init }
4199     },
4200 #endif
4201
4202 #ifdef CONFIG_CS4231A
4203     {
4204         "cs4231a",
4205         "CS4231A",
4206         0,
4207         1,
4208         { .init_isa = cs4231a_init }
4209     },
4210 #endif
4211
4212 #ifdef CONFIG_ADLIB
4213     {
4214         "adlib",
4215 #ifdef HAS_YMF262
4216         "Yamaha YMF262 (OPL3)",
4217 #else
4218         "Yamaha YM3812 (OPL2)",
4219 #endif
4220         0,
4221         1,
4222         { .init_isa = Adlib_init }
4223     },
4224 #endif
4225
4226 #ifdef CONFIG_GUS
4227     {
4228         "gus",
4229         "Gravis Ultrasound GF1",
4230         0,
4231         1,
4232         { .init_isa = GUS_init }
4233     },
4234 #endif
4235
4236 #ifdef CONFIG_AC97
4237     {
4238         "ac97",
4239         "Intel 82801AA AC97 Audio",
4240         0,
4241         0,
4242         { .init_pci = ac97_init }
4243     },
4244 #endif
4245
4246 #ifdef CONFIG_ES1370
4247     {
4248         "es1370",
4249         "ENSONIQ AudioPCI ES1370",
4250         0,
4251         0,
4252         { .init_pci = es1370_init }
4253     },
4254 #endif
4255
4256 #endif /* HAS_AUDIO_CHOICE */
4257
4258     { NULL, NULL, 0, 0, { NULL } }
4259 };
4260
4261 static void select_soundhw (const char *optarg)
4262 {
4263     struct soundhw *c;
4264
4265     if (*optarg == '?') {
4266     show_valid_cards:
4267
4268         printf ("Valid sound card names (comma separated):\n");
4269         for (c = soundhw; c->name; ++c) {
4270             printf ("%-11s %s\n", c->name, c->descr);
4271         }
4272         printf ("\n-soundhw all will enable all of the above\n");
4273         exit (*optarg != '?');
4274     }
4275     else {
4276         size_t l;
4277         const char *p;
4278         char *e;
4279         int bad_card = 0;
4280
4281         if (!strcmp (optarg, "all")) {
4282             for (c = soundhw; c->name; ++c) {
4283                 c->enabled = 1;
4284             }
4285             return;
4286         }
4287
4288         p = optarg;
4289         while (*p) {
4290             e = strchr (p, ',');
4291             l = !e ? strlen (p) : (size_t) (e - p);
4292
4293             for (c = soundhw; c->name; ++c) {
4294                 if (!strncmp (c->name, p, l) && !c->name[l]) {
4295                     c->enabled = 1;
4296                     break;
4297                 }
4298             }
4299
4300             if (!c->name) {
4301                 if (l > 80) {
4302                     fprintf (stderr,
4303                              "Unknown sound card name (too big to show)\n");
4304                 }
4305                 else {
4306                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4307                              (int) l, p);
4308                 }
4309                 bad_card = 1;
4310             }
4311             p += l + (e != NULL);
4312         }
4313
4314         if (bad_card)
4315             goto show_valid_cards;
4316     }
4317 }
4318 #endif
4319
4320 static void select_vgahw (const char *p)
4321 {
4322     const char *opts;
4323
4324     default_vga = 0;
4325     vga_interface_type = VGA_NONE;
4326     if (strstart(p, "std", &opts)) {
4327         vga_interface_type = VGA_STD;
4328     } else if (strstart(p, "cirrus", &opts)) {
4329         vga_interface_type = VGA_CIRRUS;
4330     } else if (strstart(p, "vmware", &opts)) {
4331         vga_interface_type = VGA_VMWARE;
4332     } else if (strstart(p, "xenfb", &opts)) {
4333         vga_interface_type = VGA_XENFB;
4334     } else if (!strstart(p, "none", &opts)) {
4335     invalid_vga:
4336         fprintf(stderr, "Unknown vga type: %s\n", p);
4337         exit(1);
4338     }
4339     while (*opts) {
4340         const char *nextopt;
4341
4342         if (strstart(opts, ",retrace=", &nextopt)) {
4343             opts = nextopt;
4344             if (strstart(opts, "dumb", &nextopt))
4345                 vga_retrace_method = VGA_RETRACE_DUMB;
4346             else if (strstart(opts, "precise", &nextopt))
4347                 vga_retrace_method = VGA_RETRACE_PRECISE;
4348             else goto invalid_vga;
4349         } else goto invalid_vga;
4350         opts = nextopt;
4351     }
4352 }
4353
4354 #ifdef TARGET_I386
4355 static int balloon_parse(const char *arg)
4356 {
4357     QemuOpts *opts;
4358
4359     if (strcmp(arg, "none") == 0) {
4360         return 0;
4361     }
4362
4363     if (!strncmp(arg, "virtio", 6)) {
4364         if (arg[6] == ',') {
4365             /* have params -> parse them */
4366             opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
4367             if (!opts)
4368                 return  -1;
4369         } else {
4370             /* create empty opts */
4371             opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4372         }
4373         qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4374         return 0;
4375     }
4376
4377     return -1;
4378 }
4379 #endif
4380
4381 #ifdef _WIN32
4382 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4383 {
4384     exit(STATUS_CONTROL_C_EXIT);
4385     return TRUE;
4386 }
4387 #endif
4388
4389 int qemu_uuid_parse(const char *str, uint8_t *uuid)
4390 {
4391     int ret;
4392
4393     if(strlen(str) != 36)
4394         return -1;
4395
4396     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4397             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4398             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4399
4400     if(ret != 16)
4401         return -1;
4402
4403 #ifdef TARGET_I386
4404     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4405 #endif
4406
4407     return 0;
4408 }
4409
4410 #ifndef _WIN32
4411
4412 static void termsig_handler(int signal)
4413 {
4414     qemu_system_shutdown_request();
4415 }
4416
4417 static void sigchld_handler(int signal)
4418 {
4419     waitpid(-1, NULL, WNOHANG);
4420 }
4421
4422 static void sighandler_setup(void)
4423 {
4424     struct sigaction act;
4425
4426     memset(&act, 0, sizeof(act));
4427     act.sa_handler = termsig_handler;
4428     sigaction(SIGINT,  &act, NULL);
4429     sigaction(SIGHUP,  &act, NULL);
4430     sigaction(SIGTERM, &act, NULL);
4431
4432     act.sa_handler = sigchld_handler;
4433     act.sa_flags = SA_NOCLDSTOP;
4434     sigaction(SIGCHLD, &act, NULL);
4435 }
4436
4437 #endif
4438
4439 #ifdef _WIN32
4440 /* Look for support files in the same directory as the executable.  */
4441 static char *find_datadir(const char *argv0)
4442 {
4443     char *p;
4444     char buf[MAX_PATH];
4445     DWORD len;
4446
4447     len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4448     if (len == 0) {
4449         return NULL;
4450     }
4451
4452     buf[len] = 0;
4453     p = buf + len - 1;
4454     while (p != buf && *p != '\\')
4455         p--;
4456     *p = 0;
4457     if (access(buf, R_OK) == 0) {
4458         return qemu_strdup(buf);
4459     }
4460     return NULL;
4461 }
4462 #else /* !_WIN32 */
4463
4464 /* Find a likely location for support files using the location of the binary.
4465    For installed binaries this will be "$bindir/../share/qemu".  When
4466    running from the build tree this will be "$bindir/../pc-bios".  */
4467 #define SHARE_SUFFIX "/share/qemu"
4468 #define BUILD_SUFFIX "/pc-bios"
4469 static char *find_datadir(const char *argv0)
4470 {
4471     char *dir;
4472     char *p = NULL;
4473     char *res;
4474     char buf[PATH_MAX];
4475     size_t max_len;
4476
4477 #if defined(__linux__)
4478     {
4479         int len;
4480         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4481         if (len > 0) {
4482             buf[len] = 0;
4483             p = buf;
4484         }
4485     }
4486 #elif defined(__FreeBSD__)
4487     {
4488         int len;
4489         len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4490         if (len > 0) {
4491             buf[len] = 0;
4492             p = buf;
4493         }
4494     }
4495 #endif
4496     /* If we don't have any way of figuring out the actual executable
4497        location then try argv[0].  */
4498     if (!p) {
4499         p = realpath(argv0, buf);
4500         if (!p) {
4501             return NULL;
4502         }
4503     }
4504     dir = dirname(p);
4505     dir = dirname(dir);
4506
4507     max_len = strlen(dir) +
4508         MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4509     res = qemu_mallocz(max_len);
4510     snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4511     if (access(res, R_OK)) {
4512         snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4513         if (access(res, R_OK)) {
4514             qemu_free(res);
4515             res = NULL;
4516         }
4517     }
4518
4519     return res;
4520 }
4521 #undef SHARE_SUFFIX
4522 #undef BUILD_SUFFIX
4523 #endif
4524
4525 char *qemu_find_file(int type, const char *name)
4526 {
4527     int len;
4528     const char *subdir;
4529     char *buf;
4530
4531     /* If name contains path separators then try it as a straight path.  */
4532     if ((strchr(name, '/') || strchr(name, '\\'))
4533         && access(name, R_OK) == 0) {
4534         return qemu_strdup(name);
4535     }
4536     switch (type) {
4537     case QEMU_FILE_TYPE_BIOS:
4538         subdir = "";
4539         break;
4540     case QEMU_FILE_TYPE_KEYMAP:
4541         subdir = "keymaps/";
4542         break;
4543     default:
4544         abort();
4545     }
4546     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4547     buf = qemu_mallocz(len);
4548     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4549     if (access(buf, R_OK)) {
4550         qemu_free(buf);
4551         return NULL;
4552     }
4553     return buf;
4554 }
4555
4556 static int device_help_func(QemuOpts *opts, void *opaque)
4557 {
4558     return qdev_device_help(opts);
4559 }
4560
4561 static int device_init_func(QemuOpts *opts, void *opaque)
4562 {
4563     DeviceState *dev;
4564
4565     dev = qdev_device_add(opts);
4566     if (!dev)
4567         return -1;
4568     return 0;
4569 }
4570
4571 static int chardev_init_func(QemuOpts *opts, void *opaque)
4572 {
4573     CharDriverState *chr;
4574
4575     chr = qemu_chr_open_opts(opts, NULL);
4576     if (!chr)
4577         return -1;
4578     return 0;
4579 }
4580
4581 static int mon_init_func(QemuOpts *opts, void *opaque)
4582 {
4583     CharDriverState *chr;
4584     const char *chardev;
4585     const char *mode;
4586     int flags;
4587
4588     mode = qemu_opt_get(opts, "mode");
4589     if (mode == NULL) {
4590         mode = "readline";
4591     }
4592     if (strcmp(mode, "readline") == 0) {
4593         flags = MONITOR_USE_READLINE;
4594     } else if (strcmp(mode, "control") == 0) {
4595         flags = MONITOR_USE_CONTROL;
4596     } else {
4597         fprintf(stderr, "unknown monitor mode \"%s\"\n", mode);
4598         exit(1);
4599     }
4600
4601     if (qemu_opt_get_bool(opts, "default", 0))
4602         flags |= MONITOR_IS_DEFAULT;
4603
4604     chardev = qemu_opt_get(opts, "chardev");
4605     chr = qemu_chr_find(chardev);
4606     if (chr == NULL) {
4607         fprintf(stderr, "chardev \"%s\" not found\n", chardev);
4608         exit(1);
4609     }
4610
4611     monitor_init(chr, flags);
4612     return 0;
4613 }
4614
4615 static void monitor_parse(const char *optarg, const char *mode)
4616 {
4617     static int monitor_device_index = 0;
4618     QemuOpts *opts;
4619     const char *p;
4620     char label[32];
4621     int def = 0;
4622
4623     if (strstart(optarg, "chardev:", &p)) {
4624         snprintf(label, sizeof(label), "%s", p);
4625     } else {
4626         if (monitor_device_index) {
4627             snprintf(label, sizeof(label), "monitor%d",
4628                      monitor_device_index);
4629         } else {
4630             snprintf(label, sizeof(label), "monitor");
4631             def = 1;
4632         }
4633         opts = qemu_chr_parse_compat(label, optarg);
4634         if (!opts) {
4635             fprintf(stderr, "parse error: %s\n", optarg);
4636             exit(1);
4637         }
4638     }
4639
4640     opts = qemu_opts_create(&qemu_mon_opts, label, 1);
4641     if (!opts) {
4642         fprintf(stderr, "duplicate chardev: %s\n", label);
4643         exit(1);
4644     }
4645     qemu_opt_set(opts, "mode", mode);
4646     qemu_opt_set(opts, "chardev", label);
4647     if (def)
4648         qemu_opt_set(opts, "default", "on");
4649     monitor_device_index++;
4650 }
4651
4652 struct device_config {
4653     enum {
4654         DEV_USB,       /* -usbdevice     */
4655         DEV_BT,        /* -bt            */
4656         DEV_SERIAL,    /* -serial        */
4657         DEV_PARALLEL,  /* -parallel      */
4658         DEV_VIRTCON,   /* -virtioconsole */
4659         DEV_DEBUGCON,  /* -debugcon */
4660     } type;
4661     const char *cmdline;
4662     QTAILQ_ENTRY(device_config) next;
4663 };
4664 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4665
4666 static void add_device_config(int type, const char *cmdline)
4667 {
4668     struct device_config *conf;
4669
4670     conf = qemu_mallocz(sizeof(*conf));
4671     conf->type = type;
4672     conf->cmdline = cmdline;
4673     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4674 }
4675
4676 static int foreach_device_config(int type, int (*func)(const char *cmdline))
4677 {
4678     struct device_config *conf;
4679     int rc;
4680
4681     QTAILQ_FOREACH(conf, &device_configs, next) {
4682         if (conf->type != type)
4683             continue;
4684         rc = func(conf->cmdline);
4685         if (0 != rc)
4686             return rc;
4687     }
4688     return 0;
4689 }
4690
4691 static int serial_parse(const char *devname)
4692 {
4693     static int index = 0;
4694     char label[32];
4695
4696     if (strcmp(devname, "none") == 0)
4697         return 0;
4698     if (index == MAX_SERIAL_PORTS) {
4699         fprintf(stderr, "qemu: too many serial ports\n");
4700         exit(1);
4701     }
4702     snprintf(label, sizeof(label), "serial%d", index);
4703     serial_hds[index] = qemu_chr_open(label, devname, NULL);
4704     if (!serial_hds[index]) {
4705         fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
4706                 devname, strerror(errno));
4707         return -1;
4708     }
4709     index++;
4710     return 0;
4711 }
4712
4713 static int parallel_parse(const char *devname)
4714 {
4715     static int index = 0;
4716     char label[32];
4717
4718     if (strcmp(devname, "none") == 0)
4719         return 0;
4720     if (index == MAX_PARALLEL_PORTS) {
4721         fprintf(stderr, "qemu: too many parallel ports\n");
4722         exit(1);
4723     }
4724     snprintf(label, sizeof(label), "parallel%d", index);
4725     parallel_hds[index] = qemu_chr_open(label, devname, NULL);
4726     if (!parallel_hds[index]) {
4727         fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
4728                 devname, strerror(errno));
4729         return -1;
4730     }
4731     index++;
4732     return 0;
4733 }
4734
4735 static int virtcon_parse(const char *devname)
4736 {
4737     static int index = 0;
4738     char label[32];
4739     QemuOpts *bus_opts, *dev_opts;
4740
4741     if (strcmp(devname, "none") == 0)
4742         return 0;
4743     if (index == MAX_VIRTIO_CONSOLES) {
4744         fprintf(stderr, "qemu: too many virtio consoles\n");
4745         exit(1);
4746     }
4747
4748     bus_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4749     qemu_opt_set(bus_opts, "driver", "virtio-serial");
4750
4751     dev_opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4752     qemu_opt_set(dev_opts, "driver", "virtconsole");
4753
4754     snprintf(label, sizeof(label), "virtcon%d", index);
4755     virtcon_hds[index] = qemu_chr_open(label, devname, NULL);
4756     if (!virtcon_hds[index]) {
4757         fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
4758                 devname, strerror(errno));
4759         return -1;
4760     }
4761     qemu_opt_set(dev_opts, "chardev", label);
4762
4763     index++;
4764     return 0;
4765 }
4766
4767 static int debugcon_parse(const char *devname)
4768 {
4769     QemuOpts *opts;
4770
4771     if (!qemu_chr_open("debugcon", devname, NULL)) {
4772         exit(1);
4773     }
4774     opts = qemu_opts_create(&qemu_device_opts, "debugcon", 1);
4775     if (!opts) {
4776         fprintf(stderr, "qemu: already have a debugcon device\n");
4777         exit(1);
4778     }
4779     qemu_opt_set(opts, "driver", "isa-debugcon");
4780     qemu_opt_set(opts, "chardev", "debugcon");
4781     return 0;
4782 }
4783
4784 static const QEMUOption *lookup_opt(int argc, char **argv,
4785                                     const char **poptarg, int *poptind)
4786 {
4787     const QEMUOption *popt;
4788     int optind = *poptind;
4789     char *r = argv[optind];
4790     const char *optarg;
4791
4792     optind++;
4793     /* Treat --foo the same as -foo.  */
4794     if (r[1] == '-')
4795         r++;
4796     popt = qemu_options;
4797     for(;;) {
4798         if (!popt->name) {
4799             fprintf(stderr, "%s: invalid option -- '%s'\n",
4800                     argv[0], r);
4801             exit(1);
4802         }
4803         if (!strcmp(popt->name, r + 1))
4804             break;
4805         popt++;
4806     }
4807     if (popt->flags & HAS_ARG) {
4808         if (optind >= argc) {
4809             fprintf(stderr, "%s: option '%s' requires an argument\n",
4810                     argv[0], r);
4811             exit(1);
4812         }
4813         optarg = argv[optind++];
4814     } else {
4815         optarg = NULL;
4816     }
4817
4818     *poptarg = optarg;
4819     *poptind = optind;
4820
4821     return popt;
4822 }
4823
4824 int main(int argc, char **argv, char **envp)
4825 {
4826     const char *gdbstub_dev = NULL;
4827     uint32_t boot_devices_bitmap = 0;
4828     int i;
4829     int snapshot, linux_boot, net_boot;
4830     const char *initrd_filename;
4831     const char *kernel_filename, *kernel_cmdline;
4832     char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4833     DisplayState *ds;
4834     DisplayChangeListener *dcl;
4835     int cyls, heads, secs, translation;
4836     QemuOpts *hda_opts = NULL, *opts;
4837     int optind;
4838     const char *optarg;
4839     const char *loadvm = NULL;
4840     QEMUMachine *machine;
4841     const char *cpu_model;
4842 #ifndef _WIN32
4843     int fds[2];
4844 #endif
4845     int tb_size;
4846     const char *pid_file = NULL;
4847     const char *incoming = NULL;
4848 #ifndef _WIN32
4849     int fd = 0;
4850     struct passwd *pwd = NULL;
4851     const char *chroot_dir = NULL;
4852     const char *run_as = NULL;
4853 #endif
4854     CPUState *env;
4855     int show_vnc_port = 0;
4856     int defconfig = 1;
4857
4858     init_clocks();
4859
4860     qemu_errors_to_file(stderr);
4861     qemu_cache_utils_init(envp);
4862
4863     QLIST_INIT (&vm_change_state_head);
4864 #ifndef _WIN32
4865     {
4866         struct sigaction act;
4867         sigfillset(&act.sa_mask);
4868         act.sa_flags = 0;
4869         act.sa_handler = SIG_IGN;
4870         sigaction(SIGPIPE, &act, NULL);
4871     }
4872 #else
4873     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4874     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4875        QEMU to run on a single CPU */
4876     {
4877         HANDLE h;
4878         DWORD mask, smask;
4879         int i;
4880         h = GetCurrentProcess();
4881         if (GetProcessAffinityMask(h, &mask, &smask)) {
4882             for(i = 0; i < 32; i++) {
4883                 if (mask & (1 << i))
4884                     break;
4885             }
4886             if (i != 32) {
4887                 mask = 1 << i;
4888                 SetProcessAffinityMask(h, mask);
4889             }
4890         }
4891     }
4892 #endif
4893
4894     module_call_init(MODULE_INIT_MACHINE);
4895     machine = find_default_machine();
4896     cpu_model = NULL;
4897     initrd_filename = NULL;
4898     ram_size = 0;
4899     snapshot = 0;
4900     kernel_filename = NULL;
4901     kernel_cmdline = "";
4902     cyls = heads = secs = 0;
4903     translation = BIOS_ATA_TRANSLATION_AUTO;
4904
4905     for (i = 0; i < MAX_NODES; i++) {
4906         node_mem[i] = 0;
4907         node_cpumask[i] = 0;
4908     }
4909
4910     nb_numa_nodes = 0;
4911     nb_nics = 0;
4912
4913     tb_size = 0;
4914     autostart= 1;
4915
4916     /* first pass of option parsing */
4917     optind = 1;
4918     while (optind < argc) {
4919         if (argv[optind][0] != '-') {
4920             /* disk image */
4921             optind++;
4922             continue;
4923         } else {
4924             const QEMUOption *popt;
4925
4926             popt = lookup_opt(argc, argv, &optarg, &optind);
4927             switch (popt->index) {
4928             case QEMU_OPTION_nodefconfig:
4929                 defconfig=0;
4930                 break;
4931             }
4932         }
4933     }
4934
4935     if (defconfig) {
4936         FILE *fp;
4937         fp = fopen(CONFIG_QEMU_CONFDIR "/qemu.conf", "r");
4938         if (fp) {
4939             if (qemu_config_parse(fp) != 0) {
4940                 exit(1);
4941             }
4942             fclose(fp);
4943         }
4944
4945         fp = fopen(CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf", "r");
4946         if (fp) {
4947             if (qemu_config_parse(fp) != 0) {
4948                 exit(1);
4949             }
4950             fclose(fp);
4951         }
4952     }
4953 #if defined(cpudef_setup)
4954     cpudef_setup(); /* parse cpu definitions in target config file */
4955 #endif
4956
4957     /* second pass of option parsing */
4958     optind = 1;
4959     for(;;) {
4960         if (optind >= argc)
4961             break;
4962         if (argv[optind][0] != '-') {
4963             hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4964         } else {
4965             const QEMUOption *popt;
4966
4967             popt = lookup_opt(argc, argv, &optarg, &optind);
4968             switch(popt->index) {
4969             case QEMU_OPTION_M:
4970                 machine = find_machine(optarg);
4971                 if (!machine) {
4972                     QEMUMachine *m;
4973                     printf("Supported machines are:\n");
4974                     for(m = first_machine; m != NULL; m = m->next) {
4975                         if (m->alias)
4976                             printf("%-10s %s (alias of %s)\n",
4977                                    m->alias, m->desc, m->name);
4978                         printf("%-10s %s%s\n",
4979                                m->name, m->desc,
4980                                m->is_default ? " (default)" : "");
4981                     }
4982                     exit(*optarg != '?');
4983                 }
4984                 break;
4985             case QEMU_OPTION_cpu:
4986                 /* hw initialization will check this */
4987                 if (*optarg == '?') {
4988 /* XXX: implement xxx_cpu_list for targets that still miss it */
4989 #if defined(cpu_list_id)
4990                     cpu_list_id(stdout, &fprintf, optarg);
4991 #elif defined(cpu_list)
4992                     cpu_list(stdout, &fprintf);         /* deprecated */
4993 #endif
4994                     exit(0);
4995                 } else {
4996                     cpu_model = optarg;
4997                 }
4998                 break;
4999             case QEMU_OPTION_initrd:
5000                 initrd_filename = optarg;
5001                 break;
5002             case QEMU_OPTION_hda:
5003                 if (cyls == 0)
5004                     hda_opts = drive_add(optarg, HD_ALIAS, 0);
5005                 else
5006                     hda_opts = drive_add(optarg, HD_ALIAS
5007                              ",cyls=%d,heads=%d,secs=%d%s",
5008                              0, cyls, heads, secs,
5009                              translation == BIOS_ATA_TRANSLATION_LBA ?
5010                                  ",trans=lba" :
5011                              translation == BIOS_ATA_TRANSLATION_NONE ?
5012                                  ",trans=none" : "");
5013                  break;
5014             case QEMU_OPTION_hdb:
5015             case QEMU_OPTION_hdc:
5016             case QEMU_OPTION_hdd:
5017                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
5018                 break;
5019             case QEMU_OPTION_drive:
5020                 drive_add(NULL, "%s", optarg);
5021                 break;
5022             case QEMU_OPTION_set:
5023                 if (qemu_set_option(optarg) != 0)
5024                     exit(1);
5025                 break;
5026             case QEMU_OPTION_global:
5027                 if (qemu_global_option(optarg) != 0)
5028                     exit(1);
5029                 break;
5030             case QEMU_OPTION_mtdblock:
5031                 drive_add(optarg, MTD_ALIAS);
5032                 break;
5033             case QEMU_OPTION_sd:
5034                 drive_add(optarg, SD_ALIAS);
5035                 break;
5036             case QEMU_OPTION_pflash:
5037                 drive_add(optarg, PFLASH_ALIAS);
5038                 break;
5039             case QEMU_OPTION_snapshot:
5040                 snapshot = 1;
5041                 break;
5042             case QEMU_OPTION_hdachs:
5043                 {
5044                     const char *p;
5045                     p = optarg;
5046                     cyls = strtol(p, (char **)&p, 0);
5047                     if (cyls < 1 || cyls > 16383)
5048                         goto chs_fail;
5049                     if (*p != ',')
5050                         goto chs_fail;
5051                     p++;
5052                     heads = strtol(p, (char **)&p, 0);
5053                     if (heads < 1 || heads > 16)
5054                         goto chs_fail;
5055                     if (*p != ',')
5056                         goto chs_fail;
5057                     p++;
5058                     secs = strtol(p, (char **)&p, 0);
5059                     if (secs < 1 || secs > 63)
5060                         goto chs_fail;
5061                     if (*p == ',') {
5062                         p++;
5063                         if (!strcmp(p, "none"))
5064                             translation = BIOS_ATA_TRANSLATION_NONE;
5065                         else if (!strcmp(p, "lba"))
5066                             translation = BIOS_ATA_TRANSLATION_LBA;
5067                         else if (!strcmp(p, "auto"))
5068                             translation = BIOS_ATA_TRANSLATION_AUTO;
5069                         else
5070                             goto chs_fail;
5071                     } else if (*p != '\0') {
5072                     chs_fail:
5073                         fprintf(stderr, "qemu: invalid physical CHS format\n");
5074                         exit(1);
5075                     }
5076                     if (hda_opts != NULL) {
5077                         char num[16];
5078                         snprintf(num, sizeof(num), "%d", cyls);
5079                         qemu_opt_set(hda_opts, "cyls", num);
5080                         snprintf(num, sizeof(num), "%d", heads);
5081                         qemu_opt_set(hda_opts, "heads", num);
5082                         snprintf(num, sizeof(num), "%d", secs);
5083                         qemu_opt_set(hda_opts, "secs", num);
5084                         if (translation == BIOS_ATA_TRANSLATION_LBA)
5085                             qemu_opt_set(hda_opts, "trans", "lba");
5086                         if (translation == BIOS_ATA_TRANSLATION_NONE)
5087                             qemu_opt_set(hda_opts, "trans", "none");
5088                     }
5089                 }
5090                 break;
5091             case QEMU_OPTION_numa:
5092                 if (nb_numa_nodes >= MAX_NODES) {
5093                     fprintf(stderr, "qemu: too many NUMA nodes\n");
5094                     exit(1);
5095                 }
5096                 numa_add(optarg);
5097                 break;
5098             case QEMU_OPTION_nographic:
5099                 display_type = DT_NOGRAPHIC;
5100                 break;
5101 #ifdef CONFIG_CURSES
5102             case QEMU_OPTION_curses:
5103                 display_type = DT_CURSES;
5104                 break;
5105 #endif
5106             case QEMU_OPTION_portrait:
5107                 graphic_rotate = 1;
5108                 break;
5109             case QEMU_OPTION_kernel:
5110                 kernel_filename = optarg;
5111                 break;
5112             case QEMU_OPTION_append:
5113                 kernel_cmdline = optarg;
5114                 break;
5115             case QEMU_OPTION_cdrom:
5116                 drive_add(optarg, CDROM_ALIAS);
5117                 break;
5118             case QEMU_OPTION_boot:
5119                 {
5120                     static const char * const params[] = {
5121                         "order", "once", "menu", NULL
5122                     };
5123                     char buf[sizeof(boot_devices)];
5124                     char *standard_boot_devices;
5125                     int legacy = 0;
5126
5127                     if (!strchr(optarg, '=')) {
5128                         legacy = 1;
5129                         pstrcpy(buf, sizeof(buf), optarg);
5130                     } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
5131                         fprintf(stderr,
5132                                 "qemu: unknown boot parameter '%s' in '%s'\n",
5133                                 buf, optarg);
5134                         exit(1);
5135                     }
5136
5137                     if (legacy ||
5138                         get_param_value(buf, sizeof(buf), "order", optarg)) {
5139                         boot_devices_bitmap = parse_bootdevices(buf);
5140                         pstrcpy(boot_devices, sizeof(boot_devices), buf);
5141                     }
5142                     if (!legacy) {
5143                         if (get_param_value(buf, sizeof(buf),
5144                                             "once", optarg)) {
5145                             boot_devices_bitmap |= parse_bootdevices(buf);
5146                             standard_boot_devices = qemu_strdup(boot_devices);
5147                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
5148                             qemu_register_reset(restore_boot_devices,
5149                                                 standard_boot_devices);
5150                         }
5151                         if (get_param_value(buf, sizeof(buf),
5152                                             "menu", optarg)) {
5153                             if (!strcmp(buf, "on")) {
5154                                 boot_menu = 1;
5155                             } else if (!strcmp(buf, "off")) {
5156                                 boot_menu = 0;
5157                             } else {
5158                                 fprintf(stderr,
5159                                         "qemu: invalid option value '%s'\n",
5160                                         buf);
5161                                 exit(1);
5162                             }
5163                         }
5164                     }
5165                 }
5166                 break;
5167             case QEMU_OPTION_fda:
5168             case QEMU_OPTION_fdb:
5169                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
5170                 break;
5171 #ifdef TARGET_I386
5172             case QEMU_OPTION_no_fd_bootchk:
5173                 fd_bootchk = 0;
5174                 break;
5175 #endif
5176             case QEMU_OPTION_netdev:
5177                 if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
5178                     exit(1);
5179                 }
5180                 break;
5181             case QEMU_OPTION_net:
5182                 if (net_client_parse(&qemu_net_opts, optarg) == -1) {
5183                     exit(1);
5184                 }
5185                 break;
5186 #ifdef CONFIG_SLIRP
5187             case QEMU_OPTION_tftp:
5188                 legacy_tftp_prefix = optarg;
5189                 break;
5190             case QEMU_OPTION_bootp:
5191                 legacy_bootp_filename = optarg;
5192                 break;
5193 #ifndef _WIN32
5194             case QEMU_OPTION_smb:
5195                 if (net_slirp_smb(optarg) < 0)
5196                     exit(1);
5197                 break;
5198 #endif
5199             case QEMU_OPTION_redir:
5200                 if (net_slirp_redir(optarg) < 0)
5201                     exit(1);
5202                 break;
5203 #endif
5204             case QEMU_OPTION_bt:
5205                 add_device_config(DEV_BT, optarg);
5206                 break;
5207 #ifdef HAS_AUDIO
5208             case QEMU_OPTION_audio_help:
5209                 AUD_help ();
5210                 exit (0);
5211                 break;
5212             case QEMU_OPTION_soundhw:
5213                 select_soundhw (optarg);
5214                 break;
5215 #endif
5216             case QEMU_OPTION_h:
5217                 help(0);
5218                 break;
5219             case QEMU_OPTION_version:
5220                 version();
5221                 exit(0);
5222                 break;
5223             case QEMU_OPTION_m: {
5224                 uint64_t value;
5225                 char *ptr;
5226
5227                 value = strtoul(optarg, &ptr, 10);
5228                 switch (*ptr) {
5229                 case 0: case 'M': case 'm':
5230                     value <<= 20;
5231                     break;
5232                 case 'G': case 'g':
5233                     value <<= 30;
5234                     break;
5235                 default:
5236                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5237                     exit(1);
5238                 }
5239
5240                 /* On 32-bit hosts, QEMU is limited by virtual address space */
5241                 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5242                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5243                     exit(1);
5244                 }
5245                 if (value != (uint64_t)(ram_addr_t)value) {
5246                     fprintf(stderr, "qemu: ram size too large\n");
5247                     exit(1);
5248                 }
5249                 ram_size = value;
5250                 break;
5251             }
5252             case QEMU_OPTION_mempath:
5253                 mem_path = optarg;
5254                 break;
5255 #ifdef MAP_POPULATE
5256             case QEMU_OPTION_mem_prealloc:
5257                 mem_prealloc = 1;
5258                 break;
5259 #endif
5260             case QEMU_OPTION_d:
5261                 {
5262                     int mask;
5263                     const CPULogItem *item;
5264
5265                     mask = cpu_str_to_log_mask(optarg);
5266                     if (!mask) {
5267                         printf("Log items (comma separated):\n");
5268                     for(item = cpu_log_items; item->mask != 0; item++) {
5269                         printf("%-10s %s\n", item->name, item->help);
5270                     }
5271                     exit(1);
5272                     }
5273                     cpu_set_log(mask);
5274                 }
5275                 break;
5276             case QEMU_OPTION_s:
5277                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5278                 break;
5279             case QEMU_OPTION_gdb:
5280                 gdbstub_dev = optarg;
5281                 break;
5282             case QEMU_OPTION_L:
5283                 data_dir = optarg;
5284                 break;
5285             case QEMU_OPTION_bios:
5286                 bios_name = optarg;
5287                 break;
5288             case QEMU_OPTION_singlestep:
5289                 singlestep = 1;
5290                 break;
5291             case QEMU_OPTION_S:
5292                 autostart = 0;
5293                 break;
5294             case QEMU_OPTION_k:
5295                 keyboard_layout = optarg;
5296                 break;
5297             case QEMU_OPTION_localtime:
5298                 rtc_utc = 0;
5299                 break;
5300             case QEMU_OPTION_vga:
5301                 select_vgahw (optarg);
5302                 break;
5303 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5304             case QEMU_OPTION_g:
5305                 {
5306                     const char *p;
5307                     int w, h, depth;
5308                     p = optarg;
5309                     w = strtol(p, (char **)&p, 10);
5310                     if (w <= 0) {
5311                     graphic_error:
5312                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5313                         exit(1);
5314                     }
5315                     if (*p != 'x')
5316                         goto graphic_error;
5317                     p++;
5318                     h = strtol(p, (char **)&p, 10);
5319                     if (h <= 0)
5320                         goto graphic_error;
5321                     if (*p == 'x') {
5322                         p++;
5323                         depth = strtol(p, (char **)&p, 10);
5324                         if (depth != 8 && depth != 15 && depth != 16 &&
5325                             depth != 24 && depth != 32)
5326                             goto graphic_error;
5327                     } else if (*p == '\0') {
5328                         depth = graphic_depth;
5329                     } else {
5330                         goto graphic_error;
5331                     }
5332
5333                     graphic_width = w;
5334                     graphic_height = h;
5335                     graphic_depth = depth;
5336                 }
5337                 break;
5338 #endif
5339             case QEMU_OPTION_echr:
5340                 {
5341                     char *r;
5342                     term_escape_char = strtol(optarg, &r, 0);
5343                     if (r == optarg)
5344                         printf("Bad argument to echr\n");
5345                     break;
5346                 }
5347             case QEMU_OPTION_monitor:
5348                 monitor_parse(optarg, "readline");
5349                 default_monitor = 0;
5350                 break;
5351             case QEMU_OPTION_qmp:
5352                 monitor_parse(optarg, "control");
5353                 default_monitor = 0;
5354                 break;
5355             case QEMU_OPTION_mon:
5356                 opts = qemu_opts_parse(&qemu_mon_opts, optarg, "chardev");
5357                 if (!opts) {
5358                     fprintf(stderr, "parse error: %s\n", optarg);
5359                     exit(1);
5360                 }
5361                 default_monitor = 0;
5362                 break;
5363             case QEMU_OPTION_chardev:
5364                 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend");
5365                 if (!opts) {
5366                     fprintf(stderr, "parse error: %s\n", optarg);
5367                     exit(1);
5368                 }
5369                 break;
5370             case QEMU_OPTION_serial:
5371                 add_device_config(DEV_SERIAL, optarg);
5372                 default_serial = 0;
5373                 break;
5374             case QEMU_OPTION_watchdog:
5375                 if (watchdog) {
5376                     fprintf(stderr,
5377                             "qemu: only one watchdog option may be given\n");
5378                     return 1;
5379                 }
5380                 watchdog = optarg;
5381                 break;
5382             case QEMU_OPTION_watchdog_action:
5383                 if (select_watchdog_action(optarg) == -1) {
5384                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
5385                     exit(1);
5386                 }
5387                 break;
5388             case QEMU_OPTION_virtiocon:
5389                 add_device_config(DEV_VIRTCON, optarg);
5390                 default_virtcon = 0;
5391                 break;
5392             case QEMU_OPTION_parallel:
5393                 add_device_config(DEV_PARALLEL, optarg);
5394                 default_parallel = 0;
5395                 break;
5396             case QEMU_OPTION_debugcon:
5397                 add_device_config(DEV_DEBUGCON, optarg);
5398                 break;
5399             case QEMU_OPTION_loadvm:
5400                 loadvm = optarg;
5401                 break;
5402             case QEMU_OPTION_full_screen:
5403                 full_screen = 1;
5404                 break;
5405 #ifdef CONFIG_SDL
5406             case QEMU_OPTION_no_frame:
5407                 no_frame = 1;
5408                 break;
5409             case QEMU_OPTION_alt_grab:
5410                 alt_grab = 1;
5411                 break;
5412             case QEMU_OPTION_ctrl_grab:
5413                 ctrl_grab = 1;
5414                 break;
5415             case QEMU_OPTION_no_quit:
5416                 no_quit = 1;
5417                 break;
5418             case QEMU_OPTION_sdl:
5419                 display_type = DT_SDL;
5420                 break;
5421 #endif
5422             case QEMU_OPTION_pidfile:
5423                 pid_file = optarg;
5424                 break;
5425 #ifdef TARGET_I386
5426             case QEMU_OPTION_win2k_hack:
5427                 win2k_install_hack = 1;
5428                 break;
5429             case QEMU_OPTION_rtc_td_hack:
5430                 rtc_td_hack = 1;
5431                 break;
5432             case QEMU_OPTION_acpitable:
5433                 if(acpi_table_add(optarg) < 0) {
5434                     fprintf(stderr, "Wrong acpi table provided\n");
5435                     exit(1);
5436                 }
5437                 break;
5438             case QEMU_OPTION_smbios:
5439                 if(smbios_entry_add(optarg) < 0) {
5440                     fprintf(stderr, "Wrong smbios provided\n");
5441                     exit(1);
5442                 }
5443                 break;
5444 #endif
5445 #ifdef CONFIG_KVM
5446             case QEMU_OPTION_enable_kvm:
5447                 kvm_allowed = 1;
5448                 break;
5449 #endif
5450             case QEMU_OPTION_usb:
5451                 usb_enabled = 1;
5452                 break;
5453             case QEMU_OPTION_usbdevice:
5454                 usb_enabled = 1;
5455                 add_device_config(DEV_USB, optarg);
5456                 break;
5457             case QEMU_OPTION_device:
5458                 if (!qemu_opts_parse(&qemu_device_opts, optarg, "driver")) {
5459                     exit(1);
5460                 }
5461                 break;
5462             case QEMU_OPTION_smp:
5463                 smp_parse(optarg);
5464                 if (smp_cpus < 1) {
5465                     fprintf(stderr, "Invalid number of CPUs\n");
5466                     exit(1);
5467                 }
5468                 if (max_cpus < smp_cpus) {
5469                     fprintf(stderr, "maxcpus must be equal to or greater than "
5470                             "smp\n");
5471                     exit(1);
5472                 }
5473                 if (max_cpus > 255) {
5474                     fprintf(stderr, "Unsupported number of maxcpus\n");
5475                     exit(1);
5476                 }
5477                 break;
5478             case QEMU_OPTION_vnc:
5479                 display_type = DT_VNC;
5480                 vnc_display = optarg;
5481                 break;
5482 #ifdef TARGET_I386
5483             case QEMU_OPTION_no_acpi:
5484                 acpi_enabled = 0;
5485                 break;
5486             case QEMU_OPTION_no_hpet:
5487                 no_hpet = 1;
5488                 break;
5489             case QEMU_OPTION_balloon:
5490                 if (balloon_parse(optarg) < 0) {
5491                     fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5492                     exit(1);
5493                 }
5494                 break;
5495 #endif
5496             case QEMU_OPTION_no_reboot:
5497                 no_reboot = 1;
5498                 break;
5499             case QEMU_OPTION_no_shutdown:
5500                 no_shutdown = 1;
5501                 break;
5502             case QEMU_OPTION_show_cursor:
5503                 cursor_hide = 0;
5504                 break;
5505             case QEMU_OPTION_uuid:
5506                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5507                     fprintf(stderr, "Fail to parse UUID string."
5508                             " Wrong format.\n");
5509                     exit(1);
5510                 }
5511                 break;
5512 #ifndef _WIN32
5513             case QEMU_OPTION_daemonize:
5514                 daemonize = 1;
5515                 break;
5516 #endif
5517             case QEMU_OPTION_option_rom:
5518                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5519                     fprintf(stderr, "Too many option ROMs\n");
5520                     exit(1);
5521                 }
5522                 option_rom[nb_option_roms] = optarg;
5523                 nb_option_roms++;
5524                 break;
5525 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5526             case QEMU_OPTION_semihosting:
5527                 semihosting_enabled = 1;
5528                 break;
5529 #endif
5530             case QEMU_OPTION_name:
5531                 qemu_name = qemu_strdup(optarg);
5532                  {
5533                      char *p = strchr(qemu_name, ',');
5534                      if (p != NULL) {
5535                         *p++ = 0;
5536                         if (strncmp(p, "process=", 8)) {
5537                             fprintf(stderr, "Unknown subargument %s to -name", p);
5538                             exit(1);
5539                         }
5540                         p += 8;
5541                         set_proc_name(p);
5542                      }
5543                  }
5544                 break;
5545 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5546             case QEMU_OPTION_prom_env:
5547                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5548                     fprintf(stderr, "Too many prom variables\n");
5549                     exit(1);
5550                 }
5551                 prom_envs[nb_prom_envs] = optarg;
5552                 nb_prom_envs++;
5553                 break;
5554 #endif
5555 #ifdef TARGET_ARM
5556             case QEMU_OPTION_old_param:
5557                 old_param = 1;
5558                 break;
5559 #endif
5560             case QEMU_OPTION_clock:
5561                 configure_alarms(optarg);
5562                 break;
5563             case QEMU_OPTION_startdate:
5564                 configure_rtc_date_offset(optarg, 1);
5565                 break;
5566             case QEMU_OPTION_rtc:
5567                 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
5568                 if (!opts) {
5569                     fprintf(stderr, "parse error: %s\n", optarg);
5570                     exit(1);
5571                 }
5572                 configure_rtc(opts);
5573                 break;
5574             case QEMU_OPTION_tb_size:
5575                 tb_size = strtol(optarg, NULL, 0);
5576                 if (tb_size < 0)
5577                     tb_size = 0;
5578                 break;
5579             case QEMU_OPTION_icount:
5580                 use_icount = 1;
5581                 if (strcmp(optarg, "auto") == 0) {
5582                     icount_time_shift = -1;
5583                 } else {
5584                     icount_time_shift = strtol(optarg, NULL, 0);
5585                 }
5586                 break;
5587             case QEMU_OPTION_incoming:
5588                 incoming = optarg;
5589                 break;
5590             case QEMU_OPTION_nodefaults:
5591                 default_serial = 0;
5592                 default_parallel = 0;
5593                 default_virtcon = 0;
5594                 default_monitor = 0;
5595                 default_vga = 0;
5596                 default_net = 0;
5597                 default_floppy = 0;
5598                 default_cdrom = 0;
5599                 default_sdcard = 0;
5600                 break;
5601 #ifndef _WIN32
5602             case QEMU_OPTION_chroot:
5603                 chroot_dir = optarg;
5604                 break;
5605             case QEMU_OPTION_runas:
5606                 run_as = optarg;
5607                 break;
5608 #endif
5609 #ifdef CONFIG_XEN
5610             case QEMU_OPTION_xen_domid:
5611                 xen_domid = atoi(optarg);
5612                 break;
5613             case QEMU_OPTION_xen_create:
5614                 xen_mode = XEN_CREATE;
5615                 break;
5616             case QEMU_OPTION_xen_attach:
5617                 xen_mode = XEN_ATTACH;
5618                 break;
5619 #endif
5620             case QEMU_OPTION_readconfig:
5621                 {
5622                     FILE *fp;
5623                     fp = fopen(optarg, "r");
5624                     if (fp == NULL) {
5625                         fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5626                         exit(1);
5627                     }
5628                     if (qemu_config_parse(fp) != 0) {
5629                         exit(1);
5630                     }
5631                     fclose(fp);
5632                     break;
5633                 }
5634             case QEMU_OPTION_writeconfig:
5635                 {
5636                     FILE *fp;
5637                     if (strcmp(optarg, "-") == 0) {
5638                         fp = stdout;
5639                     } else {
5640                         fp = fopen(optarg, "w");
5641                         if (fp == NULL) {
5642                             fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5643                             exit(1);
5644                         }
5645                     }
5646                     qemu_config_write(fp);
5647                     fclose(fp);
5648                     break;
5649                 }
5650             }
5651         }
5652     }
5653
5654     /* If no data_dir is specified then try to find it relative to the
5655        executable path.  */
5656     if (!data_dir) {
5657         data_dir = find_datadir(argv[0]);
5658     }
5659     /* If all else fails use the install patch specified when building.  */
5660     if (!data_dir) {
5661         data_dir = CONFIG_QEMU_SHAREDIR;
5662     }
5663
5664     /*
5665      * Default to max_cpus = smp_cpus, in case the user doesn't
5666      * specify a max_cpus value.
5667      */
5668     if (!max_cpus)
5669         max_cpus = smp_cpus;
5670
5671     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5672     if (smp_cpus > machine->max_cpus) {
5673         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5674                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5675                 machine->max_cpus);
5676         exit(1);
5677     }
5678
5679     qemu_opts_foreach(&qemu_device_opts, default_driver_check, NULL, 0);
5680     qemu_opts_foreach(&qemu_global_opts, default_driver_check, NULL, 0);
5681
5682     if (machine->no_serial) {
5683         default_serial = 0;
5684     }
5685     if (machine->no_parallel) {
5686         default_parallel = 0;
5687     }
5688     if (!machine->use_virtcon) {
5689         default_virtcon = 0;
5690     }
5691     if (machine->no_vga) {
5692         default_vga = 0;
5693     }
5694     if (machine->no_floppy) {
5695         default_floppy = 0;
5696     }
5697     if (machine->no_cdrom) {
5698         default_cdrom = 0;
5699     }
5700     if (machine->no_sdcard) {
5701         default_sdcard = 0;
5702     }
5703
5704     if (display_type == DT_NOGRAPHIC) {
5705         if (default_parallel)
5706             add_device_config(DEV_PARALLEL, "null");
5707         if (default_serial && default_monitor) {
5708             add_device_config(DEV_SERIAL, "mon:stdio");
5709         } else if (default_virtcon && default_monitor) {
5710             add_device_config(DEV_VIRTCON, "mon:stdio");
5711         } else {
5712             if (default_serial)
5713                 add_device_config(DEV_SERIAL, "stdio");
5714             if (default_virtcon)
5715                 add_device_config(DEV_VIRTCON, "stdio");
5716             if (default_monitor)
5717                 monitor_parse("stdio", "readline");
5718         }
5719     } else {
5720         if (default_serial)
5721             add_device_config(DEV_SERIAL, "vc:80Cx24C");
5722         if (default_parallel)
5723             add_device_config(DEV_PARALLEL, "vc:80Cx24C");
5724         if (default_monitor)
5725             monitor_parse("vc:80Cx24C", "readline");
5726         if (default_virtcon)
5727             add_device_config(DEV_VIRTCON, "vc:80Cx24C");
5728     }
5729     if (default_vga)
5730         vga_interface_type = VGA_CIRRUS;
5731
5732     if (qemu_opts_foreach(&qemu_chardev_opts, chardev_init_func, NULL, 1) != 0)
5733         exit(1);
5734
5735 #ifndef _WIN32
5736     if (daemonize) {
5737         pid_t pid;
5738
5739         if (pipe(fds) == -1)
5740             exit(1);
5741
5742         pid = fork();
5743         if (pid > 0) {
5744             uint8_t status;
5745             ssize_t len;
5746
5747             close(fds[1]);
5748
5749         again:
5750             len = read(fds[0], &status, 1);
5751             if (len == -1 && (errno == EINTR))
5752                 goto again;
5753
5754             if (len != 1)
5755                 exit(1);
5756             else if (status == 1) {
5757                 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
5758                 exit(1);
5759             } else
5760                 exit(0);
5761         } else if (pid < 0)
5762             exit(1);
5763
5764         close(fds[0]);
5765         qemu_set_cloexec(fds[1]);
5766
5767         setsid();
5768
5769         pid = fork();
5770         if (pid > 0)
5771             exit(0);
5772         else if (pid < 0)
5773             exit(1);
5774
5775         umask(027);
5776
5777         signal(SIGTSTP, SIG_IGN);
5778         signal(SIGTTOU, SIG_IGN);
5779         signal(SIGTTIN, SIG_IGN);
5780     }
5781 #endif
5782
5783     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5784 #ifndef _WIN32
5785         if (daemonize) {
5786             uint8_t status = 1;
5787             if (write(fds[1], &status, 1) != 1) {
5788                 perror("daemonize. Writing to pipe\n");
5789             }
5790         } else
5791 #endif
5792             fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
5793         exit(1);
5794     }
5795
5796     if (kvm_enabled()) {
5797         int ret;
5798
5799         ret = kvm_init(smp_cpus);
5800         if (ret < 0) {
5801             fprintf(stderr, "failed to initialize KVM\n");
5802             exit(1);
5803         }
5804     }
5805
5806     if (qemu_init_main_loop()) {
5807         fprintf(stderr, "qemu_init_main_loop failed\n");
5808         exit(1);
5809     }
5810     linux_boot = (kernel_filename != NULL);
5811
5812     if (!linux_boot && *kernel_cmdline != '\0') {
5813         fprintf(stderr, "-append only allowed with -kernel option\n");
5814         exit(1);
5815     }
5816
5817     if (!linux_boot && initrd_filename != NULL) {
5818         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5819         exit(1);
5820     }
5821
5822 #ifndef _WIN32
5823     /* Win32 doesn't support line-buffering and requires size >= 2 */
5824     setvbuf(stdout, NULL, _IOLBF, 0);
5825 #endif
5826
5827     if (init_timer_alarm() < 0) {
5828         fprintf(stderr, "could not initialize alarm timer\n");
5829         exit(1);
5830     }
5831     if (use_icount && icount_time_shift < 0) {
5832         use_icount = 2;
5833         /* 125MIPS seems a reasonable initial guess at the guest speed.
5834            It will be corrected fairly quickly anyway.  */
5835         icount_time_shift = 3;
5836         init_icount_adjust();
5837     }
5838
5839 #ifdef _WIN32
5840     socket_init();
5841 #endif
5842
5843     if (net_init_clients() < 0) {
5844         exit(1);
5845     }
5846
5847     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5848     net_set_boot_mask(net_boot);
5849
5850     /* init the bluetooth world */
5851     if (foreach_device_config(DEV_BT, bt_parse))
5852         exit(1);
5853
5854     /* init the memory */
5855     if (ram_size == 0)
5856         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5857
5858     /* init the dynamic translator */
5859     cpu_exec_init_all(tb_size * 1024 * 1024);
5860
5861     bdrv_init_with_whitelist();
5862
5863     blk_mig_init();
5864
5865     if (default_cdrom) {
5866         /* we always create the cdrom drive, even if no disk is there */
5867         drive_add(NULL, CDROM_ALIAS);
5868     }
5869
5870     if (default_floppy) {
5871         /* we always create at least one floppy */
5872         drive_add(NULL, FD_ALIAS, 0);
5873     }
5874
5875     if (default_sdcard) {
5876         /* we always create one sd slot, even if no card is in it */
5877         drive_add(NULL, SD_ALIAS);
5878     }
5879
5880     /* open the virtual block devices */
5881     if (snapshot)
5882         qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5883     if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5884         exit(1);
5885
5886     vmstate_register(0, &vmstate_timers ,&timers_state);
5887     register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
5888                          ram_load, NULL);
5889
5890     if (nb_numa_nodes > 0) {
5891         int i;
5892
5893         if (nb_numa_nodes > smp_cpus) {
5894             nb_numa_nodes = smp_cpus;
5895         }
5896
5897         /* If no memory size if given for any node, assume the default case
5898          * and distribute the available memory equally across all nodes
5899          */
5900         for (i = 0; i < nb_numa_nodes; i++) {
5901             if (node_mem[i] != 0)
5902                 break;
5903         }
5904         if (i == nb_numa_nodes) {
5905             uint64_t usedmem = 0;
5906
5907             /* On Linux, the each node's border has to be 8MB aligned,
5908              * the final node gets the rest.
5909              */
5910             for (i = 0; i < nb_numa_nodes - 1; i++) {
5911                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5912                 usedmem += node_mem[i];
5913             }
5914             node_mem[i] = ram_size - usedmem;
5915         }
5916
5917         for (i = 0; i < nb_numa_nodes; i++) {
5918             if (node_cpumask[i] != 0)
5919                 break;
5920         }
5921         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5922          * must cope with this anyway, because there are BIOSes out there in
5923          * real machines which also use this scheme.
5924          */
5925         if (i == nb_numa_nodes) {
5926             for (i = 0; i < smp_cpus; i++) {
5927                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5928             }
5929         }
5930     }
5931
5932     if (foreach_device_config(DEV_SERIAL, serial_parse) < 0)
5933         exit(1);
5934     if (foreach_device_config(DEV_PARALLEL, parallel_parse) < 0)
5935         exit(1);
5936     if (foreach_device_config(DEV_VIRTCON, virtcon_parse) < 0)
5937         exit(1);
5938     if (foreach_device_config(DEV_DEBUGCON, debugcon_parse) < 0)
5939         exit(1);
5940
5941     module_call_init(MODULE_INIT_DEVICE);
5942
5943     if (qemu_opts_foreach(&qemu_device_opts, device_help_func, NULL, 0) != 0)
5944         exit(0);
5945
5946     if (watchdog) {
5947         i = select_watchdog(watchdog);
5948         if (i > 0)
5949             exit (i == 1 ? 1 : 0);
5950     }
5951
5952     if (machine->compat_props) {
5953         qdev_prop_register_global_list(machine->compat_props);
5954     }
5955     qemu_add_globals();
5956
5957     machine->init(ram_size, boot_devices,
5958                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5959
5960     cpu_synchronize_all_post_init();
5961
5962 #ifndef _WIN32
5963     /* must be after terminal init, SDL library changes signal handlers */
5964     sighandler_setup();
5965 #endif
5966
5967     for (env = first_cpu; env != NULL; env = env->next_cpu) {
5968         for (i = 0; i < nb_numa_nodes; i++) {
5969             if (node_cpumask[i] & (1 << env->cpu_index)) {
5970                 env->numa_node = i;
5971             }
5972         }
5973     }
5974
5975     current_machine = machine;
5976
5977     /* init USB devices */
5978     if (usb_enabled) {
5979         if (foreach_device_config(DEV_USB, usb_parse) < 0)
5980             exit(1);
5981     }
5982
5983     /* init generic devices */
5984     if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5985         exit(1);
5986
5987     net_check_clients();
5988
5989     /* just use the first displaystate for the moment */
5990     ds = get_displaystate();
5991
5992     if (display_type == DT_DEFAULT) {
5993 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5994         display_type = DT_SDL;
5995 #else
5996         display_type = DT_VNC;
5997         vnc_display = "localhost:0,to=99";
5998         show_vnc_port = 1;
5999 #endif
6000     }
6001
6002
6003     switch (display_type) {
6004     case DT_NOGRAPHIC:
6005         break;
6006 #if defined(CONFIG_CURSES)
6007     case DT_CURSES:
6008         curses_display_init(ds, full_screen);
6009         break;
6010 #endif
6011 #if defined(CONFIG_SDL)
6012     case DT_SDL:
6013         sdl_display_init(ds, full_screen, no_frame);
6014         break;
6015 #elif defined(CONFIG_COCOA)
6016     case DT_SDL:
6017         cocoa_display_init(ds, full_screen);
6018         break;
6019 #endif
6020     case DT_VNC:
6021         vnc_display_init(ds);
6022         if (vnc_display_open(ds, vnc_display) < 0)
6023             exit(1);
6024
6025         if (show_vnc_port) {
6026             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
6027         }
6028         break;
6029     default:
6030         break;
6031     }
6032     dpy_resize(ds);
6033
6034     dcl = ds->listeners;
6035     while (dcl != NULL) {
6036         if (dcl->dpy_refresh != NULL) {
6037             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
6038             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
6039         }
6040         dcl = dcl->next;
6041     }
6042
6043     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
6044         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
6045         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
6046     }
6047
6048     text_consoles_set_display(ds);
6049
6050     if (qemu_opts_foreach(&qemu_mon_opts, mon_init_func, NULL, 1) != 0)
6051         exit(1);
6052
6053     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
6054         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
6055                 gdbstub_dev);
6056         exit(1);
6057     }
6058
6059     qdev_machine_creation_done();
6060
6061     if (rom_load_all() != 0) {
6062         fprintf(stderr, "rom loading failed\n");
6063         exit(1);
6064     }
6065
6066     qemu_system_reset();
6067     if (loadvm) {
6068         if (load_vmstate(cur_mon, loadvm) < 0) {
6069             autostart = 0;
6070         }
6071     }
6072
6073     if (incoming) {
6074         qemu_start_incoming_migration(incoming);
6075     } else if (autostart) {
6076         vm_start();
6077     }
6078
6079 #ifndef _WIN32
6080     if (daemonize) {
6081         uint8_t status = 0;
6082         ssize_t len;
6083
6084     again1:
6085         len = write(fds[1], &status, 1);
6086         if (len == -1 && (errno == EINTR))
6087             goto again1;
6088
6089         if (len != 1)
6090             exit(1);
6091
6092         if (chdir("/")) {
6093             perror("not able to chdir to /");
6094             exit(1);
6095         }
6096         TFR(fd = qemu_open("/dev/null", O_RDWR));
6097         if (fd == -1)
6098             exit(1);
6099     }
6100
6101     if (run_as) {
6102         pwd = getpwnam(run_as);
6103         if (!pwd) {
6104             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
6105             exit(1);
6106         }
6107     }
6108
6109     if (chroot_dir) {
6110         if (chroot(chroot_dir) < 0) {
6111             fprintf(stderr, "chroot failed\n");
6112             exit(1);
6113         }
6114         if (chdir("/")) {
6115             perror("not able to chdir to /");
6116             exit(1);
6117         }
6118     }
6119
6120     if (run_as) {
6121         if (setgid(pwd->pw_gid) < 0) {
6122             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
6123             exit(1);
6124         }
6125         if (setuid(pwd->pw_uid) < 0) {
6126             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
6127             exit(1);
6128         }
6129         if (setuid(0) != -1) {
6130             fprintf(stderr, "Dropping privileges failed\n");
6131             exit(1);
6132         }
6133     }
6134
6135     if (daemonize) {
6136         dup2(fd, 0);
6137         dup2(fd, 1);
6138         dup2(fd, 2);
6139
6140         close(fd);
6141     }
6142 #endif
6143
6144     main_loop();
6145     quit_timers();
6146     net_cleanup();
6147
6148     return 0;
6149 }