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(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 (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
2938         qemu_file_set_error(f);
2939         return 0;
2940     }
2941
2942     if (stage == 1) {
2943         /* Make sure all dirty bits are set */
2944         for (addr = 0; addr < last_ram_offset; addr += TARGET_PAGE_SIZE) {
2945             if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG))
2946                 cpu_physical_memory_set_dirty(addr);
2947         }
2948
2949         /* Enable dirty memory tracking */
2950         cpu_physical_memory_set_dirty_tracking(1);
2951
2952         qemu_put_be64(f, last_ram_offset | RAM_SAVE_FLAG_MEM_SIZE);
2953     }
2954
2955     bytes_transferred_last = bytes_transferred;
2956     bwidth = get_clock();
2957
2958     while (!qemu_file_rate_limit(f)) {
2959         int ret;
2960
2961         ret = ram_save_block(f);
2962         bytes_transferred += ret * TARGET_PAGE_SIZE;
2963         if (ret == 0) /* no more blocks */
2964             break;
2965     }
2966
2967     bwidth = get_clock() - bwidth;
2968     bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
2969
2970     /* if we haven't transferred anything this round, force expected_time to a
2971      * a very high value, but without crashing */
2972     if (bwidth == 0)
2973         bwidth = 0.000001;
2974
2975     /* try transferring iterative blocks of memory */
2976     if (stage == 3) {
2977         /* flush all remaining blocks regardless of rate limiting */
2978         while (ram_save_block(f) != 0) {
2979             bytes_transferred += TARGET_PAGE_SIZE;
2980         }
2981         cpu_physical_memory_set_dirty_tracking(0);
2982     }
2983
2984     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
2985
2986     expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
2987
2988     return (stage == 2) && (expected_time <= migrate_max_downtime());
2989 }
2990
2991 static int ram_load(QEMUFile *f, void *opaque, int version_id)
2992 {
2993     ram_addr_t addr;
2994     int flags;
2995
2996     if (version_id != 3)
2997         return -EINVAL;
2998
2999     do {
3000         addr = qemu_get_be64(f);
3001
3002         flags = addr & ~TARGET_PAGE_MASK;
3003         addr &= TARGET_PAGE_MASK;
3004
3005         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
3006             if (addr != last_ram_offset)
3007                 return -EINVAL;
3008         }
3009
3010         if (flags & RAM_SAVE_FLAG_COMPRESS) {
3011             uint8_t ch = qemu_get_byte(f);
3012             memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
3013 #ifndef _WIN32
3014             if (ch == 0 &&
3015                 (!kvm_enabled() || kvm_has_sync_mmu())) {
3016                 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE, MADV_DONTNEED);
3017             }
3018 #endif
3019         } else if (flags & RAM_SAVE_FLAG_PAGE)
3020             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
3021     } while (!(flags & RAM_SAVE_FLAG_EOS));
3022
3023     return 0;
3024 }
3025
3026 void qemu_service_io(void)
3027 {
3028     qemu_notify_event();
3029 }
3030
3031 /***********************************************************/
3032 /* machine registration */
3033
3034 static QEMUMachine *first_machine = NULL;
3035 QEMUMachine *current_machine = NULL;
3036
3037 int qemu_register_machine(QEMUMachine *m)
3038 {
3039     QEMUMachine **pm;
3040     pm = &first_machine;
3041     while (*pm != NULL)
3042         pm = &(*pm)->next;
3043     m->next = NULL;
3044     *pm = m;
3045     return 0;
3046 }
3047
3048 static QEMUMachine *find_machine(const char *name)
3049 {
3050     QEMUMachine *m;
3051
3052     for(m = first_machine; m != NULL; m = m->next) {
3053         if (!strcmp(m->name, name))
3054             return m;
3055         if (m->alias && !strcmp(m->alias, name))
3056             return m;
3057     }
3058     return NULL;
3059 }
3060
3061 static QEMUMachine *find_default_machine(void)
3062 {
3063     QEMUMachine *m;
3064
3065     for(m = first_machine; m != NULL; m = m->next) {
3066         if (m->is_default) {
3067             return m;
3068         }
3069     }
3070     return NULL;
3071 }
3072
3073 /***********************************************************/
3074 /* main execution loop */
3075
3076 static void gui_update(void *opaque)
3077 {
3078     uint64_t interval = GUI_REFRESH_INTERVAL;
3079     DisplayState *ds = opaque;
3080     DisplayChangeListener *dcl = ds->listeners;
3081
3082     dpy_refresh(ds);
3083
3084     while (dcl != NULL) {
3085         if (dcl->gui_timer_interval &&
3086             dcl->gui_timer_interval < interval)
3087             interval = dcl->gui_timer_interval;
3088         dcl = dcl->next;
3089     }
3090     qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock));
3091 }
3092
3093 static void nographic_update(void *opaque)
3094 {
3095     uint64_t interval = GUI_REFRESH_INTERVAL;
3096
3097     qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock));
3098 }
3099
3100 struct vm_change_state_entry {
3101     VMChangeStateHandler *cb;
3102     void *opaque;
3103     QLIST_ENTRY (vm_change_state_entry) entries;
3104 };
3105
3106 static QLIST_HEAD(vm_change_state_head, vm_change_state_entry) vm_change_state_head;
3107
3108 VMChangeStateEntry *qemu_add_vm_change_state_handler(VMChangeStateHandler *cb,
3109                                                      void *opaque)
3110 {
3111     VMChangeStateEntry *e;
3112
3113     e = qemu_mallocz(sizeof (*e));
3114
3115     e->cb = cb;
3116     e->opaque = opaque;
3117     QLIST_INSERT_HEAD(&vm_change_state_head, e, entries);
3118     return e;
3119 }
3120
3121 void qemu_del_vm_change_state_handler(VMChangeStateEntry *e)
3122 {
3123     QLIST_REMOVE (e, entries);
3124     qemu_free (e);
3125 }
3126
3127 static void vm_state_notify(int running, int reason)
3128 {
3129     VMChangeStateEntry *e;
3130
3131     for (e = vm_change_state_head.lh_first; e; e = e->entries.le_next) {
3132         e->cb(e->opaque, running, reason);
3133     }
3134 }
3135
3136 static void resume_all_vcpus(void);
3137 static void pause_all_vcpus(void);
3138
3139 void vm_start(void)
3140 {
3141     if (!vm_running) {
3142         cpu_enable_ticks();
3143         vm_running = 1;
3144         vm_state_notify(1, 0);
3145         qemu_rearm_alarm_timer(alarm_timer);
3146         resume_all_vcpus();
3147     }
3148 }
3149
3150 /* reset/shutdown handler */
3151
3152 typedef struct QEMUResetEntry {
3153     QTAILQ_ENTRY(QEMUResetEntry) entry;
3154     QEMUResetHandler *func;
3155     void *opaque;
3156 } QEMUResetEntry;
3157
3158 static QTAILQ_HEAD(reset_handlers, QEMUResetEntry) reset_handlers =
3159     QTAILQ_HEAD_INITIALIZER(reset_handlers);
3160 static int reset_requested;
3161 static int shutdown_requested;
3162 static int powerdown_requested;
3163 static int debug_requested;
3164 static int vmstop_requested;
3165
3166 int qemu_shutdown_requested(void)
3167 {
3168     int r = shutdown_requested;
3169     shutdown_requested = 0;
3170     return r;
3171 }
3172
3173 int qemu_reset_requested(void)
3174 {
3175     int r = reset_requested;
3176     reset_requested = 0;
3177     return r;
3178 }
3179
3180 int qemu_powerdown_requested(void)
3181 {
3182     int r = powerdown_requested;
3183     powerdown_requested = 0;
3184     return r;
3185 }
3186
3187 static int qemu_debug_requested(void)
3188 {
3189     int r = debug_requested;
3190     debug_requested = 0;
3191     return r;
3192 }
3193
3194 static int qemu_vmstop_requested(void)
3195 {
3196     int r = vmstop_requested;
3197     vmstop_requested = 0;
3198     return r;
3199 }
3200
3201 static void do_vm_stop(int reason)
3202 {
3203     if (vm_running) {
3204         cpu_disable_ticks();
3205         vm_running = 0;
3206         pause_all_vcpus();
3207         vm_state_notify(0, reason);
3208     }
3209 }
3210
3211 void qemu_register_reset(QEMUResetHandler *func, void *opaque)
3212 {
3213     QEMUResetEntry *re = qemu_mallocz(sizeof(QEMUResetEntry));
3214
3215     re->func = func;
3216     re->opaque = opaque;
3217     QTAILQ_INSERT_TAIL(&reset_handlers, re, entry);
3218 }
3219
3220 void qemu_unregister_reset(QEMUResetHandler *func, void *opaque)
3221 {
3222     QEMUResetEntry *re;
3223
3224     QTAILQ_FOREACH(re, &reset_handlers, entry) {
3225         if (re->func == func && re->opaque == opaque) {
3226             QTAILQ_REMOVE(&reset_handlers, re, entry);
3227             qemu_free(re);
3228             return;
3229         }
3230     }
3231 }
3232
3233 void qemu_system_reset(void)
3234 {
3235     QEMUResetEntry *re, *nre;
3236
3237     /* reset all devices */
3238     QTAILQ_FOREACH_SAFE(re, &reset_handlers, entry, nre) {
3239         re->func(re->opaque);
3240     }
3241 }
3242
3243 void qemu_system_reset_request(void)
3244 {
3245     if (no_reboot) {
3246         shutdown_requested = 1;
3247     } else {
3248         reset_requested = 1;
3249     }
3250     qemu_notify_event();
3251 }
3252
3253 void qemu_system_shutdown_request(void)
3254 {
3255     shutdown_requested = 1;
3256     qemu_notify_event();
3257 }
3258
3259 void qemu_system_powerdown_request(void)
3260 {
3261     powerdown_requested = 1;
3262     qemu_notify_event();
3263 }
3264
3265 #ifdef CONFIG_IOTHREAD
3266 static void qemu_system_vmstop_request(int reason)
3267 {
3268     vmstop_requested = reason;
3269     qemu_notify_event();
3270 }
3271 #endif
3272
3273 #ifndef _WIN32
3274 static int io_thread_fd = -1;
3275
3276 static void qemu_event_increment(void)
3277 {
3278     static const char byte = 0;
3279
3280     if (io_thread_fd == -1)
3281         return;
3282
3283     write(io_thread_fd, &byte, sizeof(byte));
3284 }
3285
3286 static void qemu_event_read(void *opaque)
3287 {
3288     int fd = (unsigned long)opaque;
3289     ssize_t len;
3290
3291     /* Drain the notify pipe */
3292     do {
3293         char buffer[512];
3294         len = read(fd, buffer, sizeof(buffer));
3295     } while ((len == -1 && errno == EINTR) || len > 0);
3296 }
3297
3298 static int qemu_event_init(void)
3299 {
3300     int err;
3301     int fds[2];
3302
3303     err = pipe(fds);
3304     if (err == -1)
3305         return -errno;
3306
3307     err = fcntl_setfl(fds[0], O_NONBLOCK);
3308     if (err < 0)
3309         goto fail;
3310
3311     err = fcntl_setfl(fds[1], O_NONBLOCK);
3312     if (err < 0)
3313         goto fail;
3314
3315     qemu_set_fd_handler2(fds[0], NULL, qemu_event_read, NULL,
3316                          (void *)(unsigned long)fds[0]);
3317
3318     io_thread_fd = fds[1];
3319     return 0;
3320
3321 fail:
3322     close(fds[0]);
3323     close(fds[1]);
3324     return err;
3325 }
3326 #else
3327 HANDLE qemu_event_handle;
3328
3329 static void dummy_event_handler(void *opaque)
3330 {
3331 }
3332
3333 static int qemu_event_init(void)
3334 {
3335     qemu_event_handle = CreateEvent(NULL, FALSE, FALSE, NULL);
3336     if (!qemu_event_handle) {
3337         fprintf(stderr, "Failed CreateEvent: %ld\n", GetLastError());
3338         return -1;
3339     }
3340     qemu_add_wait_object(qemu_event_handle, dummy_event_handler, NULL);
3341     return 0;
3342 }
3343
3344 static void qemu_event_increment(void)
3345 {
3346     if (!SetEvent(qemu_event_handle)) {
3347         fprintf(stderr, "qemu_event_increment: SetEvent failed: %ld\n",
3348                 GetLastError());
3349         exit (1);
3350     }
3351 }
3352 #endif
3353
3354 static int cpu_can_run(CPUState *env)
3355 {
3356     if (env->stop)
3357         return 0;
3358     if (env->stopped)
3359         return 0;
3360     return 1;
3361 }
3362
3363 #ifndef CONFIG_IOTHREAD
3364 static int qemu_init_main_loop(void)
3365 {
3366     return qemu_event_init();
3367 }
3368
3369 void qemu_init_vcpu(void *_env)
3370 {
3371     CPUState *env = _env;
3372
3373     if (kvm_enabled())
3374         kvm_init_vcpu(env);
3375     env->nr_cores = smp_cores;
3376     env->nr_threads = smp_threads;
3377     return;
3378 }
3379
3380 int qemu_cpu_self(void *env)
3381 {
3382     return 1;
3383 }
3384
3385 static void resume_all_vcpus(void)
3386 {
3387 }
3388
3389 static void pause_all_vcpus(void)
3390 {
3391 }
3392
3393 void qemu_cpu_kick(void *env)
3394 {
3395     return;
3396 }
3397
3398 void qemu_notify_event(void)
3399 {
3400     CPUState *env = cpu_single_env;
3401
3402     if (env) {
3403         cpu_exit(env);
3404     }
3405 }
3406
3407 void qemu_mutex_lock_iothread(void) {}
3408 void qemu_mutex_unlock_iothread(void) {}
3409
3410 void vm_stop(int reason)
3411 {
3412     do_vm_stop(reason);
3413 }
3414
3415 #else /* CONFIG_IOTHREAD */
3416
3417 #include "qemu-thread.h"
3418
3419 QemuMutex qemu_global_mutex;
3420 static QemuMutex qemu_fair_mutex;
3421
3422 static QemuThread io_thread;
3423
3424 static QemuThread *tcg_cpu_thread;
3425 static QemuCond *tcg_halt_cond;
3426
3427 static int qemu_system_ready;
3428 /* cpu creation */
3429 static QemuCond qemu_cpu_cond;
3430 /* system init */
3431 static QemuCond qemu_system_cond;
3432 static QemuCond qemu_pause_cond;
3433
3434 static void block_io_signals(void);
3435 static void unblock_io_signals(void);
3436 static int tcg_has_work(void);
3437
3438 static int qemu_init_main_loop(void)
3439 {
3440     int ret;
3441
3442     ret = qemu_event_init();
3443     if (ret)
3444         return ret;
3445
3446     qemu_cond_init(&qemu_pause_cond);
3447     qemu_mutex_init(&qemu_fair_mutex);
3448     qemu_mutex_init(&qemu_global_mutex);
3449     qemu_mutex_lock(&qemu_global_mutex);
3450
3451     unblock_io_signals();
3452     qemu_thread_self(&io_thread);
3453
3454     return 0;
3455 }
3456
3457 static void qemu_wait_io_event(CPUState *env)
3458 {
3459     while (!tcg_has_work())
3460         qemu_cond_timedwait(env->halt_cond, &qemu_global_mutex, 1000);
3461
3462     qemu_mutex_unlock(&qemu_global_mutex);
3463
3464     /*
3465      * Users of qemu_global_mutex can be starved, having no chance
3466      * to acquire it since this path will get to it first.
3467      * So use another lock to provide fairness.
3468      */
3469     qemu_mutex_lock(&qemu_fair_mutex);
3470     qemu_mutex_unlock(&qemu_fair_mutex);
3471
3472     qemu_mutex_lock(&qemu_global_mutex);
3473     if (env->stop) {
3474         env->stop = 0;
3475         env->stopped = 1;
3476         qemu_cond_signal(&qemu_pause_cond);
3477     }
3478 }
3479
3480 static int qemu_cpu_exec(CPUState *env);
3481
3482 static void *kvm_cpu_thread_fn(void *arg)
3483 {
3484     CPUState *env = arg;
3485
3486     block_io_signals();
3487     qemu_thread_self(env->thread);
3488     if (kvm_enabled())
3489         kvm_init_vcpu(env);
3490
3491     /* signal CPU creation */
3492     qemu_mutex_lock(&qemu_global_mutex);
3493     env->created = 1;
3494     qemu_cond_signal(&qemu_cpu_cond);
3495
3496     /* and wait for machine initialization */
3497     while (!qemu_system_ready)
3498         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3499
3500     while (1) {
3501         if (cpu_can_run(env))
3502             qemu_cpu_exec(env);
3503         qemu_wait_io_event(env);
3504     }
3505
3506     return NULL;
3507 }
3508
3509 static void tcg_cpu_exec(void);
3510
3511 static void *tcg_cpu_thread_fn(void *arg)
3512 {
3513     CPUState *env = arg;
3514
3515     block_io_signals();
3516     qemu_thread_self(env->thread);
3517
3518     /* signal CPU creation */
3519     qemu_mutex_lock(&qemu_global_mutex);
3520     for (env = first_cpu; env != NULL; env = env->next_cpu)
3521         env->created = 1;
3522     qemu_cond_signal(&qemu_cpu_cond);
3523
3524     /* and wait for machine initialization */
3525     while (!qemu_system_ready)
3526         qemu_cond_timedwait(&qemu_system_cond, &qemu_global_mutex, 100);
3527
3528     while (1) {
3529         tcg_cpu_exec();
3530         qemu_wait_io_event(cur_cpu);
3531     }
3532
3533     return NULL;
3534 }
3535
3536 void qemu_cpu_kick(void *_env)
3537 {
3538     CPUState *env = _env;
3539     qemu_cond_broadcast(env->halt_cond);
3540     if (kvm_enabled())
3541         qemu_thread_signal(env->thread, SIGUSR1);
3542 }
3543
3544 int qemu_cpu_self(void *_env)
3545 {
3546     CPUState *env = _env;
3547     QemuThread this;
3548
3549     qemu_thread_self(&this);
3550
3551     return qemu_thread_equal(&this, env->thread);
3552 }
3553
3554 static void cpu_signal(int sig)
3555 {
3556     if (cpu_single_env)
3557         cpu_exit(cpu_single_env);
3558 }
3559
3560 static void block_io_signals(void)
3561 {
3562     sigset_t set;
3563     struct sigaction sigact;
3564
3565     sigemptyset(&set);
3566     sigaddset(&set, SIGUSR2);
3567     sigaddset(&set, SIGIO);
3568     sigaddset(&set, SIGALRM);
3569     pthread_sigmask(SIG_BLOCK, &set, NULL);
3570
3571     sigemptyset(&set);
3572     sigaddset(&set, SIGUSR1);
3573     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3574
3575     memset(&sigact, 0, sizeof(sigact));
3576     sigact.sa_handler = cpu_signal;
3577     sigaction(SIGUSR1, &sigact, NULL);
3578 }
3579
3580 static void unblock_io_signals(void)
3581 {
3582     sigset_t set;
3583
3584     sigemptyset(&set);
3585     sigaddset(&set, SIGUSR2);
3586     sigaddset(&set, SIGIO);
3587     sigaddset(&set, SIGALRM);
3588     pthread_sigmask(SIG_UNBLOCK, &set, NULL);
3589
3590     sigemptyset(&set);
3591     sigaddset(&set, SIGUSR1);
3592     pthread_sigmask(SIG_BLOCK, &set, NULL);
3593 }
3594
3595 static void qemu_signal_lock(unsigned int msecs)
3596 {
3597     qemu_mutex_lock(&qemu_fair_mutex);
3598
3599     while (qemu_mutex_trylock(&qemu_global_mutex)) {
3600         qemu_thread_signal(tcg_cpu_thread, SIGUSR1);
3601         if (!qemu_mutex_timedlock(&qemu_global_mutex, msecs))
3602             break;
3603     }
3604     qemu_mutex_unlock(&qemu_fair_mutex);
3605 }
3606
3607 void qemu_mutex_lock_iothread(void)
3608 {
3609     if (kvm_enabled()) {
3610         qemu_mutex_lock(&qemu_fair_mutex);
3611         qemu_mutex_lock(&qemu_global_mutex);
3612         qemu_mutex_unlock(&qemu_fair_mutex);
3613     } else
3614         qemu_signal_lock(100);
3615 }
3616
3617 void qemu_mutex_unlock_iothread(void)
3618 {
3619     qemu_mutex_unlock(&qemu_global_mutex);
3620 }
3621
3622 static int all_vcpus_paused(void)
3623 {
3624     CPUState *penv = first_cpu;
3625
3626     while (penv) {
3627         if (!penv->stopped)
3628             return 0;
3629         penv = (CPUState *)penv->next_cpu;
3630     }
3631
3632     return 1;
3633 }
3634
3635 static void pause_all_vcpus(void)
3636 {
3637     CPUState *penv = first_cpu;
3638
3639     while (penv) {
3640         penv->stop = 1;
3641         qemu_thread_signal(penv->thread, SIGUSR1);
3642         qemu_cpu_kick(penv);
3643         penv = (CPUState *)penv->next_cpu;
3644     }
3645
3646     while (!all_vcpus_paused()) {
3647         qemu_cond_timedwait(&qemu_pause_cond, &qemu_global_mutex, 100);
3648         penv = first_cpu;
3649         while (penv) {
3650             qemu_thread_signal(penv->thread, SIGUSR1);
3651             penv = (CPUState *)penv->next_cpu;
3652         }
3653     }
3654 }
3655
3656 static void resume_all_vcpus(void)
3657 {
3658     CPUState *penv = first_cpu;
3659
3660     while (penv) {
3661         penv->stop = 0;
3662         penv->stopped = 0;
3663         qemu_thread_signal(penv->thread, SIGUSR1);
3664         qemu_cpu_kick(penv);
3665         penv = (CPUState *)penv->next_cpu;
3666     }
3667 }
3668
3669 static void tcg_init_vcpu(void *_env)
3670 {
3671     CPUState *env = _env;
3672     /* share a single thread for all cpus with TCG */
3673     if (!tcg_cpu_thread) {
3674         env->thread = qemu_mallocz(sizeof(QemuThread));
3675         env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3676         qemu_cond_init(env->halt_cond);
3677         qemu_thread_create(env->thread, tcg_cpu_thread_fn, env);
3678         while (env->created == 0)
3679             qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3680         tcg_cpu_thread = env->thread;
3681         tcg_halt_cond = env->halt_cond;
3682     } else {
3683         env->thread = tcg_cpu_thread;
3684         env->halt_cond = tcg_halt_cond;
3685     }
3686 }
3687
3688 static void kvm_start_vcpu(CPUState *env)
3689 {
3690     env->thread = qemu_mallocz(sizeof(QemuThread));
3691     env->halt_cond = qemu_mallocz(sizeof(QemuCond));
3692     qemu_cond_init(env->halt_cond);
3693     qemu_thread_create(env->thread, kvm_cpu_thread_fn, env);
3694     while (env->created == 0)
3695         qemu_cond_timedwait(&qemu_cpu_cond, &qemu_global_mutex, 100);
3696 }
3697
3698 void qemu_init_vcpu(void *_env)
3699 {
3700     CPUState *env = _env;
3701
3702     if (kvm_enabled())
3703         kvm_start_vcpu(env);
3704     else
3705         tcg_init_vcpu(env);
3706     env->nr_cores = smp_cores;
3707     env->nr_threads = smp_threads;
3708 }
3709
3710 void qemu_notify_event(void)
3711 {
3712     qemu_event_increment();
3713 }
3714
3715 void vm_stop(int reason)
3716 {
3717     QemuThread me;
3718     qemu_thread_self(&me);
3719
3720     if (!qemu_thread_equal(&me, &io_thread)) {
3721         qemu_system_vmstop_request(reason);
3722         /*
3723          * FIXME: should not return to device code in case
3724          * vm_stop() has been requested.
3725          */
3726         if (cpu_single_env) {
3727             cpu_exit(cpu_single_env);
3728             cpu_single_env->stop = 1;
3729         }
3730         return;
3731     }
3732     do_vm_stop(reason);
3733 }
3734
3735 #endif
3736
3737
3738 #ifdef _WIN32
3739 static void host_main_loop_wait(int *timeout)
3740 {
3741     int ret, ret2, i;
3742     PollingEntry *pe;
3743
3744
3745     /* XXX: need to suppress polling by better using win32 events */
3746     ret = 0;
3747     for(pe = first_polling_entry; pe != NULL; pe = pe->next) {
3748         ret |= pe->func(pe->opaque);
3749     }
3750     if (ret == 0) {
3751         int err;
3752         WaitObjects *w = &wait_objects;
3753
3754         ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout);
3755         if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) {
3756             if (w->func[ret - WAIT_OBJECT_0])
3757                 w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]);
3758
3759             /* Check for additional signaled events */
3760             for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) {
3761
3762                 /* Check if event is signaled */
3763                 ret2 = WaitForSingleObject(w->events[i], 0);
3764                 if(ret2 == WAIT_OBJECT_0) {
3765                     if (w->func[i])
3766                         w->func[i](w->opaque[i]);
3767                 } else if (ret2 == WAIT_TIMEOUT) {
3768                 } else {
3769                     err = GetLastError();
3770                     fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err);
3771                 }
3772             }
3773         } else if (ret == WAIT_TIMEOUT) {
3774         } else {
3775             err = GetLastError();
3776             fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err);
3777         }
3778     }
3779
3780     *timeout = 0;
3781 }
3782 #else
3783 static void host_main_loop_wait(int *timeout)
3784 {
3785 }
3786 #endif
3787
3788 void main_loop_wait(int timeout)
3789 {
3790     IOHandlerRecord *ioh;
3791     fd_set rfds, wfds, xfds;
3792     int ret, nfds;
3793     struct timeval tv;
3794
3795     qemu_bh_update_timeout(&timeout);
3796
3797     host_main_loop_wait(&timeout);
3798
3799     /* poll any events */
3800     /* XXX: separate device handlers from system ones */
3801     nfds = -1;
3802     FD_ZERO(&rfds);
3803     FD_ZERO(&wfds);
3804     FD_ZERO(&xfds);
3805     for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3806         if (ioh->deleted)
3807             continue;
3808         if (ioh->fd_read &&
3809             (!ioh->fd_read_poll ||
3810              ioh->fd_read_poll(ioh->opaque) != 0)) {
3811             FD_SET(ioh->fd, &rfds);
3812             if (ioh->fd > nfds)
3813                 nfds = ioh->fd;
3814         }
3815         if (ioh->fd_write) {
3816             FD_SET(ioh->fd, &wfds);
3817             if (ioh->fd > nfds)
3818                 nfds = ioh->fd;
3819         }
3820     }
3821
3822     tv.tv_sec = timeout / 1000;
3823     tv.tv_usec = (timeout % 1000) * 1000;
3824
3825     slirp_select_fill(&nfds, &rfds, &wfds, &xfds);
3826
3827     qemu_mutex_unlock_iothread();
3828     ret = select(nfds + 1, &rfds, &wfds, &xfds, &tv);
3829     qemu_mutex_lock_iothread();
3830     if (ret > 0) {
3831         IOHandlerRecord **pioh;
3832
3833         for(ioh = first_io_handler; ioh != NULL; ioh = ioh->next) {
3834             if (!ioh->deleted && ioh->fd_read && FD_ISSET(ioh->fd, &rfds)) {
3835                 ioh->fd_read(ioh->opaque);
3836             }
3837             if (!ioh->deleted && ioh->fd_write && FD_ISSET(ioh->fd, &wfds)) {
3838                 ioh->fd_write(ioh->opaque);
3839             }
3840         }
3841
3842         /* remove deleted IO handlers */
3843         pioh = &first_io_handler;
3844         while (*pioh) {
3845             ioh = *pioh;
3846             if (ioh->deleted) {
3847                 *pioh = ioh->next;
3848                 qemu_free(ioh);
3849             } else
3850                 pioh = &ioh->next;
3851         }
3852     }
3853
3854     slirp_select_poll(&rfds, &wfds, &xfds, (ret < 0));
3855
3856     /* rearm timer, if not periodic */
3857     if (alarm_timer->flags & ALARM_FLAG_EXPIRED) {
3858         alarm_timer->flags &= ~ALARM_FLAG_EXPIRED;
3859         qemu_rearm_alarm_timer(alarm_timer);
3860     }
3861
3862     /* vm time timers */
3863     if (vm_running) {
3864         if (!cur_cpu || likely(!(cur_cpu->singlestep_enabled & SSTEP_NOTIMER)))
3865             qemu_run_timers(&active_timers[QEMU_CLOCK_VIRTUAL],
3866                             qemu_get_clock(vm_clock));
3867     }
3868
3869     /* real time timers */
3870     qemu_run_timers(&active_timers[QEMU_CLOCK_REALTIME],
3871                     qemu_get_clock(rt_clock));
3872
3873     qemu_run_timers(&active_timers[QEMU_CLOCK_HOST],
3874                     qemu_get_clock(host_clock));
3875
3876     /* Check bottom-halves last in case any of the earlier events triggered
3877        them.  */
3878     qemu_bh_poll();
3879
3880 }
3881
3882 static int qemu_cpu_exec(CPUState *env)
3883 {
3884     int ret;
3885 #ifdef CONFIG_PROFILER
3886     int64_t ti;
3887 #endif
3888
3889 #ifdef CONFIG_PROFILER
3890     ti = profile_getclock();
3891 #endif
3892     if (use_icount) {
3893         int64_t count;
3894         int decr;
3895         qemu_icount -= (env->icount_decr.u16.low + env->icount_extra);
3896         env->icount_decr.u16.low = 0;
3897         env->icount_extra = 0;
3898         count = qemu_next_deadline();
3899         count = (count + (1 << icount_time_shift) - 1)
3900                 >> icount_time_shift;
3901         qemu_icount += count;
3902         decr = (count > 0xffff) ? 0xffff : count;
3903         count -= decr;
3904         env->icount_decr.u16.low = decr;
3905         env->icount_extra = count;
3906     }
3907     ret = cpu_exec(env);
3908 #ifdef CONFIG_PROFILER
3909     qemu_time += profile_getclock() - ti;
3910 #endif
3911     if (use_icount) {
3912         /* Fold pending instructions back into the
3913            instruction counter, and clear the interrupt flag.  */
3914         qemu_icount -= (env->icount_decr.u16.low
3915                         + env->icount_extra);
3916         env->icount_decr.u32 = 0;
3917         env->icount_extra = 0;
3918     }
3919     return ret;
3920 }
3921
3922 static void tcg_cpu_exec(void)
3923 {
3924     int ret = 0;
3925
3926     if (next_cpu == NULL)
3927         next_cpu = first_cpu;
3928     for (; next_cpu != NULL; next_cpu = next_cpu->next_cpu) {
3929         CPUState *env = cur_cpu = next_cpu;
3930
3931         if (!vm_running)
3932             break;
3933         if (timer_alarm_pending) {
3934             timer_alarm_pending = 0;
3935             break;
3936         }
3937         if (cpu_can_run(env))
3938             ret = qemu_cpu_exec(env);
3939         if (ret == EXCP_DEBUG) {
3940             gdb_set_stop_cpu(env);
3941             debug_requested = 1;
3942             break;
3943         }
3944     }
3945 }
3946
3947 static int cpu_has_work(CPUState *env)
3948 {
3949     if (env->stop)
3950         return 1;
3951     if (env->stopped)
3952         return 0;
3953     if (!env->halted)
3954         return 1;
3955     if (qemu_cpu_has_work(env))
3956         return 1;
3957     return 0;
3958 }
3959
3960 static int tcg_has_work(void)
3961 {
3962     CPUState *env;
3963
3964     for (env = first_cpu; env != NULL; env = env->next_cpu)
3965         if (cpu_has_work(env))
3966             return 1;
3967     return 0;
3968 }
3969
3970 static int qemu_calculate_timeout(void)
3971 {
3972 #ifndef CONFIG_IOTHREAD
3973     int timeout;
3974
3975     if (!vm_running)
3976         timeout = 5000;
3977     else if (tcg_has_work())
3978         timeout = 0;
3979     else if (!use_icount)
3980         timeout = 5000;
3981     else {
3982      /* XXX: use timeout computed from timers */
3983         int64_t add;
3984         int64_t delta;
3985         /* Advance virtual time to the next event.  */
3986         if (use_icount == 1) {
3987             /* When not using an adaptive execution frequency
3988                we tend to get badly out of sync with real time,
3989                so just delay for a reasonable amount of time.  */
3990             delta = 0;
3991         } else {
3992             delta = cpu_get_icount() - cpu_get_clock();
3993         }
3994         if (delta > 0) {
3995             /* If virtual time is ahead of real time then just
3996                wait for IO.  */
3997             timeout = (delta / 1000000) + 1;
3998         } else {
3999             /* Wait for either IO to occur or the next
4000                timer event.  */
4001             add = qemu_next_deadline();
4002             /* We advance the timer before checking for IO.
4003                Limit the amount we advance so that early IO
4004                activity won't get the guest too far ahead.  */
4005             if (add > 10000000)
4006                 add = 10000000;
4007             delta += add;
4008             add = (add + (1 << icount_time_shift) - 1)
4009                   >> icount_time_shift;
4010             qemu_icount += add;
4011             timeout = delta / 1000000;
4012             if (timeout < 0)
4013                 timeout = 0;
4014         }
4015     }
4016
4017     return timeout;
4018 #else /* CONFIG_IOTHREAD */
4019     return 1000;
4020 #endif
4021 }
4022
4023 static int vm_can_run(void)
4024 {
4025     if (powerdown_requested)
4026         return 0;
4027     if (reset_requested)
4028         return 0;
4029     if (shutdown_requested)
4030         return 0;
4031     if (debug_requested)
4032         return 0;
4033     return 1;
4034 }
4035
4036 qemu_irq qemu_system_powerdown;
4037
4038 static void main_loop(void)
4039 {
4040     int r;
4041
4042 #ifdef CONFIG_IOTHREAD
4043     qemu_system_ready = 1;
4044     qemu_cond_broadcast(&qemu_system_cond);
4045 #endif
4046
4047     for (;;) {
4048         do {
4049 #ifdef CONFIG_PROFILER
4050             int64_t ti;
4051 #endif
4052 #ifndef CONFIG_IOTHREAD
4053             tcg_cpu_exec();
4054 #endif
4055 #ifdef CONFIG_PROFILER
4056             ti = profile_getclock();
4057 #endif
4058             main_loop_wait(qemu_calculate_timeout());
4059 #ifdef CONFIG_PROFILER
4060             dev_time += profile_getclock() - ti;
4061 #endif
4062         } while (vm_can_run());
4063
4064         if (qemu_debug_requested()) {
4065             monitor_protocol_event(EVENT_DEBUG, NULL);
4066             vm_stop(EXCP_DEBUG);
4067         }
4068         if (qemu_shutdown_requested()) {
4069             monitor_protocol_event(EVENT_SHUTDOWN, NULL);
4070             if (no_shutdown) {
4071                 vm_stop(0);
4072                 no_shutdown = 0;
4073             } else
4074                 break;
4075         }
4076         if (qemu_reset_requested()) {
4077             monitor_protocol_event(EVENT_RESET, NULL);
4078             pause_all_vcpus();
4079             qemu_system_reset();
4080             resume_all_vcpus();
4081         }
4082         if (qemu_powerdown_requested()) {
4083             monitor_protocol_event(EVENT_POWERDOWN, NULL);
4084             qemu_irq_raise(qemu_system_powerdown);
4085         }
4086         if ((r = qemu_vmstop_requested())) {
4087             monitor_protocol_event(EVENT_STOP, NULL);
4088             vm_stop(r);
4089         }
4090     }
4091     pause_all_vcpus();
4092 }
4093
4094 static void version(void)
4095 {
4096     printf("QEMU PC emulator version " QEMU_VERSION QEMU_PKGVERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n");
4097 }
4098
4099 static void help(int exitcode)
4100 {
4101     version();
4102     printf("usage: %s [options] [disk_image]\n"
4103            "\n"
4104            "'disk_image' is a raw hard image image for IDE hard disk 0\n"
4105            "\n"
4106 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4107            opt_help
4108 #define DEFHEADING(text) stringify(text) "\n"
4109 #include "qemu-options.h"
4110 #undef DEF
4111 #undef DEFHEADING
4112 #undef GEN_DOCS
4113            "\n"
4114            "During emulation, the following keys are useful:\n"
4115            "ctrl-alt-f      toggle full screen\n"
4116            "ctrl-alt-n      switch to virtual console 'n'\n"
4117            "ctrl-alt        toggle mouse and keyboard grab\n"
4118            "\n"
4119            "When using -nographic, press 'ctrl-a h' to get some help.\n"
4120            ,
4121            "qemu",
4122            DEFAULT_RAM_SIZE,
4123 #ifndef _WIN32
4124            DEFAULT_NETWORK_SCRIPT,
4125            DEFAULT_NETWORK_DOWN_SCRIPT,
4126 #endif
4127            DEFAULT_GDBSTUB_PORT,
4128            "/tmp/qemu.log");
4129     exit(exitcode);
4130 }
4131
4132 #define HAS_ARG 0x0001
4133
4134 enum {
4135 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4136     opt_enum,
4137 #define DEFHEADING(text)
4138 #include "qemu-options.h"
4139 #undef DEF
4140 #undef DEFHEADING
4141 #undef GEN_DOCS
4142 };
4143
4144 typedef struct QEMUOption {
4145     const char *name;
4146     int flags;
4147     int index;
4148 } QEMUOption;
4149
4150 static const QEMUOption qemu_options[] = {
4151     { "h", 0, QEMU_OPTION_h },
4152 #define DEF(option, opt_arg, opt_enum, opt_help)        \
4153     { option, opt_arg, opt_enum },
4154 #define DEFHEADING(text)
4155 #include "qemu-options.h"
4156 #undef DEF
4157 #undef DEFHEADING
4158 #undef GEN_DOCS
4159     { NULL },
4160 };
4161
4162 #ifdef HAS_AUDIO
4163 struct soundhw soundhw[] = {
4164 #ifdef HAS_AUDIO_CHOICE
4165 #if defined(TARGET_I386) || defined(TARGET_MIPS)
4166     {
4167         "pcspk",
4168         "PC speaker",
4169         0,
4170         1,
4171         { .init_isa = pcspk_audio_init }
4172     },
4173 #endif
4174
4175 #ifdef CONFIG_SB16
4176     {
4177         "sb16",
4178         "Creative Sound Blaster 16",
4179         0,
4180         1,
4181         { .init_isa = SB16_init }
4182     },
4183 #endif
4184
4185 #ifdef CONFIG_CS4231A
4186     {
4187         "cs4231a",
4188         "CS4231A",
4189         0,
4190         1,
4191         { .init_isa = cs4231a_init }
4192     },
4193 #endif
4194
4195 #ifdef CONFIG_ADLIB
4196     {
4197         "adlib",
4198 #ifdef HAS_YMF262
4199         "Yamaha YMF262 (OPL3)",
4200 #else
4201         "Yamaha YM3812 (OPL2)",
4202 #endif
4203         0,
4204         1,
4205         { .init_isa = Adlib_init }
4206     },
4207 #endif
4208
4209 #ifdef CONFIG_GUS
4210     {
4211         "gus",
4212         "Gravis Ultrasound GF1",
4213         0,
4214         1,
4215         { .init_isa = GUS_init }
4216     },
4217 #endif
4218
4219 #ifdef CONFIG_AC97
4220     {
4221         "ac97",
4222         "Intel 82801AA AC97 Audio",
4223         0,
4224         0,
4225         { .init_pci = ac97_init }
4226     },
4227 #endif
4228
4229 #ifdef CONFIG_ES1370
4230     {
4231         "es1370",
4232         "ENSONIQ AudioPCI ES1370",
4233         0,
4234         0,
4235         { .init_pci = es1370_init }
4236     },
4237 #endif
4238
4239 #endif /* HAS_AUDIO_CHOICE */
4240
4241     { NULL, NULL, 0, 0, { NULL } }
4242 };
4243
4244 static void select_soundhw (const char *optarg)
4245 {
4246     struct soundhw *c;
4247
4248     if (*optarg == '?') {
4249     show_valid_cards:
4250
4251         printf ("Valid sound card names (comma separated):\n");
4252         for (c = soundhw; c->name; ++c) {
4253             printf ("%-11s %s\n", c->name, c->descr);
4254         }
4255         printf ("\n-soundhw all will enable all of the above\n");
4256         exit (*optarg != '?');
4257     }
4258     else {
4259         size_t l;
4260         const char *p;
4261         char *e;
4262         int bad_card = 0;
4263
4264         if (!strcmp (optarg, "all")) {
4265             for (c = soundhw; c->name; ++c) {
4266                 c->enabled = 1;
4267             }
4268             return;
4269         }
4270
4271         p = optarg;
4272         while (*p) {
4273             e = strchr (p, ',');
4274             l = !e ? strlen (p) : (size_t) (e - p);
4275
4276             for (c = soundhw; c->name; ++c) {
4277                 if (!strncmp (c->name, p, l) && !c->name[l]) {
4278                     c->enabled = 1;
4279                     break;
4280                 }
4281             }
4282
4283             if (!c->name) {
4284                 if (l > 80) {
4285                     fprintf (stderr,
4286                              "Unknown sound card name (too big to show)\n");
4287                 }
4288                 else {
4289                     fprintf (stderr, "Unknown sound card name `%.*s'\n",
4290                              (int) l, p);
4291                 }
4292                 bad_card = 1;
4293             }
4294             p += l + (e != NULL);
4295         }
4296
4297         if (bad_card)
4298             goto show_valid_cards;
4299     }
4300 }
4301 #endif
4302
4303 static void select_vgahw (const char *p)
4304 {
4305     const char *opts;
4306
4307     vga_interface_type = VGA_NONE;
4308     if (strstart(p, "std", &opts)) {
4309         vga_interface_type = VGA_STD;
4310     } else if (strstart(p, "cirrus", &opts)) {
4311         vga_interface_type = VGA_CIRRUS;
4312     } else if (strstart(p, "vmware", &opts)) {
4313         vga_interface_type = VGA_VMWARE;
4314     } else if (strstart(p, "xenfb", &opts)) {
4315         vga_interface_type = VGA_XENFB;
4316     } else if (!strstart(p, "none", &opts)) {
4317     invalid_vga:
4318         fprintf(stderr, "Unknown vga type: %s\n", p);
4319         exit(1);
4320     }
4321     while (*opts) {
4322         const char *nextopt;
4323
4324         if (strstart(opts, ",retrace=", &nextopt)) {
4325             opts = nextopt;
4326             if (strstart(opts, "dumb", &nextopt))
4327                 vga_retrace_method = VGA_RETRACE_DUMB;
4328             else if (strstart(opts, "precise", &nextopt))
4329                 vga_retrace_method = VGA_RETRACE_PRECISE;
4330             else goto invalid_vga;
4331         } else goto invalid_vga;
4332         opts = nextopt;
4333     }
4334 }
4335
4336 #ifdef TARGET_I386
4337 static int balloon_parse(const char *arg)
4338 {
4339     QemuOpts *opts;
4340
4341     if (strcmp(arg, "none") == 0) {
4342         return 0;
4343     }
4344
4345     if (!strncmp(arg, "virtio", 6)) {
4346         if (arg[6] == ',') {
4347             /* have params -> parse them */
4348             opts = qemu_opts_parse(&qemu_device_opts, arg+7, NULL);
4349             if (!opts)
4350                 return  -1;
4351         } else {
4352             /* create empty opts */
4353             opts = qemu_opts_create(&qemu_device_opts, NULL, 0);
4354         }
4355         qemu_opt_set(opts, "driver", "virtio-balloon-pci");
4356         return 0;
4357     }
4358
4359     return -1;
4360 }
4361 #endif
4362
4363 #ifdef _WIN32
4364 static BOOL WINAPI qemu_ctrl_handler(DWORD type)
4365 {
4366     exit(STATUS_CONTROL_C_EXIT);
4367     return TRUE;
4368 }
4369 #endif
4370
4371 int qemu_uuid_parse(const char *str, uint8_t *uuid)
4372 {
4373     int ret;
4374
4375     if(strlen(str) != 36)
4376         return -1;
4377
4378     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
4379             &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
4380             &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14], &uuid[15]);
4381
4382     if(ret != 16)
4383         return -1;
4384
4385 #ifdef TARGET_I386
4386     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
4387 #endif
4388
4389     return 0;
4390 }
4391
4392 #ifndef _WIN32
4393
4394 static void termsig_handler(int signal)
4395 {
4396     qemu_system_shutdown_request();
4397 }
4398
4399 static void sigchld_handler(int signal)
4400 {
4401     waitpid(-1, NULL, WNOHANG);
4402 }
4403
4404 static void sighandler_setup(void)
4405 {
4406     struct sigaction act;
4407
4408     memset(&act, 0, sizeof(act));
4409     act.sa_handler = termsig_handler;
4410     sigaction(SIGINT,  &act, NULL);
4411     sigaction(SIGHUP,  &act, NULL);
4412     sigaction(SIGTERM, &act, NULL);
4413
4414     act.sa_handler = sigchld_handler;
4415     act.sa_flags = SA_NOCLDSTOP;
4416     sigaction(SIGCHLD, &act, NULL);
4417 }
4418
4419 #endif
4420
4421 #ifdef _WIN32
4422 /* Look for support files in the same directory as the executable.  */
4423 static char *find_datadir(const char *argv0)
4424 {
4425     char *p;
4426     char buf[MAX_PATH];
4427     DWORD len;
4428
4429     len = GetModuleFileName(NULL, buf, sizeof(buf) - 1);
4430     if (len == 0) {
4431         return NULL;
4432     }
4433
4434     buf[len] = 0;
4435     p = buf + len - 1;
4436     while (p != buf && *p != '\\')
4437         p--;
4438     *p = 0;
4439     if (access(buf, R_OK) == 0) {
4440         return qemu_strdup(buf);
4441     }
4442     return NULL;
4443 }
4444 #else /* !_WIN32 */
4445
4446 /* Find a likely location for support files using the location of the binary.
4447    For installed binaries this will be "$bindir/../share/qemu".  When
4448    running from the build tree this will be "$bindir/../pc-bios".  */
4449 #define SHARE_SUFFIX "/share/qemu"
4450 #define BUILD_SUFFIX "/pc-bios"
4451 static char *find_datadir(const char *argv0)
4452 {
4453     char *dir;
4454     char *p = NULL;
4455     char *res;
4456     char buf[PATH_MAX];
4457     size_t max_len;
4458
4459 #if defined(__linux__)
4460     {
4461         int len;
4462         len = readlink("/proc/self/exe", buf, sizeof(buf) - 1);
4463         if (len > 0) {
4464             buf[len] = 0;
4465             p = buf;
4466         }
4467     }
4468 #elif defined(__FreeBSD__)
4469     {
4470         int len;
4471         len = readlink("/proc/curproc/file", buf, sizeof(buf) - 1);
4472         if (len > 0) {
4473             buf[len] = 0;
4474             p = buf;
4475         }
4476     }
4477 #endif
4478     /* If we don't have any way of figuring out the actual executable
4479        location then try argv[0].  */
4480     if (!p) {
4481         p = realpath(argv0, buf);
4482         if (!p) {
4483             return NULL;
4484         }
4485     }
4486     dir = dirname(p);
4487     dir = dirname(dir);
4488
4489     max_len = strlen(dir) +
4490         MAX(strlen(SHARE_SUFFIX), strlen(BUILD_SUFFIX)) + 1;
4491     res = qemu_mallocz(max_len);
4492     snprintf(res, max_len, "%s%s", dir, SHARE_SUFFIX);
4493     if (access(res, R_OK)) {
4494         snprintf(res, max_len, "%s%s", dir, BUILD_SUFFIX);
4495         if (access(res, R_OK)) {
4496             qemu_free(res);
4497             res = NULL;
4498         }
4499     }
4500
4501     return res;
4502 }
4503 #undef SHARE_SUFFIX
4504 #undef BUILD_SUFFIX
4505 #endif
4506
4507 char *qemu_find_file(int type, const char *name)
4508 {
4509     int len;
4510     const char *subdir;
4511     char *buf;
4512
4513     /* If name contains path separators then try it as a straight path.  */
4514     if ((strchr(name, '/') || strchr(name, '\\'))
4515         && access(name, R_OK) == 0) {
4516         return qemu_strdup(name);
4517     }
4518     switch (type) {
4519     case QEMU_FILE_TYPE_BIOS:
4520         subdir = "";
4521         break;
4522     case QEMU_FILE_TYPE_KEYMAP:
4523         subdir = "keymaps/";
4524         break;
4525     default:
4526         abort();
4527     }
4528     len = strlen(data_dir) + strlen(name) + strlen(subdir) + 2;
4529     buf = qemu_mallocz(len);
4530     snprintf(buf, len, "%s/%s%s", data_dir, subdir, name);
4531     if (access(buf, R_OK)) {
4532         qemu_free(buf);
4533         return NULL;
4534     }
4535     return buf;
4536 }
4537
4538 static int device_init_func(QemuOpts *opts, void *opaque)
4539 {
4540     DeviceState *dev;
4541
4542     dev = qdev_device_add(opts);
4543     if (!dev)
4544         return -1;
4545     return 0;
4546 }
4547
4548 struct device_config {
4549     enum {
4550         DEV_USB,       /* -usbdevice   */
4551         DEV_BT,        /* -bt          */
4552     } type;
4553     const char *cmdline;
4554     QTAILQ_ENTRY(device_config) next;
4555 };
4556 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4557
4558 static void add_device_config(int type, const char *cmdline)
4559 {
4560     struct device_config *conf;
4561
4562     conf = qemu_mallocz(sizeof(*conf));
4563     conf->type = type;
4564     conf->cmdline = cmdline;
4565     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4566 }
4567
4568 static int foreach_device_config(int type, int (*func)(const char *cmdline))
4569 {
4570     struct device_config *conf;
4571     int rc;
4572
4573     QTAILQ_FOREACH(conf, &device_configs, next) {
4574         if (conf->type != type)
4575             continue;
4576         rc = func(conf->cmdline);
4577         if (0 != rc)
4578             return rc;
4579     }
4580     return 0;
4581 }
4582
4583 int main(int argc, char **argv, char **envp)
4584 {
4585     const char *gdbstub_dev = NULL;
4586     uint32_t boot_devices_bitmap = 0;
4587     int i;
4588     int snapshot, linux_boot, net_boot;
4589     const char *initrd_filename;
4590     const char *kernel_filename, *kernel_cmdline;
4591     char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4592     DisplayState *ds;
4593     DisplayChangeListener *dcl;
4594     int cyls, heads, secs, translation;
4595     QemuOpts *hda_opts = NULL, *opts;
4596     int optind;
4597     const char *r, *optarg;
4598     CharDriverState *monitor_hds[MAX_MONITOR_DEVICES];
4599     const char *monitor_devices[MAX_MONITOR_DEVICES];
4600     int monitor_flags[MAX_MONITOR_DEVICES];
4601     int monitor_device_index;
4602     const char *serial_devices[MAX_SERIAL_PORTS];
4603     int serial_device_index;
4604     const char *parallel_devices[MAX_PARALLEL_PORTS];
4605     int parallel_device_index;
4606     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4607     int virtio_console_index;
4608     const char *loadvm = NULL;
4609     QEMUMachine *machine;
4610     const char *cpu_model;
4611 #ifndef _WIN32
4612     int fds[2];
4613 #endif
4614     int tb_size;
4615     const char *pid_file = NULL;
4616     const char *incoming = NULL;
4617 #ifndef _WIN32
4618     int fd = 0;
4619     struct passwd *pwd = NULL;
4620     const char *chroot_dir = NULL;
4621     const char *run_as = NULL;
4622 #endif
4623     CPUState *env;
4624     int show_vnc_port = 0;
4625
4626     init_clocks();
4627
4628     qemu_errors_to_file(stderr);
4629     qemu_cache_utils_init(envp);
4630
4631     QLIST_INIT (&vm_change_state_head);
4632 #ifndef _WIN32
4633     {
4634         struct sigaction act;
4635         sigfillset(&act.sa_mask);
4636         act.sa_flags = 0;
4637         act.sa_handler = SIG_IGN;
4638         sigaction(SIGPIPE, &act, NULL);
4639     }
4640 #else
4641     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4642     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4643        QEMU to run on a single CPU */
4644     {
4645         HANDLE h;
4646         DWORD mask, smask;
4647         int i;
4648         h = GetCurrentProcess();
4649         if (GetProcessAffinityMask(h, &mask, &smask)) {
4650             for(i = 0; i < 32; i++) {
4651                 if (mask & (1 << i))
4652                     break;
4653             }
4654             if (i != 32) {
4655                 mask = 1 << i;
4656                 SetProcessAffinityMask(h, mask);
4657             }
4658         }
4659     }
4660 #endif
4661
4662     module_call_init(MODULE_INIT_MACHINE);
4663     machine = find_default_machine();
4664     cpu_model = NULL;
4665     initrd_filename = NULL;
4666     ram_size = 0;
4667     snapshot = 0;
4668     kernel_filename = NULL;
4669     kernel_cmdline = "";
4670     cyls = heads = secs = 0;
4671     translation = BIOS_ATA_TRANSLATION_AUTO;
4672
4673     serial_devices[0] = "vc:80Cx24C";
4674     for(i = 1; i < MAX_SERIAL_PORTS; i++)
4675         serial_devices[i] = NULL;
4676     serial_device_index = 0;
4677
4678     parallel_devices[0] = "vc:80Cx24C";
4679     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4680         parallel_devices[i] = NULL;
4681     parallel_device_index = 0;
4682
4683     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4684         virtio_consoles[i] = NULL;
4685     virtio_console_index = 0;
4686
4687     monitor_devices[0] = "vc:80Cx24C";
4688     monitor_flags[0] = MONITOR_IS_DEFAULT | MONITOR_USE_READLINE;
4689     for (i = 1; i < MAX_MONITOR_DEVICES; i++) {
4690         monitor_devices[i] = NULL;
4691         monitor_flags[i] = MONITOR_USE_READLINE;
4692     }
4693     monitor_device_index = 0;
4694
4695     for (i = 0; i < MAX_NODES; i++) {
4696         node_mem[i] = 0;
4697         node_cpumask[i] = 0;
4698     }
4699
4700     nb_numa_nodes = 0;
4701     nb_nics = 0;
4702
4703     tb_size = 0;
4704     autostart= 1;
4705
4706     optind = 1;
4707     for(;;) {
4708         if (optind >= argc)
4709             break;
4710         r = argv[optind];
4711         if (r[0] != '-') {
4712             hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4713         } else {
4714             const QEMUOption *popt;
4715
4716             optind++;
4717             /* Treat --foo the same as -foo.  */
4718             if (r[1] == '-')
4719                 r++;
4720             popt = qemu_options;
4721             for(;;) {
4722                 if (!popt->name) {
4723                     fprintf(stderr, "%s: invalid option -- '%s'\n",
4724                             argv[0], r);
4725                     exit(1);
4726                 }
4727                 if (!strcmp(popt->name, r + 1))
4728                     break;
4729                 popt++;
4730             }
4731             if (popt->flags & HAS_ARG) {
4732                 if (optind >= argc) {
4733                     fprintf(stderr, "%s: option '%s' requires an argument\n",
4734                             argv[0], r);
4735                     exit(1);
4736                 }
4737                 optarg = argv[optind++];
4738             } else {
4739                 optarg = NULL;
4740             }
4741
4742             switch(popt->index) {
4743             case QEMU_OPTION_M:
4744                 machine = find_machine(optarg);
4745                 if (!machine) {
4746                     QEMUMachine *m;
4747                     printf("Supported machines are:\n");
4748                     for(m = first_machine; m != NULL; m = m->next) {
4749                         if (m->alias)
4750                             printf("%-10s %s (alias of %s)\n",
4751                                    m->alias, m->desc, m->name);
4752                         printf("%-10s %s%s\n",
4753                                m->name, m->desc,
4754                                m->is_default ? " (default)" : "");
4755                     }
4756                     exit(*optarg != '?');
4757                 }
4758                 break;
4759             case QEMU_OPTION_cpu:
4760                 /* hw initialization will check this */
4761                 if (*optarg == '?') {
4762 /* XXX: implement xxx_cpu_list for targets that still miss it */
4763 #if defined(cpu_list)
4764                     cpu_list(stdout, &fprintf);
4765 #endif
4766                     exit(0);
4767                 } else {
4768                     cpu_model = optarg;
4769                 }
4770                 break;
4771             case QEMU_OPTION_initrd:
4772                 initrd_filename = optarg;
4773                 break;
4774             case QEMU_OPTION_hda:
4775                 if (cyls == 0)
4776                     hda_opts = drive_add(optarg, HD_ALIAS, 0);
4777                 else
4778                     hda_opts = drive_add(optarg, HD_ALIAS
4779                              ",cyls=%d,heads=%d,secs=%d%s",
4780                              0, cyls, heads, secs,
4781                              translation == BIOS_ATA_TRANSLATION_LBA ?
4782                                  ",trans=lba" :
4783                              translation == BIOS_ATA_TRANSLATION_NONE ?
4784                                  ",trans=none" : "");
4785                  break;
4786             case QEMU_OPTION_hdb:
4787             case QEMU_OPTION_hdc:
4788             case QEMU_OPTION_hdd:
4789                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4790                 break;
4791             case QEMU_OPTION_drive:
4792                 drive_add(NULL, "%s", optarg);
4793                 break;
4794             case QEMU_OPTION_set:
4795                 if (qemu_set_option(optarg) != 0)
4796                     exit(1);
4797                 break;
4798             case QEMU_OPTION_mtdblock:
4799                 drive_add(optarg, MTD_ALIAS);
4800                 break;
4801             case QEMU_OPTION_sd:
4802                 drive_add(optarg, SD_ALIAS);
4803                 break;
4804             case QEMU_OPTION_pflash:
4805                 drive_add(optarg, PFLASH_ALIAS);
4806                 break;
4807             case QEMU_OPTION_snapshot:
4808                 snapshot = 1;
4809                 break;
4810             case QEMU_OPTION_hdachs:
4811                 {
4812                     const char *p;
4813                     p = optarg;
4814                     cyls = strtol(p, (char **)&p, 0);
4815                     if (cyls < 1 || cyls > 16383)
4816                         goto chs_fail;
4817                     if (*p != ',')
4818                         goto chs_fail;
4819                     p++;
4820                     heads = strtol(p, (char **)&p, 0);
4821                     if (heads < 1 || heads > 16)
4822                         goto chs_fail;
4823                     if (*p != ',')
4824                         goto chs_fail;
4825                     p++;
4826                     secs = strtol(p, (char **)&p, 0);
4827                     if (secs < 1 || secs > 63)
4828                         goto chs_fail;
4829                     if (*p == ',') {
4830                         p++;
4831                         if (!strcmp(p, "none"))
4832                             translation = BIOS_ATA_TRANSLATION_NONE;
4833                         else if (!strcmp(p, "lba"))
4834                             translation = BIOS_ATA_TRANSLATION_LBA;
4835                         else if (!strcmp(p, "auto"))
4836                             translation = BIOS_ATA_TRANSLATION_AUTO;
4837                         else
4838                             goto chs_fail;
4839                     } else if (*p != '\0') {
4840                     chs_fail:
4841                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4842                         exit(1);
4843                     }
4844                     if (hda_opts != NULL) {
4845                         char num[16];
4846                         snprintf(num, sizeof(num), "%d", cyls);
4847                         qemu_opt_set(hda_opts, "cyls", num);
4848                         snprintf(num, sizeof(num), "%d", heads);
4849                         qemu_opt_set(hda_opts, "heads", num);
4850                         snprintf(num, sizeof(num), "%d", secs);
4851                         qemu_opt_set(hda_opts, "secs", num);
4852                         if (translation == BIOS_ATA_TRANSLATION_LBA)
4853                             qemu_opt_set(hda_opts, "trans", "lba");
4854                         if (translation == BIOS_ATA_TRANSLATION_NONE)
4855                             qemu_opt_set(hda_opts, "trans", "none");
4856                     }
4857                 }
4858                 break;
4859             case QEMU_OPTION_numa:
4860                 if (nb_numa_nodes >= MAX_NODES) {
4861                     fprintf(stderr, "qemu: too many NUMA nodes\n");
4862                     exit(1);
4863                 }
4864                 numa_add(optarg);
4865                 break;
4866             case QEMU_OPTION_nographic:
4867                 display_type = DT_NOGRAPHIC;
4868                 break;
4869 #ifdef CONFIG_CURSES
4870             case QEMU_OPTION_curses:
4871                 display_type = DT_CURSES;
4872                 break;
4873 #endif
4874             case QEMU_OPTION_portrait:
4875                 graphic_rotate = 1;
4876                 break;
4877             case QEMU_OPTION_kernel:
4878                 kernel_filename = optarg;
4879                 break;
4880             case QEMU_OPTION_append:
4881                 kernel_cmdline = optarg;
4882                 break;
4883             case QEMU_OPTION_cdrom:
4884                 drive_add(optarg, CDROM_ALIAS);
4885                 break;
4886             case QEMU_OPTION_boot:
4887                 {
4888                     static const char * const params[] = {
4889                         "order", "once", "menu", NULL
4890                     };
4891                     char buf[sizeof(boot_devices)];
4892                     char *standard_boot_devices;
4893                     int legacy = 0;
4894
4895                     if (!strchr(optarg, '=')) {
4896                         legacy = 1;
4897                         pstrcpy(buf, sizeof(buf), optarg);
4898                     } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
4899                         fprintf(stderr,
4900                                 "qemu: unknown boot parameter '%s' in '%s'\n",
4901                                 buf, optarg);
4902                         exit(1);
4903                     }
4904
4905                     if (legacy ||
4906                         get_param_value(buf, sizeof(buf), "order", optarg)) {
4907                         boot_devices_bitmap = parse_bootdevices(buf);
4908                         pstrcpy(boot_devices, sizeof(boot_devices), buf);
4909                     }
4910                     if (!legacy) {
4911                         if (get_param_value(buf, sizeof(buf),
4912                                             "once", optarg)) {
4913                             boot_devices_bitmap |= parse_bootdevices(buf);
4914                             standard_boot_devices = qemu_strdup(boot_devices);
4915                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
4916                             qemu_register_reset(restore_boot_devices,
4917                                                 standard_boot_devices);
4918                         }
4919                         if (get_param_value(buf, sizeof(buf),
4920                                             "menu", optarg)) {
4921                             if (!strcmp(buf, "on")) {
4922                                 boot_menu = 1;
4923                             } else if (!strcmp(buf, "off")) {
4924                                 boot_menu = 0;
4925                             } else {
4926                                 fprintf(stderr,
4927                                         "qemu: invalid option value '%s'\n",
4928                                         buf);
4929                                 exit(1);
4930                             }
4931                         }
4932                     }
4933                 }
4934                 break;
4935             case QEMU_OPTION_fda:
4936             case QEMU_OPTION_fdb:
4937                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4938                 break;
4939 #ifdef TARGET_I386
4940             case QEMU_OPTION_no_fd_bootchk:
4941                 fd_bootchk = 0;
4942                 break;
4943 #endif
4944             case QEMU_OPTION_netdev:
4945                 if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
4946                     exit(1);
4947                 }
4948                 break;
4949             case QEMU_OPTION_net:
4950                 if (net_client_parse(&qemu_net_opts, optarg) == -1) {
4951                     exit(1);
4952                 }
4953                 break;
4954 #ifdef CONFIG_SLIRP
4955             case QEMU_OPTION_tftp:
4956                 legacy_tftp_prefix = optarg;
4957                 break;
4958             case QEMU_OPTION_bootp:
4959                 legacy_bootp_filename = optarg;
4960                 break;
4961 #ifndef _WIN32
4962             case QEMU_OPTION_smb:
4963                 if (net_slirp_smb(optarg) < 0)
4964                     exit(1);
4965                 break;
4966 #endif
4967             case QEMU_OPTION_redir:
4968                 if (net_slirp_redir(optarg) < 0)
4969                     exit(1);
4970                 break;
4971 #endif
4972             case QEMU_OPTION_bt:
4973                 add_device_config(DEV_BT, optarg);
4974                 break;
4975 #ifdef HAS_AUDIO
4976             case QEMU_OPTION_audio_help:
4977                 AUD_help ();
4978                 exit (0);
4979                 break;
4980             case QEMU_OPTION_soundhw:
4981                 select_soundhw (optarg);
4982                 break;
4983 #endif
4984             case QEMU_OPTION_h:
4985                 help(0);
4986                 break;
4987             case QEMU_OPTION_version:
4988                 version();
4989                 exit(0);
4990                 break;
4991             case QEMU_OPTION_m: {
4992                 uint64_t value;
4993                 char *ptr;
4994
4995                 value = strtoul(optarg, &ptr, 10);
4996                 switch (*ptr) {
4997                 case 0: case 'M': case 'm':
4998                     value <<= 20;
4999                     break;
5000                 case 'G': case 'g':
5001                     value <<= 30;
5002                     break;
5003                 default:
5004                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5005                     exit(1);
5006                 }
5007
5008                 /* On 32-bit hosts, QEMU is limited by virtual address space */
5009                 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5010                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5011                     exit(1);
5012                 }
5013                 if (value != (uint64_t)(ram_addr_t)value) {
5014                     fprintf(stderr, "qemu: ram size too large\n");
5015                     exit(1);
5016                 }
5017                 ram_size = value;
5018                 break;
5019             }
5020             case QEMU_OPTION_d:
5021                 {
5022                     int mask;
5023                     const CPULogItem *item;
5024
5025                     mask = cpu_str_to_log_mask(optarg);
5026                     if (!mask) {
5027                         printf("Log items (comma separated):\n");
5028                     for(item = cpu_log_items; item->mask != 0; item++) {
5029                         printf("%-10s %s\n", item->name, item->help);
5030                     }
5031                     exit(1);
5032                     }
5033                     cpu_set_log(mask);
5034                 }
5035                 break;
5036             case QEMU_OPTION_s:
5037                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5038                 break;
5039             case QEMU_OPTION_gdb:
5040                 gdbstub_dev = optarg;
5041                 break;
5042             case QEMU_OPTION_L:
5043                 data_dir = optarg;
5044                 break;
5045             case QEMU_OPTION_bios:
5046                 bios_name = optarg;
5047                 break;
5048             case QEMU_OPTION_singlestep:
5049                 singlestep = 1;
5050                 break;
5051             case QEMU_OPTION_S:
5052                 autostart = 0;
5053                 break;
5054             case QEMU_OPTION_k:
5055                 keyboard_layout = optarg;
5056                 break;
5057             case QEMU_OPTION_localtime:
5058                 rtc_utc = 0;
5059                 break;
5060             case QEMU_OPTION_vga:
5061                 select_vgahw (optarg);
5062                 break;
5063 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5064             case QEMU_OPTION_g:
5065                 {
5066                     const char *p;
5067                     int w, h, depth;
5068                     p = optarg;
5069                     w = strtol(p, (char **)&p, 10);
5070                     if (w <= 0) {
5071                     graphic_error:
5072                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5073                         exit(1);
5074                     }
5075                     if (*p != 'x')
5076                         goto graphic_error;
5077                     p++;
5078                     h = strtol(p, (char **)&p, 10);
5079                     if (h <= 0)
5080                         goto graphic_error;
5081                     if (*p == 'x') {
5082                         p++;
5083                         depth = strtol(p, (char **)&p, 10);
5084                         if (depth != 8 && depth != 15 && depth != 16 &&
5085                             depth != 24 && depth != 32)
5086                             goto graphic_error;
5087                     } else if (*p == '\0') {
5088                         depth = graphic_depth;
5089                     } else {
5090                         goto graphic_error;
5091                     }
5092
5093                     graphic_width = w;
5094                     graphic_height = h;
5095                     graphic_depth = depth;
5096                 }
5097                 break;
5098 #endif
5099             case QEMU_OPTION_echr:
5100                 {
5101                     char *r;
5102                     term_escape_char = strtol(optarg, &r, 0);
5103                     if (r == optarg)
5104                         printf("Bad argument to echr\n");
5105                     break;
5106                 }
5107             case QEMU_OPTION_monitor:
5108                 if (monitor_device_index >= MAX_MONITOR_DEVICES) {
5109                     fprintf(stderr, "qemu: too many monitor devices\n");
5110                     exit(1);
5111                 }
5112                 monitor_devices[monitor_device_index] =
5113                                 monitor_cmdline_parse(optarg,
5114                                         &monitor_flags[monitor_device_index]);
5115                 monitor_device_index++;
5116                 break;
5117             case QEMU_OPTION_chardev:
5118                 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend");
5119                 if (!opts) {
5120                     fprintf(stderr, "parse error: %s\n", optarg);
5121                     exit(1);
5122                 }
5123                 if (qemu_chr_open_opts(opts, NULL) == NULL) {
5124                     exit(1);
5125                 }
5126                 break;
5127             case QEMU_OPTION_serial:
5128                 if (serial_device_index >= MAX_SERIAL_PORTS) {
5129                     fprintf(stderr, "qemu: too many serial ports\n");
5130                     exit(1);
5131                 }
5132                 serial_devices[serial_device_index] = optarg;
5133                 serial_device_index++;
5134                 break;
5135             case QEMU_OPTION_watchdog:
5136                 if (watchdog) {
5137                     fprintf(stderr,
5138                             "qemu: only one watchdog option may be given\n");
5139                     return 1;
5140                 }
5141                 watchdog = optarg;
5142                 break;
5143             case QEMU_OPTION_watchdog_action:
5144                 if (select_watchdog_action(optarg) == -1) {
5145                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
5146                     exit(1);
5147                 }
5148                 break;
5149             case QEMU_OPTION_virtiocon:
5150                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5151                     fprintf(stderr, "qemu: too many virtio consoles\n");
5152                     exit(1);
5153                 }
5154                 virtio_consoles[virtio_console_index] = optarg;
5155                 virtio_console_index++;
5156                 break;
5157             case QEMU_OPTION_parallel:
5158                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5159                     fprintf(stderr, "qemu: too many parallel ports\n");
5160                     exit(1);
5161                 }
5162                 parallel_devices[parallel_device_index] = optarg;
5163                 parallel_device_index++;
5164                 break;
5165             case QEMU_OPTION_loadvm:
5166                 loadvm = optarg;
5167                 break;
5168             case QEMU_OPTION_full_screen:
5169                 full_screen = 1;
5170                 break;
5171 #ifdef CONFIG_SDL
5172             case QEMU_OPTION_no_frame:
5173                 no_frame = 1;
5174                 break;
5175             case QEMU_OPTION_alt_grab:
5176                 alt_grab = 1;
5177                 break;
5178             case QEMU_OPTION_ctrl_grab:
5179                 ctrl_grab = 1;
5180                 break;
5181             case QEMU_OPTION_no_quit:
5182                 no_quit = 1;
5183                 break;
5184             case QEMU_OPTION_sdl:
5185                 display_type = DT_SDL;
5186                 break;
5187 #endif
5188             case QEMU_OPTION_pidfile:
5189                 pid_file = optarg;
5190                 break;
5191 #ifdef TARGET_I386
5192             case QEMU_OPTION_win2k_hack:
5193                 win2k_install_hack = 1;
5194                 break;
5195             case QEMU_OPTION_rtc_td_hack:
5196                 rtc_td_hack = 1;
5197                 break;
5198             case QEMU_OPTION_acpitable:
5199                 if(acpi_table_add(optarg) < 0) {
5200                     fprintf(stderr, "Wrong acpi table provided\n");
5201                     exit(1);
5202                 }
5203                 break;
5204             case QEMU_OPTION_smbios:
5205                 if(smbios_entry_add(optarg) < 0) {
5206                     fprintf(stderr, "Wrong smbios provided\n");
5207                     exit(1);
5208                 }
5209                 break;
5210 #endif
5211 #ifdef CONFIG_KVM
5212             case QEMU_OPTION_enable_kvm:
5213                 kvm_allowed = 1;
5214                 break;
5215 #endif
5216             case QEMU_OPTION_usb:
5217                 usb_enabled = 1;
5218                 break;
5219             case QEMU_OPTION_usbdevice:
5220                 usb_enabled = 1;
5221                 add_device_config(DEV_USB, optarg);
5222                 break;
5223             case QEMU_OPTION_device:
5224                 if (!qemu_opts_parse(&qemu_device_opts, optarg, "driver")) {
5225                     exit(1);
5226                 }
5227                 break;
5228             case QEMU_OPTION_smp:
5229                 smp_parse(optarg);
5230                 if (smp_cpus < 1) {
5231                     fprintf(stderr, "Invalid number of CPUs\n");
5232                     exit(1);
5233                 }
5234                 if (max_cpus < smp_cpus) {
5235                     fprintf(stderr, "maxcpus must be equal to or greater than "
5236                             "smp\n");
5237                     exit(1);
5238                 }
5239                 if (max_cpus > 255) {
5240                     fprintf(stderr, "Unsupported number of maxcpus\n");
5241                     exit(1);
5242                 }
5243                 break;
5244             case QEMU_OPTION_vnc:
5245                 display_type = DT_VNC;
5246                 vnc_display = optarg;
5247                 break;
5248 #ifdef TARGET_I386
5249             case QEMU_OPTION_no_acpi:
5250                 acpi_enabled = 0;
5251                 break;
5252             case QEMU_OPTION_no_hpet:
5253                 no_hpet = 1;
5254                 break;
5255             case QEMU_OPTION_balloon:
5256                 if (balloon_parse(optarg) < 0) {
5257                     fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5258                     exit(1);
5259                 }
5260                 break;
5261 #endif
5262             case QEMU_OPTION_no_reboot:
5263                 no_reboot = 1;
5264                 break;
5265             case QEMU_OPTION_no_shutdown:
5266                 no_shutdown = 1;
5267                 break;
5268             case QEMU_OPTION_show_cursor:
5269                 cursor_hide = 0;
5270                 break;
5271             case QEMU_OPTION_uuid:
5272                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5273                     fprintf(stderr, "Fail to parse UUID string."
5274                             " Wrong format.\n");
5275                     exit(1);
5276                 }
5277                 break;
5278 #ifndef _WIN32
5279             case QEMU_OPTION_daemonize:
5280                 daemonize = 1;
5281                 break;
5282 #endif
5283             case QEMU_OPTION_option_rom:
5284                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5285                     fprintf(stderr, "Too many option ROMs\n");
5286                     exit(1);
5287                 }
5288                 option_rom[nb_option_roms] = optarg;
5289                 nb_option_roms++;
5290                 break;
5291 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5292             case QEMU_OPTION_semihosting:
5293                 semihosting_enabled = 1;
5294                 break;
5295 #endif
5296             case QEMU_OPTION_name:
5297                 qemu_name = qemu_strdup(optarg);
5298                  {
5299                      char *p = strchr(qemu_name, ',');
5300                      if (p != NULL) {
5301                         *p++ = 0;
5302                         if (strncmp(p, "process=", 8)) {
5303                             fprintf(stderr, "Unknown subargument %s to -name", p);
5304                             exit(1);
5305                         }
5306                         p += 8;
5307                         set_proc_name(p);
5308                      }
5309                  }
5310                 break;
5311 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5312             case QEMU_OPTION_prom_env:
5313                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5314                     fprintf(stderr, "Too many prom variables\n");
5315                     exit(1);
5316                 }
5317                 prom_envs[nb_prom_envs] = optarg;
5318                 nb_prom_envs++;
5319                 break;
5320 #endif
5321 #ifdef TARGET_ARM
5322             case QEMU_OPTION_old_param:
5323                 old_param = 1;
5324                 break;
5325 #endif
5326             case QEMU_OPTION_clock:
5327                 configure_alarms(optarg);
5328                 break;
5329             case QEMU_OPTION_startdate:
5330                 configure_rtc_date_offset(optarg, 1);
5331                 break;
5332             case QEMU_OPTION_rtc:
5333                 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
5334                 if (!opts) {
5335                     fprintf(stderr, "parse error: %s\n", optarg);
5336                     exit(1);
5337                 }
5338                 configure_rtc(opts);
5339                 break;
5340             case QEMU_OPTION_tb_size:
5341                 tb_size = strtol(optarg, NULL, 0);
5342                 if (tb_size < 0)
5343                     tb_size = 0;
5344                 break;
5345             case QEMU_OPTION_icount:
5346                 use_icount = 1;
5347                 if (strcmp(optarg, "auto") == 0) {
5348                     icount_time_shift = -1;
5349                 } else {
5350                     icount_time_shift = strtol(optarg, NULL, 0);
5351                 }
5352                 break;
5353             case QEMU_OPTION_incoming:
5354                 incoming = optarg;
5355                 break;
5356 #ifndef _WIN32
5357             case QEMU_OPTION_chroot:
5358                 chroot_dir = optarg;
5359                 break;
5360             case QEMU_OPTION_runas:
5361                 run_as = optarg;
5362                 break;
5363 #endif
5364 #ifdef CONFIG_XEN
5365             case QEMU_OPTION_xen_domid:
5366                 xen_domid = atoi(optarg);
5367                 break;
5368             case QEMU_OPTION_xen_create:
5369                 xen_mode = XEN_CREATE;
5370                 break;
5371             case QEMU_OPTION_xen_attach:
5372                 xen_mode = XEN_ATTACH;
5373                 break;
5374 #endif
5375             case QEMU_OPTION_readconfig:
5376                 {
5377                     FILE *fp;
5378                     fp = fopen(optarg, "r");
5379                     if (fp == NULL) {
5380                         fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5381                         exit(1);
5382                     }
5383                     if (qemu_config_parse(fp) != 0) {
5384                         exit(1);
5385                     }
5386                     fclose(fp);
5387                     break;
5388                 }
5389             case QEMU_OPTION_writeconfig:
5390                 {
5391                     FILE *fp;
5392                     if (strcmp(optarg, "-") == 0) {
5393                         fp = stdout;
5394                     } else {
5395                         fp = fopen(optarg, "w");
5396                         if (fp == NULL) {
5397                             fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5398                             exit(1);
5399                         }
5400                     }
5401                     qemu_config_write(fp);
5402                     fclose(fp);
5403                     break;
5404                 }
5405             }
5406         }
5407     }
5408
5409     /* If no data_dir is specified then try to find it relative to the
5410        executable path.  */
5411     if (!data_dir) {
5412         data_dir = find_datadir(argv[0]);
5413     }
5414     /* If all else fails use the install patch specified when building.  */
5415     if (!data_dir) {
5416         data_dir = CONFIG_QEMU_SHAREDIR;
5417     }
5418
5419     /*
5420      * Default to max_cpus = smp_cpus, in case the user doesn't
5421      * specify a max_cpus value.
5422      */
5423     if (!max_cpus)
5424         max_cpus = smp_cpus;
5425
5426     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5427     if (smp_cpus > machine->max_cpus) {
5428         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5429                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5430                 machine->max_cpus);
5431         exit(1);
5432     }
5433
5434     if (display_type == DT_NOGRAPHIC) {
5435        if (serial_device_index == 0)
5436            serial_devices[0] = "stdio";
5437        if (parallel_device_index == 0)
5438            parallel_devices[0] = "null";
5439        if (strncmp(monitor_devices[0], "vc", 2) == 0) {
5440            monitor_devices[0] = "stdio";
5441        }
5442     }
5443
5444 #ifndef _WIN32
5445     if (daemonize) {
5446         pid_t pid;
5447
5448         if (pipe(fds) == -1)
5449             exit(1);
5450
5451         pid = fork();
5452         if (pid > 0) {
5453             uint8_t status;
5454             ssize_t len;
5455
5456             close(fds[1]);
5457
5458         again:
5459             len = read(fds[0], &status, 1);
5460             if (len == -1 && (errno == EINTR))
5461                 goto again;
5462
5463             if (len != 1)
5464                 exit(1);
5465             else if (status == 1) {
5466                 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
5467                 exit(1);
5468             } else
5469                 exit(0);
5470         } else if (pid < 0)
5471             exit(1);
5472
5473         setsid();
5474
5475         pid = fork();
5476         if (pid > 0)
5477             exit(0);
5478         else if (pid < 0)
5479             exit(1);
5480
5481         umask(027);
5482
5483         signal(SIGTSTP, SIG_IGN);
5484         signal(SIGTTOU, SIG_IGN);
5485         signal(SIGTTIN, SIG_IGN);
5486     }
5487
5488     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5489         if (daemonize) {
5490             uint8_t status = 1;
5491             write(fds[1], &status, 1);
5492         } else
5493             fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
5494         exit(1);
5495     }
5496 #endif
5497
5498     if (kvm_enabled()) {
5499         int ret;
5500
5501         ret = kvm_init(smp_cpus);
5502         if (ret < 0) {
5503             fprintf(stderr, "failed to initialize KVM\n");
5504             exit(1);
5505         }
5506     }
5507
5508     if (qemu_init_main_loop()) {
5509         fprintf(stderr, "qemu_init_main_loop failed\n");
5510         exit(1);
5511     }
5512     linux_boot = (kernel_filename != NULL);
5513
5514     if (!linux_boot && *kernel_cmdline != '\0') {
5515         fprintf(stderr, "-append only allowed with -kernel option\n");
5516         exit(1);
5517     }
5518
5519     if (!linux_boot && initrd_filename != NULL) {
5520         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5521         exit(1);
5522     }
5523
5524 #ifndef _WIN32
5525     /* Win32 doesn't support line-buffering and requires size >= 2 */
5526     setvbuf(stdout, NULL, _IOLBF, 0);
5527 #endif
5528
5529     if (init_timer_alarm() < 0) {
5530         fprintf(stderr, "could not initialize alarm timer\n");
5531         exit(1);
5532     }
5533     if (use_icount && icount_time_shift < 0) {
5534         use_icount = 2;
5535         /* 125MIPS seems a reasonable initial guess at the guest speed.
5536            It will be corrected fairly quickly anyway.  */
5537         icount_time_shift = 3;
5538         init_icount_adjust();
5539     }
5540
5541 #ifdef _WIN32
5542     socket_init();
5543 #endif
5544
5545     if (net_init_clients() < 0) {
5546         exit(1);
5547     }
5548
5549     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5550     net_set_boot_mask(net_boot);
5551
5552     /* init the bluetooth world */
5553     if (foreach_device_config(DEV_BT, bt_parse))
5554         exit(1);
5555
5556     /* init the memory */
5557     if (ram_size == 0)
5558         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5559
5560     /* init the dynamic translator */
5561     cpu_exec_init_all(tb_size * 1024 * 1024);
5562
5563     bdrv_init_with_whitelist();
5564
5565     blk_mig_init();
5566
5567     /* we always create the cdrom drive, even if no disk is there */
5568     drive_add(NULL, CDROM_ALIAS);
5569
5570     /* we always create at least one floppy */
5571     drive_add(NULL, FD_ALIAS, 0);
5572
5573     /* we always create one sd slot, even if no card is in it */
5574     drive_add(NULL, SD_ALIAS);
5575
5576     /* open the virtual block devices */
5577     if (snapshot)
5578         qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5579     if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5580         exit(1);
5581
5582     vmstate_register(0, &vmstate_timers ,&timers_state);
5583     register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
5584                          ram_load, NULL);
5585
5586     /* Maintain compatibility with multiple stdio monitors */
5587     if (!strcmp(monitor_devices[0],"stdio")) {
5588         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5589             const char *devname = serial_devices[i];
5590             if (devname && !strcmp(devname,"mon:stdio")) {
5591                 monitor_devices[0] = NULL;
5592                 break;
5593             } else if (devname && !strcmp(devname,"stdio")) {
5594                 monitor_devices[0] = NULL;
5595                 serial_devices[i] = "mon:stdio";
5596                 break;
5597             }
5598         }
5599     }
5600
5601     if (nb_numa_nodes > 0) {
5602         int i;
5603
5604         if (nb_numa_nodes > smp_cpus) {
5605             nb_numa_nodes = smp_cpus;
5606         }
5607
5608         /* If no memory size if given for any node, assume the default case
5609          * and distribute the available memory equally across all nodes
5610          */
5611         for (i = 0; i < nb_numa_nodes; i++) {
5612             if (node_mem[i] != 0)
5613                 break;
5614         }
5615         if (i == nb_numa_nodes) {
5616             uint64_t usedmem = 0;
5617
5618             /* On Linux, the each node's border has to be 8MB aligned,
5619              * the final node gets the rest.
5620              */
5621             for (i = 0; i < nb_numa_nodes - 1; i++) {
5622                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5623                 usedmem += node_mem[i];
5624             }
5625             node_mem[i] = ram_size - usedmem;
5626         }
5627
5628         for (i = 0; i < nb_numa_nodes; i++) {
5629             if (node_cpumask[i] != 0)
5630                 break;
5631         }
5632         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5633          * must cope with this anyway, because there are BIOSes out there in
5634          * real machines which also use this scheme.
5635          */
5636         if (i == nb_numa_nodes) {
5637             for (i = 0; i < smp_cpus; i++) {
5638                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5639             }
5640         }
5641     }
5642
5643     for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
5644         const char *devname = monitor_devices[i];
5645         if (devname && strcmp(devname, "none")) {
5646             char label[32];
5647             if (i == 0) {
5648                 snprintf(label, sizeof(label), "monitor");
5649             } else {
5650                 snprintf(label, sizeof(label), "monitor%d", i);
5651             }
5652             monitor_hds[i] = qemu_chr_open(label, devname, NULL);
5653             if (!monitor_hds[i]) {
5654                 fprintf(stderr, "qemu: could not open monitor device '%s'\n",
5655                         devname);
5656                 exit(1);
5657             }
5658         }
5659     }
5660
5661     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5662         const char *devname = serial_devices[i];
5663         if (devname && strcmp(devname, "none")) {
5664             char label[32];
5665             snprintf(label, sizeof(label), "serial%d", i);
5666             serial_hds[i] = qemu_chr_open(label, devname, NULL);
5667             if (!serial_hds[i]) {
5668                 fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
5669                         devname, strerror(errno));
5670                 exit(1);
5671             }
5672         }
5673     }
5674
5675     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5676         const char *devname = parallel_devices[i];
5677         if (devname && strcmp(devname, "none")) {
5678             char label[32];
5679             snprintf(label, sizeof(label), "parallel%d", i);
5680             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5681             if (!parallel_hds[i]) {
5682                 fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
5683                         devname, strerror(errno));
5684                 exit(1);
5685             }
5686         }
5687     }
5688
5689     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5690         const char *devname = virtio_consoles[i];
5691         if (devname && strcmp(devname, "none")) {
5692             char label[32];
5693             snprintf(label, sizeof(label), "virtcon%d", i);
5694             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5695             if (!virtcon_hds[i]) {
5696                 fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
5697                         devname, strerror(errno));
5698                 exit(1);
5699             }
5700         }
5701     }
5702
5703     module_call_init(MODULE_INIT_DEVICE);
5704
5705     if (watchdog) {
5706         i = select_watchdog(watchdog);
5707         if (i > 0)
5708             exit (i == 1 ? 1 : 0);
5709     }
5710
5711     if (machine->compat_props) {
5712         qdev_prop_register_compat(machine->compat_props);
5713     }
5714     machine->init(ram_size, boot_devices,
5715                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5716
5717
5718 #ifndef _WIN32
5719     /* must be after terminal init, SDL library changes signal handlers */
5720     sighandler_setup();
5721 #endif
5722
5723     for (env = first_cpu; env != NULL; env = env->next_cpu) {
5724         for (i = 0; i < nb_numa_nodes; i++) {
5725             if (node_cpumask[i] & (1 << env->cpu_index)) {
5726                 env->numa_node = i;
5727             }
5728         }
5729     }
5730
5731     current_machine = machine;
5732
5733     /* init USB devices */
5734     if (usb_enabled) {
5735         if (foreach_device_config(DEV_USB, usb_parse) < 0)
5736             exit(1);
5737     }
5738
5739     /* init generic devices */
5740     if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5741         exit(1);
5742
5743     if (!display_state)
5744         dumb_display_init();
5745     /* just use the first displaystate for the moment */
5746     ds = display_state;
5747
5748     if (display_type == DT_DEFAULT) {
5749 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5750         display_type = DT_SDL;
5751 #else
5752         display_type = DT_VNC;
5753         vnc_display = "localhost:0,to=99";
5754         show_vnc_port = 1;
5755 #endif
5756     }
5757
5758
5759     switch (display_type) {
5760     case DT_NOGRAPHIC:
5761         break;
5762 #if defined(CONFIG_CURSES)
5763     case DT_CURSES:
5764         curses_display_init(ds, full_screen);
5765         break;
5766 #endif
5767 #if defined(CONFIG_SDL)
5768     case DT_SDL:
5769         sdl_display_init(ds, full_screen, no_frame);
5770         break;
5771 #elif defined(CONFIG_COCOA)
5772     case DT_SDL:
5773         cocoa_display_init(ds, full_screen);
5774         break;
5775 #endif
5776     case DT_VNC:
5777         vnc_display_init(ds);
5778         if (vnc_display_open(ds, vnc_display) < 0)
5779             exit(1);
5780
5781         if (show_vnc_port) {
5782             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
5783         }
5784         break;
5785     default:
5786         break;
5787     }
5788     dpy_resize(ds);
5789
5790     dcl = ds->listeners;
5791     while (dcl != NULL) {
5792         if (dcl->dpy_refresh != NULL) {
5793             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5794             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5795         }
5796         dcl = dcl->next;
5797     }
5798
5799     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
5800         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5801         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5802     }
5803
5804     text_consoles_set_display(display_state);
5805
5806     for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
5807         if (monitor_devices[i] && monitor_hds[i]) {
5808             monitor_init(monitor_hds[i], monitor_flags[i]);
5809         }
5810     }
5811
5812     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5813         const char *devname = serial_devices[i];
5814         if (devname && strcmp(devname, "none")) {
5815             if (strstart(devname, "vc", 0))
5816                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5817         }
5818     }
5819
5820     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5821         const char *devname = parallel_devices[i];
5822         if (devname && strcmp(devname, "none")) {
5823             if (strstart(devname, "vc", 0))
5824                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5825         }
5826     }
5827
5828     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5829         const char *devname = virtio_consoles[i];
5830         if (virtcon_hds[i] && devname) {
5831             if (strstart(devname, "vc", 0))
5832                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5833         }
5834     }
5835
5836     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5837         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5838                 gdbstub_dev);
5839         exit(1);
5840     }
5841
5842     qdev_machine_creation_done();
5843
5844     rom_load_all();
5845
5846     qemu_system_reset();
5847     if (loadvm) {
5848         if (load_vmstate(cur_mon, loadvm) < 0) {
5849             autostart = 0;
5850         }
5851     }
5852
5853     if (incoming) {
5854         qemu_start_incoming_migration(incoming);
5855     } else if (autostart) {
5856         vm_start();
5857     }
5858
5859 #ifndef _WIN32
5860     if (daemonize) {
5861         uint8_t status = 0;
5862         ssize_t len;
5863
5864     again1:
5865         len = write(fds[1], &status, 1);
5866         if (len == -1 && (errno == EINTR))
5867             goto again1;
5868
5869         if (len != 1)
5870             exit(1);
5871
5872         chdir("/");
5873         TFR(fd = open("/dev/null", O_RDWR));
5874         if (fd == -1)
5875             exit(1);
5876     }
5877
5878     if (run_as) {
5879         pwd = getpwnam(run_as);
5880         if (!pwd) {
5881             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5882             exit(1);
5883         }
5884     }
5885
5886     if (chroot_dir) {
5887         if (chroot(chroot_dir) < 0) {
5888             fprintf(stderr, "chroot failed\n");
5889             exit(1);
5890         }
5891         chdir("/");
5892     }
5893
5894     if (run_as) {
5895         if (setgid(pwd->pw_gid) < 0) {
5896             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5897             exit(1);
5898         }
5899         if (setuid(pwd->pw_uid) < 0) {
5900             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5901             exit(1);
5902         }
5903         if (setuid(0) != -1) {
5904             fprintf(stderr, "Dropping privileges failed\n");
5905             exit(1);
5906         }
5907     }
5908
5909     if (daemonize) {
5910         dup2(fd, 0);
5911         dup2(fd, 1);
5912         dup2(fd, 2);
5913
5914         close(fd);
5915     }
5916 #endif
5917
5918     main_loop();
5919     quit_timers();
5920     net_cleanup();
5921
5922     return 0;
5923 }