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