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