vl.c

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