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(EVENT_DEBUG, NULL);
4107             vm_stop(EXCP_DEBUG);
4108         }
4109         if (qemu_shutdown_requested()) {
4110             monitor_protocol_event(EVENT_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(EVENT_RESET, NULL);
4119             pause_all_vcpus();
4120             qemu_system_reset();
4121             resume_all_vcpus();
4122         }
4123         if (qemu_powerdown_requested()) {
4124             monitor_protocol_event(EVENT_POWERDOWN, NULL);
4125             qemu_irq_raise(qemu_system_powerdown);
4126         }
4127         if ((r = qemu_vmstop_requested())) {
4128             monitor_protocol_event(EVENT_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 struct device_config {
4590     enum {
4591         DEV_USB,       /* -usbdevice   */
4592         DEV_BT,        /* -bt          */
4593     } type;
4594     const char *cmdline;
4595     QTAILQ_ENTRY(device_config) next;
4596 };
4597 QTAILQ_HEAD(, device_config) device_configs = QTAILQ_HEAD_INITIALIZER(device_configs);
4598
4599 static void add_device_config(int type, const char *cmdline)
4600 {
4601     struct device_config *conf;
4602
4603     conf = qemu_mallocz(sizeof(*conf));
4604     conf->type = type;
4605     conf->cmdline = cmdline;
4606     QTAILQ_INSERT_TAIL(&device_configs, conf, next);
4607 }
4608
4609 static int foreach_device_config(int type, int (*func)(const char *cmdline))
4610 {
4611     struct device_config *conf;
4612     int rc;
4613
4614     QTAILQ_FOREACH(conf, &device_configs, next) {
4615         if (conf->type != type)
4616             continue;
4617         rc = func(conf->cmdline);
4618         if (0 != rc)
4619             return rc;
4620     }
4621     return 0;
4622 }
4623
4624 int main(int argc, char **argv, char **envp)
4625 {
4626     const char *gdbstub_dev = NULL;
4627     uint32_t boot_devices_bitmap = 0;
4628     int i;
4629     int snapshot, linux_boot, net_boot;
4630     const char *initrd_filename;
4631     const char *kernel_filename, *kernel_cmdline;
4632     char boot_devices[33] = "cad"; /* default to HD->floppy->CD-ROM */
4633     DisplayState *ds;
4634     DisplayChangeListener *dcl;
4635     int cyls, heads, secs, translation;
4636     QemuOpts *hda_opts = NULL, *opts;
4637     int optind;
4638     const char *r, *optarg;
4639     CharDriverState *monitor_hds[MAX_MONITOR_DEVICES];
4640     const char *monitor_devices[MAX_MONITOR_DEVICES];
4641     int monitor_flags[MAX_MONITOR_DEVICES];
4642     int monitor_device_index;
4643     const char *serial_devices[MAX_SERIAL_PORTS];
4644     int serial_device_index;
4645     const char *parallel_devices[MAX_PARALLEL_PORTS];
4646     int parallel_device_index;
4647     const char *virtio_consoles[MAX_VIRTIO_CONSOLES];
4648     int virtio_console_index;
4649     const char *loadvm = NULL;
4650     QEMUMachine *machine;
4651     const char *cpu_model;
4652 #ifndef _WIN32
4653     int fds[2];
4654 #endif
4655     int tb_size;
4656     const char *pid_file = NULL;
4657     const char *incoming = NULL;
4658 #ifndef _WIN32
4659     int fd = 0;
4660     struct passwd *pwd = NULL;
4661     const char *chroot_dir = NULL;
4662     const char *run_as = NULL;
4663 #endif
4664     CPUState *env;
4665     int show_vnc_port = 0;
4666
4667     init_clocks();
4668
4669     qemu_errors_to_file(stderr);
4670     qemu_cache_utils_init(envp);
4671
4672     QLIST_INIT (&vm_change_state_head);
4673 #ifndef _WIN32
4674     {
4675         struct sigaction act;
4676         sigfillset(&act.sa_mask);
4677         act.sa_flags = 0;
4678         act.sa_handler = SIG_IGN;
4679         sigaction(SIGPIPE, &act, NULL);
4680     }
4681 #else
4682     SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE);
4683     /* Note: cpu_interrupt() is currently not SMP safe, so we force
4684        QEMU to run on a single CPU */
4685     {
4686         HANDLE h;
4687         DWORD mask, smask;
4688         int i;
4689         h = GetCurrentProcess();
4690         if (GetProcessAffinityMask(h, &mask, &smask)) {
4691             for(i = 0; i < 32; i++) {
4692                 if (mask & (1 << i))
4693                     break;
4694             }
4695             if (i != 32) {
4696                 mask = 1 << i;
4697                 SetProcessAffinityMask(h, mask);
4698             }
4699         }
4700     }
4701 #endif
4702
4703     module_call_init(MODULE_INIT_MACHINE);
4704     machine = find_default_machine();
4705     cpu_model = NULL;
4706     initrd_filename = NULL;
4707     ram_size = 0;
4708     snapshot = 0;
4709     kernel_filename = NULL;
4710     kernel_cmdline = "";
4711     cyls = heads = secs = 0;
4712     translation = BIOS_ATA_TRANSLATION_AUTO;
4713
4714     serial_devices[0] = "vc:80Cx24C";
4715     for(i = 1; i < MAX_SERIAL_PORTS; i++)
4716         serial_devices[i] = NULL;
4717     serial_device_index = 0;
4718
4719     parallel_devices[0] = "vc:80Cx24C";
4720     for(i = 1; i < MAX_PARALLEL_PORTS; i++)
4721         parallel_devices[i] = NULL;
4722     parallel_device_index = 0;
4723
4724     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++)
4725         virtio_consoles[i] = NULL;
4726     virtio_console_index = 0;
4727
4728     monitor_devices[0] = "vc:80Cx24C";
4729     monitor_flags[0] = MONITOR_IS_DEFAULT | MONITOR_USE_READLINE;
4730     for (i = 1; i < MAX_MONITOR_DEVICES; i++) {
4731         monitor_devices[i] = NULL;
4732         monitor_flags[i] = MONITOR_USE_READLINE;
4733     }
4734     monitor_device_index = 0;
4735
4736     for (i = 0; i < MAX_NODES; i++) {
4737         node_mem[i] = 0;
4738         node_cpumask[i] = 0;
4739     }
4740
4741     nb_numa_nodes = 0;
4742     nb_nics = 0;
4743
4744     tb_size = 0;
4745     autostart= 1;
4746
4747     optind = 1;
4748     for(;;) {
4749         if (optind >= argc)
4750             break;
4751         r = argv[optind];
4752         if (r[0] != '-') {
4753             hda_opts = drive_add(argv[optind++], HD_ALIAS, 0);
4754         } else {
4755             const QEMUOption *popt;
4756
4757             optind++;
4758             /* Treat --foo the same as -foo.  */
4759             if (r[1] == '-')
4760                 r++;
4761             popt = qemu_options;
4762             for(;;) {
4763                 if (!popt->name) {
4764                     fprintf(stderr, "%s: invalid option -- '%s'\n",
4765                             argv[0], r);
4766                     exit(1);
4767                 }
4768                 if (!strcmp(popt->name, r + 1))
4769                     break;
4770                 popt++;
4771             }
4772             if (popt->flags & HAS_ARG) {
4773                 if (optind >= argc) {
4774                     fprintf(stderr, "%s: option '%s' requires an argument\n",
4775                             argv[0], r);
4776                     exit(1);
4777                 }
4778                 optarg = argv[optind++];
4779             } else {
4780                 optarg = NULL;
4781             }
4782
4783             switch(popt->index) {
4784             case QEMU_OPTION_M:
4785                 machine = find_machine(optarg);
4786                 if (!machine) {
4787                     QEMUMachine *m;
4788                     printf("Supported machines are:\n");
4789                     for(m = first_machine; m != NULL; m = m->next) {
4790                         if (m->alias)
4791                             printf("%-10s %s (alias of %s)\n",
4792                                    m->alias, m->desc, m->name);
4793                         printf("%-10s %s%s\n",
4794                                m->name, m->desc,
4795                                m->is_default ? " (default)" : "");
4796                     }
4797                     exit(*optarg != '?');
4798                 }
4799                 break;
4800             case QEMU_OPTION_cpu:
4801                 /* hw initialization will check this */
4802                 if (*optarg == '?') {
4803 /* XXX: implement xxx_cpu_list for targets that still miss it */
4804 #if defined(cpu_list)
4805                     cpu_list(stdout, &fprintf);
4806 #endif
4807                     exit(0);
4808                 } else {
4809                     cpu_model = optarg;
4810                 }
4811                 break;
4812             case QEMU_OPTION_initrd:
4813                 initrd_filename = optarg;
4814                 break;
4815             case QEMU_OPTION_hda:
4816                 if (cyls == 0)
4817                     hda_opts = drive_add(optarg, HD_ALIAS, 0);
4818                 else
4819                     hda_opts = drive_add(optarg, HD_ALIAS
4820                              ",cyls=%d,heads=%d,secs=%d%s",
4821                              0, cyls, heads, secs,
4822                              translation == BIOS_ATA_TRANSLATION_LBA ?
4823                                  ",trans=lba" :
4824                              translation == BIOS_ATA_TRANSLATION_NONE ?
4825                                  ",trans=none" : "");
4826                  break;
4827             case QEMU_OPTION_hdb:
4828             case QEMU_OPTION_hdc:
4829             case QEMU_OPTION_hdd:
4830                 drive_add(optarg, HD_ALIAS, popt->index - QEMU_OPTION_hda);
4831                 break;
4832             case QEMU_OPTION_drive:
4833                 drive_add(NULL, "%s", optarg);
4834                 break;
4835             case QEMU_OPTION_set:
4836                 if (qemu_set_option(optarg) != 0)
4837                     exit(1);
4838                 break;
4839             case QEMU_OPTION_mtdblock:
4840                 drive_add(optarg, MTD_ALIAS);
4841                 break;
4842             case QEMU_OPTION_sd:
4843                 drive_add(optarg, SD_ALIAS);
4844                 break;
4845             case QEMU_OPTION_pflash:
4846                 drive_add(optarg, PFLASH_ALIAS);
4847                 break;
4848             case QEMU_OPTION_snapshot:
4849                 snapshot = 1;
4850                 break;
4851             case QEMU_OPTION_hdachs:
4852                 {
4853                     const char *p;
4854                     p = optarg;
4855                     cyls = strtol(p, (char **)&p, 0);
4856                     if (cyls < 1 || cyls > 16383)
4857                         goto chs_fail;
4858                     if (*p != ',')
4859                         goto chs_fail;
4860                     p++;
4861                     heads = strtol(p, (char **)&p, 0);
4862                     if (heads < 1 || heads > 16)
4863                         goto chs_fail;
4864                     if (*p != ',')
4865                         goto chs_fail;
4866                     p++;
4867                     secs = strtol(p, (char **)&p, 0);
4868                     if (secs < 1 || secs > 63)
4869                         goto chs_fail;
4870                     if (*p == ',') {
4871                         p++;
4872                         if (!strcmp(p, "none"))
4873                             translation = BIOS_ATA_TRANSLATION_NONE;
4874                         else if (!strcmp(p, "lba"))
4875                             translation = BIOS_ATA_TRANSLATION_LBA;
4876                         else if (!strcmp(p, "auto"))
4877                             translation = BIOS_ATA_TRANSLATION_AUTO;
4878                         else
4879                             goto chs_fail;
4880                     } else if (*p != '\0') {
4881                     chs_fail:
4882                         fprintf(stderr, "qemu: invalid physical CHS format\n");
4883                         exit(1);
4884                     }
4885                     if (hda_opts != NULL) {
4886                         char num[16];
4887                         snprintf(num, sizeof(num), "%d", cyls);
4888                         qemu_opt_set(hda_opts, "cyls", num);
4889                         snprintf(num, sizeof(num), "%d", heads);
4890                         qemu_opt_set(hda_opts, "heads", num);
4891                         snprintf(num, sizeof(num), "%d", secs);
4892                         qemu_opt_set(hda_opts, "secs", num);
4893                         if (translation == BIOS_ATA_TRANSLATION_LBA)
4894                             qemu_opt_set(hda_opts, "trans", "lba");
4895                         if (translation == BIOS_ATA_TRANSLATION_NONE)
4896                             qemu_opt_set(hda_opts, "trans", "none");
4897                     }
4898                 }
4899                 break;
4900             case QEMU_OPTION_numa:
4901                 if (nb_numa_nodes >= MAX_NODES) {
4902                     fprintf(stderr, "qemu: too many NUMA nodes\n");
4903                     exit(1);
4904                 }
4905                 numa_add(optarg);
4906                 break;
4907             case QEMU_OPTION_nographic:
4908                 display_type = DT_NOGRAPHIC;
4909                 break;
4910 #ifdef CONFIG_CURSES
4911             case QEMU_OPTION_curses:
4912                 display_type = DT_CURSES;
4913                 break;
4914 #endif
4915             case QEMU_OPTION_portrait:
4916                 graphic_rotate = 1;
4917                 break;
4918             case QEMU_OPTION_kernel:
4919                 kernel_filename = optarg;
4920                 break;
4921             case QEMU_OPTION_append:
4922                 kernel_cmdline = optarg;
4923                 break;
4924             case QEMU_OPTION_cdrom:
4925                 drive_add(optarg, CDROM_ALIAS);
4926                 break;
4927             case QEMU_OPTION_boot:
4928                 {
4929                     static const char * const params[] = {
4930                         "order", "once", "menu", NULL
4931                     };
4932                     char buf[sizeof(boot_devices)];
4933                     char *standard_boot_devices;
4934                     int legacy = 0;
4935
4936                     if (!strchr(optarg, '=')) {
4937                         legacy = 1;
4938                         pstrcpy(buf, sizeof(buf), optarg);
4939                     } else if (check_params(buf, sizeof(buf), params, optarg) < 0) {
4940                         fprintf(stderr,
4941                                 "qemu: unknown boot parameter '%s' in '%s'\n",
4942                                 buf, optarg);
4943                         exit(1);
4944                     }
4945
4946                     if (legacy ||
4947                         get_param_value(buf, sizeof(buf), "order", optarg)) {
4948                         boot_devices_bitmap = parse_bootdevices(buf);
4949                         pstrcpy(boot_devices, sizeof(boot_devices), buf);
4950                     }
4951                     if (!legacy) {
4952                         if (get_param_value(buf, sizeof(buf),
4953                                             "once", optarg)) {
4954                             boot_devices_bitmap |= parse_bootdevices(buf);
4955                             standard_boot_devices = qemu_strdup(boot_devices);
4956                             pstrcpy(boot_devices, sizeof(boot_devices), buf);
4957                             qemu_register_reset(restore_boot_devices,
4958                                                 standard_boot_devices);
4959                         }
4960                         if (get_param_value(buf, sizeof(buf),
4961                                             "menu", optarg)) {
4962                             if (!strcmp(buf, "on")) {
4963                                 boot_menu = 1;
4964                             } else if (!strcmp(buf, "off")) {
4965                                 boot_menu = 0;
4966                             } else {
4967                                 fprintf(stderr,
4968                                         "qemu: invalid option value '%s'\n",
4969                                         buf);
4970                                 exit(1);
4971                             }
4972                         }
4973                     }
4974                 }
4975                 break;
4976             case QEMU_OPTION_fda:
4977             case QEMU_OPTION_fdb:
4978                 drive_add(optarg, FD_ALIAS, popt->index - QEMU_OPTION_fda);
4979                 break;
4980 #ifdef TARGET_I386
4981             case QEMU_OPTION_no_fd_bootchk:
4982                 fd_bootchk = 0;
4983                 break;
4984 #endif
4985             case QEMU_OPTION_netdev:
4986                 if (net_client_parse(&qemu_netdev_opts, optarg) == -1) {
4987                     exit(1);
4988                 }
4989                 break;
4990             case QEMU_OPTION_net:
4991                 if (net_client_parse(&qemu_net_opts, optarg) == -1) {
4992                     exit(1);
4993                 }
4994                 break;
4995 #ifdef CONFIG_SLIRP
4996             case QEMU_OPTION_tftp:
4997                 legacy_tftp_prefix = optarg;
4998                 break;
4999             case QEMU_OPTION_bootp:
5000                 legacy_bootp_filename = optarg;
5001                 break;
5002 #ifndef _WIN32
5003             case QEMU_OPTION_smb:
5004                 if (net_slirp_smb(optarg) < 0)
5005                     exit(1);
5006                 break;
5007 #endif
5008             case QEMU_OPTION_redir:
5009                 if (net_slirp_redir(optarg) < 0)
5010                     exit(1);
5011                 break;
5012 #endif
5013             case QEMU_OPTION_bt:
5014                 add_device_config(DEV_BT, optarg);
5015                 break;
5016 #ifdef HAS_AUDIO
5017             case QEMU_OPTION_audio_help:
5018                 AUD_help ();
5019                 exit (0);
5020                 break;
5021             case QEMU_OPTION_soundhw:
5022                 select_soundhw (optarg);
5023                 break;
5024 #endif
5025             case QEMU_OPTION_h:
5026                 help(0);
5027                 break;
5028             case QEMU_OPTION_version:
5029                 version();
5030                 exit(0);
5031                 break;
5032             case QEMU_OPTION_m: {
5033                 uint64_t value;
5034                 char *ptr;
5035
5036                 value = strtoul(optarg, &ptr, 10);
5037                 switch (*ptr) {
5038                 case 0: case 'M': case 'm':
5039                     value <<= 20;
5040                     break;
5041                 case 'G': case 'g':
5042                     value <<= 30;
5043                     break;
5044                 default:
5045                     fprintf(stderr, "qemu: invalid ram size: %s\n", optarg);
5046                     exit(1);
5047                 }
5048
5049                 /* On 32-bit hosts, QEMU is limited by virtual address space */
5050                 if (value > (2047 << 20) && HOST_LONG_BITS == 32) {
5051                     fprintf(stderr, "qemu: at most 2047 MB RAM can be simulated\n");
5052                     exit(1);
5053                 }
5054                 if (value != (uint64_t)(ram_addr_t)value) {
5055                     fprintf(stderr, "qemu: ram size too large\n");
5056                     exit(1);
5057                 }
5058                 ram_size = value;
5059                 break;
5060             }
5061             case QEMU_OPTION_d:
5062                 {
5063                     int mask;
5064                     const CPULogItem *item;
5065
5066                     mask = cpu_str_to_log_mask(optarg);
5067                     if (!mask) {
5068                         printf("Log items (comma separated):\n");
5069                     for(item = cpu_log_items; item->mask != 0; item++) {
5070                         printf("%-10s %s\n", item->name, item->help);
5071                     }
5072                     exit(1);
5073                     }
5074                     cpu_set_log(mask);
5075                 }
5076                 break;
5077             case QEMU_OPTION_s:
5078                 gdbstub_dev = "tcp::" DEFAULT_GDBSTUB_PORT;
5079                 break;
5080             case QEMU_OPTION_gdb:
5081                 gdbstub_dev = optarg;
5082                 break;
5083             case QEMU_OPTION_L:
5084                 data_dir = optarg;
5085                 break;
5086             case QEMU_OPTION_bios:
5087                 bios_name = optarg;
5088                 break;
5089             case QEMU_OPTION_singlestep:
5090                 singlestep = 1;
5091                 break;
5092             case QEMU_OPTION_S:
5093                 autostart = 0;
5094                 break;
5095             case QEMU_OPTION_k:
5096                 keyboard_layout = optarg;
5097                 break;
5098             case QEMU_OPTION_localtime:
5099                 rtc_utc = 0;
5100                 break;
5101             case QEMU_OPTION_vga:
5102                 select_vgahw (optarg);
5103                 break;
5104 #if defined(TARGET_PPC) || defined(TARGET_SPARC)
5105             case QEMU_OPTION_g:
5106                 {
5107                     const char *p;
5108                     int w, h, depth;
5109                     p = optarg;
5110                     w = strtol(p, (char **)&p, 10);
5111                     if (w <= 0) {
5112                     graphic_error:
5113                         fprintf(stderr, "qemu: invalid resolution or depth\n");
5114                         exit(1);
5115                     }
5116                     if (*p != 'x')
5117                         goto graphic_error;
5118                     p++;
5119                     h = strtol(p, (char **)&p, 10);
5120                     if (h <= 0)
5121                         goto graphic_error;
5122                     if (*p == 'x') {
5123                         p++;
5124                         depth = strtol(p, (char **)&p, 10);
5125                         if (depth != 8 && depth != 15 && depth != 16 &&
5126                             depth != 24 && depth != 32)
5127                             goto graphic_error;
5128                     } else if (*p == '\0') {
5129                         depth = graphic_depth;
5130                     } else {
5131                         goto graphic_error;
5132                     }
5133
5134                     graphic_width = w;
5135                     graphic_height = h;
5136                     graphic_depth = depth;
5137                 }
5138                 break;
5139 #endif
5140             case QEMU_OPTION_echr:
5141                 {
5142                     char *r;
5143                     term_escape_char = strtol(optarg, &r, 0);
5144                     if (r == optarg)
5145                         printf("Bad argument to echr\n");
5146                     break;
5147                 }
5148             case QEMU_OPTION_monitor:
5149                 if (monitor_device_index >= MAX_MONITOR_DEVICES) {
5150                     fprintf(stderr, "qemu: too many monitor devices\n");
5151                     exit(1);
5152                 }
5153                 monitor_devices[monitor_device_index] =
5154                                 monitor_cmdline_parse(optarg,
5155                                         &monitor_flags[monitor_device_index]);
5156                 monitor_device_index++;
5157                 break;
5158             case QEMU_OPTION_chardev:
5159                 opts = qemu_opts_parse(&qemu_chardev_opts, optarg, "backend");
5160                 if (!opts) {
5161                     fprintf(stderr, "parse error: %s\n", optarg);
5162                     exit(1);
5163                 }
5164                 if (qemu_chr_open_opts(opts, NULL) == NULL) {
5165                     exit(1);
5166                 }
5167                 break;
5168             case QEMU_OPTION_serial:
5169                 if (serial_device_index >= MAX_SERIAL_PORTS) {
5170                     fprintf(stderr, "qemu: too many serial ports\n");
5171                     exit(1);
5172                 }
5173                 serial_devices[serial_device_index] = optarg;
5174                 serial_device_index++;
5175                 break;
5176             case QEMU_OPTION_watchdog:
5177                 if (watchdog) {
5178                     fprintf(stderr,
5179                             "qemu: only one watchdog option may be given\n");
5180                     return 1;
5181                 }
5182                 watchdog = optarg;
5183                 break;
5184             case QEMU_OPTION_watchdog_action:
5185                 if (select_watchdog_action(optarg) == -1) {
5186                     fprintf(stderr, "Unknown -watchdog-action parameter\n");
5187                     exit(1);
5188                 }
5189                 break;
5190             case QEMU_OPTION_virtiocon:
5191                 if (virtio_console_index >= MAX_VIRTIO_CONSOLES) {
5192                     fprintf(stderr, "qemu: too many virtio consoles\n");
5193                     exit(1);
5194                 }
5195                 virtio_consoles[virtio_console_index] = optarg;
5196                 virtio_console_index++;
5197                 break;
5198             case QEMU_OPTION_parallel:
5199                 if (parallel_device_index >= MAX_PARALLEL_PORTS) {
5200                     fprintf(stderr, "qemu: too many parallel ports\n");
5201                     exit(1);
5202                 }
5203                 parallel_devices[parallel_device_index] = optarg;
5204                 parallel_device_index++;
5205                 break;
5206             case QEMU_OPTION_loadvm:
5207                 loadvm = optarg;
5208                 break;
5209             case QEMU_OPTION_full_screen:
5210                 full_screen = 1;
5211                 break;
5212 #ifdef CONFIG_SDL
5213             case QEMU_OPTION_no_frame:
5214                 no_frame = 1;
5215                 break;
5216             case QEMU_OPTION_alt_grab:
5217                 alt_grab = 1;
5218                 break;
5219             case QEMU_OPTION_ctrl_grab:
5220                 ctrl_grab = 1;
5221                 break;
5222             case QEMU_OPTION_no_quit:
5223                 no_quit = 1;
5224                 break;
5225             case QEMU_OPTION_sdl:
5226                 display_type = DT_SDL;
5227                 break;
5228 #endif
5229             case QEMU_OPTION_pidfile:
5230                 pid_file = optarg;
5231                 break;
5232 #ifdef TARGET_I386
5233             case QEMU_OPTION_win2k_hack:
5234                 win2k_install_hack = 1;
5235                 break;
5236             case QEMU_OPTION_rtc_td_hack:
5237                 rtc_td_hack = 1;
5238                 break;
5239             case QEMU_OPTION_acpitable:
5240                 if(acpi_table_add(optarg) < 0) {
5241                     fprintf(stderr, "Wrong acpi table provided\n");
5242                     exit(1);
5243                 }
5244                 break;
5245             case QEMU_OPTION_smbios:
5246                 if(smbios_entry_add(optarg) < 0) {
5247                     fprintf(stderr, "Wrong smbios provided\n");
5248                     exit(1);
5249                 }
5250                 break;
5251 #endif
5252 #ifdef CONFIG_KVM
5253             case QEMU_OPTION_enable_kvm:
5254                 kvm_allowed = 1;
5255                 break;
5256 #endif
5257             case QEMU_OPTION_usb:
5258                 usb_enabled = 1;
5259                 break;
5260             case QEMU_OPTION_usbdevice:
5261                 usb_enabled = 1;
5262                 add_device_config(DEV_USB, optarg);
5263                 break;
5264             case QEMU_OPTION_device:
5265                 if (!qemu_opts_parse(&qemu_device_opts, optarg, "driver")) {
5266                     exit(1);
5267                 }
5268                 break;
5269             case QEMU_OPTION_smp:
5270                 smp_parse(optarg);
5271                 if (smp_cpus < 1) {
5272                     fprintf(stderr, "Invalid number of CPUs\n");
5273                     exit(1);
5274                 }
5275                 if (max_cpus < smp_cpus) {
5276                     fprintf(stderr, "maxcpus must be equal to or greater than "
5277                             "smp\n");
5278                     exit(1);
5279                 }
5280                 if (max_cpus > 255) {
5281                     fprintf(stderr, "Unsupported number of maxcpus\n");
5282                     exit(1);
5283                 }
5284                 break;
5285             case QEMU_OPTION_vnc:
5286                 display_type = DT_VNC;
5287                 vnc_display = optarg;
5288                 break;
5289 #ifdef TARGET_I386
5290             case QEMU_OPTION_no_acpi:
5291                 acpi_enabled = 0;
5292                 break;
5293             case QEMU_OPTION_no_hpet:
5294                 no_hpet = 1;
5295                 break;
5296             case QEMU_OPTION_balloon:
5297                 if (balloon_parse(optarg) < 0) {
5298                     fprintf(stderr, "Unknown -balloon argument %s\n", optarg);
5299                     exit(1);
5300                 }
5301                 break;
5302 #endif
5303             case QEMU_OPTION_no_reboot:
5304                 no_reboot = 1;
5305                 break;
5306             case QEMU_OPTION_no_shutdown:
5307                 no_shutdown = 1;
5308                 break;
5309             case QEMU_OPTION_show_cursor:
5310                 cursor_hide = 0;
5311                 break;
5312             case QEMU_OPTION_uuid:
5313                 if(qemu_uuid_parse(optarg, qemu_uuid) < 0) {
5314                     fprintf(stderr, "Fail to parse UUID string."
5315                             " Wrong format.\n");
5316                     exit(1);
5317                 }
5318                 break;
5319 #ifndef _WIN32
5320             case QEMU_OPTION_daemonize:
5321                 daemonize = 1;
5322                 break;
5323 #endif
5324             case QEMU_OPTION_option_rom:
5325                 if (nb_option_roms >= MAX_OPTION_ROMS) {
5326                     fprintf(stderr, "Too many option ROMs\n");
5327                     exit(1);
5328                 }
5329                 option_rom[nb_option_roms] = optarg;
5330                 nb_option_roms++;
5331                 break;
5332 #if defined(TARGET_ARM) || defined(TARGET_M68K)
5333             case QEMU_OPTION_semihosting:
5334                 semihosting_enabled = 1;
5335                 break;
5336 #endif
5337             case QEMU_OPTION_name:
5338                 qemu_name = qemu_strdup(optarg);
5339                  {
5340                      char *p = strchr(qemu_name, ',');
5341                      if (p != NULL) {
5342                         *p++ = 0;
5343                         if (strncmp(p, "process=", 8)) {
5344                             fprintf(stderr, "Unknown subargument %s to -name", p);
5345                             exit(1);
5346                         }
5347                         p += 8;
5348                         set_proc_name(p);
5349                      }
5350                  }
5351                 break;
5352 #if defined(TARGET_SPARC) || defined(TARGET_PPC)
5353             case QEMU_OPTION_prom_env:
5354                 if (nb_prom_envs >= MAX_PROM_ENVS) {
5355                     fprintf(stderr, "Too many prom variables\n");
5356                     exit(1);
5357                 }
5358                 prom_envs[nb_prom_envs] = optarg;
5359                 nb_prom_envs++;
5360                 break;
5361 #endif
5362 #ifdef TARGET_ARM
5363             case QEMU_OPTION_old_param:
5364                 old_param = 1;
5365                 break;
5366 #endif
5367             case QEMU_OPTION_clock:
5368                 configure_alarms(optarg);
5369                 break;
5370             case QEMU_OPTION_startdate:
5371                 configure_rtc_date_offset(optarg, 1);
5372                 break;
5373             case QEMU_OPTION_rtc:
5374                 opts = qemu_opts_parse(&qemu_rtc_opts, optarg, NULL);
5375                 if (!opts) {
5376                     fprintf(stderr, "parse error: %s\n", optarg);
5377                     exit(1);
5378                 }
5379                 configure_rtc(opts);
5380                 break;
5381             case QEMU_OPTION_tb_size:
5382                 tb_size = strtol(optarg, NULL, 0);
5383                 if (tb_size < 0)
5384                     tb_size = 0;
5385                 break;
5386             case QEMU_OPTION_icount:
5387                 use_icount = 1;
5388                 if (strcmp(optarg, "auto") == 0) {
5389                     icount_time_shift = -1;
5390                 } else {
5391                     icount_time_shift = strtol(optarg, NULL, 0);
5392                 }
5393                 break;
5394             case QEMU_OPTION_incoming:
5395                 incoming = optarg;
5396                 break;
5397 #ifndef _WIN32
5398             case QEMU_OPTION_chroot:
5399                 chroot_dir = optarg;
5400                 break;
5401             case QEMU_OPTION_runas:
5402                 run_as = optarg;
5403                 break;
5404 #endif
5405 #ifdef CONFIG_XEN
5406             case QEMU_OPTION_xen_domid:
5407                 xen_domid = atoi(optarg);
5408                 break;
5409             case QEMU_OPTION_xen_create:
5410                 xen_mode = XEN_CREATE;
5411                 break;
5412             case QEMU_OPTION_xen_attach:
5413                 xen_mode = XEN_ATTACH;
5414                 break;
5415 #endif
5416             case QEMU_OPTION_readconfig:
5417                 {
5418                     FILE *fp;
5419                     fp = fopen(optarg, "r");
5420                     if (fp == NULL) {
5421                         fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5422                         exit(1);
5423                     }
5424                     if (qemu_config_parse(fp) != 0) {
5425                         exit(1);
5426                     }
5427                     fclose(fp);
5428                     break;
5429                 }
5430             case QEMU_OPTION_writeconfig:
5431                 {
5432                     FILE *fp;
5433                     if (strcmp(optarg, "-") == 0) {
5434                         fp = stdout;
5435                     } else {
5436                         fp = fopen(optarg, "w");
5437                         if (fp == NULL) {
5438                             fprintf(stderr, "open %s: %s\n", optarg, strerror(errno));
5439                             exit(1);
5440                         }
5441                     }
5442                     qemu_config_write(fp);
5443                     fclose(fp);
5444                     break;
5445                 }
5446             }
5447         }
5448     }
5449
5450     /* If no data_dir is specified then try to find it relative to the
5451        executable path.  */
5452     if (!data_dir) {
5453         data_dir = find_datadir(argv[0]);
5454     }
5455     /* If all else fails use the install patch specified when building.  */
5456     if (!data_dir) {
5457         data_dir = CONFIG_QEMU_SHAREDIR;
5458     }
5459
5460     /*
5461      * Default to max_cpus = smp_cpus, in case the user doesn't
5462      * specify a max_cpus value.
5463      */
5464     if (!max_cpus)
5465         max_cpus = smp_cpus;
5466
5467     machine->max_cpus = machine->max_cpus ?: 1; /* Default to UP */
5468     if (smp_cpus > machine->max_cpus) {
5469         fprintf(stderr, "Number of SMP cpus requested (%d), exceeds max cpus "
5470                 "supported by machine `%s' (%d)\n", smp_cpus,  machine->name,
5471                 machine->max_cpus);
5472         exit(1);
5473     }
5474
5475     if (display_type == DT_NOGRAPHIC) {
5476        if (serial_device_index == 0)
5477            serial_devices[0] = "stdio";
5478        if (parallel_device_index == 0)
5479            parallel_devices[0] = "null";
5480        if (strncmp(monitor_devices[0], "vc", 2) == 0) {
5481            monitor_devices[0] = "stdio";
5482        }
5483     }
5484
5485 #ifndef _WIN32
5486     if (daemonize) {
5487         pid_t pid;
5488
5489         if (pipe(fds) == -1)
5490             exit(1);
5491
5492         pid = fork();
5493         if (pid > 0) {
5494             uint8_t status;
5495             ssize_t len;
5496
5497             close(fds[1]);
5498
5499         again:
5500             len = read(fds[0], &status, 1);
5501             if (len == -1 && (errno == EINTR))
5502                 goto again;
5503
5504             if (len != 1)
5505                 exit(1);
5506             else if (status == 1) {
5507                 fprintf(stderr, "Could not acquire pidfile: %s\n", strerror(errno));
5508                 exit(1);
5509             } else
5510                 exit(0);
5511         } else if (pid < 0)
5512             exit(1);
5513
5514         close(fds[0]);
5515         qemu_set_cloexec(fds[1]);
5516
5517         setsid();
5518
5519         pid = fork();
5520         if (pid > 0)
5521             exit(0);
5522         else if (pid < 0)
5523             exit(1);
5524
5525         umask(027);
5526
5527         signal(SIGTSTP, SIG_IGN);
5528         signal(SIGTTOU, SIG_IGN);
5529         signal(SIGTTIN, SIG_IGN);
5530     }
5531
5532     if (pid_file && qemu_create_pidfile(pid_file) != 0) {
5533         if (daemonize) {
5534             uint8_t status = 1;
5535             write(fds[1], &status, 1);
5536         } else
5537             fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno));
5538         exit(1);
5539     }
5540 #endif
5541
5542     if (kvm_enabled()) {
5543         int ret;
5544
5545         ret = kvm_init(smp_cpus);
5546         if (ret < 0) {
5547             fprintf(stderr, "failed to initialize KVM\n");
5548             exit(1);
5549         }
5550     }
5551
5552     if (qemu_init_main_loop()) {
5553         fprintf(stderr, "qemu_init_main_loop failed\n");
5554         exit(1);
5555     }
5556     linux_boot = (kernel_filename != NULL);
5557
5558     if (!linux_boot && *kernel_cmdline != '\0') {
5559         fprintf(stderr, "-append only allowed with -kernel option\n");
5560         exit(1);
5561     }
5562
5563     if (!linux_boot && initrd_filename != NULL) {
5564         fprintf(stderr, "-initrd only allowed with -kernel option\n");
5565         exit(1);
5566     }
5567
5568 #ifndef _WIN32
5569     /* Win32 doesn't support line-buffering and requires size >= 2 */
5570     setvbuf(stdout, NULL, _IOLBF, 0);
5571 #endif
5572
5573     if (init_timer_alarm() < 0) {
5574         fprintf(stderr, "could not initialize alarm timer\n");
5575         exit(1);
5576     }
5577     if (use_icount && icount_time_shift < 0) {
5578         use_icount = 2;
5579         /* 125MIPS seems a reasonable initial guess at the guest speed.
5580            It will be corrected fairly quickly anyway.  */
5581         icount_time_shift = 3;
5582         init_icount_adjust();
5583     }
5584
5585 #ifdef _WIN32
5586     socket_init();
5587 #endif
5588
5589     if (net_init_clients() < 0) {
5590         exit(1);
5591     }
5592
5593     net_boot = (boot_devices_bitmap >> ('n' - 'a')) & 0xF;
5594     net_set_boot_mask(net_boot);
5595
5596     /* init the bluetooth world */
5597     if (foreach_device_config(DEV_BT, bt_parse))
5598         exit(1);
5599
5600     /* init the memory */
5601     if (ram_size == 0)
5602         ram_size = DEFAULT_RAM_SIZE * 1024 * 1024;
5603
5604     /* init the dynamic translator */
5605     cpu_exec_init_all(tb_size * 1024 * 1024);
5606
5607     bdrv_init_with_whitelist();
5608
5609     blk_mig_init();
5610
5611     /* we always create the cdrom drive, even if no disk is there */
5612     drive_add(NULL, CDROM_ALIAS);
5613
5614     /* we always create at least one floppy */
5615     drive_add(NULL, FD_ALIAS, 0);
5616
5617     /* we always create one sd slot, even if no card is in it */
5618     drive_add(NULL, SD_ALIAS);
5619
5620     /* open the virtual block devices */
5621     if (snapshot)
5622         qemu_opts_foreach(&qemu_drive_opts, drive_enable_snapshot, NULL, 0);
5623     if (qemu_opts_foreach(&qemu_drive_opts, drive_init_func, machine, 1) != 0)
5624         exit(1);
5625
5626     vmstate_register(0, &vmstate_timers ,&timers_state);
5627     register_savevm_live("ram", 0, 3, NULL, ram_save_live, NULL,
5628                          ram_load, NULL);
5629
5630     /* Maintain compatibility with multiple stdio monitors */
5631     if (!strcmp(monitor_devices[0],"stdio")) {
5632         for (i = 0; i < MAX_SERIAL_PORTS; i++) {
5633             const char *devname = serial_devices[i];
5634             if (devname && !strcmp(devname,"mon:stdio")) {
5635                 monitor_devices[0] = NULL;
5636                 break;
5637             } else if (devname && !strcmp(devname,"stdio")) {
5638                 monitor_devices[0] = NULL;
5639                 serial_devices[i] = "mon:stdio";
5640                 break;
5641             }
5642         }
5643     }
5644
5645     if (nb_numa_nodes > 0) {
5646         int i;
5647
5648         if (nb_numa_nodes > smp_cpus) {
5649             nb_numa_nodes = smp_cpus;
5650         }
5651
5652         /* If no memory size if given for any node, assume the default case
5653          * and distribute the available memory equally across all nodes
5654          */
5655         for (i = 0; i < nb_numa_nodes; i++) {
5656             if (node_mem[i] != 0)
5657                 break;
5658         }
5659         if (i == nb_numa_nodes) {
5660             uint64_t usedmem = 0;
5661
5662             /* On Linux, the each node's border has to be 8MB aligned,
5663              * the final node gets the rest.
5664              */
5665             for (i = 0; i < nb_numa_nodes - 1; i++) {
5666                 node_mem[i] = (ram_size / nb_numa_nodes) & ~((1 << 23UL) - 1);
5667                 usedmem += node_mem[i];
5668             }
5669             node_mem[i] = ram_size - usedmem;
5670         }
5671
5672         for (i = 0; i < nb_numa_nodes; i++) {
5673             if (node_cpumask[i] != 0)
5674                 break;
5675         }
5676         /* assigning the VCPUs round-robin is easier to implement, guest OSes
5677          * must cope with this anyway, because there are BIOSes out there in
5678          * real machines which also use this scheme.
5679          */
5680         if (i == nb_numa_nodes) {
5681             for (i = 0; i < smp_cpus; i++) {
5682                 node_cpumask[i % nb_numa_nodes] |= 1 << i;
5683             }
5684         }
5685     }
5686
5687     for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
5688         const char *devname = monitor_devices[i];
5689         if (devname && strcmp(devname, "none")) {
5690             char label[32];
5691             if (i == 0) {
5692                 snprintf(label, sizeof(label), "monitor");
5693             } else {
5694                 snprintf(label, sizeof(label), "monitor%d", i);
5695             }
5696             monitor_hds[i] = qemu_chr_open(label, devname, NULL);
5697             if (!monitor_hds[i]) {
5698                 fprintf(stderr, "qemu: could not open monitor device '%s'\n",
5699                         devname);
5700                 exit(1);
5701             }
5702         }
5703     }
5704
5705     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5706         const char *devname = serial_devices[i];
5707         if (devname && strcmp(devname, "none")) {
5708             char label[32];
5709             snprintf(label, sizeof(label), "serial%d", i);
5710             serial_hds[i] = qemu_chr_open(label, devname, NULL);
5711             if (!serial_hds[i]) {
5712                 fprintf(stderr, "qemu: could not open serial device '%s': %s\n",
5713                         devname, strerror(errno));
5714                 exit(1);
5715             }
5716         }
5717     }
5718
5719     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5720         const char *devname = parallel_devices[i];
5721         if (devname && strcmp(devname, "none")) {
5722             char label[32];
5723             snprintf(label, sizeof(label), "parallel%d", i);
5724             parallel_hds[i] = qemu_chr_open(label, devname, NULL);
5725             if (!parallel_hds[i]) {
5726                 fprintf(stderr, "qemu: could not open parallel device '%s': %s\n",
5727                         devname, strerror(errno));
5728                 exit(1);
5729             }
5730         }
5731     }
5732
5733     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5734         const char *devname = virtio_consoles[i];
5735         if (devname && strcmp(devname, "none")) {
5736             char label[32];
5737             snprintf(label, sizeof(label), "virtcon%d", i);
5738             virtcon_hds[i] = qemu_chr_open(label, devname, NULL);
5739             if (!virtcon_hds[i]) {
5740                 fprintf(stderr, "qemu: could not open virtio console '%s': %s\n",
5741                         devname, strerror(errno));
5742                 exit(1);
5743             }
5744         }
5745     }
5746
5747     module_call_init(MODULE_INIT_DEVICE);
5748
5749     if (watchdog) {
5750         i = select_watchdog(watchdog);
5751         if (i > 0)
5752             exit (i == 1 ? 1 : 0);
5753     }
5754
5755     if (machine->compat_props) {
5756         qdev_prop_register_compat(machine->compat_props);
5757     }
5758     machine->init(ram_size, boot_devices,
5759                   kernel_filename, kernel_cmdline, initrd_filename, cpu_model);
5760
5761
5762 #ifndef _WIN32
5763     /* must be after terminal init, SDL library changes signal handlers */
5764     sighandler_setup();
5765 #endif
5766
5767     for (env = first_cpu; env != NULL; env = env->next_cpu) {
5768         for (i = 0; i < nb_numa_nodes; i++) {
5769             if (node_cpumask[i] & (1 << env->cpu_index)) {
5770                 env->numa_node = i;
5771             }
5772         }
5773     }
5774
5775     current_machine = machine;
5776
5777     /* init USB devices */
5778     if (usb_enabled) {
5779         if (foreach_device_config(DEV_USB, usb_parse) < 0)
5780             exit(1);
5781     }
5782
5783     /* init generic devices */
5784     if (qemu_opts_foreach(&qemu_device_opts, device_init_func, NULL, 1) != 0)
5785         exit(1);
5786
5787     if (!display_state)
5788         dumb_display_init();
5789     /* just use the first displaystate for the moment */
5790     ds = display_state;
5791
5792     if (display_type == DT_DEFAULT) {
5793 #if defined(CONFIG_SDL) || defined(CONFIG_COCOA)
5794         display_type = DT_SDL;
5795 #else
5796         display_type = DT_VNC;
5797         vnc_display = "localhost:0,to=99";
5798         show_vnc_port = 1;
5799 #endif
5800     }
5801
5802
5803     switch (display_type) {
5804     case DT_NOGRAPHIC:
5805         break;
5806 #if defined(CONFIG_CURSES)
5807     case DT_CURSES:
5808         curses_display_init(ds, full_screen);
5809         break;
5810 #endif
5811 #if defined(CONFIG_SDL)
5812     case DT_SDL:
5813         sdl_display_init(ds, full_screen, no_frame);
5814         break;
5815 #elif defined(CONFIG_COCOA)
5816     case DT_SDL:
5817         cocoa_display_init(ds, full_screen);
5818         break;
5819 #endif
5820     case DT_VNC:
5821         vnc_display_init(ds);
5822         if (vnc_display_open(ds, vnc_display) < 0)
5823             exit(1);
5824
5825         if (show_vnc_port) {
5826             printf("VNC server running on `%s'\n", vnc_display_local_addr(ds));
5827         }
5828         break;
5829     default:
5830         break;
5831     }
5832     dpy_resize(ds);
5833
5834     dcl = ds->listeners;
5835     while (dcl != NULL) {
5836         if (dcl->dpy_refresh != NULL) {
5837             ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds);
5838             qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock));
5839         }
5840         dcl = dcl->next;
5841     }
5842
5843     if (display_type == DT_NOGRAPHIC || display_type == DT_VNC) {
5844         nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL);
5845         qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock));
5846     }
5847
5848     text_consoles_set_display(display_state);
5849
5850     for (i = 0; i < MAX_MONITOR_DEVICES; i++) {
5851         if (monitor_devices[i] && monitor_hds[i]) {
5852             monitor_init(monitor_hds[i], monitor_flags[i]);
5853         }
5854     }
5855
5856     for(i = 0; i < MAX_SERIAL_PORTS; i++) {
5857         const char *devname = serial_devices[i];
5858         if (devname && strcmp(devname, "none")) {
5859             if (strstart(devname, "vc", 0))
5860                 qemu_chr_printf(serial_hds[i], "serial%d console\r\n", i);
5861         }
5862     }
5863
5864     for(i = 0; i < MAX_PARALLEL_PORTS; i++) {
5865         const char *devname = parallel_devices[i];
5866         if (devname && strcmp(devname, "none")) {
5867             if (strstart(devname, "vc", 0))
5868                 qemu_chr_printf(parallel_hds[i], "parallel%d console\r\n", i);
5869         }
5870     }
5871
5872     for(i = 0; i < MAX_VIRTIO_CONSOLES; i++) {
5873         const char *devname = virtio_consoles[i];
5874         if (virtcon_hds[i] && devname) {
5875             if (strstart(devname, "vc", 0))
5876                 qemu_chr_printf(virtcon_hds[i], "virtio console%d\r\n", i);
5877         }
5878     }
5879
5880     if (gdbstub_dev && gdbserver_start(gdbstub_dev) < 0) {
5881         fprintf(stderr, "qemu: could not open gdbserver on device '%s'\n",
5882                 gdbstub_dev);
5883         exit(1);
5884     }
5885
5886     qdev_machine_creation_done();
5887
5888     rom_load_all();
5889
5890     qemu_system_reset();
5891     if (loadvm) {
5892         if (load_vmstate(cur_mon, loadvm) < 0) {
5893             autostart = 0;
5894         }
5895     }
5896
5897     if (incoming) {
5898         qemu_start_incoming_migration(incoming);
5899     } else if (autostart) {
5900         vm_start();
5901     }
5902
5903 #ifndef _WIN32
5904     if (daemonize) {
5905         uint8_t status = 0;
5906         ssize_t len;
5907
5908     again1:
5909         len = write(fds[1], &status, 1);
5910         if (len == -1 && (errno == EINTR))
5911             goto again1;
5912
5913         if (len != 1)
5914             exit(1);
5915
5916         chdir("/");
5917         TFR(fd = qemu_open("/dev/null", O_RDWR));
5918         if (fd == -1)
5919             exit(1);
5920     }
5921
5922     if (run_as) {
5923         pwd = getpwnam(run_as);
5924         if (!pwd) {
5925             fprintf(stderr, "User \"%s\" doesn't exist\n", run_as);
5926             exit(1);
5927         }
5928     }
5929
5930     if (chroot_dir) {
5931         if (chroot(chroot_dir) < 0) {
5932             fprintf(stderr, "chroot failed\n");
5933             exit(1);
5934         }
5935         chdir("/");
5936     }
5937
5938     if (run_as) {
5939         if (setgid(pwd->pw_gid) < 0) {
5940             fprintf(stderr, "Failed to setgid(%d)\n", pwd->pw_gid);
5941             exit(1);
5942         }
5943         if (setuid(pwd->pw_uid) < 0) {
5944             fprintf(stderr, "Failed to setuid(%d)\n", pwd->pw_uid);
5945             exit(1);
5946         }
5947         if (setuid(0) != -1) {
5948             fprintf(stderr, "Dropping privileges failed\n");
5949             exit(1);
5950         }
5951     }
5952
5953     if (daemonize) {
5954         dup2(fd, 0);
5955         dup2(fd, 1);
5956         dup2(fd, 2);
5957
5958         close(fd);
5959     }
5960 #endif
5961
5962     main_loop();
5963     quit_timers();
5964     net_cleanup();
5965
5966     return 0;
5967 }