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