vl.c

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