vl.c

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