vl.c

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